wonka - npm Package Compare versions
Comparing version 1.4.0 to 1.4.1
@@ -18,6 +18,17 @@ { | ||
| "dir": "src", | ||
| "subdirs": [{ | ||
| "dir": "web", | ||
| "backend": ["js"] | ||
| }] | ||
| "subdirs": [ | ||
| { | ||
| "dir": "operators" | ||
| }, | ||
| { | ||
| "dir": "sources" | ||
| }, | ||
| { | ||
| "dir": "sinks" | ||
| }, | ||
| { | ||
| "dir": "web", | ||
| "backend": ["js"] | ||
| } | ||
| ] | ||
| }, | ||
@@ -24,0 +35,0 @@ { |
1586
dist/wonka.es.js
@@ -97,47 +97,2 @@ function pipe(source) { | ||
| function _2(o, a0, a1) { | ||
| var arity = o.length; | ||
| if (2 === arity) { | ||
| return o(a0, a1); | ||
| } else { | ||
| return (function curry_2(o, a0, a1, arity) { | ||
| switch (arity) { | ||
| case 1: | ||
| return app(o(a0), [a1]); | ||
| case 2: | ||
| return o(a0, a1); | ||
| case 3: | ||
| return function(param) { | ||
| return o(a0, a1, param); | ||
| }; | ||
| case 4: | ||
| return function(param, param$1) { | ||
| return o(a0, a1, param, param$1); | ||
| }; | ||
| case 5: | ||
| return function(param, param$1, param$2) { | ||
| return o(a0, a1, param, param$1, param$2); | ||
| }; | ||
| case 6: | ||
| return function(param, param$1, param$2, param$3) { | ||
| return o(a0, a1, param, param$1, param$2, param$3); | ||
| }; | ||
| case 7: | ||
| return function(param, param$1, param$2, param$3, param$4) { | ||
| return o(a0, a1, param, param$1, param$2, param$3, param$4); | ||
| }; | ||
| default: | ||
| return app(o, [a0, a1]); | ||
| } | ||
| })(o, a0, a1, arity); | ||
| } | ||
| } | ||
| function _3(o, a0, a1, a2) { | ||
@@ -194,4 +149,3 @@ var arity = o.length; | ||
| } else if (null !== x && x[0] === undefinedHeader) { | ||
| var nid = (x[1] + 1) | 0; | ||
| var block$1 = [undefinedHeader, nid]; | ||
| var block$1 = [undefinedHeader, (x[1] + 1) | 0]; | ||
| block$1.tag = 256; | ||
@@ -233,61 +187,72 @@ return block$1; | ||
| function makeSubject(param) { | ||
| var state = [new Array(), !1]; | ||
| return [ | ||
| function(sink) { | ||
| state[0] = state[0].concat(sink); | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (1 === signal) { | ||
| state[0] = state[0].filter(function(x) { | ||
| return x !== sink; | ||
| }); | ||
| return 0; | ||
| } else { | ||
| return 0; | ||
| } | ||
| 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) { | ||
| if (signal || state[0]) { | ||
| 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 (signal.tag) { | ||
| if (queue.length >= max && max > 0) { | ||
| queue.shift(); | ||
| } | ||
| ]) | ||
| ); | ||
| }, | ||
| function(value) { | ||
| if (state[1]) { | ||
| return 0; | ||
| } else { | ||
| state[0].forEach(function(sink) { | ||
| return sink(__(1, [value])); | ||
| }); | ||
| return 0; | ||
| } | ||
| }, | ||
| function(param) { | ||
| if (state[1]) { | ||
| return 0; | ||
| } else { | ||
| state[1] = !0; | ||
| state[0].forEach(function(sink) { | ||
| return sink(0); | ||
| }); | ||
| return 0; | ||
| } | ||
| } | ||
| ]; | ||
| queue.push(signal[0]); | ||
| return talkback(0); | ||
| } else { | ||
| return talkback(0); | ||
| } | ||
| }); | ||
| }; | ||
| }; | ||
| } | ||
| function make(f) { | ||
| function fromListener(addListener, removeListener) { | ||
| return function(sink) { | ||
| var teardown = f([ | ||
| function(value) { | ||
| return sink(__(1, [value])); | ||
| }, | ||
| function(param) { | ||
| return sink(0); | ||
| } | ||
| ]); | ||
| return sink( | ||
| var handler = function($$event) { | ||
| return sink(__(1, [$$event])); | ||
| }; | ||
| sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (signal) { | ||
| return teardown(); | ||
| return _1(removeListener, handler); | ||
| } else { | ||
@@ -299,38 +264,50 @@ return 0; | ||
| ); | ||
| return _1(addListener, handler); | ||
| }; | ||
| } | ||
| function fromList(ls) { | ||
| return function(sink) { | ||
| var state = [ls, !1, !1, !1]; | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| var match = state[2]; | ||
| if (signal) { | ||
| state[1] = !0; | ||
| return 0; | ||
| } else if (match) { | ||
| state[3] = !0; | ||
| return 0; | ||
| } else { | ||
| 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 { | ||
| state[1] = !0; | ||
| sink(0); | ||
| } | ||
| } | ||
| state[2] = !1; | ||
| return 0; | ||
| } | ||
| var toPromise$1 = function toPromise(source) { | ||
| return new Promise(function(resolve, param) { | ||
| return _1(takeLast(1)(source), function(signal) { | ||
| if ("number" == typeof signal) { | ||
| return 0; | ||
| } else if (signal.tag) { | ||
| return resolve(signal[0]); | ||
| } else { | ||
| return signal[0](0); | ||
| } | ||
| }); | ||
| }); | ||
| }; | ||
| function subscribe(f) { | ||
| return function(source) { | ||
| var state = [talkbackPlaceholder, !1]; | ||
| _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| state[1] = !0; | ||
| return 0; | ||
| } else if (signal.tag) { | ||
| if (state[1]) { | ||
| return 0; | ||
| } else { | ||
| f(signal[0]); | ||
| return state[0](0); | ||
| } | ||
| ]) | ||
| ); | ||
| } else { | ||
| var x = signal[0]; | ||
| state[0] = x; | ||
| return x(0); | ||
| } | ||
| }); | ||
| return [ | ||
| function(param) { | ||
| if (state[1]) { | ||
| return 0; | ||
| } else { | ||
| state[1] = !0; | ||
| return state[0](1); | ||
| } | ||
| } | ||
| ]; | ||
| }; | ||
@@ -377,92 +354,2 @@ } | ||
| function fromValue(x) { | ||
| return function(sink) { | ||
| var ended = [!1]; | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (signal || ended[0]) { | ||
| return 0; | ||
| } else { | ||
| ended[0] = !0; | ||
| sink(__(1, [x])); | ||
| return sink(0); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| } | ||
| function empty(sink) { | ||
| sink(__(0, [talkbackPlaceholder])); | ||
| return sink(0); | ||
| } | ||
| function never(sink) { | ||
| return sink(__(0, [talkbackPlaceholder])); | ||
| } | ||
| function tap(f) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| return _1(source, function(signal) { | ||
| if ("number" != typeof signal) { | ||
| if (signal.tag) { | ||
| f(signal[0]); | ||
| } | ||
| } | ||
| return sink(signal); | ||
| }); | ||
| }; | ||
| }; | ||
| } | ||
| function map(f) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| return _1(source, function(signal) { | ||
| var tmp; | ||
| tmp = | ||
| "number" == typeof signal ? 0 : signal.tag ? __(1, [f(signal[0])]) : __(0, [signal[0]]); | ||
| return sink(tmp); | ||
| }); | ||
| }; | ||
| }; | ||
| } | ||
| function filter(f) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| return captureTalkback(source, function(signal, talkback) { | ||
| if ("number" == typeof signal || !signal.tag || f(signal[0])) { | ||
| return sink(signal); | ||
| } else { | ||
| return talkback(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 { | ||
| tmp = __(0, [signal[0]]); | ||
| } | ||
| return sink(tmp); | ||
| }); | ||
| }; | ||
| }; | ||
| } | ||
| function mergeMap(f) { | ||
@@ -527,2 +414,5 @@ return function(source) { | ||
| if (signal) { | ||
| state[1].forEach(function(talkback) { | ||
| return talkback(1); | ||
| }); | ||
| if (state[2]) { | ||
@@ -554,8 +444,2 @@ return 0; | ||
| function merge(sources) { | ||
| return mergeMap(function(x) { | ||
| return x; | ||
| })(fromArray(sources)); | ||
| } | ||
| function mergeAll(source) { | ||
@@ -638,2 +522,3 @@ return mergeMap(function(x) { | ||
| if (signal) { | ||
| state[2](1); | ||
| if (state[5]) { | ||
@@ -645,3 +530,4 @@ return 0; | ||
| state[1](1); | ||
| return state[2](1); | ||
| state[2] = talkbackPlaceholder; | ||
| return 0; | ||
| } | ||
@@ -660,67 +546,204 @@ } else if (state[5]) { | ||
| function concatAll(source) { | ||
| return concatMap(function(x) { | ||
| return x; | ||
| })(source); | ||
| } | ||
| var Types = 0; | ||
| function concat(sources) { | ||
| return concatMap(function(x) { | ||
| return x; | ||
| })(fromArray(sources)); | ||
| } | ||
| var fromArray$1 = fromArray; | ||
| function switchMap(f) { | ||
| return function(source) { | ||
| var fromList$1 = function fromList(ls) { | ||
| return function(sink) { | ||
| var state = [ls, !1, !1, !1]; | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| var match = state[2]; | ||
| if (signal) { | ||
| state[1] = !0; | ||
| return 0; | ||
| } else if (match) { | ||
| state[3] = !0; | ||
| return 0; | ||
| } else { | ||
| 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 { | ||
| state[1] = !0; | ||
| sink(0); | ||
| } | ||
| } | ||
| state[2] = !1; | ||
| return 0; | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| }; | ||
| var fromValue$1 = function fromValue(x) { | ||
| return function(sink) { | ||
| var ended = [!1]; | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (signal || ended[0]) { | ||
| return 0; | ||
| } else { | ||
| ended[0] = !0; | ||
| sink(__(1, [x])); | ||
| return sink(0); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| }; | ||
| var make$1 = function make(f) { | ||
| return function(sink) { | ||
| var teardown = f([ | ||
| function(value) { | ||
| return sink(__(1, [value])); | ||
| }, | ||
| function(param) { | ||
| return sink(0); | ||
| } | ||
| ]); | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (signal) { | ||
| return teardown(); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| }; | ||
| var makeSubject$1 = function makeSubject(param) { | ||
| var state = [new Array(), !1]; | ||
| return [ | ||
| function(sink) { | ||
| state[0] = state[0].concat(sink); | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (1 === signal) { | ||
| state[0] = state[0].filter(function(x) { | ||
| return x !== sink; | ||
| }); | ||
| return 0; | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }, | ||
| function(value) { | ||
| if (state[1]) { | ||
| return 0; | ||
| } else { | ||
| state[0].forEach(function(sink) { | ||
| return sink(__(1, [value])); | ||
| }); | ||
| return 0; | ||
| } | ||
| }, | ||
| function(param) { | ||
| if (state[1]) { | ||
| return 0; | ||
| } else { | ||
| state[1] = !0; | ||
| state[0].forEach(function(sink) { | ||
| return sink(0); | ||
| }); | ||
| return 0; | ||
| } | ||
| } | ||
| ]; | ||
| }; | ||
| var empty$1 = function empty(sink) { | ||
| sink(__(0, [talkbackPlaceholder])); | ||
| return sink(0); | ||
| }; | ||
| var never$1 = function never(sink) { | ||
| return sink(__(0, [talkbackPlaceholder])); | ||
| }; | ||
| var combine$1 = function combine(sourceA) { | ||
| return function(sourceB) { | ||
| return function(sink) { | ||
| var state = [talkbackPlaceholder, talkbackPlaceholder, !1, !1, !1]; | ||
| _1(source, function(signal) { | ||
| 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[4]) { | ||
| if (state[5] < 1) { | ||
| state[5] = (state[5] + 1) | 0; | ||
| return 0; | ||
| } else if (state[6]) { | ||
| return 0; | ||
| } else { | ||
| state[4] = !0; | ||
| if (state[2]) { | ||
| state[6] = !0; | ||
| return sink(0); | ||
| } | ||
| } else if (signal.tag) { | ||
| var a = signal[0]; | ||
| if (void 0 !== match) { | ||
| if (state[6]) { | ||
| return 0; | ||
| } else { | ||
| return sink(0); | ||
| state[2] = some(a); | ||
| state[4] = !1; | ||
| return sink(__(1, [[a, valFromOption(match)]])); | ||
| } | ||
| } else { | ||
| state[2] = some(a); | ||
| state[4] = !1; | ||
| return 0; | ||
| } | ||
| } else if (signal.tag) { | ||
| if (state[4]) { | ||
| } else { | ||
| state[0] = signal[0]; | ||
| return 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 (state[6]) { | ||
| return 0; | ||
| } else { | ||
| if (state[2]) { | ||
| state[1](1); | ||
| state[1] = talkbackPlaceholder; | ||
| state[6] = !0; | ||
| return sink(0); | ||
| } | ||
| } else if (signal.tag) { | ||
| var b = signal[0]; | ||
| if (void 0 !== match) { | ||
| if (state[6]) { | ||
| return 0; | ||
| } else { | ||
| state[3] = some(b); | ||
| state[4] = !1; | ||
| return sink(__(1, [[valFromOption(match), b]])); | ||
| } | ||
| _1(f(signal[0]), function(signal) { | ||
| if ("number" == typeof signal) { | ||
| state[2] = !1; | ||
| state[1] = talkbackPlaceholder; | ||
| if (state[4]) { | ||
| return sink(0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else if (signal.tag) { | ||
| if (state[3]) { | ||
| return 0; | ||
| } else { | ||
| sink(__(1, [signal[0]])); | ||
| return state[1](0); | ||
| } | ||
| } else { | ||
| var tb = signal[0]; | ||
| state[2] = !0; | ||
| state[1] = tb; | ||
| return tb(0); | ||
| } | ||
| }); | ||
| return state[0](0); | ||
| } else { | ||
| state[3] = some(b); | ||
| state[4] = !1; | ||
| return 0; | ||
| } | ||
| } else { | ||
| var tb = signal[0]; | ||
| state[0] = tb; | ||
| return tb(0); | ||
| state[1] = signal[0]; | ||
| return 0; | ||
| } | ||
@@ -731,15 +754,14 @@ }); | ||
| function(signal) { | ||
| if (signal) { | ||
| if (state[4]) { | ||
| return 0; | ||
| } else { | ||
| state[4] = !0; | ||
| state[3] = !0; | ||
| state[0](1); | ||
| state[1](1); | ||
| state[1] = talkbackPlaceholder; | ||
| return 0; | ||
| } | ||
| if (state[6]) { | ||
| return 0; | ||
| } else if (signal) { | ||
| state[6] = !0; | ||
| state[0](1); | ||
| return state[1](1); | ||
| } else if (state[4]) { | ||
| return 0; | ||
| } else { | ||
| return state[1](0); | ||
| state[4] = !0; | ||
| state[0](signal); | ||
| return state[1](signal); | ||
| } | ||
@@ -751,5 +773,78 @@ } | ||
| }; | ||
| } | ||
| }; | ||
| function share(source) { | ||
| var concatMap$1 = concatMap; | ||
| var concat$1 = function concat(sources) { | ||
| return concatMap(function(x) { | ||
| return x; | ||
| })(fromArray(sources)); | ||
| }; | ||
| var concatAll$1 = function concatAll(source) { | ||
| return concatMap(function(x) { | ||
| return x; | ||
| })(source); | ||
| }; | ||
| var filter$1 = function filter(f) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| return captureTalkback(source, function(signal, talkback) { | ||
| if ("number" == typeof signal || !signal.tag || f(signal[0])) { | ||
| return sink(signal); | ||
| } else { | ||
| return talkback(0); | ||
| } | ||
| }); | ||
| }; | ||
| }; | ||
| }; | ||
| var map$1 = function map(f) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| return _1(source, function(signal) { | ||
| var tmp; | ||
| tmp = | ||
| "number" == typeof signal ? 0 : signal.tag ? __(1, [f(signal[0])]) : __(0, [signal[0]]); | ||
| return sink(tmp); | ||
| }); | ||
| }; | ||
| }; | ||
| }; | ||
| var mergeMap$1 = mergeMap; | ||
| var merge$1 = function merge(sources) { | ||
| return mergeMap(function(x) { | ||
| return x; | ||
| })(fromArray(sources)); | ||
| }; | ||
| var mergeAll$1 = mergeAll; | ||
| var flatten$1 = mergeAll; | ||
| var scan$1 = 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] = f(acc[0], signal[0]); | ||
| tmp = __(1, [acc[0]]); | ||
| } else { | ||
| tmp = __(0, [signal[0]]); | ||
| } | ||
| return sink(tmp); | ||
| }); | ||
| }; | ||
| }; | ||
| }; | ||
| var share$1 = function share(source) { | ||
| var state = [new Array(), talkbackPlaceholder, !1]; | ||
@@ -800,94 +895,178 @@ return function(sink) { | ||
| }; | ||
| } | ||
| }; | ||
| 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 (state[6]) { | ||
| return 0; | ||
| var skip$1 = 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 { | ||
| state[6] = !0; | ||
| rest[0] = (rest[0] - 1) | 0; | ||
| return talkback(0); | ||
| } | ||
| }); | ||
| }; | ||
| }; | ||
| }; | ||
| var skipUntil$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); | ||
| } | ||
| state[1] = !0; | ||
| return sink(0); | ||
| } | ||
| } else if (signal.tag) { | ||
| var a = signal[0]; | ||
| if (void 0 !== match) { | ||
| if (state[6]) { | ||
| } else if (signal.tag) { | ||
| if (state[0] && !state[1]) { | ||
| return state[3](0); | ||
| } else if (state[1]) { | ||
| return 0; | ||
| } else { | ||
| state[2] = some(a); | ||
| state[4] = !1; | ||
| return sink(__(1, [[a, valFromOption(match)]])); | ||
| state[2] = !1; | ||
| return sink(signal); | ||
| } | ||
| } else { | ||
| state[2] = some(a); | ||
| state[4] = !1; | ||
| return 0; | ||
| var tb = signal[0]; | ||
| state[3] = tb; | ||
| return _1(notifier, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| return 0; | ||
| } else if (signal.tag) { | ||
| state[0] = !1; | ||
| return state[4](1); | ||
| } else { | ||
| var innerTb = signal[0]; | ||
| state[4] = innerTb; | ||
| innerTb(0); | ||
| return tb(0); | ||
| } | ||
| }); | ||
| } | ||
| } else { | ||
| state[0] = signal[0]; | ||
| return 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 (state[6]) { | ||
| return 0; | ||
| }); | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (signal) { | ||
| if (state[0]) { | ||
| state[4](1); | ||
| } | ||
| state[1] = !0; | ||
| return state[3](1); | ||
| } else if (!state[2] && !state[1]) { | ||
| state[2] = !0; | ||
| return state[3](0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| }; | ||
| }; | ||
| var skipWhile$1 = function skipWhile(f) { | ||
| 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 (f(signal[0])) { | ||
| return talkback(0); | ||
| } else { | ||
| state[6] = !0; | ||
| return sink(0); | ||
| skip[0] = !1; | ||
| return sink(signal); | ||
| } | ||
| } else if (signal.tag) { | ||
| var b = signal[0]; | ||
| if (void 0 !== match) { | ||
| if (state[6]) { | ||
| }); | ||
| }; | ||
| }; | ||
| }; | ||
| var switchMap$1 = function switchMap(f) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var state = [talkbackPlaceholder, talkbackPlaceholder, !1, !1, !1]; | ||
| _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| if (state[4]) { | ||
| return 0; | ||
| } else { | ||
| state[3] = some(b); | ||
| state[4] = !1; | ||
| return sink(__(1, [[valFromOption(match), b]])); | ||
| state[4] = !0; | ||
| if (state[2]) { | ||
| return 0; | ||
| } else { | ||
| return sink(0); | ||
| } | ||
| } | ||
| } else { | ||
| state[3] = some(b); | ||
| state[4] = !1; | ||
| return 0; | ||
| } | ||
| } else { | ||
| state[1] = signal[0]; | ||
| return 0; | ||
| } | ||
| }); | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (state[6]) { | ||
| } else if (signal.tag) { | ||
| if (state[4]) { | ||
| return 0; | ||
| } else if (signal) { | ||
| state[6] = !0; | ||
| state[0](1); | ||
| return state[1](1); | ||
| } else if (state[4]) { | ||
| return 0; | ||
| } else { | ||
| state[4] = !0; | ||
| state[0](signal); | ||
| return state[1](signal); | ||
| if (state[2]) { | ||
| state[1](1); | ||
| state[1] = talkbackPlaceholder; | ||
| } | ||
| _1(f(signal[0]), function(signal) { | ||
| if ("number" == typeof signal) { | ||
| state[2] = !1; | ||
| state[1] = talkbackPlaceholder; | ||
| if (state[4]) { | ||
| return sink(0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else if (signal.tag) { | ||
| if (state[3]) { | ||
| return 0; | ||
| } else { | ||
| sink(__(1, [signal[0]])); | ||
| return state[1](0); | ||
| } | ||
| } else { | ||
| var tb = signal[0]; | ||
| state[2] = !0; | ||
| state[1] = tb; | ||
| return tb(0); | ||
| } | ||
| }); | ||
| return state[0](0); | ||
| } | ||
| } else { | ||
| var tb = signal[0]; | ||
| state[0] = tb; | ||
| return tb(0); | ||
| } | ||
| ]) | ||
| ); | ||
| }); | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (signal) { | ||
| state[1](1); | ||
| if (state[4]) { | ||
| return 0; | ||
| } else { | ||
| state[4] = !0; | ||
| state[3] = !0; | ||
| state[0](1); | ||
| state[1] = talkbackPlaceholder; | ||
| return 0; | ||
| } | ||
| } else { | ||
| return state[1](0); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| }; | ||
| } | ||
| }; | ||
| function take(max) { | ||
| var take$1 = function take(max) { | ||
| return function(source) { | ||
@@ -940,114 +1119,9 @@ return function(sink) { | ||
| }; | ||
| } | ||
| }; | ||
| 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 (signal.tag) { | ||
| if (queue.length >= max && max > 0) { | ||
| queue.shift(); | ||
| } | ||
| queue.push(signal[0]); | ||
| return talkback(0); | ||
| } else { | ||
| return talkback(0); | ||
| } | ||
| }); | ||
| }; | ||
| }; | ||
| } | ||
| var takeLast$1 = takeLast; | ||
| function takeWhile(f) { | ||
| var takeUntil$1 = function takeUntil(notifier) { | ||
| 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 { | ||
| ended[0] = !0; | ||
| return sink(0); | ||
| } | ||
| } else if (signal.tag) { | ||
| if (ended[0]) { | ||
| return 0; | ||
| } else if (f(signal[0])) { | ||
| return sink(signal); | ||
| } else { | ||
| ended[0] = !0; | ||
| sink(0); | ||
| return talkback[0](1); | ||
| } | ||
| } else { | ||
| talkback[0] = signal[0]; | ||
| return sink(signal); | ||
| } | ||
| }); | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (ended[0]) { | ||
| return 0; | ||
| } else if (signal) { | ||
| ended[0] = !0; | ||
| return talkback[0](1); | ||
| } else { | ||
| return talkback[0](0); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| }; | ||
| } | ||
| function takeUntil(notifier) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var state = [!1, talkbackPlaceholder, talkbackPlaceholder]; | ||
@@ -1103,74 +1177,30 @@ _1(source, function(signal) { | ||
| }; | ||
| } | ||
| }; | ||
| function skip(wait) { | ||
| var takeWhile$1 = function takeWhile(f) { | ||
| 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 { | ||
| rest[0] = (rest[0] - 1) | 0; | ||
| return talkback(0); | ||
| } | ||
| }); | ||
| }; | ||
| }; | ||
| } | ||
| function skipWhile(f) { | ||
| 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 (f(signal[0])) { | ||
| return talkback(0); | ||
| } else { | ||
| skip[0] = !1; | ||
| return sink(signal); | ||
| } | ||
| }); | ||
| }; | ||
| }; | ||
| } | ||
| function skipUntil(notifier) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var state = [!0, !1, !1, talkbackPlaceholder, talkbackPlaceholder]; | ||
| var ended = [!1]; | ||
| var talkback = [talkbackPlaceholder]; | ||
| _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| if (state[0]) { | ||
| state[4](1); | ||
| if (ended[0]) { | ||
| return 0; | ||
| } else { | ||
| ended[0] = !0; | ||
| return sink(0); | ||
| } | ||
| state[1] = !0; | ||
| return sink(0); | ||
| } else if (signal.tag) { | ||
| if (state[0] && !state[1]) { | ||
| return state[3](0); | ||
| } else if (state[1]) { | ||
| if (ended[0]) { | ||
| return 0; | ||
| } else if (f(signal[0])) { | ||
| return sink(signal); | ||
| } else { | ||
| state[2] = !1; | ||
| return sink(signal); | ||
| ended[0] = !0; | ||
| sink(0); | ||
| return talkback[0](1); | ||
| } | ||
| } else { | ||
| var tb = signal[0]; | ||
| state[3] = tb; | ||
| return _1(notifier, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| return 0; | ||
| } else if (signal.tag) { | ||
| state[0] = !1; | ||
| return state[4](1); | ||
| } else { | ||
| var innerTb = signal[0]; | ||
| state[4] = innerTb; | ||
| innerTb(0); | ||
| return tb(0); | ||
| } | ||
| }); | ||
| talkback[0] = signal[0]; | ||
| return sink(signal); | ||
| } | ||
@@ -1181,13 +1211,9 @@ }); | ||
| function(signal) { | ||
| if (signal) { | ||
| if (state[0]) { | ||
| state[4](1); | ||
| } | ||
| state[1] = !0; | ||
| return state[3](1); | ||
| } else if (!state[2] && !state[1]) { | ||
| state[2] = !0; | ||
| return state[3](0); | ||
| if (ended[0]) { | ||
| return 0; | ||
| } else if (signal) { | ||
| ended[0] = !0; | ||
| return talkback[0](1); | ||
| } else { | ||
| return 0; | ||
| return talkback[0](0); | ||
| } | ||
@@ -1199,5 +1225,20 @@ } | ||
| }; | ||
| } | ||
| }; | ||
| function publish(source) { | ||
| var tap$1 = function tap(f) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| return _1(source, function(signal) { | ||
| if ("number" != typeof signal) { | ||
| if (signal.tag) { | ||
| f(signal[0]); | ||
| } | ||
| } | ||
| return sink(signal); | ||
| }); | ||
| }; | ||
| }; | ||
| }; | ||
| var publish$1 = function publish(source) { | ||
| var state = [talkbackPlaceholder, !1]; | ||
@@ -1230,38 +1271,7 @@ _1(source, function(signal) { | ||
| ]; | ||
| } | ||
| }; | ||
| function subscribe(f) { | ||
| return function(source) { | ||
| var state = [talkbackPlaceholder, !1]; | ||
| _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| state[1] = !0; | ||
| return 0; | ||
| } else if (signal.tag) { | ||
| if (state[1]) { | ||
| return 0; | ||
| } else { | ||
| f(signal[0]); | ||
| return state[0](0); | ||
| } | ||
| } else { | ||
| var x = signal[0]; | ||
| state[0] = x; | ||
| return x(0); | ||
| } | ||
| }); | ||
| return [ | ||
| function(param) { | ||
| if (state[1]) { | ||
| return 0; | ||
| } else { | ||
| state[1] = !0; | ||
| return state[0](1); | ||
| } | ||
| } | ||
| ]; | ||
| }; | ||
| } | ||
| var subscribe$1 = subscribe; | ||
| function forEach(f) { | ||
| var forEach$1 = function forEach(f) { | ||
| return function(source) { | ||
@@ -1271,96 +1281,5 @@ subscribe(f)(source); | ||
| }; | ||
| } | ||
| }; | ||
| var Types = 0; | ||
| var flatten = mergeAll; | ||
| 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 { | ||
| return 0; | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| return _1(addListener, handler); | ||
| }; | ||
| } | ||
| function fromDomEvent(element, $$event) { | ||
| return function(sink) { | ||
| var addEventListener = function(element, event, handler) { | ||
| element.addEventListener(event, handler); | ||
| }; | ||
| var removeEventListener = function(element, event, handler) { | ||
| element.removeEventListener(event, handler); | ||
| }; | ||
| return fromListener( | ||
| function(handler) { | ||
| return _3(addEventListener, element, $$event, handler); | ||
| }, | ||
| function(handler) { | ||
| return _3(removeEventListener, element, $$event, handler); | ||
| } | ||
| )(sink); | ||
| }; | ||
| } | ||
| 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(signal) { | ||
| if (signal) { | ||
| clearInterval(id); | ||
| return 0; | ||
| } else { | ||
| return 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 sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (signal) { | ||
| ended[0] = !0; | ||
| return 0; | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| } | ||
| function debounce(f) { | ||
| var debounce$2 = function debounce(f) { | ||
| return function(source) { | ||
@@ -1420,58 +1339,79 @@ return function(sink) { | ||
| }; | ||
| } | ||
| }; | ||
| function throttle(f) { | ||
| var delay$2 = function delay(wait) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var skip$$1 = [!1]; | ||
| var id = [void 0]; | ||
| var $$clearTimeout$1 = function(param) { | ||
| var match = id[0]; | ||
| if (void 0 !== match) { | ||
| clearTimeout(valFromOption(match)); | ||
| return 0; | ||
| var state = [talkbackPlaceholder, 0, !1]; | ||
| _1(source, function(signal) { | ||
| var exit = 0; | ||
| if ("number" == typeof signal || signal.tag) { | ||
| exit = 1; | ||
| } else { | ||
| state[0] = signal[0]; | ||
| return 0; | ||
| } | ||
| }; | ||
| return _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| $$clearTimeout$1(); | ||
| return sink(0); | ||
| } else if (signal.tag) { | ||
| if (skip$$1[0]) { | ||
| if (1 === exit) { | ||
| if (state[2]) { | ||
| return 0; | ||
| } else { | ||
| skip$$1[0] = !0; | ||
| $$clearTimeout$1(); | ||
| id[0] = some( | ||
| setTimeout(function(param) { | ||
| id[0] = void 0; | ||
| skip$$1[0] = !1; | ||
| return 0; | ||
| }, f(signal[0])) | ||
| ); | ||
| return sink(signal); | ||
| state[1] = (state[1] + 1) | 0; | ||
| setTimeout(function(param) { | ||
| if (state[2] && 0 === state[1]) { | ||
| sink(0); | ||
| } else { | ||
| state[1] = (state[1] - 1) | 0; | ||
| } | ||
| return sink(signal); | ||
| }, wait); | ||
| return 0; | ||
| } | ||
| } else { | ||
| var tb = signal[0]; | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (signal) { | ||
| $$clearTimeout$1(); | ||
| return tb(1); | ||
| } else { | ||
| return tb(signal); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| } | ||
| }); | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (signal) { | ||
| state[2] = !0; | ||
| if (0 === state[1]) { | ||
| return sink(0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else if (state[2]) { | ||
| return 0; | ||
| } else { | ||
| return state[0](signal); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| }; | ||
| } | ||
| }; | ||
| function sample(notifier) { | ||
| var interval$2 = 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(signal) { | ||
| if (signal) { | ||
| clearInterval(id); | ||
| return 0; | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| }; | ||
| var sample$2 = function sample(notifier) { | ||
| return function(source) { | ||
@@ -1536,68 +1476,104 @@ return function(sink) { | ||
| }; | ||
| } | ||
| }; | ||
| function delay(wait) { | ||
| var throttle$2 = function throttle(f) { | ||
| 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; | ||
| 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; | ||
| } else { | ||
| state[0] = signal[0]; | ||
| return 0; | ||
| } | ||
| if (1 === exit) { | ||
| if (state[2]) { | ||
| }; | ||
| return _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| $$clearTimeout$1(); | ||
| return sink(0); | ||
| } else if (signal.tag) { | ||
| if (skip[0]) { | ||
| return 0; | ||
| } else { | ||
| state[1] = (state[1] + 1) | 0; | ||
| setTimeout(function(param) { | ||
| if (state[2] && 0 === state[1]) { | ||
| sink(0); | ||
| } else { | ||
| state[1] = (state[1] - 1) | 0; | ||
| skip[0] = !0; | ||
| $$clearTimeout$1(); | ||
| id[0] = some( | ||
| setTimeout(function(param) { | ||
| id[0] = void 0; | ||
| skip[0] = !1; | ||
| return 0; | ||
| }, f(signal[0])) | ||
| ); | ||
| return sink(signal); | ||
| } | ||
| } else { | ||
| var tb = signal[0]; | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (signal) { | ||
| $$clearTimeout$1(); | ||
| return tb(1); | ||
| } else { | ||
| return tb(signal); | ||
| } | ||
| } | ||
| return sink(signal); | ||
| }, wait); | ||
| return 0; | ||
| } | ||
| ]) | ||
| ); | ||
| } | ||
| }); | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (signal) { | ||
| state[2] = !0; | ||
| if (0 === state[1]) { | ||
| return sink(0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else if (state[2]) { | ||
| return 0; | ||
| } else { | ||
| return state[0](signal); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| }; | ||
| } | ||
| }; | ||
| function toPromise(source) { | ||
| return new Promise(function(resolve, param) { | ||
| return _1(takeLast(1)(source), function(signal) { | ||
| if ("number" == typeof signal) { | ||
| return 0; | ||
| } else if (signal.tag) { | ||
| return resolve(signal[0]); | ||
| } else { | ||
| return signal[0](0); | ||
| var toPromise$2 = toPromise$1; | ||
| var fromDomEvent$2 = function fromDomEvent(element, $$event) { | ||
| return function(sink) { | ||
| var addEventListener = function(element, event, handler) { | ||
| element.addEventListener(event, handler); | ||
| }; | ||
| var removeEventListener = function(element, event, handler) { | ||
| element.removeEventListener(event, handler); | ||
| }; | ||
| return fromListener( | ||
| function(handler) { | ||
| return _3(addEventListener, element, $$event, handler); | ||
| }, | ||
| function(handler) { | ||
| return _3(removeEventListener, element, $$event, handler); | ||
| } | ||
| )(sink); | ||
| }; | ||
| }; | ||
| var fromListener$2 = fromListener; | ||
| var fromPromise$2 = 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 sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (signal) { | ||
| ended[0] = !0; | ||
| return 0; | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| }; | ||
@@ -1607,42 +1583,42 @@ export { | ||
| Types, | ||
| makeSubject, | ||
| make, | ||
| fromList, | ||
| fromArray, | ||
| fromValue, | ||
| empty, | ||
| never, | ||
| tap, | ||
| map, | ||
| filter, | ||
| scan, | ||
| mergeMap, | ||
| switchMap, | ||
| concatMap, | ||
| merge, | ||
| concat, | ||
| mergeAll, | ||
| flatten, | ||
| concatAll, | ||
| share, | ||
| combine, | ||
| take, | ||
| takeLast, | ||
| takeWhile, | ||
| takeUntil, | ||
| skip, | ||
| skipWhile, | ||
| skipUntil, | ||
| publish, | ||
| forEach, | ||
| subscribe, | ||
| fromListener, | ||
| fromDomEvent, | ||
| interval, | ||
| fromPromise, | ||
| debounce, | ||
| throttle, | ||
| sample, | ||
| delay, | ||
| toPromise | ||
| fromArray$1 as fromArray, | ||
| fromList$1 as fromList, | ||
| fromValue$1 as fromValue, | ||
| make$1 as make, | ||
| makeSubject$1 as makeSubject, | ||
| empty$1 as empty, | ||
| never$1 as never, | ||
| combine$1 as combine, | ||
| concatMap$1 as concatMap, | ||
| concat$1 as concat, | ||
| concatAll$1 as concatAll, | ||
| filter$1 as filter, | ||
| map$1 as map, | ||
| mergeMap$1 as mergeMap, | ||
| merge$1 as merge, | ||
| mergeAll$1 as mergeAll, | ||
| flatten$1 as flatten, | ||
| scan$1 as scan, | ||
| share$1 as share, | ||
| skip$1 as skip, | ||
| skipUntil$1 as skipUntil, | ||
| skipWhile$1 as skipWhile, | ||
| switchMap$1 as switchMap, | ||
| take$1 as take, | ||
| takeLast$1 as takeLast, | ||
| takeUntil$1 as takeUntil, | ||
| takeWhile$1 as takeWhile, | ||
| tap$1 as tap, | ||
| publish$1 as publish, | ||
| subscribe$1 as subscribe, | ||
| forEach$1 as forEach, | ||
| debounce$2 as debounce, | ||
| delay$2 as delay, | ||
| interval$2 as interval, | ||
| sample$2 as sample, | ||
| throttle$2 as throttle, | ||
| toPromise$2 as toPromise, | ||
| fromDomEvent$2 as fromDomEvent, | ||
| fromListener$2 as fromListener, | ||
| fromPromise$2 as fromPromise | ||
| }; |
1418
dist/wonka.js
@@ -87,47 +87,2 @@ function __(tag, block) { | ||
| function _2(o, a0, a1) { | ||
| var arity = o.length; | ||
| if (2 === arity) { | ||
| return o(a0, a1); | ||
| } else { | ||
| return (function curry_2(o, a0, a1, arity) { | ||
| switch (arity) { | ||
| case 1: | ||
| return app(o(a0), [a1]); | ||
| case 2: | ||
| return o(a0, a1); | ||
| case 3: | ||
| return function(param) { | ||
| return o(a0, a1, param); | ||
| }; | ||
| case 4: | ||
| return function(param, param$1) { | ||
| return o(a0, a1, param, param$1); | ||
| }; | ||
| case 5: | ||
| return function(param, param$1, param$2) { | ||
| return o(a0, a1, param, param$1, param$2); | ||
| }; | ||
| case 6: | ||
| return function(param, param$1, param$2, param$3) { | ||
| return o(a0, a1, param, param$1, param$2, param$3); | ||
| }; | ||
| case 7: | ||
| return function(param, param$1, param$2, param$3, param$4) { | ||
| return o(a0, a1, param, param$1, param$2, param$3, param$4); | ||
| }; | ||
| default: | ||
| return app(o, [a0, a1]); | ||
| } | ||
| })(o, a0, a1, arity); | ||
| } | ||
| } | ||
| function _3(o, a0, a1, a2) { | ||
@@ -184,4 +139,3 @@ var arity = o.length; | ||
| } else if (null !== x && x[0] === undefinedHeader) { | ||
| var nid = (x[1] + 1) | 0; | ||
| var block$1 = [undefinedHeader, nid]; | ||
| var block$1 = [undefinedHeader, (x[1] + 1) | 0]; | ||
| block$1.tag = 256; | ||
@@ -223,2 +177,129 @@ return block$1; | ||
| 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) { | ||
| if (signal || state[0]) { | ||
| 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 (signal.tag) { | ||
| if (queue.length >= max && max > 0) { | ||
| queue.shift(); | ||
| } | ||
| queue.push(signal[0]); | ||
| return talkback(0); | ||
| } else { | ||
| return talkback(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 { | ||
| return 0; | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| return _1(addListener, handler); | ||
| }; | ||
| } | ||
| var toPromise$1 = function toPromise(source) { | ||
| return new Promise(function(resolve, param) { | ||
| return _1(takeLast(1)(source), function(signal) { | ||
| if ("number" == typeof signal) { | ||
| return 0; | ||
| } else if (signal.tag) { | ||
| return resolve(signal[0]); | ||
| } else { | ||
| return signal[0](0); | ||
| } | ||
| }); | ||
| }); | ||
| }; | ||
| function subscribe(f) { | ||
| return function(source) { | ||
| var state = [talkbackPlaceholder, !1]; | ||
| _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| state[1] = !0; | ||
| return 0; | ||
| } else if (signal.tag) { | ||
| if (state[1]) { | ||
| return 0; | ||
| } else { | ||
| f(signal[0]); | ||
| return state[0](0); | ||
| } | ||
| } else { | ||
| var x = signal[0]; | ||
| state[0] = x; | ||
| return x(0); | ||
| } | ||
| }); | ||
| return [ | ||
| function(param) { | ||
| if (state[1]) { | ||
| return 0; | ||
| } else { | ||
| state[1] = !0; | ||
| return state[0](1); | ||
| } | ||
| } | ||
| ]; | ||
| }; | ||
| } | ||
| function fromArray(arr) { | ||
@@ -321,2 +402,5 @@ return function(sink) { | ||
| if (signal) { | ||
| state[1].forEach(function(talkback) { | ||
| return talkback(1); | ||
| }); | ||
| if (state[2]) { | ||
@@ -425,2 +509,3 @@ return 0; | ||
| if (signal) { | ||
| state[2](1); | ||
| if (state[5]) { | ||
@@ -432,3 +517,4 @@ return 0; | ||
| state[1](1); | ||
| return state[2](1); | ||
| state[2] = talkbackPlaceholder; | ||
| return 0; | ||
| } | ||
@@ -447,108 +533,74 @@ } else if (state[5]) { | ||
| 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 (signal.tag) { | ||
| if (queue.length >= max && max > 0) { | ||
| queue.shift(); | ||
| var fromArray$1 = fromArray; | ||
| var fromList$1 = function fromList(ls) { | ||
| return function(sink) { | ||
| var state = [ls, !1, !1, !1]; | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| var match = state[2]; | ||
| if (signal) { | ||
| state[1] = !0; | ||
| return 0; | ||
| } else if (match) { | ||
| state[3] = !0; | ||
| return 0; | ||
| } else { | ||
| 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 { | ||
| state[1] = !0; | ||
| sink(0); | ||
| } | ||
| } | ||
| state[2] = !1; | ||
| return 0; | ||
| } | ||
| queue.push(signal[0]); | ||
| return talkback(0); | ||
| } else { | ||
| return talkback(0); | ||
| } | ||
| }); | ||
| }; | ||
| ]) | ||
| ); | ||
| }; | ||
| } | ||
| }; | ||
| function subscribe(f) { | ||
| return function(source) { | ||
| var state = [talkbackPlaceholder, !1]; | ||
| _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| state[1] = !0; | ||
| return 0; | ||
| } else if (signal.tag) { | ||
| if (state[1]) { | ||
| return 0; | ||
| } else { | ||
| f(signal[0]); | ||
| return state[0](0); | ||
| var fromValue$1 = function fromValue(x) { | ||
| return function(sink) { | ||
| var ended = [!1]; | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (signal || ended[0]) { | ||
| return 0; | ||
| } else { | ||
| ended[0] = !0; | ||
| sink(__(1, [x])); | ||
| return sink(0); | ||
| } | ||
| } | ||
| } else { | ||
| var x = signal[0]; | ||
| state[0] = x; | ||
| return x(0); | ||
| } | ||
| }); | ||
| return [ | ||
| function(param) { | ||
| if (state[1]) { | ||
| return 0; | ||
| } else { | ||
| state[1] = !0; | ||
| return state[0](1); | ||
| } | ||
| } | ||
| ]; | ||
| ]) | ||
| ); | ||
| }; | ||
| } | ||
| }; | ||
| var flatten = mergeAll; | ||
| function fromListener(addListener, removeListener) { | ||
| var make$1 = function make(f) { | ||
| return function(sink) { | ||
| var handler = function($$event) { | ||
| return sink(__(1, [$$event])); | ||
| }; | ||
| sink( | ||
| var teardown = f([ | ||
| function(value) { | ||
| return sink(__(1, [value])); | ||
| }, | ||
| function(param) { | ||
| return sink(0); | ||
| } | ||
| ]); | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (signal) { | ||
| return _1(removeListener, handler); | ||
| return teardown(); | ||
| } else { | ||
@@ -560,19 +612,6 @@ return 0; | ||
| ); | ||
| return _1(addListener, handler); | ||
| }; | ||
| } | ||
| 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 makeSubject$1 = function makeSubject(param) { | ||
| var state = [new Array(), !1]; | ||
@@ -621,102 +660,125 @@ return [ | ||
| exports.make = function make(f) { | ||
| return function(sink) { | ||
| var teardown = f([ | ||
| function(value) { | ||
| return sink(__(1, [value])); | ||
| }, | ||
| function(param) { | ||
| return sink(0); | ||
| } | ||
| ]); | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (signal) { | ||
| return teardown(); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| var empty$1 = function empty(sink) { | ||
| sink(__(0, [talkbackPlaceholder])); | ||
| return sink(0); | ||
| }; | ||
| exports.fromList = function fromList(ls) { | ||
| return function(sink) { | ||
| var state = [ls, !1, !1, !1]; | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| var match = state[2]; | ||
| if (signal) { | ||
| state[1] = !0; | ||
| var never$1 = function never(sink) { | ||
| return sink(__(0, [talkbackPlaceholder])); | ||
| }; | ||
| var combine$1 = function combine(sourceA) { | ||
| return function(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 (match) { | ||
| state[3] = !0; | ||
| } else if (state[6]) { | ||
| return 0; | ||
| } else { | ||
| 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 { | ||
| state[1] = !0; | ||
| sink(0); | ||
| } | ||
| state[6] = !0; | ||
| return sink(0); | ||
| } | ||
| } else if (signal.tag) { | ||
| var a = signal[0]; | ||
| if (void 0 !== match) { | ||
| if (state[6]) { | ||
| return 0; | ||
| } else { | ||
| state[2] = some(a); | ||
| state[4] = !1; | ||
| return sink(__(1, [[a, valFromOption(match)]])); | ||
| } | ||
| state[2] = !1; | ||
| } else { | ||
| state[2] = some(a); | ||
| state[4] = !1; | ||
| return 0; | ||
| } | ||
| } else { | ||
| state[0] = signal[0]; | ||
| return 0; | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| }; | ||
| exports.fromArray = fromArray; | ||
| exports.fromValue = function fromValue(x) { | ||
| return function(sink) { | ||
| var ended = [!1]; | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (signal || ended[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 (state[6]) { | ||
| return 0; | ||
| } else { | ||
| ended[0] = !0; | ||
| sink(__(1, [x])); | ||
| state[6] = !0; | ||
| return sink(0); | ||
| } | ||
| } else if (signal.tag) { | ||
| var b = signal[0]; | ||
| if (void 0 !== match) { | ||
| if (state[6]) { | ||
| return 0; | ||
| } else { | ||
| state[3] = some(b); | ||
| state[4] = !1; | ||
| return sink(__(1, [[valFromOption(match), b]])); | ||
| } | ||
| } else { | ||
| state[3] = some(b); | ||
| state[4] = !1; | ||
| return 0; | ||
| } | ||
| } else { | ||
| state[1] = signal[0]; | ||
| return 0; | ||
| } | ||
| ]) | ||
| ); | ||
| }); | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (state[6]) { | ||
| return 0; | ||
| } else if (signal) { | ||
| state[6] = !0; | ||
| state[0](1); | ||
| return state[1](1); | ||
| } else if (state[4]) { | ||
| return 0; | ||
| } else { | ||
| state[4] = !0; | ||
| state[0](signal); | ||
| return state[1](signal); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| }; | ||
| }; | ||
| exports.empty = function empty(sink) { | ||
| sink(__(0, [talkbackPlaceholder])); | ||
| return sink(0); | ||
| var concatMap$1 = concatMap; | ||
| var concat$1 = function concat(sources) { | ||
| return concatMap(function(x) { | ||
| return x; | ||
| })(fromArray(sources)); | ||
| }; | ||
| exports.never = function never(sink) { | ||
| return sink(__(0, [talkbackPlaceholder])); | ||
| var concatAll$1 = function concatAll(source) { | ||
| return concatMap(function(x) { | ||
| return x; | ||
| })(source); | ||
| }; | ||
| exports.tap = function tap(f) { | ||
| var filter$1 = function filter(f) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| return _1(source, function(signal) { | ||
| if ("number" != typeof signal) { | ||
| if (signal.tag) { | ||
| f(signal[0]); | ||
| } | ||
| return captureTalkback(source, function(signal, talkback) { | ||
| if ("number" == typeof signal || !signal.tag || f(signal[0])) { | ||
| return sink(signal); | ||
| } else { | ||
| return talkback(0); | ||
| } | ||
| return sink(signal); | ||
| }); | ||
@@ -727,3 +789,3 @@ }; | ||
| exports.map = function map(f) { | ||
| var map$1 = function map(f) { | ||
| return function(source) { | ||
@@ -741,9 +803,91 @@ return function(sink) { | ||
| exports.filter = function filter(f) { | ||
| var mergeMap$1 = mergeMap; | ||
| var merge$1 = function merge(sources) { | ||
| return mergeMap(function(x) { | ||
| return x; | ||
| })(fromArray(sources)); | ||
| }; | ||
| var mergeAll$1 = mergeAll; | ||
| var flatten$1 = mergeAll; | ||
| var scan$1 = 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] = f(acc[0], signal[0]); | ||
| tmp = __(1, [acc[0]]); | ||
| } else { | ||
| tmp = __(0, [signal[0]]); | ||
| } | ||
| return sink(tmp); | ||
| }); | ||
| }; | ||
| }; | ||
| }; | ||
| var share$1 = 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); | ||
| }); | ||
| state[0] = new Array(); | ||
| return 0; | ||
| } else if (signal.tag) { | ||
| state[2] = !1; | ||
| state[0].forEach(function(sink) { | ||
| return sink(signal); | ||
| }); | ||
| return 0; | ||
| } else { | ||
| state[1] = signal[0]; | ||
| return 0; | ||
| } | ||
| }); | ||
| } | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (signal) { | ||
| state[0] = state[0].filter(function(x) { | ||
| return x !== sink; | ||
| }); | ||
| if (0 === state[0].length) { | ||
| return state[1](1); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else if (state[2]) { | ||
| return 0; | ||
| } else { | ||
| state[2] = !0; | ||
| return state[1](signal); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| }; | ||
| var skip$1 = function skip(wait) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var rest = [wait]; | ||
| return captureTalkback(source, function(signal, talkback) { | ||
| if ("number" == typeof signal || !signal.tag || f(signal[0])) { | ||
| if ("number" == typeof signal || !(signal.tag && rest[0] > 0)) { | ||
| return sink(signal); | ||
| } else { | ||
| rest[0] = (rest[0] - 1) | 0; | ||
| return talkback(0); | ||
@@ -756,18 +900,58 @@ } | ||
| exports.scan = function scan(f, seed) { | ||
| var skipUntil$1 = function skipUntil(notifier) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var acc = [seed]; | ||
| return _1(source, function(signal) { | ||
| var tmp; | ||
| var state = [!0, !1, !1, talkbackPlaceholder, talkbackPlaceholder]; | ||
| _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| tmp = 0; | ||
| if (state[0]) { | ||
| state[4](1); | ||
| } | ||
| state[1] = !0; | ||
| return sink(0); | ||
| } else if (signal.tag) { | ||
| acc[0] = _2(f, acc[0], signal[0]); | ||
| tmp = __(1, [acc[0]]); | ||
| if (state[0] && !state[1]) { | ||
| return state[3](0); | ||
| } else if (state[1]) { | ||
| return 0; | ||
| } else { | ||
| state[2] = !1; | ||
| return sink(signal); | ||
| } | ||
| } else { | ||
| tmp = __(0, [signal[0]]); | ||
| var tb = signal[0]; | ||
| state[3] = tb; | ||
| return _1(notifier, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| return 0; | ||
| } else if (signal.tag) { | ||
| state[0] = !1; | ||
| return state[4](1); | ||
| } else { | ||
| var innerTb = signal[0]; | ||
| state[4] = innerTb; | ||
| innerTb(0); | ||
| return tb(0); | ||
| } | ||
| }); | ||
| } | ||
| return sink(tmp); | ||
| }); | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (signal) { | ||
| if (state[0]) { | ||
| state[4](1); | ||
| } | ||
| state[1] = !0; | ||
| return state[3](1); | ||
| } else if (!state[2] && !state[1]) { | ||
| state[2] = !0; | ||
| return state[3](0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
@@ -777,5 +961,21 @@ }; | ||
| exports.mergeMap = mergeMap; | ||
| var skipWhile$1 = function skipWhile(f) { | ||
| 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 (f(signal[0])) { | ||
| return talkback(0); | ||
| } else { | ||
| skip[0] = !1; | ||
| return sink(signal); | ||
| } | ||
| }); | ||
| }; | ||
| }; | ||
| }; | ||
| exports.switchMap = function switchMap(f) { | ||
| var switchMap$1 = function switchMap(f) { | ||
| return function(source) { | ||
@@ -839,2 +1039,3 @@ return function(sink) { | ||
| if (signal) { | ||
| state[1](1); | ||
| if (state[4]) { | ||
@@ -846,3 +1047,2 @@ return 0; | ||
| state[0](1); | ||
| state[1](1); | ||
| state[1] = talkbackPlaceholder; | ||
@@ -861,164 +1061,3 @@ return 0; | ||
| exports.concatMap = concatMap; | ||
| exports.merge = function merge(sources) { | ||
| return mergeMap(function(x) { | ||
| return x; | ||
| })(fromArray(sources)); | ||
| }; | ||
| exports.concat = function concat(sources) { | ||
| return concatMap(function(x) { | ||
| return x; | ||
| })(fromArray(sources)); | ||
| }; | ||
| exports.mergeAll = mergeAll; | ||
| exports.flatten = flatten; | ||
| exports.concatAll = function concatAll(source) { | ||
| return concatMap(function(x) { | ||
| return x; | ||
| })(source); | ||
| }; | ||
| 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); | ||
| }); | ||
| state[0] = new Array(); | ||
| return 0; | ||
| } else if (signal.tag) { | ||
| state[2] = !1; | ||
| state[0].forEach(function(sink) { | ||
| return sink(signal); | ||
| }); | ||
| return 0; | ||
| } else { | ||
| state[1] = signal[0]; | ||
| return 0; | ||
| } | ||
| }); | ||
| } | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (signal) { | ||
| state[0] = state[0].filter(function(x) { | ||
| return x !== sink; | ||
| }); | ||
| if (0 === state[0].length) { | ||
| return state[1](1); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else if (state[2]) { | ||
| return 0; | ||
| } else { | ||
| state[2] = !0; | ||
| return state[1](signal); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| }; | ||
| 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 (state[6]) { | ||
| return 0; | ||
| } else { | ||
| state[6] = !0; | ||
| return sink(0); | ||
| } | ||
| } else if (signal.tag) { | ||
| var a = signal[0]; | ||
| if (void 0 !== match) { | ||
| if (state[6]) { | ||
| return 0; | ||
| } else { | ||
| state[2] = some(a); | ||
| state[4] = !1; | ||
| return sink(__(1, [[a, valFromOption(match)]])); | ||
| } | ||
| } else { | ||
| state[2] = some(a); | ||
| state[4] = !1; | ||
| return 0; | ||
| } | ||
| } else { | ||
| state[0] = signal[0]; | ||
| return 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 (state[6]) { | ||
| return 0; | ||
| } else { | ||
| state[6] = !0; | ||
| return sink(0); | ||
| } | ||
| } else if (signal.tag) { | ||
| var b = signal[0]; | ||
| if (void 0 !== match) { | ||
| if (state[6]) { | ||
| return 0; | ||
| } else { | ||
| state[3] = some(b); | ||
| state[4] = !1; | ||
| return sink(__(1, [[valFromOption(match), b]])); | ||
| } | ||
| } else { | ||
| state[3] = some(b); | ||
| state[4] = !1; | ||
| return 0; | ||
| } | ||
| } else { | ||
| state[1] = signal[0]; | ||
| return 0; | ||
| } | ||
| }); | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (state[6]) { | ||
| return 0; | ||
| } else if (signal) { | ||
| state[6] = !0; | ||
| state[0](1); | ||
| return state[1](1); | ||
| } else if (state[4]) { | ||
| return 0; | ||
| } else { | ||
| state[4] = !0; | ||
| state[0](signal); | ||
| return state[1](signal); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| }; | ||
| exports.take = function take(max) { | ||
| var take$1 = function take(max) { | ||
| return function(source) { | ||
@@ -1073,53 +1112,7 @@ return function(sink) { | ||
| exports.takeLast = takeLast; | ||
| var takeLast$1 = takeLast; | ||
| exports.takeWhile = function takeWhile(f) { | ||
| var takeUntil$1 = function takeUntil(notifier) { | ||
| 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 { | ||
| ended[0] = !0; | ||
| return sink(0); | ||
| } | ||
| } else if (signal.tag) { | ||
| if (ended[0]) { | ||
| return 0; | ||
| } else if (f(signal[0])) { | ||
| return sink(signal); | ||
| } else { | ||
| ended[0] = !0; | ||
| sink(0); | ||
| return talkback[0](1); | ||
| } | ||
| } else { | ||
| talkback[0] = signal[0]; | ||
| return sink(signal); | ||
| } | ||
| }); | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (ended[0]) { | ||
| return 0; | ||
| } else if (signal) { | ||
| ended[0] = !0; | ||
| return talkback[0](1); | ||
| } else { | ||
| return talkback[0](0); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| }; | ||
| }; | ||
| exports.takeUntil = function takeUntil(notifier) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var state = [!1, talkbackPlaceholder, talkbackPlaceholder]; | ||
@@ -1177,72 +1170,28 @@ _1(source, function(signal) { | ||
| exports.skip = function skip(wait) { | ||
| var takeWhile$1 = function takeWhile(f) { | ||
| 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 { | ||
| rest[0] = (rest[0] - 1) | 0; | ||
| return talkback(0); | ||
| } | ||
| }); | ||
| }; | ||
| }; | ||
| }; | ||
| exports.skipWhile = function skipWhile(f) { | ||
| 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 (f(signal[0])) { | ||
| return talkback(0); | ||
| } else { | ||
| skip[0] = !1; | ||
| return sink(signal); | ||
| } | ||
| }); | ||
| }; | ||
| }; | ||
| }; | ||
| exports.skipUntil = function skipUntil(notifier) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var state = [!0, !1, !1, talkbackPlaceholder, talkbackPlaceholder]; | ||
| var ended = [!1]; | ||
| var talkback = [talkbackPlaceholder]; | ||
| _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| if (state[0]) { | ||
| state[4](1); | ||
| if (ended[0]) { | ||
| return 0; | ||
| } else { | ||
| ended[0] = !0; | ||
| return sink(0); | ||
| } | ||
| state[1] = !0; | ||
| return sink(0); | ||
| } else if (signal.tag) { | ||
| if (state[0] && !state[1]) { | ||
| return state[3](0); | ||
| } else if (state[1]) { | ||
| if (ended[0]) { | ||
| return 0; | ||
| } else if (f(signal[0])) { | ||
| return sink(signal); | ||
| } else { | ||
| state[2] = !1; | ||
| return sink(signal); | ||
| ended[0] = !0; | ||
| sink(0); | ||
| return talkback[0](1); | ||
| } | ||
| } else { | ||
| var tb = signal[0]; | ||
| state[3] = tb; | ||
| return _1(notifier, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| return 0; | ||
| } else if (signal.tag) { | ||
| state[0] = !1; | ||
| return state[4](1); | ||
| } else { | ||
| var innerTb = signal[0]; | ||
| state[4] = innerTb; | ||
| innerTb(0); | ||
| return tb(0); | ||
| } | ||
| }); | ||
| talkback[0] = signal[0]; | ||
| return sink(signal); | ||
| } | ||
@@ -1253,13 +1202,9 @@ }); | ||
| function(signal) { | ||
| if (signal) { | ||
| if (state[0]) { | ||
| state[4](1); | ||
| } | ||
| state[1] = !0; | ||
| return state[3](1); | ||
| } else if (!state[2] && !state[1]) { | ||
| state[2] = !0; | ||
| return state[3](0); | ||
| if (ended[0]) { | ||
| return 0; | ||
| } else if (signal) { | ||
| ended[0] = !0; | ||
| return talkback[0](1); | ||
| } else { | ||
| return 0; | ||
| return talkback[0](0); | ||
| } | ||
@@ -1273,3 +1218,18 @@ } | ||
| exports.publish = function publish(source) { | ||
| var tap$1 = function tap(f) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| return _1(source, function(signal) { | ||
| if ("number" != typeof signal) { | ||
| if (signal.tag) { | ||
| f(signal[0]); | ||
| } | ||
| } | ||
| return sink(signal); | ||
| }); | ||
| }; | ||
| }; | ||
| }; | ||
| var publish$1 = function publish(source) { | ||
| var state = [talkbackPlaceholder, !1]; | ||
@@ -1304,3 +1264,5 @@ _1(source, function(signal) { | ||
| exports.forEach = function forEach(f) { | ||
| var subscribe$1 = subscribe; | ||
| var forEach$1 = function forEach(f) { | ||
| return function(source) { | ||
@@ -1312,74 +1274,3 @@ subscribe(f)(source); | ||
| exports.subscribe = subscribe; | ||
| exports.fromListener = fromListener; | ||
| exports.fromDomEvent = function fromDomEvent(element, $$event) { | ||
| return function(sink) { | ||
| var addEventListener = function(element, event, handler) { | ||
| element.addEventListener(event, handler); | ||
| }; | ||
| var removeEventListener = function(element, event, handler) { | ||
| element.removeEventListener(event, handler); | ||
| }; | ||
| return fromListener( | ||
| function(handler) { | ||
| return _3(addEventListener, element, $$event, handler); | ||
| }, | ||
| function(handler) { | ||
| return _3(removeEventListener, element, $$event, handler); | ||
| } | ||
| )(sink); | ||
| }; | ||
| }; | ||
| 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(signal) { | ||
| if (signal) { | ||
| clearInterval(id); | ||
| return 0; | ||
| } else { | ||
| return 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 sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (signal) { | ||
| ended[0] = !0; | ||
| return 0; | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| }; | ||
| exports.debounce = function debounce(f) { | ||
| var debounce$2 = function debounce(f) { | ||
| return function(source) { | ||
@@ -1441,51 +1332,49 @@ return function(sink) { | ||
| exports.throttle = function throttle(f) { | ||
| var delay$2 = function delay(wait) { | ||
| return function(source) { | ||
| return function(sink) { | ||
| var skip$$1 = [!1]; | ||
| var id = [void 0]; | ||
| var $$clearTimeout$1 = function(param) { | ||
| var match = id[0]; | ||
| if (void 0 !== match) { | ||
| clearTimeout(valFromOption(match)); | ||
| return 0; | ||
| var state = [talkbackPlaceholder, 0, !1]; | ||
| _1(source, function(signal) { | ||
| var exit = 0; | ||
| if ("number" == typeof signal || signal.tag) { | ||
| exit = 1; | ||
| } else { | ||
| state[0] = signal[0]; | ||
| return 0; | ||
| } | ||
| }; | ||
| return _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| $$clearTimeout$1(); | ||
| return sink(0); | ||
| } else if (signal.tag) { | ||
| if (skip$$1[0]) { | ||
| if (1 === exit) { | ||
| if (state[2]) { | ||
| return 0; | ||
| } else { | ||
| skip$$1[0] = !0; | ||
| $$clearTimeout$1(); | ||
| id[0] = some( | ||
| setTimeout(function(param) { | ||
| id[0] = void 0; | ||
| skip$$1[0] = !1; | ||
| return 0; | ||
| }, f(signal[0])) | ||
| ); | ||
| return sink(signal); | ||
| state[1] = (state[1] + 1) | 0; | ||
| setTimeout(function(param) { | ||
| if (state[2] && 0 === state[1]) { | ||
| sink(0); | ||
| } else { | ||
| state[1] = (state[1] - 1) | 0; | ||
| } | ||
| return sink(signal); | ||
| }, wait); | ||
| return 0; | ||
| } | ||
| } else { | ||
| var tb = signal[0]; | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (signal) { | ||
| $$clearTimeout$1(); | ||
| return tb(1); | ||
| } else { | ||
| return tb(signal); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| } | ||
| }); | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (signal) { | ||
| state[2] = !0; | ||
| if (0 === state[1]) { | ||
| return sink(0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else if (state[2]) { | ||
| return 0; | ||
| } else { | ||
| return state[0](signal); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
@@ -1495,3 +1384,26 @@ }; | ||
| exports.sample = function sample(notifier) { | ||
| var interval$2 = 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(signal) { | ||
| if (signal) { | ||
| clearInterval(id); | ||
| return 0; | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| }; | ||
| var sample$2 = function sample(notifier) { | ||
| return function(source) { | ||
@@ -1558,49 +1470,51 @@ return function(sink) { | ||
| exports.delay = function delay(wait) { | ||
| var throttle$2 = function throttle(f) { | ||
| 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; | ||
| 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; | ||
| } else { | ||
| state[0] = signal[0]; | ||
| return 0; | ||
| } | ||
| if (1 === exit) { | ||
| if (state[2]) { | ||
| }; | ||
| return _1(source, function(signal) { | ||
| if ("number" == typeof signal) { | ||
| $$clearTimeout$1(); | ||
| return sink(0); | ||
| } else if (signal.tag) { | ||
| if (skip[0]) { | ||
| return 0; | ||
| } else { | ||
| state[1] = (state[1] + 1) | 0; | ||
| setTimeout(function(param) { | ||
| if (state[2] && 0 === state[1]) { | ||
| sink(0); | ||
| } else { | ||
| state[1] = (state[1] - 1) | 0; | ||
| skip[0] = !0; | ||
| $$clearTimeout$1(); | ||
| id[0] = some( | ||
| setTimeout(function(param) { | ||
| id[0] = void 0; | ||
| skip[0] = !1; | ||
| return 0; | ||
| }, f(signal[0])) | ||
| ); | ||
| return sink(signal); | ||
| } | ||
| } else { | ||
| var tb = signal[0]; | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (signal) { | ||
| $$clearTimeout$1(); | ||
| return tb(1); | ||
| } else { | ||
| return tb(signal); | ||
| } | ||
| } | ||
| return sink(signal); | ||
| }, wait); | ||
| return 0; | ||
| } | ||
| ]) | ||
| ); | ||
| } | ||
| }); | ||
| return sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (signal) { | ||
| state[2] = !0; | ||
| if (0 === state[1]) { | ||
| return sink(0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else if (state[2]) { | ||
| return 0; | ||
| } else { | ||
| return state[0](signal); | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
@@ -1610,14 +1524,140 @@ }; | ||
| exports.toPromise = function toPromise(source) { | ||
| return new Promise(function(resolve, param) { | ||
| return _1(takeLast(1)(source), function(signal) { | ||
| if ("number" == typeof signal) { | ||
| return 0; | ||
| } else if (signal.tag) { | ||
| return resolve(signal[0]); | ||
| } else { | ||
| return signal[0](0); | ||
| var toPromise$2 = toPromise$1; | ||
| var fromDomEvent$2 = function fromDomEvent(element, $$event) { | ||
| return function(sink) { | ||
| var addEventListener = function(element, event, handler) { | ||
| element.addEventListener(event, handler); | ||
| }; | ||
| var removeEventListener = function(element, event, handler) { | ||
| element.removeEventListener(event, handler); | ||
| }; | ||
| return fromListener( | ||
| function(handler) { | ||
| return _3(addEventListener, element, $$event, handler); | ||
| }, | ||
| function(handler) { | ||
| return _3(removeEventListener, element, $$event, handler); | ||
| } | ||
| )(sink); | ||
| }; | ||
| }; | ||
| var fromListener$2 = fromListener; | ||
| var fromPromise$2 = 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 sink( | ||
| __(0, [ | ||
| function(signal) { | ||
| if (signal) { | ||
| ended[0] = !0; | ||
| return 0; | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| ]) | ||
| ); | ||
| }; | ||
| }; | ||
| 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.fromArray = fromArray$1; | ||
| exports.fromList = fromList$1; | ||
| exports.fromValue = fromValue$1; | ||
| exports.make = make$1; | ||
| exports.makeSubject = makeSubject$1; | ||
| exports.empty = empty$1; | ||
| exports.never = never$1; | ||
| exports.combine = combine$1; | ||
| exports.concatMap = concatMap$1; | ||
| exports.concat = concat$1; | ||
| exports.concatAll = concatAll$1; | ||
| exports.filter = filter$1; | ||
| exports.map = map$1; | ||
| exports.mergeMap = mergeMap$1; | ||
| exports.merge = merge$1; | ||
| exports.mergeAll = mergeAll$1; | ||
| exports.flatten = flatten$1; | ||
| exports.scan = scan$1; | ||
| exports.share = share$1; | ||
| exports.skip = skip$1; | ||
| exports.skipUntil = skipUntil$1; | ||
| exports.skipWhile = skipWhile$1; | ||
| exports.switchMap = switchMap$1; | ||
| exports.take = take$1; | ||
| exports.takeLast = takeLast$1; | ||
| exports.takeUntil = takeUntil$1; | ||
| exports.takeWhile = takeWhile$1; | ||
| exports.tap = tap$1; | ||
| exports.publish = publish$1; | ||
| exports.subscribe = subscribe$1; | ||
| exports.forEach = forEach$1; | ||
| exports.debounce = debounce$2; | ||
| exports.delay = delay$2; | ||
| exports.interval = interval$2; | ||
| exports.sample = sample$2; | ||
| exports.throttle = throttle$2; | ||
| exports.toPromise = toPromise$2; | ||
| exports.fromDomEvent = fromDomEvent$2; | ||
| exports.fromListener = fromListener$2; | ||
| exports.fromPromise = fromPromise$2; |
| 'use strict'; | ||
| var Block = require("bs-platform/lib/js/block.js"); | ||
| var Curry = require("bs-platform/lib/js/curry.js"); | ||
| var Wonka = require("../wonka.js"); | ||
| var Caml_option = require("bs-platform/lib/js/caml_option.js"); | ||
| var Wonka_helpers = require("../wonka_helpers.js"); | ||
| var Wonka_operator_delay = require("./wonka_operator_delay.js"); | ||
| var Wonka_sink_toPromise = require("./wonka_sink_toPromise.js"); | ||
| var Wonka_operator_sample = require("./wonka_operator_sample.js"); | ||
| var Wonka_operator_debounce = require("./wonka_operator_debounce.js"); | ||
| var Wonka_operator_interval = require("./wonka_operator_interval.js"); | ||
| var Wonka_operator_throttle = require("./wonka_operator_throttle.js"); | ||
| var Wonka_source_fromPromise = require("./wonka_source_fromPromise.js"); | ||
| var Wonka_source_fromDomEvent = require("./wonka_source_fromDomEvent.js"); | ||
| var Wonka_source_fromListener = require("./wonka_source_fromListener.js"); | ||
| function fromListener(addListener, removeListener) { | ||
| return (function (sink) { | ||
| var handler = function ($$event) { | ||
| return sink(/* Push */Block.__(1, [$$event])); | ||
| }; | ||
| sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (signal) { | ||
| return Curry._1(removeListener, handler); | ||
| } else { | ||
| return /* () */0; | ||
| } | ||
| })])); | ||
| return Curry._1(addListener, handler); | ||
| }); | ||
| } | ||
| var debounce = Wonka_operator_debounce.debounce; | ||
| function fromDomEvent(element, $$event) { | ||
| return (function (sink) { | ||
| var addEventListener = ( | ||
| function (element, event, handler) { | ||
| element.addEventListener(event, handler); | ||
| } | ||
| ); | ||
| var removeEventListener = ( | ||
| function (element, event, handler) { | ||
| element.removeEventListener(event, handler); | ||
| } | ||
| ); | ||
| return fromListener((function (handler) { | ||
| return Curry._3(addEventListener, element, $$event, handler); | ||
| }), (function (handler) { | ||
| return Curry._3(removeEventListener, element, $$event, handler); | ||
| }))(sink); | ||
| }); | ||
| } | ||
| var delay = Wonka_operator_delay.delay; | ||
| function interval(p) { | ||
| return (function (sink) { | ||
| var i = /* record */[/* contents */0]; | ||
| var id = setInterval((function (param) { | ||
| var num = i[0]; | ||
| i[0] = i[0] + 1 | 0; | ||
| return sink(/* Push */Block.__(1, [num])); | ||
| }), p); | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (signal) { | ||
| clearInterval(id); | ||
| return /* () */0; | ||
| } else { | ||
| return /* () */0; | ||
| } | ||
| })])); | ||
| }); | ||
| } | ||
| var interval = Wonka_operator_interval.interval; | ||
| function fromPromise(promise) { | ||
| return (function (sink) { | ||
| var ended = /* record */[/* contents */false]; | ||
| promise.then((function (value) { | ||
| if (!ended[0]) { | ||
| sink(/* Push */Block.__(1, [value])); | ||
| sink(/* End */0); | ||
| } | ||
| return Promise.resolve(/* () */0); | ||
| })); | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (signal) { | ||
| ended[0] = true; | ||
| return /* () */0; | ||
| } else { | ||
| return /* () */0; | ||
| } | ||
| })])); | ||
| }); | ||
| } | ||
| var sample = Wonka_operator_sample.sample; | ||
| function debounce(f) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| var gotEndSignal = /* record */[/* contents */false]; | ||
| var id = /* record */[/* contents */undefined]; | ||
| var $$clearTimeout$1 = function (param) { | ||
| var match = id[0]; | ||
| if (match !== undefined) { | ||
| id[0] = undefined; | ||
| clearTimeout(Caml_option.valFromOption(match)); | ||
| return /* () */0; | ||
| } else { | ||
| return /* () */0; | ||
| } | ||
| }; | ||
| return Curry._1(source, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| gotEndSignal[0] = true; | ||
| var match = id[0]; | ||
| if (match !== undefined) { | ||
| return /* () */0; | ||
| } else { | ||
| return sink(/* End */0); | ||
| } | ||
| } else if (signal.tag) { | ||
| $$clearTimeout$1(/* () */0); | ||
| id[0] = Caml_option.some(setTimeout((function (param) { | ||
| id[0] = undefined; | ||
| sink(signal); | ||
| if (gotEndSignal[0]) { | ||
| return sink(/* End */0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| }), f(signal[0]))); | ||
| return /* () */0; | ||
| } else { | ||
| var tb = signal[0]; | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (signal) { | ||
| $$clearTimeout$1(/* () */0); | ||
| return tb(/* Close */1); | ||
| } else { | ||
| return tb(signal); | ||
| } | ||
| })])); | ||
| } | ||
| })); | ||
| }); | ||
| }); | ||
| } | ||
| var throttle = Wonka_operator_throttle.throttle; | ||
| function throttle(f) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| var skip = /* record */[/* contents */false]; | ||
| var id = /* record */[/* contents */undefined]; | ||
| var $$clearTimeout$1 = function (param) { | ||
| var match = id[0]; | ||
| if (match !== undefined) { | ||
| clearTimeout(Caml_option.valFromOption(match)); | ||
| return /* () */0; | ||
| } else { | ||
| return /* () */0; | ||
| } | ||
| }; | ||
| return Curry._1(source, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| $$clearTimeout$1(/* () */0); | ||
| return sink(/* End */0); | ||
| } else if (signal.tag) { | ||
| if (skip[0]) { | ||
| return /* () */0; | ||
| } else { | ||
| skip[0] = true; | ||
| $$clearTimeout$1(/* () */0); | ||
| id[0] = Caml_option.some(setTimeout((function (param) { | ||
| id[0] = undefined; | ||
| skip[0] = false; | ||
| return /* () */0; | ||
| }), f(signal[0]))); | ||
| return sink(signal); | ||
| } | ||
| } else { | ||
| var tb = signal[0]; | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (signal) { | ||
| $$clearTimeout$1(/* () */0); | ||
| return tb(/* Close */1); | ||
| } else { | ||
| return tb(signal); | ||
| } | ||
| })])); | ||
| } | ||
| })); | ||
| }); | ||
| }); | ||
| } | ||
| var toPromise = Wonka_sink_toPromise.toPromise; | ||
| function sample(notifier) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| var state = /* record */[ | ||
| /* ended */false, | ||
| /* value */undefined, | ||
| /* sourceTalkback */(function (param) { | ||
| return /* () */0; | ||
| }), | ||
| /* notifierTalkback */(function (param) { | ||
| return /* () */0; | ||
| }) | ||
| ]; | ||
| Curry._1(source, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| state[/* ended */0] = true; | ||
| state[/* notifierTalkback */3](/* Close */1); | ||
| return sink(/* End */0); | ||
| } else if (signal.tag) { | ||
| state[/* value */1] = Caml_option.some(signal[0]); | ||
| return /* () */0; | ||
| } else { | ||
| state[/* sourceTalkback */2] = signal[0]; | ||
| return /* () */0; | ||
| } | ||
| })); | ||
| Curry._1(notifier, (function (signal) { | ||
| var match = state[/* value */1]; | ||
| if (typeof signal === "number") { | ||
| state[/* ended */0] = true; | ||
| state[/* sourceTalkback */2](/* Close */1); | ||
| return sink(/* End */0); | ||
| } else if (signal.tag) { | ||
| if (match !== undefined && !state[/* ended */0]) { | ||
| state[/* value */1] = undefined; | ||
| return sink(/* Push */Block.__(1, [Caml_option.valFromOption(match)])); | ||
| } else { | ||
| return /* () */0; | ||
| } | ||
| } else { | ||
| state[/* notifierTalkback */3] = signal[0]; | ||
| return /* () */0; | ||
| } | ||
| })); | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (signal) { | ||
| state[/* ended */0] = true; | ||
| state[/* sourceTalkback */2](/* Close */1); | ||
| return state[/* notifierTalkback */3](/* Close */1); | ||
| } else { | ||
| state[/* sourceTalkback */2](/* Pull */0); | ||
| return state[/* notifierTalkback */3](/* Pull */0); | ||
| } | ||
| })])); | ||
| }); | ||
| }); | ||
| } | ||
| var fromDomEvent = Wonka_source_fromDomEvent.fromDomEvent; | ||
| function delay(wait) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| var state = /* record */[ | ||
| /* talkback */Wonka_helpers.talkbackPlaceholder, | ||
| /* active */0, | ||
| /* gotEndSignal */false | ||
| ]; | ||
| Curry._1(source, (function (signal) { | ||
| var exit = 0; | ||
| if (typeof signal === "number" || signal.tag) { | ||
| exit = 1; | ||
| } else { | ||
| state[/* talkback */0] = signal[0]; | ||
| return /* () */0; | ||
| } | ||
| if (exit === 1) { | ||
| if (state[/* gotEndSignal */2]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* active */1] = state[/* active */1] + 1 | 0; | ||
| setTimeout((function (param) { | ||
| if (state[/* gotEndSignal */2] && state[/* active */1] === 0) { | ||
| sink(/* End */0); | ||
| } else { | ||
| state[/* active */1] = state[/* active */1] - 1 | 0; | ||
| } | ||
| return sink(signal); | ||
| }), wait); | ||
| return /* () */0; | ||
| } | ||
| } | ||
| })); | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (signal) { | ||
| state[/* gotEndSignal */2] = true; | ||
| if (state[/* active */1] === 0) { | ||
| return sink(/* End */0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else if (state[/* gotEndSignal */2]) { | ||
| return /* () */0; | ||
| } else { | ||
| return state[/* talkback */0](signal); | ||
| } | ||
| })])); | ||
| }); | ||
| }); | ||
| } | ||
| var fromListener = Wonka_source_fromListener.fromListener; | ||
| function toPromise(source) { | ||
| return new Promise((function (resolve, param) { | ||
| return Curry._1(Wonka.takeLast(1)(source), (function (signal) { | ||
| if (typeof signal === "number") { | ||
| return /* () */0; | ||
| } else if (signal.tag) { | ||
| return resolve(signal[0]); | ||
| } else { | ||
| return signal[0](/* Pull */0); | ||
| } | ||
| })); | ||
| })); | ||
| } | ||
| var fromPromise = Wonka_source_fromPromise.fromPromise; | ||
| exports.fromListener = fromListener; | ||
| exports.fromDomEvent = fromDomEvent; | ||
| exports.debounce = debounce; | ||
| exports.delay = delay; | ||
| exports.interval = interval; | ||
| exports.fromPromise = fromPromise; | ||
| exports.debounce = debounce; | ||
| exports.sample = sample; | ||
| exports.throttle = throttle; | ||
| exports.sample = sample; | ||
| exports.delay = delay; | ||
| exports.toPromise = toPromise; | ||
| exports.fromDomEvent = fromDomEvent; | ||
| exports.fromListener = fromListener; | ||
| exports.fromPromise = fromPromise; | ||
| /* No side effect */ |
| 'use strict'; | ||
| var Block = require("bs-platform/lib/js/block.js"); | ||
| var Curry = require("bs-platform/lib/js/curry.js"); | ||
| var Caml_option = require("bs-platform/lib/js/caml_option.js"); | ||
| var Wonka_helpers = require("./wonka_helpers.js"); | ||
| var MutableQueue_js = require("bs-rebel/lib/js/src/js/MutableQueue_js.js"); | ||
| var WonkaJs = require("./web/wonkaJs.js"); | ||
| var Wonka_source_make = require("./sources/wonka_source_make.js"); | ||
| var Wonka_operator_map = require("./operators/wonka_operator_map.js"); | ||
| var Wonka_operator_tap = require("./operators/wonka_operator_tap.js"); | ||
| var Wonka_sink_publish = require("./sinks/wonka_sink_publish.js"); | ||
| var Wonka_operator_scan = require("./operators/wonka_operator_scan.js"); | ||
| var Wonka_operator_skip = require("./operators/wonka_operator_skip.js"); | ||
| var Wonka_operator_take = require("./operators/wonka_operator_take.js"); | ||
| var Wonka_operator_share = require("./operators/wonka_operator_share.js"); | ||
| var Wonka_sink_subscribe = require("./sinks/wonka_sink_subscribe.js"); | ||
| var Wonka_operator_filter = require("./operators/wonka_operator_filter.js"); | ||
| var Wonka_source_fromList = require("./sources/wonka_source_fromList.js"); | ||
| var Wonka_operator_combine = require("./operators/wonka_operator_combine.js"); | ||
| var Wonka_source_fromArray = require("./sources/wonka_source_fromArray.js"); | ||
| var Wonka_source_fromValue = require("./sources/wonka_source_fromValue.js"); | ||
| var Wonka_operator_mergeMap = require("./operators/wonka_operator_mergeMap.js"); | ||
| var Wonka_operator_takeLast = require("./operators/wonka_operator_takeLast.js"); | ||
| var Wonka_source_primitives = require("./sources/wonka_source_primitives.js"); | ||
| var Wonka_operator_concatMap = require("./operators/wonka_operator_concatMap.js"); | ||
| var Wonka_operator_skipUntil = require("./operators/wonka_operator_skipUntil.js"); | ||
| var Wonka_operator_skipWhile = require("./operators/wonka_operator_skipWhile.js"); | ||
| var Wonka_operator_switchMap = require("./operators/wonka_operator_switchMap.js"); | ||
| var Wonka_operator_takeUntil = require("./operators/wonka_operator_takeUntil.js"); | ||
| var Wonka_operator_takeWhile = require("./operators/wonka_operator_takeWhile.js"); | ||
| var Wonka_source_makeSubject = require("./sources/wonka_source_makeSubject.js"); | ||
| function makeSubject(param) { | ||
| var state = /* record */[ | ||
| /* sinks */new Array(), | ||
| /* ended */false | ||
| ]; | ||
| var source = function (sink) { | ||
| state[/* sinks */0] = state[/* sinks */0].concat(sink); | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (signal === /* Close */1) { | ||
| state[/* sinks */0] = state[/* sinks */0].filter((function (x) { | ||
| return x !== sink; | ||
| })); | ||
| return /* () */0; | ||
| } else { | ||
| return 0; | ||
| } | ||
| })])); | ||
| }; | ||
| var next = function (value) { | ||
| if (state[/* ended */1]) { | ||
| return 0; | ||
| } else { | ||
| state[/* sinks */0].forEach((function (sink) { | ||
| return sink(/* Push */Block.__(1, [value])); | ||
| })); | ||
| return /* () */0; | ||
| } | ||
| }; | ||
| var complete = function (param) { | ||
| if (state[/* ended */1]) { | ||
| return 0; | ||
| } else { | ||
| state[/* ended */1] = true; | ||
| state[/* sinks */0].forEach((function (sink) { | ||
| return sink(/* End */0); | ||
| })); | ||
| return /* () */0; | ||
| } | ||
| }; | ||
| return /* record */[ | ||
| /* source */source, | ||
| /* next */next, | ||
| /* complete */complete | ||
| ]; | ||
| } | ||
| var Types = 0; | ||
| function make(f) { | ||
| return (function (sink) { | ||
| var teardown = f(/* record */[ | ||
| /* next */(function (value) { | ||
| return sink(/* Push */Block.__(1, [value])); | ||
| }), | ||
| /* complete */(function (param) { | ||
| return sink(/* End */0); | ||
| }) | ||
| ]); | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (signal) { | ||
| return teardown(); | ||
| } else { | ||
| return /* () */0; | ||
| } | ||
| })])); | ||
| }); | ||
| } | ||
| var fromArray = Wonka_source_fromArray.fromArray; | ||
| function fromList(ls) { | ||
| return (function (sink) { | ||
| var state = /* record */[ | ||
| /* value */ls, | ||
| /* ended */false, | ||
| /* looping */false, | ||
| /* pull */false | ||
| ]; | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| var match = state[/* looping */2]; | ||
| if (signal) { | ||
| state[/* ended */1] = true; | ||
| return /* () */0; | ||
| } else if (match) { | ||
| state[/* pull */3] = true; | ||
| return /* () */0; | ||
| } else { | ||
| state[/* pull */3] = true; | ||
| state[/* looping */2] = true; | ||
| while(state[/* pull */3] && !state[/* ended */1]) { | ||
| var match$1 = state[/* value */0]; | ||
| if (match$1) { | ||
| state[/* value */0] = match$1[1]; | ||
| state[/* pull */3] = false; | ||
| sink(/* Push */Block.__(1, [match$1[0]])); | ||
| } else { | ||
| state[/* ended */1] = true; | ||
| sink(/* End */0); | ||
| } | ||
| }; | ||
| state[/* looping */2] = false; | ||
| return /* () */0; | ||
| } | ||
| })])); | ||
| }); | ||
| } | ||
| var fromList = Wonka_source_fromList.fromList; | ||
| function fromArray(arr) { | ||
| return (function (sink) { | ||
| var size = arr.length; | ||
| var state = /* record */[ | ||
| /* index */0, | ||
| /* ended */false, | ||
| /* looping */false, | ||
| /* pull */false | ||
| ]; | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| var match = state[/* looping */2]; | ||
| if (signal) { | ||
| state[/* ended */1] = true; | ||
| return /* () */0; | ||
| } else if (match) { | ||
| state[/* pull */3] = true; | ||
| return /* () */0; | ||
| } else { | ||
| state[/* pull */3] = true; | ||
| state[/* looping */2] = true; | ||
| while(state[/* pull */3] && !state[/* ended */1]) { | ||
| var index = state[/* index */0]; | ||
| if (index < size) { | ||
| var x = arr[index]; | ||
| state[/* index */0] = index + 1 | 0; | ||
| state[/* pull */3] = false; | ||
| sink(/* Push */Block.__(1, [x])); | ||
| } else { | ||
| state[/* ended */1] = true; | ||
| sink(/* End */0); | ||
| } | ||
| }; | ||
| state[/* looping */2] = false; | ||
| return /* () */0; | ||
| } | ||
| })])); | ||
| }); | ||
| } | ||
| var fromValue = Wonka_source_fromValue.fromValue; | ||
| function fromValue(x) { | ||
| return (function (sink) { | ||
| var ended = /* record */[/* contents */false]; | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (signal || ended[0]) { | ||
| return /* () */0; | ||
| } else { | ||
| ended[0] = true; | ||
| sink(/* Push */Block.__(1, [x])); | ||
| return sink(/* End */0); | ||
| } | ||
| })])); | ||
| }); | ||
| } | ||
| var make = Wonka_source_make.make; | ||
| function empty(sink) { | ||
| sink(/* Start */Block.__(0, [Wonka_helpers.talkbackPlaceholder])); | ||
| return sink(/* End */0); | ||
| } | ||
| var makeSubject = Wonka_source_makeSubject.makeSubject; | ||
| function never(sink) { | ||
| return sink(/* Start */Block.__(0, [Wonka_helpers.talkbackPlaceholder])); | ||
| } | ||
| var empty = Wonka_source_primitives.empty; | ||
| function tap(f) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| return Curry._1(source, (function (signal) { | ||
| if (typeof signal !== "number") { | ||
| if (signal.tag) { | ||
| f(signal[0]); | ||
| } | ||
| } | ||
| return sink(signal); | ||
| })); | ||
| }); | ||
| }); | ||
| } | ||
| var never = Wonka_source_primitives.never; | ||
| function map(f) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| return Curry._1(source, (function (signal) { | ||
| var tmp; | ||
| tmp = typeof signal === "number" ? /* End */0 : ( | ||
| signal.tag ? /* Push */Block.__(1, [f(signal[0])]) : /* Start */Block.__(0, [signal[0]]) | ||
| ); | ||
| return sink(tmp); | ||
| })); | ||
| }); | ||
| }); | ||
| } | ||
| var combine = Wonka_operator_combine.combine; | ||
| function filter(f) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| return Wonka_helpers.captureTalkback(source, (function (signal, talkback) { | ||
| if (typeof signal === "number" || !(signal.tag && !f(signal[0]))) { | ||
| return sink(signal); | ||
| } else { | ||
| return talkback(/* Pull */0); | ||
| } | ||
| })); | ||
| }); | ||
| }); | ||
| } | ||
| var concatMap = Wonka_operator_concatMap.concatMap; | ||
| function scan(f, seed) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| var acc = /* record */[/* contents */seed]; | ||
| return Curry._1(source, (function (signal) { | ||
| var tmp; | ||
| if (typeof signal === "number") { | ||
| tmp = /* End */0; | ||
| } else if (signal.tag) { | ||
| acc[0] = Curry._2(f, acc[0], signal[0]); | ||
| tmp = /* Push */Block.__(1, [acc[0]]); | ||
| } else { | ||
| tmp = /* Start */Block.__(0, [signal[0]]); | ||
| } | ||
| return sink(tmp); | ||
| })); | ||
| }); | ||
| }); | ||
| } | ||
| var concat = Wonka_operator_concatMap.concat; | ||
| function mergeMap(f) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| var state = /* record */[ | ||
| /* outerTalkback */Wonka_helpers.talkbackPlaceholder, | ||
| /* innerTalkbacks */new Array(), | ||
| /* ended */false | ||
| ]; | ||
| var applyInnerSource = function (innerSource) { | ||
| var talkback = /* record */[/* contents */Wonka_helpers.talkbackPlaceholder]; | ||
| return Curry._1(innerSource, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| state[/* innerTalkbacks */1] = state[/* innerTalkbacks */1].filter((function (x) { | ||
| return x !== talkback[0]; | ||
| })); | ||
| if (state[/* ended */2] && state[/* innerTalkbacks */1].length === 0) { | ||
| return sink(/* End */0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else if (signal.tag) { | ||
| if (state[/* innerTalkbacks */1].length !== 0) { | ||
| sink(/* Push */Block.__(1, [signal[0]])); | ||
| return talkback[0](/* Pull */0); | ||
| } else { | ||
| return /* () */0; | ||
| } | ||
| } else { | ||
| var tb = signal[0]; | ||
| talkback[0] = tb; | ||
| state[/* innerTalkbacks */1] = state[/* innerTalkbacks */1].concat(tb); | ||
| return tb(/* Pull */0); | ||
| } | ||
| })); | ||
| }; | ||
| Curry._1(source, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| if (state[/* ended */2]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* ended */2] = true; | ||
| if (state[/* innerTalkbacks */1].length === 0) { | ||
| return sink(/* End */0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| } else if (signal.tag) { | ||
| if (state[/* ended */2]) { | ||
| return /* () */0; | ||
| } else { | ||
| applyInnerSource(f(signal[0])); | ||
| return state[/* outerTalkback */0](/* Pull */0); | ||
| } | ||
| } else { | ||
| var tb = signal[0]; | ||
| state[/* outerTalkback */0] = tb; | ||
| return tb(/* Pull */0); | ||
| } | ||
| })); | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (signal) { | ||
| if (state[/* ended */2]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* ended */2] = true; | ||
| state[/* outerTalkback */0](/* Close */1); | ||
| state[/* innerTalkbacks */1].forEach((function (talkback) { | ||
| return talkback(/* Close */1); | ||
| })); | ||
| state[/* innerTalkbacks */1] = new Array(); | ||
| return /* () */0; | ||
| } | ||
| } else if (state[/* ended */2]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* innerTalkbacks */1].forEach((function (talkback) { | ||
| return talkback(/* Pull */0); | ||
| })); | ||
| return /* () */0; | ||
| } | ||
| })])); | ||
| }); | ||
| }); | ||
| } | ||
| var concatAll = Wonka_operator_concatMap.concatAll; | ||
| function merge(sources) { | ||
| return mergeMap((function (x) { | ||
| return x; | ||
| }))(fromArray(sources)); | ||
| } | ||
| var filter = Wonka_operator_filter.filter; | ||
| function mergeAll(source) { | ||
| return mergeMap((function (x) { | ||
| return x; | ||
| }))(source); | ||
| } | ||
| var map = Wonka_operator_map.map; | ||
| function concatMap(f) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| var state = /* record */[ | ||
| /* inputQueue */new Array(), | ||
| /* outerTalkback */Wonka_helpers.talkbackPlaceholder, | ||
| /* innerTalkback */Wonka_helpers.talkbackPlaceholder, | ||
| /* innerActive */false, | ||
| /* closed */false, | ||
| /* ended */false | ||
| ]; | ||
| var applyInnerSource = function (innerSource) { | ||
| return Curry._1(innerSource, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| state[/* innerActive */3] = false; | ||
| state[/* innerTalkback */2] = Wonka_helpers.talkbackPlaceholder; | ||
| var match = state[/* inputQueue */0].shift(); | ||
| if (match !== undefined) { | ||
| return applyInnerSource(f(Caml_option.valFromOption(match))); | ||
| } else if (state[/* ended */5]) { | ||
| return sink(/* End */0); | ||
| } else { | ||
| return /* () */0; | ||
| } | ||
| } else if (signal.tag) { | ||
| if (state[/* closed */4]) { | ||
| return /* () */0; | ||
| } else { | ||
| sink(/* Push */Block.__(1, [signal[0]])); | ||
| return state[/* innerTalkback */2](/* Pull */0); | ||
| } | ||
| } else { | ||
| var tb = signal[0]; | ||
| state[/* innerActive */3] = true; | ||
| state[/* innerTalkback */2] = tb; | ||
| return tb(/* Pull */0); | ||
| } | ||
| })); | ||
| }; | ||
| Curry._1(source, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| if (state[/* ended */5]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* ended */5] = true; | ||
| if (!state[/* innerActive */3] && MutableQueue_js.isEmpty(state[/* inputQueue */0])) { | ||
| return sink(/* End */0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| } else if (signal.tag) { | ||
| if (state[/* ended */5]) { | ||
| return /* () */0; | ||
| } else { | ||
| var x = signal[0]; | ||
| if (state[/* innerActive */3]) { | ||
| state[/* inputQueue */0].push(x); | ||
| } else { | ||
| applyInnerSource(f(x)); | ||
| } | ||
| return state[/* outerTalkback */1](/* Pull */0); | ||
| } | ||
| } else { | ||
| var tb = signal[0]; | ||
| state[/* outerTalkback */1] = tb; | ||
| return tb(/* Pull */0); | ||
| } | ||
| })); | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (signal) { | ||
| if (state[/* ended */5]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* ended */5] = true; | ||
| state[/* closed */4] = true; | ||
| state[/* outerTalkback */1](/* Close */1); | ||
| return state[/* innerTalkback */2](/* Close */1); | ||
| } | ||
| } else if (state[/* ended */5]) { | ||
| return 0; | ||
| } else { | ||
| return state[/* innerTalkback */2](/* Pull */0); | ||
| } | ||
| })])); | ||
| }); | ||
| }); | ||
| } | ||
| var mergeMap = Wonka_operator_mergeMap.mergeMap; | ||
| function concatAll(source) { | ||
| return concatMap((function (x) { | ||
| return x; | ||
| }))(source); | ||
| } | ||
| var merge = Wonka_operator_mergeMap.merge; | ||
| function concat(sources) { | ||
| return concatMap((function (x) { | ||
| return x; | ||
| }))(fromArray(sources)); | ||
| } | ||
| var mergeAll = Wonka_operator_mergeMap.mergeAll; | ||
| function switchMap(f) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| var state = /* record */[ | ||
| /* outerTalkback */Wonka_helpers.talkbackPlaceholder, | ||
| /* innerTalkback */Wonka_helpers.talkbackPlaceholder, | ||
| /* innerActive */false, | ||
| /* closed */false, | ||
| /* ended */false | ||
| ]; | ||
| var applyInnerSource = function (innerSource) { | ||
| return Curry._1(innerSource, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| state[/* innerActive */2] = false; | ||
| state[/* innerTalkback */1] = Wonka_helpers.talkbackPlaceholder; | ||
| if (state[/* ended */4]) { | ||
| return sink(/* End */0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else if (signal.tag) { | ||
| if (state[/* closed */3]) { | ||
| return /* () */0; | ||
| } else { | ||
| sink(/* Push */Block.__(1, [signal[0]])); | ||
| return state[/* innerTalkback */1](/* Pull */0); | ||
| } | ||
| } else { | ||
| var tb = signal[0]; | ||
| state[/* innerActive */2] = true; | ||
| state[/* innerTalkback */1] = tb; | ||
| return tb(/* Pull */0); | ||
| } | ||
| })); | ||
| }; | ||
| Curry._1(source, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| if (state[/* ended */4]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* ended */4] = true; | ||
| if (state[/* innerActive */2]) { | ||
| return 0; | ||
| } else { | ||
| return sink(/* End */0); | ||
| } | ||
| } | ||
| } else if (signal.tag) { | ||
| if (state[/* ended */4]) { | ||
| return /* () */0; | ||
| } else { | ||
| if (state[/* innerActive */2]) { | ||
| state[/* innerTalkback */1](/* Close */1); | ||
| state[/* innerTalkback */1] = Wonka_helpers.talkbackPlaceholder; | ||
| } | ||
| applyInnerSource(f(signal[0])); | ||
| return state[/* outerTalkback */0](/* Pull */0); | ||
| } | ||
| } else { | ||
| var tb = signal[0]; | ||
| state[/* outerTalkback */0] = tb; | ||
| return tb(/* Pull */0); | ||
| } | ||
| })); | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (signal) { | ||
| if (state[/* ended */4]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* ended */4] = true; | ||
| state[/* closed */3] = true; | ||
| state[/* outerTalkback */0](/* Close */1); | ||
| state[/* innerTalkback */1](/* Close */1); | ||
| state[/* innerTalkback */1] = Wonka_helpers.talkbackPlaceholder; | ||
| return /* () */0; | ||
| } | ||
| } else { | ||
| return state[/* innerTalkback */1](/* Pull */0); | ||
| } | ||
| })])); | ||
| }); | ||
| }); | ||
| } | ||
| var flatten = Wonka_operator_mergeMap.flatten; | ||
| function share(source) { | ||
| var state = /* record */[ | ||
| /* sinks */new Array(), | ||
| /* talkback */Wonka_helpers.talkbackPlaceholder, | ||
| /* gotSignal */false | ||
| ]; | ||
| return (function (sink) { | ||
| state[/* sinks */0] = state[/* sinks */0].concat(sink); | ||
| if (state[/* sinks */0].length === 1) { | ||
| Curry._1(source, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| state[/* sinks */0].forEach((function (sink) { | ||
| return sink(/* End */0); | ||
| })); | ||
| state[/* sinks */0] = new Array(); | ||
| return /* () */0; | ||
| } else if (signal.tag) { | ||
| state[/* gotSignal */2] = false; | ||
| state[/* sinks */0].forEach((function (sink) { | ||
| return sink(signal); | ||
| })); | ||
| return /* () */0; | ||
| } else { | ||
| state[/* talkback */1] = signal[0]; | ||
| return /* () */0; | ||
| } | ||
| })); | ||
| } | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (signal) { | ||
| state[/* sinks */0] = state[/* sinks */0].filter((function (x) { | ||
| return x !== sink; | ||
| })); | ||
| if (state[/* sinks */0].length === 0) { | ||
| return state[/* talkback */1](/* Close */1); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else if (state[/* gotSignal */2]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* gotSignal */2] = true; | ||
| return state[/* talkback */1](signal); | ||
| } | ||
| })])); | ||
| }); | ||
| } | ||
| var scan = Wonka_operator_scan.scan; | ||
| function combine(sourceA, sourceB) { | ||
| return (function (sink) { | ||
| var state = /* record */[ | ||
| /* talkbackA */Wonka_helpers.talkbackPlaceholder, | ||
| /* talkbackB */Wonka_helpers.talkbackPlaceholder, | ||
| /* lastValA */undefined, | ||
| /* lastValB */undefined, | ||
| /* gotSignal */false, | ||
| /* endCounter */0, | ||
| /* ended */false | ||
| ]; | ||
| Curry._1(sourceA, (function (signal) { | ||
| var match = state[/* lastValB */3]; | ||
| if (typeof signal === "number") { | ||
| if (state[/* endCounter */5] < 1) { | ||
| state[/* endCounter */5] = state[/* endCounter */5] + 1 | 0; | ||
| return /* () */0; | ||
| } else if (state[/* ended */6]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* ended */6] = true; | ||
| return sink(/* End */0); | ||
| } | ||
| } else if (signal.tag) { | ||
| var a = signal[0]; | ||
| if (match !== undefined) { | ||
| if (state[/* ended */6]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* lastValA */2] = Caml_option.some(a); | ||
| state[/* gotSignal */4] = false; | ||
| return sink(/* Push */Block.__(1, [/* tuple */[ | ||
| a, | ||
| Caml_option.valFromOption(match) | ||
| ]])); | ||
| } | ||
| } else { | ||
| state[/* lastValA */2] = Caml_option.some(a); | ||
| state[/* gotSignal */4] = false; | ||
| return /* () */0; | ||
| } | ||
| } else { | ||
| state[/* talkbackA */0] = signal[0]; | ||
| return /* () */0; | ||
| } | ||
| })); | ||
| Curry._1(sourceB, (function (signal) { | ||
| var match = state[/* lastValA */2]; | ||
| if (typeof signal === "number") { | ||
| if (state[/* endCounter */5] < 1) { | ||
| state[/* endCounter */5] = state[/* endCounter */5] + 1 | 0; | ||
| return /* () */0; | ||
| } else if (state[/* ended */6]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* ended */6] = true; | ||
| return sink(/* End */0); | ||
| } | ||
| } else if (signal.tag) { | ||
| var b = signal[0]; | ||
| if (match !== undefined) { | ||
| if (state[/* ended */6]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* lastValB */3] = Caml_option.some(b); | ||
| state[/* gotSignal */4] = false; | ||
| return sink(/* Push */Block.__(1, [/* tuple */[ | ||
| Caml_option.valFromOption(match), | ||
| b | ||
| ]])); | ||
| } | ||
| } else { | ||
| state[/* lastValB */3] = Caml_option.some(b); | ||
| state[/* gotSignal */4] = false; | ||
| return /* () */0; | ||
| } | ||
| } else { | ||
| state[/* talkbackB */1] = signal[0]; | ||
| return /* () */0; | ||
| } | ||
| })); | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (state[/* ended */6]) { | ||
| return 0; | ||
| } else if (signal) { | ||
| state[/* ended */6] = true; | ||
| state[/* talkbackA */0](/* Close */1); | ||
| return state[/* talkbackB */1](/* Close */1); | ||
| } else if (state[/* gotSignal */4]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* gotSignal */4] = true; | ||
| state[/* talkbackA */0](signal); | ||
| return state[/* talkbackB */1](signal); | ||
| } | ||
| })])); | ||
| }); | ||
| } | ||
| var share = Wonka_operator_share.share; | ||
| function take(max) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| var state = /* record */[ | ||
| /* taken */0, | ||
| /* talkback */Wonka_helpers.talkbackPlaceholder | ||
| ]; | ||
| Curry._1(source, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| if (state[/* taken */0] < max) { | ||
| state[/* taken */0] = max; | ||
| return sink(/* End */0); | ||
| } else { | ||
| return /* () */0; | ||
| } | ||
| } else if (signal.tag) { | ||
| if (state[/* taken */0] < max) { | ||
| state[/* taken */0] = state[/* taken */0] + 1 | 0; | ||
| sink(signal); | ||
| if (state[/* taken */0] === max) { | ||
| sink(/* End */0); | ||
| return state[/* talkback */1](/* Close */1); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else { | ||
| return /* () */0; | ||
| } | ||
| } else { | ||
| state[/* talkback */1] = signal[0]; | ||
| return /* () */0; | ||
| } | ||
| })); | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (state[/* taken */0] < max) { | ||
| if (signal) { | ||
| state[/* taken */0] = max; | ||
| return state[/* talkback */1](/* Close */1); | ||
| } else { | ||
| return state[/* talkback */1](/* Pull */0); | ||
| } | ||
| } else { | ||
| return 0; | ||
| } | ||
| })])); | ||
| }); | ||
| }); | ||
| } | ||
| var skip = Wonka_operator_skip.skip; | ||
| function takeLast(max) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| var queue = new Array(); | ||
| return Wonka_helpers.captureTalkback(source, (function (signal, talkback) { | ||
| if (typeof signal === "number") { | ||
| return Wonka_helpers.makeTrampoline(sink, (function () { | ||
| return queue.shift(); | ||
| })); | ||
| } else if (signal.tag) { | ||
| var size = queue.length; | ||
| if (size >= max && max > 0) { | ||
| queue.shift(); | ||
| } | ||
| queue.push(signal[0]); | ||
| return talkback(/* Pull */0); | ||
| } else { | ||
| return talkback(/* Pull */0); | ||
| } | ||
| })); | ||
| }); | ||
| }); | ||
| } | ||
| var skipUntil = Wonka_operator_skipUntil.skipUntil; | ||
| function takeWhile(f) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| var ended = /* record */[/* contents */false]; | ||
| var talkback = /* record */[/* contents */Wonka_helpers.talkbackPlaceholder]; | ||
| Curry._1(source, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| if (ended[0]) { | ||
| return /* () */0; | ||
| } else { | ||
| ended[0] = true; | ||
| return sink(/* End */0); | ||
| } | ||
| } else if (signal.tag) { | ||
| if (ended[0]) { | ||
| return /* () */0; | ||
| } else if (f(signal[0])) { | ||
| return sink(signal); | ||
| } else { | ||
| ended[0] = true; | ||
| sink(/* End */0); | ||
| return talkback[0](/* Close */1); | ||
| } | ||
| } else { | ||
| talkback[0] = signal[0]; | ||
| return sink(signal); | ||
| } | ||
| })); | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (ended[0]) { | ||
| return 0; | ||
| } else if (signal) { | ||
| ended[0] = true; | ||
| return talkback[0](/* Close */1); | ||
| } else { | ||
| return talkback[0](/* Pull */0); | ||
| } | ||
| })])); | ||
| }); | ||
| }); | ||
| } | ||
| var skipWhile = Wonka_operator_skipWhile.skipWhile; | ||
| function takeUntil(notifier) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| var state = /* record */[ | ||
| /* ended */false, | ||
| /* sourceTalkback */Wonka_helpers.talkbackPlaceholder, | ||
| /* notifierTalkback */Wonka_helpers.talkbackPlaceholder | ||
| ]; | ||
| Curry._1(source, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| if (state[/* ended */0]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* notifierTalkback */2](/* Close */1); | ||
| state[/* ended */0] = true; | ||
| return sink(/* End */0); | ||
| } | ||
| } else if (signal.tag) { | ||
| if (state[/* ended */0]) { | ||
| return /* () */0; | ||
| } else { | ||
| return sink(signal); | ||
| } | ||
| } else { | ||
| state[/* sourceTalkback */1] = signal[0]; | ||
| return Curry._1(notifier, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| return /* () */0; | ||
| } else if (signal.tag) { | ||
| state[/* ended */0] = true; | ||
| state[/* notifierTalkback */2](/* Close */1); | ||
| state[/* sourceTalkback */1](/* Close */1); | ||
| return sink(/* End */0); | ||
| } else { | ||
| var innerTb = signal[0]; | ||
| state[/* notifierTalkback */2] = innerTb; | ||
| return innerTb(/* Pull */0); | ||
| } | ||
| })); | ||
| } | ||
| })); | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (state[/* ended */0]) { | ||
| return 0; | ||
| } else if (signal) { | ||
| state[/* sourceTalkback */1](/* Close */1); | ||
| return state[/* notifierTalkback */2](/* Close */1); | ||
| } else { | ||
| return state[/* sourceTalkback */1](/* Pull */0); | ||
| } | ||
| })])); | ||
| }); | ||
| }); | ||
| } | ||
| var switchMap = Wonka_operator_switchMap.switchMap; | ||
| function skip(wait) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| var rest = /* record */[/* contents */wait]; | ||
| return Wonka_helpers.captureTalkback(source, (function (signal, talkback) { | ||
| if (typeof signal === "number" || !(signal.tag && rest[0] > 0)) { | ||
| return sink(signal); | ||
| } else { | ||
| rest[0] = rest[0] - 1 | 0; | ||
| return talkback(/* Pull */0); | ||
| } | ||
| })); | ||
| }); | ||
| }); | ||
| } | ||
| var take = Wonka_operator_take.take; | ||
| function skipWhile(f) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| var skip = /* record */[/* contents */true]; | ||
| return Wonka_helpers.captureTalkback(source, (function (signal, talkback) { | ||
| if (typeof signal === "number" || !(signal.tag && skip[0])) { | ||
| return sink(signal); | ||
| } else if (f(signal[0])) { | ||
| return talkback(/* Pull */0); | ||
| } else { | ||
| skip[0] = false; | ||
| return sink(signal); | ||
| } | ||
| })); | ||
| }); | ||
| }); | ||
| } | ||
| var takeLast = Wonka_operator_takeLast.takeLast; | ||
| function skipUntil(notifier) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| var state = /* record */[ | ||
| /* skip */true, | ||
| /* ended */false, | ||
| /* gotSignal */false, | ||
| /* sourceTalkback */Wonka_helpers.talkbackPlaceholder, | ||
| /* notifierTalkback */Wonka_helpers.talkbackPlaceholder | ||
| ]; | ||
| Curry._1(source, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| if (state[/* skip */0]) { | ||
| state[/* notifierTalkback */4](/* Close */1); | ||
| } | ||
| state[/* ended */1] = true; | ||
| return sink(/* End */0); | ||
| } else if (signal.tag) { | ||
| if (state[/* skip */0] && !state[/* ended */1]) { | ||
| return state[/* sourceTalkback */3](/* Pull */0); | ||
| } else if (state[/* ended */1]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* gotSignal */2] = false; | ||
| return sink(signal); | ||
| } | ||
| } else { | ||
| var tb = signal[0]; | ||
| state[/* sourceTalkback */3] = tb; | ||
| return Curry._1(notifier, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| return /* () */0; | ||
| } else if (signal.tag) { | ||
| state[/* skip */0] = false; | ||
| return state[/* notifierTalkback */4](/* Close */1); | ||
| } else { | ||
| var innerTb = signal[0]; | ||
| state[/* notifierTalkback */4] = innerTb; | ||
| innerTb(/* Pull */0); | ||
| return tb(/* Pull */0); | ||
| } | ||
| })); | ||
| } | ||
| })); | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (signal) { | ||
| if (state[/* skip */0]) { | ||
| state[/* notifierTalkback */4](/* Close */1); | ||
| } | ||
| state[/* ended */1] = true; | ||
| return state[/* sourceTalkback */3](/* Close */1); | ||
| } else if (!state[/* gotSignal */2] && !state[/* ended */1]) { | ||
| state[/* gotSignal */2] = true; | ||
| return state[/* sourceTalkback */3](/* Pull */0); | ||
| } else { | ||
| return /* () */0; | ||
| } | ||
| })])); | ||
| }); | ||
| }); | ||
| } | ||
| var takeUntil = Wonka_operator_takeUntil.takeUntil; | ||
| function publish(source) { | ||
| var state = /* record */[ | ||
| /* talkback */Wonka_helpers.talkbackPlaceholder, | ||
| /* ended */false | ||
| ]; | ||
| Curry._1(source, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| state[/* ended */1] = true; | ||
| return /* () */0; | ||
| } else if (signal.tag) { | ||
| if (state[/* ended */1]) { | ||
| return 0; | ||
| } else { | ||
| return state[/* talkback */0](/* Pull */0); | ||
| } | ||
| } else { | ||
| var x = signal[0]; | ||
| state[/* talkback */0] = x; | ||
| return x(/* Pull */0); | ||
| } | ||
| })); | ||
| return /* record */[/* unsubscribe */(function (param) { | ||
| if (state[/* ended */1]) { | ||
| return 0; | ||
| } else { | ||
| state[/* ended */1] = true; | ||
| return state[/* talkback */0](/* Close */1); | ||
| } | ||
| })]; | ||
| } | ||
| var takeWhile = Wonka_operator_takeWhile.takeWhile; | ||
| function subscribe(f) { | ||
| return (function (source) { | ||
| var state = /* record */[ | ||
| /* talkback */Wonka_helpers.talkbackPlaceholder, | ||
| /* ended */false | ||
| ]; | ||
| Curry._1(source, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| state[/* ended */1] = true; | ||
| return /* () */0; | ||
| } else if (signal.tag) { | ||
| if (state[/* ended */1]) { | ||
| return /* () */0; | ||
| } else { | ||
| f(signal[0]); | ||
| return state[/* talkback */0](/* Pull */0); | ||
| } | ||
| } else { | ||
| var x = signal[0]; | ||
| state[/* talkback */0] = x; | ||
| return x(/* Pull */0); | ||
| } | ||
| })); | ||
| return /* record */[/* unsubscribe */(function (param) { | ||
| if (state[/* ended */1]) { | ||
| return 0; | ||
| } else { | ||
| state[/* ended */1] = true; | ||
| return state[/* talkback */0](/* Close */1); | ||
| } | ||
| })]; | ||
| }); | ||
| } | ||
| var tap = Wonka_operator_tap.tap; | ||
| function forEach(f) { | ||
| return (function (source) { | ||
| subscribe(f)(source); | ||
| return /* () */0; | ||
| }); | ||
| } | ||
| var publish = Wonka_sink_publish.publish; | ||
| var Types = 0; | ||
| var subscribe = Wonka_sink_subscribe.subscribe; | ||
| var flatten = mergeAll; | ||
| var forEach = Wonka_sink_subscribe.forEach; | ||
| var debounce = WonkaJs.debounce; | ||
| var delay = WonkaJs.delay; | ||
| var interval = WonkaJs.interval; | ||
| var sample = WonkaJs.sample; | ||
| var throttle = WonkaJs.throttle; | ||
| var toPromise = WonkaJs.toPromise; | ||
| var fromDomEvent = WonkaJs.fromDomEvent; | ||
| var fromListener = WonkaJs.fromListener; | ||
| var fromPromise = WonkaJs.fromPromise; | ||
| exports.Types = Types; | ||
| exports.makeSubject = makeSubject; | ||
| exports.make = make; | ||
| exports.fromArray = fromArray; | ||
| exports.fromList = fromList; | ||
| exports.fromArray = fromArray; | ||
| exports.fromValue = fromValue; | ||
| exports.make = make; | ||
| exports.makeSubject = makeSubject; | ||
| exports.empty = empty; | ||
| exports.never = never; | ||
| exports.tap = tap; | ||
| exports.combine = combine; | ||
| exports.concatMap = concatMap; | ||
| exports.concat = concat; | ||
| exports.concatAll = concatAll; | ||
| exports.filter = filter; | ||
| exports.map = map; | ||
| exports.filter = filter; | ||
| exports.scan = scan; | ||
| exports.mergeMap = mergeMap; | ||
| exports.switchMap = switchMap; | ||
| exports.concatMap = concatMap; | ||
| exports.merge = merge; | ||
| exports.concat = concat; | ||
| exports.mergeAll = mergeAll; | ||
| exports.flatten = flatten; | ||
| exports.concatAll = concatAll; | ||
| exports.scan = scan; | ||
| exports.share = share; | ||
| exports.combine = combine; | ||
| exports.skip = skip; | ||
| exports.skipUntil = skipUntil; | ||
| exports.skipWhile = skipWhile; | ||
| exports.switchMap = switchMap; | ||
| exports.take = take; | ||
| exports.takeLast = takeLast; | ||
| exports.takeUntil = takeUntil; | ||
| exports.takeWhile = takeWhile; | ||
| exports.takeUntil = takeUntil; | ||
| exports.skip = skip; | ||
| exports.skipWhile = skipWhile; | ||
| exports.skipUntil = skipUntil; | ||
| exports.tap = tap; | ||
| exports.publish = publish; | ||
| exports.subscribe = subscribe; | ||
| exports.forEach = forEach; | ||
| exports.subscribe = subscribe; | ||
| exports.debounce = debounce; | ||
| exports.delay = delay; | ||
| exports.interval = interval; | ||
| exports.sample = sample; | ||
| exports.throttle = throttle; | ||
| exports.toPromise = toPromise; | ||
| exports.fromDomEvent = fromDomEvent; | ||
| exports.fromListener = fromListener; | ||
| exports.fromPromise = fromPromise; | ||
| /* No side effect */ |
| { | ||
| "name": "wonka", | ||
| "version": "1.4.0", | ||
| "version": "1.4.1", | ||
| "author": "Phil Pluckthun <phil@kitten.sh>", | ||
@@ -5,0 +5,0 @@ "source": "./src/index.js", |
@@ -1,5 +0,4 @@ | ||
| export { Talkback, Signal, Sink, Subscription, Source, Operator, Observer, Subject } from './wonka_types'; | ||
| export * from './pipe'; | ||
| export * from './wonka_types'; | ||
| export * from './wonka'; | ||
| export * from './web/wonkaJs'; |
| export * from './pipe'; | ||
| export * from './wonka'; | ||
| export * from './web/wonkaJs'; |
@@ -1,17 +0,14 @@ | ||
| import { Sink, Source, Operator } from '../wonka_types'; | ||
| /* operators */ | ||
| export * from './wonka_operator_debounce'; | ||
| export * from './wonka_operator_delay'; | ||
| export * from './wonka_operator_interval'; | ||
| export * from './wonka_operator_sample'; | ||
| export * from './wonka_operator_throttle'; | ||
| export const fromListener: <E>( | ||
| addListener: (cb: (event: E) => void) => void, | ||
| removeListener: (cb: (event: E) => void) => void | ||
| ) => Source<E>; | ||
| /* sinks */ | ||
| export * from './wonka_sink_toPromise'; | ||
| export const fromDomEvent: <E>(HTMLElement, string) => Source<E>; | ||
| export const interval: (interval: number) => Source<number>; | ||
| export const fromPromise: <A>(promise: Promise<A>) => Source<A>; | ||
| export const debounce: <A>(f: (x: A) => number) => Operator<A, A>; | ||
| export const throttle: <A>(f: (x: A) => number) => Operator<A, A>; | ||
| export const sample: <A>(signal: Source<any>) => Operator<A, A>; | ||
| export const delay: <A>(duration: number) => Operator<A, A>; | ||
| export const toPromise: <A>(source: Source<A>) => Promise<A>; | ||
| /* sources */ | ||
| export * from './wonka_source_fromDomEvent'; | ||
| export * from './wonka_source_fromListener'; | ||
| export * from './wonka_source_fromPromise'; |
| import * as Block from "bs-platform/lib/es6/block.js"; | ||
| import * as Curry from "bs-platform/lib/es6/curry.js"; | ||
| import * as Wonka from "../wonka.js"; | ||
| import * as Caml_option from "bs-platform/lib/es6/caml_option.js"; | ||
| import * as Wonka_helpers from "../wonka_helpers.js"; | ||
| import * as Wonka_operator_delay from "./wonka_operator_delay.js"; | ||
| import * as Wonka_sink_toPromise from "./wonka_sink_toPromise.js"; | ||
| import * as Wonka_operator_sample from "./wonka_operator_sample.js"; | ||
| import * as Wonka_operator_debounce from "./wonka_operator_debounce.js"; | ||
| import * as Wonka_operator_interval from "./wonka_operator_interval.js"; | ||
| import * as Wonka_operator_throttle from "./wonka_operator_throttle.js"; | ||
| import * as Wonka_source_fromPromise from "./wonka_source_fromPromise.js"; | ||
| import * as Wonka_source_fromDomEvent from "./wonka_source_fromDomEvent.js"; | ||
| import * as Wonka_source_fromListener from "./wonka_source_fromListener.js"; | ||
| function fromListener(addListener, removeListener) { | ||
| return (function (sink) { | ||
| var handler = function ($$event) { | ||
| return sink(/* Push */Block.__(1, [$$event])); | ||
| }; | ||
| sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (signal) { | ||
| return Curry._1(removeListener, handler); | ||
| } else { | ||
| return /* () */0; | ||
| } | ||
| })])); | ||
| return Curry._1(addListener, handler); | ||
| }); | ||
| } | ||
| var debounce = Wonka_operator_debounce.debounce; | ||
| function fromDomEvent(element, $$event) { | ||
| return (function (sink) { | ||
| var addEventListener = ( | ||
| function (element, event, handler) { | ||
| element.addEventListener(event, handler); | ||
| } | ||
| ); | ||
| var removeEventListener = ( | ||
| function (element, event, handler) { | ||
| element.removeEventListener(event, handler); | ||
| } | ||
| ); | ||
| return fromListener((function (handler) { | ||
| return Curry._3(addEventListener, element, $$event, handler); | ||
| }), (function (handler) { | ||
| return Curry._3(removeEventListener, element, $$event, handler); | ||
| }))(sink); | ||
| }); | ||
| } | ||
| var delay = Wonka_operator_delay.delay; | ||
| function interval(p) { | ||
| return (function (sink) { | ||
| var i = /* record */[/* contents */0]; | ||
| var id = setInterval((function (param) { | ||
| var num = i[0]; | ||
| i[0] = i[0] + 1 | 0; | ||
| return sink(/* Push */Block.__(1, [num])); | ||
| }), p); | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (signal) { | ||
| clearInterval(id); | ||
| return /* () */0; | ||
| } else { | ||
| return /* () */0; | ||
| } | ||
| })])); | ||
| }); | ||
| } | ||
| var interval = Wonka_operator_interval.interval; | ||
| function fromPromise(promise) { | ||
| return (function (sink) { | ||
| var ended = /* record */[/* contents */false]; | ||
| promise.then((function (value) { | ||
| if (!ended[0]) { | ||
| sink(/* Push */Block.__(1, [value])); | ||
| sink(/* End */0); | ||
| } | ||
| return Promise.resolve(/* () */0); | ||
| })); | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (signal) { | ||
| ended[0] = true; | ||
| return /* () */0; | ||
| } else { | ||
| return /* () */0; | ||
| } | ||
| })])); | ||
| }); | ||
| } | ||
| var sample = Wonka_operator_sample.sample; | ||
| function debounce(f) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| var gotEndSignal = /* record */[/* contents */false]; | ||
| var id = /* record */[/* contents */undefined]; | ||
| var $$clearTimeout$1 = function (param) { | ||
| var match = id[0]; | ||
| if (match !== undefined) { | ||
| id[0] = undefined; | ||
| clearTimeout(Caml_option.valFromOption(match)); | ||
| return /* () */0; | ||
| } else { | ||
| return /* () */0; | ||
| } | ||
| }; | ||
| return Curry._1(source, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| gotEndSignal[0] = true; | ||
| var match = id[0]; | ||
| if (match !== undefined) { | ||
| return /* () */0; | ||
| } else { | ||
| return sink(/* End */0); | ||
| } | ||
| } else if (signal.tag) { | ||
| $$clearTimeout$1(/* () */0); | ||
| id[0] = Caml_option.some(setTimeout((function (param) { | ||
| id[0] = undefined; | ||
| sink(signal); | ||
| if (gotEndSignal[0]) { | ||
| return sink(/* End */0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| }), f(signal[0]))); | ||
| return /* () */0; | ||
| } else { | ||
| var tb = signal[0]; | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (signal) { | ||
| $$clearTimeout$1(/* () */0); | ||
| return tb(/* Close */1); | ||
| } else { | ||
| return tb(signal); | ||
| } | ||
| })])); | ||
| } | ||
| })); | ||
| }); | ||
| }); | ||
| } | ||
| var throttle = Wonka_operator_throttle.throttle; | ||
| function throttle(f) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| var skip = /* record */[/* contents */false]; | ||
| var id = /* record */[/* contents */undefined]; | ||
| var $$clearTimeout$1 = function (param) { | ||
| var match = id[0]; | ||
| if (match !== undefined) { | ||
| clearTimeout(Caml_option.valFromOption(match)); | ||
| return /* () */0; | ||
| } else { | ||
| return /* () */0; | ||
| } | ||
| }; | ||
| return Curry._1(source, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| $$clearTimeout$1(/* () */0); | ||
| return sink(/* End */0); | ||
| } else if (signal.tag) { | ||
| if (skip[0]) { | ||
| return /* () */0; | ||
| } else { | ||
| skip[0] = true; | ||
| $$clearTimeout$1(/* () */0); | ||
| id[0] = Caml_option.some(setTimeout((function (param) { | ||
| id[0] = undefined; | ||
| skip[0] = false; | ||
| return /* () */0; | ||
| }), f(signal[0]))); | ||
| return sink(signal); | ||
| } | ||
| } else { | ||
| var tb = signal[0]; | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (signal) { | ||
| $$clearTimeout$1(/* () */0); | ||
| return tb(/* Close */1); | ||
| } else { | ||
| return tb(signal); | ||
| } | ||
| })])); | ||
| } | ||
| })); | ||
| }); | ||
| }); | ||
| } | ||
| var toPromise = Wonka_sink_toPromise.toPromise; | ||
| function sample(notifier) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| var state = /* record */[ | ||
| /* ended */false, | ||
| /* value */undefined, | ||
| /* sourceTalkback */(function (param) { | ||
| return /* () */0; | ||
| }), | ||
| /* notifierTalkback */(function (param) { | ||
| return /* () */0; | ||
| }) | ||
| ]; | ||
| Curry._1(source, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| state[/* ended */0] = true; | ||
| state[/* notifierTalkback */3](/* Close */1); | ||
| return sink(/* End */0); | ||
| } else if (signal.tag) { | ||
| state[/* value */1] = Caml_option.some(signal[0]); | ||
| return /* () */0; | ||
| } else { | ||
| state[/* sourceTalkback */2] = signal[0]; | ||
| return /* () */0; | ||
| } | ||
| })); | ||
| Curry._1(notifier, (function (signal) { | ||
| var match = state[/* value */1]; | ||
| if (typeof signal === "number") { | ||
| state[/* ended */0] = true; | ||
| state[/* sourceTalkback */2](/* Close */1); | ||
| return sink(/* End */0); | ||
| } else if (signal.tag) { | ||
| if (match !== undefined && !state[/* ended */0]) { | ||
| state[/* value */1] = undefined; | ||
| return sink(/* Push */Block.__(1, [Caml_option.valFromOption(match)])); | ||
| } else { | ||
| return /* () */0; | ||
| } | ||
| } else { | ||
| state[/* notifierTalkback */3] = signal[0]; | ||
| return /* () */0; | ||
| } | ||
| })); | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (signal) { | ||
| state[/* ended */0] = true; | ||
| state[/* sourceTalkback */2](/* Close */1); | ||
| return state[/* notifierTalkback */3](/* Close */1); | ||
| } else { | ||
| state[/* sourceTalkback */2](/* Pull */0); | ||
| return state[/* notifierTalkback */3](/* Pull */0); | ||
| } | ||
| })])); | ||
| }); | ||
| }); | ||
| } | ||
| var fromDomEvent = Wonka_source_fromDomEvent.fromDomEvent; | ||
| function delay(wait) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| var state = /* record */[ | ||
| /* talkback */Wonka_helpers.talkbackPlaceholder, | ||
| /* active */0, | ||
| /* gotEndSignal */false | ||
| ]; | ||
| Curry._1(source, (function (signal) { | ||
| var exit = 0; | ||
| if (typeof signal === "number" || signal.tag) { | ||
| exit = 1; | ||
| } else { | ||
| state[/* talkback */0] = signal[0]; | ||
| return /* () */0; | ||
| } | ||
| if (exit === 1) { | ||
| if (state[/* gotEndSignal */2]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* active */1] = state[/* active */1] + 1 | 0; | ||
| setTimeout((function (param) { | ||
| if (state[/* gotEndSignal */2] && state[/* active */1] === 0) { | ||
| sink(/* End */0); | ||
| } else { | ||
| state[/* active */1] = state[/* active */1] - 1 | 0; | ||
| } | ||
| return sink(signal); | ||
| }), wait); | ||
| return /* () */0; | ||
| } | ||
| } | ||
| })); | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (signal) { | ||
| state[/* gotEndSignal */2] = true; | ||
| if (state[/* active */1] === 0) { | ||
| return sink(/* End */0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else if (state[/* gotEndSignal */2]) { | ||
| return /* () */0; | ||
| } else { | ||
| return state[/* talkback */0](signal); | ||
| } | ||
| })])); | ||
| }); | ||
| }); | ||
| } | ||
| var fromListener = Wonka_source_fromListener.fromListener; | ||
| function toPromise(source) { | ||
| return new Promise((function (resolve, param) { | ||
| return Curry._1(Wonka.takeLast(1)(source), (function (signal) { | ||
| if (typeof signal === "number") { | ||
| return /* () */0; | ||
| } else if (signal.tag) { | ||
| return resolve(signal[0]); | ||
| } else { | ||
| return signal[0](/* Pull */0); | ||
| } | ||
| })); | ||
| })); | ||
| } | ||
| var fromPromise = Wonka_source_fromPromise.fromPromise; | ||
| export { | ||
| fromListener , | ||
| fromDomEvent , | ||
| debounce , | ||
| delay , | ||
| interval , | ||
| fromPromise , | ||
| debounce , | ||
| sample , | ||
| throttle , | ||
| sample , | ||
| delay , | ||
| toPromise , | ||
| fromDomEvent , | ||
| fromListener , | ||
| fromPromise , | ||
| } | ||
| /* No side effect */ |
@@ -1,40 +0,31 @@ | ||
| import { List, Sink, Source, Subscription, Operator, Observer, Subject } from './wonka_types'; | ||
| /* sources */ | ||
| export * from './sources/wonka_source_fromArray'; | ||
| export * from './sources/wonka_source_fromList'; | ||
| export * from './sources/wonka_source_fromValue'; | ||
| export * from './sources/wonka_source_make'; | ||
| export * from './sources/wonka_source_makeSubject'; | ||
| export * from './sources/wonka_source_primitives'; | ||
| export const makeSubject: <A>() => Subject<A>; | ||
| /* operators */ | ||
| export * from './operators/wonka_operator_combine'; | ||
| export * from './operators/wonka_operator_concatMap'; | ||
| export * from './operators/wonka_operator_filter'; | ||
| export * from './operators/wonka_operator_map'; | ||
| export * from './operators/wonka_operator_mergeMap'; | ||
| export * from './operators/wonka_operator_scan'; | ||
| export * from './operators/wonka_operator_share'; | ||
| export * from './operators/wonka_operator_skip'; | ||
| export * from './operators/wonka_operator_skipUntil'; | ||
| export * from './operators/wonka_operator_skipWhile'; | ||
| export * from './operators/wonka_operator_switchMap'; | ||
| export * from './operators/wonka_operator_take'; | ||
| export * from './operators/wonka_operator_takeLast'; | ||
| export * from './operators/wonka_operator_takeUntil'; | ||
| export * from './operators/wonka_operator_takeWhile'; | ||
| export * from './operators/wonka_operator_tap'; | ||
| export const make: <A>(f: (observer: Observer<A>) => (() => void)) => Source<A>; | ||
| export const fromList: <A>(list: List<A>) => Source<A>; | ||
| export const fromArray: <A>(array: A[]) => Source<A>; | ||
| export const fromValue: <A>(value: A) => Source<A>; | ||
| export const empty: Source<{}>; | ||
| export const never: Source<{}>; | ||
| /* sinks */ | ||
| export * from './sinks/wonka_sink_publish'; | ||
| export * from './sinks/wonka_sink_subscribe'; | ||
| export const tap: <A>(f: (value: A) => void) => Operator<A, A>; | ||
| export const map: <A, B>(f: (value: A) => B) => Operator<A, B>; | ||
| export const filter: <A>(f: (value: A) => boolean) => Operator<A, A>; | ||
| export const scan: <A, B>(f: (acc: B, value: A) => B, acc: B) => Operator<A, B>; | ||
| export const mergeMap: <A, B>(f: (value: A) => Source<B>) => Operator<A, B>; | ||
| export const switchMap: <A, B>(f: (value: A) => Source<B>) => Operator<A, B>; | ||
| export const concatMap: <A, B>(f: (value: A) => Source<B>) => Operator<A, B>; | ||
| export const merge: <A>(sources: Array<Source<A>>) => Source<A>; | ||
| export const concat: <A>(sources: Array<Source<A>>) => Source<A>; | ||
| export const share: <A>(source: Source<A>) => Source<A>; | ||
| export const combine: <A, B>(a: Source<A>, b: Source<B>) => Source<[A, B]>; | ||
| export const concatAll: <A>(source: Source<Source<A>>) => Source<A>; | ||
| export const mergeAll: <A>(source: Source<Source<A>>) => Source<A>; | ||
| export const flatten: <A>(source: Source<Source<A>>) => Source<A>; | ||
| export const take: <A>(max: number) => Operator<A, A>; | ||
| export const takeLast: <A>(max: number) => Operator<A, A>; | ||
| export const takeWhile: <A>(f: (x: A) => boolean) => Operator<A, A>; | ||
| export const takeUntil: <A>(signal: Source<any>) => Operator<A, A>; | ||
| export const skip: <A>(max: number) => Operator<A, A>; | ||
| export const skipWhile: <A>(f: (x: A) => boolean) => Operator<A, A>; | ||
| export const skipUntil: <A>(signal: Source<any>) => Operator<A, A>; | ||
| export const publish: <A>(source: Source<A>) => Subscription; | ||
| export const forEach: <A>(f: (x: A) => void) => (source: Source<A>) => void; | ||
| export const subscribe: <A>(f: (x: A) => void) => (source: Source<A>) => Subscription; | ||
| export * from './web/wonkaJs'; |
1091
src/wonka.js
| import * as Block from "bs-platform/lib/es6/block.js"; | ||
| import * as Curry from "bs-platform/lib/es6/curry.js"; | ||
| import * as Caml_option from "bs-platform/lib/es6/caml_option.js"; | ||
| import * as Wonka_helpers from "./wonka_helpers.js"; | ||
| import * as MutableQueue_js from "bs-rebel/src/js/MutableQueue_js.js"; | ||
| import * as WonkaJs from "./web/wonkaJs.js"; | ||
| import * as Wonka_source_make from "./sources/wonka_source_make.js"; | ||
| import * as Wonka_operator_map from "./operators/wonka_operator_map.js"; | ||
| import * as Wonka_operator_tap from "./operators/wonka_operator_tap.js"; | ||
| import * as Wonka_sink_publish from "./sinks/wonka_sink_publish.js"; | ||
| import * as Wonka_operator_scan from "./operators/wonka_operator_scan.js"; | ||
| import * as Wonka_operator_skip from "./operators/wonka_operator_skip.js"; | ||
| import * as Wonka_operator_take from "./operators/wonka_operator_take.js"; | ||
| import * as Wonka_operator_share from "./operators/wonka_operator_share.js"; | ||
| import * as Wonka_sink_subscribe from "./sinks/wonka_sink_subscribe.js"; | ||
| import * as Wonka_operator_filter from "./operators/wonka_operator_filter.js"; | ||
| import * as Wonka_source_fromList from "./sources/wonka_source_fromList.js"; | ||
| import * as Wonka_operator_combine from "./operators/wonka_operator_combine.js"; | ||
| import * as Wonka_source_fromArray from "./sources/wonka_source_fromArray.js"; | ||
| import * as Wonka_source_fromValue from "./sources/wonka_source_fromValue.js"; | ||
| import * as Wonka_operator_mergeMap from "./operators/wonka_operator_mergeMap.js"; | ||
| import * as Wonka_operator_takeLast from "./operators/wonka_operator_takeLast.js"; | ||
| import * as Wonka_source_primitives from "./sources/wonka_source_primitives.js"; | ||
| import * as Wonka_operator_concatMap from "./operators/wonka_operator_concatMap.js"; | ||
| import * as Wonka_operator_skipUntil from "./operators/wonka_operator_skipUntil.js"; | ||
| import * as Wonka_operator_skipWhile from "./operators/wonka_operator_skipWhile.js"; | ||
| import * as Wonka_operator_switchMap from "./operators/wonka_operator_switchMap.js"; | ||
| import * as Wonka_operator_takeUntil from "./operators/wonka_operator_takeUntil.js"; | ||
| import * as Wonka_operator_takeWhile from "./operators/wonka_operator_takeWhile.js"; | ||
| import * as Wonka_source_makeSubject from "./sources/wonka_source_makeSubject.js"; | ||
| function makeSubject(param) { | ||
| var state = /* record */[ | ||
| /* sinks */new Array(), | ||
| /* ended */false | ||
| ]; | ||
| var source = function (sink) { | ||
| state[/* sinks */0] = state[/* sinks */0].concat(sink); | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (signal === /* Close */1) { | ||
| state[/* sinks */0] = state[/* sinks */0].filter((function (x) { | ||
| return x !== sink; | ||
| })); | ||
| return /* () */0; | ||
| } else { | ||
| return 0; | ||
| } | ||
| })])); | ||
| }; | ||
| var next = function (value) { | ||
| if (state[/* ended */1]) { | ||
| return 0; | ||
| } else { | ||
| state[/* sinks */0].forEach((function (sink) { | ||
| return sink(/* Push */Block.__(1, [value])); | ||
| })); | ||
| return /* () */0; | ||
| } | ||
| }; | ||
| var complete = function (param) { | ||
| if (state[/* ended */1]) { | ||
| return 0; | ||
| } else { | ||
| state[/* ended */1] = true; | ||
| state[/* sinks */0].forEach((function (sink) { | ||
| return sink(/* End */0); | ||
| })); | ||
| return /* () */0; | ||
| } | ||
| }; | ||
| return /* record */[ | ||
| /* source */source, | ||
| /* next */next, | ||
| /* complete */complete | ||
| ]; | ||
| } | ||
| var Types = 0; | ||
| function make(f) { | ||
| return (function (sink) { | ||
| var teardown = f(/* record */[ | ||
| /* next */(function (value) { | ||
| return sink(/* Push */Block.__(1, [value])); | ||
| }), | ||
| /* complete */(function (param) { | ||
| return sink(/* End */0); | ||
| }) | ||
| ]); | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (signal) { | ||
| return teardown(); | ||
| } else { | ||
| return /* () */0; | ||
| } | ||
| })])); | ||
| }); | ||
| } | ||
| var fromArray = Wonka_source_fromArray.fromArray; | ||
| function fromList(ls) { | ||
| return (function (sink) { | ||
| var state = /* record */[ | ||
| /* value */ls, | ||
| /* ended */false, | ||
| /* looping */false, | ||
| /* pull */false | ||
| ]; | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| var match = state[/* looping */2]; | ||
| if (signal) { | ||
| state[/* ended */1] = true; | ||
| return /* () */0; | ||
| } else if (match) { | ||
| state[/* pull */3] = true; | ||
| return /* () */0; | ||
| } else { | ||
| state[/* pull */3] = true; | ||
| state[/* looping */2] = true; | ||
| while(state[/* pull */3] && !state[/* ended */1]) { | ||
| var match$1 = state[/* value */0]; | ||
| if (match$1) { | ||
| state[/* value */0] = match$1[1]; | ||
| state[/* pull */3] = false; | ||
| sink(/* Push */Block.__(1, [match$1[0]])); | ||
| } else { | ||
| state[/* ended */1] = true; | ||
| sink(/* End */0); | ||
| } | ||
| }; | ||
| state[/* looping */2] = false; | ||
| return /* () */0; | ||
| } | ||
| })])); | ||
| }); | ||
| } | ||
| var fromList = Wonka_source_fromList.fromList; | ||
| function fromArray(arr) { | ||
| return (function (sink) { | ||
| var size = arr.length; | ||
| var state = /* record */[ | ||
| /* index */0, | ||
| /* ended */false, | ||
| /* looping */false, | ||
| /* pull */false | ||
| ]; | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| var match = state[/* looping */2]; | ||
| if (signal) { | ||
| state[/* ended */1] = true; | ||
| return /* () */0; | ||
| } else if (match) { | ||
| state[/* pull */3] = true; | ||
| return /* () */0; | ||
| } else { | ||
| state[/* pull */3] = true; | ||
| state[/* looping */2] = true; | ||
| while(state[/* pull */3] && !state[/* ended */1]) { | ||
| var index = state[/* index */0]; | ||
| if (index < size) { | ||
| var x = arr[index]; | ||
| state[/* index */0] = index + 1 | 0; | ||
| state[/* pull */3] = false; | ||
| sink(/* Push */Block.__(1, [x])); | ||
| } else { | ||
| state[/* ended */1] = true; | ||
| sink(/* End */0); | ||
| } | ||
| }; | ||
| state[/* looping */2] = false; | ||
| return /* () */0; | ||
| } | ||
| })])); | ||
| }); | ||
| } | ||
| var fromValue = Wonka_source_fromValue.fromValue; | ||
| function fromValue(x) { | ||
| return (function (sink) { | ||
| var ended = /* record */[/* contents */false]; | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (signal || ended[0]) { | ||
| return /* () */0; | ||
| } else { | ||
| ended[0] = true; | ||
| sink(/* Push */Block.__(1, [x])); | ||
| return sink(/* End */0); | ||
| } | ||
| })])); | ||
| }); | ||
| } | ||
| var make = Wonka_source_make.make; | ||
| function empty(sink) { | ||
| sink(/* Start */Block.__(0, [Wonka_helpers.talkbackPlaceholder])); | ||
| return sink(/* End */0); | ||
| } | ||
| var makeSubject = Wonka_source_makeSubject.makeSubject; | ||
| function never(sink) { | ||
| return sink(/* Start */Block.__(0, [Wonka_helpers.talkbackPlaceholder])); | ||
| } | ||
| var empty = Wonka_source_primitives.empty; | ||
| function tap(f) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| return Curry._1(source, (function (signal) { | ||
| if (typeof signal !== "number") { | ||
| if (signal.tag) { | ||
| f(signal[0]); | ||
| } | ||
| } | ||
| return sink(signal); | ||
| })); | ||
| }); | ||
| }); | ||
| } | ||
| var never = Wonka_source_primitives.never; | ||
| function map(f) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| return Curry._1(source, (function (signal) { | ||
| var tmp; | ||
| tmp = typeof signal === "number" ? /* End */0 : ( | ||
| signal.tag ? /* Push */Block.__(1, [f(signal[0])]) : /* Start */Block.__(0, [signal[0]]) | ||
| ); | ||
| return sink(tmp); | ||
| })); | ||
| }); | ||
| }); | ||
| } | ||
| var combine = Wonka_operator_combine.combine; | ||
| function filter(f) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| return Wonka_helpers.captureTalkback(source, (function (signal, talkback) { | ||
| if (typeof signal === "number" || !(signal.tag && !f(signal[0]))) { | ||
| return sink(signal); | ||
| } else { | ||
| return talkback(/* Pull */0); | ||
| } | ||
| })); | ||
| }); | ||
| }); | ||
| } | ||
| var concatMap = Wonka_operator_concatMap.concatMap; | ||
| function scan(f, seed) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| var acc = /* record */[/* contents */seed]; | ||
| return Curry._1(source, (function (signal) { | ||
| var tmp; | ||
| if (typeof signal === "number") { | ||
| tmp = /* End */0; | ||
| } else if (signal.tag) { | ||
| acc[0] = Curry._2(f, acc[0], signal[0]); | ||
| tmp = /* Push */Block.__(1, [acc[0]]); | ||
| } else { | ||
| tmp = /* Start */Block.__(0, [signal[0]]); | ||
| } | ||
| return sink(tmp); | ||
| })); | ||
| }); | ||
| }); | ||
| } | ||
| var concat = Wonka_operator_concatMap.concat; | ||
| function mergeMap(f) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| var state = /* record */[ | ||
| /* outerTalkback */Wonka_helpers.talkbackPlaceholder, | ||
| /* innerTalkbacks */new Array(), | ||
| /* ended */false | ||
| ]; | ||
| var applyInnerSource = function (innerSource) { | ||
| var talkback = /* record */[/* contents */Wonka_helpers.talkbackPlaceholder]; | ||
| return Curry._1(innerSource, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| state[/* innerTalkbacks */1] = state[/* innerTalkbacks */1].filter((function (x) { | ||
| return x !== talkback[0]; | ||
| })); | ||
| if (state[/* ended */2] && state[/* innerTalkbacks */1].length === 0) { | ||
| return sink(/* End */0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else if (signal.tag) { | ||
| if (state[/* innerTalkbacks */1].length !== 0) { | ||
| sink(/* Push */Block.__(1, [signal[0]])); | ||
| return talkback[0](/* Pull */0); | ||
| } else { | ||
| return /* () */0; | ||
| } | ||
| } else { | ||
| var tb = signal[0]; | ||
| talkback[0] = tb; | ||
| state[/* innerTalkbacks */1] = state[/* innerTalkbacks */1].concat(tb); | ||
| return tb(/* Pull */0); | ||
| } | ||
| })); | ||
| }; | ||
| Curry._1(source, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| if (state[/* ended */2]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* ended */2] = true; | ||
| if (state[/* innerTalkbacks */1].length === 0) { | ||
| return sink(/* End */0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| } else if (signal.tag) { | ||
| if (state[/* ended */2]) { | ||
| return /* () */0; | ||
| } else { | ||
| applyInnerSource(f(signal[0])); | ||
| return state[/* outerTalkback */0](/* Pull */0); | ||
| } | ||
| } else { | ||
| var tb = signal[0]; | ||
| state[/* outerTalkback */0] = tb; | ||
| return tb(/* Pull */0); | ||
| } | ||
| })); | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (signal) { | ||
| if (state[/* ended */2]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* ended */2] = true; | ||
| state[/* outerTalkback */0](/* Close */1); | ||
| state[/* innerTalkbacks */1].forEach((function (talkback) { | ||
| return talkback(/* Close */1); | ||
| })); | ||
| state[/* innerTalkbacks */1] = new Array(); | ||
| return /* () */0; | ||
| } | ||
| } else if (state[/* ended */2]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* innerTalkbacks */1].forEach((function (talkback) { | ||
| return talkback(/* Pull */0); | ||
| })); | ||
| return /* () */0; | ||
| } | ||
| })])); | ||
| }); | ||
| }); | ||
| } | ||
| var concatAll = Wonka_operator_concatMap.concatAll; | ||
| function merge(sources) { | ||
| return mergeMap((function (x) { | ||
| return x; | ||
| }))(fromArray(sources)); | ||
| } | ||
| var filter = Wonka_operator_filter.filter; | ||
| function mergeAll(source) { | ||
| return mergeMap((function (x) { | ||
| return x; | ||
| }))(source); | ||
| } | ||
| var map = Wonka_operator_map.map; | ||
| function concatMap(f) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| var state = /* record */[ | ||
| /* inputQueue */new Array(), | ||
| /* outerTalkback */Wonka_helpers.talkbackPlaceholder, | ||
| /* innerTalkback */Wonka_helpers.talkbackPlaceholder, | ||
| /* innerActive */false, | ||
| /* closed */false, | ||
| /* ended */false | ||
| ]; | ||
| var applyInnerSource = function (innerSource) { | ||
| return Curry._1(innerSource, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| state[/* innerActive */3] = false; | ||
| state[/* innerTalkback */2] = Wonka_helpers.talkbackPlaceholder; | ||
| var match = state[/* inputQueue */0].shift(); | ||
| if (match !== undefined) { | ||
| return applyInnerSource(f(Caml_option.valFromOption(match))); | ||
| } else if (state[/* ended */5]) { | ||
| return sink(/* End */0); | ||
| } else { | ||
| return /* () */0; | ||
| } | ||
| } else if (signal.tag) { | ||
| if (state[/* closed */4]) { | ||
| return /* () */0; | ||
| } else { | ||
| sink(/* Push */Block.__(1, [signal[0]])); | ||
| return state[/* innerTalkback */2](/* Pull */0); | ||
| } | ||
| } else { | ||
| var tb = signal[0]; | ||
| state[/* innerActive */3] = true; | ||
| state[/* innerTalkback */2] = tb; | ||
| return tb(/* Pull */0); | ||
| } | ||
| })); | ||
| }; | ||
| Curry._1(source, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| if (state[/* ended */5]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* ended */5] = true; | ||
| if (!state[/* innerActive */3] && MutableQueue_js.isEmpty(state[/* inputQueue */0])) { | ||
| return sink(/* End */0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } | ||
| } else if (signal.tag) { | ||
| if (state[/* ended */5]) { | ||
| return /* () */0; | ||
| } else { | ||
| var x = signal[0]; | ||
| if (state[/* innerActive */3]) { | ||
| state[/* inputQueue */0].push(x); | ||
| } else { | ||
| applyInnerSource(f(x)); | ||
| } | ||
| return state[/* outerTalkback */1](/* Pull */0); | ||
| } | ||
| } else { | ||
| var tb = signal[0]; | ||
| state[/* outerTalkback */1] = tb; | ||
| return tb(/* Pull */0); | ||
| } | ||
| })); | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (signal) { | ||
| if (state[/* ended */5]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* ended */5] = true; | ||
| state[/* closed */4] = true; | ||
| state[/* outerTalkback */1](/* Close */1); | ||
| return state[/* innerTalkback */2](/* Close */1); | ||
| } | ||
| } else if (state[/* ended */5]) { | ||
| return 0; | ||
| } else { | ||
| return state[/* innerTalkback */2](/* Pull */0); | ||
| } | ||
| })])); | ||
| }); | ||
| }); | ||
| } | ||
| var mergeMap = Wonka_operator_mergeMap.mergeMap; | ||
| function concatAll(source) { | ||
| return concatMap((function (x) { | ||
| return x; | ||
| }))(source); | ||
| } | ||
| var merge = Wonka_operator_mergeMap.merge; | ||
| function concat(sources) { | ||
| return concatMap((function (x) { | ||
| return x; | ||
| }))(fromArray(sources)); | ||
| } | ||
| var mergeAll = Wonka_operator_mergeMap.mergeAll; | ||
| function switchMap(f) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| var state = /* record */[ | ||
| /* outerTalkback */Wonka_helpers.talkbackPlaceholder, | ||
| /* innerTalkback */Wonka_helpers.talkbackPlaceholder, | ||
| /* innerActive */false, | ||
| /* closed */false, | ||
| /* ended */false | ||
| ]; | ||
| var applyInnerSource = function (innerSource) { | ||
| return Curry._1(innerSource, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| state[/* innerActive */2] = false; | ||
| state[/* innerTalkback */1] = Wonka_helpers.talkbackPlaceholder; | ||
| if (state[/* ended */4]) { | ||
| return sink(/* End */0); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else if (signal.tag) { | ||
| if (state[/* closed */3]) { | ||
| return /* () */0; | ||
| } else { | ||
| sink(/* Push */Block.__(1, [signal[0]])); | ||
| return state[/* innerTalkback */1](/* Pull */0); | ||
| } | ||
| } else { | ||
| var tb = signal[0]; | ||
| state[/* innerActive */2] = true; | ||
| state[/* innerTalkback */1] = tb; | ||
| return tb(/* Pull */0); | ||
| } | ||
| })); | ||
| }; | ||
| Curry._1(source, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| if (state[/* ended */4]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* ended */4] = true; | ||
| if (state[/* innerActive */2]) { | ||
| return 0; | ||
| } else { | ||
| return sink(/* End */0); | ||
| } | ||
| } | ||
| } else if (signal.tag) { | ||
| if (state[/* ended */4]) { | ||
| return /* () */0; | ||
| } else { | ||
| if (state[/* innerActive */2]) { | ||
| state[/* innerTalkback */1](/* Close */1); | ||
| state[/* innerTalkback */1] = Wonka_helpers.talkbackPlaceholder; | ||
| } | ||
| applyInnerSource(f(signal[0])); | ||
| return state[/* outerTalkback */0](/* Pull */0); | ||
| } | ||
| } else { | ||
| var tb = signal[0]; | ||
| state[/* outerTalkback */0] = tb; | ||
| return tb(/* Pull */0); | ||
| } | ||
| })); | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (signal) { | ||
| if (state[/* ended */4]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* ended */4] = true; | ||
| state[/* closed */3] = true; | ||
| state[/* outerTalkback */0](/* Close */1); | ||
| state[/* innerTalkback */1](/* Close */1); | ||
| state[/* innerTalkback */1] = Wonka_helpers.talkbackPlaceholder; | ||
| return /* () */0; | ||
| } | ||
| } else { | ||
| return state[/* innerTalkback */1](/* Pull */0); | ||
| } | ||
| })])); | ||
| }); | ||
| }); | ||
| } | ||
| var flatten = Wonka_operator_mergeMap.flatten; | ||
| function share(source) { | ||
| var state = /* record */[ | ||
| /* sinks */new Array(), | ||
| /* talkback */Wonka_helpers.talkbackPlaceholder, | ||
| /* gotSignal */false | ||
| ]; | ||
| return (function (sink) { | ||
| state[/* sinks */0] = state[/* sinks */0].concat(sink); | ||
| if (state[/* sinks */0].length === 1) { | ||
| Curry._1(source, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| state[/* sinks */0].forEach((function (sink) { | ||
| return sink(/* End */0); | ||
| })); | ||
| state[/* sinks */0] = new Array(); | ||
| return /* () */0; | ||
| } else if (signal.tag) { | ||
| state[/* gotSignal */2] = false; | ||
| state[/* sinks */0].forEach((function (sink) { | ||
| return sink(signal); | ||
| })); | ||
| return /* () */0; | ||
| } else { | ||
| state[/* talkback */1] = signal[0]; | ||
| return /* () */0; | ||
| } | ||
| })); | ||
| } | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (signal) { | ||
| state[/* sinks */0] = state[/* sinks */0].filter((function (x) { | ||
| return x !== sink; | ||
| })); | ||
| if (state[/* sinks */0].length === 0) { | ||
| return state[/* talkback */1](/* Close */1); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else if (state[/* gotSignal */2]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* gotSignal */2] = true; | ||
| return state[/* talkback */1](signal); | ||
| } | ||
| })])); | ||
| }); | ||
| } | ||
| var scan = Wonka_operator_scan.scan; | ||
| function combine(sourceA, sourceB) { | ||
| return (function (sink) { | ||
| var state = /* record */[ | ||
| /* talkbackA */Wonka_helpers.talkbackPlaceholder, | ||
| /* talkbackB */Wonka_helpers.talkbackPlaceholder, | ||
| /* lastValA */undefined, | ||
| /* lastValB */undefined, | ||
| /* gotSignal */false, | ||
| /* endCounter */0, | ||
| /* ended */false | ||
| ]; | ||
| Curry._1(sourceA, (function (signal) { | ||
| var match = state[/* lastValB */3]; | ||
| if (typeof signal === "number") { | ||
| if (state[/* endCounter */5] < 1) { | ||
| state[/* endCounter */5] = state[/* endCounter */5] + 1 | 0; | ||
| return /* () */0; | ||
| } else if (state[/* ended */6]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* ended */6] = true; | ||
| return sink(/* End */0); | ||
| } | ||
| } else if (signal.tag) { | ||
| var a = signal[0]; | ||
| if (match !== undefined) { | ||
| if (state[/* ended */6]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* lastValA */2] = Caml_option.some(a); | ||
| state[/* gotSignal */4] = false; | ||
| return sink(/* Push */Block.__(1, [/* tuple */[ | ||
| a, | ||
| Caml_option.valFromOption(match) | ||
| ]])); | ||
| } | ||
| } else { | ||
| state[/* lastValA */2] = Caml_option.some(a); | ||
| state[/* gotSignal */4] = false; | ||
| return /* () */0; | ||
| } | ||
| } else { | ||
| state[/* talkbackA */0] = signal[0]; | ||
| return /* () */0; | ||
| } | ||
| })); | ||
| Curry._1(sourceB, (function (signal) { | ||
| var match = state[/* lastValA */2]; | ||
| if (typeof signal === "number") { | ||
| if (state[/* endCounter */5] < 1) { | ||
| state[/* endCounter */5] = state[/* endCounter */5] + 1 | 0; | ||
| return /* () */0; | ||
| } else if (state[/* ended */6]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* ended */6] = true; | ||
| return sink(/* End */0); | ||
| } | ||
| } else if (signal.tag) { | ||
| var b = signal[0]; | ||
| if (match !== undefined) { | ||
| if (state[/* ended */6]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* lastValB */3] = Caml_option.some(b); | ||
| state[/* gotSignal */4] = false; | ||
| return sink(/* Push */Block.__(1, [/* tuple */[ | ||
| Caml_option.valFromOption(match), | ||
| b | ||
| ]])); | ||
| } | ||
| } else { | ||
| state[/* lastValB */3] = Caml_option.some(b); | ||
| state[/* gotSignal */4] = false; | ||
| return /* () */0; | ||
| } | ||
| } else { | ||
| state[/* talkbackB */1] = signal[0]; | ||
| return /* () */0; | ||
| } | ||
| })); | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (state[/* ended */6]) { | ||
| return 0; | ||
| } else if (signal) { | ||
| state[/* ended */6] = true; | ||
| state[/* talkbackA */0](/* Close */1); | ||
| return state[/* talkbackB */1](/* Close */1); | ||
| } else if (state[/* gotSignal */4]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* gotSignal */4] = true; | ||
| state[/* talkbackA */0](signal); | ||
| return state[/* talkbackB */1](signal); | ||
| } | ||
| })])); | ||
| }); | ||
| } | ||
| var share = Wonka_operator_share.share; | ||
| function take(max) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| var state = /* record */[ | ||
| /* taken */0, | ||
| /* talkback */Wonka_helpers.talkbackPlaceholder | ||
| ]; | ||
| Curry._1(source, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| if (state[/* taken */0] < max) { | ||
| state[/* taken */0] = max; | ||
| return sink(/* End */0); | ||
| } else { | ||
| return /* () */0; | ||
| } | ||
| } else if (signal.tag) { | ||
| if (state[/* taken */0] < max) { | ||
| state[/* taken */0] = state[/* taken */0] + 1 | 0; | ||
| sink(signal); | ||
| if (state[/* taken */0] === max) { | ||
| sink(/* End */0); | ||
| return state[/* talkback */1](/* Close */1); | ||
| } else { | ||
| return 0; | ||
| } | ||
| } else { | ||
| return /* () */0; | ||
| } | ||
| } else { | ||
| state[/* talkback */1] = signal[0]; | ||
| return /* () */0; | ||
| } | ||
| })); | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (state[/* taken */0] < max) { | ||
| if (signal) { | ||
| state[/* taken */0] = max; | ||
| return state[/* talkback */1](/* Close */1); | ||
| } else { | ||
| return state[/* talkback */1](/* Pull */0); | ||
| } | ||
| } else { | ||
| return 0; | ||
| } | ||
| })])); | ||
| }); | ||
| }); | ||
| } | ||
| var skip = Wonka_operator_skip.skip; | ||
| function takeLast(max) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| var queue = new Array(); | ||
| return Wonka_helpers.captureTalkback(source, (function (signal, talkback) { | ||
| if (typeof signal === "number") { | ||
| return Wonka_helpers.makeTrampoline(sink, (function () { | ||
| return queue.shift(); | ||
| })); | ||
| } else if (signal.tag) { | ||
| var size = queue.length; | ||
| if (size >= max && max > 0) { | ||
| queue.shift(); | ||
| } | ||
| queue.push(signal[0]); | ||
| return talkback(/* Pull */0); | ||
| } else { | ||
| return talkback(/* Pull */0); | ||
| } | ||
| })); | ||
| }); | ||
| }); | ||
| } | ||
| var skipUntil = Wonka_operator_skipUntil.skipUntil; | ||
| function takeWhile(f) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| var ended = /* record */[/* contents */false]; | ||
| var talkback = /* record */[/* contents */Wonka_helpers.talkbackPlaceholder]; | ||
| Curry._1(source, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| if (ended[0]) { | ||
| return /* () */0; | ||
| } else { | ||
| ended[0] = true; | ||
| return sink(/* End */0); | ||
| } | ||
| } else if (signal.tag) { | ||
| if (ended[0]) { | ||
| return /* () */0; | ||
| } else if (f(signal[0])) { | ||
| return sink(signal); | ||
| } else { | ||
| ended[0] = true; | ||
| sink(/* End */0); | ||
| return talkback[0](/* Close */1); | ||
| } | ||
| } else { | ||
| talkback[0] = signal[0]; | ||
| return sink(signal); | ||
| } | ||
| })); | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (ended[0]) { | ||
| return 0; | ||
| } else if (signal) { | ||
| ended[0] = true; | ||
| return talkback[0](/* Close */1); | ||
| } else { | ||
| return talkback[0](/* Pull */0); | ||
| } | ||
| })])); | ||
| }); | ||
| }); | ||
| } | ||
| var skipWhile = Wonka_operator_skipWhile.skipWhile; | ||
| function takeUntil(notifier) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| var state = /* record */[ | ||
| /* ended */false, | ||
| /* sourceTalkback */Wonka_helpers.talkbackPlaceholder, | ||
| /* notifierTalkback */Wonka_helpers.talkbackPlaceholder | ||
| ]; | ||
| Curry._1(source, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| if (state[/* ended */0]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* notifierTalkback */2](/* Close */1); | ||
| state[/* ended */0] = true; | ||
| return sink(/* End */0); | ||
| } | ||
| } else if (signal.tag) { | ||
| if (state[/* ended */0]) { | ||
| return /* () */0; | ||
| } else { | ||
| return sink(signal); | ||
| } | ||
| } else { | ||
| state[/* sourceTalkback */1] = signal[0]; | ||
| return Curry._1(notifier, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| return /* () */0; | ||
| } else if (signal.tag) { | ||
| state[/* ended */0] = true; | ||
| state[/* notifierTalkback */2](/* Close */1); | ||
| state[/* sourceTalkback */1](/* Close */1); | ||
| return sink(/* End */0); | ||
| } else { | ||
| var innerTb = signal[0]; | ||
| state[/* notifierTalkback */2] = innerTb; | ||
| return innerTb(/* Pull */0); | ||
| } | ||
| })); | ||
| } | ||
| })); | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (state[/* ended */0]) { | ||
| return 0; | ||
| } else if (signal) { | ||
| state[/* sourceTalkback */1](/* Close */1); | ||
| return state[/* notifierTalkback */2](/* Close */1); | ||
| } else { | ||
| return state[/* sourceTalkback */1](/* Pull */0); | ||
| } | ||
| })])); | ||
| }); | ||
| }); | ||
| } | ||
| var switchMap = Wonka_operator_switchMap.switchMap; | ||
| function skip(wait) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| var rest = /* record */[/* contents */wait]; | ||
| return Wonka_helpers.captureTalkback(source, (function (signal, talkback) { | ||
| if (typeof signal === "number" || !(signal.tag && rest[0] > 0)) { | ||
| return sink(signal); | ||
| } else { | ||
| rest[0] = rest[0] - 1 | 0; | ||
| return talkback(/* Pull */0); | ||
| } | ||
| })); | ||
| }); | ||
| }); | ||
| } | ||
| var take = Wonka_operator_take.take; | ||
| function skipWhile(f) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| var skip = /* record */[/* contents */true]; | ||
| return Wonka_helpers.captureTalkback(source, (function (signal, talkback) { | ||
| if (typeof signal === "number" || !(signal.tag && skip[0])) { | ||
| return sink(signal); | ||
| } else if (f(signal[0])) { | ||
| return talkback(/* Pull */0); | ||
| } else { | ||
| skip[0] = false; | ||
| return sink(signal); | ||
| } | ||
| })); | ||
| }); | ||
| }); | ||
| } | ||
| var takeLast = Wonka_operator_takeLast.takeLast; | ||
| function skipUntil(notifier) { | ||
| return (function (source) { | ||
| return (function (sink) { | ||
| var state = /* record */[ | ||
| /* skip */true, | ||
| /* ended */false, | ||
| /* gotSignal */false, | ||
| /* sourceTalkback */Wonka_helpers.talkbackPlaceholder, | ||
| /* notifierTalkback */Wonka_helpers.talkbackPlaceholder | ||
| ]; | ||
| Curry._1(source, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| if (state[/* skip */0]) { | ||
| state[/* notifierTalkback */4](/* Close */1); | ||
| } | ||
| state[/* ended */1] = true; | ||
| return sink(/* End */0); | ||
| } else if (signal.tag) { | ||
| if (state[/* skip */0] && !state[/* ended */1]) { | ||
| return state[/* sourceTalkback */3](/* Pull */0); | ||
| } else if (state[/* ended */1]) { | ||
| return /* () */0; | ||
| } else { | ||
| state[/* gotSignal */2] = false; | ||
| return sink(signal); | ||
| } | ||
| } else { | ||
| var tb = signal[0]; | ||
| state[/* sourceTalkback */3] = tb; | ||
| return Curry._1(notifier, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| return /* () */0; | ||
| } else if (signal.tag) { | ||
| state[/* skip */0] = false; | ||
| return state[/* notifierTalkback */4](/* Close */1); | ||
| } else { | ||
| var innerTb = signal[0]; | ||
| state[/* notifierTalkback */4] = innerTb; | ||
| innerTb(/* Pull */0); | ||
| return tb(/* Pull */0); | ||
| } | ||
| })); | ||
| } | ||
| })); | ||
| return sink(/* Start */Block.__(0, [(function (signal) { | ||
| if (signal) { | ||
| if (state[/* skip */0]) { | ||
| state[/* notifierTalkback */4](/* Close */1); | ||
| } | ||
| state[/* ended */1] = true; | ||
| return state[/* sourceTalkback */3](/* Close */1); | ||
| } else if (!state[/* gotSignal */2] && !state[/* ended */1]) { | ||
| state[/* gotSignal */2] = true; | ||
| return state[/* sourceTalkback */3](/* Pull */0); | ||
| } else { | ||
| return /* () */0; | ||
| } | ||
| })])); | ||
| }); | ||
| }); | ||
| } | ||
| var takeUntil = Wonka_operator_takeUntil.takeUntil; | ||
| function publish(source) { | ||
| var state = /* record */[ | ||
| /* talkback */Wonka_helpers.talkbackPlaceholder, | ||
| /* ended */false | ||
| ]; | ||
| Curry._1(source, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| state[/* ended */1] = true; | ||
| return /* () */0; | ||
| } else if (signal.tag) { | ||
| if (state[/* ended */1]) { | ||
| return 0; | ||
| } else { | ||
| return state[/* talkback */0](/* Pull */0); | ||
| } | ||
| } else { | ||
| var x = signal[0]; | ||
| state[/* talkback */0] = x; | ||
| return x(/* Pull */0); | ||
| } | ||
| })); | ||
| return /* record */[/* unsubscribe */(function (param) { | ||
| if (state[/* ended */1]) { | ||
| return 0; | ||
| } else { | ||
| state[/* ended */1] = true; | ||
| return state[/* talkback */0](/* Close */1); | ||
| } | ||
| })]; | ||
| } | ||
| var takeWhile = Wonka_operator_takeWhile.takeWhile; | ||
| function subscribe(f) { | ||
| return (function (source) { | ||
| var state = /* record */[ | ||
| /* talkback */Wonka_helpers.talkbackPlaceholder, | ||
| /* ended */false | ||
| ]; | ||
| Curry._1(source, (function (signal) { | ||
| if (typeof signal === "number") { | ||
| state[/* ended */1] = true; | ||
| return /* () */0; | ||
| } else if (signal.tag) { | ||
| if (state[/* ended */1]) { | ||
| return /* () */0; | ||
| } else { | ||
| f(signal[0]); | ||
| return state[/* talkback */0](/* Pull */0); | ||
| } | ||
| } else { | ||
| var x = signal[0]; | ||
| state[/* talkback */0] = x; | ||
| return x(/* Pull */0); | ||
| } | ||
| })); | ||
| return /* record */[/* unsubscribe */(function (param) { | ||
| if (state[/* ended */1]) { | ||
| return 0; | ||
| } else { | ||
| state[/* ended */1] = true; | ||
| return state[/* talkback */0](/* Close */1); | ||
| } | ||
| })]; | ||
| }); | ||
| } | ||
| var tap = Wonka_operator_tap.tap; | ||
| function forEach(f) { | ||
| return (function (source) { | ||
| subscribe(f)(source); | ||
| return /* () */0; | ||
| }); | ||
| } | ||
| var publish = Wonka_sink_publish.publish; | ||
| var Types = 0; | ||
| var subscribe = Wonka_sink_subscribe.subscribe; | ||
| var flatten = mergeAll; | ||
| var forEach = Wonka_sink_subscribe.forEach; | ||
| var debounce = WonkaJs.debounce; | ||
| var delay = WonkaJs.delay; | ||
| var interval = WonkaJs.interval; | ||
| var sample = WonkaJs.sample; | ||
| var throttle = WonkaJs.throttle; | ||
| var toPromise = WonkaJs.toPromise; | ||
| var fromDomEvent = WonkaJs.fromDomEvent; | ||
| var fromListener = WonkaJs.fromListener; | ||
| var fromPromise = WonkaJs.fromPromise; | ||
| export { | ||
| Types , | ||
| makeSubject , | ||
| make , | ||
| fromArray , | ||
| fromList , | ||
| fromArray , | ||
| fromValue , | ||
| make , | ||
| makeSubject , | ||
| empty , | ||
| never , | ||
| tap , | ||
| combine , | ||
| concatMap , | ||
| concat , | ||
| concatAll , | ||
| filter , | ||
| map , | ||
| filter , | ||
| scan , | ||
| mergeMap , | ||
| switchMap , | ||
| concatMap , | ||
| merge , | ||
| concat , | ||
| mergeAll , | ||
| flatten , | ||
| concatAll , | ||
| scan , | ||
| share , | ||
| combine , | ||
| skip , | ||
| skipUntil , | ||
| skipWhile , | ||
| switchMap , | ||
| take , | ||
| takeLast , | ||
| takeUntil , | ||
| takeWhile , | ||
| takeUntil , | ||
| skip , | ||
| skipWhile , | ||
| skipUntil , | ||
| tap , | ||
| publish , | ||
| subscribe , | ||
| forEach , | ||
| subscribe , | ||
| debounce , | ||
| delay , | ||
| interval , | ||
| sample , | ||
| throttle , | ||
| toPromise , | ||
| fromDomEvent , | ||
| fromListener , | ||
| fromPromise , | ||
| } | ||
| /* No side effect */ |
Sorry, the diff of this file is too big to display
Sorry, the diff of this file is not supported yet
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
Major refactor
Supply chain riskPackage has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.
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 by8.24%
372192
- Number of package files
- increased by562.07%
192
- Lines of code
- increased by9.86%
8511
Worsened metrics
- Number of medium supply chain risk alerts
- increased byInfinity%
1
No dependency changes