wonka - npm Package Compare versions
Comparing version 1.1.4 to 1.1.5
3292
dist/wonka.es.js
@@ -1,786 +0,408 @@ | ||
| function pipe(source) { | ||
| var args = arguments; | ||
| var len = args.length; | ||
| var x = source; | ||
| for (var i = 1; i < len; i++) { | ||
| x = args[i](x); | ||
| function pipe(r) { | ||
| var e = arguments; | ||
| var n = e.length; | ||
| var t = r; | ||
| for (var u = 1; u < n; u++) { | ||
| t = e[u](t); | ||
| } | ||
| return t; | ||
| } | ||
| return x; | ||
| function __(r, e) { | ||
| e.tag = r; | ||
| return e; | ||
| } | ||
| function __(tag, block) { | ||
| block.tag = tag; | ||
| return block; | ||
| function caml_array_sub(r, e, n) { | ||
| var t = new Array(n); | ||
| var u = 0; | ||
| var i = e; | ||
| while (u < n) { | ||
| t[u] = r[i]; | ||
| u = (u + 1) | 0; | ||
| i = (i + 1) | 0; | ||
| } | ||
| return t; | ||
| } | ||
| /* No side effect */ | ||
| var out_of_memory = /* tuple */[ | ||
| "Out_of_memory", | ||
| 0 | ||
| ]; | ||
| function app(r, e) { | ||
| while (1) { | ||
| var n = e; | ||
| var t = r; | ||
| var u = t.length; | ||
| var i = (u - n.length) | 0; | ||
| if (0 === i) { | ||
| return t.apply(null, n); | ||
| } else if (i < 0) { | ||
| e = caml_array_sub(n, u, 0 | -i); | ||
| r = t.apply(null, caml_array_sub(n, 0, u)); | ||
| continue; | ||
| } else { | ||
| return (function(r, e) { | ||
| return function(n) { | ||
| return app(r, e.concat([n])); | ||
| }; | ||
| })(t, n); | ||
| } | ||
| } | ||
| } | ||
| var sys_error = /* tuple */[ | ||
| "Sys_error", | ||
| -1 | ||
| ]; | ||
| function _1(r, e) { | ||
| var n = r.length; | ||
| if (1 === n) { | ||
| return r(e); | ||
| } else { | ||
| return (function curry_1(r, e, n) { | ||
| switch (n) { | ||
| case 1: | ||
| return r(e); | ||
| var failure = /* tuple */[ | ||
| "Failure", | ||
| -2 | ||
| ]; | ||
| case 2: | ||
| return function(n) { | ||
| return r(e, n); | ||
| }; | ||
| var invalid_argument = /* tuple */[ | ||
| "Invalid_argument", | ||
| -3 | ||
| ]; | ||
| case 3: | ||
| return function(n, t) { | ||
| return r(e, n, t); | ||
| }; | ||
| var end_of_file = /* tuple */[ | ||
| "End_of_file", | ||
| -4 | ||
| ]; | ||
| case 4: | ||
| return function(n, t, u) { | ||
| return r(e, n, t, u); | ||
| }; | ||
| var division_by_zero = /* tuple */[ | ||
| "Division_by_zero", | ||
| -5 | ||
| ]; | ||
| case 5: | ||
| return function(n, t, u, i) { | ||
| return r(e, n, t, u, i); | ||
| }; | ||
| var not_found = /* tuple */[ | ||
| "Not_found", | ||
| -6 | ||
| ]; | ||
| case 6: | ||
| return function(n, t, u, i, f) { | ||
| return r(e, n, t, u, i, f); | ||
| }; | ||
| var match_failure = /* tuple */[ | ||
| "Match_failure", | ||
| -7 | ||
| ]; | ||
| case 7: | ||
| return function(n, t, u, i, f, o) { | ||
| return r(e, n, t, u, i, f, o); | ||
| }; | ||
| var stack_overflow = /* tuple */[ | ||
| "Stack_overflow", | ||
| -8 | ||
| ]; | ||
| default: | ||
| return app(r, [e]); | ||
| } | ||
| })(r, e, n); | ||
| } | ||
| } | ||
| var sys_blocked_io = /* tuple */[ | ||
| "Sys_blocked_io", | ||
| -9 | ||
| ]; | ||
| function _2(r, e, n) { | ||
| var t = r.length; | ||
| if (2 === t) { | ||
| return r(e, n); | ||
| } else { | ||
| return (function curry_2(r, e, n, t) { | ||
| switch (t) { | ||
| case 1: | ||
| return app(r(e), [n]); | ||
| var assert_failure = /* tuple */[ | ||
| "Assert_failure", | ||
| -10 | ||
| ]; | ||
| case 2: | ||
| return r(e, n); | ||
| var undefined_recursive_module = /* tuple */[ | ||
| "Undefined_recursive_module", | ||
| -11 | ||
| ]; | ||
| case 3: | ||
| return function(t) { | ||
| return r(e, n, t); | ||
| }; | ||
| out_of_memory.tag = 248; | ||
| case 4: | ||
| return function(t, u) { | ||
| return r(e, n, t, u); | ||
| }; | ||
| sys_error.tag = 248; | ||
| case 5: | ||
| return function(t, u, i) { | ||
| return r(e, n, t, u, i); | ||
| }; | ||
| failure.tag = 248; | ||
| case 6: | ||
| return function(t, u, i, f) { | ||
| return r(e, n, t, u, i, f); | ||
| }; | ||
| invalid_argument.tag = 248; | ||
| case 7: | ||
| return function(t, u, i, f, o) { | ||
| return r(e, n, t, u, i, f, o); | ||
| }; | ||
| end_of_file.tag = 248; | ||
| default: | ||
| return app(r, [e, n]); | ||
| } | ||
| })(r, e, n, t); | ||
| } | ||
| } | ||
| division_by_zero.tag = 248; | ||
| function _3(r, e, n, t) { | ||
| var u = r.length; | ||
| if (3 === u) { | ||
| return r(e, n, t); | ||
| } else { | ||
| return (function curry_3(r, e, n, t, u) { | ||
| switch (u) { | ||
| case 1: | ||
| return app(r(e), [n, t]); | ||
| not_found.tag = 248; | ||
| case 2: | ||
| return app(r(e, n), [t]); | ||
| match_failure.tag = 248; | ||
| case 3: | ||
| return r(e, n, t); | ||
| stack_overflow.tag = 248; | ||
| case 4: | ||
| return function(u) { | ||
| return r(e, n, t, u); | ||
| }; | ||
| sys_blocked_io.tag = 248; | ||
| case 5: | ||
| return function(u, i) { | ||
| return r(e, n, t, u, i); | ||
| }; | ||
| assert_failure.tag = 248; | ||
| case 6: | ||
| return function(u, i, f) { | ||
| return r(e, n, t, u, i, f); | ||
| }; | ||
| undefined_recursive_module.tag = 248; | ||
| /* Not a pure module */ | ||
| case 7: | ||
| return function(u, i, f, o) { | ||
| return r(e, n, t, u, i, f, o); | ||
| }; | ||
| function caml_array_sub(x, offset, len) { | ||
| var result = new Array(len); | ||
| var j = 0; | ||
| var i = offset; | ||
| while(j < len) { | ||
| result[j] = x[i]; | ||
| j = j + 1 | 0; | ||
| i = i + 1 | 0; | ||
| } return result; | ||
| } | ||
| /* No side effect */ | ||
| function app(_f, _args) { | ||
| while(true) { | ||
| var args = _args; | ||
| var f = _f; | ||
| var arity = f.length; | ||
| var len = args.length; | ||
| var d = arity - len | 0; | ||
| if (d === 0) { | ||
| return f.apply(null, args); | ||
| } else if (d < 0) { | ||
| _args = caml_array_sub(args, arity, -d | 0); | ||
| _f = f.apply(null, caml_array_sub(args, 0, arity)); | ||
| continue ; | ||
| } else { | ||
| return (function(f,args){ | ||
| return function (x) { | ||
| return app(f, args.concat(/* array */[x])); | ||
| default: | ||
| return app(r, [e, n, t]); | ||
| } | ||
| }(f,args)); | ||
| } | ||
| }} | ||
| function curry_1(o, a0, arity) { | ||
| switch (arity) { | ||
| case 1 : | ||
| return o(a0); | ||
| case 2 : | ||
| return (function (param) { | ||
| return o(a0, param); | ||
| }); | ||
| case 3 : | ||
| return (function (param, param$1) { | ||
| return o(a0, param, param$1); | ||
| }); | ||
| case 4 : | ||
| return (function (param, param$1, param$2) { | ||
| return o(a0, param, param$1, param$2); | ||
| }); | ||
| case 5 : | ||
| return (function (param, param$1, param$2, param$3) { | ||
| return o(a0, param, param$1, param$2, param$3); | ||
| }); | ||
| case 6 : | ||
| return (function (param, param$1, param$2, param$3, param$4) { | ||
| return o(a0, param, param$1, param$2, param$3, param$4); | ||
| }); | ||
| case 7 : | ||
| return (function (param, param$1, param$2, param$3, param$4, param$5) { | ||
| return o(a0, param, param$1, param$2, param$3, param$4, param$5); | ||
| }); | ||
| default: | ||
| return app(o, /* array */[a0]); | ||
| })(r, e, n, t, u); | ||
| } | ||
| } | ||
| function _1(o, a0) { | ||
| var arity = o.length; | ||
| if (arity === 1) { | ||
| return o(a0); | ||
| } else { | ||
| return curry_1(o, a0, arity); | ||
| } | ||
| } | ||
| var r = []; | ||
| function curry_2(o, a0, a1, arity) { | ||
| switch (arity) { | ||
| case 1 : | ||
| return app(o(a0), /* array */[a1]); | ||
| case 2 : | ||
| return o(a0, a1); | ||
| case 3 : | ||
| return (function (param) { | ||
| return o(a0, a1, param); | ||
| }); | ||
| case 4 : | ||
| return (function (param, param$1) { | ||
| return o(a0, a1, param, param$1); | ||
| }); | ||
| case 5 : | ||
| return (function (param, param$1, param$2) { | ||
| return o(a0, a1, param, param$1, param$2); | ||
| }); | ||
| case 6 : | ||
| return (function (param, param$1, param$2, param$3) { | ||
| return o(a0, a1, param, param$1, param$2, param$3); | ||
| }); | ||
| case 7 : | ||
| return (function (param, param$1, param$2, param$3, param$4) { | ||
| return o(a0, a1, param, param$1, param$2, param$3, param$4); | ||
| }); | ||
| default: | ||
| return app(o, /* array */[ | ||
| a0, | ||
| a1 | ||
| ]); | ||
| } | ||
| } | ||
| function _2(o, a0, a1) { | ||
| var arity = o.length; | ||
| if (arity === 2) { | ||
| return o(a0, a1); | ||
| function some(e) { | ||
| if (void 0 === e) { | ||
| var n = [r, 0]; | ||
| n.tag = 256; | ||
| return n; | ||
| } else if (null !== e && e[0] === r) { | ||
| var t = (e[1] + 1) | 0; | ||
| var u = [r, t]; | ||
| u.tag = 256; | ||
| return u; | ||
| } else { | ||
| return curry_2(o, a0, a1, arity); | ||
| return e; | ||
| } | ||
| } | ||
| function curry_3(o, a0, a1, a2, arity) { | ||
| switch (arity) { | ||
| case 1 : | ||
| return app(o(a0), /* array */[ | ||
| a1, | ||
| a2 | ||
| ]); | ||
| case 2 : | ||
| return app(o(a0, a1), /* array */[a2]); | ||
| case 3 : | ||
| return o(a0, a1, a2); | ||
| case 4 : | ||
| return (function (param) { | ||
| return o(a0, a1, a2, param); | ||
| }); | ||
| case 5 : | ||
| return (function (param, param$1) { | ||
| return o(a0, a1, a2, param, param$1); | ||
| }); | ||
| case 6 : | ||
| return (function (param, param$1, param$2) { | ||
| return o(a0, a1, a2, param, param$1, param$2); | ||
| }); | ||
| case 7 : | ||
| return (function (param, param$1, param$2, param$3) { | ||
| return o(a0, a1, a2, param, param$1, param$2, param$3); | ||
| }); | ||
| default: | ||
| return app(o, /* array */[ | ||
| a0, | ||
| a1, | ||
| a2 | ||
| ]); | ||
| } | ||
| } | ||
| function _3(o, a0, a1, a2) { | ||
| var arity = o.length; | ||
| if (arity === 3) { | ||
| return o(a0, a1, a2); | ||
| } else { | ||
| return curry_3(o, a0, a1, a2, arity); | ||
| } | ||
| } | ||
| /* No side effect */ | ||
| /* No side effect */ | ||
| /* No side effect */ | ||
| var undefinedHeader = /* array */[]; | ||
| function some(x) { | ||
| if (x === undefined) { | ||
| var block = /* tuple */[ | ||
| undefinedHeader, | ||
| 0 | ||
| ]; | ||
| block.tag = 256; | ||
| return block; | ||
| } else if (x !== null && x[0] === undefinedHeader) { | ||
| var nid = x[1] + 1 | 0; | ||
| var block$1 = /* tuple */[ | ||
| undefinedHeader, | ||
| nid | ||
| ]; | ||
| block$1.tag = 256; | ||
| return block$1; | ||
| } else { | ||
| return x; | ||
| } | ||
| } | ||
| function valFromOption(x) { | ||
| if (x !== null && x[0] === undefinedHeader) { | ||
| var depth = x[1]; | ||
| if (depth === 0) { | ||
| return undefined; | ||
| function valFromOption(e) { | ||
| if (null !== e && e[0] === r) { | ||
| var n = e[1]; | ||
| if (0 === n) { | ||
| return; | ||
| } else { | ||
| return /* tuple */[ | ||
| undefinedHeader, | ||
| depth - 1 | 0 | ||
| ]; | ||
| return [r, (n - 1) | 0]; | ||
| } | ||
| } else { | ||
| return x; | ||
| return e; | ||
| } | ||
| } | ||
| /* No side effect */ | ||
| /* No side effect */ | ||
| /* No side effect */ | ||
| function make$1(len, vals) { | ||
| var res = new Array(len); | ||
| res.fill(vals); | ||
| return res; | ||
| function talkbackPlaceholder(r) { | ||
| return 0; | ||
| } | ||
| /* No side effect */ | ||
| function talkbackPlaceholder(param) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } | ||
| function captureTalkback(source, sinkWithTalkback) { | ||
| var talkback = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| talkbackPlaceholder]; | ||
| return _1(source, function (signal) { | ||
| if (typeof signal !== "number") { | ||
| if (!signal.tag) { | ||
| talkback[0] = signal[0]; | ||
| function captureTalkback(r, e) { | ||
| var n = [talkbackPlaceholder]; | ||
| return _1(r, function(r) { | ||
| if ("number" != typeof r) { | ||
| if (!r.tag) { | ||
| n[0] = r[0]; | ||
| } | ||
| } | ||
| return sinkWithTalkback(signal, talkback[0]); | ||
| return e(r, n[0]); | ||
| }); | ||
| } | ||
| function makeTrampoline(sink, f) { | ||
| var state = | ||
| /* record */ | ||
| [ | ||
| /* exhausted */ | ||
| false, | ||
| /* inLoop */ | ||
| false, | ||
| /* gotSignal */ | ||
| false]; | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| var match = state[ | ||
| /* exhausted */ | ||
| 0]; | ||
| if (signal || match) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| function makeSubject(r) { | ||
| var e = [new Array(), !1]; | ||
| return [ | ||
| function(r) { | ||
| e[0] = e[0].concat(r); | ||
| return r( | ||
| __(0, [ | ||
| function(n) { | ||
| if (1 === n) { | ||
| e[0] = e[0].filter(function(e) { | ||
| return e !== r; | ||
| }); | ||
| return 0; | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| } else { | ||
| state[ | ||
| /* gotSignal */ | ||
| 2] = true; | ||
| if (state[ | ||
| /* inLoop */ | ||
| 1]) { | ||
| }, | ||
| function(r) { | ||
| if (e[1]) { | ||
| return 0; | ||
| } else { | ||
| var explode = function (_param) { | ||
| while (true) { | ||
| var match = f(); | ||
| if (match !== undefined) { | ||
| state[ | ||
| /* gotSignal */ | ||
| 2] = false; | ||
| sink( | ||
| /* Push */ | ||
| __(1, [valFromOption(match)])); | ||
| if (state[ | ||
| /* gotSignal */ | ||
| 2]) { | ||
| _param = | ||
| /* () */ | ||
| 0; | ||
| continue; | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else { | ||
| state[ | ||
| /* exhausted */ | ||
| 0] = true; | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| } | ||
| } | ||
| }; | ||
| state[ | ||
| /* inLoop */ | ||
| 1] = true; | ||
| explode( | ||
| /* () */ | ||
| 0); | ||
| state[ | ||
| /* inLoop */ | ||
| 1] = false; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| e[0].forEach(function(e) { | ||
| return e(__(1, [r])); | ||
| }); | ||
| return 0; | ||
| } | ||
| } | ||
| }])); | ||
| } | ||
| /* No side effect */ | ||
| function makeSubject(param) { | ||
| var state = | ||
| /* record */ | ||
| [ | ||
| /* sinks */ | ||
| new Array(), | ||
| /* ended */ | ||
| false]; | ||
| var source = function (sink) { | ||
| state[ | ||
| /* sinks */ | ||
| 0] = state[ | ||
| /* sinks */ | ||
| 0].concat(sink); | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (signal === | ||
| /* Close */ | ||
| 1) { | ||
| state[ | ||
| /* sinks */ | ||
| 0] = state[ | ||
| /* sinks */ | ||
| 0].filter(function (x) { | ||
| return x !== sink; | ||
| }, | ||
| function(r) { | ||
| if (e[1]) { | ||
| return 0; | ||
| } else { | ||
| e[1] = !0; | ||
| e[0].forEach(function(r) { | ||
| return r(0); | ||
| }); | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else { | ||
| return 0; | ||
| } | ||
| }])); | ||
| }; | ||
| var next = function (value) { | ||
| if (state[ | ||
| /* ended */ | ||
| 1]) { | ||
| return 0; | ||
| } else { | ||
| state[ | ||
| /* sinks */ | ||
| 0].forEach(function (sink) { | ||
| return sink( | ||
| /* Push */ | ||
| __(1, [value])); | ||
| }); | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } | ||
| }; | ||
| var complete = function (param) { | ||
| if (state[ | ||
| /* ended */ | ||
| 1]) { | ||
| return 0; | ||
| } else { | ||
| state[ | ||
| /* ended */ | ||
| 1] = true; | ||
| state[ | ||
| /* sinks */ | ||
| 0].forEach(function (sink) { | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| }); | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } | ||
| }; | ||
| return ( | ||
| /* record */ | ||
| [ | ||
| /* source */ | ||
| source, | ||
| /* next */ | ||
| next, | ||
| /* complete */ | ||
| complete] | ||
| ); | ||
| ]; | ||
| } | ||
| function make$2(f) { | ||
| return function (sink) { | ||
| var teardown = _1(f, | ||
| /* record */ | ||
| [ | ||
| /* next */ | ||
| function (value) { | ||
| return sink( | ||
| /* Push */ | ||
| __(1, [value])); | ||
| }, | ||
| /* complete */ | ||
| function (param) { | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| }]); | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (signal) { | ||
| return _1(teardown, | ||
| /* () */ | ||
| 0); | ||
| } else { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| function make$2(r) { | ||
| return function(e) { | ||
| var n = _1(r, [ | ||
| function(r) { | ||
| return e(__(1, [r])); | ||
| }, | ||
| function(r) { | ||
| return e(0); | ||
| } | ||
| }])); | ||
| ]); | ||
| return e( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| return _1(n, 0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| } | ||
| function fromList(ls) { | ||
| return function (sink) { | ||
| var state = | ||
| /* record */ | ||
| [ | ||
| /* value */ | ||
| ls, | ||
| /* ended */ | ||
| false, | ||
| /* looping */ | ||
| false, | ||
| /* pull */ | ||
| false]; | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| var match = state[ | ||
| /* looping */ | ||
| 2]; | ||
| if (signal) { | ||
| state[ | ||
| /* ended */ | ||
| 1] = true; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else if (match) { | ||
| state[ | ||
| /* pull */ | ||
| 3] = true; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else { | ||
| state[ | ||
| /* pull */ | ||
| 3] = true; | ||
| state[ | ||
| /* looping */ | ||
| 2] = true; | ||
| while (state[ | ||
| /* pull */ | ||
| 3] && !state[ | ||
| /* ended */ | ||
| 1]) { | ||
| var match$1 = state[ | ||
| /* value */ | ||
| 0]; | ||
| if (match$1) { | ||
| state[ | ||
| /* value */ | ||
| 0] = match$1[1]; | ||
| state[ | ||
| /* pull */ | ||
| 3] = false; | ||
| sink( | ||
| /* Push */ | ||
| __(1, [match$1[0]])); | ||
| function fromList(r) { | ||
| return function(e) { | ||
| var n = [r, !1, !1, !1]; | ||
| return e( | ||
| __(0, [ | ||
| function(r) { | ||
| var t = n[2]; | ||
| if (r) { | ||
| n[1] = !0; | ||
| return 0; | ||
| } else if (t) { | ||
| n[3] = !0; | ||
| return 0; | ||
| } else { | ||
| state[ | ||
| /* ended */ | ||
| 1] = true; | ||
| sink( | ||
| /* End */ | ||
| 0); | ||
| n[3] = !0; | ||
| n[2] = !0; | ||
| while (n[3] && !n[1]) { | ||
| var u = n[0]; | ||
| if (u) { | ||
| n[0] = u[1]; | ||
| n[3] = !1; | ||
| e(__(1, [u[0]])); | ||
| } else { | ||
| n[1] = !0; | ||
| e(0); | ||
| } | ||
| } | ||
| n[2] = !1; | ||
| return 0; | ||
| } | ||
| } | ||
| state[ | ||
| /* looping */ | ||
| 2] = false; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } | ||
| }])); | ||
| ]) | ||
| ); | ||
| }; | ||
| } | ||
| function fromArray(arr) { | ||
| return function (sink) { | ||
| var size = arr.length; | ||
| var state = | ||
| /* record */ | ||
| [ | ||
| /* index */ | ||
| 0, | ||
| /* ended */ | ||
| false, | ||
| /* looping */ | ||
| false, | ||
| /* pull */ | ||
| false]; | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| var match = state[ | ||
| /* looping */ | ||
| 2]; | ||
| if (signal) { | ||
| state[ | ||
| /* ended */ | ||
| 1] = true; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else if (match) { | ||
| state[ | ||
| /* pull */ | ||
| 3] = true; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else { | ||
| state[ | ||
| /* pull */ | ||
| 3] = true; | ||
| state[ | ||
| /* looping */ | ||
| 2] = true; | ||
| while (state[ | ||
| /* pull */ | ||
| 3] && !state[ | ||
| /* ended */ | ||
| 1]) { | ||
| var index = state[ | ||
| /* index */ | ||
| 0]; | ||
| if (index < size) { | ||
| var x = arr[index]; | ||
| state[ | ||
| /* index */ | ||
| 0] = index + 1 | 0; | ||
| state[ | ||
| /* pull */ | ||
| 3] = false; | ||
| sink( | ||
| /* Push */ | ||
| __(1, [x])); | ||
| function fromArray(r) { | ||
| return function(e) { | ||
| var n = r.length; | ||
| var t = [0, !1, !1, !1]; | ||
| return e( | ||
| __(0, [ | ||
| function(u) { | ||
| var i = t[2]; | ||
| if (u) { | ||
| t[1] = !0; | ||
| return 0; | ||
| } else if (i) { | ||
| t[3] = !0; | ||
| return 0; | ||
| } else { | ||
| state[ | ||
| /* ended */ | ||
| 1] = true; | ||
| sink( | ||
| /* End */ | ||
| 0); | ||
| t[3] = !0; | ||
| t[2] = !0; | ||
| while (t[3] && !t[1]) { | ||
| var f = t[0]; | ||
| if (f < n) { | ||
| var o = r[f]; | ||
| t[0] = (f + 1) | 0; | ||
| t[3] = !1; | ||
| e(__(1, [o])); | ||
| } else { | ||
| t[1] = !0; | ||
| e(0); | ||
| } | ||
| } | ||
| t[2] = !1; | ||
| return 0; | ||
| } | ||
| } | ||
| state[ | ||
| /* looping */ | ||
| 2] = false; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } | ||
| }])); | ||
| ]) | ||
| ); | ||
| }; | ||
| } | ||
| function fromValue(x) { | ||
| return function (sink) { | ||
| var ended = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| false]; | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (signal || ended[0]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else { | ||
| ended[0] = true; | ||
| sink( | ||
| /* Push */ | ||
| __(1, [x])); | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| } | ||
| }])); | ||
| function fromValue(r) { | ||
| return function(e) { | ||
| var n = [!1]; | ||
| return e( | ||
| __(0, [ | ||
| function(t) { | ||
| if (t || n[0]) { | ||
| return 0; | ||
| } else { | ||
| n[0] = !0; | ||
| e(__(1, [r])); | ||
| return e(0); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| } | ||
| function empty(sink) { | ||
| sink( | ||
| /* Start */ | ||
| __(0, [talkbackPlaceholder])); | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| function empty(r) { | ||
| r(__(0, [talkbackPlaceholder])); | ||
| return r(0); | ||
| } | ||
| function never(sink) { | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [talkbackPlaceholder])); | ||
| function never(r) { | ||
| return r(__(0, [talkbackPlaceholder])); | ||
| } | ||
| function map$1(f) { | ||
| return function (source) { | ||
| return function (sink) { | ||
| return _1(source, function (signal) { | ||
| var tmp; | ||
| tmp = typeof signal === "number" ? | ||
| /* End */ | ||
| 0 : signal.tag ? | ||
| /* Push */ | ||
| __(1, [_1(f, signal[0])]) : | ||
| /* Start */ | ||
| __(0, [signal[0]]); | ||
| return sink(tmp); | ||
| function map$1(r) { | ||
| return function(e) { | ||
| return function(n) { | ||
| return _1(e, function(e) { | ||
| var t; | ||
| t = "number" == typeof e ? 0 : e.tag ? __(1, [_1(r, e[0])]) : __(0, [e[0]]); | ||
| return n(t); | ||
| }); | ||
@@ -791,12 +413,10 @@ }; | ||
| function filter(f) { | ||
| return function (source) { | ||
| return function (sink) { | ||
| return captureTalkback(source, function (signal, talkback) { | ||
| if (typeof signal === "number" || !(signal.tag && !_1(f, signal[0]))) { | ||
| return sink(signal); | ||
| function filter(r) { | ||
| return function(e) { | ||
| return function(n) { | ||
| return captureTalkback(e, function(e, t) { | ||
| if ("number" == typeof e || !e.tag || _1(r, e[0])) { | ||
| return n(e); | ||
| } else { | ||
| return talkback( | ||
| /* Pull */ | ||
| 0); | ||
| return t(0); | ||
| } | ||
@@ -808,29 +428,17 @@ }); | ||
| function scan(f, seed) { | ||
| return function (source) { | ||
| return function (sink) { | ||
| var acc = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| seed]; | ||
| return _1(source, function (signal) { | ||
| var tmp; | ||
| if (typeof signal === "number") { | ||
| tmp = | ||
| /* End */ | ||
| 0; | ||
| } else if (signal.tag) { | ||
| acc[0] = _2(f, acc[0], signal[0]); | ||
| tmp = | ||
| /* Push */ | ||
| __(1, [acc[0]]); | ||
| function scan(r, e) { | ||
| return function(n) { | ||
| return function(t) { | ||
| var u = [e]; | ||
| return _1(n, function(e) { | ||
| var n; | ||
| if ("number" == typeof e) { | ||
| n = 0; | ||
| } else if (e.tag) { | ||
| u[0] = _2(r, u[0], e[0]); | ||
| n = __(1, [u[0]]); | ||
| } else { | ||
| tmp = | ||
| /* Start */ | ||
| __(0, [signal[0]]); | ||
| n = __(0, [e[0]]); | ||
| } | ||
| return sink(tmp); | ||
| return t(n); | ||
| }); | ||
@@ -841,23 +449,18 @@ }; | ||
| function merge(sources) { | ||
| return function (sink) { | ||
| var size = sources.length; | ||
| var talkbacks = make$1(size, talkbackPlaceholder); | ||
| var state = | ||
| /* record */ | ||
| [ | ||
| /* started */ | ||
| 0, | ||
| /* ended */ | ||
| 0]; | ||
| var talkback = function (signal) { | ||
| var _i = 0; | ||
| while (true) { | ||
| var i = _i; | ||
| if (i < size) { | ||
| talkbacks[i](signal); | ||
| _i = i + 1 | 0; | ||
| function merge(r) { | ||
| return function(e) { | ||
| var n = r.length; | ||
| var t = (function make$1(r, e) { | ||
| var n = new Array(r); | ||
| n.fill(e); | ||
| return n; | ||
| })(n, talkbackPlaceholder); | ||
| var u = [0, 0]; | ||
| var i = function(r) { | ||
| var e = 0; | ||
| while (1) { | ||
| var u = e; | ||
| if (u < n) { | ||
| t[u](r); | ||
| e = (u + 1) | 0; | ||
| continue; | ||
@@ -869,53 +472,32 @@ } else { | ||
| }; | ||
| var _i = 0; | ||
| while (true) { | ||
| var i = _i; | ||
| if (i < size) { | ||
| var source = sources[i]; | ||
| _1(source, function (i) { | ||
| return function (signal) { | ||
| if (typeof signal === "number") { | ||
| state[ | ||
| /* ended */ | ||
| 1] = state[ | ||
| /* ended */ | ||
| 1] + 1 | 0; | ||
| if (state[ | ||
| /* ended */ | ||
| 1] === size) { | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| var f = 0; | ||
| while (1) { | ||
| var o = f; | ||
| if (o < n) { | ||
| _1( | ||
| r[o], | ||
| (function(r) { | ||
| return function(f) { | ||
| if ("number" == typeof f) { | ||
| u[1] = (u[1] + 1) | 0; | ||
| if (u[1] === n) { | ||
| return e(0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else if (f.tag) { | ||
| return e(f); | ||
| } else { | ||
| return 0; | ||
| t[r] = f[0]; | ||
| u[0] = (u[0] + 1) | 0; | ||
| if (u[0] === n) { | ||
| return e(__(0, [i])); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| } else if (signal.tag) { | ||
| return sink(signal); | ||
| } else { | ||
| talkbacks[i] = signal[0]; | ||
| state[ | ||
| /* started */ | ||
| 0] = state[ | ||
| /* started */ | ||
| 0] + 1 | 0; | ||
| if (state[ | ||
| /* started */ | ||
| 0] === size) { | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [talkback])); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| }; | ||
| }(i)); | ||
| _i = i + 1 | 0; | ||
| }; | ||
| })(o) | ||
| ); | ||
| f = (o + 1) | 0; | ||
| continue; | ||
@@ -929,423 +511,192 @@ } else { | ||
| function concat$1(sources) { | ||
| return function (sink) { | ||
| var size = sources.length; | ||
| var talkback = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| talkbackPlaceholder]; | ||
| var nextSource = function (i) { | ||
| if (i < size) { | ||
| var source = sources[i]; | ||
| return _1(source, function (signal) { | ||
| if (typeof signal === "number") { | ||
| return nextSource(i + 1 | 0); | ||
| } else if (signal.tag) { | ||
| return sink(signal); | ||
| function concat$1(r) { | ||
| return function(e) { | ||
| var n = r.length; | ||
| var t = [talkbackPlaceholder]; | ||
| var u = function(i) { | ||
| if (i < n) { | ||
| return _1(r[i], function(r) { | ||
| if ("number" == typeof r) { | ||
| return u((i + 1) | 0); | ||
| } else if (r.tag) { | ||
| return e(r); | ||
| } else { | ||
| var tb = signal[0]; | ||
| talkback[0] = tb; | ||
| if (i === 0) { | ||
| sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| return talkback[0](signal); | ||
| }])); | ||
| var n = r[0]; | ||
| t[0] = n; | ||
| if (0 === i) { | ||
| e( | ||
| __(0, [ | ||
| function(r) { | ||
| return t[0](r); | ||
| } | ||
| ]) | ||
| ); | ||
| } | ||
| return tb( | ||
| /* Pull */ | ||
| 0); | ||
| return n(0); | ||
| } | ||
| }); | ||
| } else { | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| return e(0); | ||
| } | ||
| }; | ||
| return nextSource(0); | ||
| return u(0); | ||
| }; | ||
| } | ||
| function share(source) { | ||
| var state = | ||
| /* record */ | ||
| [ | ||
| /* sinks */ | ||
| new Array(), | ||
| /* talkback */ | ||
| talkbackPlaceholder, | ||
| /* gotSignal */ | ||
| false]; | ||
| return function (sink) { | ||
| state[ | ||
| /* sinks */ | ||
| 0] = state[ | ||
| /* sinks */ | ||
| 0].concat(sink); | ||
| if (state[ | ||
| /* sinks */ | ||
| 0].length === 1) { | ||
| _1(source, function (signal) { | ||
| if (typeof signal === "number") { | ||
| state[ | ||
| /* sinks */ | ||
| 0].forEach(function (sink) { | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| function share(r) { | ||
| var e = [new Array(), talkbackPlaceholder, !1]; | ||
| return function(n) { | ||
| e[0] = e[0].concat(n); | ||
| if (1 === e[0].length) { | ||
| _1(r, function(r) { | ||
| if ("number" == typeof r) { | ||
| e[0].forEach(function(r) { | ||
| return r(0); | ||
| }); | ||
| state[ | ||
| /* sinks */ | ||
| 0] = new Array(); | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else if (signal.tag) { | ||
| state[ | ||
| /* gotSignal */ | ||
| 2] = false; | ||
| state[ | ||
| /* sinks */ | ||
| 0].forEach(function (sink) { | ||
| return sink(signal); | ||
| e[0] = new Array(); | ||
| return 0; | ||
| } else if (r.tag) { | ||
| e[2] = !1; | ||
| e[0].forEach(function(e) { | ||
| return e(r); | ||
| }); | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| return 0; | ||
| } else { | ||
| state[ | ||
| /* talkback */ | ||
| 1] = signal[0]; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| e[1] = r[0]; | ||
| return 0; | ||
| } | ||
| }); | ||
| } | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (signal) { | ||
| state[ | ||
| /* sinks */ | ||
| 0] = state[ | ||
| /* sinks */ | ||
| 0].filter(function (x) { | ||
| return x !== sink; | ||
| }); | ||
| if (state[ | ||
| /* sinks */ | ||
| 0].length === 0) { | ||
| return state[ | ||
| /* talkback */ | ||
| 1]( | ||
| /* Close */ | ||
| 1); | ||
| } else { | ||
| return 0; | ||
| return n( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| e[0] = e[0].filter(function(r) { | ||
| return r !== n; | ||
| }); | ||
| if (0 === e[0].length) { | ||
| return e[1](1); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else if (e[2]) { | ||
| return 0; | ||
| } else { | ||
| e[2] = !0; | ||
| return e[1](r); | ||
| } | ||
| } | ||
| } else if (state[ | ||
| /* gotSignal */ | ||
| 2]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else { | ||
| state[ | ||
| /* gotSignal */ | ||
| 2] = true; | ||
| return state[ | ||
| /* talkback */ | ||
| 1](signal); | ||
| } | ||
| }])); | ||
| ]) | ||
| ); | ||
| }; | ||
| } | ||
| function combine(sourceA, sourceB) { | ||
| return function (sink) { | ||
| var state = | ||
| /* record */ | ||
| [ | ||
| /* talkbackA */ | ||
| talkbackPlaceholder, | ||
| /* talkbackB */ | ||
| talkbackPlaceholder, | ||
| /* lastValA */ | ||
| undefined, | ||
| /* lastValB */ | ||
| undefined, | ||
| /* gotSignal */ | ||
| false, | ||
| /* endCounter */ | ||
| 0, | ||
| /* ended */ | ||
| false]; | ||
| _1(sourceA, function (signal) { | ||
| var match = state[ | ||
| /* lastValB */ | ||
| 3]; | ||
| if (typeof signal === "number") { | ||
| if (state[ | ||
| /* endCounter */ | ||
| 5] < 1) { | ||
| state[ | ||
| /* endCounter */ | ||
| 5] = state[ | ||
| /* endCounter */ | ||
| 5] + 1 | 0; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else if (state[ | ||
| /* ended */ | ||
| 6]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| function combine(r, e) { | ||
| return function(n) { | ||
| var t = [talkbackPlaceholder, talkbackPlaceholder, void 0, void 0, !1, 0, !1]; | ||
| _1(r, function(r) { | ||
| var e = t[3]; | ||
| if ("number" == typeof r) { | ||
| if (t[5] < 1) { | ||
| t[5] = (t[5] + 1) | 0; | ||
| return 0; | ||
| } else if (t[6]) { | ||
| return 0; | ||
| } else { | ||
| state[ | ||
| /* ended */ | ||
| 6] = true; | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| t[6] = !0; | ||
| return n(0); | ||
| } | ||
| } else if (signal.tag) { | ||
| var a = signal[0]; | ||
| if (match !== undefined) { | ||
| if (state[ | ||
| /* ended */ | ||
| 6]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else if (r.tag) { | ||
| var u = r[0]; | ||
| if (void 0 !== e) { | ||
| if (t[6]) { | ||
| return 0; | ||
| } else { | ||
| state[ | ||
| /* lastValA */ | ||
| 2] = some(a); | ||
| state[ | ||
| /* gotSignal */ | ||
| 4] = false; | ||
| return sink( | ||
| /* Push */ | ||
| __(1, [ | ||
| /* tuple */ | ||
| [a, valFromOption(match)]])); | ||
| t[2] = some(u); | ||
| t[4] = !1; | ||
| return n(__(1, [[u, valFromOption(e)]])); | ||
| } | ||
| } else { | ||
| state[ | ||
| /* lastValA */ | ||
| 2] = some(a); | ||
| state[ | ||
| /* gotSignal */ | ||
| 4] = false; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| t[2] = some(u); | ||
| t[4] = !1; | ||
| return 0; | ||
| } | ||
| } else { | ||
| state[ | ||
| /* talkbackA */ | ||
| 0] = signal[0]; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| t[0] = r[0]; | ||
| return 0; | ||
| } | ||
| }); | ||
| _1(sourceB, function (signal) { | ||
| var match = state[ | ||
| /* lastValA */ | ||
| 2]; | ||
| if (typeof signal === "number") { | ||
| if (state[ | ||
| /* endCounter */ | ||
| 5] < 1) { | ||
| state[ | ||
| /* endCounter */ | ||
| 5] = state[ | ||
| /* endCounter */ | ||
| 5] + 1 | 0; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else if (state[ | ||
| /* ended */ | ||
| 6]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| _1(e, function(r) { | ||
| var e = t[2]; | ||
| if ("number" == typeof r) { | ||
| if (t[5] < 1) { | ||
| t[5] = (t[5] + 1) | 0; | ||
| return 0; | ||
| } else if (t[6]) { | ||
| return 0; | ||
| } else { | ||
| state[ | ||
| /* ended */ | ||
| 6] = true; | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| t[6] = !0; | ||
| return n(0); | ||
| } | ||
| } else if (signal.tag) { | ||
| var b = signal[0]; | ||
| if (match !== undefined) { | ||
| if (state[ | ||
| /* ended */ | ||
| 6]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else if (r.tag) { | ||
| var u = r[0]; | ||
| if (void 0 !== e) { | ||
| if (t[6]) { | ||
| return 0; | ||
| } else { | ||
| state[ | ||
| /* lastValB */ | ||
| 3] = some(b); | ||
| state[ | ||
| /* gotSignal */ | ||
| 4] = false; | ||
| return sink( | ||
| /* Push */ | ||
| __(1, [ | ||
| /* tuple */ | ||
| [valFromOption(match), b]])); | ||
| t[3] = some(u); | ||
| t[4] = !1; | ||
| return n(__(1, [[valFromOption(e), u]])); | ||
| } | ||
| } else { | ||
| state[ | ||
| /* lastValB */ | ||
| 3] = some(b); | ||
| state[ | ||
| /* gotSignal */ | ||
| 4] = false; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| t[3] = some(u); | ||
| t[4] = !1; | ||
| return 0; | ||
| } | ||
| } else { | ||
| state[ | ||
| /* talkbackB */ | ||
| 1] = signal[0]; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| t[1] = r[0]; | ||
| return 0; | ||
| } | ||
| }); | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (state[ | ||
| /* ended */ | ||
| 6]) { | ||
| return 0; | ||
| } else if (signal) { | ||
| state[ | ||
| /* ended */ | ||
| 6] = true; | ||
| state[ | ||
| /* talkbackA */ | ||
| 0]( | ||
| /* Close */ | ||
| 1); | ||
| return state[ | ||
| /* talkbackB */ | ||
| 1]( | ||
| /* Close */ | ||
| 1); | ||
| } else if (state[ | ||
| /* gotSignal */ | ||
| 4]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else { | ||
| state[ | ||
| /* gotSignal */ | ||
| 4] = true; | ||
| state[ | ||
| /* talkbackA */ | ||
| 0](signal); | ||
| return state[ | ||
| /* talkbackB */ | ||
| 1](signal); | ||
| } | ||
| }])); | ||
| return n( | ||
| __(0, [ | ||
| function(r) { | ||
| if (t[6]) { | ||
| return 0; | ||
| } else if (r) { | ||
| t[6] = !0; | ||
| t[0](1); | ||
| return t[1](1); | ||
| } else if (t[4]) { | ||
| return 0; | ||
| } else { | ||
| t[4] = !0; | ||
| t[0](r); | ||
| return t[1](r); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| } | ||
| function take(max) { | ||
| return function (source) { | ||
| return function (sink) { | ||
| var state = | ||
| /* record */ | ||
| [ | ||
| /* taken */ | ||
| 0, | ||
| /* talkback */ | ||
| talkbackPlaceholder]; | ||
| _1(source, function (signal) { | ||
| if (typeof signal === "number") { | ||
| if (state[ | ||
| /* taken */ | ||
| 0] < max) { | ||
| state[ | ||
| /* taken */ | ||
| 0] = max; | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| function take(r) { | ||
| return function(e) { | ||
| return function(n) { | ||
| var t = [0, talkbackPlaceholder]; | ||
| _1(e, function(e) { | ||
| if ("number" == typeof e) { | ||
| if (t[0] < r) { | ||
| t[0] = r; | ||
| return n(0); | ||
| } else { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| return 0; | ||
| } | ||
| } else if (signal.tag) { | ||
| if (state[ | ||
| /* taken */ | ||
| 0] < max) { | ||
| state[ | ||
| /* taken */ | ||
| 0] = state[ | ||
| /* taken */ | ||
| 0] + 1 | 0; | ||
| sink(signal); | ||
| if (state[ | ||
| /* taken */ | ||
| 0] === max) { | ||
| sink( | ||
| /* End */ | ||
| 0); | ||
| return state[ | ||
| /* talkback */ | ||
| 1]( | ||
| /* Close */ | ||
| 1); | ||
| } else if (e.tag) { | ||
| if (t[0] < r) { | ||
| t[0] = (t[0] + 1) | 0; | ||
| n(e); | ||
| if (t[0] === r) { | ||
| n(0); | ||
| return t[1](1); | ||
| } else { | ||
@@ -1355,44 +706,25 @@ return 0; | ||
| } else { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| return 0; | ||
| } | ||
| } else { | ||
| state[ | ||
| /* talkback */ | ||
| 1] = signal[0]; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| t[1] = e[0]; | ||
| return 0; | ||
| } | ||
| }); | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (state[ | ||
| /* taken */ | ||
| 0] < max) { | ||
| if (signal) { | ||
| state[ | ||
| /* taken */ | ||
| 0] = max; | ||
| return state[ | ||
| /* talkback */ | ||
| 1]( | ||
| /* Close */ | ||
| 1); | ||
| } else { | ||
| return state[ | ||
| /* talkback */ | ||
| 1]( | ||
| /* Pull */ | ||
| 0); | ||
| return n( | ||
| __(0, [ | ||
| function(e) { | ||
| if (t[0] < r) { | ||
| if (e) { | ||
| t[0] = r; | ||
| return t[1](1); | ||
| } else { | ||
| return t[1](0); | ||
| } | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| } else { | ||
| return 0; | ||
| } | ||
| }])); | ||
| ]) | ||
| ); | ||
| }; | ||
@@ -1402,26 +734,57 @@ }; | ||
| function takeLast(max) { | ||
| return function (source) { | ||
| return function (sink) { | ||
| var queue = new Array(); | ||
| return captureTalkback(source, function (signal, talkback) { | ||
| if (typeof signal === "number") { | ||
| return makeTrampoline(sink, function () { | ||
| return queue.shift(); | ||
| function takeLast(r) { | ||
| return function(e) { | ||
| return function(n) { | ||
| var t = new Array(); | ||
| return captureTalkback(e, function(e, u) { | ||
| if ("number" == typeof e) { | ||
| return (function makeTrampoline(r, e) { | ||
| var n = [!1, !1, !1]; | ||
| return r( | ||
| __(0, [ | ||
| function(t) { | ||
| var u = n[0]; | ||
| if (t || u) { | ||
| return 0; | ||
| } else { | ||
| n[2] = !0; | ||
| if (n[1]) { | ||
| return 0; | ||
| } else { | ||
| n[1] = !0; | ||
| !(function(t) { | ||
| while (1) { | ||
| var u = e(); | ||
| if (void 0 !== u) { | ||
| n[2] = !1; | ||
| r(__(1, [valFromOption(u)])); | ||
| if (n[2]) { | ||
| continue; | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else { | ||
| n[0] = !0; | ||
| return r(0); | ||
| } | ||
| } | ||
| })(); | ||
| n[1] = !1; | ||
| return 0; | ||
| } | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| })(n, function() { | ||
| return t.shift(); | ||
| }); | ||
| } else if (signal.tag) { | ||
| var size = queue.length; | ||
| if (size >= max && max > 0) { | ||
| queue.shift(); | ||
| } else if (e.tag) { | ||
| if (t.length >= r && r > 0) { | ||
| t.shift(); | ||
| } | ||
| queue.push(signal[0]); | ||
| return talkback( | ||
| /* Pull */ | ||
| 0); | ||
| t.push(e[0]); | ||
| return u(0); | ||
| } else { | ||
| return talkback( | ||
| /* Pull */ | ||
| 0); | ||
| return u(0); | ||
| } | ||
@@ -1433,68 +796,44 @@ }); | ||
| function takeWhile(predicate) { | ||
| return function (source) { | ||
| return function (sink) { | ||
| var ended = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| false]; | ||
| var talkback = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| talkbackPlaceholder]; | ||
| _1(source, function (signal) { | ||
| if (typeof signal === "number") { | ||
| if (ended[0]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| function takeWhile(r) { | ||
| return function(e) { | ||
| return function(n) { | ||
| var t = [!1]; | ||
| var u = [talkbackPlaceholder]; | ||
| _1(e, function(e) { | ||
| if ("number" == typeof e) { | ||
| if (t[0]) { | ||
| return 0; | ||
| } else { | ||
| ended[0] = true; | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| t[0] = !0; | ||
| return n(0); | ||
| } | ||
| } else if (signal.tag) { | ||
| if (ended[0]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else if (_1(predicate, signal[0])) { | ||
| return sink(signal); | ||
| } else if (e.tag) { | ||
| if (t[0]) { | ||
| return 0; | ||
| } else if (_1(r, e[0])) { | ||
| return n(e); | ||
| } else { | ||
| ended[0] = true; | ||
| sink( | ||
| /* End */ | ||
| 0); | ||
| return talkback[0]( | ||
| /* Close */ | ||
| 1); | ||
| t[0] = !0; | ||
| n(0); | ||
| return u[0](1); | ||
| } | ||
| } else { | ||
| talkback[0] = signal[0]; | ||
| return sink(signal); | ||
| u[0] = e[0]; | ||
| return n(e); | ||
| } | ||
| }); | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (ended[0]) { | ||
| return 0; | ||
| } else if (signal) { | ||
| ended[0] = true; | ||
| return talkback[0]( | ||
| /* Close */ | ||
| 1); | ||
| } else { | ||
| return talkback[0]( | ||
| /* Pull */ | ||
| 0); | ||
| } | ||
| }])); | ||
| return n( | ||
| __(0, [ | ||
| function(r) { | ||
| if (t[0]) { | ||
| return 0; | ||
| } else if (r) { | ||
| t[0] = !0; | ||
| return u[0](1); | ||
| } else { | ||
| return u[0](0); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
@@ -1504,83 +843,35 @@ }; | ||
| function takeUntil(notifier) { | ||
| return function (source) { | ||
| return function (sink) { | ||
| var state = | ||
| /* record */ | ||
| [ | ||
| /* ended */ | ||
| false, | ||
| /* sourceTalkback */ | ||
| talkbackPlaceholder, | ||
| /* notifierTalkback */ | ||
| talkbackPlaceholder]; | ||
| _1(source, function (signal) { | ||
| if (typeof signal === "number") { | ||
| if (state[ | ||
| /* ended */ | ||
| 0]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| function takeUntil(r) { | ||
| return function(e) { | ||
| return function(n) { | ||
| var t = [!1, talkbackPlaceholder, talkbackPlaceholder]; | ||
| _1(e, function(e) { | ||
| if ("number" == typeof e) { | ||
| if (t[0]) { | ||
| return 0; | ||
| } else { | ||
| state[ | ||
| /* notifierTalkback */ | ||
| 2]( | ||
| /* Close */ | ||
| 1); | ||
| state[ | ||
| /* ended */ | ||
| 0] = true; | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| t[2](1); | ||
| t[0] = !0; | ||
| return n(0); | ||
| } | ||
| } else if (signal.tag) { | ||
| if (state[ | ||
| /* ended */ | ||
| 0]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else if (e.tag) { | ||
| if (t[0]) { | ||
| return 0; | ||
| } else { | ||
| return sink(signal); | ||
| return n(e); | ||
| } | ||
| } else { | ||
| state[ | ||
| /* sourceTalkback */ | ||
| 1] = signal[0]; | ||
| return _1(notifier, function (signal) { | ||
| if (typeof signal === "number") { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else if (signal.tag) { | ||
| state[ | ||
| /* ended */ | ||
| 0] = true; | ||
| state[ | ||
| /* notifierTalkback */ | ||
| 2]( | ||
| /* Close */ | ||
| 1); | ||
| state[ | ||
| /* sourceTalkback */ | ||
| 1]( | ||
| /* Close */ | ||
| 1); | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| t[1] = e[0]; | ||
| return _1(r, function(r) { | ||
| if ("number" == typeof r) { | ||
| return 0; | ||
| } else if (r.tag) { | ||
| t[0] = !0; | ||
| t[2](1); | ||
| t[1](1); | ||
| return n(0); | ||
| } else { | ||
| var innerTb = signal[0]; | ||
| state[ | ||
| /* notifierTalkback */ | ||
| 2] = innerTb; | ||
| return innerTb( | ||
| /* Pull */ | ||
| 0); | ||
| var e = r[0]; | ||
| t[2] = e; | ||
| return e(0); | ||
| } | ||
@@ -1590,29 +881,16 @@ }); | ||
| }); | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (state[ | ||
| /* ended */ | ||
| 0]) { | ||
| return 0; | ||
| } else if (signal) { | ||
| state[ | ||
| /* sourceTalkback */ | ||
| 1]( | ||
| /* Close */ | ||
| 1); | ||
| return state[ | ||
| /* notifierTalkback */ | ||
| 2]( | ||
| /* Close */ | ||
| 1); | ||
| } else { | ||
| return state[ | ||
| /* sourceTalkback */ | ||
| 1]( | ||
| /* Pull */ | ||
| 0); | ||
| } | ||
| }])); | ||
| return n( | ||
| __(0, [ | ||
| function(r) { | ||
| if (t[0]) { | ||
| return 0; | ||
| } else if (r) { | ||
| t[1](1); | ||
| return t[2](1); | ||
| } else { | ||
| return t[1](0); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
@@ -1622,18 +900,12 @@ }; | ||
| function skip(wait) { | ||
| return function (source) { | ||
| return function (sink) { | ||
| var rest = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| wait]; | ||
| return captureTalkback(source, function (signal, talkback) { | ||
| if (typeof signal === "number" || !(signal.tag && rest[0] > 0)) { | ||
| return sink(signal); | ||
| function skip(r) { | ||
| return function(e) { | ||
| return function(n) { | ||
| var t = [r]; | ||
| return captureTalkback(e, function(r, e) { | ||
| if ("number" == typeof r || !(r.tag && t[0] > 0)) { | ||
| return n(r); | ||
| } else { | ||
| rest[0] = rest[0] - 1 | 0; | ||
| return talkback( | ||
| /* Pull */ | ||
| 0); | ||
| t[0] = (t[0] - 1) | 0; | ||
| return e(0); | ||
| } | ||
@@ -1645,20 +917,14 @@ }); | ||
| function skipWhile(predicate) { | ||
| return function (source) { | ||
| return function (sink) { | ||
| var skip = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| true]; | ||
| return captureTalkback(source, function (signal, talkback) { | ||
| if (typeof signal === "number" || !(signal.tag && skip[0])) { | ||
| return sink(signal); | ||
| } else if (_1(predicate, signal[0])) { | ||
| return talkback( | ||
| /* Pull */ | ||
| 0); | ||
| function skipWhile(r) { | ||
| return function(e) { | ||
| return function(n) { | ||
| var t = [!0]; | ||
| return captureTalkback(e, function(e, u) { | ||
| if ("number" == typeof e || !e.tag || !t[0]) { | ||
| return n(e); | ||
| } else if (_1(r, e[0])) { | ||
| return u(0); | ||
| } else { | ||
| skip[0] = false; | ||
| return sink(signal); | ||
| t[0] = !1; | ||
| return n(e); | ||
| } | ||
@@ -1670,92 +936,36 @@ }); | ||
| function skipUntil(notifier) { | ||
| return function (source) { | ||
| return function (sink) { | ||
| var state = | ||
| /* record */ | ||
| [ | ||
| /* skip */ | ||
| true, | ||
| /* ended */ | ||
| false, | ||
| /* gotSignal */ | ||
| false, | ||
| /* sourceTalkback */ | ||
| talkbackPlaceholder, | ||
| /* notifierTalkback */ | ||
| talkbackPlaceholder]; | ||
| _1(source, function (signal) { | ||
| if (typeof signal === "number") { | ||
| if (state[ | ||
| /* skip */ | ||
| 0]) { | ||
| state[ | ||
| /* notifierTalkback */ | ||
| 4]( | ||
| /* Close */ | ||
| 1); | ||
| function skipUntil(r) { | ||
| return function(e) { | ||
| return function(n) { | ||
| var t = [!0, !1, !1, talkbackPlaceholder, talkbackPlaceholder]; | ||
| _1(e, function(e) { | ||
| if ("number" == typeof e) { | ||
| if (t[0]) { | ||
| t[4](1); | ||
| } | ||
| state[ | ||
| /* ended */ | ||
| 1] = true; | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| } else if (signal.tag) { | ||
| if (state[ | ||
| /* skip */ | ||
| 0] && !state[ | ||
| /* ended */ | ||
| 1]) { | ||
| return state[ | ||
| /* sourceTalkback */ | ||
| 3]( | ||
| /* Pull */ | ||
| 0); | ||
| } else if (state[ | ||
| /* ended */ | ||
| 1]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| t[1] = !0; | ||
| return n(0); | ||
| } else if (e.tag) { | ||
| if (t[0] && !t[1]) { | ||
| return t[3](0); | ||
| } else if (t[1]) { | ||
| return 0; | ||
| } else { | ||
| state[ | ||
| /* gotSignal */ | ||
| 2] = false; | ||
| return sink(signal); | ||
| t[2] = !1; | ||
| return n(e); | ||
| } | ||
| } else { | ||
| var tb = signal[0]; | ||
| state[ | ||
| /* sourceTalkback */ | ||
| 3] = tb; | ||
| return _1(notifier, function (signal) { | ||
| if (typeof signal === "number") { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else if (signal.tag) { | ||
| state[ | ||
| /* skip */ | ||
| 0] = false; | ||
| return state[ | ||
| /* notifierTalkback */ | ||
| 4]( | ||
| /* Close */ | ||
| 1); | ||
| var u = e[0]; | ||
| t[3] = u; | ||
| return _1(r, function(r) { | ||
| if ("number" == typeof r) { | ||
| return 0; | ||
| } else if (r.tag) { | ||
| t[0] = !1; | ||
| return t[4](1); | ||
| } else { | ||
| var innerTb = signal[0]; | ||
| state[ | ||
| /* notifierTalkback */ | ||
| 4] = innerTb; | ||
| innerTb( | ||
| /* Pull */ | ||
| 0); | ||
| return tb( | ||
| /* Pull */ | ||
| 0); | ||
| var e = r[0]; | ||
| t[4] = e; | ||
| e(0); | ||
| return u(0); | ||
| } | ||
@@ -1765,45 +975,20 @@ }); | ||
| }); | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (signal) { | ||
| if (state[ | ||
| /* skip */ | ||
| 0]) { | ||
| state[ | ||
| /* notifierTalkback */ | ||
| 4]( | ||
| /* Close */ | ||
| 1); | ||
| return n( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| if (t[0]) { | ||
| t[4](1); | ||
| } | ||
| t[1] = !0; | ||
| return t[3](1); | ||
| } else if (!t[2] && !t[1]) { | ||
| t[2] = !0; | ||
| return t[3](0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| state[ | ||
| /* ended */ | ||
| 1] = true; | ||
| return state[ | ||
| /* sourceTalkback */ | ||
| 3]( | ||
| /* Close */ | ||
| 1); | ||
| } else if (!state[ | ||
| /* gotSignal */ | ||
| 2] && !state[ | ||
| /* ended */ | ||
| 1]) { | ||
| state[ | ||
| /* gotSignal */ | ||
| 2] = true; | ||
| return state[ | ||
| /* sourceTalkback */ | ||
| 3]( | ||
| /* Pull */ | ||
| 0); | ||
| } else { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } | ||
| }])); | ||
| ]) | ||
| ); | ||
| }; | ||
@@ -1813,152 +998,68 @@ }; | ||
| function flatten(source) { | ||
| return function (sink) { | ||
| var state = | ||
| /* record */ | ||
| [ | ||
| /* sourceTalkback */ | ||
| talkbackPlaceholder, | ||
| /* innerTalkback */ | ||
| talkbackPlaceholder, | ||
| /* sourceEnded */ | ||
| false, | ||
| /* innerEnded */ | ||
| true]; | ||
| _1(source, function (signal) { | ||
| if (typeof signal === "number") { | ||
| if (state[ | ||
| /* innerEnded */ | ||
| 3]) { | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| function flatten(r) { | ||
| return function(e) { | ||
| var n = [talkbackPlaceholder, talkbackPlaceholder, !1, !0]; | ||
| _1(r, function(r) { | ||
| if ("number" == typeof r) { | ||
| if (n[3]) { | ||
| return e(0); | ||
| } else { | ||
| state[ | ||
| /* sourceEnded */ | ||
| 2] = true; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| n[2] = !0; | ||
| return 0; | ||
| } | ||
| } else if (signal.tag) { | ||
| var innerSource = signal[0]; | ||
| return _1(innerSource, function (signal) { | ||
| if (typeof signal === "number") { | ||
| if (state[ | ||
| /* sourceEnded */ | ||
| 2]) { | ||
| return state[ | ||
| /* sourceTalkback */ | ||
| 0]( | ||
| /* Close */ | ||
| 1); | ||
| } else if (r.tag) { | ||
| return _1(r[0], function(r) { | ||
| if ("number" == typeof r) { | ||
| if (n[2]) { | ||
| return n[0](1); | ||
| } else { | ||
| state[ | ||
| /* innerEnded */ | ||
| 3] = true; | ||
| return state[ | ||
| /* sourceTalkback */ | ||
| 0]( | ||
| /* Pull */ | ||
| 0); | ||
| n[3] = !0; | ||
| return n[0](0); | ||
| } | ||
| } else if (signal.tag) { | ||
| return sink(signal); | ||
| } else if (r.tag) { | ||
| return e(r); | ||
| } else { | ||
| var tb = signal[0]; | ||
| if (!state[ | ||
| /* innerEnded */ | ||
| 3]) { | ||
| state[ | ||
| /* innerTalkback */ | ||
| 1]( | ||
| /* Close */ | ||
| 1); | ||
| var t = r[0]; | ||
| if (!n[3]) { | ||
| n[1](1); | ||
| } | ||
| state[ | ||
| /* innerEnded */ | ||
| 3] = false; | ||
| state[ | ||
| /* innerTalkback */ | ||
| 1] = tb; | ||
| return tb( | ||
| /* Pull */ | ||
| 0); | ||
| n[3] = !1; | ||
| n[1] = t; | ||
| return t(0); | ||
| } | ||
| }); | ||
| } else { | ||
| state[ | ||
| /* sourceTalkback */ | ||
| 0] = signal[0]; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| n[0] = r[0]; | ||
| return 0; | ||
| } | ||
| }); | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (signal) { | ||
| state[ | ||
| /* sourceTalkback */ | ||
| 0]( | ||
| /* Close */ | ||
| 1); | ||
| return state[ | ||
| /* innerTalkback */ | ||
| 1]( | ||
| /* Close */ | ||
| 1); | ||
| } else if (!state[ | ||
| /* innerEnded */ | ||
| 3] && !state[ | ||
| /* sourceEnded */ | ||
| 2]) { | ||
| return state[ | ||
| /* innerTalkback */ | ||
| 1]( | ||
| /* Pull */ | ||
| 0); | ||
| } else if (state[ | ||
| /* sourceEnded */ | ||
| 2]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else { | ||
| return state[ | ||
| /* sourceTalkback */ | ||
| 0]( | ||
| /* Pull */ | ||
| 0); | ||
| } | ||
| }])); | ||
| return e( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| n[0](1); | ||
| return n[1](1); | ||
| } else if (!n[3] && !n[2]) { | ||
| return n[1](0); | ||
| } else if (n[2]) { | ||
| return 0; | ||
| } else { | ||
| return n[0](0); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| } | ||
| function forEach$1(f) { | ||
| return function (source) { | ||
| return captureTalkback(source, function (signal, talkback) { | ||
| if (typeof signal === "number") { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else if (signal.tag) { | ||
| _1(f, signal[0]); | ||
| return talkback( | ||
| /* Pull */ | ||
| 0); | ||
| function forEach$1(r) { | ||
| return function(e) { | ||
| return captureTalkback(e, function(e, n) { | ||
| if ("number" == typeof e) { | ||
| return 0; | ||
| } else if (e.tag) { | ||
| _1(r, e[0]); | ||
| return n(0); | ||
| } else { | ||
| return talkback( | ||
| /* Pull */ | ||
| 0); | ||
| return n(0); | ||
| } | ||
@@ -1969,50 +1070,27 @@ }); | ||
| function subscribe(f) { | ||
| return function (source) { | ||
| var talkback = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| talkbackPlaceholder]; | ||
| var ended = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| false]; | ||
| _1(source, function (signal) { | ||
| if (typeof signal === "number") { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else if (signal.tag) { | ||
| if (ended[0]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| function subscribe(r) { | ||
| return function(e) { | ||
| var n = [talkbackPlaceholder]; | ||
| var t = [!1]; | ||
| _1(e, function(e) { | ||
| if ("number" == typeof e) { | ||
| return 0; | ||
| } else if (e.tag) { | ||
| if (t[0]) { | ||
| return 0; | ||
| } else { | ||
| _1(f, signal[0]); | ||
| return talkback[0]( | ||
| /* Pull */ | ||
| 0); | ||
| _1(r, e[0]); | ||
| return n[0](0); | ||
| } | ||
| } else { | ||
| talkback[0] = signal[0]; | ||
| return talkback[0]( | ||
| /* Pull */ | ||
| 0); | ||
| n[0] = e[0]; | ||
| return n[0](0); | ||
| } | ||
| }); | ||
| return function (param) { | ||
| if (ended[0]) { | ||
| return function(r) { | ||
| if (t[0]) { | ||
| return 0; | ||
| } else { | ||
| ended[0] = true; | ||
| return talkback[0]( | ||
| /* Close */ | ||
| 1); | ||
| t[0] = !0; | ||
| return n[0](1); | ||
| } | ||
@@ -2023,203 +1101,142 @@ }; | ||
| var Types = 0; | ||
| /* No side effect */ | ||
| var e = 0; | ||
| function fromListener(addListener, removeListener) { | ||
| return function (sink) { | ||
| var handler = function ($$event) { | ||
| return sink( | ||
| /* Push */ | ||
| __(1, [$$event])); | ||
| function fromListener(r, e) { | ||
| return function(n) { | ||
| var t = function(r) { | ||
| return n(__(1, [r])); | ||
| }; | ||
| sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (signal) { | ||
| return _1(removeListener, handler); | ||
| } else { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } | ||
| }])); | ||
| return _1(addListener, handler); | ||
| n( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| return _1(e, t); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| return _1(r, t); | ||
| }; | ||
| } | ||
| function fromDomEvent(element, $$event) { | ||
| return function (sink) { | ||
| var addEventListener = function (element, event, handler) { | ||
| element.addEventListener(event, handler); | ||
| function fromDomEvent(r, e) { | ||
| return function(n) { | ||
| var t = function(r, e, n) { | ||
| r.addEventListener(e, n); | ||
| }; | ||
| var removeEventListener = function (element, event, handler) { | ||
| element.removeEventListener(event, handler); | ||
| var u = function(r, e, n) { | ||
| r.removeEventListener(e, n); | ||
| }; | ||
| return fromListener(function (handler) { | ||
| return _3(addEventListener, element, $$event, handler); | ||
| }, function (handler) { | ||
| return _3(removeEventListener, element, $$event, handler); | ||
| })(sink); | ||
| return fromListener( | ||
| function(n) { | ||
| return _3(t, r, e, n); | ||
| }, | ||
| function(n) { | ||
| return _3(u, r, e, n); | ||
| } | ||
| )(n); | ||
| }; | ||
| } | ||
| function interval(p) { | ||
| return function (sink) { | ||
| var i = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| 0]; | ||
| var id = setInterval(function (param) { | ||
| var num = i[0]; | ||
| i[0] = i[0] + 1 | 0; | ||
| return sink( | ||
| /* Push */ | ||
| __(1, [num])); | ||
| }, p); | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (signal) { | ||
| clearInterval(id); | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } | ||
| }])); | ||
| function interval(r) { | ||
| return function(e) { | ||
| var n = [0]; | ||
| var t = setInterval(function(r) { | ||
| var t = n[0]; | ||
| n[0] = (n[0] + 1) | 0; | ||
| return e(__(1, [t])); | ||
| }, r); | ||
| return e( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| clearInterval(t); | ||
| return 0; | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| } | ||
| function fromPromise(promise) { | ||
| return function (sink) { | ||
| var ended = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| false]; | ||
| promise.then(function (value) { | ||
| if (!ended[0]) { | ||
| sink( | ||
| /* Push */ | ||
| __(1, [value])); | ||
| sink( | ||
| /* End */ | ||
| 0); | ||
| function fromPromise(r) { | ||
| return function(e) { | ||
| var n = [!1]; | ||
| r.then(function(r) { | ||
| if (!n[0]) { | ||
| e(__(1, [r])); | ||
| e(0); | ||
| } | ||
| return Promise.resolve( | ||
| /* () */ | ||
| 0); | ||
| return Promise.resolve(0); | ||
| }); | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (signal) { | ||
| ended[0] = true; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } | ||
| }])); | ||
| return e( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| n[0] = !0; | ||
| return 0; | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| } | ||
| function debounce(debounceF) { | ||
| return function (source) { | ||
| return function (sink) { | ||
| var gotEndSignal = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| false]; | ||
| var id = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| undefined]; | ||
| var $$clearTimeout$1 = function (param) { | ||
| var match = id[0]; | ||
| if (match !== undefined) { | ||
| id[0] = undefined; | ||
| clearTimeout(valFromOption(match)); | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| function debounce(r) { | ||
| return function(e) { | ||
| return function(n) { | ||
| var t = [!1]; | ||
| var u = [void 0]; | ||
| var i = function(r) { | ||
| var e = u[0]; | ||
| if (void 0 !== e) { | ||
| u[0] = void 0; | ||
| clearTimeout(valFromOption(e)); | ||
| return 0; | ||
| } else { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| return 0; | ||
| } | ||
| }; | ||
| return _1(source, function (signal) { | ||
| if (typeof signal === "number") { | ||
| gotEndSignal[0] = true; | ||
| var match = id[0]; | ||
| if (match !== undefined) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| return _1(e, function(e) { | ||
| if ("number" == typeof e) { | ||
| t[0] = !0; | ||
| if (void 0 !== u[0]) { | ||
| return 0; | ||
| } else { | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| return n(0); | ||
| } | ||
| } else if (signal.tag) { | ||
| $$clearTimeout$1( | ||
| /* () */ | ||
| 0); | ||
| id[0] = some(setTimeout(function (param) { | ||
| id[0] = undefined; | ||
| sink(signal); | ||
| if (gotEndSignal[0]) { | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| }, _1(debounceF, signal[0]))); | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| } else if (e.tag) { | ||
| i(); | ||
| u[0] = some( | ||
| setTimeout(function(r) { | ||
| u[0] = void 0; | ||
| n(e); | ||
| if (t[0]) { | ||
| return n(0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| }, _1(r, e[0])) | ||
| ); | ||
| return 0; | ||
| } else { | ||
| var tb = signal[0]; | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (signal) { | ||
| $$clearTimeout$1( | ||
| /* () */ | ||
| 0); | ||
| return tb( | ||
| /* Close */ | ||
| 1); | ||
| } else { | ||
| return tb(signal); | ||
| } | ||
| }])); | ||
| var f = e[0]; | ||
| return n( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| i(); | ||
| return f(1); | ||
| } else { | ||
| return f(r); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| } | ||
@@ -2231,78 +1248,49 @@ }); | ||
| function throttle(throttleF) { | ||
| return function (source) { | ||
| return function (sink) { | ||
| var skip = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| false]; | ||
| var id = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| undefined]; | ||
| var $$clearTimeout$1 = function (param) { | ||
| var match = id[0]; | ||
| if (match !== undefined) { | ||
| clearTimeout(valFromOption(match)); | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| function throttle(r) { | ||
| return function(e) { | ||
| return function(n) { | ||
| var t = [!1]; | ||
| var u = [void 0]; | ||
| var i = function(r) { | ||
| var e = u[0]; | ||
| if (void 0 !== e) { | ||
| clearTimeout(valFromOption(e)); | ||
| return 0; | ||
| } else { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| return 0; | ||
| } | ||
| }; | ||
| return _1(source, function (signal) { | ||
| if (typeof signal === "number") { | ||
| $$clearTimeout$1( | ||
| /* () */ | ||
| 0); | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| } else if (signal.tag) { | ||
| if (skip[0]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| return _1(e, function(e) { | ||
| if ("number" == typeof e) { | ||
| i(); | ||
| return n(0); | ||
| } else if (e.tag) { | ||
| if (t[0]) { | ||
| return 0; | ||
| } else { | ||
| t[0] = !0; | ||
| i(); | ||
| u[0] = some( | ||
| setTimeout(function(r) { | ||
| u[0] = void 0; | ||
| t[0] = !1; | ||
| return 0; | ||
| }, _1(r, e[0])) | ||
| ); | ||
| } else { | ||
| skip[0] = true; | ||
| $$clearTimeout$1( | ||
| /* () */ | ||
| 0); | ||
| id[0] = some(setTimeout(function (param) { | ||
| id[0] = undefined; | ||
| skip[0] = false; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| }, _1(throttleF, signal[0]))); | ||
| return sink(signal); | ||
| return n(e); | ||
| } | ||
| } else { | ||
| var tb = signal[0]; | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (signal) { | ||
| $$clearTimeout$1( | ||
| /* () */ | ||
| 0); | ||
| return tb( | ||
| /* Close */ | ||
| 1); | ||
| } else { | ||
| return tb(signal); | ||
| } | ||
| }])); | ||
| var f = e[0]; | ||
| return n( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| i(); | ||
| return f(1); | ||
| } else { | ||
| return f(r); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| } | ||
@@ -2314,133 +1302,60 @@ }); | ||
| function sample(notifier) { | ||
| return function (source) { | ||
| return function (sink) { | ||
| var state = | ||
| /* record */ | ||
| [ | ||
| /* ended */ | ||
| false, | ||
| /* value */ | ||
| undefined, | ||
| /* sourceTalkback */ | ||
| function (param) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| }, | ||
| /* notifierTalkback */ | ||
| function (param) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| }]; | ||
| _1(source, function (signal) { | ||
| if (typeof signal === "number") { | ||
| state[ | ||
| /* ended */ | ||
| 0] = true; | ||
| state[ | ||
| /* notifierTalkback */ | ||
| 3]( | ||
| /* Close */ | ||
| 1); | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| } else if (signal.tag) { | ||
| state[ | ||
| /* value */ | ||
| 1] = some(signal[0]); | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| function sample(r) { | ||
| return function(e) { | ||
| return function(n) { | ||
| var t = [ | ||
| !1, | ||
| void 0, | ||
| function(r) { | ||
| return 0; | ||
| }, | ||
| function(r) { | ||
| return 0; | ||
| } | ||
| ]; | ||
| _1(e, function(r) { | ||
| if ("number" == typeof r) { | ||
| t[0] = !0; | ||
| t[3](1); | ||
| return n(0); | ||
| } else if (r.tag) { | ||
| t[1] = some(r[0]); | ||
| return 0; | ||
| } else { | ||
| state[ | ||
| /* sourceTalkback */ | ||
| 2] = signal[0]; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| t[2] = r[0]; | ||
| return 0; | ||
| } | ||
| }); | ||
| _1(notifier, function (signal) { | ||
| var match = state[ | ||
| /* value */ | ||
| 1]; | ||
| if (typeof signal === "number") { | ||
| state[ | ||
| /* ended */ | ||
| 0] = true; | ||
| state[ | ||
| /* sourceTalkback */ | ||
| 2]( | ||
| /* Close */ | ||
| 1); | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| } else if (signal.tag) { | ||
| if (match !== undefined && !state[ | ||
| /* ended */ | ||
| 0]) { | ||
| state[ | ||
| /* value */ | ||
| 1] = undefined; | ||
| return sink( | ||
| /* Push */ | ||
| __(1, [valFromOption(match)])); | ||
| _1(r, function(r) { | ||
| var e = t[1]; | ||
| if ("number" == typeof r) { | ||
| t[0] = !0; | ||
| t[2](1); | ||
| return n(0); | ||
| } else if (r.tag) { | ||
| if (void 0 !== e && !t[0]) { | ||
| t[1] = void 0; | ||
| return n(__(1, [valFromOption(e)])); | ||
| } else { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| return 0; | ||
| } | ||
| } else { | ||
| state[ | ||
| /* notifierTalkback */ | ||
| 3] = signal[0]; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| t[3] = r[0]; | ||
| return 0; | ||
| } | ||
| }); | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (signal) { | ||
| state[ | ||
| /* ended */ | ||
| 0] = true; | ||
| state[ | ||
| /* sourceTalkback */ | ||
| 2]( | ||
| /* Close */ | ||
| 1); | ||
| return state[ | ||
| /* notifierTalkback */ | ||
| 3]( | ||
| /* Close */ | ||
| 1); | ||
| } else { | ||
| state[ | ||
| /* sourceTalkback */ | ||
| 2]( | ||
| /* Pull */ | ||
| 0); | ||
| return state[ | ||
| /* notifierTalkback */ | ||
| 3]( | ||
| /* Pull */ | ||
| 0); | ||
| } | ||
| }])); | ||
| return n( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| t[0] = !0; | ||
| t[2](1); | ||
| return t[3](1); | ||
| } else { | ||
| t[2](0); | ||
| return t[3](0); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
@@ -2450,107 +1365,88 @@ }; | ||
| function delay(wait) { | ||
| return function (source) { | ||
| return function (sink) { | ||
| var state = | ||
| /* record */ | ||
| [ | ||
| /* talkback */ | ||
| talkbackPlaceholder, | ||
| /* active */ | ||
| 0, | ||
| /* gotEndSignal */ | ||
| false]; | ||
| _1(source, function (signal) { | ||
| var exit = 0; | ||
| if (typeof signal === "number" || signal.tag) { | ||
| exit = 1; | ||
| function delay(r) { | ||
| return function(e) { | ||
| return function(n) { | ||
| var t = [talkbackPlaceholder, 0, !1]; | ||
| _1(e, function(e) { | ||
| var u = 0; | ||
| if ("number" == typeof e || e.tag) { | ||
| u = 1; | ||
| } else { | ||
| state[ | ||
| /* talkback */ | ||
| 0] = signal[0]; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| t[0] = e[0]; | ||
| return 0; | ||
| } | ||
| if (exit === 1) { | ||
| if (state[ | ||
| /* gotEndSignal */ | ||
| 2]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| if (1 === u) { | ||
| if (t[2]) { | ||
| return 0; | ||
| } else { | ||
| state[ | ||
| /* active */ | ||
| 1] = state[ | ||
| /* active */ | ||
| 1] + 1 | 0; | ||
| setTimeout(function (param) { | ||
| if (state[ | ||
| /* gotEndSignal */ | ||
| 2] && state[ | ||
| /* active */ | ||
| 1] === 0) { | ||
| sink( | ||
| /* End */ | ||
| 0); | ||
| t[1] = (t[1] + 1) | 0; | ||
| setTimeout(function(r) { | ||
| if (t[2] && 0 === t[1]) { | ||
| n(0); | ||
| } else { | ||
| state[ | ||
| /* active */ | ||
| 1] = state[ | ||
| /* active */ | ||
| 1] - 1 | 0; | ||
| t[1] = (t[1] - 1) | 0; | ||
| } | ||
| return sink(signal); | ||
| }, wait); | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| return n(e); | ||
| }, r); | ||
| return 0; | ||
| } | ||
| } | ||
| }); | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (signal) { | ||
| state[ | ||
| /* gotEndSignal */ | ||
| 2] = true; | ||
| if (state[ | ||
| /* active */ | ||
| 1] === 0) { | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| } else { | ||
| return 0; | ||
| return n( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| t[2] = !0; | ||
| if (0 === t[1]) { | ||
| return n(0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else if (t[2]) { | ||
| return 0; | ||
| } else { | ||
| return t[0](r); | ||
| } | ||
| } | ||
| } else if (state[ | ||
| /* gotEndSignal */ | ||
| 2]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else { | ||
| return state[ | ||
| /* talkback */ | ||
| 0](signal); | ||
| } | ||
| }])); | ||
| ]) | ||
| ); | ||
| }; | ||
| }; | ||
| } | ||
| /* No side effect */ | ||
| export { pipe, Types, makeSubject, make$2 as make, fromList, fromArray, fromValue, empty, never, map$1 as map, filter, scan, merge, concat$1 as concat, share, combine, take, takeLast, takeWhile, takeUntil, skip, skipWhile, skipUntil, flatten, forEach$1 as forEach, subscribe, fromListener, fromDomEvent, interval, fromPromise, debounce, throttle, sample, delay }; | ||
| //# sourceMappingURL=wonka.es.js.map | ||
| export { | ||
| pipe, | ||
| e as Types, | ||
| makeSubject, | ||
| make$2 as make, | ||
| fromList, | ||
| fromArray, | ||
| fromValue, | ||
| empty, | ||
| never, | ||
| map$1 as map, | ||
| filter, | ||
| scan, | ||
| merge, | ||
| concat$1 as concat, | ||
| share, | ||
| combine, | ||
| take, | ||
| takeLast, | ||
| takeWhile, | ||
| takeUntil, | ||
| skip, | ||
| skipWhile, | ||
| skipUntil, | ||
| flatten, | ||
| forEach$1 as forEach, | ||
| subscribe, | ||
| fromListener, | ||
| fromDomEvent, | ||
| interval, | ||
| fromPromise, | ||
| debounce, | ||
| throttle, | ||
| sample, | ||
| delay | ||
| }; |
3264
dist/wonka.js
@@ -1,78 +0,39 @@ | ||
| function pipe(source) { | ||
| var args = arguments; | ||
| var len = args.length; | ||
| var x = source; | ||
| for (var i = 1; i < len; i++) { | ||
| x = args[i](x); | ||
| function pipe(r) { | ||
| var e = arguments; | ||
| var n = e.length; | ||
| var t = r; | ||
| for (var u = 1; u < n; u++) { | ||
| t = e[u](t); | ||
| } | ||
| return x; | ||
| return t; | ||
| } | ||
| function __(tag, block) { | ||
| block.tag = tag; | ||
| return block; | ||
| function __(r, e) { | ||
| e.tag = r; | ||
| return e; | ||
| } | ||
| /* No side effect */ | ||
| var out_of_memory = /* tuple */[ | ||
| "Out_of_memory", | ||
| 0 | ||
| ]; | ||
| var out_of_memory = ["Out_of_memory", 0]; | ||
| var sys_error = /* tuple */[ | ||
| "Sys_error", | ||
| -1 | ||
| ]; | ||
| var sys_error = ["Sys_error", -1]; | ||
| var failure = /* tuple */[ | ||
| "Failure", | ||
| -2 | ||
| ]; | ||
| var failure = ["Failure", -2]; | ||
| var invalid_argument = /* tuple */[ | ||
| "Invalid_argument", | ||
| -3 | ||
| ]; | ||
| var invalid_argument = ["Invalid_argument", -3]; | ||
| var end_of_file = /* tuple */[ | ||
| "End_of_file", | ||
| -4 | ||
| ]; | ||
| var end_of_file = ["End_of_file", -4]; | ||
| var division_by_zero = /* tuple */[ | ||
| "Division_by_zero", | ||
| -5 | ||
| ]; | ||
| var division_by_zero = ["Division_by_zero", -5]; | ||
| var not_found = /* tuple */[ | ||
| "Not_found", | ||
| -6 | ||
| ]; | ||
| var not_found = ["Not_found", -6]; | ||
| var match_failure = /* tuple */[ | ||
| "Match_failure", | ||
| -7 | ||
| ]; | ||
| var match_failure = ["Match_failure", -7]; | ||
| var stack_overflow = /* tuple */[ | ||
| "Stack_overflow", | ||
| -8 | ||
| ]; | ||
| var stack_overflow = ["Stack_overflow", -8]; | ||
| var sys_blocked_io = /* tuple */[ | ||
| "Sys_blocked_io", | ||
| -9 | ||
| ]; | ||
| var sys_blocked_io = ["Sys_blocked_io", -9]; | ||
| var assert_failure = /* tuple */[ | ||
| "Assert_failure", | ||
| -10 | ||
| ]; | ||
| var assert_failure = ["Assert_failure", -10]; | ||
| var undefined_recursive_module = /* tuple */[ | ||
| "Undefined_recursive_module", | ||
| -11 | ||
| ]; | ||
| var undefined_recursive_module = ["Undefined_recursive_module", -11]; | ||
@@ -102,686 +63,447 @@ out_of_memory.tag = 248; | ||
| undefined_recursive_module.tag = 248; | ||
| /* Not a pure module */ | ||
| function caml_array_sub(x, offset, len) { | ||
| var result = new Array(len); | ||
| var j = 0; | ||
| var i = offset; | ||
| while(j < len) { | ||
| result[j] = x[i]; | ||
| j = j + 1 | 0; | ||
| i = i + 1 | 0; | ||
| } return result; | ||
| function caml_array_sub(r, e, n) { | ||
| var t = new Array(n); | ||
| var u = 0; | ||
| var i = e; | ||
| while (u < n) { | ||
| t[u] = r[i]; | ||
| u = (u + 1) | 0; | ||
| i = (i + 1) | 0; | ||
| } | ||
| return t; | ||
| } | ||
| /* No side effect */ | ||
| function app(_f, _args) { | ||
| while(true) { | ||
| var args = _args; | ||
| var f = _f; | ||
| var arity = f.length; | ||
| var len = args.length; | ||
| var d = arity - len | 0; | ||
| if (d === 0) { | ||
| return f.apply(null, args); | ||
| } else if (d < 0) { | ||
| _args = caml_array_sub(args, arity, -d | 0); | ||
| _f = f.apply(null, caml_array_sub(args, 0, arity)); | ||
| continue ; | ||
| function app(r, e) { | ||
| while (1) { | ||
| var n = e; | ||
| var t = r; | ||
| var u = t.length; | ||
| var i = (u - n.length) | 0; | ||
| if (0 === i) { | ||
| return t.apply(null, n); | ||
| } else if (i < 0) { | ||
| e = caml_array_sub(n, u, 0 | -i); | ||
| r = t.apply(null, caml_array_sub(n, 0, u)); | ||
| continue; | ||
| } else { | ||
| return (function(f,args){ | ||
| return function (x) { | ||
| return app(f, args.concat(/* array */[x])); | ||
| } | ||
| }(f,args)); | ||
| return (function(r, e) { | ||
| return function(n) { | ||
| return app(r, e.concat([n])); | ||
| }; | ||
| })(t, n); | ||
| } | ||
| }} | ||
| } | ||
| } | ||
| function curry_1(o, a0, arity) { | ||
| switch (arity) { | ||
| case 1 : | ||
| return o(a0); | ||
| case 2 : | ||
| return (function (param) { | ||
| return o(a0, param); | ||
| }); | ||
| case 3 : | ||
| return (function (param, param$1) { | ||
| return o(a0, param, param$1); | ||
| }); | ||
| case 4 : | ||
| return (function (param, param$1, param$2) { | ||
| return o(a0, param, param$1, param$2); | ||
| }); | ||
| case 5 : | ||
| return (function (param, param$1, param$2, param$3) { | ||
| return o(a0, param, param$1, param$2, param$3); | ||
| }); | ||
| case 6 : | ||
| return (function (param, param$1, param$2, param$3, param$4) { | ||
| return o(a0, param, param$1, param$2, param$3, param$4); | ||
| }); | ||
| case 7 : | ||
| return (function (param, param$1, param$2, param$3, param$4, param$5) { | ||
| return o(a0, param, param$1, param$2, param$3, param$4, param$5); | ||
| }); | ||
| function curry_1(r, e, n) { | ||
| switch (n) { | ||
| case 1: | ||
| return r(e); | ||
| case 2: | ||
| return function(n) { | ||
| return r(e, n); | ||
| }; | ||
| case 3: | ||
| return function(n, t) { | ||
| return r(e, n, t); | ||
| }; | ||
| case 4: | ||
| return function(n, t, u) { | ||
| return r(e, n, t, u); | ||
| }; | ||
| case 5: | ||
| return function(n, t, u, i) { | ||
| return r(e, n, t, u, i); | ||
| }; | ||
| case 6: | ||
| return function(n, t, u, i, f) { | ||
| return r(e, n, t, u, i, f); | ||
| }; | ||
| case 7: | ||
| return function(n, t, u, i, f, o) { | ||
| return r(e, n, t, u, i, f, o); | ||
| }; | ||
| default: | ||
| return app(o, /* array */[a0]); | ||
| return app(r, [e]); | ||
| } | ||
| } | ||
| function _1(o, a0) { | ||
| var arity = o.length; | ||
| if (arity === 1) { | ||
| return o(a0); | ||
| function _1(r, e) { | ||
| var n = r.length; | ||
| if (1 === n) { | ||
| return r(e); | ||
| } else { | ||
| return curry_1(o, a0, arity); | ||
| return curry_1(r, e, n); | ||
| } | ||
| } | ||
| function curry_2(o, a0, a1, arity) { | ||
| switch (arity) { | ||
| case 1 : | ||
| return app(o(a0), /* array */[a1]); | ||
| case 2 : | ||
| return o(a0, a1); | ||
| case 3 : | ||
| return (function (param) { | ||
| return o(a0, a1, param); | ||
| }); | ||
| case 4 : | ||
| return (function (param, param$1) { | ||
| return o(a0, a1, param, param$1); | ||
| }); | ||
| case 5 : | ||
| return (function (param, param$1, param$2) { | ||
| return o(a0, a1, param, param$1, param$2); | ||
| }); | ||
| case 6 : | ||
| return (function (param, param$1, param$2, param$3) { | ||
| return o(a0, a1, param, param$1, param$2, param$3); | ||
| }); | ||
| case 7 : | ||
| return (function (param, param$1, param$2, param$3, param$4) { | ||
| return o(a0, a1, param, param$1, param$2, param$3, param$4); | ||
| }); | ||
| function curry_2(r, e, n, t) { | ||
| switch (t) { | ||
| case 1: | ||
| return app(r(e), [n]); | ||
| case 2: | ||
| return r(e, n); | ||
| case 3: | ||
| return function(t) { | ||
| return r(e, n, t); | ||
| }; | ||
| case 4: | ||
| return function(t, u) { | ||
| return r(e, n, t, u); | ||
| }; | ||
| case 5: | ||
| return function(t, u, i) { | ||
| return r(e, n, t, u, i); | ||
| }; | ||
| case 6: | ||
| return function(t, u, i, f) { | ||
| return r(e, n, t, u, i, f); | ||
| }; | ||
| case 7: | ||
| return function(t, u, i, f, o) { | ||
| return r(e, n, t, u, i, f, o); | ||
| }; | ||
| default: | ||
| return app(o, /* array */[ | ||
| a0, | ||
| a1 | ||
| ]); | ||
| return app(r, [e, n]); | ||
| } | ||
| } | ||
| function _2(o, a0, a1) { | ||
| var arity = o.length; | ||
| if (arity === 2) { | ||
| return o(a0, a1); | ||
| function _2(r, e, n) { | ||
| var t = r.length; | ||
| if (2 === t) { | ||
| return r(e, n); | ||
| } else { | ||
| return curry_2(o, a0, a1, arity); | ||
| return curry_2(r, e, n, t); | ||
| } | ||
| } | ||
| function curry_3(o, a0, a1, a2, arity) { | ||
| switch (arity) { | ||
| case 1 : | ||
| return app(o(a0), /* array */[ | ||
| a1, | ||
| a2 | ||
| ]); | ||
| case 2 : | ||
| return app(o(a0, a1), /* array */[a2]); | ||
| case 3 : | ||
| return o(a0, a1, a2); | ||
| case 4 : | ||
| return (function (param) { | ||
| return o(a0, a1, a2, param); | ||
| }); | ||
| case 5 : | ||
| return (function (param, param$1) { | ||
| return o(a0, a1, a2, param, param$1); | ||
| }); | ||
| case 6 : | ||
| return (function (param, param$1, param$2) { | ||
| return o(a0, a1, a2, param, param$1, param$2); | ||
| }); | ||
| case 7 : | ||
| return (function (param, param$1, param$2, param$3) { | ||
| return o(a0, a1, a2, param, param$1, param$2, param$3); | ||
| }); | ||
| function curry_3(r, e, n, t, u) { | ||
| switch (u) { | ||
| case 1: | ||
| return app(r(e), [n, t]); | ||
| case 2: | ||
| return app(r(e, n), [t]); | ||
| case 3: | ||
| return r(e, n, t); | ||
| case 4: | ||
| return function(u) { | ||
| return r(e, n, t, u); | ||
| }; | ||
| case 5: | ||
| return function(u, i) { | ||
| return r(e, n, t, u, i); | ||
| }; | ||
| case 6: | ||
| return function(u, i, f) { | ||
| return r(e, n, t, u, i, f); | ||
| }; | ||
| case 7: | ||
| return function(u, i, f, o) { | ||
| return r(e, n, t, u, i, f, o); | ||
| }; | ||
| default: | ||
| return app(o, /* array */[ | ||
| a0, | ||
| a1, | ||
| a2 | ||
| ]); | ||
| return app(r, [e, n, t]); | ||
| } | ||
| } | ||
| function _3(o, a0, a1, a2) { | ||
| var arity = o.length; | ||
| if (arity === 3) { | ||
| return o(a0, a1, a2); | ||
| function _3(r, e, n, t) { | ||
| var u = r.length; | ||
| if (3 === u) { | ||
| return r(e, n, t); | ||
| } else { | ||
| return curry_3(o, a0, a1, a2, arity); | ||
| return curry_3(r, e, n, t, u); | ||
| } | ||
| } | ||
| /* No side effect */ | ||
| /* No side effect */ | ||
| var undefinedHeader = []; | ||
| /* No side effect */ | ||
| var undefinedHeader = /* array */[]; | ||
| function some(x) { | ||
| if (x === undefined) { | ||
| var block = /* tuple */[ | ||
| undefinedHeader, | ||
| 0 | ||
| ]; | ||
| block.tag = 256; | ||
| return block; | ||
| } else if (x !== null && x[0] === undefinedHeader) { | ||
| var nid = x[1] + 1 | 0; | ||
| var block$1 = /* tuple */[ | ||
| undefinedHeader, | ||
| nid | ||
| ]; | ||
| block$1.tag = 256; | ||
| return block$1; | ||
| function some(r) { | ||
| if (void 0 === r) { | ||
| var e = [undefinedHeader, 0]; | ||
| e.tag = 256; | ||
| return e; | ||
| } else if (null !== r && r[0] === undefinedHeader) { | ||
| var n = (r[1] + 1) | 0; | ||
| var t = [undefinedHeader, n]; | ||
| t.tag = 256; | ||
| return t; | ||
| } else { | ||
| return x; | ||
| return r; | ||
| } | ||
| } | ||
| function valFromOption(x) { | ||
| if (x !== null && x[0] === undefinedHeader) { | ||
| var depth = x[1]; | ||
| if (depth === 0) { | ||
| return undefined; | ||
| function valFromOption(r) { | ||
| if (null !== r && r[0] === undefinedHeader) { | ||
| var e = r[1]; | ||
| if (0 === e) { | ||
| return; | ||
| } else { | ||
| return /* tuple */[ | ||
| undefinedHeader, | ||
| depth - 1 | 0 | ||
| ]; | ||
| return [undefinedHeader, (e - 1) | 0]; | ||
| } | ||
| } else { | ||
| return x; | ||
| return r; | ||
| } | ||
| } | ||
| /* No side effect */ | ||
| /* No side effect */ | ||
| /* No side effect */ | ||
| function make$1(len, vals) { | ||
| var res = new Array(len); | ||
| res.fill(vals); | ||
| return res; | ||
| function make$1(r, e) { | ||
| var n = new Array(r); | ||
| n.fill(e); | ||
| return n; | ||
| } | ||
| /* No side effect */ | ||
| function talkbackPlaceholder(param) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| function talkbackPlaceholder(r) { | ||
| return 0; | ||
| } | ||
| function captureTalkback(source, sinkWithTalkback) { | ||
| var talkback = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| talkbackPlaceholder]; | ||
| return _1(source, function (signal) { | ||
| if (typeof signal !== "number") { | ||
| if (!signal.tag) { | ||
| talkback[0] = signal[0]; | ||
| function captureTalkback(r, e) { | ||
| var n = [talkbackPlaceholder]; | ||
| return _1(r, function(r) { | ||
| if ("number" != typeof r) { | ||
| if (!r.tag) { | ||
| n[0] = r[0]; | ||
| } | ||
| } | ||
| return sinkWithTalkback(signal, talkback[0]); | ||
| return e(r, n[0]); | ||
| }); | ||
| } | ||
| function makeTrampoline(sink, f) { | ||
| var state = | ||
| /* record */ | ||
| [ | ||
| /* exhausted */ | ||
| false, | ||
| /* inLoop */ | ||
| false, | ||
| /* gotSignal */ | ||
| false]; | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| var match = state[ | ||
| /* exhausted */ | ||
| 0]; | ||
| if (signal || match) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else { | ||
| state[ | ||
| /* gotSignal */ | ||
| 2] = true; | ||
| if (state[ | ||
| /* inLoop */ | ||
| 1]) { | ||
| return 0; | ||
| } else { | ||
| var explode = function (_param) { | ||
| while (true) { | ||
| var match = f(); | ||
| if (match !== undefined) { | ||
| state[ | ||
| /* gotSignal */ | ||
| 2] = false; | ||
| sink( | ||
| /* Push */ | ||
| __(1, [valFromOption(match)])); | ||
| if (state[ | ||
| /* gotSignal */ | ||
| 2]) { | ||
| _param = | ||
| /* () */ | ||
| 0; | ||
| continue; | ||
| } else { | ||
| return 0; | ||
| function makeTrampoline(r, e) { | ||
| var n = [!1, !1, !1]; | ||
| return r( | ||
| __(0, [ | ||
| function(t) { | ||
| var u = n[0]; | ||
| if (t || u) { | ||
| return 0; | ||
| } else { | ||
| n[2] = !0; | ||
| if (n[1]) { | ||
| return 0; | ||
| } else { | ||
| n[1] = !0; | ||
| !(function(t) { | ||
| while (1) { | ||
| var u = e(); | ||
| if (void 0 !== u) { | ||
| n[2] = !1; | ||
| r(__(1, [valFromOption(u)])); | ||
| if (n[2]) { | ||
| continue; | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else { | ||
| n[0] = !0; | ||
| return r(0); | ||
| } | ||
| } | ||
| } else { | ||
| state[ | ||
| /* exhausted */ | ||
| 0] = true; | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| } | ||
| })(); | ||
| n[1] = !1; | ||
| return 0; | ||
| } | ||
| }; | ||
| state[ | ||
| /* inLoop */ | ||
| 1] = true; | ||
| explode( | ||
| /* () */ | ||
| 0); | ||
| state[ | ||
| /* inLoop */ | ||
| 1] = false; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } | ||
| } | ||
| } | ||
| }])); | ||
| ]) | ||
| ); | ||
| } | ||
| /* No side effect */ | ||
| function makeSubject(param) { | ||
| var state = | ||
| /* record */ | ||
| [ | ||
| /* sinks */ | ||
| new Array(), | ||
| /* ended */ | ||
| false]; | ||
| var source = function (sink) { | ||
| state[ | ||
| /* sinks */ | ||
| 0] = state[ | ||
| /* sinks */ | ||
| 0].concat(sink); | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (signal === | ||
| /* Close */ | ||
| 1) { | ||
| state[ | ||
| /* sinks */ | ||
| 0] = state[ | ||
| /* sinks */ | ||
| 0].filter(function (x) { | ||
| return x !== sink; | ||
| function makeSubject(r) { | ||
| var e = [new Array(), !1]; | ||
| return [ | ||
| function(r) { | ||
| e[0] = e[0].concat(r); | ||
| return r( | ||
| __(0, [ | ||
| function(n) { | ||
| if (1 === n) { | ||
| e[0] = e[0].filter(function(e) { | ||
| return e !== r; | ||
| }); | ||
| return 0; | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }, | ||
| function(r) { | ||
| if (e[1]) { | ||
| return 0; | ||
| } else { | ||
| e[0].forEach(function(e) { | ||
| return e(__(1, [r])); | ||
| }); | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| return 0; | ||
| } | ||
| }, | ||
| function(r) { | ||
| if (e[1]) { | ||
| return 0; | ||
| } else { | ||
| e[1] = !0; | ||
| e[0].forEach(function(r) { | ||
| return r(0); | ||
| }); | ||
| return 0; | ||
| } | ||
| }])); | ||
| }; | ||
| var next = function (value) { | ||
| if (state[ | ||
| /* ended */ | ||
| 1]) { | ||
| return 0; | ||
| } else { | ||
| state[ | ||
| /* sinks */ | ||
| 0].forEach(function (sink) { | ||
| return sink( | ||
| /* Push */ | ||
| __(1, [value])); | ||
| }); | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } | ||
| }; | ||
| var complete = function (param) { | ||
| if (state[ | ||
| /* ended */ | ||
| 1]) { | ||
| return 0; | ||
| } else { | ||
| state[ | ||
| /* ended */ | ||
| 1] = true; | ||
| state[ | ||
| /* sinks */ | ||
| 0].forEach(function (sink) { | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| }); | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } | ||
| }; | ||
| return ( | ||
| /* record */ | ||
| [ | ||
| /* source */ | ||
| source, | ||
| /* next */ | ||
| next, | ||
| /* complete */ | ||
| complete] | ||
| ); | ||
| ]; | ||
| } | ||
| function make$2(f) { | ||
| return function (sink) { | ||
| var teardown = _1(f, | ||
| /* record */ | ||
| [ | ||
| /* next */ | ||
| function (value) { | ||
| return sink( | ||
| /* Push */ | ||
| __(1, [value])); | ||
| }, | ||
| /* complete */ | ||
| function (param) { | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| }]); | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (signal) { | ||
| return _1(teardown, | ||
| /* () */ | ||
| 0); | ||
| } else { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| function make$2(r) { | ||
| return function(e) { | ||
| var n = _1(r, [ | ||
| function(r) { | ||
| return e(__(1, [r])); | ||
| }, | ||
| function(r) { | ||
| return e(0); | ||
| } | ||
| }])); | ||
| ]); | ||
| return e( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| return _1(n, 0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| } | ||
| function fromList(ls) { | ||
| return function (sink) { | ||
| var state = | ||
| /* record */ | ||
| [ | ||
| /* value */ | ||
| ls, | ||
| /* ended */ | ||
| false, | ||
| /* looping */ | ||
| false, | ||
| /* pull */ | ||
| false]; | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| var match = state[ | ||
| /* looping */ | ||
| 2]; | ||
| if (signal) { | ||
| state[ | ||
| /* ended */ | ||
| 1] = true; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else if (match) { | ||
| state[ | ||
| /* pull */ | ||
| 3] = true; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else { | ||
| state[ | ||
| /* pull */ | ||
| 3] = true; | ||
| state[ | ||
| /* looping */ | ||
| 2] = true; | ||
| while (state[ | ||
| /* pull */ | ||
| 3] && !state[ | ||
| /* ended */ | ||
| 1]) { | ||
| var match$1 = state[ | ||
| /* value */ | ||
| 0]; | ||
| if (match$1) { | ||
| state[ | ||
| /* value */ | ||
| 0] = match$1[1]; | ||
| state[ | ||
| /* pull */ | ||
| 3] = false; | ||
| sink( | ||
| /* Push */ | ||
| __(1, [match$1[0]])); | ||
| function fromList(r) { | ||
| return function(e) { | ||
| var n = [r, !1, !1, !1]; | ||
| return e( | ||
| __(0, [ | ||
| function(r) { | ||
| var t = n[2]; | ||
| if (r) { | ||
| n[1] = !0; | ||
| return 0; | ||
| } else if (t) { | ||
| n[3] = !0; | ||
| return 0; | ||
| } else { | ||
| state[ | ||
| /* ended */ | ||
| 1] = true; | ||
| sink( | ||
| /* End */ | ||
| 0); | ||
| n[3] = !0; | ||
| n[2] = !0; | ||
| while (n[3] && !n[1]) { | ||
| var u = n[0]; | ||
| if (u) { | ||
| n[0] = u[1]; | ||
| n[3] = !1; | ||
| e(__(1, [u[0]])); | ||
| } else { | ||
| n[1] = !0; | ||
| e(0); | ||
| } | ||
| } | ||
| n[2] = !1; | ||
| return 0; | ||
| } | ||
| } | ||
| state[ | ||
| /* looping */ | ||
| 2] = false; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } | ||
| }])); | ||
| ]) | ||
| ); | ||
| }; | ||
| } | ||
| function fromArray(arr) { | ||
| return function (sink) { | ||
| var size = arr.length; | ||
| var state = | ||
| /* record */ | ||
| [ | ||
| /* index */ | ||
| 0, | ||
| /* ended */ | ||
| false, | ||
| /* looping */ | ||
| false, | ||
| /* pull */ | ||
| false]; | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| var match = state[ | ||
| /* looping */ | ||
| 2]; | ||
| if (signal) { | ||
| state[ | ||
| /* ended */ | ||
| 1] = true; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else if (match) { | ||
| state[ | ||
| /* pull */ | ||
| 3] = true; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else { | ||
| state[ | ||
| /* pull */ | ||
| 3] = true; | ||
| state[ | ||
| /* looping */ | ||
| 2] = true; | ||
| while (state[ | ||
| /* pull */ | ||
| 3] && !state[ | ||
| /* ended */ | ||
| 1]) { | ||
| var index = state[ | ||
| /* index */ | ||
| 0]; | ||
| if (index < size) { | ||
| var x = arr[index]; | ||
| state[ | ||
| /* index */ | ||
| 0] = index + 1 | 0; | ||
| state[ | ||
| /* pull */ | ||
| 3] = false; | ||
| sink( | ||
| /* Push */ | ||
| __(1, [x])); | ||
| function fromArray(r) { | ||
| return function(e) { | ||
| var n = r.length; | ||
| var t = [0, !1, !1, !1]; | ||
| return e( | ||
| __(0, [ | ||
| function(u) { | ||
| var i = t[2]; | ||
| if (u) { | ||
| t[1] = !0; | ||
| return 0; | ||
| } else if (i) { | ||
| t[3] = !0; | ||
| return 0; | ||
| } else { | ||
| state[ | ||
| /* ended */ | ||
| 1] = true; | ||
| sink( | ||
| /* End */ | ||
| 0); | ||
| t[3] = !0; | ||
| t[2] = !0; | ||
| while (t[3] && !t[1]) { | ||
| var f = t[0]; | ||
| if (f < n) { | ||
| var o = r[f]; | ||
| t[0] = (f + 1) | 0; | ||
| t[3] = !1; | ||
| e(__(1, [o])); | ||
| } else { | ||
| t[1] = !0; | ||
| e(0); | ||
| } | ||
| } | ||
| t[2] = !1; | ||
| return 0; | ||
| } | ||
| } | ||
| state[ | ||
| /* looping */ | ||
| 2] = false; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } | ||
| }])); | ||
| ]) | ||
| ); | ||
| }; | ||
| } | ||
| function fromValue(x) { | ||
| return function (sink) { | ||
| var ended = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| false]; | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (signal || ended[0]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else { | ||
| ended[0] = true; | ||
| sink( | ||
| /* Push */ | ||
| __(1, [x])); | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| } | ||
| }])); | ||
| function fromValue(r) { | ||
| return function(e) { | ||
| var n = [!1]; | ||
| return e( | ||
| __(0, [ | ||
| function(t) { | ||
| if (t || n[0]) { | ||
| return 0; | ||
| } else { | ||
| n[0] = !0; | ||
| e(__(1, [r])); | ||
| return e(0); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| } | ||
| function empty(sink) { | ||
| sink( | ||
| /* Start */ | ||
| __(0, [talkbackPlaceholder])); | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| function empty(r) { | ||
| r(__(0, [talkbackPlaceholder])); | ||
| return r(0); | ||
| } | ||
| function never(sink) { | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [talkbackPlaceholder])); | ||
| function never(r) { | ||
| return r(__(0, [talkbackPlaceholder])); | ||
| } | ||
| function map$1(f) { | ||
| return function (source) { | ||
| return function (sink) { | ||
| return _1(source, function (signal) { | ||
| var tmp; | ||
| tmp = typeof signal === "number" ? | ||
| /* End */ | ||
| 0 : signal.tag ? | ||
| /* Push */ | ||
| __(1, [_1(f, signal[0])]) : | ||
| /* Start */ | ||
| __(0, [signal[0]]); | ||
| return sink(tmp); | ||
| function map$1(r) { | ||
| return function(e) { | ||
| return function(n) { | ||
| return _1(e, function(e) { | ||
| var t; | ||
| t = "number" == typeof e ? 0 : e.tag ? __(1, [_1(r, e[0])]) : __(0, [e[0]]); | ||
| return n(t); | ||
| }); | ||
@@ -792,12 +514,10 @@ }; | ||
| function filter(f) { | ||
| return function (source) { | ||
| return function (sink) { | ||
| return captureTalkback(source, function (signal, talkback) { | ||
| if (typeof signal === "number" || !(signal.tag && !_1(f, signal[0]))) { | ||
| return sink(signal); | ||
| function filter(r) { | ||
| return function(e) { | ||
| return function(n) { | ||
| return captureTalkback(e, function(e, t) { | ||
| if ("number" == typeof e || !e.tag || _1(r, e[0])) { | ||
| return n(e); | ||
| } else { | ||
| return talkback( | ||
| /* Pull */ | ||
| 0); | ||
| return t(0); | ||
| } | ||
@@ -809,29 +529,17 @@ }); | ||
| function scan(f, seed) { | ||
| return function (source) { | ||
| return function (sink) { | ||
| var acc = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| seed]; | ||
| return _1(source, function (signal) { | ||
| var tmp; | ||
| if (typeof signal === "number") { | ||
| tmp = | ||
| /* End */ | ||
| 0; | ||
| } else if (signal.tag) { | ||
| acc[0] = _2(f, acc[0], signal[0]); | ||
| tmp = | ||
| /* Push */ | ||
| __(1, [acc[0]]); | ||
| function scan(r, e) { | ||
| return function(n) { | ||
| return function(t) { | ||
| var u = [e]; | ||
| return _1(n, function(e) { | ||
| var n; | ||
| if ("number" == typeof e) { | ||
| n = 0; | ||
| } else if (e.tag) { | ||
| u[0] = _2(r, u[0], e[0]); | ||
| n = __(1, [u[0]]); | ||
| } else { | ||
| tmp = | ||
| /* Start */ | ||
| __(0, [signal[0]]); | ||
| n = __(0, [e[0]]); | ||
| } | ||
| return sink(tmp); | ||
| return t(n); | ||
| }); | ||
@@ -842,23 +550,14 @@ }; | ||
| function merge(sources) { | ||
| return function (sink) { | ||
| var size = sources.length; | ||
| var talkbacks = make$1(size, talkbackPlaceholder); | ||
| var state = | ||
| /* record */ | ||
| [ | ||
| /* started */ | ||
| 0, | ||
| /* ended */ | ||
| 0]; | ||
| var talkback = function (signal) { | ||
| var _i = 0; | ||
| while (true) { | ||
| var i = _i; | ||
| if (i < size) { | ||
| talkbacks[i](signal); | ||
| _i = i + 1 | 0; | ||
| function merge(r) { | ||
| return function(e) { | ||
| var n = r.length; | ||
| var t = make$1(n, talkbackPlaceholder); | ||
| var u = [0, 0]; | ||
| var i = function(r) { | ||
| var e = 0; | ||
| while (1) { | ||
| var u = e; | ||
| if (u < n) { | ||
| t[u](r); | ||
| e = (u + 1) | 0; | ||
| continue; | ||
@@ -870,53 +569,32 @@ } else { | ||
| }; | ||
| var _i = 0; | ||
| while (true) { | ||
| var i = _i; | ||
| if (i < size) { | ||
| var source = sources[i]; | ||
| _1(source, function (i) { | ||
| return function (signal) { | ||
| if (typeof signal === "number") { | ||
| state[ | ||
| /* ended */ | ||
| 1] = state[ | ||
| /* ended */ | ||
| 1] + 1 | 0; | ||
| if (state[ | ||
| /* ended */ | ||
| 1] === size) { | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| var f = 0; | ||
| while (1) { | ||
| var o = f; | ||
| if (o < n) { | ||
| _1( | ||
| r[o], | ||
| (function(r) { | ||
| return function(f) { | ||
| if ("number" == typeof f) { | ||
| u[1] = (u[1] + 1) | 0; | ||
| if (u[1] === n) { | ||
| return e(0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else if (f.tag) { | ||
| return e(f); | ||
| } else { | ||
| return 0; | ||
| t[r] = f[0]; | ||
| u[0] = (u[0] + 1) | 0; | ||
| if (u[0] === n) { | ||
| return e(__(0, [i])); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| } else if (signal.tag) { | ||
| return sink(signal); | ||
| } else { | ||
| talkbacks[i] = signal[0]; | ||
| state[ | ||
| /* started */ | ||
| 0] = state[ | ||
| /* started */ | ||
| 0] + 1 | 0; | ||
| if (state[ | ||
| /* started */ | ||
| 0] === size) { | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [talkback])); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| }; | ||
| }(i)); | ||
| _i = i + 1 | 0; | ||
| }; | ||
| })(o) | ||
| ); | ||
| f = (o + 1) | 0; | ||
| continue; | ||
@@ -930,423 +608,192 @@ } else { | ||
| function concat$1(sources) { | ||
| return function (sink) { | ||
| var size = sources.length; | ||
| var talkback = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| talkbackPlaceholder]; | ||
| var nextSource = function (i) { | ||
| if (i < size) { | ||
| var source = sources[i]; | ||
| return _1(source, function (signal) { | ||
| if (typeof signal === "number") { | ||
| return nextSource(i + 1 | 0); | ||
| } else if (signal.tag) { | ||
| return sink(signal); | ||
| function concat$1(r) { | ||
| return function(e) { | ||
| var n = r.length; | ||
| var t = [talkbackPlaceholder]; | ||
| var u = function(i) { | ||
| if (i < n) { | ||
| return _1(r[i], function(r) { | ||
| if ("number" == typeof r) { | ||
| return u((i + 1) | 0); | ||
| } else if (r.tag) { | ||
| return e(r); | ||
| } else { | ||
| var tb = signal[0]; | ||
| talkback[0] = tb; | ||
| if (i === 0) { | ||
| sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| return talkback[0](signal); | ||
| }])); | ||
| var n = r[0]; | ||
| t[0] = n; | ||
| if (0 === i) { | ||
| e( | ||
| __(0, [ | ||
| function(r) { | ||
| return t[0](r); | ||
| } | ||
| ]) | ||
| ); | ||
| } | ||
| return tb( | ||
| /* Pull */ | ||
| 0); | ||
| return n(0); | ||
| } | ||
| }); | ||
| } else { | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| return e(0); | ||
| } | ||
| }; | ||
| return nextSource(0); | ||
| return u(0); | ||
| }; | ||
| } | ||
| function share(source) { | ||
| var state = | ||
| /* record */ | ||
| [ | ||
| /* sinks */ | ||
| new Array(), | ||
| /* talkback */ | ||
| talkbackPlaceholder, | ||
| /* gotSignal */ | ||
| false]; | ||
| return function (sink) { | ||
| state[ | ||
| /* sinks */ | ||
| 0] = state[ | ||
| /* sinks */ | ||
| 0].concat(sink); | ||
| if (state[ | ||
| /* sinks */ | ||
| 0].length === 1) { | ||
| _1(source, function (signal) { | ||
| if (typeof signal === "number") { | ||
| state[ | ||
| /* sinks */ | ||
| 0].forEach(function (sink) { | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| function share(r) { | ||
| var e = [new Array(), talkbackPlaceholder, !1]; | ||
| return function(n) { | ||
| e[0] = e[0].concat(n); | ||
| if (1 === e[0].length) { | ||
| _1(r, function(r) { | ||
| if ("number" == typeof r) { | ||
| e[0].forEach(function(r) { | ||
| return r(0); | ||
| }); | ||
| state[ | ||
| /* sinks */ | ||
| 0] = new Array(); | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else if (signal.tag) { | ||
| state[ | ||
| /* gotSignal */ | ||
| 2] = false; | ||
| state[ | ||
| /* sinks */ | ||
| 0].forEach(function (sink) { | ||
| return sink(signal); | ||
| e[0] = new Array(); | ||
| return 0; | ||
| } else if (r.tag) { | ||
| e[2] = !1; | ||
| e[0].forEach(function(e) { | ||
| return e(r); | ||
| }); | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| return 0; | ||
| } else { | ||
| state[ | ||
| /* talkback */ | ||
| 1] = signal[0]; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| e[1] = r[0]; | ||
| return 0; | ||
| } | ||
| }); | ||
| } | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (signal) { | ||
| state[ | ||
| /* sinks */ | ||
| 0] = state[ | ||
| /* sinks */ | ||
| 0].filter(function (x) { | ||
| return x !== sink; | ||
| }); | ||
| if (state[ | ||
| /* sinks */ | ||
| 0].length === 0) { | ||
| return state[ | ||
| /* talkback */ | ||
| 1]( | ||
| /* Close */ | ||
| 1); | ||
| } else { | ||
| return 0; | ||
| return n( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| e[0] = e[0].filter(function(r) { | ||
| return r !== n; | ||
| }); | ||
| if (0 === e[0].length) { | ||
| return e[1](1); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else if (e[2]) { | ||
| return 0; | ||
| } else { | ||
| e[2] = !0; | ||
| return e[1](r); | ||
| } | ||
| } | ||
| } else if (state[ | ||
| /* gotSignal */ | ||
| 2]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else { | ||
| state[ | ||
| /* gotSignal */ | ||
| 2] = true; | ||
| return state[ | ||
| /* talkback */ | ||
| 1](signal); | ||
| } | ||
| }])); | ||
| ]) | ||
| ); | ||
| }; | ||
| } | ||
| function combine(sourceA, sourceB) { | ||
| return function (sink) { | ||
| var state = | ||
| /* record */ | ||
| [ | ||
| /* talkbackA */ | ||
| talkbackPlaceholder, | ||
| /* talkbackB */ | ||
| talkbackPlaceholder, | ||
| /* lastValA */ | ||
| undefined, | ||
| /* lastValB */ | ||
| undefined, | ||
| /* gotSignal */ | ||
| false, | ||
| /* endCounter */ | ||
| 0, | ||
| /* ended */ | ||
| false]; | ||
| _1(sourceA, function (signal) { | ||
| var match = state[ | ||
| /* lastValB */ | ||
| 3]; | ||
| if (typeof signal === "number") { | ||
| if (state[ | ||
| /* endCounter */ | ||
| 5] < 1) { | ||
| state[ | ||
| /* endCounter */ | ||
| 5] = state[ | ||
| /* endCounter */ | ||
| 5] + 1 | 0; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else if (state[ | ||
| /* ended */ | ||
| 6]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| function combine(r, e) { | ||
| return function(n) { | ||
| var t = [talkbackPlaceholder, talkbackPlaceholder, void 0, void 0, !1, 0, !1]; | ||
| _1(r, function(r) { | ||
| var e = t[3]; | ||
| if ("number" == typeof r) { | ||
| if (t[5] < 1) { | ||
| t[5] = (t[5] + 1) | 0; | ||
| return 0; | ||
| } else if (t[6]) { | ||
| return 0; | ||
| } else { | ||
| state[ | ||
| /* ended */ | ||
| 6] = true; | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| t[6] = !0; | ||
| return n(0); | ||
| } | ||
| } else if (signal.tag) { | ||
| var a = signal[0]; | ||
| if (match !== undefined) { | ||
| if (state[ | ||
| /* ended */ | ||
| 6]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else if (r.tag) { | ||
| var u = r[0]; | ||
| if (void 0 !== e) { | ||
| if (t[6]) { | ||
| return 0; | ||
| } else { | ||
| state[ | ||
| /* lastValA */ | ||
| 2] = some(a); | ||
| state[ | ||
| /* gotSignal */ | ||
| 4] = false; | ||
| return sink( | ||
| /* Push */ | ||
| __(1, [ | ||
| /* tuple */ | ||
| [a, valFromOption(match)]])); | ||
| t[2] = some(u); | ||
| t[4] = !1; | ||
| return n(__(1, [[u, valFromOption(e)]])); | ||
| } | ||
| } else { | ||
| state[ | ||
| /* lastValA */ | ||
| 2] = some(a); | ||
| state[ | ||
| /* gotSignal */ | ||
| 4] = false; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| t[2] = some(u); | ||
| t[4] = !1; | ||
| return 0; | ||
| } | ||
| } else { | ||
| state[ | ||
| /* talkbackA */ | ||
| 0] = signal[0]; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| t[0] = r[0]; | ||
| return 0; | ||
| } | ||
| }); | ||
| _1(sourceB, function (signal) { | ||
| var match = state[ | ||
| /* lastValA */ | ||
| 2]; | ||
| if (typeof signal === "number") { | ||
| if (state[ | ||
| /* endCounter */ | ||
| 5] < 1) { | ||
| state[ | ||
| /* endCounter */ | ||
| 5] = state[ | ||
| /* endCounter */ | ||
| 5] + 1 | 0; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else if (state[ | ||
| /* ended */ | ||
| 6]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| _1(e, function(r) { | ||
| var e = t[2]; | ||
| if ("number" == typeof r) { | ||
| if (t[5] < 1) { | ||
| t[5] = (t[5] + 1) | 0; | ||
| return 0; | ||
| } else if (t[6]) { | ||
| return 0; | ||
| } else { | ||
| state[ | ||
| /* ended */ | ||
| 6] = true; | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| t[6] = !0; | ||
| return n(0); | ||
| } | ||
| } else if (signal.tag) { | ||
| var b = signal[0]; | ||
| if (match !== undefined) { | ||
| if (state[ | ||
| /* ended */ | ||
| 6]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else if (r.tag) { | ||
| var u = r[0]; | ||
| if (void 0 !== e) { | ||
| if (t[6]) { | ||
| return 0; | ||
| } else { | ||
| state[ | ||
| /* lastValB */ | ||
| 3] = some(b); | ||
| state[ | ||
| /* gotSignal */ | ||
| 4] = false; | ||
| return sink( | ||
| /* Push */ | ||
| __(1, [ | ||
| /* tuple */ | ||
| [valFromOption(match), b]])); | ||
| t[3] = some(u); | ||
| t[4] = !1; | ||
| return n(__(1, [[valFromOption(e), u]])); | ||
| } | ||
| } else { | ||
| state[ | ||
| /* lastValB */ | ||
| 3] = some(b); | ||
| state[ | ||
| /* gotSignal */ | ||
| 4] = false; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| t[3] = some(u); | ||
| t[4] = !1; | ||
| return 0; | ||
| } | ||
| } else { | ||
| state[ | ||
| /* talkbackB */ | ||
| 1] = signal[0]; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| t[1] = r[0]; | ||
| return 0; | ||
| } | ||
| }); | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (state[ | ||
| /* ended */ | ||
| 6]) { | ||
| return 0; | ||
| } else if (signal) { | ||
| state[ | ||
| /* ended */ | ||
| 6] = true; | ||
| state[ | ||
| /* talkbackA */ | ||
| 0]( | ||
| /* Close */ | ||
| 1); | ||
| return state[ | ||
| /* talkbackB */ | ||
| 1]( | ||
| /* Close */ | ||
| 1); | ||
| } else if (state[ | ||
| /* gotSignal */ | ||
| 4]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else { | ||
| state[ | ||
| /* gotSignal */ | ||
| 4] = true; | ||
| state[ | ||
| /* talkbackA */ | ||
| 0](signal); | ||
| return state[ | ||
| /* talkbackB */ | ||
| 1](signal); | ||
| } | ||
| }])); | ||
| return n( | ||
| __(0, [ | ||
| function(r) { | ||
| if (t[6]) { | ||
| return 0; | ||
| } else if (r) { | ||
| t[6] = !0; | ||
| t[0](1); | ||
| return t[1](1); | ||
| } else if (t[4]) { | ||
| return 0; | ||
| } else { | ||
| t[4] = !0; | ||
| t[0](r); | ||
| return t[1](r); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| } | ||
| function take(max) { | ||
| return function (source) { | ||
| return function (sink) { | ||
| var state = | ||
| /* record */ | ||
| [ | ||
| /* taken */ | ||
| 0, | ||
| /* talkback */ | ||
| talkbackPlaceholder]; | ||
| _1(source, function (signal) { | ||
| if (typeof signal === "number") { | ||
| if (state[ | ||
| /* taken */ | ||
| 0] < max) { | ||
| state[ | ||
| /* taken */ | ||
| 0] = max; | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| function take(r) { | ||
| return function(e) { | ||
| return function(n) { | ||
| var t = [0, talkbackPlaceholder]; | ||
| _1(e, function(e) { | ||
| if ("number" == typeof e) { | ||
| if (t[0] < r) { | ||
| t[0] = r; | ||
| return n(0); | ||
| } else { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| return 0; | ||
| } | ||
| } else if (signal.tag) { | ||
| if (state[ | ||
| /* taken */ | ||
| 0] < max) { | ||
| state[ | ||
| /* taken */ | ||
| 0] = state[ | ||
| /* taken */ | ||
| 0] + 1 | 0; | ||
| sink(signal); | ||
| if (state[ | ||
| /* taken */ | ||
| 0] === max) { | ||
| sink( | ||
| /* End */ | ||
| 0); | ||
| return state[ | ||
| /* talkback */ | ||
| 1]( | ||
| /* Close */ | ||
| 1); | ||
| } else if (e.tag) { | ||
| if (t[0] < r) { | ||
| t[0] = (t[0] + 1) | 0; | ||
| n(e); | ||
| if (t[0] === r) { | ||
| n(0); | ||
| return t[1](1); | ||
| } else { | ||
@@ -1356,44 +803,25 @@ return 0; | ||
| } else { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| return 0; | ||
| } | ||
| } else { | ||
| state[ | ||
| /* talkback */ | ||
| 1] = signal[0]; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| t[1] = e[0]; | ||
| return 0; | ||
| } | ||
| }); | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (state[ | ||
| /* taken */ | ||
| 0] < max) { | ||
| if (signal) { | ||
| state[ | ||
| /* taken */ | ||
| 0] = max; | ||
| return state[ | ||
| /* talkback */ | ||
| 1]( | ||
| /* Close */ | ||
| 1); | ||
| } else { | ||
| return state[ | ||
| /* talkback */ | ||
| 1]( | ||
| /* Pull */ | ||
| 0); | ||
| return n( | ||
| __(0, [ | ||
| function(e) { | ||
| if (t[0] < r) { | ||
| if (e) { | ||
| t[0] = r; | ||
| return t[1](1); | ||
| } else { | ||
| return t[1](0); | ||
| } | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| } else { | ||
| return 0; | ||
| } | ||
| }])); | ||
| ]) | ||
| ); | ||
| }; | ||
@@ -1403,26 +831,19 @@ }; | ||
| function takeLast(max) { | ||
| return function (source) { | ||
| return function (sink) { | ||
| var queue = new Array(); | ||
| return captureTalkback(source, function (signal, talkback) { | ||
| if (typeof signal === "number") { | ||
| return makeTrampoline(sink, function () { | ||
| return queue.shift(); | ||
| function takeLast(r) { | ||
| return function(e) { | ||
| return function(n) { | ||
| var t = new Array(); | ||
| return captureTalkback(e, function(e, u) { | ||
| if ("number" == typeof e) { | ||
| return makeTrampoline(n, function() { | ||
| return t.shift(); | ||
| }); | ||
| } else if (signal.tag) { | ||
| var size = queue.length; | ||
| if (size >= max && max > 0) { | ||
| queue.shift(); | ||
| } else if (e.tag) { | ||
| if (t.length >= r && r > 0) { | ||
| t.shift(); | ||
| } | ||
| queue.push(signal[0]); | ||
| return talkback( | ||
| /* Pull */ | ||
| 0); | ||
| t.push(e[0]); | ||
| return u(0); | ||
| } else { | ||
| return talkback( | ||
| /* Pull */ | ||
| 0); | ||
| return u(0); | ||
| } | ||
@@ -1434,68 +855,44 @@ }); | ||
| function takeWhile(predicate) { | ||
| return function (source) { | ||
| return function (sink) { | ||
| var ended = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| false]; | ||
| var talkback = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| talkbackPlaceholder]; | ||
| _1(source, function (signal) { | ||
| if (typeof signal === "number") { | ||
| if (ended[0]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| function takeWhile(r) { | ||
| return function(e) { | ||
| return function(n) { | ||
| var t = [!1]; | ||
| var u = [talkbackPlaceholder]; | ||
| _1(e, function(e) { | ||
| if ("number" == typeof e) { | ||
| if (t[0]) { | ||
| return 0; | ||
| } else { | ||
| ended[0] = true; | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| t[0] = !0; | ||
| return n(0); | ||
| } | ||
| } else if (signal.tag) { | ||
| if (ended[0]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else if (_1(predicate, signal[0])) { | ||
| return sink(signal); | ||
| } else if (e.tag) { | ||
| if (t[0]) { | ||
| return 0; | ||
| } else if (_1(r, e[0])) { | ||
| return n(e); | ||
| } else { | ||
| ended[0] = true; | ||
| sink( | ||
| /* End */ | ||
| 0); | ||
| return talkback[0]( | ||
| /* Close */ | ||
| 1); | ||
| t[0] = !0; | ||
| n(0); | ||
| return u[0](1); | ||
| } | ||
| } else { | ||
| talkback[0] = signal[0]; | ||
| return sink(signal); | ||
| u[0] = e[0]; | ||
| return n(e); | ||
| } | ||
| }); | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (ended[0]) { | ||
| return 0; | ||
| } else if (signal) { | ||
| ended[0] = true; | ||
| return talkback[0]( | ||
| /* Close */ | ||
| 1); | ||
| } else { | ||
| return talkback[0]( | ||
| /* Pull */ | ||
| 0); | ||
| } | ||
| }])); | ||
| return n( | ||
| __(0, [ | ||
| function(r) { | ||
| if (t[0]) { | ||
| return 0; | ||
| } else if (r) { | ||
| t[0] = !0; | ||
| return u[0](1); | ||
| } else { | ||
| return u[0](0); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
@@ -1505,83 +902,35 @@ }; | ||
| function takeUntil(notifier) { | ||
| return function (source) { | ||
| return function (sink) { | ||
| var state = | ||
| /* record */ | ||
| [ | ||
| /* ended */ | ||
| false, | ||
| /* sourceTalkback */ | ||
| talkbackPlaceholder, | ||
| /* notifierTalkback */ | ||
| talkbackPlaceholder]; | ||
| _1(source, function (signal) { | ||
| if (typeof signal === "number") { | ||
| if (state[ | ||
| /* ended */ | ||
| 0]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| function takeUntil(r) { | ||
| return function(e) { | ||
| return function(n) { | ||
| var t = [!1, talkbackPlaceholder, talkbackPlaceholder]; | ||
| _1(e, function(e) { | ||
| if ("number" == typeof e) { | ||
| if (t[0]) { | ||
| return 0; | ||
| } else { | ||
| state[ | ||
| /* notifierTalkback */ | ||
| 2]( | ||
| /* Close */ | ||
| 1); | ||
| state[ | ||
| /* ended */ | ||
| 0] = true; | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| t[2](1); | ||
| t[0] = !0; | ||
| return n(0); | ||
| } | ||
| } else if (signal.tag) { | ||
| if (state[ | ||
| /* ended */ | ||
| 0]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else if (e.tag) { | ||
| if (t[0]) { | ||
| return 0; | ||
| } else { | ||
| return sink(signal); | ||
| return n(e); | ||
| } | ||
| } else { | ||
| state[ | ||
| /* sourceTalkback */ | ||
| 1] = signal[0]; | ||
| return _1(notifier, function (signal) { | ||
| if (typeof signal === "number") { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else if (signal.tag) { | ||
| state[ | ||
| /* ended */ | ||
| 0] = true; | ||
| state[ | ||
| /* notifierTalkback */ | ||
| 2]( | ||
| /* Close */ | ||
| 1); | ||
| state[ | ||
| /* sourceTalkback */ | ||
| 1]( | ||
| /* Close */ | ||
| 1); | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| t[1] = e[0]; | ||
| return _1(r, function(r) { | ||
| if ("number" == typeof r) { | ||
| return 0; | ||
| } else if (r.tag) { | ||
| t[0] = !0; | ||
| t[2](1); | ||
| t[1](1); | ||
| return n(0); | ||
| } else { | ||
| var innerTb = signal[0]; | ||
| state[ | ||
| /* notifierTalkback */ | ||
| 2] = innerTb; | ||
| return innerTb( | ||
| /* Pull */ | ||
| 0); | ||
| var e = r[0]; | ||
| t[2] = e; | ||
| return e(0); | ||
| } | ||
@@ -1591,29 +940,16 @@ }); | ||
| }); | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (state[ | ||
| /* ended */ | ||
| 0]) { | ||
| return 0; | ||
| } else if (signal) { | ||
| state[ | ||
| /* sourceTalkback */ | ||
| 1]( | ||
| /* Close */ | ||
| 1); | ||
| return state[ | ||
| /* notifierTalkback */ | ||
| 2]( | ||
| /* Close */ | ||
| 1); | ||
| } else { | ||
| return state[ | ||
| /* sourceTalkback */ | ||
| 1]( | ||
| /* Pull */ | ||
| 0); | ||
| } | ||
| }])); | ||
| return n( | ||
| __(0, [ | ||
| function(r) { | ||
| if (t[0]) { | ||
| return 0; | ||
| } else if (r) { | ||
| t[1](1); | ||
| return t[2](1); | ||
| } else { | ||
| return t[1](0); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
@@ -1623,18 +959,12 @@ }; | ||
| function skip(wait) { | ||
| return function (source) { | ||
| return function (sink) { | ||
| var rest = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| wait]; | ||
| return captureTalkback(source, function (signal, talkback) { | ||
| if (typeof signal === "number" || !(signal.tag && rest[0] > 0)) { | ||
| return sink(signal); | ||
| function skip(r) { | ||
| return function(e) { | ||
| return function(n) { | ||
| var t = [r]; | ||
| return captureTalkback(e, function(r, e) { | ||
| if ("number" == typeof r || !(r.tag && t[0] > 0)) { | ||
| return n(r); | ||
| } else { | ||
| rest[0] = rest[0] - 1 | 0; | ||
| return talkback( | ||
| /* Pull */ | ||
| 0); | ||
| t[0] = (t[0] - 1) | 0; | ||
| return e(0); | ||
| } | ||
@@ -1646,20 +976,14 @@ }); | ||
| function skipWhile(predicate) { | ||
| return function (source) { | ||
| return function (sink) { | ||
| var skip = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| true]; | ||
| return captureTalkback(source, function (signal, talkback) { | ||
| if (typeof signal === "number" || !(signal.tag && skip[0])) { | ||
| return sink(signal); | ||
| } else if (_1(predicate, signal[0])) { | ||
| return talkback( | ||
| /* Pull */ | ||
| 0); | ||
| function skipWhile(r) { | ||
| return function(e) { | ||
| return function(n) { | ||
| var t = [!0]; | ||
| return captureTalkback(e, function(e, u) { | ||
| if ("number" == typeof e || !e.tag || !t[0]) { | ||
| return n(e); | ||
| } else if (_1(r, e[0])) { | ||
| return u(0); | ||
| } else { | ||
| skip[0] = false; | ||
| return sink(signal); | ||
| t[0] = !1; | ||
| return n(e); | ||
| } | ||
@@ -1671,92 +995,36 @@ }); | ||
| function skipUntil(notifier) { | ||
| return function (source) { | ||
| return function (sink) { | ||
| var state = | ||
| /* record */ | ||
| [ | ||
| /* skip */ | ||
| true, | ||
| /* ended */ | ||
| false, | ||
| /* gotSignal */ | ||
| false, | ||
| /* sourceTalkback */ | ||
| talkbackPlaceholder, | ||
| /* notifierTalkback */ | ||
| talkbackPlaceholder]; | ||
| _1(source, function (signal) { | ||
| if (typeof signal === "number") { | ||
| if (state[ | ||
| /* skip */ | ||
| 0]) { | ||
| state[ | ||
| /* notifierTalkback */ | ||
| 4]( | ||
| /* Close */ | ||
| 1); | ||
| function skipUntil(r) { | ||
| return function(e) { | ||
| return function(n) { | ||
| var t = [!0, !1, !1, talkbackPlaceholder, talkbackPlaceholder]; | ||
| _1(e, function(e) { | ||
| if ("number" == typeof e) { | ||
| if (t[0]) { | ||
| t[4](1); | ||
| } | ||
| state[ | ||
| /* ended */ | ||
| 1] = true; | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| } else if (signal.tag) { | ||
| if (state[ | ||
| /* skip */ | ||
| 0] && !state[ | ||
| /* ended */ | ||
| 1]) { | ||
| return state[ | ||
| /* sourceTalkback */ | ||
| 3]( | ||
| /* Pull */ | ||
| 0); | ||
| } else if (state[ | ||
| /* ended */ | ||
| 1]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| t[1] = !0; | ||
| return n(0); | ||
| } else if (e.tag) { | ||
| if (t[0] && !t[1]) { | ||
| return t[3](0); | ||
| } else if (t[1]) { | ||
| return 0; | ||
| } else { | ||
| state[ | ||
| /* gotSignal */ | ||
| 2] = false; | ||
| return sink(signal); | ||
| t[2] = !1; | ||
| return n(e); | ||
| } | ||
| } else { | ||
| var tb = signal[0]; | ||
| state[ | ||
| /* sourceTalkback */ | ||
| 3] = tb; | ||
| return _1(notifier, function (signal) { | ||
| if (typeof signal === "number") { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else if (signal.tag) { | ||
| state[ | ||
| /* skip */ | ||
| 0] = false; | ||
| return state[ | ||
| /* notifierTalkback */ | ||
| 4]( | ||
| /* Close */ | ||
| 1); | ||
| var u = e[0]; | ||
| t[3] = u; | ||
| return _1(r, function(r) { | ||
| if ("number" == typeof r) { | ||
| return 0; | ||
| } else if (r.tag) { | ||
| t[0] = !1; | ||
| return t[4](1); | ||
| } else { | ||
| var innerTb = signal[0]; | ||
| state[ | ||
| /* notifierTalkback */ | ||
| 4] = innerTb; | ||
| innerTb( | ||
| /* Pull */ | ||
| 0); | ||
| return tb( | ||
| /* Pull */ | ||
| 0); | ||
| var e = r[0]; | ||
| t[4] = e; | ||
| e(0); | ||
| return u(0); | ||
| } | ||
@@ -1766,45 +1034,20 @@ }); | ||
| }); | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (signal) { | ||
| if (state[ | ||
| /* skip */ | ||
| 0]) { | ||
| state[ | ||
| /* notifierTalkback */ | ||
| 4]( | ||
| /* Close */ | ||
| 1); | ||
| return n( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| if (t[0]) { | ||
| t[4](1); | ||
| } | ||
| t[1] = !0; | ||
| return t[3](1); | ||
| } else if (!t[2] && !t[1]) { | ||
| t[2] = !0; | ||
| return t[3](0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| state[ | ||
| /* ended */ | ||
| 1] = true; | ||
| return state[ | ||
| /* sourceTalkback */ | ||
| 3]( | ||
| /* Close */ | ||
| 1); | ||
| } else if (!state[ | ||
| /* gotSignal */ | ||
| 2] && !state[ | ||
| /* ended */ | ||
| 1]) { | ||
| state[ | ||
| /* gotSignal */ | ||
| 2] = true; | ||
| return state[ | ||
| /* sourceTalkback */ | ||
| 3]( | ||
| /* Pull */ | ||
| 0); | ||
| } else { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } | ||
| }])); | ||
| ]) | ||
| ); | ||
| }; | ||
@@ -1814,152 +1057,68 @@ }; | ||
| function flatten(source) { | ||
| return function (sink) { | ||
| var state = | ||
| /* record */ | ||
| [ | ||
| /* sourceTalkback */ | ||
| talkbackPlaceholder, | ||
| /* innerTalkback */ | ||
| talkbackPlaceholder, | ||
| /* sourceEnded */ | ||
| false, | ||
| /* innerEnded */ | ||
| true]; | ||
| _1(source, function (signal) { | ||
| if (typeof signal === "number") { | ||
| if (state[ | ||
| /* innerEnded */ | ||
| 3]) { | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| function flatten(r) { | ||
| return function(e) { | ||
| var n = [talkbackPlaceholder, talkbackPlaceholder, !1, !0]; | ||
| _1(r, function(r) { | ||
| if ("number" == typeof r) { | ||
| if (n[3]) { | ||
| return e(0); | ||
| } else { | ||
| state[ | ||
| /* sourceEnded */ | ||
| 2] = true; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| n[2] = !0; | ||
| return 0; | ||
| } | ||
| } else if (signal.tag) { | ||
| var innerSource = signal[0]; | ||
| return _1(innerSource, function (signal) { | ||
| if (typeof signal === "number") { | ||
| if (state[ | ||
| /* sourceEnded */ | ||
| 2]) { | ||
| return state[ | ||
| /* sourceTalkback */ | ||
| 0]( | ||
| /* Close */ | ||
| 1); | ||
| } else if (r.tag) { | ||
| return _1(r[0], function(r) { | ||
| if ("number" == typeof r) { | ||
| if (n[2]) { | ||
| return n[0](1); | ||
| } else { | ||
| state[ | ||
| /* innerEnded */ | ||
| 3] = true; | ||
| return state[ | ||
| /* sourceTalkback */ | ||
| 0]( | ||
| /* Pull */ | ||
| 0); | ||
| n[3] = !0; | ||
| return n[0](0); | ||
| } | ||
| } else if (signal.tag) { | ||
| return sink(signal); | ||
| } else if (r.tag) { | ||
| return e(r); | ||
| } else { | ||
| var tb = signal[0]; | ||
| if (!state[ | ||
| /* innerEnded */ | ||
| 3]) { | ||
| state[ | ||
| /* innerTalkback */ | ||
| 1]( | ||
| /* Close */ | ||
| 1); | ||
| var t = r[0]; | ||
| if (!n[3]) { | ||
| n[1](1); | ||
| } | ||
| state[ | ||
| /* innerEnded */ | ||
| 3] = false; | ||
| state[ | ||
| /* innerTalkback */ | ||
| 1] = tb; | ||
| return tb( | ||
| /* Pull */ | ||
| 0); | ||
| n[3] = !1; | ||
| n[1] = t; | ||
| return t(0); | ||
| } | ||
| }); | ||
| } else { | ||
| state[ | ||
| /* sourceTalkback */ | ||
| 0] = signal[0]; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| n[0] = r[0]; | ||
| return 0; | ||
| } | ||
| }); | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (signal) { | ||
| state[ | ||
| /* sourceTalkback */ | ||
| 0]( | ||
| /* Close */ | ||
| 1); | ||
| return state[ | ||
| /* innerTalkback */ | ||
| 1]( | ||
| /* Close */ | ||
| 1); | ||
| } else if (!state[ | ||
| /* innerEnded */ | ||
| 3] && !state[ | ||
| /* sourceEnded */ | ||
| 2]) { | ||
| return state[ | ||
| /* innerTalkback */ | ||
| 1]( | ||
| /* Pull */ | ||
| 0); | ||
| } else if (state[ | ||
| /* sourceEnded */ | ||
| 2]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else { | ||
| return state[ | ||
| /* sourceTalkback */ | ||
| 0]( | ||
| /* Pull */ | ||
| 0); | ||
| } | ||
| }])); | ||
| return e( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| n[0](1); | ||
| return n[1](1); | ||
| } else if (!n[3] && !n[2]) { | ||
| return n[1](0); | ||
| } else if (n[2]) { | ||
| return 0; | ||
| } else { | ||
| return n[0](0); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| } | ||
| function forEach$1(f) { | ||
| return function (source) { | ||
| return captureTalkback(source, function (signal, talkback) { | ||
| if (typeof signal === "number") { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else if (signal.tag) { | ||
| _1(f, signal[0]); | ||
| return talkback( | ||
| /* Pull */ | ||
| 0); | ||
| function forEach$1(r) { | ||
| return function(e) { | ||
| return captureTalkback(e, function(e, n) { | ||
| if ("number" == typeof e) { | ||
| return 0; | ||
| } else if (e.tag) { | ||
| _1(r, e[0]); | ||
| return n(0); | ||
| } else { | ||
| return talkback( | ||
| /* Pull */ | ||
| 0); | ||
| return n(0); | ||
| } | ||
@@ -1970,50 +1129,27 @@ }); | ||
| function subscribe(f) { | ||
| return function (source) { | ||
| var talkback = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| talkbackPlaceholder]; | ||
| var ended = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| false]; | ||
| _1(source, function (signal) { | ||
| if (typeof signal === "number") { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else if (signal.tag) { | ||
| if (ended[0]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| function subscribe(r) { | ||
| return function(e) { | ||
| var n = [talkbackPlaceholder]; | ||
| var t = [!1]; | ||
| _1(e, function(e) { | ||
| if ("number" == typeof e) { | ||
| return 0; | ||
| } else if (e.tag) { | ||
| if (t[0]) { | ||
| return 0; | ||
| } else { | ||
| _1(f, signal[0]); | ||
| return talkback[0]( | ||
| /* Pull */ | ||
| 0); | ||
| _1(r, e[0]); | ||
| return n[0](0); | ||
| } | ||
| } else { | ||
| talkback[0] = signal[0]; | ||
| return talkback[0]( | ||
| /* Pull */ | ||
| 0); | ||
| n[0] = e[0]; | ||
| return n[0](0); | ||
| } | ||
| }); | ||
| return function (param) { | ||
| if (ended[0]) { | ||
| return function(r) { | ||
| if (t[0]) { | ||
| return 0; | ||
| } else { | ||
| ended[0] = true; | ||
| return talkback[0]( | ||
| /* Close */ | ||
| 1); | ||
| t[0] = !0; | ||
| return n[0](1); | ||
| } | ||
@@ -2025,202 +1161,141 @@ }; | ||
| var Types = 0; | ||
| /* No side effect */ | ||
| function fromListener(addListener, removeListener) { | ||
| return function (sink) { | ||
| var handler = function ($$event) { | ||
| return sink( | ||
| /* Push */ | ||
| __(1, [$$event])); | ||
| function fromListener(r, e) { | ||
| return function(n) { | ||
| var t = function(r) { | ||
| return n(__(1, [r])); | ||
| }; | ||
| sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (signal) { | ||
| return _1(removeListener, handler); | ||
| } else { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } | ||
| }])); | ||
| return _1(addListener, handler); | ||
| n( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| return _1(e, t); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| return _1(r, t); | ||
| }; | ||
| } | ||
| function fromDomEvent(element, $$event) { | ||
| return function (sink) { | ||
| var addEventListener = function (element, event, handler) { | ||
| element.addEventListener(event, handler); | ||
| function fromDomEvent(r, e) { | ||
| return function(n) { | ||
| var t = function(r, e, n) { | ||
| r.addEventListener(e, n); | ||
| }; | ||
| var removeEventListener = function (element, event, handler) { | ||
| element.removeEventListener(event, handler); | ||
| var u = function(r, e, n) { | ||
| r.removeEventListener(e, n); | ||
| }; | ||
| return fromListener(function (handler) { | ||
| return _3(addEventListener, element, $$event, handler); | ||
| }, function (handler) { | ||
| return _3(removeEventListener, element, $$event, handler); | ||
| })(sink); | ||
| return fromListener( | ||
| function(n) { | ||
| return _3(t, r, e, n); | ||
| }, | ||
| function(n) { | ||
| return _3(u, r, e, n); | ||
| } | ||
| )(n); | ||
| }; | ||
| } | ||
| function interval(p) { | ||
| return function (sink) { | ||
| var i = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| 0]; | ||
| var id = setInterval(function (param) { | ||
| var num = i[0]; | ||
| i[0] = i[0] + 1 | 0; | ||
| return sink( | ||
| /* Push */ | ||
| __(1, [num])); | ||
| }, p); | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (signal) { | ||
| clearInterval(id); | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } | ||
| }])); | ||
| function interval(r) { | ||
| return function(e) { | ||
| var n = [0]; | ||
| var t = setInterval(function(r) { | ||
| var t = n[0]; | ||
| n[0] = (n[0] + 1) | 0; | ||
| return e(__(1, [t])); | ||
| }, r); | ||
| return e( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| clearInterval(t); | ||
| return 0; | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| } | ||
| function fromPromise(promise) { | ||
| return function (sink) { | ||
| var ended = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| false]; | ||
| promise.then(function (value) { | ||
| if (!ended[0]) { | ||
| sink( | ||
| /* Push */ | ||
| __(1, [value])); | ||
| sink( | ||
| /* End */ | ||
| 0); | ||
| function fromPromise(r) { | ||
| return function(e) { | ||
| var n = [!1]; | ||
| r.then(function(r) { | ||
| if (!n[0]) { | ||
| e(__(1, [r])); | ||
| e(0); | ||
| } | ||
| return Promise.resolve( | ||
| /* () */ | ||
| 0); | ||
| return Promise.resolve(0); | ||
| }); | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (signal) { | ||
| ended[0] = true; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } | ||
| }])); | ||
| return e( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| n[0] = !0; | ||
| return 0; | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| } | ||
| function debounce(debounceF) { | ||
| return function (source) { | ||
| return function (sink) { | ||
| var gotEndSignal = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| false]; | ||
| var id = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| undefined]; | ||
| var $$clearTimeout$1 = function (param) { | ||
| var match = id[0]; | ||
| if (match !== undefined) { | ||
| id[0] = undefined; | ||
| clearTimeout(valFromOption(match)); | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| function debounce(r) { | ||
| return function(e) { | ||
| return function(n) { | ||
| var t = [!1]; | ||
| var u = [void 0]; | ||
| var i = function(r) { | ||
| var e = u[0]; | ||
| if (void 0 !== e) { | ||
| u[0] = void 0; | ||
| clearTimeout(valFromOption(e)); | ||
| return 0; | ||
| } else { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| return 0; | ||
| } | ||
| }; | ||
| return _1(source, function (signal) { | ||
| if (typeof signal === "number") { | ||
| gotEndSignal[0] = true; | ||
| var match = id[0]; | ||
| if (match !== undefined) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| return _1(e, function(e) { | ||
| if ("number" == typeof e) { | ||
| t[0] = !0; | ||
| if (void 0 !== u[0]) { | ||
| return 0; | ||
| } else { | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| return n(0); | ||
| } | ||
| } else if (signal.tag) { | ||
| $$clearTimeout$1( | ||
| /* () */ | ||
| 0); | ||
| id[0] = some(setTimeout(function (param) { | ||
| id[0] = undefined; | ||
| sink(signal); | ||
| if (gotEndSignal[0]) { | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| }, _1(debounceF, signal[0]))); | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| } else if (e.tag) { | ||
| i(); | ||
| u[0] = some( | ||
| setTimeout(function(r) { | ||
| u[0] = void 0; | ||
| n(e); | ||
| if (t[0]) { | ||
| return n(0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| }, _1(r, e[0])) | ||
| ); | ||
| return 0; | ||
| } else { | ||
| var tb = signal[0]; | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (signal) { | ||
| $$clearTimeout$1( | ||
| /* () */ | ||
| 0); | ||
| return tb( | ||
| /* Close */ | ||
| 1); | ||
| } else { | ||
| return tb(signal); | ||
| } | ||
| }])); | ||
| var f = e[0]; | ||
| return n( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| i(); | ||
| return f(1); | ||
| } else { | ||
| return f(r); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| } | ||
@@ -2232,78 +1307,49 @@ }); | ||
| function throttle(throttleF) { | ||
| return function (source) { | ||
| return function (sink) { | ||
| var skip = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| false]; | ||
| var id = | ||
| /* record */ | ||
| [ | ||
| /* contents */ | ||
| undefined]; | ||
| var $$clearTimeout$1 = function (param) { | ||
| var match = id[0]; | ||
| if (match !== undefined) { | ||
| clearTimeout(valFromOption(match)); | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| function throttle(r) { | ||
| return function(e) { | ||
| return function(n) { | ||
| var t = [!1]; | ||
| var u = [void 0]; | ||
| var i = function(r) { | ||
| var e = u[0]; | ||
| if (void 0 !== e) { | ||
| clearTimeout(valFromOption(e)); | ||
| return 0; | ||
| } else { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| return 0; | ||
| } | ||
| }; | ||
| return _1(source, function (signal) { | ||
| if (typeof signal === "number") { | ||
| $$clearTimeout$1( | ||
| /* () */ | ||
| 0); | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| } else if (signal.tag) { | ||
| if (skip[0]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| return _1(e, function(e) { | ||
| if ("number" == typeof e) { | ||
| i(); | ||
| return n(0); | ||
| } else if (e.tag) { | ||
| if (t[0]) { | ||
| return 0; | ||
| } else { | ||
| t[0] = !0; | ||
| i(); | ||
| u[0] = some( | ||
| setTimeout(function(r) { | ||
| u[0] = void 0; | ||
| t[0] = !1; | ||
| return 0; | ||
| }, _1(r, e[0])) | ||
| ); | ||
| } else { | ||
| skip[0] = true; | ||
| $$clearTimeout$1( | ||
| /* () */ | ||
| 0); | ||
| id[0] = some(setTimeout(function (param) { | ||
| id[0] = undefined; | ||
| skip[0] = false; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| }, _1(throttleF, signal[0]))); | ||
| return sink(signal); | ||
| return n(e); | ||
| } | ||
| } else { | ||
| var tb = signal[0]; | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (signal) { | ||
| $$clearTimeout$1( | ||
| /* () */ | ||
| 0); | ||
| return tb( | ||
| /* Close */ | ||
| 1); | ||
| } else { | ||
| return tb(signal); | ||
| } | ||
| }])); | ||
| var f = e[0]; | ||
| return n( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| i(); | ||
| return f(1); | ||
| } else { | ||
| return f(r); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| } | ||
@@ -2315,133 +1361,60 @@ }); | ||
| function sample(notifier) { | ||
| return function (source) { | ||
| return function (sink) { | ||
| var state = | ||
| /* record */ | ||
| [ | ||
| /* ended */ | ||
| false, | ||
| /* value */ | ||
| undefined, | ||
| /* sourceTalkback */ | ||
| function (param) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| }, | ||
| /* notifierTalkback */ | ||
| function (param) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| }]; | ||
| _1(source, function (signal) { | ||
| if (typeof signal === "number") { | ||
| state[ | ||
| /* ended */ | ||
| 0] = true; | ||
| state[ | ||
| /* notifierTalkback */ | ||
| 3]( | ||
| /* Close */ | ||
| 1); | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| } else if (signal.tag) { | ||
| state[ | ||
| /* value */ | ||
| 1] = some(signal[0]); | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| function sample(r) { | ||
| return function(e) { | ||
| return function(n) { | ||
| var t = [ | ||
| !1, | ||
| void 0, | ||
| function(r) { | ||
| return 0; | ||
| }, | ||
| function(r) { | ||
| return 0; | ||
| } | ||
| ]; | ||
| _1(e, function(r) { | ||
| if ("number" == typeof r) { | ||
| t[0] = !0; | ||
| t[3](1); | ||
| return n(0); | ||
| } else if (r.tag) { | ||
| t[1] = some(r[0]); | ||
| return 0; | ||
| } else { | ||
| state[ | ||
| /* sourceTalkback */ | ||
| 2] = signal[0]; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| t[2] = r[0]; | ||
| return 0; | ||
| } | ||
| }); | ||
| _1(notifier, function (signal) { | ||
| var match = state[ | ||
| /* value */ | ||
| 1]; | ||
| if (typeof signal === "number") { | ||
| state[ | ||
| /* ended */ | ||
| 0] = true; | ||
| state[ | ||
| /* sourceTalkback */ | ||
| 2]( | ||
| /* Close */ | ||
| 1); | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| } else if (signal.tag) { | ||
| if (match !== undefined && !state[ | ||
| /* ended */ | ||
| 0]) { | ||
| state[ | ||
| /* value */ | ||
| 1] = undefined; | ||
| return sink( | ||
| /* Push */ | ||
| __(1, [valFromOption(match)])); | ||
| _1(r, function(r) { | ||
| var e = t[1]; | ||
| if ("number" == typeof r) { | ||
| t[0] = !0; | ||
| t[2](1); | ||
| return n(0); | ||
| } else if (r.tag) { | ||
| if (void 0 !== e && !t[0]) { | ||
| t[1] = void 0; | ||
| return n(__(1, [valFromOption(e)])); | ||
| } else { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| return 0; | ||
| } | ||
| } else { | ||
| state[ | ||
| /* notifierTalkback */ | ||
| 3] = signal[0]; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| t[3] = r[0]; | ||
| return 0; | ||
| } | ||
| }); | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (signal) { | ||
| state[ | ||
| /* ended */ | ||
| 0] = true; | ||
| state[ | ||
| /* sourceTalkback */ | ||
| 2]( | ||
| /* Close */ | ||
| 1); | ||
| return state[ | ||
| /* notifierTalkback */ | ||
| 3]( | ||
| /* Close */ | ||
| 1); | ||
| } else { | ||
| state[ | ||
| /* sourceTalkback */ | ||
| 2]( | ||
| /* Pull */ | ||
| 0); | ||
| return state[ | ||
| /* notifierTalkback */ | ||
| 3]( | ||
| /* Pull */ | ||
| 0); | ||
| } | ||
| }])); | ||
| return n( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| t[0] = !0; | ||
| t[2](1); | ||
| return t[3](1); | ||
| } else { | ||
| t[2](0); | ||
| return t[3](0); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
@@ -2451,140 +1424,119 @@ }; | ||
| function delay(wait) { | ||
| return function (source) { | ||
| return function (sink) { | ||
| var state = | ||
| /* record */ | ||
| [ | ||
| /* talkback */ | ||
| talkbackPlaceholder, | ||
| /* active */ | ||
| 0, | ||
| /* gotEndSignal */ | ||
| false]; | ||
| _1(source, function (signal) { | ||
| var exit = 0; | ||
| if (typeof signal === "number" || signal.tag) { | ||
| exit = 1; | ||
| function delay(r) { | ||
| return function(e) { | ||
| return function(n) { | ||
| var t = [talkbackPlaceholder, 0, !1]; | ||
| _1(e, function(e) { | ||
| var u = 0; | ||
| if ("number" == typeof e || e.tag) { | ||
| u = 1; | ||
| } else { | ||
| state[ | ||
| /* talkback */ | ||
| 0] = signal[0]; | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| t[0] = e[0]; | ||
| return 0; | ||
| } | ||
| if (exit === 1) { | ||
| if (state[ | ||
| /* gotEndSignal */ | ||
| 2]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| if (1 === u) { | ||
| if (t[2]) { | ||
| return 0; | ||
| } else { | ||
| state[ | ||
| /* active */ | ||
| 1] = state[ | ||
| /* active */ | ||
| 1] + 1 | 0; | ||
| setTimeout(function (param) { | ||
| if (state[ | ||
| /* gotEndSignal */ | ||
| 2] && state[ | ||
| /* active */ | ||
| 1] === 0) { | ||
| sink( | ||
| /* End */ | ||
| 0); | ||
| t[1] = (t[1] + 1) | 0; | ||
| setTimeout(function(r) { | ||
| if (t[2] && 0 === t[1]) { | ||
| n(0); | ||
| } else { | ||
| state[ | ||
| /* active */ | ||
| 1] = state[ | ||
| /* active */ | ||
| 1] - 1 | 0; | ||
| t[1] = (t[1] - 1) | 0; | ||
| } | ||
| return sink(signal); | ||
| }, wait); | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| return n(e); | ||
| }, r); | ||
| return 0; | ||
| } | ||
| } | ||
| }); | ||
| return sink( | ||
| /* Start */ | ||
| __(0, [function (signal) { | ||
| if (signal) { | ||
| state[ | ||
| /* gotEndSignal */ | ||
| 2] = true; | ||
| if (state[ | ||
| /* active */ | ||
| 1] === 0) { | ||
| return sink( | ||
| /* End */ | ||
| 0); | ||
| } else { | ||
| return 0; | ||
| return n( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| t[2] = !0; | ||
| if (0 === t[1]) { | ||
| return n(0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else if (t[2]) { | ||
| return 0; | ||
| } else { | ||
| return t[0](r); | ||
| } | ||
| } | ||
| } else if (state[ | ||
| /* gotEndSignal */ | ||
| 2]) { | ||
| return ( | ||
| /* () */ | ||
| 0 | ||
| ); | ||
| } else { | ||
| return state[ | ||
| /* talkback */ | ||
| 0](signal); | ||
| } | ||
| }])); | ||
| ]) | ||
| ); | ||
| }; | ||
| }; | ||
| } | ||
| /* No side effect */ | ||
| exports.pipe = pipe; | ||
| exports.Types = Types; | ||
| exports.makeSubject = makeSubject; | ||
| exports.make = make$2; | ||
| exports.fromList = fromList; | ||
| exports.fromArray = fromArray; | ||
| exports.fromValue = fromValue; | ||
| exports.empty = empty; | ||
| exports.never = never; | ||
| exports.map = map$1; | ||
| exports.filter = filter; | ||
| exports.scan = scan; | ||
| exports.merge = merge; | ||
| exports.concat = concat$1; | ||
| exports.share = share; | ||
| exports.combine = combine; | ||
| exports.take = take; | ||
| exports.takeLast = takeLast; | ||
| exports.takeWhile = takeWhile; | ||
| exports.takeUntil = takeUntil; | ||
| exports.skip = skip; | ||
| exports.skipWhile = skipWhile; | ||
| exports.skipUntil = skipUntil; | ||
| exports.flatten = flatten; | ||
| exports.forEach = forEach$1; | ||
| exports.subscribe = subscribe; | ||
| exports.fromListener = fromListener; | ||
| exports.fromDomEvent = fromDomEvent; | ||
| exports.interval = interval; | ||
| exports.fromPromise = fromPromise; | ||
| exports.debounce = debounce; | ||
| exports.throttle = throttle; | ||
| exports.sample = sample; | ||
| exports.delay = delay; | ||
| //# sourceMappingURL=wonka.js.map |
| { | ||
| "name": "wonka", | ||
| "version": "1.1.4", | ||
| "version": "1.1.5", | ||
| "author": "Phil Pluckthun <phil@kitten.sh>", | ||
@@ -19,13 +19,17 @@ "source": "./src/index.js", | ||
| "scripts": { | ||
| "clean:bs": "bsb -clean-world", | ||
| "clean:dist": "rimraf dist", | ||
| "clean": "run-p clean:bs clean:dist", | ||
| "clean": "bsb -clean-world", | ||
| "build": "bsb -make-world", | ||
| "watch": "bsb -make-world -w", | ||
| "bundle": "microbundle --external none --no-compress --format es,cjs", | ||
| "prebundlesize": "run-s bundle", | ||
| "bundlesize": "bundlesize", | ||
| "test": "jest", | ||
| "coverage": "jest -c ./.jest.coverage.json --coverage", | ||
| "test:watch": "jest --watch", | ||
| "terser:es": "terser --config-file .terser.config.json --module -o ./dist/wonka.es.js ./dist/wonka.es.js", | ||
| "terser:cjs": "terser --config-file .terser.config.json -o ./dist/wonka.js ./dist/wonka.js", | ||
| "terser": "run-p terser:es terser:cjs", | ||
| "prettier": "prettier --write ./dist/*.js", | ||
| "prebundle": "rimraf ./dist", | ||
| "bundle": "microbundle --external none --no-compress --no-sourcemap --format es,cjs", | ||
| "postbundle": "run-s terser prettier", | ||
| "prebundlesize": "run-s bundle", | ||
| "bundlesize": "bundlesize", | ||
| "prepublishOnly": "run-s clean build bundle test" | ||
@@ -57,4 +61,8 @@ }, | ||
| "npm-run-all": "^4.1.5", | ||
| "rimraf": "^2.6.3" | ||
| "rimraf": "^2.6.3", | ||
| "terser": "^3.14.1" | ||
| }, | ||
| "prettier": { | ||
| "printWidth": 100 | ||
| }, | ||
| "jest": { | ||
@@ -61,0 +69,0 @@ "moduleFileExtensions": [ |
New alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Fixed alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Worsened metrics
- Total package byte prevSize
- decreased by-48.93%
301934
- Dev dependency count
- increased by14.29%
8
- Number of package files
- decreased by-6.45%
29
- Lines of code
- decreased by-22.28%
7029
No dependency changes