wonka - npm Package Compare versions
Comparing version 1.1.5 to 1.1.6
1507
dist/wonka.es.js
@@ -1,46 +0,46 @@ | ||
| function pipe(r) { | ||
| var e = arguments; | ||
| var n = e.length; | ||
| var t = r; | ||
| for (var u = 1; u < n; u++) { | ||
| t = e[u](t); | ||
| function pipe(source) { | ||
| var args = arguments; | ||
| var len = args.length; | ||
| var x = source; | ||
| for (var i = 1; i < len; i++) { | ||
| x = args[i](x); | ||
| } | ||
| 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; | ||
| 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 t; | ||
| return result; | ||
| } | ||
| function app(r, e) { | ||
| function app(_f, _args) { | ||
| 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)); | ||
| var args = _args; | ||
| var f = _f; | ||
| var arity = f.length; | ||
| var d = (arity - args.length) | 0; | ||
| if (0 === d) { | ||
| return f.apply(null, args); | ||
| } else if (d < 0) { | ||
| _args = caml_array_sub(args, arity, 0 | -d); | ||
| _f = f.apply(null, caml_array_sub(args, 0, arity)); | ||
| continue; | ||
| } else { | ||
| return (function(r, e) { | ||
| return function(n) { | ||
| return app(r, e.concat([n])); | ||
| return (function(f, args) { | ||
| return function(x) { | ||
| return app(f, args.concat([x])); | ||
| }; | ||
| })(t, n); | ||
| })(f, args); | ||
| } | ||
@@ -50,194 +50,194 @@ } | ||
| function _1(r, e) { | ||
| var n = r.length; | ||
| if (1 === n) { | ||
| return r(e); | ||
| function _1(o, a0) { | ||
| var arity = o.length; | ||
| if (1 === arity) { | ||
| return o(a0); | ||
| } else { | ||
| return (function curry_1(r, e, n) { | ||
| switch (n) { | ||
| return (function curry_1(o, a0, arity) { | ||
| switch (arity) { | ||
| case 1: | ||
| return r(e); | ||
| return o(a0); | ||
| case 2: | ||
| return function(n) { | ||
| return r(e, n); | ||
| return function(param) { | ||
| return o(a0, param); | ||
| }; | ||
| case 3: | ||
| return function(n, t) { | ||
| return r(e, n, t); | ||
| return function(param, param$1) { | ||
| return o(a0, param, param$1); | ||
| }; | ||
| case 4: | ||
| return function(n, t, u) { | ||
| return r(e, n, t, u); | ||
| return function(param, param$1, param$2) { | ||
| return o(a0, param, param$1, param$2); | ||
| }; | ||
| case 5: | ||
| return function(n, t, u, i) { | ||
| return r(e, n, t, u, i); | ||
| return function(param, param$1, param$2, param$3) { | ||
| return o(a0, param, param$1, param$2, param$3); | ||
| }; | ||
| case 6: | ||
| return function(n, t, u, i, f) { | ||
| return r(e, n, t, u, i, f); | ||
| 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(n, t, u, i, f, o) { | ||
| return r(e, n, t, u, i, f, o); | ||
| 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(r, [e]); | ||
| return app(o, [a0]); | ||
| } | ||
| })(r, e, n); | ||
| })(o, a0, arity); | ||
| } | ||
| } | ||
| function _2(r, e, n) { | ||
| var t = r.length; | ||
| if (2 === t) { | ||
| return r(e, n); | ||
| function _2(o, a0, a1) { | ||
| var arity = o.length; | ||
| if (2 === arity) { | ||
| return o(a0, a1); | ||
| } else { | ||
| return (function curry_2(r, e, n, t) { | ||
| switch (t) { | ||
| return (function curry_2(o, a0, a1, arity) { | ||
| switch (arity) { | ||
| case 1: | ||
| return app(r(e), [n]); | ||
| return app(o(a0), [a1]); | ||
| case 2: | ||
| return r(e, n); | ||
| return o(a0, a1); | ||
| case 3: | ||
| return function(t) { | ||
| return r(e, n, t); | ||
| return function(param) { | ||
| return o(a0, a1, param); | ||
| }; | ||
| case 4: | ||
| return function(t, u) { | ||
| return r(e, n, t, u); | ||
| return function(param, param$1) { | ||
| return o(a0, a1, param, param$1); | ||
| }; | ||
| case 5: | ||
| return function(t, u, i) { | ||
| return r(e, n, t, u, i); | ||
| return function(param, param$1, param$2) { | ||
| return o(a0, a1, param, param$1, param$2); | ||
| }; | ||
| case 6: | ||
| return function(t, u, i, f) { | ||
| return r(e, n, t, u, i, f); | ||
| return function(param, param$1, param$2, param$3) { | ||
| return o(a0, a1, param, param$1, param$2, param$3); | ||
| }; | ||
| case 7: | ||
| return function(t, u, i, f, o) { | ||
| return r(e, n, t, u, i, f, o); | ||
| 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(r, [e, n]); | ||
| return app(o, [a0, a1]); | ||
| } | ||
| })(r, e, n, t); | ||
| })(o, a0, a1, arity); | ||
| } | ||
| } | ||
| function _3(r, e, n, t) { | ||
| var u = r.length; | ||
| if (3 === u) { | ||
| return r(e, n, t); | ||
| function _3(o, a0, a1, a2) { | ||
| var arity = o.length; | ||
| if (3 === arity) { | ||
| return o(a0, a1, a2); | ||
| } else { | ||
| return (function curry_3(r, e, n, t, u) { | ||
| switch (u) { | ||
| return (function curry_3(o, a0, a1, a2, arity) { | ||
| switch (arity) { | ||
| case 1: | ||
| return app(r(e), [n, t]); | ||
| return app(o(a0), [a1, a2]); | ||
| case 2: | ||
| return app(r(e, n), [t]); | ||
| return app(o(a0, a1), [a2]); | ||
| case 3: | ||
| return r(e, n, t); | ||
| return o(a0, a1, a2); | ||
| case 4: | ||
| return function(u) { | ||
| return r(e, n, t, u); | ||
| return function(param) { | ||
| return o(a0, a1, a2, param); | ||
| }; | ||
| case 5: | ||
| return function(u, i) { | ||
| return r(e, n, t, u, i); | ||
| return function(param, param$1) { | ||
| return o(a0, a1, a2, param, param$1); | ||
| }; | ||
| case 6: | ||
| return function(u, i, f) { | ||
| return r(e, n, t, u, i, f); | ||
| return function(param, param$1, param$2) { | ||
| return o(a0, a1, a2, param, param$1, param$2); | ||
| }; | ||
| case 7: | ||
| return function(u, i, f, o) { | ||
| return r(e, n, t, u, i, f, o); | ||
| return function(param, param$1, param$2, param$3) { | ||
| return o(a0, a1, a2, param, param$1, param$2, param$3); | ||
| }; | ||
| default: | ||
| return app(r, [e, n, t]); | ||
| return app(o, [a0, a1, a2]); | ||
| } | ||
| })(r, e, n, t, u); | ||
| })(o, a0, a1, a2, arity); | ||
| } | ||
| } | ||
| var r = []; | ||
| var undefinedHeader = []; | ||
| 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; | ||
| function some(x) { | ||
| if (void 0 === x) { | ||
| var block = [undefinedHeader, 0]; | ||
| block.tag = 256; | ||
| return block; | ||
| } else if (null !== x && x[0] === undefinedHeader) { | ||
| var nid = (x[1] + 1) | 0; | ||
| var block$1 = [undefinedHeader, nid]; | ||
| block$1.tag = 256; | ||
| return block$1; | ||
| } else { | ||
| return e; | ||
| return x; | ||
| } | ||
| } | ||
| function valFromOption(e) { | ||
| if (null !== e && e[0] === r) { | ||
| var n = e[1]; | ||
| if (0 === n) { | ||
| function valFromOption(x) { | ||
| if (null !== x && x[0] === undefinedHeader) { | ||
| var depth = x[1]; | ||
| if (0 === depth) { | ||
| return; | ||
| } else { | ||
| return [r, (n - 1) | 0]; | ||
| return [undefinedHeader, (depth - 1) | 0]; | ||
| } | ||
| } else { | ||
| return e; | ||
| return x; | ||
| } | ||
| } | ||
| function talkbackPlaceholder(r) { | ||
| function talkbackPlaceholder(param) { | ||
| return 0; | ||
| } | ||
| function captureTalkback(r, e) { | ||
| var n = [talkbackPlaceholder]; | ||
| return _1(r, function(r) { | ||
| if ("number" != typeof r) { | ||
| if (!r.tag) { | ||
| n[0] = r[0]; | ||
| function captureTalkback(source, sinkWithTalkback) { | ||
| var talkback = [talkbackPlaceholder]; | ||
| return _1(source, function(signal) { | ||
| if ("number" != typeof signal) { | ||
| if (!signal.tag) { | ||
| talkback[0] = signal[0]; | ||
| } | ||
| } | ||
| return e(r, n[0]); | ||
| return sinkWithTalkback(signal, talkback[0]); | ||
| }); | ||
| } | ||
| function makeSubject(r) { | ||
| var e = [new Array(), !1]; | ||
| function makeSubject(param) { | ||
| var state = [new Array(), !1]; | ||
| return [ | ||
| function(r) { | ||
| e[0] = e[0].concat(r); | ||
| return r( | ||
| function(sink) { | ||
| state[0] = state[0].concat(sink); | ||
| return sink( | ||
| __(0, [ | ||
| function(n) { | ||
| if (1 === n) { | ||
| e[0] = e[0].filter(function(e) { | ||
| return e !== r; | ||
| function(signal) { | ||
| if (1 === signal) { | ||
| state[0] = state[0].filter(function(x) { | ||
| return x !== sink; | ||
| }); | ||
@@ -252,8 +252,8 @@ return 0; | ||
| }, | ||
| function(r) { | ||
| if (e[1]) { | ||
| function(value) { | ||
| if (state[1]) { | ||
| return 0; | ||
| } else { | ||
| e[0].forEach(function(e) { | ||
| return e(__(1, [r])); | ||
| state[0].forEach(function(sink) { | ||
| return sink(__(1, [value])); | ||
| }); | ||
@@ -263,9 +263,9 @@ return 0; | ||
| }, | ||
| function(r) { | ||
| if (e[1]) { | ||
| function(param) { | ||
| if (state[1]) { | ||
| return 0; | ||
| } else { | ||
| e[1] = !0; | ||
| e[0].forEach(function(r) { | ||
| return r(0); | ||
| state[1] = !0; | ||
| state[0].forEach(function(sink) { | ||
| return sink(0); | ||
| }); | ||
@@ -278,17 +278,17 @@ return 0; | ||
| function make$2(r) { | ||
| return function(e) { | ||
| var n = _1(r, [ | ||
| function(r) { | ||
| return e(__(1, [r])); | ||
| function make$2(f) { | ||
| return function(sink) { | ||
| var teardown = _1(f, [ | ||
| function(value) { | ||
| return sink(__(1, [value])); | ||
| }, | ||
| function(r) { | ||
| return e(0); | ||
| function(param) { | ||
| return sink(0); | ||
| } | ||
| ]); | ||
| return e( | ||
| return sink( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| return _1(n, 0); | ||
| function(signal) { | ||
| if (signal) { | ||
| return _1(teardown, 0); | ||
| } else { | ||
@@ -303,30 +303,30 @@ return 0; | ||
| function fromList(r) { | ||
| return function(e) { | ||
| var n = [r, !1, !1, !1]; | ||
| return e( | ||
| function fromList(ls) { | ||
| return function(sink) { | ||
| var state = [ls, !1, !1, !1]; | ||
| return sink( | ||
| __(0, [ | ||
| function(r) { | ||
| var t = n[2]; | ||
| if (r) { | ||
| n[1] = !0; | ||
| function(signal) { | ||
| var match = state[2]; | ||
| if (signal) { | ||
| state[1] = !0; | ||
| return 0; | ||
| } else if (t) { | ||
| n[3] = !0; | ||
| } else if (match) { | ||
| state[3] = !0; | ||
| return 0; | ||
| } else { | ||
| 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]])); | ||
| state[3] = !0; | ||
| state[2] = !0; | ||
| while (state[3] && !state[1]) { | ||
| var match$1 = state[0]; | ||
| if (match$1) { | ||
| state[0] = match$1[1]; | ||
| state[3] = !1; | ||
| sink(__(1, [match$1[0]])); | ||
| } else { | ||
| n[1] = !0; | ||
| e(0); | ||
| state[1] = !0; | ||
| sink(0); | ||
| } | ||
| } | ||
| n[2] = !1; | ||
| state[2] = !1; | ||
| return 0; | ||
@@ -340,32 +340,32 @@ } | ||
| function fromArray(r) { | ||
| return function(e) { | ||
| var n = r.length; | ||
| var t = [0, !1, !1, !1]; | ||
| return e( | ||
| function fromArray(arr) { | ||
| return function(sink) { | ||
| var size = arr.length; | ||
| var state = [0, !1, !1, !1]; | ||
| return sink( | ||
| __(0, [ | ||
| function(u) { | ||
| var i = t[2]; | ||
| if (u) { | ||
| t[1] = !0; | ||
| function(signal) { | ||
| var match = state[2]; | ||
| if (signal) { | ||
| state[1] = !0; | ||
| return 0; | ||
| } else if (i) { | ||
| t[3] = !0; | ||
| } else if (match) { | ||
| state[3] = !0; | ||
| return 0; | ||
| } else { | ||
| 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])); | ||
| state[3] = !0; | ||
| state[2] = !0; | ||
| while (state[3] && !state[1]) { | ||
| var index = state[0]; | ||
| if (index < size) { | ||
| var x = arr[index]; | ||
| state[0] = (index + 1) | 0; | ||
| state[3] = !1; | ||
| sink(__(1, [x])); | ||
| } else { | ||
| t[1] = !0; | ||
| e(0); | ||
| state[1] = !0; | ||
| sink(0); | ||
| } | ||
| } | ||
| t[2] = !1; | ||
| state[2] = !1; | ||
| return 0; | ||
@@ -379,14 +379,14 @@ } | ||
| function fromValue(r) { | ||
| return function(e) { | ||
| var n = [!1]; | ||
| return e( | ||
| function fromValue(x) { | ||
| return function(sink) { | ||
| var ended = [!1]; | ||
| return sink( | ||
| __(0, [ | ||
| function(t) { | ||
| if (t || n[0]) { | ||
| function(signal) { | ||
| if (signal || ended[0]) { | ||
| return 0; | ||
| } else { | ||
| n[0] = !0; | ||
| e(__(1, [r])); | ||
| return e(0); | ||
| ended[0] = !0; | ||
| sink(__(1, [x])); | ||
| return sink(0); | ||
| } | ||
@@ -399,18 +399,23 @@ } | ||
| function empty(r) { | ||
| r(__(0, [talkbackPlaceholder])); | ||
| return r(0); | ||
| function empty(sink) { | ||
| sink(__(0, [talkbackPlaceholder])); | ||
| return sink(0); | ||
| } | ||
| function never(r) { | ||
| return r(__(0, [talkbackPlaceholder])); | ||
| function never(sink) { | ||
| return sink(__(0, [talkbackPlaceholder])); | ||
| } | ||
| 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); | ||
| function map$1(f) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| return _1(source, function(signal) { | ||
| var tmp; | ||
| tmp = | ||
| "number" == typeof signal | ||
| ? 0 | ||
| : signal.tag | ||
| ? __(1, [_1(f, signal[0])]) | ||
| : __(0, [signal[0]]); | ||
| return sink(tmp); | ||
| }); | ||
@@ -421,10 +426,10 @@ }; | ||
| 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); | ||
| function filter(f) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| return captureTalkback(source, function(signal, talkback) { | ||
| if ("number" == typeof signal || !signal.tag || _1(f, signal[0])) { | ||
| return sink(signal); | ||
| } else { | ||
| return t(0); | ||
| return talkback(0); | ||
| } | ||
@@ -436,17 +441,17 @@ }); | ||
| 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]]); | ||
| function scan(f, seed) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var acc = [seed]; | ||
| return _1(source, function(signal) { | ||
| var tmp; | ||
| if ("number" == typeof signal) { | ||
| tmp = 0; | ||
| } else if (signal.tag) { | ||
| acc[0] = _2(f, acc[0], signal[0]); | ||
| tmp = __(1, [acc[0]]); | ||
| } else { | ||
| n = __(0, [e[0]]); | ||
| tmp = __(0, [signal[0]]); | ||
| } | ||
| return t(n); | ||
| return sink(tmp); | ||
| }); | ||
@@ -457,18 +462,18 @@ }; | ||
| 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; | ||
| function merge(sources) { | ||
| return function(sink) { | ||
| var size = sources.length; | ||
| var talkbacks = (function make$1(len, vals) { | ||
| var res = new Array(len); | ||
| res.fill(vals); | ||
| return res; | ||
| })(size, talkbackPlaceholder); | ||
| var state = [0, 0]; | ||
| var talkback = function(signal) { | ||
| var _i = 0; | ||
| while (1) { | ||
| var u = e; | ||
| if (u < n) { | ||
| t[u](r); | ||
| e = (u + 1) | 0; | ||
| var i = _i; | ||
| if (i < size) { | ||
| talkbacks[i](signal); | ||
| _i = (i + 1) | 0; | ||
| continue; | ||
@@ -480,24 +485,24 @@ } else { | ||
| }; | ||
| var f = 0; | ||
| var _i = 0; | ||
| while (1) { | ||
| var o = f; | ||
| if (o < n) { | ||
| var i = _i; | ||
| if (i < size) { | ||
| _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); | ||
| sources[i], | ||
| (function(i) { | ||
| return function(signal) { | ||
| if ("number" == typeof signal) { | ||
| state[1] = (state[1] + 1) | 0; | ||
| if (state[1] === size) { | ||
| return sink(0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else if (f.tag) { | ||
| return e(f); | ||
| } else if (signal.tag) { | ||
| return sink(signal); | ||
| } else { | ||
| t[r] = f[0]; | ||
| u[0] = (u[0] + 1) | 0; | ||
| if (u[0] === n) { | ||
| return e(__(0, [i])); | ||
| talkbacks[i] = signal[0]; | ||
| state[0] = (state[0] + 1) | 0; | ||
| if (state[0] === size) { | ||
| return sink(__(0, [talkback])); | ||
| } else { | ||
@@ -508,5 +513,5 @@ return 0; | ||
| }; | ||
| })(o) | ||
| })(i) | ||
| ); | ||
| f = (o + 1) | 0; | ||
| _i = (i + 1) | 0; | ||
| continue; | ||
@@ -520,21 +525,21 @@ } else { | ||
| 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); | ||
| function concat$1(sources) { | ||
| return function(sink) { | ||
| var size = sources.length; | ||
| var talkback = [talkbackPlaceholder]; | ||
| var nextSource = function(i) { | ||
| if (i < size) { | ||
| return _1(sources[i], function(signal) { | ||
| if ("number" == typeof signal) { | ||
| return nextSource((i + 1) | 0); | ||
| } else if (signal.tag) { | ||
| return sink(signal); | ||
| } else { | ||
| var n = r[0]; | ||
| t[0] = n; | ||
| var tb = signal[0]; | ||
| talkback[0] = tb; | ||
| if (0 === i) { | ||
| e( | ||
| sink( | ||
| __(0, [ | ||
| function(r) { | ||
| return t[0](r); | ||
| function(signal) { | ||
| return talkback[0](signal); | ||
| } | ||
@@ -544,33 +549,33 @@ ]) | ||
| } | ||
| return n(0); | ||
| return tb(0); | ||
| } | ||
| }); | ||
| } else { | ||
| return e(0); | ||
| return sink(0); | ||
| } | ||
| }; | ||
| return u(0); | ||
| return nextSource(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); | ||
| function share(source) { | ||
| var state = [new Array(), talkbackPlaceholder, !1]; | ||
| return function(sink) { | ||
| state[0] = state[0].concat(sink); | ||
| if (1 === state[0].length) { | ||
| _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| state[0].forEach(function(sink) { | ||
| return sink(0); | ||
| }); | ||
| e[0] = new Array(); | ||
| state[0] = new Array(); | ||
| return 0; | ||
| } else if (r.tag) { | ||
| e[2] = !1; | ||
| e[0].forEach(function(e) { | ||
| return e(r); | ||
| } else if (signal.tag) { | ||
| state[2] = !1; | ||
| state[0].forEach(function(sink) { | ||
| return sink(signal); | ||
| }); | ||
| return 0; | ||
| } else { | ||
| e[1] = r[0]; | ||
| state[1] = signal[0]; | ||
| return 0; | ||
@@ -580,19 +585,19 @@ } | ||
| } | ||
| return n( | ||
| return sink( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| e[0] = e[0].filter(function(r) { | ||
| return r !== n; | ||
| function(signal) { | ||
| if (signal) { | ||
| state[0] = state[0].filter(function(x) { | ||
| return x !== sink; | ||
| }); | ||
| if (0 === e[0].length) { | ||
| return e[1](1); | ||
| if (0 === state[0].length) { | ||
| return state[1](1); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else if (e[2]) { | ||
| } else if (state[2]) { | ||
| return 0; | ||
| } else { | ||
| e[2] = !0; | ||
| return e[1](r); | ||
| state[2] = !0; | ||
| return state[1](signal); | ||
| } | ||
@@ -605,84 +610,84 @@ } | ||
| 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; | ||
| function combine(sourceA, sourceB) { | ||
| return function(sink) { | ||
| var state = [talkbackPlaceholder, talkbackPlaceholder, void 0, void 0, !1, 0, !1]; | ||
| _1(sourceA, function(signal) { | ||
| var match = state[3]; | ||
| if ("number" == typeof signal) { | ||
| if (state[5] < 1) { | ||
| state[5] = (state[5] + 1) | 0; | ||
| return 0; | ||
| } else if (t[6]) { | ||
| } else if (state[6]) { | ||
| return 0; | ||
| } else { | ||
| t[6] = !0; | ||
| return n(0); | ||
| state[6] = !0; | ||
| return sink(0); | ||
| } | ||
| } else if (r.tag) { | ||
| var u = r[0]; | ||
| if (void 0 !== e) { | ||
| if (t[6]) { | ||
| } else if (signal.tag) { | ||
| var a = signal[0]; | ||
| if (void 0 !== match) { | ||
| if (state[6]) { | ||
| return 0; | ||
| } else { | ||
| t[2] = some(u); | ||
| t[4] = !1; | ||
| return n(__(1, [[u, valFromOption(e)]])); | ||
| state[2] = some(a); | ||
| state[4] = !1; | ||
| return sink(__(1, [[a, valFromOption(match)]])); | ||
| } | ||
| } else { | ||
| t[2] = some(u); | ||
| t[4] = !1; | ||
| state[2] = some(a); | ||
| state[4] = !1; | ||
| return 0; | ||
| } | ||
| } else { | ||
| t[0] = r[0]; | ||
| state[0] = signal[0]; | ||
| return 0; | ||
| } | ||
| }); | ||
| _1(e, function(r) { | ||
| var e = t[2]; | ||
| if ("number" == typeof r) { | ||
| if (t[5] < 1) { | ||
| t[5] = (t[5] + 1) | 0; | ||
| _1(sourceB, function(signal) { | ||
| var match = state[2]; | ||
| if ("number" == typeof signal) { | ||
| if (state[5] < 1) { | ||
| state[5] = (state[5] + 1) | 0; | ||
| return 0; | ||
| } else if (t[6]) { | ||
| } else if (state[6]) { | ||
| return 0; | ||
| } else { | ||
| t[6] = !0; | ||
| return n(0); | ||
| state[6] = !0; | ||
| return sink(0); | ||
| } | ||
| } else if (r.tag) { | ||
| var u = r[0]; | ||
| if (void 0 !== e) { | ||
| if (t[6]) { | ||
| } else if (signal.tag) { | ||
| var b = signal[0]; | ||
| if (void 0 !== match) { | ||
| if (state[6]) { | ||
| return 0; | ||
| } else { | ||
| t[3] = some(u); | ||
| t[4] = !1; | ||
| return n(__(1, [[valFromOption(e), u]])); | ||
| state[3] = some(b); | ||
| state[4] = !1; | ||
| return sink(__(1, [[valFromOption(match), b]])); | ||
| } | ||
| } else { | ||
| t[3] = some(u); | ||
| t[4] = !1; | ||
| state[3] = some(b); | ||
| state[4] = !1; | ||
| return 0; | ||
| } | ||
| } else { | ||
| t[1] = r[0]; | ||
| state[1] = signal[0]; | ||
| return 0; | ||
| } | ||
| }); | ||
| return n( | ||
| return sink( | ||
| __(0, [ | ||
| function(r) { | ||
| if (t[6]) { | ||
| function(signal) { | ||
| if (state[6]) { | ||
| return 0; | ||
| } else if (r) { | ||
| t[6] = !0; | ||
| t[0](1); | ||
| return t[1](1); | ||
| } else if (t[4]) { | ||
| } else if (signal) { | ||
| state[6] = !0; | ||
| state[0](1); | ||
| return state[1](1); | ||
| } else if (state[4]) { | ||
| return 0; | ||
| } else { | ||
| t[4] = !0; | ||
| t[0](r); | ||
| return t[1](r); | ||
| state[4] = !0; | ||
| state[0](signal); | ||
| return state[1](signal); | ||
| } | ||
@@ -695,21 +700,21 @@ } | ||
| 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); | ||
| function take(max) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var state = [0, talkbackPlaceholder]; | ||
| _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| if (state[0] < max) { | ||
| state[0] = max; | ||
| return sink(0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } 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 if (signal.tag) { | ||
| if (state[0] < max) { | ||
| state[0] = (state[0] + 1) | 0; | ||
| sink(signal); | ||
| if (state[0] === max) { | ||
| sink(0); | ||
| return state[1](1); | ||
| } else { | ||
@@ -722,15 +727,15 @@ return 0; | ||
| } else { | ||
| t[1] = e[0]; | ||
| state[1] = signal[0]; | ||
| return 0; | ||
| } | ||
| }); | ||
| return n( | ||
| return sink( | ||
| __(0, [ | ||
| function(e) { | ||
| if (t[0] < r) { | ||
| if (e) { | ||
| t[0] = r; | ||
| return t[1](1); | ||
| function(signal) { | ||
| if (state[0] < max) { | ||
| if (signal) { | ||
| state[0] = max; | ||
| return state[1](1); | ||
| } else { | ||
| return t[1](0); | ||
| return state[1](0); | ||
| } | ||
@@ -747,29 +752,29 @@ } else { | ||
| 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( | ||
| function takeLast(max) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var queue = new Array(); | ||
| return captureTalkback(source, function(signal, talkback) { | ||
| if ("number" == typeof signal) { | ||
| return (function makeTrampoline(sink, f) { | ||
| var state = [!1, !1, !1]; | ||
| return sink( | ||
| __(0, [ | ||
| function(t) { | ||
| var u = n[0]; | ||
| if (t || u) { | ||
| function(signal) { | ||
| var match = state[0]; | ||
| if (signal || match) { | ||
| return 0; | ||
| } else { | ||
| n[2] = !0; | ||
| if (n[1]) { | ||
| state[2] = !0; | ||
| if (state[1]) { | ||
| return 0; | ||
| } else { | ||
| n[1] = !0; | ||
| !(function(t) { | ||
| state[1] = !0; | ||
| !(function(_param) { | ||
| while (1) { | ||
| var u = e(); | ||
| if (void 0 !== u) { | ||
| n[2] = !1; | ||
| r(__(1, [valFromOption(u)])); | ||
| if (n[2]) { | ||
| var match = f(); | ||
| if (void 0 !== match) { | ||
| state[2] = !1; | ||
| sink(__(1, [valFromOption(match)])); | ||
| if (state[2]) { | ||
| continue; | ||
@@ -780,8 +785,8 @@ } else { | ||
| } else { | ||
| n[0] = !0; | ||
| return r(0); | ||
| state[0] = !0; | ||
| return sink(0); | ||
| } | ||
| } | ||
| })(); | ||
| n[1] = !1; | ||
| state[1] = !1; | ||
| return 0; | ||
@@ -793,13 +798,13 @@ } | ||
| ); | ||
| })(n, function() { | ||
| return t.shift(); | ||
| })(sink, function() { | ||
| return queue.shift(); | ||
| }); | ||
| } else if (e.tag) { | ||
| if (t.length >= r && r > 0) { | ||
| t.shift(); | ||
| } else if (signal.tag) { | ||
| if (queue.length >= max && max > 0) { | ||
| queue.shift(); | ||
| } | ||
| t.push(e[0]); | ||
| return u(0); | ||
| queue.push(signal[0]); | ||
| return talkback(0); | ||
| } else { | ||
| return u(0); | ||
| return talkback(0); | ||
| } | ||
@@ -811,40 +816,40 @@ }); | ||
| 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]) { | ||
| function takeWhile(predicate) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var ended = [!1]; | ||
| var talkback = [talkbackPlaceholder]; | ||
| _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| if (ended[0]) { | ||
| return 0; | ||
| } else { | ||
| t[0] = !0; | ||
| return n(0); | ||
| ended[0] = !0; | ||
| return sink(0); | ||
| } | ||
| } else if (e.tag) { | ||
| if (t[0]) { | ||
| } else if (signal.tag) { | ||
| if (ended[0]) { | ||
| return 0; | ||
| } else if (_1(r, e[0])) { | ||
| return n(e); | ||
| } else if (_1(predicate, signal[0])) { | ||
| return sink(signal); | ||
| } else { | ||
| t[0] = !0; | ||
| n(0); | ||
| return u[0](1); | ||
| ended[0] = !0; | ||
| sink(0); | ||
| return talkback[0](1); | ||
| } | ||
| } else { | ||
| u[0] = e[0]; | ||
| return n(e); | ||
| talkback[0] = signal[0]; | ||
| return sink(signal); | ||
| } | ||
| }); | ||
| return n( | ||
| return sink( | ||
| __(0, [ | ||
| function(r) { | ||
| if (t[0]) { | ||
| function(signal) { | ||
| if (ended[0]) { | ||
| return 0; | ||
| } else if (r) { | ||
| t[0] = !0; | ||
| return u[0](1); | ||
| } else if (signal) { | ||
| ended[0] = !0; | ||
| return talkback[0](1); | ||
| } else { | ||
| return u[0](0); | ||
| return talkback[0](0); | ||
| } | ||
@@ -858,35 +863,35 @@ } | ||
| 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]) { | ||
| function takeUntil(notifier) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var state = [!1, talkbackPlaceholder, talkbackPlaceholder]; | ||
| _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| if (state[0]) { | ||
| return 0; | ||
| } else { | ||
| t[2](1); | ||
| t[0] = !0; | ||
| return n(0); | ||
| state[2](1); | ||
| state[0] = !0; | ||
| return sink(0); | ||
| } | ||
| } else if (e.tag) { | ||
| if (t[0]) { | ||
| } else if (signal.tag) { | ||
| if (state[0]) { | ||
| return 0; | ||
| } else { | ||
| return n(e); | ||
| return sink(signal); | ||
| } | ||
| } else { | ||
| t[1] = e[0]; | ||
| return _1(r, function(r) { | ||
| if ("number" == typeof r) { | ||
| state[1] = signal[0]; | ||
| return _1(notifier, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| return 0; | ||
| } else if (r.tag) { | ||
| t[0] = !0; | ||
| t[2](1); | ||
| t[1](1); | ||
| return n(0); | ||
| } else if (signal.tag) { | ||
| state[0] = !0; | ||
| state[2](1); | ||
| state[1](1); | ||
| return sink(0); | ||
| } else { | ||
| var e = r[0]; | ||
| t[2] = e; | ||
| return e(0); | ||
| var innerTb = signal[0]; | ||
| state[2] = innerTb; | ||
| return innerTb(0); | ||
| } | ||
@@ -896,12 +901,12 @@ }); | ||
| }); | ||
| return n( | ||
| return sink( | ||
| __(0, [ | ||
| function(r) { | ||
| if (t[0]) { | ||
| function(signal) { | ||
| if (state[0]) { | ||
| return 0; | ||
| } else if (r) { | ||
| t[1](1); | ||
| return t[2](1); | ||
| } else if (signal) { | ||
| state[1](1); | ||
| return state[2](1); | ||
| } else { | ||
| return t[1](0); | ||
| return state[1](0); | ||
| } | ||
@@ -915,12 +920,12 @@ } | ||
| 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); | ||
| function skip(wait) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var rest = [wait]; | ||
| return captureTalkback(source, function(signal, talkback) { | ||
| if ("number" == typeof signal || !(signal.tag && rest[0] > 0)) { | ||
| return sink(signal); | ||
| } else { | ||
| t[0] = (t[0] - 1) | 0; | ||
| return e(0); | ||
| rest[0] = (rest[0] - 1) | 0; | ||
| return talkback(0); | ||
| } | ||
@@ -932,14 +937,14 @@ }); | ||
| 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); | ||
| function skipWhile(predicate) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var skip = [!0]; | ||
| return captureTalkback(source, function(signal, talkback) { | ||
| if ("number" == typeof signal || !signal.tag || !skip[0]) { | ||
| return sink(signal); | ||
| } else if (_1(predicate, signal[0])) { | ||
| return talkback(0); | ||
| } else { | ||
| t[0] = !1; | ||
| return n(e); | ||
| skip[0] = !1; | ||
| return sink(signal); | ||
| } | ||
@@ -951,36 +956,36 @@ }); | ||
| 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); | ||
| function skipUntil(notifier) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var state = [!0, !1, !1, talkbackPlaceholder, talkbackPlaceholder]; | ||
| _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| if (state[0]) { | ||
| state[4](1); | ||
| } | ||
| t[1] = !0; | ||
| return n(0); | ||
| } else if (e.tag) { | ||
| if (t[0] && !t[1]) { | ||
| return t[3](0); | ||
| } else if (t[1]) { | ||
| state[1] = !0; | ||
| return sink(0); | ||
| } else if (signal.tag) { | ||
| if (state[0] && !state[1]) { | ||
| return state[3](0); | ||
| } else if (state[1]) { | ||
| return 0; | ||
| } else { | ||
| t[2] = !1; | ||
| return n(e); | ||
| state[2] = !1; | ||
| return sink(signal); | ||
| } | ||
| } else { | ||
| var u = e[0]; | ||
| t[3] = u; | ||
| return _1(r, function(r) { | ||
| if ("number" == typeof r) { | ||
| var tb = signal[0]; | ||
| state[3] = tb; | ||
| return _1(notifier, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| return 0; | ||
| } else if (r.tag) { | ||
| t[0] = !1; | ||
| return t[4](1); | ||
| } else if (signal.tag) { | ||
| state[0] = !1; | ||
| return state[4](1); | ||
| } else { | ||
| var e = r[0]; | ||
| t[4] = e; | ||
| e(0); | ||
| return u(0); | ||
| var innerTb = signal[0]; | ||
| state[4] = innerTb; | ||
| innerTb(0); | ||
| return tb(0); | ||
| } | ||
@@ -990,14 +995,14 @@ }); | ||
| }); | ||
| return n( | ||
| return sink( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| if (t[0]) { | ||
| t[4](1); | ||
| function(signal) { | ||
| if (signal) { | ||
| if (state[0]) { | ||
| state[4](1); | ||
| } | ||
| t[1] = !0; | ||
| return t[3](1); | ||
| } else if (!t[2] && !t[1]) { | ||
| t[2] = !0; | ||
| return t[3](0); | ||
| state[1] = !0; | ||
| return state[3](1); | ||
| } else if (!state[2] && !state[1]) { | ||
| state[2] = !0; | ||
| return state[3](0); | ||
| } else { | ||
@@ -1013,51 +1018,51 @@ return 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); | ||
| function flatten(source) { | ||
| return function(sink) { | ||
| var state = [talkbackPlaceholder, talkbackPlaceholder, !1, !0]; | ||
| _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| if (state[3]) { | ||
| return sink(0); | ||
| } else { | ||
| n[2] = !0; | ||
| state[2] = !0; | ||
| return 0; | ||
| } | ||
| } else if (r.tag) { | ||
| return _1(r[0], function(r) { | ||
| if ("number" == typeof r) { | ||
| if (n[2]) { | ||
| return n[0](1); | ||
| } else if (signal.tag) { | ||
| return _1(signal[0], function(signal) { | ||
| if ("number" == typeof signal) { | ||
| if (state[2]) { | ||
| return state[0](1); | ||
| } else { | ||
| n[3] = !0; | ||
| return n[0](0); | ||
| state[3] = !0; | ||
| return state[0](0); | ||
| } | ||
| } else if (r.tag) { | ||
| return e(r); | ||
| } else if (signal.tag) { | ||
| return sink(signal); | ||
| } else { | ||
| var t = r[0]; | ||
| if (!n[3]) { | ||
| n[1](1); | ||
| var tb = signal[0]; | ||
| if (!state[3]) { | ||
| state[1](1); | ||
| } | ||
| n[3] = !1; | ||
| n[1] = t; | ||
| return t(0); | ||
| state[3] = !1; | ||
| state[1] = tb; | ||
| return tb(0); | ||
| } | ||
| }); | ||
| } else { | ||
| n[0] = r[0]; | ||
| state[0] = signal[0]; | ||
| return 0; | ||
| } | ||
| }); | ||
| return e( | ||
| return sink( | ||
| __(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]) { | ||
| function(signal) { | ||
| if (signal) { | ||
| state[0](1); | ||
| return state[1](1); | ||
| } else if (!state[3] && !state[2]) { | ||
| return state[1](0); | ||
| } else if (state[2]) { | ||
| return 0; | ||
| } else { | ||
| return n[0](0); | ||
| return state[0](0); | ||
| } | ||
@@ -1070,12 +1075,12 @@ } | ||
| function forEach$1(r) { | ||
| return function(e) { | ||
| return captureTalkback(e, function(e, n) { | ||
| if ("number" == typeof e) { | ||
| function forEach$1(f) { | ||
| return function(source) { | ||
| return captureTalkback(source, function(signal, talkback) { | ||
| if ("number" == typeof signal) { | ||
| return 0; | ||
| } else if (e.tag) { | ||
| _1(r, e[0]); | ||
| return n(0); | ||
| } else if (signal.tag) { | ||
| _1(f, signal[0]); | ||
| return talkback(0); | ||
| } else { | ||
| return n(0); | ||
| return talkback(0); | ||
| } | ||
@@ -1086,27 +1091,27 @@ }); | ||
| function subscribe(r) { | ||
| return function(e) { | ||
| var n = [talkbackPlaceholder]; | ||
| var t = [!1]; | ||
| _1(e, function(e) { | ||
| if ("number" == typeof e) { | ||
| function subscribe(f) { | ||
| return function(source) { | ||
| var talkback = [talkbackPlaceholder]; | ||
| var ended = [!1]; | ||
| _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| return 0; | ||
| } else if (e.tag) { | ||
| if (t[0]) { | ||
| } else if (signal.tag) { | ||
| if (ended[0]) { | ||
| return 0; | ||
| } else { | ||
| _1(r, e[0]); | ||
| return n[0](0); | ||
| _1(f, signal[0]); | ||
| return talkback[0](0); | ||
| } | ||
| } else { | ||
| n[0] = e[0]; | ||
| return n[0](0); | ||
| talkback[0] = signal[0]; | ||
| return talkback[0](0); | ||
| } | ||
| }); | ||
| return function(r) { | ||
| if (t[0]) { | ||
| return function(param) { | ||
| if (ended[0]) { | ||
| return 0; | ||
| } else { | ||
| t[0] = !0; | ||
| return n[0](1); | ||
| ended[0] = !0; | ||
| return talkback[0](1); | ||
| } | ||
@@ -1117,14 +1122,14 @@ }; | ||
| var e = 0; | ||
| var Types = 0; | ||
| function fromListener(r, e) { | ||
| return function(n) { | ||
| var t = function(r) { | ||
| return n(__(1, [r])); | ||
| function fromListener(addListener, removeListener) { | ||
| return function(sink) { | ||
| var handler = function($$event) { | ||
| return sink(__(1, [$$event])); | ||
| }; | ||
| n( | ||
| sink( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| return _1(e, t); | ||
| function(signal) { | ||
| if (signal) { | ||
| return _1(removeListener, handler); | ||
| } else { | ||
@@ -1136,38 +1141,38 @@ return 0; | ||
| ); | ||
| return _1(r, t); | ||
| return _1(addListener, handler); | ||
| }; | ||
| } | ||
| function fromDomEvent(r, e) { | ||
| return function(n) { | ||
| var t = function(r, e, n) { | ||
| r.addEventListener(e, n); | ||
| function fromDomEvent(element, $$event) { | ||
| return function(sink) { | ||
| var addEventListener = function(element, event, handler) { | ||
| element.addEventListener(event, handler); | ||
| }; | ||
| var u = function(r, e, n) { | ||
| r.removeEventListener(e, n); | ||
| var removeEventListener = function(element, event, handler) { | ||
| element.removeEventListener(event, handler); | ||
| }; | ||
| return fromListener( | ||
| function(n) { | ||
| return _3(t, r, e, n); | ||
| function(handler) { | ||
| return _3(addEventListener, element, $$event, handler); | ||
| }, | ||
| function(n) { | ||
| return _3(u, r, e, n); | ||
| function(handler) { | ||
| return _3(removeEventListener, element, $$event, handler); | ||
| } | ||
| )(n); | ||
| )(sink); | ||
| }; | ||
| } | ||
| 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( | ||
| function interval(p) { | ||
| return function(sink) { | ||
| var i = [0]; | ||
| var id = setInterval(function(param) { | ||
| var num = i[0]; | ||
| i[0] = (i[0] + 1) | 0; | ||
| return sink(__(1, [num])); | ||
| }, p); | ||
| return sink( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| clearInterval(t); | ||
| function(signal) { | ||
| if (signal) { | ||
| clearInterval(id); | ||
| return 0; | ||
@@ -1183,17 +1188,17 @@ } else { | ||
| function fromPromise(r) { | ||
| return function(e) { | ||
| var n = [!1]; | ||
| r.then(function(r) { | ||
| if (!n[0]) { | ||
| e(__(1, [r])); | ||
| e(0); | ||
| function fromPromise(promise) { | ||
| return function(sink) { | ||
| var ended = [!1]; | ||
| promise.then(function(value) { | ||
| if (!ended[0]) { | ||
| sink(__(1, [value])); | ||
| sink(0); | ||
| } | ||
| return Promise.resolve(0); | ||
| }); | ||
| return e( | ||
| return sink( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| n[0] = !0; | ||
| function(signal) { | ||
| if (signal) { | ||
| ended[0] = !0; | ||
| return 0; | ||
@@ -1209,12 +1214,12 @@ } else { | ||
| 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)); | ||
| function debounce(debounceF) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var gotEndSignal = [!1]; | ||
| var id = [void 0]; | ||
| var $$clearTimeout$1 = function(param) { | ||
| var match = id[0]; | ||
| if (void 0 !== match) { | ||
| id[0] = void 0; | ||
| clearTimeout(valFromOption(match)); | ||
| return 0; | ||
@@ -1225,34 +1230,34 @@ } else { | ||
| }; | ||
| return _1(e, function(e) { | ||
| if ("number" == typeof e) { | ||
| t[0] = !0; | ||
| if (void 0 !== u[0]) { | ||
| return _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| gotEndSignal[0] = !0; | ||
| if (void 0 !== id[0]) { | ||
| return 0; | ||
| } else { | ||
| return n(0); | ||
| return sink(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 if (signal.tag) { | ||
| $$clearTimeout$1(); | ||
| id[0] = some( | ||
| setTimeout(function(param) { | ||
| id[0] = void 0; | ||
| sink(signal); | ||
| if (gotEndSignal[0]) { | ||
| return sink(0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| }, _1(r, e[0])) | ||
| }, _1(debounceF, signal[0])) | ||
| ); | ||
| return 0; | ||
| } else { | ||
| var f = e[0]; | ||
| return n( | ||
| var tb = signal[0]; | ||
| return sink( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| i(); | ||
| return f(1); | ||
| function(signal) { | ||
| if (signal) { | ||
| $$clearTimeout$1(); | ||
| return tb(1); | ||
| } else { | ||
| return f(r); | ||
| return tb(signal); | ||
| } | ||
@@ -1268,11 +1273,11 @@ } | ||
| 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)); | ||
| function throttle(throttleF) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var skip = [!1]; | ||
| var id = [void 0]; | ||
| var $$clearTimeout$1 = function(param) { | ||
| var match = id[0]; | ||
| if (void 0 !== match) { | ||
| clearTimeout(valFromOption(match)); | ||
| return 0; | ||
@@ -1283,31 +1288,31 @@ } else { | ||
| }; | ||
| return _1(e, function(e) { | ||
| if ("number" == typeof e) { | ||
| i(); | ||
| return n(0); | ||
| } else if (e.tag) { | ||
| if (t[0]) { | ||
| return _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| $$clearTimeout$1(); | ||
| return sink(0); | ||
| } else if (signal.tag) { | ||
| if (skip[0]) { | ||
| return 0; | ||
| } else { | ||
| t[0] = !0; | ||
| i(); | ||
| u[0] = some( | ||
| setTimeout(function(r) { | ||
| u[0] = void 0; | ||
| t[0] = !1; | ||
| skip[0] = !0; | ||
| $$clearTimeout$1(); | ||
| id[0] = some( | ||
| setTimeout(function(param) { | ||
| id[0] = void 0; | ||
| skip[0] = !1; | ||
| return 0; | ||
| }, _1(r, e[0])) | ||
| }, _1(throttleF, signal[0])) | ||
| ); | ||
| return n(e); | ||
| return sink(signal); | ||
| } | ||
| } else { | ||
| var f = e[0]; | ||
| return n( | ||
| var tb = signal[0]; | ||
| return sink( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| i(); | ||
| return f(1); | ||
| function(signal) { | ||
| if (signal) { | ||
| $$clearTimeout$1(); | ||
| return tb(1); | ||
| } else { | ||
| return f(r); | ||
| return tb(signal); | ||
| } | ||
@@ -1323,38 +1328,38 @@ } | ||
| function sample(r) { | ||
| return function(e) { | ||
| return function(n) { | ||
| var t = [ | ||
| function sample(notifier) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var state = [ | ||
| !1, | ||
| void 0, | ||
| function(r) { | ||
| function(param) { | ||
| return 0; | ||
| }, | ||
| function(r) { | ||
| function(param) { | ||
| 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]); | ||
| _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| state[0] = !0; | ||
| state[3](1); | ||
| return sink(0); | ||
| } else if (signal.tag) { | ||
| state[1] = some(signal[0]); | ||
| return 0; | ||
| } else { | ||
| t[2] = r[0]; | ||
| state[2] = signal[0]; | ||
| return 0; | ||
| } | ||
| }); | ||
| _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)])); | ||
| _1(notifier, function(signal) { | ||
| var match = state[1]; | ||
| if ("number" == typeof signal) { | ||
| state[0] = !0; | ||
| state[2](1); | ||
| return sink(0); | ||
| } else if (signal.tag) { | ||
| if (void 0 !== match && !state[0]) { | ||
| state[1] = void 0; | ||
| return sink(__(1, [valFromOption(match)])); | ||
| } else { | ||
@@ -1364,16 +1369,16 @@ return 0; | ||
| } else { | ||
| t[3] = r[0]; | ||
| state[3] = signal[0]; | ||
| return 0; | ||
| } | ||
| }); | ||
| return n( | ||
| return sink( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| t[0] = !0; | ||
| t[2](1); | ||
| return t[3](1); | ||
| function(signal) { | ||
| if (signal) { | ||
| state[0] = !0; | ||
| state[2](1); | ||
| return state[3](1); | ||
| } else { | ||
| t[2](0); | ||
| return t[3](0); | ||
| state[2](0); | ||
| return state[3](0); | ||
| } | ||
@@ -1387,27 +1392,27 @@ } | ||
| 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; | ||
| function delay(wait) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var state = [talkbackPlaceholder, 0, !1]; | ||
| _1(source, function(signal) { | ||
| var exit = 0; | ||
| if ("number" == typeof signal || signal.tag) { | ||
| exit = 1; | ||
| } else { | ||
| t[0] = e[0]; | ||
| state[0] = signal[0]; | ||
| return 0; | ||
| } | ||
| if (1 === u) { | ||
| if (t[2]) { | ||
| if (1 === exit) { | ||
| if (state[2]) { | ||
| return 0; | ||
| } else { | ||
| t[1] = (t[1] + 1) | 0; | ||
| setTimeout(function(r) { | ||
| if (t[2] && 0 === t[1]) { | ||
| n(0); | ||
| state[1] = (state[1] + 1) | 0; | ||
| setTimeout(function(param) { | ||
| if (state[2] && 0 === state[1]) { | ||
| sink(0); | ||
| } else { | ||
| t[1] = (t[1] - 1) | 0; | ||
| state[1] = (state[1] - 1) | 0; | ||
| } | ||
| return n(e); | ||
| }, r); | ||
| return sink(signal); | ||
| }, wait); | ||
| return 0; | ||
@@ -1417,16 +1422,16 @@ } | ||
| }); | ||
| return n( | ||
| return sink( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| t[2] = !0; | ||
| if (0 === t[1]) { | ||
| return n(0); | ||
| function(signal) { | ||
| if (signal) { | ||
| state[2] = !0; | ||
| if (0 === state[1]) { | ||
| return sink(0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else if (t[2]) { | ||
| } else if (state[2]) { | ||
| return 0; | ||
| } else { | ||
| return t[0](r); | ||
| return state[0](signal); | ||
| } | ||
@@ -1442,3 +1447,3 @@ } | ||
| pipe, | ||
| e as Types, | ||
| Types, | ||
| makeSubject, | ||
@@ -1445,0 +1450,0 @@ make$2 as make, |
1835
dist/wonka.js
@@ -1,94 +0,36 @@ | ||
| 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; | ||
| function __(tag, block) { | ||
| block.tag = tag; | ||
| return block; | ||
| } | ||
| function __(r, e) { | ||
| e.tag = r; | ||
| return e; | ||
| } | ||
| var out_of_memory = ["Out_of_memory", 0]; | ||
| var sys_error = ["Sys_error", -1]; | ||
| var failure = ["Failure", -2]; | ||
| var invalid_argument = ["Invalid_argument", -3]; | ||
| var end_of_file = ["End_of_file", -4]; | ||
| var division_by_zero = ["Division_by_zero", -5]; | ||
| var not_found = ["Not_found", -6]; | ||
| var match_failure = ["Match_failure", -7]; | ||
| var stack_overflow = ["Stack_overflow", -8]; | ||
| var sys_blocked_io = ["Sys_blocked_io", -9]; | ||
| var assert_failure = ["Assert_failure", -10]; | ||
| var undefined_recursive_module = ["Undefined_recursive_module", -11]; | ||
| out_of_memory.tag = 248; | ||
| sys_error.tag = 248; | ||
| failure.tag = 248; | ||
| invalid_argument.tag = 248; | ||
| end_of_file.tag = 248; | ||
| division_by_zero.tag = 248; | ||
| not_found.tag = 248; | ||
| match_failure.tag = 248; | ||
| stack_overflow.tag = 248; | ||
| sys_blocked_io.tag = 248; | ||
| assert_failure.tag = 248; | ||
| undefined_recursive_module.tag = 248; | ||
| 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; | ||
| 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 t; | ||
| return result; | ||
| } | ||
| function app(r, e) { | ||
| function app(_f, _args) { | ||
| 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)); | ||
| var args = _args; | ||
| var f = _f; | ||
| var arity = f.length; | ||
| var d = (arity - args.length) | 0; | ||
| if (0 === d) { | ||
| return f.apply(null, args); | ||
| } else if (d < 0) { | ||
| _args = caml_array_sub(args, arity, 0 | -d); | ||
| _f = f.apply(null, caml_array_sub(args, 0, arity)); | ||
| continue; | ||
| } else { | ||
| return (function(r, e) { | ||
| return function(n) { | ||
| return app(r, e.concat([n])); | ||
| return (function(f, args) { | ||
| return function(x) { | ||
| return app(f, args.concat([x])); | ||
| }; | ||
| })(t, n); | ||
| })(f, args); | ||
| } | ||
@@ -98,246 +40,226 @@ } | ||
| function curry_1(r, e, n) { | ||
| switch (n) { | ||
| case 1: | ||
| return r(e); | ||
| function _1(o, a0) { | ||
| var arity = o.length; | ||
| if (1 === arity) { | ||
| return o(a0); | ||
| } else { | ||
| return (function curry_1(o, a0, arity) { | ||
| switch (arity) { | ||
| case 1: | ||
| return o(a0); | ||
| case 2: | ||
| return function(n) { | ||
| return r(e, n); | ||
| }; | ||
| case 2: | ||
| return function(param) { | ||
| return o(a0, param); | ||
| }; | ||
| case 3: | ||
| return function(n, t) { | ||
| return r(e, n, t); | ||
| }; | ||
| case 3: | ||
| return function(param, param$1) { | ||
| return o(a0, param, param$1); | ||
| }; | ||
| case 4: | ||
| return function(n, t, u) { | ||
| return r(e, n, t, u); | ||
| }; | ||
| case 4: | ||
| return function(param, param$1, param$2) { | ||
| return o(a0, param, param$1, param$2); | ||
| }; | ||
| case 5: | ||
| return function(n, t, u, i) { | ||
| return r(e, n, t, u, i); | ||
| }; | ||
| 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(n, t, u, i, f) { | ||
| return r(e, n, t, u, i, f); | ||
| }; | ||
| 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(n, t, u, i, f, o) { | ||
| return r(e, n, t, u, i, f, o); | ||
| }; | ||
| 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(r, [e]); | ||
| default: | ||
| return app(o, [a0]); | ||
| } | ||
| })(o, a0, arity); | ||
| } | ||
| } | ||
| function _1(r, e) { | ||
| var n = r.length; | ||
| if (1 === n) { | ||
| return r(e); | ||
| function _2(o, a0, a1) { | ||
| var arity = o.length; | ||
| if (2 === arity) { | ||
| return o(a0, a1); | ||
| } else { | ||
| return curry_1(r, e, n); | ||
| } | ||
| } | ||
| return (function curry_2(o, a0, a1, arity) { | ||
| switch (arity) { | ||
| case 1: | ||
| return app(o(a0), [a1]); | ||
| function curry_2(r, e, n, t) { | ||
| switch (t) { | ||
| case 1: | ||
| return app(r(e), [n]); | ||
| case 2: | ||
| return o(a0, a1); | ||
| case 2: | ||
| return r(e, n); | ||
| case 3: | ||
| return function(param) { | ||
| return o(a0, a1, param); | ||
| }; | ||
| case 3: | ||
| return function(t) { | ||
| return r(e, n, t); | ||
| }; | ||
| case 4: | ||
| return function(param, param$1) { | ||
| return o(a0, a1, param, param$1); | ||
| }; | ||
| case 4: | ||
| return function(t, u) { | ||
| return r(e, n, t, u); | ||
| }; | ||
| case 5: | ||
| return function(param, param$1, param$2) { | ||
| return o(a0, a1, param, param$1, param$2); | ||
| }; | ||
| case 5: | ||
| return function(t, u, i) { | ||
| return r(e, n, t, u, i); | ||
| }; | ||
| case 6: | ||
| return function(param, param$1, param$2, param$3) { | ||
| return o(a0, a1, param, param$1, param$2, param$3); | ||
| }; | ||
| case 6: | ||
| return function(t, u, i, f) { | ||
| return r(e, n, t, u, i, f); | ||
| }; | ||
| 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); | ||
| }; | ||
| case 7: | ||
| return function(t, u, i, f, o) { | ||
| return r(e, n, t, u, i, f, o); | ||
| }; | ||
| default: | ||
| return app(r, [e, n]); | ||
| default: | ||
| return app(o, [a0, a1]); | ||
| } | ||
| })(o, a0, a1, arity); | ||
| } | ||
| } | ||
| function _2(r, e, n) { | ||
| var t = r.length; | ||
| if (2 === t) { | ||
| return r(e, n); | ||
| function _3(o, a0, a1, a2) { | ||
| var arity = o.length; | ||
| if (3 === arity) { | ||
| return o(a0, a1, a2); | ||
| } else { | ||
| return curry_2(r, e, n, t); | ||
| } | ||
| } | ||
| return (function curry_3(o, a0, a1, a2, arity) { | ||
| switch (arity) { | ||
| case 1: | ||
| return app(o(a0), [a1, a2]); | ||
| function curry_3(r, e, n, t, u) { | ||
| switch (u) { | ||
| case 1: | ||
| return app(r(e), [n, t]); | ||
| case 2: | ||
| return app(o(a0, a1), [a2]); | ||
| case 2: | ||
| return app(r(e, n), [t]); | ||
| case 3: | ||
| return o(a0, a1, a2); | ||
| case 3: | ||
| return r(e, n, t); | ||
| case 4: | ||
| return function(param) { | ||
| return o(a0, a1, a2, param); | ||
| }; | ||
| case 4: | ||
| return function(u) { | ||
| return r(e, n, t, u); | ||
| }; | ||
| case 5: | ||
| return function(param, param$1) { | ||
| return o(a0, a1, a2, param, param$1); | ||
| }; | ||
| case 5: | ||
| return function(u, i) { | ||
| return r(e, n, t, u, i); | ||
| }; | ||
| case 6: | ||
| return function(param, param$1, param$2) { | ||
| return o(a0, a1, a2, param, param$1, param$2); | ||
| }; | ||
| case 6: | ||
| return function(u, i, f) { | ||
| return r(e, n, t, u, i, f); | ||
| }; | ||
| case 7: | ||
| return function(param, param$1, param$2, param$3) { | ||
| return o(a0, a1, a2, param, param$1, param$2, param$3); | ||
| }; | ||
| case 7: | ||
| return function(u, i, f, o) { | ||
| return r(e, n, t, u, i, f, o); | ||
| }; | ||
| default: | ||
| return app(r, [e, n, t]); | ||
| default: | ||
| return app(o, [a0, a1, a2]); | ||
| } | ||
| })(o, a0, a1, a2, arity); | ||
| } | ||
| } | ||
| function _3(r, e, n, t) { | ||
| var u = r.length; | ||
| if (3 === u) { | ||
| return r(e, n, t); | ||
| } else { | ||
| return curry_3(r, e, n, t, u); | ||
| } | ||
| } | ||
| var undefinedHeader = []; | ||
| 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; | ||
| function some(x) { | ||
| if (void 0 === x) { | ||
| var block = [undefinedHeader, 0]; | ||
| block.tag = 256; | ||
| return block; | ||
| } else if (null !== x && x[0] === undefinedHeader) { | ||
| var nid = (x[1] + 1) | 0; | ||
| var block$1 = [undefinedHeader, nid]; | ||
| block$1.tag = 256; | ||
| return block$1; | ||
| } else { | ||
| return r; | ||
| return x; | ||
| } | ||
| } | ||
| function valFromOption(r) { | ||
| if (null !== r && r[0] === undefinedHeader) { | ||
| var e = r[1]; | ||
| if (0 === e) { | ||
| function valFromOption(x) { | ||
| if (null !== x && x[0] === undefinedHeader) { | ||
| var depth = x[1]; | ||
| if (0 === depth) { | ||
| return; | ||
| } else { | ||
| return [undefinedHeader, (e - 1) | 0]; | ||
| return [undefinedHeader, (depth - 1) | 0]; | ||
| } | ||
| } else { | ||
| return r; | ||
| return x; | ||
| } | ||
| } | ||
| function make$1(r, e) { | ||
| var n = new Array(r); | ||
| n.fill(e); | ||
| return n; | ||
| } | ||
| function talkbackPlaceholder(r) { | ||
| function talkbackPlaceholder(param) { | ||
| return 0; | ||
| } | ||
| function captureTalkback(r, e) { | ||
| var n = [talkbackPlaceholder]; | ||
| return _1(r, function(r) { | ||
| if ("number" != typeof r) { | ||
| if (!r.tag) { | ||
| n[0] = r[0]; | ||
| function captureTalkback(source, sinkWithTalkback) { | ||
| var talkback = [talkbackPlaceholder]; | ||
| return _1(source, function(signal) { | ||
| if ("number" != typeof signal) { | ||
| if (!signal.tag) { | ||
| talkback[0] = signal[0]; | ||
| } | ||
| } | ||
| return e(r, n[0]); | ||
| return sinkWithTalkback(signal, talkback[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; | ||
| function fromListener(addListener, removeListener) { | ||
| return function(sink) { | ||
| var handler = function($$event) { | ||
| return sink(__(1, [$$event])); | ||
| }; | ||
| sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (signal) { | ||
| return _1(removeListener, handler); | ||
| } 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; | ||
| } | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| ]) | ||
| ); | ||
| return _1(addListener, handler); | ||
| }; | ||
| } | ||
| function makeSubject(r) { | ||
| var e = [new Array(), !1]; | ||
| exports.pipe = function pipe(source) { | ||
| var args = arguments; | ||
| var len = args.length; | ||
| var x = source; | ||
| for (var i = 1; i < len; i++) { | ||
| x = args[i](x); | ||
| } | ||
| return x; | ||
| }; | ||
| exports.Types = 0; | ||
| exports.makeSubject = function makeSubject(param) { | ||
| var state = [new Array(), !1]; | ||
| return [ | ||
| function(r) { | ||
| e[0] = e[0].concat(r); | ||
| return r( | ||
| function(sink) { | ||
| state[0] = state[0].concat(sink); | ||
| return sink( | ||
| __(0, [ | ||
| function(n) { | ||
| if (1 === n) { | ||
| e[0] = e[0].filter(function(e) { | ||
| return e !== r; | ||
| function(signal) { | ||
| if (1 === signal) { | ||
| state[0] = state[0].filter(function(x) { | ||
| return x !== sink; | ||
| }); | ||
@@ -352,8 +274,8 @@ return 0; | ||
| }, | ||
| function(r) { | ||
| if (e[1]) { | ||
| function(value) { | ||
| if (state[1]) { | ||
| return 0; | ||
| } else { | ||
| e[0].forEach(function(e) { | ||
| return e(__(1, [r])); | ||
| state[0].forEach(function(sink) { | ||
| return sink(__(1, [value])); | ||
| }); | ||
@@ -363,9 +285,9 @@ return 0; | ||
| }, | ||
| function(r) { | ||
| if (e[1]) { | ||
| function(param) { | ||
| if (state[1]) { | ||
| return 0; | ||
| } else { | ||
| e[1] = !0; | ||
| e[0].forEach(function(r) { | ||
| return r(0); | ||
| state[1] = !0; | ||
| state[0].forEach(function(sink) { | ||
| return sink(0); | ||
| }); | ||
@@ -376,19 +298,19 @@ return 0; | ||
| ]; | ||
| } | ||
| }; | ||
| function make$2(r) { | ||
| return function(e) { | ||
| var n = _1(r, [ | ||
| function(r) { | ||
| return e(__(1, [r])); | ||
| exports.make = function make$2(f) { | ||
| return function(sink) { | ||
| var teardown = _1(f, [ | ||
| function(value) { | ||
| return sink(__(1, [value])); | ||
| }, | ||
| function(r) { | ||
| return e(0); | ||
| function(param) { | ||
| return sink(0); | ||
| } | ||
| ]); | ||
| return e( | ||
| return sink( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| return _1(n, 0); | ||
| function(signal) { | ||
| if (signal) { | ||
| return _1(teardown, 0); | ||
| } else { | ||
@@ -401,32 +323,32 @@ return 0; | ||
| }; | ||
| } | ||
| }; | ||
| function fromList(r) { | ||
| return function(e) { | ||
| var n = [r, !1, !1, !1]; | ||
| return e( | ||
| exports.fromList = function fromList(ls) { | ||
| return function(sink) { | ||
| var state = [ls, !1, !1, !1]; | ||
| return sink( | ||
| __(0, [ | ||
| function(r) { | ||
| var t = n[2]; | ||
| if (r) { | ||
| n[1] = !0; | ||
| function(signal) { | ||
| var match = state[2]; | ||
| if (signal) { | ||
| state[1] = !0; | ||
| return 0; | ||
| } else if (t) { | ||
| n[3] = !0; | ||
| } else if (match) { | ||
| state[3] = !0; | ||
| return 0; | ||
| } else { | ||
| 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]])); | ||
| state[3] = !0; | ||
| state[2] = !0; | ||
| while (state[3] && !state[1]) { | ||
| var match$1 = state[0]; | ||
| if (match$1) { | ||
| state[0] = match$1[1]; | ||
| state[3] = !1; | ||
| sink(__(1, [match$1[0]])); | ||
| } else { | ||
| n[1] = !0; | ||
| e(0); | ||
| state[1] = !0; | ||
| sink(0); | ||
| } | ||
| } | ||
| n[2] = !1; | ||
| state[2] = !1; | ||
| return 0; | ||
@@ -438,34 +360,34 @@ } | ||
| }; | ||
| } | ||
| }; | ||
| function fromArray(r) { | ||
| return function(e) { | ||
| var n = r.length; | ||
| var t = [0, !1, !1, !1]; | ||
| return e( | ||
| exports.fromArray = function fromArray(arr) { | ||
| return function(sink) { | ||
| var size = arr.length; | ||
| var state = [0, !1, !1, !1]; | ||
| return sink( | ||
| __(0, [ | ||
| function(u) { | ||
| var i = t[2]; | ||
| if (u) { | ||
| t[1] = !0; | ||
| function(signal) { | ||
| var match = state[2]; | ||
| if (signal) { | ||
| state[1] = !0; | ||
| return 0; | ||
| } else if (i) { | ||
| t[3] = !0; | ||
| } else if (match) { | ||
| state[3] = !0; | ||
| return 0; | ||
| } else { | ||
| 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])); | ||
| state[3] = !0; | ||
| state[2] = !0; | ||
| while (state[3] && !state[1]) { | ||
| var index = state[0]; | ||
| if (index < size) { | ||
| var x = arr[index]; | ||
| state[0] = (index + 1) | 0; | ||
| state[3] = !1; | ||
| sink(__(1, [x])); | ||
| } else { | ||
| t[1] = !0; | ||
| e(0); | ||
| state[1] = !0; | ||
| sink(0); | ||
| } | ||
| } | ||
| t[2] = !1; | ||
| state[2] = !1; | ||
| return 0; | ||
@@ -477,16 +399,16 @@ } | ||
| }; | ||
| } | ||
| }; | ||
| function fromValue(r) { | ||
| return function(e) { | ||
| var n = [!1]; | ||
| return e( | ||
| exports.fromValue = function fromValue(x) { | ||
| return function(sink) { | ||
| var ended = [!1]; | ||
| return sink( | ||
| __(0, [ | ||
| function(t) { | ||
| if (t || n[0]) { | ||
| function(signal) { | ||
| if (signal || ended[0]) { | ||
| return 0; | ||
| } else { | ||
| n[0] = !0; | ||
| e(__(1, [r])); | ||
| return e(0); | ||
| ended[0] = !0; | ||
| sink(__(1, [x])); | ||
| return sink(0); | ||
| } | ||
@@ -497,33 +419,38 @@ } | ||
| }; | ||
| } | ||
| }; | ||
| function empty(r) { | ||
| r(__(0, [talkbackPlaceholder])); | ||
| return r(0); | ||
| } | ||
| exports.empty = function empty(sink) { | ||
| sink(__(0, [talkbackPlaceholder])); | ||
| return sink(0); | ||
| }; | ||
| function never(r) { | ||
| return r(__(0, [talkbackPlaceholder])); | ||
| } | ||
| exports.never = function never(sink) { | ||
| return sink(__(0, [talkbackPlaceholder])); | ||
| }; | ||
| 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); | ||
| exports.map = function map$1(f) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| return _1(source, function(signal) { | ||
| var tmp; | ||
| tmp = | ||
| "number" == typeof signal | ||
| ? 0 | ||
| : signal.tag | ||
| ? __(1, [_1(f, signal[0])]) | ||
| : __(0, [signal[0]]); | ||
| return sink(tmp); | ||
| }); | ||
| }; | ||
| }; | ||
| } | ||
| }; | ||
| 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); | ||
| exports.filter = function filter(f) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| return captureTalkback(source, function(signal, talkback) { | ||
| if ("number" == typeof signal || !signal.tag || _1(f, signal[0])) { | ||
| return sink(signal); | ||
| } else { | ||
| return t(0); | ||
| return talkback(0); | ||
| } | ||
@@ -533,36 +460,40 @@ }); | ||
| }; | ||
| } | ||
| }; | ||
| 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]]); | ||
| exports.scan = function scan(f, seed) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var acc = [seed]; | ||
| return _1(source, function(signal) { | ||
| var tmp; | ||
| if ("number" == typeof signal) { | ||
| tmp = 0; | ||
| } else if (signal.tag) { | ||
| acc[0] = _2(f, acc[0], signal[0]); | ||
| tmp = __(1, [acc[0]]); | ||
| } else { | ||
| n = __(0, [e[0]]); | ||
| tmp = __(0, [signal[0]]); | ||
| } | ||
| return t(n); | ||
| return sink(tmp); | ||
| }); | ||
| }; | ||
| }; | ||
| } | ||
| }; | ||
| 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; | ||
| exports.merge = function merge(sources) { | ||
| return function(sink) { | ||
| var size = sources.length; | ||
| var talkbacks = (function make$1(len, vals) { | ||
| var res = new Array(len); | ||
| res.fill(vals); | ||
| return res; | ||
| })(size, talkbackPlaceholder); | ||
| var state = [0, 0]; | ||
| var talkback = function(signal) { | ||
| var _i = 0; | ||
| while (1) { | ||
| var u = e; | ||
| if (u < n) { | ||
| t[u](r); | ||
| e = (u + 1) | 0; | ||
| var i = _i; | ||
| if (i < size) { | ||
| talkbacks[i](signal); | ||
| _i = (i + 1) | 0; | ||
| continue; | ||
@@ -574,24 +505,24 @@ } else { | ||
| }; | ||
| var f = 0; | ||
| var _i = 0; | ||
| while (1) { | ||
| var o = f; | ||
| if (o < n) { | ||
| var i = _i; | ||
| if (i < size) { | ||
| _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); | ||
| sources[i], | ||
| (function(i) { | ||
| return function(signal) { | ||
| if ("number" == typeof signal) { | ||
| state[1] = (state[1] + 1) | 0; | ||
| if (state[1] === size) { | ||
| return sink(0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else if (f.tag) { | ||
| return e(f); | ||
| } else if (signal.tag) { | ||
| return sink(signal); | ||
| } else { | ||
| t[r] = f[0]; | ||
| u[0] = (u[0] + 1) | 0; | ||
| if (u[0] === n) { | ||
| return e(__(0, [i])); | ||
| talkbacks[i] = signal[0]; | ||
| state[0] = (state[0] + 1) | 0; | ||
| if (state[0] === size) { | ||
| return sink(__(0, [talkback])); | ||
| } else { | ||
@@ -602,5 +533,5 @@ return 0; | ||
| }; | ||
| })(o) | ||
| })(i) | ||
| ); | ||
| f = (o + 1) | 0; | ||
| _i = (i + 1) | 0; | ||
| continue; | ||
@@ -612,23 +543,23 @@ } else { | ||
| }; | ||
| } | ||
| }; | ||
| 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); | ||
| exports.concat = function concat$1(sources) { | ||
| return function(sink) { | ||
| var size = sources.length; | ||
| var talkback = [talkbackPlaceholder]; | ||
| var nextSource = function(i) { | ||
| if (i < size) { | ||
| return _1(sources[i], function(signal) { | ||
| if ("number" == typeof signal) { | ||
| return nextSource((i + 1) | 0); | ||
| } else if (signal.tag) { | ||
| return sink(signal); | ||
| } else { | ||
| var n = r[0]; | ||
| t[0] = n; | ||
| var tb = signal[0]; | ||
| talkback[0] = tb; | ||
| if (0 === i) { | ||
| e( | ||
| sink( | ||
| __(0, [ | ||
| function(r) { | ||
| return t[0](r); | ||
| function(signal) { | ||
| return talkback[0](signal); | ||
| } | ||
@@ -638,33 +569,33 @@ ]) | ||
| } | ||
| return n(0); | ||
| return tb(0); | ||
| } | ||
| }); | ||
| } else { | ||
| return e(0); | ||
| return sink(0); | ||
| } | ||
| }; | ||
| return u(0); | ||
| return nextSource(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); | ||
| exports.share = function share(source) { | ||
| var state = [new Array(), talkbackPlaceholder, !1]; | ||
| return function(sink) { | ||
| state[0] = state[0].concat(sink); | ||
| if (1 === state[0].length) { | ||
| _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| state[0].forEach(function(sink) { | ||
| return sink(0); | ||
| }); | ||
| e[0] = new Array(); | ||
| state[0] = new Array(); | ||
| return 0; | ||
| } else if (r.tag) { | ||
| e[2] = !1; | ||
| e[0].forEach(function(e) { | ||
| return e(r); | ||
| } else if (signal.tag) { | ||
| state[2] = !1; | ||
| state[0].forEach(function(sink) { | ||
| return sink(signal); | ||
| }); | ||
| return 0; | ||
| } else { | ||
| e[1] = r[0]; | ||
| state[1] = signal[0]; | ||
| return 0; | ||
@@ -674,19 +605,19 @@ } | ||
| } | ||
| return n( | ||
| return sink( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| e[0] = e[0].filter(function(r) { | ||
| return r !== n; | ||
| function(signal) { | ||
| if (signal) { | ||
| state[0] = state[0].filter(function(x) { | ||
| return x !== sink; | ||
| }); | ||
| if (0 === e[0].length) { | ||
| return e[1](1); | ||
| if (0 === state[0].length) { | ||
| return state[1](1); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else if (e[2]) { | ||
| } else if (state[2]) { | ||
| return 0; | ||
| } else { | ||
| e[2] = !0; | ||
| return e[1](r); | ||
| state[2] = !0; | ||
| return state[1](signal); | ||
| } | ||
@@ -697,86 +628,86 @@ } | ||
| }; | ||
| } | ||
| }; | ||
| 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; | ||
| exports.combine = function combine(sourceA, sourceB) { | ||
| return function(sink) { | ||
| var state = [talkbackPlaceholder, talkbackPlaceholder, void 0, void 0, !1, 0, !1]; | ||
| _1(sourceA, function(signal) { | ||
| var match = state[3]; | ||
| if ("number" == typeof signal) { | ||
| if (state[5] < 1) { | ||
| state[5] = (state[5] + 1) | 0; | ||
| return 0; | ||
| } else if (t[6]) { | ||
| } else if (state[6]) { | ||
| return 0; | ||
| } else { | ||
| t[6] = !0; | ||
| return n(0); | ||
| state[6] = !0; | ||
| return sink(0); | ||
| } | ||
| } else if (r.tag) { | ||
| var u = r[0]; | ||
| if (void 0 !== e) { | ||
| if (t[6]) { | ||
| } else if (signal.tag) { | ||
| var a = signal[0]; | ||
| if (void 0 !== match) { | ||
| if (state[6]) { | ||
| return 0; | ||
| } else { | ||
| t[2] = some(u); | ||
| t[4] = !1; | ||
| return n(__(1, [[u, valFromOption(e)]])); | ||
| state[2] = some(a); | ||
| state[4] = !1; | ||
| return sink(__(1, [[a, valFromOption(match)]])); | ||
| } | ||
| } else { | ||
| t[2] = some(u); | ||
| t[4] = !1; | ||
| state[2] = some(a); | ||
| state[4] = !1; | ||
| return 0; | ||
| } | ||
| } else { | ||
| t[0] = r[0]; | ||
| state[0] = signal[0]; | ||
| return 0; | ||
| } | ||
| }); | ||
| _1(e, function(r) { | ||
| var e = t[2]; | ||
| if ("number" == typeof r) { | ||
| if (t[5] < 1) { | ||
| t[5] = (t[5] + 1) | 0; | ||
| _1(sourceB, function(signal) { | ||
| var match = state[2]; | ||
| if ("number" == typeof signal) { | ||
| if (state[5] < 1) { | ||
| state[5] = (state[5] + 1) | 0; | ||
| return 0; | ||
| } else if (t[6]) { | ||
| } else if (state[6]) { | ||
| return 0; | ||
| } else { | ||
| t[6] = !0; | ||
| return n(0); | ||
| state[6] = !0; | ||
| return sink(0); | ||
| } | ||
| } else if (r.tag) { | ||
| var u = r[0]; | ||
| if (void 0 !== e) { | ||
| if (t[6]) { | ||
| } else if (signal.tag) { | ||
| var b = signal[0]; | ||
| if (void 0 !== match) { | ||
| if (state[6]) { | ||
| return 0; | ||
| } else { | ||
| t[3] = some(u); | ||
| t[4] = !1; | ||
| return n(__(1, [[valFromOption(e), u]])); | ||
| state[3] = some(b); | ||
| state[4] = !1; | ||
| return sink(__(1, [[valFromOption(match), b]])); | ||
| } | ||
| } else { | ||
| t[3] = some(u); | ||
| t[4] = !1; | ||
| state[3] = some(b); | ||
| state[4] = !1; | ||
| return 0; | ||
| } | ||
| } else { | ||
| t[1] = r[0]; | ||
| state[1] = signal[0]; | ||
| return 0; | ||
| } | ||
| }); | ||
| return n( | ||
| return sink( | ||
| __(0, [ | ||
| function(r) { | ||
| if (t[6]) { | ||
| function(signal) { | ||
| if (state[6]) { | ||
| return 0; | ||
| } else if (r) { | ||
| t[6] = !0; | ||
| t[0](1); | ||
| return t[1](1); | ||
| } else if (t[4]) { | ||
| } else if (signal) { | ||
| state[6] = !0; | ||
| state[0](1); | ||
| return state[1](1); | ||
| } else if (state[4]) { | ||
| return 0; | ||
| } else { | ||
| t[4] = !0; | ||
| t[0](r); | ||
| return t[1](r); | ||
| state[4] = !0; | ||
| state[0](signal); | ||
| return state[1](signal); | ||
| } | ||
@@ -787,23 +718,23 @@ } | ||
| }; | ||
| } | ||
| }; | ||
| 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); | ||
| exports.take = function take(max) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var state = [0, talkbackPlaceholder]; | ||
| _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| if (state[0] < max) { | ||
| state[0] = max; | ||
| return sink(0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } 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 if (signal.tag) { | ||
| if (state[0] < max) { | ||
| state[0] = (state[0] + 1) | 0; | ||
| sink(signal); | ||
| if (state[0] === max) { | ||
| sink(0); | ||
| return state[1](1); | ||
| } else { | ||
@@ -816,15 +747,15 @@ return 0; | ||
| } else { | ||
| t[1] = e[0]; | ||
| state[1] = signal[0]; | ||
| return 0; | ||
| } | ||
| }); | ||
| return n( | ||
| return sink( | ||
| __(0, [ | ||
| function(e) { | ||
| if (t[0] < r) { | ||
| if (e) { | ||
| t[0] = r; | ||
| return t[1](1); | ||
| function(signal) { | ||
| if (state[0] < max) { | ||
| if (signal) { | ||
| state[0] = max; | ||
| return state[1](1); | ||
| } else { | ||
| return t[1](0); | ||
| return state[1](0); | ||
| } | ||
@@ -839,21 +770,59 @@ } else { | ||
| }; | ||
| } | ||
| }; | ||
| 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(); | ||
| exports.takeLast = function takeLast(max) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var queue = new Array(); | ||
| return captureTalkback(source, function(signal, talkback) { | ||
| if ("number" == typeof signal) { | ||
| return (function makeTrampoline(sink, f) { | ||
| var state = [!1, !1, !1]; | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| var match = state[0]; | ||
| if (signal || match) { | ||
| return 0; | ||
| } else { | ||
| state[2] = !0; | ||
| if (state[1]) { | ||
| return 0; | ||
| } else { | ||
| state[1] = !0; | ||
| !(function(_param) { | ||
| while (1) { | ||
| var match = f(); | ||
| if (void 0 !== match) { | ||
| state[2] = !1; | ||
| sink(__(1, [valFromOption(match)])); | ||
| if (state[2]) { | ||
| continue; | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else { | ||
| state[0] = !0; | ||
| return sink(0); | ||
| } | ||
| } | ||
| })(); | ||
| state[1] = !1; | ||
| return 0; | ||
| } | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| })(sink, function() { | ||
| return queue.shift(); | ||
| }); | ||
| } else if (e.tag) { | ||
| if (t.length >= r && r > 0) { | ||
| t.shift(); | ||
| } else if (signal.tag) { | ||
| if (queue.length >= max && max > 0) { | ||
| queue.shift(); | ||
| } | ||
| t.push(e[0]); | ||
| return u(0); | ||
| queue.push(signal[0]); | ||
| return talkback(0); | ||
| } else { | ||
| return u(0); | ||
| return talkback(0); | ||
| } | ||
@@ -863,42 +832,42 @@ }); | ||
| }; | ||
| } | ||
| }; | ||
| 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]) { | ||
| exports.takeWhile = function takeWhile(predicate) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var ended = [!1]; | ||
| var talkback = [talkbackPlaceholder]; | ||
| _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| if (ended[0]) { | ||
| return 0; | ||
| } else { | ||
| t[0] = !0; | ||
| return n(0); | ||
| ended[0] = !0; | ||
| return sink(0); | ||
| } | ||
| } else if (e.tag) { | ||
| if (t[0]) { | ||
| } else if (signal.tag) { | ||
| if (ended[0]) { | ||
| return 0; | ||
| } else if (_1(r, e[0])) { | ||
| return n(e); | ||
| } else if (_1(predicate, signal[0])) { | ||
| return sink(signal); | ||
| } else { | ||
| t[0] = !0; | ||
| n(0); | ||
| return u[0](1); | ||
| ended[0] = !0; | ||
| sink(0); | ||
| return talkback[0](1); | ||
| } | ||
| } else { | ||
| u[0] = e[0]; | ||
| return n(e); | ||
| talkback[0] = signal[0]; | ||
| return sink(signal); | ||
| } | ||
| }); | ||
| return n( | ||
| return sink( | ||
| __(0, [ | ||
| function(r) { | ||
| if (t[0]) { | ||
| function(signal) { | ||
| if (ended[0]) { | ||
| return 0; | ||
| } else if (r) { | ||
| t[0] = !0; | ||
| return u[0](1); | ||
| } else if (signal) { | ||
| ended[0] = !0; | ||
| return talkback[0](1); | ||
| } else { | ||
| return u[0](0); | ||
| return talkback[0](0); | ||
| } | ||
@@ -910,37 +879,37 @@ } | ||
| }; | ||
| } | ||
| }; | ||
| 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]) { | ||
| exports.takeUntil = function takeUntil(notifier) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var state = [!1, talkbackPlaceholder, talkbackPlaceholder]; | ||
| _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| if (state[0]) { | ||
| return 0; | ||
| } else { | ||
| t[2](1); | ||
| t[0] = !0; | ||
| return n(0); | ||
| state[2](1); | ||
| state[0] = !0; | ||
| return sink(0); | ||
| } | ||
| } else if (e.tag) { | ||
| if (t[0]) { | ||
| } else if (signal.tag) { | ||
| if (state[0]) { | ||
| return 0; | ||
| } else { | ||
| return n(e); | ||
| return sink(signal); | ||
| } | ||
| } else { | ||
| t[1] = e[0]; | ||
| return _1(r, function(r) { | ||
| if ("number" == typeof r) { | ||
| state[1] = signal[0]; | ||
| return _1(notifier, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| return 0; | ||
| } else if (r.tag) { | ||
| t[0] = !0; | ||
| t[2](1); | ||
| t[1](1); | ||
| return n(0); | ||
| } else if (signal.tag) { | ||
| state[0] = !0; | ||
| state[2](1); | ||
| state[1](1); | ||
| return sink(0); | ||
| } else { | ||
| var e = r[0]; | ||
| t[2] = e; | ||
| return e(0); | ||
| var innerTb = signal[0]; | ||
| state[2] = innerTb; | ||
| return innerTb(0); | ||
| } | ||
@@ -950,12 +919,12 @@ }); | ||
| }); | ||
| return n( | ||
| return sink( | ||
| __(0, [ | ||
| function(r) { | ||
| if (t[0]) { | ||
| function(signal) { | ||
| if (state[0]) { | ||
| return 0; | ||
| } else if (r) { | ||
| t[1](1); | ||
| return t[2](1); | ||
| } else if (signal) { | ||
| state[1](1); | ||
| return state[2](1); | ||
| } else { | ||
| return t[1](0); | ||
| return state[1](0); | ||
| } | ||
@@ -967,14 +936,14 @@ } | ||
| }; | ||
| } | ||
| }; | ||
| 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); | ||
| exports.skip = function skip(wait) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var rest = [wait]; | ||
| return captureTalkback(source, function(signal, talkback) { | ||
| if ("number" == typeof signal || !(signal.tag && rest[0] > 0)) { | ||
| return sink(signal); | ||
| } else { | ||
| t[0] = (t[0] - 1) | 0; | ||
| return e(0); | ||
| rest[0] = (rest[0] - 1) | 0; | ||
| return talkback(0); | ||
| } | ||
@@ -984,16 +953,16 @@ }); | ||
| }; | ||
| } | ||
| }; | ||
| 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); | ||
| exports.skipWhile = function skipWhile(predicate) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var skip = [!0]; | ||
| return captureTalkback(source, function(signal, talkback) { | ||
| if ("number" == typeof signal || !signal.tag || !skip[0]) { | ||
| return sink(signal); | ||
| } else if (_1(predicate, signal[0])) { | ||
| return talkback(0); | ||
| } else { | ||
| t[0] = !1; | ||
| return n(e); | ||
| skip[0] = !1; | ||
| return sink(signal); | ||
| } | ||
@@ -1003,38 +972,38 @@ }); | ||
| }; | ||
| } | ||
| }; | ||
| 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); | ||
| exports.skipUntil = function skipUntil(notifier) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var state = [!0, !1, !1, talkbackPlaceholder, talkbackPlaceholder]; | ||
| _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| if (state[0]) { | ||
| state[4](1); | ||
| } | ||
| t[1] = !0; | ||
| return n(0); | ||
| } else if (e.tag) { | ||
| if (t[0] && !t[1]) { | ||
| return t[3](0); | ||
| } else if (t[1]) { | ||
| state[1] = !0; | ||
| return sink(0); | ||
| } else if (signal.tag) { | ||
| if (state[0] && !state[1]) { | ||
| return state[3](0); | ||
| } else if (state[1]) { | ||
| return 0; | ||
| } else { | ||
| t[2] = !1; | ||
| return n(e); | ||
| state[2] = !1; | ||
| return sink(signal); | ||
| } | ||
| } else { | ||
| var u = e[0]; | ||
| t[3] = u; | ||
| return _1(r, function(r) { | ||
| if ("number" == typeof r) { | ||
| var tb = signal[0]; | ||
| state[3] = tb; | ||
| return _1(notifier, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| return 0; | ||
| } else if (r.tag) { | ||
| t[0] = !1; | ||
| return t[4](1); | ||
| } else if (signal.tag) { | ||
| state[0] = !1; | ||
| return state[4](1); | ||
| } else { | ||
| var e = r[0]; | ||
| t[4] = e; | ||
| e(0); | ||
| return u(0); | ||
| var innerTb = signal[0]; | ||
| state[4] = innerTb; | ||
| innerTb(0); | ||
| return tb(0); | ||
| } | ||
@@ -1044,14 +1013,14 @@ }); | ||
| }); | ||
| return n( | ||
| return sink( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| if (t[0]) { | ||
| t[4](1); | ||
| function(signal) { | ||
| if (signal) { | ||
| if (state[0]) { | ||
| state[4](1); | ||
| } | ||
| t[1] = !0; | ||
| return t[3](1); | ||
| } else if (!t[2] && !t[1]) { | ||
| t[2] = !0; | ||
| return t[3](0); | ||
| state[1] = !0; | ||
| return state[3](1); | ||
| } else if (!state[2] && !state[1]) { | ||
| state[2] = !0; | ||
| return state[3](0); | ||
| } else { | ||
@@ -1065,53 +1034,53 @@ return 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); | ||
| exports.flatten = function flatten(source) { | ||
| return function(sink) { | ||
| var state = [talkbackPlaceholder, talkbackPlaceholder, !1, !0]; | ||
| _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| if (state[3]) { | ||
| return sink(0); | ||
| } else { | ||
| n[2] = !0; | ||
| state[2] = !0; | ||
| return 0; | ||
| } | ||
| } else if (r.tag) { | ||
| return _1(r[0], function(r) { | ||
| if ("number" == typeof r) { | ||
| if (n[2]) { | ||
| return n[0](1); | ||
| } else if (signal.tag) { | ||
| return _1(signal[0], function(signal) { | ||
| if ("number" == typeof signal) { | ||
| if (state[2]) { | ||
| return state[0](1); | ||
| } else { | ||
| n[3] = !0; | ||
| return n[0](0); | ||
| state[3] = !0; | ||
| return state[0](0); | ||
| } | ||
| } else if (r.tag) { | ||
| return e(r); | ||
| } else if (signal.tag) { | ||
| return sink(signal); | ||
| } else { | ||
| var t = r[0]; | ||
| if (!n[3]) { | ||
| n[1](1); | ||
| var tb = signal[0]; | ||
| if (!state[3]) { | ||
| state[1](1); | ||
| } | ||
| n[3] = !1; | ||
| n[1] = t; | ||
| return t(0); | ||
| state[3] = !1; | ||
| state[1] = tb; | ||
| return tb(0); | ||
| } | ||
| }); | ||
| } else { | ||
| n[0] = r[0]; | ||
| state[0] = signal[0]; | ||
| return 0; | ||
| } | ||
| }); | ||
| return e( | ||
| return sink( | ||
| __(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]) { | ||
| function(signal) { | ||
| if (signal) { | ||
| state[0](1); | ||
| return state[1](1); | ||
| } else if (!state[3] && !state[2]) { | ||
| return state[1](0); | ||
| } else if (state[2]) { | ||
| return 0; | ||
| } else { | ||
| return n[0](0); | ||
| return state[0](0); | ||
| } | ||
@@ -1122,103 +1091,83 @@ } | ||
| }; | ||
| } | ||
| }; | ||
| function forEach$1(r) { | ||
| return function(e) { | ||
| return captureTalkback(e, function(e, n) { | ||
| if ("number" == typeof e) { | ||
| exports.forEach = function forEach$1(f) { | ||
| return function(source) { | ||
| return captureTalkback(source, function(signal, talkback) { | ||
| if ("number" == typeof signal) { | ||
| return 0; | ||
| } else if (e.tag) { | ||
| _1(r, e[0]); | ||
| return n(0); | ||
| } else if (signal.tag) { | ||
| _1(f, signal[0]); | ||
| return talkback(0); | ||
| } else { | ||
| return n(0); | ||
| return talkback(0); | ||
| } | ||
| }); | ||
| }; | ||
| } | ||
| }; | ||
| function subscribe(r) { | ||
| return function(e) { | ||
| var n = [talkbackPlaceholder]; | ||
| var t = [!1]; | ||
| _1(e, function(e) { | ||
| if ("number" == typeof e) { | ||
| exports.subscribe = function subscribe(f) { | ||
| return function(source) { | ||
| var talkback = [talkbackPlaceholder]; | ||
| var ended = [!1]; | ||
| _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| return 0; | ||
| } else if (e.tag) { | ||
| if (t[0]) { | ||
| } else if (signal.tag) { | ||
| if (ended[0]) { | ||
| return 0; | ||
| } else { | ||
| _1(r, e[0]); | ||
| return n[0](0); | ||
| _1(f, signal[0]); | ||
| return talkback[0](0); | ||
| } | ||
| } else { | ||
| n[0] = e[0]; | ||
| return n[0](0); | ||
| talkback[0] = signal[0]; | ||
| return talkback[0](0); | ||
| } | ||
| }); | ||
| return function(r) { | ||
| if (t[0]) { | ||
| return function(param) { | ||
| if (ended[0]) { | ||
| return 0; | ||
| } else { | ||
| t[0] = !0; | ||
| return n[0](1); | ||
| ended[0] = !0; | ||
| return talkback[0](1); | ||
| } | ||
| }; | ||
| }; | ||
| } | ||
| }; | ||
| var Types = 0; | ||
| exports.fromListener = fromListener; | ||
| function fromListener(r, e) { | ||
| return function(n) { | ||
| var t = function(r) { | ||
| return n(__(1, [r])); | ||
| exports.fromDomEvent = function fromDomEvent(element, $$event) { | ||
| return function(sink) { | ||
| var addEventListener = function(element, event, handler) { | ||
| element.addEventListener(event, handler); | ||
| }; | ||
| n( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| return _1(e, t); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| return _1(r, t); | ||
| }; | ||
| } | ||
| 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(n) { | ||
| return _3(t, r, e, n); | ||
| function(handler) { | ||
| return _3(addEventListener, element, $$event, handler); | ||
| }, | ||
| function(n) { | ||
| return _3(u, r, e, n); | ||
| function(handler) { | ||
| return _3(removeEventListener, element, $$event, handler); | ||
| } | ||
| )(n); | ||
| )(sink); | ||
| }; | ||
| } | ||
| }; | ||
| 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( | ||
| exports.interval = function interval(p) { | ||
| return function(sink) { | ||
| var i = [0]; | ||
| var id = setInterval(function(param) { | ||
| var num = i[0]; | ||
| i[0] = (i[0] + 1) | 0; | ||
| return sink(__(1, [num])); | ||
| }, p); | ||
| return sink( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| clearInterval(t); | ||
| function(signal) { | ||
| if (signal) { | ||
| clearInterval(id); | ||
| return 0; | ||
@@ -1232,19 +1181,19 @@ } else { | ||
| }; | ||
| } | ||
| }; | ||
| function fromPromise(r) { | ||
| return function(e) { | ||
| var n = [!1]; | ||
| r.then(function(r) { | ||
| if (!n[0]) { | ||
| e(__(1, [r])); | ||
| e(0); | ||
| exports.fromPromise = function fromPromise(promise) { | ||
| return function(sink) { | ||
| var ended = [!1]; | ||
| promise.then(function(value) { | ||
| if (!ended[0]) { | ||
| sink(__(1, [value])); | ||
| sink(0); | ||
| } | ||
| return Promise.resolve(0); | ||
| }); | ||
| return e( | ||
| return sink( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| n[0] = !0; | ||
| function(signal) { | ||
| if (signal) { | ||
| ended[0] = !0; | ||
| return 0; | ||
@@ -1258,14 +1207,14 @@ } else { | ||
| }; | ||
| } | ||
| }; | ||
| 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)); | ||
| exports.debounce = function debounce(debounceF) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var gotEndSignal = [!1]; | ||
| var id = [void 0]; | ||
| var $$clearTimeout$1 = function(param) { | ||
| var match = id[0]; | ||
| if (void 0 !== match) { | ||
| id[0] = void 0; | ||
| clearTimeout(valFromOption(match)); | ||
| return 0; | ||
@@ -1276,34 +1225,34 @@ } else { | ||
| }; | ||
| return _1(e, function(e) { | ||
| if ("number" == typeof e) { | ||
| t[0] = !0; | ||
| if (void 0 !== u[0]) { | ||
| return _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| gotEndSignal[0] = !0; | ||
| if (void 0 !== id[0]) { | ||
| return 0; | ||
| } else { | ||
| return n(0); | ||
| return sink(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 if (signal.tag) { | ||
| $$clearTimeout$1(); | ||
| id[0] = some( | ||
| setTimeout(function(param) { | ||
| id[0] = void 0; | ||
| sink(signal); | ||
| if (gotEndSignal[0]) { | ||
| return sink(0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| }, _1(r, e[0])) | ||
| }, _1(debounceF, signal[0])) | ||
| ); | ||
| return 0; | ||
| } else { | ||
| var f = e[0]; | ||
| return n( | ||
| var tb = signal[0]; | ||
| return sink( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| i(); | ||
| return f(1); | ||
| function(signal) { | ||
| if (signal) { | ||
| $$clearTimeout$1(); | ||
| return tb(1); | ||
| } else { | ||
| return f(r); | ||
| return tb(signal); | ||
| } | ||
@@ -1317,13 +1266,13 @@ } | ||
| }; | ||
| } | ||
| }; | ||
| 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)); | ||
| exports.throttle = function throttle(throttleF) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var skip = [!1]; | ||
| var id = [void 0]; | ||
| var $$clearTimeout$1 = function(param) { | ||
| var match = id[0]; | ||
| if (void 0 !== match) { | ||
| clearTimeout(valFromOption(match)); | ||
| return 0; | ||
@@ -1334,31 +1283,31 @@ } else { | ||
| }; | ||
| return _1(e, function(e) { | ||
| if ("number" == typeof e) { | ||
| i(); | ||
| return n(0); | ||
| } else if (e.tag) { | ||
| if (t[0]) { | ||
| return _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| $$clearTimeout$1(); | ||
| return sink(0); | ||
| } else if (signal.tag) { | ||
| if (skip[0]) { | ||
| return 0; | ||
| } else { | ||
| t[0] = !0; | ||
| i(); | ||
| u[0] = some( | ||
| setTimeout(function(r) { | ||
| u[0] = void 0; | ||
| t[0] = !1; | ||
| skip[0] = !0; | ||
| $$clearTimeout$1(); | ||
| id[0] = some( | ||
| setTimeout(function(param) { | ||
| id[0] = void 0; | ||
| skip[0] = !1; | ||
| return 0; | ||
| }, _1(r, e[0])) | ||
| }, _1(throttleF, signal[0])) | ||
| ); | ||
| return n(e); | ||
| return sink(signal); | ||
| } | ||
| } else { | ||
| var f = e[0]; | ||
| return n( | ||
| var tb = signal[0]; | ||
| return sink( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| i(); | ||
| return f(1); | ||
| function(signal) { | ||
| if (signal) { | ||
| $$clearTimeout$1(); | ||
| return tb(1); | ||
| } else { | ||
| return f(r); | ||
| return tb(signal); | ||
| } | ||
@@ -1372,40 +1321,40 @@ } | ||
| }; | ||
| } | ||
| }; | ||
| function sample(r) { | ||
| return function(e) { | ||
| return function(n) { | ||
| var t = [ | ||
| exports.sample = function sample(notifier) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var state = [ | ||
| !1, | ||
| void 0, | ||
| function(r) { | ||
| function(param) { | ||
| return 0; | ||
| }, | ||
| function(r) { | ||
| function(param) { | ||
| 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]); | ||
| _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| state[0] = !0; | ||
| state[3](1); | ||
| return sink(0); | ||
| } else if (signal.tag) { | ||
| state[1] = some(signal[0]); | ||
| return 0; | ||
| } else { | ||
| t[2] = r[0]; | ||
| state[2] = signal[0]; | ||
| return 0; | ||
| } | ||
| }); | ||
| _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)])); | ||
| _1(notifier, function(signal) { | ||
| var match = state[1]; | ||
| if ("number" == typeof signal) { | ||
| state[0] = !0; | ||
| state[2](1); | ||
| return sink(0); | ||
| } else if (signal.tag) { | ||
| if (void 0 !== match && !state[0]) { | ||
| state[1] = void 0; | ||
| return sink(__(1, [valFromOption(match)])); | ||
| } else { | ||
@@ -1415,16 +1364,16 @@ return 0; | ||
| } else { | ||
| t[3] = r[0]; | ||
| state[3] = signal[0]; | ||
| return 0; | ||
| } | ||
| }); | ||
| return n( | ||
| return sink( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| t[0] = !0; | ||
| t[2](1); | ||
| return t[3](1); | ||
| function(signal) { | ||
| if (signal) { | ||
| state[0] = !0; | ||
| state[2](1); | ||
| return state[3](1); | ||
| } else { | ||
| t[2](0); | ||
| return t[3](0); | ||
| state[2](0); | ||
| return state[3](0); | ||
| } | ||
@@ -1436,29 +1385,29 @@ } | ||
| }; | ||
| } | ||
| }; | ||
| 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; | ||
| exports.delay = function delay(wait) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var state = [talkbackPlaceholder, 0, !1]; | ||
| _1(source, function(signal) { | ||
| var exit = 0; | ||
| if ("number" == typeof signal || signal.tag) { | ||
| exit = 1; | ||
| } else { | ||
| t[0] = e[0]; | ||
| state[0] = signal[0]; | ||
| return 0; | ||
| } | ||
| if (1 === u) { | ||
| if (t[2]) { | ||
| if (1 === exit) { | ||
| if (state[2]) { | ||
| return 0; | ||
| } else { | ||
| t[1] = (t[1] + 1) | 0; | ||
| setTimeout(function(r) { | ||
| if (t[2] && 0 === t[1]) { | ||
| n(0); | ||
| state[1] = (state[1] + 1) | 0; | ||
| setTimeout(function(param) { | ||
| if (state[2] && 0 === state[1]) { | ||
| sink(0); | ||
| } else { | ||
| t[1] = (t[1] - 1) | 0; | ||
| state[1] = (state[1] - 1) | 0; | ||
| } | ||
| return n(e); | ||
| }, r); | ||
| return sink(signal); | ||
| }, wait); | ||
| return 0; | ||
@@ -1468,16 +1417,16 @@ } | ||
| }); | ||
| return n( | ||
| return sink( | ||
| __(0, [ | ||
| function(r) { | ||
| if (r) { | ||
| t[2] = !0; | ||
| if (0 === t[1]) { | ||
| return n(0); | ||
| function(signal) { | ||
| if (signal) { | ||
| state[2] = !0; | ||
| if (0 === state[1]) { | ||
| return sink(0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else if (t[2]) { | ||
| } else if (state[2]) { | ||
| return 0; | ||
| } else { | ||
| return t[0](r); | ||
| return state[0](signal); | ||
| } | ||
@@ -1489,70 +1438,2 @@ } | ||
| }; | ||
| } | ||
| 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; | ||
| }; |
| { | ||
| "name": "wonka", | ||
| "version": "1.1.5", | ||
| "version": "1.1.6", | ||
| "author": "Phil Pluckthun <phil@kitten.sh>", | ||
@@ -5,0 +5,0 @@ "source": "./src/index.js", |
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
Improved metrics
- Total package byte prevSize
- increased by2.88%
310639
Worsened metrics
- Lines of code
- decreased by-0.74%
6977
No dependency changes