VimџUnDoеBЃ#х%ЯФZ§3h~)кi6е§ЇhщЃ=R&m…P„oA return next(element), index <= end ? (stop(), false) : true#ЬДйДДNRt€_РЭЬW4яяяяi'i#v#NOЬ–TхVXq4 var streams = stack(source), open = 1, interrupt5Ѓ_РЬЮЭh@яяяяi'i#v#NOЬћхgjq@ // If steam is still open and read is not interrupted 5Ѓ_РЭЯЮj=яяяяj'j#v#NOЬЇхikrF return open && false !== alive ? alive = next(value) : false5Ѓ_РЮаЯiяяяяj'j#v#NOЬ±хhjr //5Ѓ_РЯбаi;яяяяj'j#v#NOЬГхhjr; // element to the reader, otherwise we interrupt 5Ѓ_РавбiBяяяяj'j#v#NOЬИVхhjrB // element to the reader, otherwise we interrupt reader.5Ѓ_РбгвNяяяяj'j#v#NOЬшхMOr4 * var stream = merge(list(async, list(1, 2, 3)))5Ѓ_РвдгW(яяяяJ JvNOеЖWхVXr0 var streams = stack(source), open = 1, alive5Ѓ_Ргедg+яяяяJ JvNP&яхgis хgir5Ѓ_РджеhяяяяJ JvNP'Xхgis console.log()5Ѓ_РезжhяяяяJ JvNP'BYхgis console.log(element)5Ѓ_РжизhяяяяJ JvNP'’хhjt хhjs5Ѓ_РзйиW0яяяяJ JvNP'џZхVXt0 var streams = stack(source), open = 2, alive5Ѓ_Рикйe3яяяяJ JvNP'іхegu хegt5Ѓ_РймкfяяяяJ JvNP'¶[хegu console.log()5Ѓ_Ркнлмjяяяяmm'v'NP(0]хiku console.log()5Ѓ_Рмонjяяяяmm'v'NP)хiku. console.log(open && false !== alive)5Ѓ_Рнпоjяяяяmm'v'NP)^хiku/ console.log(open, && false !== alive)5Ѓ_Рорпfяяяяmm'v'NP)*_хegu console.log(stream)5Ѓ_Рпср_яяяяmm'v'NP)qх`b console.logх_bv х_au5Ѓ_Рртсaяяяяoo'v'NP)u`х`bw console.log()5Ѓ_РсутW(яяяяoo'v'NP)љaхVXw7 var streams = stack(source), open = 2, alive = true5Ѓ_РтфуW(яяяяoo'v'NP*bхVXw7 var streams = stack(source), open = 3, alive = true5Ѓ_РухфXяяяяoo'v'NP**хXZx хXZw5Ѓ_РфцхYяяяяpp'v'NP*-хXZx console.log()5Ѓ_РхшцYяяяяpp'v'NP*-cхXZx console.log('')5Ѓ_РцщчшYяяяяpp'v'NP*2dхXZx console.log('stop')5Ѓ_Ршъщbяяяяpp'v'NP*?eхacx console.log(open)5Ѓ_Рщыъiяяяяpp'v'NP*Pfхhjx! console.log(stream, open)5Ѓ_Ръьыlяяяяpp'v'NP*Vхkmx% console.log('!!!', element)5Ѓ_Рыэьl(яяяяpp'v'NP*Yхkmx) console.log('element', element)5Ѓ_Рьюэl.яяяяpp'v'NP*]хkmx/ console.log('element', element, open)5Ѓ_Рэяюmяяяяmm*v*NP*`хlnx, console.log(open, false !== alive)5Ѓ_Рюяmяяяяmm*v*NP*aхlnx console.log(open, )5Ѓ_Ряm яяяяmm*v*NP*aхlm console.log(open, 5Ѓ_Рl0яяяяmm*v*NP*dgхkmw1 console.log('element', element, open, )5Ѓ_РW(яяяяmm*v*NP*‡hхVXw7 var streams = stack(source), open = 1, alive = true5Ѓ_Рiяяяяii*v*NP*Їхhjw+ console.log('stream', stream, open)5Ѓ_Рiяяяяii*v*NP*°хhi 5Ѓ_Рiяяяяii*v*NP*Іiхikw хikv5Ѓ_РW*яяяяii*v*NP+хWYx хWYw5Ѓ_РXяяяяjj*v*NP+ хWYx function onStop()5Ѓ_Р Xяяяяjj*v*NP+jхWZx function onStop() {}5Ѓ_Р [яяяя[gvNP+)хZ\y console.log('stop', open)8 // If no more open streams left just return early.. if (!open || false === alive) return nilE // If stream was stopped with error we mark all streams closed. if (error) open = 0< // Otherwise we just decrement number of open streams. else open --$ console.log('decrement', open)4 // If stream is no longer open we stop reader. if (!open) stop(error)5Ѓ_Р [яяяя[[!vNP+,хZ[ 5Ѓ_Р Xяяяя[[!vNP+-хXfm хXZl5Ѓ_Р gяяяяhh!vNP+5хfhy !function onStop(error) {5Ѓ_Р gяяяяhh!vNP+8хfhy !function recursive(error) {5Ѓ_Рrяяяяhh!vNP+@kхqsy }, onStop)5Ѓ_Рjяяяяhh!vNP+Slхiky4 else head(streams)(function onStream(stream) {5Ѓ_Рgяяяяhh!vNP+^mхgiz хgiy5Ѓ_Рh яяяяii!vNP+inхgiz onStop()5Ѓ_Рfяяяяii!vNP+Ѓoхfhz5Ѓ_РXяяяяjj!vNP+ЉpхWY{ function onStop() {5Ѓ_РWяяяяjj!vNP+’qхWY{5Ѓ_Р_яяяяkk!vNP+љrх_a|5Ѓ_Р`яяяяll!vNP+©tх_`5Ѓ_РW(яяяяkk!vNP,>uхVX|7 var streams = stack(source), open = 2, alive = true5Ѓ_РW(яяяяkk!vNP,ЕvхVX|7 var streams = stack(source), open = 3, alive = true5Ѓ_РW(яяяяkk!vNP,яwхVX|7 var streams = stack(source), open = 2, alive = true5Ѓ_РZяяяяkk!vNP- хYZ console.log('stop', open)5Ѓ_Рbяяяяjj!vNP-хab$ console.log('decrement', open)5Ѓ_Рbяяяяii!vNP-хab5Ѓ_Рlяяяяhh!vNP-хkl+ console.log('stream', stream, open)5Ѓ_Р mяяяяhh!vNP-xхlm@ console.log('element', element, open, false !== alive)5Ѓ_Р! W(яяяяhh!vNP-myхVXw7 var streams = stack(source), open = 3, alive = true5Ѓ_Р "!cяяяяhh!vNP-wzхbdw if (!open) stop(error)5Ѓ_Р!$"_яяяяhh!vNP-z|х^_< // Otherwise we just decrement number of open streams.5Ѓ_Р"%#$oяяяяgg!vNP-гхnpv }, recur)5Ѓ_Р$&%o яяяяgg!vNP-зхnpv }, func)5Ѓ_Р%'&oяяяяgg!vNP-йхnpv }, func)5Ѓ_Р&('oяяяяgg!vNP-мхnpv }, function onStop())5Ѓ_Р')(oяяяяgg!vNP-нхnqv! }, function onStop() {})5Ѓ_Р(*)oяяяяgg!vNP-пхnpw }, function onStop() {5Ѓ_Р)+*o яяяяgg!vNP-тхoqx хoqw5Ѓ_Р*,+pяяяяgg!vNP-ххoqx if ()5Ѓ_Р+-,pяяяяgg!vNP-ч}хoqx if (error)5Ѓ_Р,.-pяяяяgg!vNP.хpry хprx5Ѓ_Р-/.qяяяяgg!vNP.хpry if ()5Ѓ_Р.0/qяяяяgg!vNP.хpry if (!open)5Ѓ_Р/10qяяяяgg!vNP.~хpry if (!open) stop()5Ѓ_Р021pяяяяgg!vNP.хoqy if (error) open = 05Ѓ_Р132pяяяяgg!vNP.хoqy if (error) stop()5Ѓ_Р243pяяяяgg!vNP.хoqy if (error) stop(error)5Ѓ_Р354pяяяяgg!vNP.хoqy( if (error) returns stop(error)5Ѓ_Р465pяяяяgg!vNP.хoqy' if (error) return stop(error)5Ѓ_Р576pяяяяgg!vNP."хoqy* return error) return stop(error)5Ѓ_Р687p+яяяяgg!vNP.$хoqy+ return error ? return stop(error)5Ѓ_Р798p3яяяяgg!vNP.+хoqy3 return error ? return stop(error) : recur5Ѓ_Р8:9q яяяяgg!vNP.-хpq if (!open) stop(error)5Ѓ_Р9;:p яяяяgg!vNP.:хoqx5 return error ? return stop(error) : recur()5Ѓ_Р:<;p яяяяgg!vNP.AхoqxC return error ? return open = false, stop(error) : recur()5Ѓ_Р;=<p:яяяяgg!vNP.EЃхoqxD return error ? return (open = false, stop(error) : recur()5Ѓ_Р<>=p>яяяяgg!vNP.XхoqxE return error ? return (open = false, stop(error)) : recur()5Ѓ_Р=?>pOяяяяgg!vNP.c‚хoqxO return error ? return (open = false, stop(error)) : (open --, recur()5Ѓ_Р>@?fяяяяgg!vNP.lхef onStop(error)5Ѓ_Р?A@fяяяяff!vNP.mхefF // Otherwise we open a next stream and pipe all it's elements to5Ѓ_Р@BAfяяяяff!vNP.mхef // the reader.5Ѓ_РACBoяяяяff!vNP.pхnpu }, onStop)5Ѓ_РBDCoяяяяff!vNP.uхnpu }, function onStop())5Ѓ_РCEDoяяяяff!vNP.uхnqu }, function onStop() {})5Ѓ_РDFEoяяяяff!vNP.{хnpv }, function onStop() {5Ѓ_РEGFoяяяяff!vNP.}хoqw хoqv5Ѓ_РFHGm яяяяff!vNP.„хlnwP return error ? return (open = false, stop(error)) : (open --, recur())5Ѓ_РGIHpяяяяff!vNP.†хoqw return error 5Ѓ_РHJIpяяяяff!vNP.‡хoqw return error ? ()5Ѓ_РIKJp$яяяяff!vNP.Ќхoqw% return error ? (open = false)5Ѓ_РJLKp+яяяяff!vNP.ђхoqw- return error ? (open = false, stop())5Ѓ_РKMLp2яяяяff!vNP.®хorw2 return error ? (open = false, stop(error))5Ѓ_РLNMqяяяяff!vNP.їхprx open5Ѓ_РMONqяяяяff!vNP.Ахprx !open5Ѓ_РNPOqяяяяff!vNP.Ехprx !open ? stop()5Ѓ_РOQPqяяяяff!vNP.Йхprx !open ? stop()5Ѓ_РPRQq#яяяяff!vNP.Ьѓхprx# !open ? stop() : inl5Ѓ_РQSRXяяяяXcvNP.и…хWYx function onStop(error) {8 // If no more open streams left just return early.. if (!open || false === alive) return nilE // If stream was stopped with error we mark all streams closed. if (error) open = 0 else open --4 // If stream is no longer open we stop reader. if (!open--) stop(error) }5Ѓ_РRTSYяяяяXXvNP/ хY[m хY[l5Ѓ_РSUTZяяяяXXvNP/†хYZ function o5Ѓ_РTVUXяяяяXXvNP/TхWYl5Ѓ_РUWVXяяяяXXvNP/WхWYl func5Ѓ_РVXWXяяяяXXvNP/XхWYl func5Ѓ_РWYXXяяяяXXvNP/`хWYl function onStop()5Ѓ_РXZYXяяяяXXvNP/bхWZl function onStop() {}5Ѓ_РY[ZXяяяяXXvNP/dхXZn хXZm5Ѓ_РZ\[XяяяяXXvNP/iхWYn function onStop() {5Ѓ_Р[]\YяяяяXXvNP/nхXZn return error ? 5Ѓ_Р\^]YяяяяXXvNP/oхXZn return error ? ()5Ѓ_Р]_^Y)яяяяXXvNP/vхXZn+ return error ? (open = false, stop())5Ѓ_Р^`_W7яяяяXXvNP/‚хVXn7 var streams = stack(source), open = 0, alive = true5Ѓ_Р_a`Y яяяяXXvNP/‹хXZn0 return error ? (open = false, stop(error))5Ѓ_Р`baYяяяяXXvNP/іхX[n: return stopped ? error ? (open = false, stop(error))5Ѓ_РacbZ#яяяяXXvNP/јхY[o0 error ? (open = false, stop(error))5Ѓ_РbfcZ@яяяяXXvNP/ЗхY\o@ error ? (open = false, stopped = true, stop(error))5Ѓ_РcgdfY яяяяXXvNP/лхXZp return stopped ? nil :5Ѓ_Рfhg[ яяяяXXvNP/тхZ\p open5Ѓ_Рgih[яяяяXXvNP/ухZ\p !open5Ѓ_Рhji[яяяяXXvNP/шхZ\p !open ? stop()5Ѓ_Рilj[ яяяяXXvNP/ъхZ\p !open ? stop(error)5Ѓ_РjoklYяяяяXXvNP0‡хXZp return !stopped ? nil :5Ѓ_РlpnoZяяяяXXvNP0хY[pB error ? (open = false, stopped = true, stop(error)) :5Ѓ_Рoqp[!яяяяXXvNP0+хZ\p! !open ? stop(error) 5Ѓ_Рprq\яяяяXXvNP0Mх\^p5Ѓ_Рqsrh!яяяяXXvNP0Rхgiq! }, function onStop(error) {5Ѓ_РrtsiяяяяXXvNP0Xхhi4 return error ? (open = false, stop(error)) :5Ѓ_РsutiяяяяXXvNP0Yхhi# !open ? stop() : nil5Ѓ_РtvuiяяяяXXvNP0Zхhi })5Ѓ_Рuwvf7яяяяXXvNP0ЃхegnI return error ? (open = false, stop(error)) : (open --, recur())5Ѓ_РvxwfяяяяXXvNP0†‰хegn# return (open --, recur())5Ѓ_РwzxeяяяяXXvNP0 Њхdfn$ }, function onStop(error) {5Ѓ_Рx{yzfяяяяffvNP0юхegn2 return (open --, onStop(error), recur())5Ѓ_Рz|{fяяяяffvNP0яхegn* return ( onStop(error), recur())5Ѓ_Р{}|f яяяяffvNP1Ќхegn) return (onStop(error), recur())5Ѓ_Р|~}hяяяяffvNP1gхgin }, onStop)5Ѓ_Р}~fяяяяffvNP1mЋхegn2 return (onStop(error), open --, recur())5Ѓ_Р~ЂeяяяяffvNP1vЏхdfn }, function (error) {5Ѓ_РЃЂXяяяяffvNP1{ђхWYn function onStop(error) {5Ѓ_РЂ‚ЃWяяяяffvNP1~“хWYn5Ѓ_РЃѓ‚eяяяяggvNP7ЅхdfoH return open && false !== alive ? alive = next(element) : false5Ѓ_Р‚„ѓeяяяяggvNP7ВхdfoP return stopped open && false !== alive ? alive = next(element) : false5Ѓ_Рѓ…„eяяяяggvNP7М–хdfoQ return !stopped open && false !== alive ? alive = next(element) : false5Ѓ_Р„†…`яяяяggvNP8\х`bp х`bo5Ѓ_Р…‡†aяяяяhhvNP8_х`a console5Ѓ_Р†€‡aяяяяggvNP8`хacp хaco5Ѓ_Р‡‰€bяяяяhhvNP8cхacp console.log()5Ѓ_Р€Љ‰bяяяяhhvNP8gхacp console.log(open, )5Ѓ_Р‰‹ЉbяяяяhhvNP8jхacp console.log('open, )5Ѓ_РЉЊ‹bяяяяhhvNP8lхacp console.log('open:', )5Ѓ_Р‹ЌЊbяяяяhhvNP8o—хacp console.log('open:', )5Ѓ_РЊЋЌg яяяяhhvNP8sхgiq хgip5Ѓ_РЌЏЋhяяяяiivNP8xхgiq console.log()5Ѓ_РЋђЏhяяяяiivNP8xхgiq console.log('')5Ѓ_РЏ‘ђhяяяяiivNP8|хgiq console.log('close')5Ѓ_Рђ’‘YяяяяiivNP8‚хY[r хY[q5Ѓ_Р‘“’ZяяяяjjvNP8‡хY[r console.log()5Ѓ_Р’”“ZяяяяjjvNP8€хY[r console.log('')5Ѓ_Р“•”ZяяяяjjvNP8ЉхY[r console.log('update')5Ѓ_Р”–•bяяяяjjvNP9љхacr open ++5Ѓ_Р•–YяяяяjjvNP9њхY[s хY[r5Ѓ_Р–™—k)яяяяkkvNP9+ћхjls2 return (update(error), open --, recur())5Ѓ_Рљ™^яяяяkkvNP9Ђх]_s nil5Ѓ_Р™›љZяяяяkkvNP9ѓ хYZ open --5Ѓ_Рљњ›ZяяяяjjvNP9ЅхYZ! console.log('update', open)5Ѓ_Р›ќњbяяяяiivNP9Ахab" console.log('open:', open)5Ѓ_РњћќgяяяяhhvNP9Бўхfg console.log('close')5Ѓ_РќџћbяяяяggvNP:0хbdp хbdo5Ѓ_Рћ џcяяяяhhvNP:3хbdp console.log()5Ѓ_РџЎ cяяяяhhvNP:4хbdp console.log('')5Ѓ_Р ўЎcяяяяhhvNP:5Јхbdp console.log('>>>')5Ѓ_РЎЈў`#яяяяhhvNP;6х`bq х`bp5Ѓ_Рў¤ЈaяяяяiivNP;:¤х`bq console.log()5Ѓ_РЈҐ¤aяяяяiivNP;™Ґх`bq console.log(stream)5Ѓ_Р¤¦ҐdяяяяiivNP;ў¦хceq% console.log('>>>', element)5Ѓ_РҐ§¦hяяяяiivNP;©хhjr хhjq5Ѓ_Р¦Ё§iяяяяjjvNP;Їхhjr console.log()5Ѓ_Р§©ЁiяяяяjjvNP;Їхhjr console.log('')5Ѓ_РЁЄ©iяяяяjjvNP;і§хhjr console.log('close')5Ѓ_Р©«ЄYяяяяjjvNP;ЦхY[s хY[r5Ѓ_РЄ¬«ZяяяяkkvNP;ЩхY[s console.log()5Ѓ_Р«¬ZяяяяkkvNP;ЩхY[s console.log('')5Ѓ_Р¬®ZяяяяkkvNP;ЬЁхY[s console.log('sync: ')5Ѓ_РЇ®kяяяяkkvNP<]хjls) return (update(error), recur())5Ѓ_Р®°ЇkяяяяkkvNP<^хjls return (, recur())5Ѓ_РЇ±°kяяяяkkvNP<_©хjls return (recur())5Ѓ_Р°І±Z!яяяяkkvNP)хu хt5Ѓ_Р¶ё·яяяяmmvNP>3хu return filter()5Ѓ_Р·№ёяяяяmmvNP>6хu return filter(function())5Ѓ_Рёє№яяяяmmvNP>7хu return filter(function() {})5Ѓ_Р№»єяяяяnnvNP>:хv return filter(function() {5Ѓ_Рєј»яяяяnnvNP><хw хv5Ѓ_Р»ЅјяяяяoovNP>Eхw stop5Ѓ_РјѕЅяяяяoovNP>‘хx хw5Ѓ_РЅїѕяяяяppvNP>љхx return start < index5Ѓ_РѕАїяяяяppvNP>¤хx return index < stream5Ѓ_РїБАяяяяppvNP>©хx return index < start5Ѓ_РАВБяяяяppvNP>Їхx return index++ < start5Ѓ_РБГВяяяяppvNP>±®хx return ++index++ < start5Ѓ_РВДГяяяяppvNP>єЇхx return ++index < start5Ѓ_РГЕД яяяяppvNP>Ихx return ++index <= start5Ѓ_РДЖЕяяяяppvNP>Мхx return index <= start5Ѓ_РЕЗЖяяяяppvNP>Нхx return index++ <= start5Ѓ_РЖИЗяяяяppvNP>Пхx return index ++ <= start5Ѓ_РЗЙИяяяяppvNP>Ххx })5Ѓ_РИКЙяяяяppvNP>вхx }, source)5Ѓ_РЙМК яяяяppvNP>мхx# return filter(function(element) {5Ѓ_РКНЛМ яяяяppvNP>ххx# return filter(function(element) {5Ѓ_РМОНяяяяppvNP>ьхx( return take(filter(function(element) {5Ѓ_РНПОяяяяqqvNP?хy return take(function () {5Ѓ_РОРПяяяяqqvNP? хz хy5Ѓ_РПСРяяяя#vNP?хz& return function stream(next, stop) { var index = -1, interrupt( source(function onElement(element) {D // Skip elements until we reach start of the extraction range.& if (++index < start) return trueA // If index is in range we want to extract from then yield.0 if (index < end) interrupt = next(element)E // If this is last element we stop stream and interrupt reading; return index + 1 >= end ? (stop(), false) : interrupt }, stop = limit(stop)) }5Ѓ_РРТСяяяяvNP?°х 5Ѓ_РСУТяяяяvNP?Aхo return index ++ < start5Ѓ_РТФУяяяяvNP?Dхo return index ++ > start5Ѓ_РУХФяяяяvNP?Gхo return ++index ++ > start5Ѓ_РФЦХяяяяvNP?J±хo return ++index > start5Ѓ_РХЧЦ яяяяvNP?Mхo return ++index >= start5Ѓ_РЦШЧяяяяvNP?Pхo return index >= start5Ѓ_РЧЩШяяяяvNP?Rхo return index++ >= start5Ѓ_РШЪЩяяяяvNP?Sхo return index+ + >= start5Ѓ_РЩЫЪяяяяvNP?Sхo return index++ >= start5Ѓ_РЪЬЫ яяяяvNP?UІхo return ++index < end5Ѓ_РЫаЬяяяяvNP?i¶хo }, source)5Ѓ_РЬбЮаяяяяvNP?Іёхo return index ++ >= start5Ѓ_РавбяяяяvNP?Вхo return index ++ > start5Ѓ_РбгвяяяяvNP?Ж№хo return ++ index ++ > start5Ѓ_РвдгяяяяvNP?Чхo return ++ index > start5Ѓ_РгедяяяяvNP?Щхo return index > start5Ѓ_РджеяяяяvNP?Ьхo return index < start5Ѓ_РезжяяяяvNP?Эхo return index++ < start5Ѓ_РжизяяяяvNP?Яхo return index ++ < start5Ѓ_РзйияяяяvNP?бхo return start5Ѓ_РикйяяяяvNP?охo return ++ index < end5Ѓ_РймкяяяяvNP?сјхo return end5Ѓ_РкнлмяяяяvNP@@Ѕхp var index = 0хp хo5Ѓ_Рмон яяяяvNP@zхo" return take(function (element) {5Ѓ_РнрояяяяvNP@€хp return end >= index ++5Ѓ_РотпряяяяvNP@Џхp return end >= index ++ }, filter(function(element) { return start <= index ++ }, source))5Ѓ_РрустяяяяvNP@љхp }, source))5Ѓ_РтфуяяяяvNP@љхp }, source))()5Ѓ_РухфяяяяvNP@џхp }, source))(next, stopped)5Ѓ_РфцхяяяяvNP@ хq хp5Ѓ_РхчцяяяяvNP@Ґхq var index = 05Ѓ_РцшчяяяяvNP@Ґх 5Ѓ_РчэшяяяяvNP@¦Юхq хp5Ѓ_РшюыэяяяяvNPAAхq }, stop)5Ѓ_РэяюяяяяvNPAHДхq }, stop = limit())5Ѓ_РюяяяяяvNPAДхq return end >= index ++5Ѓ_РяяяяяvNPAЖЛхq return end >= index5Ѓ_Р яяяяvNPBUОхq return end >= ++ index5Ѓ_Р яяяяvNPB¦Пхq return end >= index5Ѓ_Р яяяяvNPB№хq return end >= index + 15Ѓ_Р яяяяvNPBѕСхq return end < index + 15Ѓ_РяяяяvNPBКхq return end < index5Ѓ_РяяяяvNPBМхq return index5Ѓ_РяяяяvNPBПТхq return index < ended5Ѓ_РяяяяvNPBХШхq return index < end5Ѓ_РяяяяvNPDхq return index <= end5Ѓ_РяяяяvNPD"хq return index <= end ? 5Ѓ_РяяяяvNPD#хq return index < end ? 5Ѓ_РяяяяvNPDJх take(function (element) {5Ѓ_РяяяяvNPDKх0 return index < end ? true : index === end 5Ѓ_РяяяяvNPDMхo! }, filter(function(element) {5Ѓ_РяяяяvNPDYхo }, source))(next, stop)5Ѓ_Р яяяяvNPD\хo }, source)(next, stop)5Ѓ_Р! "яяяяvNPDaхo. }, source)(function onElement()next, stop)5Ѓ_Р "!+яяяяvNPDdхo6 }, source)(function onElement(elements)next, stop)5Ѓ_Р!#"яяяяvNPDpхp next, stop)5Ѓ_Р"$#яяяяvNPDyхp }, stop = limit())5Ѓ_Р#%$яяяяvNPD|хp5Ѓ_Р$&%яяяяvNPD~хq5Ѓ_Р%'&яяяяvNPD‘хq index === end ? stop()5Ѓ_Р&('$яяяяvNPD“хq% index === end ? stop() : next()5Ѓ_Р'*(*яяяяvNPD–Ъхq- }, source)(function onElement(elements) {5Ѓ_Р(3)*яяяяvNPDИхq, index === end ? stop() : next(element)5Ѓ_Р*4+3яяяяvNPDкхq* index < end ? stop() : next(element)5Ѓ_Р354яяяяvNPDмхq$ index < end ? : next(element)5Ѓ_Р4V5яяяяvNPDюмхq! index < end ? next(element)5Ѓ_Р5W6VяяяяvNPGхq next(element)5Ѓ_РVXWяяяяvNPGЃхq return next(element)5Ѓ_РWѓX3яяяяvNPG‘ыхq3 return next(element), index === stop ? stop()5Ѓ_РX„Zѓ3яяяяvNPIъьхq9 return next(element), index === stop ? stop() : nil5Ѓ_Рѓ…„-яяяяvNPJхq@ return next(element), index === stop ? stop(), false : nil5Ѓ_Р„†…;яяяяvNPJ эхqA return next(element), index === stop ? (stop(), false : nil5Ѓ_Р…‡†*яяяяvNPJюхqB return next(element), index === stop ? (stop(), false) : nil5Ѓ_Р†ў‡яяяяvNPJ5хq% return function steam(next, stop) {5Ѓ_Р‡ЈЎў` яяяяvNPмх_aq" console.log('open stream')5Ѓ_Рў¤Ј`яяяяvNPмљх_aq console.log('open')5Ѓ_РЈҐ¤hяяяя`&`vNPмўхgiq console.log('close')5Ѓ_Р¤¦Ґcяяяя`&`vNPмЁхbdq' console.log('yield', element)5Ѓ_РҐ§¦aяяяя`&`vNPн х`bq open += 25Ѓ_Р¦Ё§aяяяя`&`vNPнх`bq open +++5Ѓ_Р§©ЁXяяяяXXvNPнхWYq open --5Ѓ_РЁЄ©XяяяяXXvNPнхWX 5Ѓ_Р©«ЄW!яяяяXXvNPнхVXp" console.log('sync: ', error)5Ѓ_РЄ¬«h(яяяяXXvNPн!хgip) return (recur(), update(error))5Ѓ_Р«¬h*яяяяh0h*v*NPн1хgip2 return (recur(), update(error), open --)5Ѓ_Р¬®h*яяяяh0h*v*NPн1хgip+ return (recur(), update(error), )5Ѓ_РЇ®hяяяяh0h*v*NPн3хgip) return (recur(), update(error))5Ѓ_Р®°Їhяяяяhh!v!NPн:хgip2 return (open --, recur(), update(error))5Ѓ_РЇ±°hяяяяhh!v!NPн;хgip+ return (open --, , update(error))5Ѓ_Р°І±h(яяяяhh!v!NPн=хgip) return (open --, update(error))5Ѓ_Р±іІT)яяяяhh!v!NPнFхSUpH var streams = stack(source), open = 1, alive = true, stopped = false5Ѓ_РІґіhяяяяhhvNPнgхgip2 return (open --, update(error), recur())5Ѓ_РіµґhяяяяhhvNPнhхgip+ return (, update(error), recur())5Ѓ_Рґ¶µh!яяяяhhvNPнkхgip) return (update(error), recur())5Ѓ_Рµ·¶h!яяяяh)h!v!NPн{хgip2 return (update(error), open --, recur())5Ѓ_Р¶ё·h(яяяяh)h!v!NPн} хgip) return (update(error), recur())5Ѓ_Р·№ёh3яяяяh)h!v!NPн!хgip4 return (update(error), recur(), open --, )5Ѓ_Рёє№T(яяяяh)h!v!NPн»"хSUpH var streams = stack(source), open = 0, alive = true, stopped = false5Ѓ_Р№»єh*яяяяh*h0v0NPнЭхgip2 return (update(error), recur(), open --)5Ѓ_Рєј»h*яяяяh*h0v0NPнЭ#хgip+ return (update(error), recur(), )5Ѓ_Р»ЅјVяяяяh*h0v0NPнв$хVXq хVXp5Ѓ_РјѕЅ[яяяяi*i0v0NPнщ%хZ\q nil5Ѓ_РЅїѕWяяяяi*i0v0NPнэ&хVW open --5Ѓ_РѕАї_яяяя_'_vNPох^`p( console.log('open', stream.name)5Ѓ_РїБА_яяяя_'_vNPо х^_ 5Ѓ_РАВБ_яяяя_'_vNPо х_ap х_ao5Ѓ_РБГВ`'яяяя_'_vNPо!х_ap( console.log('open', stream.name)5Ѓ_РВДГ`*яяяя_'_vNPо$'х_ap+ console.log('open', stream.name, 3)5Ѓ_РГЕДg*яяяя_'_vNPо)(хfhp+ console.log('close', stream.name)5Ѓ_РДЖЕVяяяя_'_vNPо[хUWp function update(error) {5Ѓ_РЕЗЖVяяяя_'_vNPо^хUWp function onStream(error) {5Ѓ_РЖИЗVяяяяSVvNPо`хUWp function onS(error) {5Ѓ_РЗЙИjяяяяVV v NPоgхikp }, update)5Ѓ_РИКЙhяяяяVV v NPоj)хgip) return (update(error), recur())5Ѓ_РЙЛКfяяяяVV v NPоq*хegp$ }, function onStop(error) {5Ѓ_РКМЛWяяяяVV v NPоѕ+хVXp( console.log('sync: ', error, open)5Ѓ_РЛНМWяяяяVV v NPоИ-хVXp* console.log('onStop: ', error, open)5Ѓ_РМОНjяяяяVV v NPп-хikp }, onStop)5Ѓ_РНПОjяяяяVV v NPп1хikp }, function stopped())5Ѓ_РОРПjяяяяVV v NPп2хilp }, function stopped() {})5Ѓ_РПСРjяяяяVV v NPп3хjlr хjlq5Ѓ_РРТСjяяяяVV v NPп9хikr }, function stopped() {5Ѓ_РСУТkяяяяVV v NPп;хjlr console.log()5Ѓ_РТФУkяяяяVV v NPп=хjlr console.log('')5Ѓ_РУХФkяяяяVV v NPпAхjlr console.log('stop-head')5Ѓ_РФЦХkяяяяVV v NPпDхkms хkmr5Ѓ_РХЧЦlяяяяVV v NPпGхkms onStop()5Ѓ_РЦШЧlяяяяVV v NPпHхlnt хlns5Ѓ_РЧЩШmяяяяVV v NPпLхlnt console.log()5Ѓ_РШЪЩmяяяяVV v NPпLхlnt console.log('')5Ѓ_РЩЫЪmяяяяVV v NPпQ.хlnt console.log('stop-head')5Ѓ_РЪЬЫhяяяяVV v NPпaхgit) return (onStop(error), recur())5Ѓ_РЫЭЬhяяяяVV v NPпeхgit" (onStop(error), recur())5Ѓ_РЬЮЭhяяяяVV v NPпfхgjt! onStop(error), recur())5Ѓ_РЭЯЮiяяяяVV v NPпhхhju recur())5Ѓ_РЮаЯiяяяяVV v NPпhхikv хiku5Ѓ_РЯбаjяяяяVV v NPпmхikv console.log()5Ѓ_РавбjяяяяVV v NPпnхikv console.log('')5Ѓ_РбгвjяяяяVV v NPпp/хikv console.log('#')5Ѓ_РвдгY-яяяяVV v NPпќхXZvK error || !open ? (open = false, stopped = true, stop(error)) :5Ѓ_РгедYяяяяVV v NPпћ2хXZv= error || !open ? (stopped = true, stop(error)) :5Ѓ_РджеYяяяяVV v NPп°3хXZv< error || !open ? stopped = true, stop(error)) :5Ѓ_РезжoяяяяVV v NPпЛхnpv console.log('#', open)5Ѓ_РжизjяяяяVV v NPпР4хikv console.log('#', open)5Ѓ_РзйиlяяяяVV v NPр'5хkmv" }, function stopped(error) {5Ѓ_Рикй7яяяяVV v NPрЛхv†!(typeof define !== "function" ? function($){ $(require, exports, module); } : define)(function(require, exports, module, undefined) {5Ѓ_РйлкEяяяяVV v NPрОхvѓ!(typeof define !== "function" ? function($){ $(null, exports, module); } : define)(function(require, exports, module, undefined) {5Ѓ_Ркмл=яяяяVV v NPрСхv{!(typeof define !== "function" ? function($){ $(null, exports); } : define)(function(require, exports, module, undefined) {5Ѓ_РлнмJяяяяVV v NPрихv‰!(typeof define !== "function" ? function($){ $(null, typeof exports !== ''); } : define)(function(require, exports, module, undefined) {5Ѓ_РмонUяяяяVV v NPрпхv’!(typeof define !== "function" ? function($){ $(null, typeof exports !== 'undefined'); } : define)(function(require, exports, module, undefined) {5Ѓ_РнпоUяяяяVV v NPррхv“!(typeof define !== "function" ? function($){ $(null, typeof exports !== 'undefined') ; } : define)(function(require, exports, module, undefined) {5Ѓ_Рорп=яяяяVV v NPрфхv”!(typeof define !== "function" ? function($){ $(null, typeof exports !== 'undefined') ; } : define)(function(require, exports, module, undefined) {5Ѓ_РпсрDяяяяVV v NPрцхv”!(typeof define !== "function" ? function($){ $(null, typeof(exports !== 'undefined') ; } : define)(function(require, exports, module, undefined) {5Ѓ_РртсFяяяяVV v NPрщхv•!(typeof define !== "function" ? function($){ $(null, typeof(exports) !== 'undefined') ; } : define)(function(require, exports, module, undefined) {5Ѓ_РсутVяяяяVV v NPряхv•!(typeof define !== "function" ? function($){ $(null, typeof(exports) === 'undefined') ; } : define)(function(require, exports, module, undefined) {5Ѓ_Ртфу^яяяяVV v NPсхvќ!(typeof define !== "function" ? function($){ $(null, typeof(exports) === 'undefined' ? window ; } : define)(function(require, exports, module, undefined) {5Ѓ_РухфhяяяяVV v NPс&хvҐ!(typeof define !== "function" ? function($){ $(null, typeof(exports) === 'undefined' ? this : exports ; } : define)(function(require, exports, module, undefined) {5Ѓ_РфцхfяяяяVV v NPс(хvў!(typeof define !== "function" ? function($){ $(null, typeof(exports) === 'undefined' ? this : export; } : define)(function(require, exports, module, undefined) {5Ѓ_РхчцfяяяяVV v NPс*хvў!(typeof define !== "function" ? function($){ $(null, typeof(exports) === 'undefined' ? this : export, } : define)(function(require, exports, module, undefined) {5Ѓ_РцшчћяяяяVV v NPс.хvЎ!(typeof define !== "function" ? function($){ $(null, typeof(exports) === 'undefined' ? this : export } : define)(function(require, exports, module, undefined) {5Ѓ_Рчщш4яяяяVV v NPс4хvЋ!(typeof define !== "function" ? function($){ $(null, typeof(exports) === 'undefined' ? this : export } : define)(function(require, exports) {5Ѓ_Ршъщ7яяяяVV v NPс7хv’!(typeof define !== "function" ? function($){ $(typeof(), typeof(exports) === 'undefined' ? this : export } : define)(function(require, exports) {5Ѓ_Рщыъ?яяяяVV v NPс:хv™!(typeof define !== "function" ? function($){ $(typeof(require), typeof(exports) === 'undefined' ? this : export } : define)(function(require, exports) {5Ѓ_РъьыEяяяяVV v NPс=хv !(typeof define !== "function" ? function($){ $(typeof(require) === '', typeof(exports) === 'undefined' ? this : export } : define)(function(require, exports) {5Ѓ_РыэьOяяяяVV v NPс?хv©!(typeof define !== "function" ? function($){ $(typeof(require) === 'undefined', typeof(exports) === 'undefined' ? this : export } : define)(function(require, exports) {5Ѓ_РьюэQяяяяQ@vUNPсDхv«!(typeof define !== "function" ? function($){ $(typeof(require) === 'undefined' ?, typeof(exports) === 'undefined' ? this : export } : define)(function(require, exports) {5Ѓ_РэяюQяяяяQ@vUNPсSхv¬!(typeof define !== "function" ? function($){ $(typeof(require) === 'undefined' ? , typeof(exports) === 'undefined' ? this : export } : define)(function(require, exports) {5Ѓ_Рюя\яяяяQ@vUNPсWхv·!(typeof define !== "function" ? function($){ $(typeof(require) === 'undefined' ? function() , typeof(exports) === 'undefined' ? this : export } : define)(function(require, exports) {5Ѓ_Ря^яяяяQ@vUNPсXхvє!(typeof define !== "function" ? function($){ $(typeof(require) === 'undefined' ? function() {} , typeof(exports) === 'undefined' ? this : export } : define)(function(require, exports) {5Ѓ_РkяяяяQ@vUNPс]хvИ!(typeof define !== "function" ? function($){ $(typeof(require) === 'undefined' ? function() { throw Error()} , typeof(exports) === 'undefined' ? this : export } : define)(function(require, exports) {5Ѓ_РlяяяяQ@vUNPс]хvК!(typeof define !== "function" ? function($){ $(typeof(require) === 'undefined' ? function() { throw Error('')} , typeof(exports) === 'undefined' ? this : export } : define)(function(require, exports) {5Ѓ_РЃяяяяQ@vUNPсeхvЭ!(typeof define !== "function" ? function($){ $(typeof(require) === 'undefined' ? function() { throw Error('require unsupported')} , typeof(exports) === 'undefined' ? this : export } : define)(function(require, exports) {5Ѓ_РЃяяяяQ@vUNPсgхvЮ!(typeof define !== "function" ? function($){ $(typeof(require) === 'undefined' ? function() { throw Error('require unsupported') } , typeof(exports) === 'undefined' ? this : export } : define)(function(require, exports) {5Ѓ_Р‚яяяяQ@vUNPсlхvЯ!(typeof define !== "function" ? function($){ $(typeof(require) === 'undefined' ? function() { throw Error('require unsupported'); } , typeof(exports) === 'undefined' ? this : export } : define)(function(require, exports) {5Ѓ_РѓяяяяQ@vUNPсmхvЮ!(typeof define !== "function" ? function($){ $(typeof(require) === 'undefined' ? function() { throw Error('require unsupported') } , typeof(exports) === 'undefined' ? this : export } : define)(function(require, exports) {5Ѓ_РїяяяяQ@vUNPс„хvи!(typeof define !== "function" ? function($){ $(typeof(require) === 'undefined' ? function() { throw Error('require unsupported') } : require , typeof(exports) === 'undefined' ? this : export } : define)(function(require, exports) {5Ѓ_Р АяяяяQ@vUNPс’7хvй!(typeof define !== "function" ? function($){ $(typeof(require) === 'undefined' ? function() { throw Error('require unsupported') } : require , typeof(exports) === 'undefined' ? this : export) } : define)(function(require, exports) {5Ѓ_Р яяяяvNPт хvк!(typeof define !== "function" ? function($){ $(typeof(require) === 'undefined' ? function() { throw Error('require unsupported') } : require , typeof(exports) === 'undefined' ? this : export); } : define)(function(require, exports) {5Ѓ_Р яяяяvNPтхvк!(typeof(define !== "function" ? function($){ $(typeof(require) === 'undefined' ? function() { throw Error('require unsupported') } : require , typeof(exports) === 'undefined' ? this : export); } : define)(function(require, exports) {5Ѓ_Р яяяяvNPтхvл!(typeof(define) !== "function" ? function($){ $(typeof(require) === 'undefined' ? function() { throw Error('require unsupported') } : require , typeof(exports) === 'undefined' ? this : export); } : define)(function(require, exports) {5Ѓ_РяяяяvNPт8хvл!(typeof(define) === "function" ? function($){ $(typeof(require) === 'undefined' ? function() { throw Error('require unsupported') } : require , typeof(exports) === 'undefined' ? this : export); } : define)(function(require, exports) {5Ѓ_РAяяяяvNPтхvл!(typeof(define) !== "function" ? function($){ $(typeof(require) === 'undefined' ? function() { throw Error('require unsupported') } : require , typeof(exports) === 'undefined' ? this : export); } : define)(function(require, exports) {5Ѓ_РOяяяяvNPт хvл!(typeof(define) !== "function" ? function($){ $(typeof(require) !== 'undefined' ? function() { throw Error('require unsupported') } : require , typeof(exports) === 'undefined' ? this : export); } : define)(function(require, exports) {5Ѓ_РЃяяяяvNPт,хvк!(typeof(define) !== "function" ? function($){ $(typeof(require) !== 'function' ? function() { throw Error('require unsupported') } : require , typeof(exports) === 'undefined' ? this : export); } : define)(function(require, exports) {5Ѓ_РRяяяяvNPт0хvл!(typeof(define) !== "function" ? function($){ $(typeof(require) !== 'function' ? function() { throw Error('require unsupported'); } : require , typeof(exports) === 'undefined' ? this : export); } : define)(function(require, exports) {5Ѓ_Р…яяяяvNPт6хvм!(typeof(define) !== "function" ? function($){ $(typeof(require) !== 'function' ? (function() { throw Error('require unsupported'); } : require , typeof(exports) === 'undefined' ? this : export); } : define)(function(require, exports) {5Ѓ_Р‘яяяяvNPт9хvн!(typeof(define) !== "function" ? function($){ $(typeof(require) !== 'function' ? (function() { throw Error('require unsupported'); }) : require , typeof(exports) === 'undefined' ? this : export); } : define)(function(require, exports) {5Ѓ_РБяяяяНvНNPт}9хvм!(typeof(define) !== "function" ? function($){ $(typeof(require) !== 'function' ? (function() { throw Error('require unsupported'); }) : require, typeof(exports) === 'undefined' ? this : export); } : define)(function(require, exports) {5Ѓ_Р[яяяяvVNR@бх[]w х[]v5Ѓ_Р\яяяяwVNR@хх[]w function pipeStream()5Ѓ_Р\яяяяwVNR@ьх[]w function pipeStream(stream)5Ѓ_Р\!яяяяwVNR@эх[^w" function pipeStream(stream) {}5Ѓ_Р\яяяяxVNR@ях\^y х\^x5Ѓ_Р] яяяяyVNRAх\^y stream()5Ѓ_Р]яяяяyVNRAх\^y stream(next, )5Ѓ_Р]яяяяyVNRAх\^y stream(next, function)5Ѓ_Р ]яяяяyVNRAх\^y stream(next, function)5Ѓ_Р! ]$яяяяyVNRAх\^y% stream(next, function onStop())5Ѓ_Р "!]&яяяяyVNRAх\_y( stream(next, function onStop() {})5Ѓ_Р!#"]#яяяяzVNRAх\^z& stream(next, function onStop() {5Ѓ_Р"$#]'яяяяzVNRA х]_{ х]_z5Ѓ_Р#%$^яяяя{VNRA"х]_{ if ()5Ѓ_Р$&%^яяяя{VNRA#х]_{ if (error)5Ѓ_Р%'&^яяяя{VNRA'х]_{ if (error) stop()5Ѓ_Р&('^яяяя{VNRA*х^`| х^`{5Ѓ_Р')(_яяяя|VNRA3х^`| else pipeStream()5Ѓ_Р(*)_яяяя|VNRA5х^`| else pipeStream(head())5Ѓ_Р)+*_яяяя_$_vNRA;х^`|& else pipeStream(head(streams))5Ѓ_Р*,+_ яяяя_$_vNRA<х^`| else pipeStream()5Ѓ_Р+-,_яяяя_$_vNRA?х^`|& else head(streams)pipeStream()5Ѓ_Р,.-_'яяяя_$_vNRA@х^`|' else head(streams)(pipeStream()5Ѓ_Р-/.\яяяя_$_vNRAbх[\! function pipeStream(stream) {5Ѓ_Р.0/\яяяя^$^vNRAbх[\+ stream(next, function onStop(error) {5Ѓ_Р/10\яяяя]$]vNRAcх[\ if (error) stop(error)5Ѓ_Р021\яяяя\$\vNRAcх[\4 else head(streams)(pipeStream, onStreamStop)5Ѓ_Р132\яяяя\$\vNRAdх[\ })5Ѓ_Р243\яяяя\$\vNRAd:х[\ }5Ѓ_Р354_яяяя\$\vNRAn=х^`v open ++5Ѓ_Р465Z яяяя\$\vNRAДхYZ open --5Ѓ_Р576Wяяяя[$[vNRAЕ>хWYv хWYu5Ѓ_Р687Z=яяяя\$\vNRAП?хY[v= error || !open ? (stopped = true, stop(error)) :5Ѓ_Р798fяяяя\$\vNRBхegv% }, function stopped(error) {5Ѓ_Р8:9g яяяя\$\vNRBхfg1 console.log('close', stream.name, open)5Ѓ_Р9;:g яяяя\$\vNRBхfiu onStop(error)5Ѓ_Р:<;h яяяя\$\vNRB хhjw хhjv5Ѓ_Р;=<g яяяя\$\vNRB"хgix хgiw5Ѓ_Р<>=fяяяя\$\vNRB'хfhy хfhx5Ѓ_Р=?>gяяяя\$\vNRB(хfhy if ()5Ѓ_Р>@?gяяяя\$\vNRB*хfhy if (stopped)5Ѓ_Р?A@hяяяя\$\vNRB:хgiy if (error) {5Ѓ_Р@BAg яяяя\$\vNRB<хfg! if (stopped) return nil5Ѓ_РACBgяяяя\$\vNRB=хfhx if (error) 5Ѓ_РBDCgяяяя\$\vNRB@хfhx if (error) stop()5Ѓ_РCEDhяяяя\$\vNRBBхgh stopped = 5Ѓ_РDFEh яяяя\$\vNRBBхgh onStop(error)5Ѓ_РEGFh яяяя\$\vNRBCхgh }5Ѓ_РFHGg яяяя\$\vNRBEхgiv хgiu5Ѓ_РGIHfяяяя\$\vNRBLхfhw хfhv5Ѓ_РHJI_яяяя\$\vNRBQх^`w open += 25Ѓ_РIKJiяяяя\$\vNRBYхhjw else 5Ѓ_РJLKiяяяя\$\vNRBYхhjw else ()5Ѓ_РKMLj яяяя\$\vNRBbхij recur()5Ѓ_РLNMj яяяя\$\vNRBcхij& console.log('stream#', open)5Ѓ_РMONiяяяя\$\vNRBeхhju else (recur)5Ѓ_РNPOiяяяя\$\vNRBl@хhju else recur()5Ѓ_РOQP_яяяя\$\vNRBwAх^`u open ++5Ѓ_РPRQT(яяяя\$\vNRB~BхSUuH var streams = stack(source), open = 1, alive = true, stopped = false5Ѓ_РQSRk!яяяя\$\vNRB’хjlu! }, function stoppe(error) {5Ѓ_РRTSkяяяя\$\vNRB–хjlu }, function onStop()5Ѓ_РSUTkяяяя\$\vNRB—хjlu }, function onStop(error)5Ѓ_РTVUk"яяяя\$\vNRBхjlu" }, function onStop(error) {}5Ѓ_РUWV\яяяя\$\vNRBќх\^vх\^u5Ѓ_РVXW]яяяя\$\vNRBҐх\^v stop = limit()5Ѓ_РWYXVяяяя\$\vNRBЄхUV function onStop(error) {5Ѓ_РXZYVяяяя[$[vNRBЄхUV+ console.log(' onStop: ', error, open)5Ѓ_РY[ZVяяяяZ$ZvNRB«хUV open --5Ѓ_РZ\[VяяяяY$YvNRB«хUV return stopped ? nil :5Ѓ_Р[]\V яяяяX$XvNRB«хUVA error || !open ? (stopped = true, stop(error)) : nil5Ѓ_Р\^]VяяяяW$WvNRB¬хUV }5Ѓ_Р]_^VяяяяV$VvNRB¬CхUV5Ѓ_Р^`_fяяяяV$VvNRB±хef console.log('stop-head')5Ѓ_Р_a`fяяяяV$VvNRB±хef onStop(error)5Ѓ_Р`bafяяяяV$VvNRBІхef" console.log('head#', open)5Ѓ_РacbeяяяяV$VvNRBІDхegm хegl5Ѓ_РbdcfяяяяV$VvNRBјхfhn хfhm5Ѓ_РcedgяяяяV$VvNRBЅхfhn if ()5Ѓ_РdfegяяяяV$VvNRBїхfhn if (error)5Ѓ_РegfgяяяяV$VvNRBАхfhn if (error) stop()5Ѓ_РfhggяяяяV$VvNRBБхgio хgin5Ѓ_РgihhяяяяV$VvNRBЕхgio else if ()5Ѓ_РhjihяяяяV$VvNRBРEхgio else if (!open)5Ѓ_РikjcяяяяV$VvNRBШхcep хceo5Ѓ_РjlkdяяяяV$VvNRBЬхcep else ()5Ѓ_РkmldяяяяV$VvNRBахcep else (stop())5Ѓ_РlnmdяяяяV$VvNRBаGхcep else stop())5Ѓ_РmonX.яяяяV$VvNRC?хXZq хXZp5Ѓ_РnpoYяяяяV$VvNRCCHхXY con5Ѓ_РoqpZяяяяV$VvNRCIIхY[p. console.log('open', stream.name, open)5Ѓ_РprqaяяяяZZ0v0NRCRхacq хacp5Ѓ_Рqsrb2яяяяZZ0v0NRCTJхacq3 console.log(' open', stream.name, open)5Ѓ_РrtshяяяяZZ0v0NRCWхhjr хhjq5Ѓ_РsutiяяяяZZ0v0NRC[хhjr1 console.log(' open', stream.name, open)5Ѓ_РtvuiяяяяZZ0v0NRC\хhjr4 console.log(' closure', stream.name, open)5Ѓ_РuwvbяяяяZZ0v0NRC_Kхacr3 console.log(' open', stream.name, open)5Ѓ_РvxwT'яяяяZZ0v0NRC…хSUrH var streams = stack(source), open = 0, alive = true, stopped = false5Ѓ_РwzxT)яяяяZZ0v0NRC‡LхSUrH var streams = stack(source), open = 0, alive = true, stopped = false5Ѓ_Рx{yz\яяяяZZ0v0NRCЬх[]r* console.log(' yield', element)5Ѓ_Рz|{ZяяяяZZ0v0NRCЮхY[r1 console.log(' open', stream.name, open)5Ѓ_Р{}|ZяяяяZZ0v0NRCахY[r2 console.log(' +open', stream.name, open)5Ѓ_Р|~}\яяяяZZ0v0NRCдх[]r, console.log(' yield', element)5Ѓ_Р}~\яяяяZZ0v0NRCих[]r. console.log(' |- yield', element)5Ѓ_Р~ЃbяяяяZZ0v0NRCнхacr4 console.log(' close', stream.name, open)5Ѓ_Р‚ЂЃiяяяяZZ0v0NRCъхhjr2 console.log(' close', stream.name, open)5Ѓ_РЃѓ‚iяяяяZZ0v0NRCьMхhjr4 console.log(' _ close', stream.name, open)5Ѓ_Р‚„ѓ\яяяяZZ0v0NRDNх[]r, console.log(' |- yield', element)5Ѓ_Рѓ†„bяяяяZZ0v0NRD>Pхacr6 console.log(' - close', stream.name, open)5Ѓ_Р„‡…†_7яяяяZZ0v0NRE{Qх^arT return !stopped && open && false !== alive ? alive = next(element) : false5Ѓ_Р†€‡YяяяяZZ0v0NREєRхXZs open += 25Ѓ_Р‡‰€T)яяяяZZ0v0NREАSхSUsH var streams = stack(source), open = 1, alive = true, stopped = false5Ѓ_Р€‹‰iяяяяZZ0v0NREИVхhi open --5Ѓ_Р‰ЊЉ‹f яяяяZZ0v0NREыхef else stop()5Ѓ_Р‹ЌЊeяяяяZZ0v0NREьWхdfq else if (open) recur()5Ѓ_РЊЏЌeяяяяZZ0v0NRFXхdfq else (open) recur()5Ѓ_РЌђЋЏh яяяяh h2v2NRF‰Yхgiq4 console.log(' - close', stream.name, open)5Ѓ_РЏ‘ђhяяяяh h2v2NRF™Zхgiq! console.log(' - close')5Ѓ_Рђ’‘cяяяяh h2v2NRFћ[хbdq6 console.log(' @ close', stream.name, open)5Ѓ_Р‘“’\яяяяh h2v2NRF·\х[]q- console.log(' |- yield', element)5Ѓ_Р’”“Zяяяяh h2v2NRFѕхZ\r хZ\q5Ѓ_Р“•”[яяяяi i2v2NRFБхZ\r console.log()5Ѓ_Р”–•[яяяяi i2v2NRFВ]хZ\r console.log('')5Ѓ_Р•—–[яяяяi i2v2NRFЗхZ\r console.log(stream.name)5Ѓ_Р–—[яяяяi i2v2NRFМхZ\r' console.log(' + 'stream.name)5Ѓ_Р—™[яяяяi i2v2NRFН^хZ\r) console.log(' + 'stream.name)5Ѓ_Рљ™ZяяяяZZ,v,NRFФ_хY[r3 console.log(' + open', stream.name, open)5Ѓ_Р™›љZяяяяZZ,v,NRFЦ`хY[r% console.log(' + open' open)5Ѓ_Рљњ›ZяяяяZZ,v,NRFбaхY[r& console.log(' + open', open)5Ѓ_Р›ќњiяяяяZZ,v,NRFххhjr! console.log(' < close')5Ѓ_РњћќiяяяяZZ,v,NRFчbхhjr console.log(' < ')5Ѓ_РќџћiяяяяZZ,v,NRGcхhjr" console.log(' < ', open)5Ѓ_Рћ џdяяяяZZ,v,NRGхcer6 console.log(' - close', stream.name, open)5Ѓ_РџЎ d#яяяяZZ,v,NRGхcer8 console.log(' - close', stream.name, open)5Ѓ_Р ўЎd2яяяяZZ,v,NRGeхcer3 console.log(' - ', stream.name, open)5Ѓ_РЎЈў]$яяяяZZ,v,NRGfх\^r/ console.log(' |- yield', element)5Ѓ_Рў¤ЈZ яяяяZZ,v,NRGGхY[r! console.log(' >', open)5Ѓ_РЈҐ¤i яяяяZZ,v,NRGKgхhjr! console.log(' <', open)5Ѓ_Р¤¦ҐWяяяяZZ,v,NRGќхWYs хWYr5Ѓ_РҐ§¦Xяяяя[[,v,NRGЎхWYs console.log()5Ѓ_Р¦Ё§Xяяяя[[,v,NRGўhхWYs console.log('')5Ѓ_Р§©ЁYяяяя[[,v,NRGЧхY[t хY[s5Ѓ_РЁЄ©Zяяяя\\,v,NRGЩхY[t console.log()5Ѓ_Р©«ЄZяяяя\\,v,NRGЩiхY[t console.log('')5Ѓ_РЄ¬«Xяяяя\\,v,NRGЬlхWX console.log('#######')5Ѓ_Р«¬f яяяя[[,v,NRIдmхegs if (error) stop(error)5Ѓ_Р¬®g яяяя[[,v,NRIфхfhs else recur()5Ѓ_РЇ®gяяяя[[,v,NRIцnхfis //else recur()5Ѓ_Р®ґЇh яяяя[[,v,NRIчoхgit //recur()5Ѓ_РЇµ°ґT(яяяя[[,v,NRJhpхSUtH var streams = stack(source), open = 0, alive = true, stopped = false5Ѓ_Рґ¶µZяяяя[[,v,NRJqqхY[t open ++5Ѓ_Рµ·¶e яяяя[[,v,NRJzхde- console.log(' - ', stream.name)5Ѓ_Р¶ё·eяяяя[[,v,NRJ{хdfs" //if (error) stop(error)5Ѓ_Р·№ёfяяяя[[,v,NRJ~хegs //else5Ѓ_Рёє№fяяяя[[,v,NRJхegs else5Ѓ_Р№»єT(яяяя[[,v,NRJ–хSUsH var streams = stack(source), open = 1, alive = true, stopped = false5Ѓ_Рєј»Zяяяя[[,v,NRJ›хY[s open += 25Ѓ_Р»Ѕјfяяяя[[,v,NRJ§хegs else 5Ѓ_РјѕЅfяяяя[[,v,NRJЁхegs else if ()5Ѓ_РЅїѕfяяяя[[,v,NRJ«хegs else if (open)5Ѓ_РѕАїfяяяя[[,v,NRJ¬хegs else if (!open)5Ѓ_РїБАg яяяя[[,v,NRJЇsхfg recur()5Ѓ_РАВБiяяяя[[,v,NRJАхhi console.log(' <')5Ѓ_РБГВiяяяя[[,v,NRJБхikr хikq5Ѓ_РВДГjяяяя[[,v,NRJГхikr if ()5Ѓ_РГЕДjяяяя[[,v,NRJЖtхikr if (open === 0)5Ѓ_РДЖЕjяяяя[[,v,NRJЙхjls хjlr5Ѓ_РЕЗЖkяяяя[[,v,NRJЛхjls if ()5Ѓ_РЖИЗlяяяя[[,v,NRJФхjls if (open === -1)stop()хkms else if (!open) stop()5Ѓ_РЗЙИkяяяя[[,v,NRJЦuхjlr if (open === -1)stop()5Ѓ_РИКЙh яяяя[[,v,NRJфvхhjs хhjr5Ѓ_РЙЛКZяяяя[[,v,NRKxхY[s open ++5Ѓ_РКМЛdяяяя[[,v,NRKyхdft хdfs5Ѓ_РЛНМeяяяя[[,v,NRK|хdft console.log()5Ѓ_РМОНeяяяя[[,v,NRK}хdft console.log('')5Ѓ_РНПОeяяяя[[,v,NRKѓyхdft console.log(' - ')5Ѓ_РОРПjяяяя[[,v,NRK‰хjlu хjlt5Ѓ_РПнРkяяяя[[,v,NRK‹Љхjlu console.log()5Ѓ_РРСнnяяяя[[,v,NRQћхmou if (open === -1) stop()5Ѓ_РнAяяяя[[,v,NRUjЎхuA return next(element), index === end ? (stop(), false) : nil5Ѓ_Р+яяяя[[,v,NRUЋхv хu5Ѓ_Р яяяя\\,v,NRU“хv if ()5Ѓ_Ряяяя\\,v,NRUхv if (index < end)5Ѓ_Ряяяя\\,v,NRUљўхv if (index < end) next()5Ѓ_Ряяяя\\,v,NRUќҐхvB return next(element), index === end ? (stop(), false) : true5Ѓ_Ряяяя\\,v,NRU¶¦хv$ if (index < end) next(element)5Ѓ_Рfяяяя\\,v,NRUЩЁхegv+ console.log(' - ', strict.name)5Ѓ_Р яяяя\\,v,NRVхv% if (index <= end) next(element)5Ѓ_Ряяяя\\,v,NRVхv! index <= end) next(element)5Ѓ_Ряяяя\\,v,NRV хv" index <= end ? next(element)5Ѓ_Р)яяяя\\,v,NRVхv) return index <= end ? next(element)5Ѓ_Ряяяя\\,v,NRVх next(element), хv+ return index <= end ? next(element), 5Ѓ_Р яяяя]],v,NRVхw (next(element), &index === end ? (stop(), false) : trueхw3 return index === end ? (stop(), false) : true5Ѓ_Р Cяяяя\\,v,NRVх stopхvC (next(element), index === end ? (stop(), false) : true5Ѓ_Р! яяяя]],v,NRV%хw stop()5Ѓ_Р "! яяяя]],v,NRV)хw stop(), false5Ѓ_Р!$"яяяя]],v,NRV+Їхw (stop(), false5Ѓ_Р"%#$mяяяя]],v,NRVбІхlnw console.log('')5Ѓ_Р$&%[яяяя]],v,NRWёхZ[ console.log('!!!!!!')5Ѓ_Р%'&Yяяяя\\,v,NRW¬хY[w хY[v5Ѓ_Р&('Zяяяя]],v,NRWЇхY[w console.log()5Ѓ_Р')(Zяяяя]],v,NRW°№хY[w console.log('')5Ѓ_Р(*)яяяя]],v,NRXњхw'/* vim:set ts=2 sw=2 sts=2 expandtab */?/*jshint asi: true undef: true es5: true node: true devel: true' forin: false latedef: false *//*global define: true */н!(typeof(define) !== "function" ? function($){ $(typeof(require) !== 'function' ? (function() { throw Error('require unsupported'); }) : require, typeof(exports) === 'undefined' ? this : exports); } : define)(function(require, exports) { 'use strict';"var nil // Shortcut for undefined./**H * Internal utility function that takes a `source` function and optionalG * `number` arguments and returns a function that calls `source` with aG * given arguments only first `number` of times it's called. Useful for@ * wrapping callbacks that must be called only ones for example. */ function limit(source, number) { number = number || 1 return function limited() {G return number-- > 0 && source ? source.apply(this, arguments) : nil }}function normalize(source) {& return function stream(next, stop) {' var stopped = false, reading = true( source(function onElement(element) {( if (!stopped && false !== reading)( return (reading = next(element)) }, function onStop(reason) {; return stopped ? nil : (stopped = true, stop(reason)) }) }}/**K * Utility function that returns streams of elements of given `array`. ThisI * function is dangerous as array mutations will have side effects on theJ * returned stream so it should be used with a care, reader of such streamL * **MUST NOT** mutate source array, this is also reason why we don't export * this function. */ function streamArray(elements) {& return function stream(next, stop) { var index = 0# while (index < elements.length)< // If stream reader interrupts reading we just return.9 if (false === next(elements[index++])) return falseK // Once all elements were yielded we stop a stream if such callback was // passed. if (stop) stop() }}/**$ * Creates stream of given elements. * @examples# * list('a', 2, {})(console.log) */function list() {; return streamArray(Array.prototype.slice.call(arguments))}exports.list = list/*8 * Creates empty stream. This is equivalent of `list()`. */function empty() {> return function stream(next, stop) { return stop && stop() }}exports.empty = empty/**# * Returns stream of mapped values. * @param {Function} lambda# * function that maps each value * @param {Function} input * source stream to be mapped * @examples: * var stream = list({ name: 'foo' }, { name: 'bar' })D * var names = map(function(value) { return value.name }, stream) * names(console.log) * // 'foo' * // 'bar'! * var numbers = list(1, 2, 3)N * var mapped = map(function onEach(number) { return number * 2 }, numbers) * mapped(console.log) * // 2 * // 4 * // 6 */function map(lambda, source) {& return function stream(next, stop) {( source(function onElement(element) {" return next(lambda(element)) }, stop) }}exports.map = map/**% * Returns stream of filtered values. * @param {Function} lambda" * function that filters values * @param {Function} source" * source stream to be filtered * @examples* * var numbers = list(10, 23, 2, 7, 17)+ * var digits = filter(function(value) {' * return value >= 0 && value <= 9 * }, numbers) * digits(console.log) * // 2 * // 7 */!function filter(lambda, source) {& return function stream(next, stop) {( source(function onElement(element) {3 return lambda(element) ? next(element) : true }, stop) }}exports.filter = filter/**# * Returns stream of reduced values * @param {Function} source * stream to reduce. * @param {Function} reducer * reducer function * @param initial * initial value * @examples! * var numbers = list(2, 3, 8)> * var sum = reduce(function onElement(previous, current) {( * return (previous || 0) + current * }, numbers) * sum(console.log) * // 13 */+function reduce(reducer, source, initial) {& return function stream(next, stop) { var value = initial( source(function onElement(element) {% value = reducer(value, element) }, function onStop(error) {# if (error) return stop(error) next(value) if (stop) stop() }) }}exports.reduce = reduce/**L * This function returns stream of tuples, where the n-th tuple contains theI * n-th element from each of the argument streams. The returned stream isE * truncated in length to the length of the shortest argument stream. * @params {Function}" * source steams to be combined * @examples% * var a = list([ 'a', 'b', 'c' ])" * var b = list([ 1, 2, 3, 4 ])/ * var c = list([ '!', '@', '#', '$', '%' ]) * var abc = zip(a, b, c) * abs(console.log) * // [ 'a', 1, '!' ] * // [ 'b', 2, '@' ] * // [ 'c', 3, '#' ] */var zip = (function Zip() {+ // Returns weather array is empty or not.2 function isEmpty(array) { return !array.length }G // Utility function that check if each array in given array of arraysA // has at least one element (in which case we do have a tuple).: function hasTuple(array) { return !array.some(isEmpty) }F // Utility function that creates tuple by shifting element from each // array of arrays. function shiftTuple(array) {( var index = array.length, tuple = []< while (0 <= --index) tuple.unshift(array[index].shift()) return tuple } return function zip() {7 var sources = Array.prototype.slice.call(arguments)( return function stream(next, stop) {? var buffers = [], id, reason, isStopped = false, shortest' function onElement(id, element) {N // If resulting stream is already stopped (we are in truncate mode) orP // if this stream is stopped (we deal with badly implemented stream that> // yields value after it's stopped) we ignore element." if (isStopped) return null* // Otherwise we buffer an element.! buffers[id].push(element)) // If tuple is ready we yield it.C return hasTuple(buffers) ? next(shiftTuple(buffers)) : true }" function onStop(id, error) {N // If shortest stream was already stopped then we are in truncate mode@ // which means we ignore all the following stream stops." if (isStopped) return nullL // If stream being stopped is the first one to be stopped or if it'sK // shorter then the shortest one stopped, we update stop reason and- // shortest stopped stream reference.@ if (!shortest || shortest.length > buffers[id].length) { shortest = buffers[id] reason = error }P // If shortest stream has no buffered elements, we stop resulting stream // & do some clean up. if (!shortest.length) {' // Marking stream as stopped. isStopped = true // Stopping a stream. stop(reason)K // Setting all closure captured elements to `null` so that gc can // collect them.# buffers = shortest = null } } // Initializing buffers. id = sources.length( while (0 <= --id) buffers.push([]) // Start reading streams. id = sources.length while (0 <= --id)D sources[id](onElement.bind(null, id), onStop.bind(null, id)) } }})()exports.zip = zip/**K * Returns stream containing first `n` elements of given `source`, on which * given lambda returns `true`. * * @param {Function} lambda# * function that takes elements. * @param {Function} source* * source stream to take elements from. * @examples* * var numbers = list(10, 23, 2, 7, 17)) * var digits = take(function(value) { * return value >= 10 * }, numbers) * digits(console.log) * // 10 * // 23 */function take(lambda, source) {& return function stream(next, stop) {( source(function onElement(element) {> return lambda(element) ? next(element) : stop() && false }, stop = limit(stop)) }}exports.take = take/**M * Returns a stream consisting of the given `source` stream elements startingL * form the `start` zero-based index till `end` zero-based index element. If5 * `end` is not passed all elements will be included. */$function slice(source, start, end) {3 // Zero-based index at which to begin extraction. start = start || 00 // Zero-based index at which to end extraction end = end || Infinity& return function stream(next, stop) { var index = 0 filter(function(element) { return start <= index ++, }, source)(function onElement(element) { return index <= end ?F (next(element), index === end ? (stop(), false) : true) : (stop(), false) }, stop = limit(stop)) }}exports.slice = slice/**K * Returns a stream containing only first `number` of elements of the givenM * `source` stream or all elements, if `source` stream has less than `number`= * of elements. If `number` is not passed it defaults to `1`. * @param {Function} source * source stream * @param {Number} number=1, * number of elements to take from stream */function head(source, number) {= return slice(source, 0, number && number >= 0 ? number : 1)}exports.head = head/**N * Returns a stream equivalent to given `source` stream, except that the firstN * `number` of elements are omitted. If `source` stream has less than `number`O * of elements, then empty stream is returned. `number` defaults to `1` if it's * not passed. * @param {Function} source& * source stream to return tail of. * @param {Number} number=1. * Number of elements that will be omitted. */function tail(source, number) {: return slice(source, number && number >= 0 ? number : 1)}exports.tail = tail/**O * Returns a stream that contains all elements of each stream in the order theyL * appear in the original streams. If any of the `source` streams is stoppedM * with an error than it propagates to the resulting stream and it also get's * stopped. * @examples5 * var stream = append(list(1, 2), list('a', 'b')) * stream(console.log) * // 1 * // 2 * // 'a' * // 'b' */function append() {8 var streams = Array.prototype.slice.call(arguments, 0)& return function stream(next, stop) {* var source, sources = streams.slice(0) function onStop(error) {+ if (error) return stop && stop(error): if ((source = sources.shift())) source(next, onStop) else return stop && stop() } onStop() }}exports.append = append/**J * Returns a stream that contains all elements of each stream of the givenP * source stream. `source` is stream of streams whose elements will be containedK * by the resulting stream. Any error from any stream will propagate to theP * resulting stream. Stream is stopped when all streams from `source` and sourceI * itself is ended. Elements of the stream are position in order they areL * delivered so it could happen that elements from second stream will appear2 * before or between elements of the first stream. * @param {Function} sourceL * Stream of streams whose elements will be contained by resulting stream * @examples" * function async(next, stop) { * setTimeout(function() { * next('async') * stop() * }, 10) * }4 * var stream = merge(list(async, list(1, 2, 3))) * stream(console.log) * // 1 * // 2 * // 3 * // 'async' */function merge(source) {& return function stream(next, stop) { var open = 1, alive function onStop(error) {0 if (!open || false === alive) return false if (error) open = 0 else open -- if (!open) stop(error) }& source(function onStream(stream) { open ++% stream(function onNext(value) {D return open && false !== alive ? alive = next(value) : false }, onStop) }, onStop) }}exports.merge = merge/**% * Utility function to print streams. * @param {Function} stream * stream to print * @examples# * print(list('Hello', 'world')) */function print(stream) { console.log('>>')< stream(console.log.bind(console), function onStop(error) {# if (error) console.error(error) else console.log('<<') })}exports.print = print/**H * Returns a stream equivalent to a given `source`, with difference thatK * all the consumers will start reading it from the point it's at the givenM * moment. This is useful with streams such as user generated events (clicks,M * keypress, etc..) where multiple stream readers might need to read from the, * same source. In other words, this is yourK * [pub / sub](http://en.wikipedia.org/wiki/Publish/subscribe) for streams. * @param {Function} source; * Stream whose elements get published to a subscribers. * @return {Function}5 * Stream that multiple subscribers can read from. * @examples" * function range(start, end) {, * return function stream(next, stop) { * var number = start - 1( * setTimeout(function onNext() { * if (++number >= end) * return stop()' * if (false !== next(number))# * setTimeout(onNext, 2) * }, 2) * } * } * function printer(index) {' * return function print(stream) {> * stream(console.log.bind(console, '#' + index + '>'),9 * console.log.bind(console, '<#' + index)) * } * } * var numbers = range(1, 5) * printer(1)(numbers)8 * setTimeout(function () { printer(2)(numbers) }, 5) *. * // Output will look something like this: * #1> 1 * #1> 2 * #1> 3 * #2> 1 * #1> 4 * #2> 2 * <#1 * #2> 3 * #2> 4 * <#2 *L * // If you noticed second print started form the first `1` element. Now* * // lets do similar thing with a hub. *$ * var numbers = hub(range(1, 5)) * printer(1)(numbers)8 * setTimeout(function () { printer(2)(numbers) }, 5) */ * // In this case output will be different: * * #1> 1 * #1> 2 * #1> 3 * #1> 4 * #2> 4 * <#1 * <#2 *L * // Notice this time second print only printed only following elements. */function hub(source) {/ var listeners = [], isStopped = false, reason# source(function onNext(element) { var index = 0E // Maybe it'd be better to just iterate on sliced array instead ?& while (index < listeners.length) {3 if (listeners[index++][0](element) === false)$ listeners.splice(--index, 1) } }, function onStop(error) { isStopped = true reason = error var listener, stop- while ((listener = listeners.shift())) {, if ((stop = listener[1])) stop(reason) } })& return function stream(next, stop) {: // If stream is already stopped, we notify a listener.' if (isStopped && stop) stop(reason)! // Else we register listener.' else listeners.push([ next, stop ]) }}exports.hub = hub/**O * Returns a stream equivalent to a given `source` by caching all it's elementsN * into memory for faster reads. This is useful with `source` streams that areL * expensive to compute (requires access to the network for example). Use itD * carefully though, do not cache infinite streams and be aware thatB * asynchronous stream when cached will yield some or all elementsL * synchronously. Also be aware, that unlike other functions, this is greedyF * which means that it will start reading `source` stream immediately. * @param {Function} source * source stream to cache. * @returns {Function}B * cached equivalent of source that can be read multiple times. */function cache(source) { var buffer = []@ // Creating a stream that streams element of the buffer array. function cached(next, stop) { var index = 0! while (index < buffer.length)7 if (false === next(buffer[index++])) return false stop() }9 return append(cached, hub(function stream(next, stop) {( source(function onElement(element) { buffer.push(element) return next(element) }, stop) }));}exports.cache = cache/**N * Returns stream equivalent to a given `source` with a difference that it hasL * a state, meaning that if reader stops reading on n-th element next readerM * will continue reading from n-th element. Purpose is to wrap any other typeL * of stream, such that each element of `source` can be read only once. ThisO * allow element distribution across different consumers with a help of `head`, * `tail` and similars. * @param {Function} source0 * source stream to create stack stream from. * @returns {Function}< * stack equivalent of source that can be read only once. */function stack(source) {M var readers = [], buffer = [], isStopped = false, isStarted = false, reason function update() {5 if (!buffer.length || !readers.length) return nil. var resume = readers[0][0](buffer.shift())) if (false === resume) readers.shift() update() } function onNext(element) { update(buffer.push(element)) } function onStop(error) { isStopped = true reason = error var reader = readers.shift()F return reader ? onStop(error, reader[1] && reader[1](error)) : nil }& return function stream(next, stop) {: // If stream is already stopped, we notify a listener.@ if (isStopped && !buffer.length) return stop && stop(reason) readers.push([ next, stop ]) update()B // If `source` stream is not yet being read, start reading it. if (isStarted) return nil isStarted = true source(onNext, onStop) }}exports.stack = stack/**J * Returns a stream that contains all elements of each stream of the givenP * source stream. `source` is stream of streams whose elements will be containedK * by the resulting stream. Any error from any stream will propagate to theP * resulting stream. Stream is stopped when all streams from `source` and sourceO * itself are ended. Elements of the stream are position in order, all elements6 * of first stream, all elements of second stream etc. * @param {Function} sourceL * Stream of streams whose elements will be contained by resulting stream * @examples" * function async(next, stop) { * setTimeout(function() { * next('async') * stop() * }, 10) * }3 * var stream = join(list(async, list(1, 2, 3))) * stream(console.log) * // 'async' * // 1 * // 2 * // 3 */function join(source) {& return function stream(next, stop) {H var streams = stack(source), open = 0, alive = true, stopped = false stop = limit(stop) !function recur(error) { console.log('@')/ head(streams)(function onStream(stream) { open += 2 console.log(' >')+ console.log(' + ', stream.name), stream(function onElement(element) {* console.log(' |- ', element)J // If steam is still open and read is not interrupted we deliverB // element to the reader, otherwise we interrupt source.6 return !stopped && open && false !== alive ?. alive = next(element) : false$ }, function onStop(error) { open --+ console.log(' - ', stream.name) if (error) stop(error)! else if (!open) recur() })! }, function onStop(error) { open -- console.log(' <') if (error) stop(error) if (open === 0) recur()$ else if (open === -1) stop() }) }() }}exports.join = join});5Ѓ_Р)+*Pяяяя]],v,NRXўхPRm хPRl5Ѓ_Р*,+Qяяяя^^,v,NRXҐєхPRm console.log()5Ѓ_Р+-,gяяяя^^,v,NRXЕхgin хgim5Ѓ_Р,.-hяяяя^^,v,NRXИхgin console.loc()5Ѓ_Р-/.hяяяя^^,v,NRXЙхgin console.loc()5Ѓ_Р.0/hяяяя^^,v,NRXНхgin console.log()5Ѓ_Р/10hяяяя^^,v,NRXО»хgin console.log('')5Ѓ_Р021яяяя^^,v,NRY!хn'/* vim:set ts=2 sw=2 sts=2 expandtab */?/*jshint asi: true undef: true es5: true node: true devel: true' forin: false latedef: false *//*global define: true */н!(typeof(define) !== "function" ? function($){ $(typeof(require) !== 'function' ? (function() { throw Error('require unsupported'); }) : require, typeof(exports) === 'undefined' ? this : exports); } : define)(function(require, exports) { 'use strict';"var nil // Shortcut for undefined./**H * Internal utility function that takes a `source` function and optionalG * `number` arguments and returns a function that calls `source` with aG * given arguments only first `number` of times it's called. Useful for@ * wrapping callbacks that must be called only ones for example. */ function limit(source, number) { number = number || 1 return function limited() {G return number-- > 0 && source ? source.apply(this, arguments) : nil }}/**K * Utility function that returns streams of elements of given `array`. ThisI * function is dangerous as array mutations will have side effects on theJ * returned stream so it should be used with a care, reader of such streamL * **MUST NOT** mutate source array, this is also reason why we don't export * this function. */ function streamArray(elements) {& return function stream(next, stop) { var index = 0# while (index < elements.length)< // If stream reader interrupts reading we just return.9 if (false === next(elements[index++])) return falseK // Once all elements were yielded we stop a stream if such callback was // passed. if (stop) stop() }}/**$ * Creates stream of given elements. * @examples# * list('a', 2, {})(console.log) */function list() {; return streamArray(Array.prototype.slice.call(arguments))}exports.list = list/*8 * Creates empty stream. This is equivalent of `list()`. */function empty() {> return function stream(next, stop) { return stop && stop() }}exports.empty = empty/**# * Returns stream of mapped values. * @param {Function} lambda# * function that maps each value * @param {Function} input * source stream to be mapped * @examples: * var stream = list({ name: 'foo' }, { name: 'bar' })D * var names = map(function(value) { return value.name }, stream) * names(console.log) * // 'foo' * // 'bar'! * var numbers = list(1, 2, 3)N * var mapped = map(function onEach(number) { return number * 2 }, numbers) * mapped(console.log) * // 2 * // 4 * // 6 */function map(lambda, source) {& return function stream(next, stop) {( source(function onElement(element) {" return next(lambda(element)) }, stop) }}exports.map = map/**% * Returns stream of filtered values. * @param {Function} lambda" * function that filters values * @param {Function} source" * source stream to be filtered * @examples* * var numbers = list(10, 23, 2, 7, 17)+ * var digits = filter(function(value) {' * return value >= 0 && value <= 9 * }, numbers) * digits(console.log) * // 2 * // 7 */!function filter(lambda, source) {& return function stream(next, stop) {( source(function onElement(element) {3 return lambda(element) ? next(element) : true }, stop) }}exports.filter = filter/**# * Returns stream of reduced values * @param {Function} source * stream to reduce. * @param {Function} reducer * reducer function * @param initial * initial value * @examples! * var numbers = list(2, 3, 8)> * var sum = reduce(function onElement(previous, current) {( * return (previous || 0) + current * }, numbers) * sum(console.log) * // 13 */+function reduce(reducer, source, initial) {& return function stream(next, stop) { var value = initial( source(function onElement(element) {% value = reducer(value, element) }, function onStop(error) {# if (error) return stop(error) next(value) if (stop) stop() }) }}exports.reduce = reduce/**L * This function returns stream of tuples, where the n-th tuple contains theI * n-th element from each of the argument streams. The returned stream isE * truncated in length to the length of the shortest argument stream. * @params {Function}" * source steams to be combined * @examples% * var a = list([ 'a', 'b', 'c' ])" * var b = list([ 1, 2, 3, 4 ])/ * var c = list([ '!', '@', '#', '$', '%' ]) * var abc = zip(a, b, c) * abs(console.log) * // [ 'a', 1, '!' ] * // [ 'b', 2, '@' ] * // [ 'c', 3, '#' ] */var zip = (function Zip() {+ // Returns weather array is empty or not.2 function isEmpty(array) { return !array.length }G // Utility function that check if each array in given array of arraysA // has at least one element (in which case we do have a tuple).: function hasTuple(array) { return !array.some(isEmpty) }F // Utility function that creates tuple by shifting element from each // array of arrays. function shiftTuple(array) {( var index = array.length, tuple = []< while (0 <= --index) tuple.unshift(array[index].shift()) return tuple } return function zip() {7 var sources = Array.prototype.slice.call(arguments)( return function stream(next, stop) {? var buffers = [], id, reason, isStopped = false, shortest' function onElement(id, element) {N // If resulting stream is already stopped (we are in truncate mode) orP // if this stream is stopped (we deal with badly implemented stream that> // yields value after it's stopped) we ignore element." if (isStopped) return null* // Otherwise we buffer an element.! buffers[id].push(element)) // If tuple is ready we yield it.C return hasTuple(buffers) ? next(shiftTuple(buffers)) : true }" function onStop(id, error) {N // If shortest stream was already stopped then we are in truncate mode@ // which means we ignore all the following stream stops." if (isStopped) return nullL // If stream being stopped is the first one to be stopped or if it'sK // shorter then the shortest one stopped, we update stop reason and- // shortest stopped stream reference.@ if (!shortest || shortest.length > buffers[id].length) { shortest = buffers[id] reason = error }P // If shortest stream has no buffered elements, we stop resulting stream // & do some clean up. if (!shortest.length) {' // Marking stream as stopped. isStopped = true // Stopping a stream. stop(reason)K // Setting all closure captured elements to `null` so that gc can // collect them.# buffers = shortest = null } } // Initializing buffers. id = sources.length( while (0 <= --id) buffers.push([]) // Start reading streams. id = sources.length while (0 <= --id)D sources[id](onElement.bind(null, id), onStop.bind(null, id)) } }})()exports.zip = zip/**K * Returns stream containing first `n` elements of given `source`, on which * given lambda returns `true`. * * @param {Function} lambda# * function that takes elements. * @param {Function} source* * source stream to take elements from. * @examples* * var numbers = list(10, 23, 2, 7, 17)) * var digits = take(function(value) { * return value >= 10 * }, numbers) * digits(console.log) * // 10 * // 23 */function take(lambda, source) {& return function stream(next, stop) {( source(function onElement(element) {> return lambda(element) ? next(element) : stop() && false }, stop) }}exports.take = take/**M * Returns a stream consisting of the given `source` stream elements startingL * form the `start` zero-based index till `end` zero-based index element. If5 * `end` is not passed all elements will be included. */$function slice(source, start, end) {3 // Zero-based index at which to begin extraction. start = start || 00 // Zero-based index at which to end extraction end = end || Infinity& return function stream(next, stop) { var index = -1, interrupt( source(function onElement(element) {D // Skip elements until we reach start of the extraction range.& if (++index < start) return trueA // If index is in range we want to extract from then yield.0 if (index < end) interrupt = next(element)E // If this is last element we stop stream and interrupt reading; return index + 1 >= end ? (stop(), false) : interrupt }, stop = limit(stop)) }}exports.slice = slice/**K * Returns a stream containing only first `number` of elements of the givenM * `source` stream or all elements, if `source` stream has less than `number`= * of elements. If `number` is not passed it defaults to `1`. * @param {Function} source * source stream * @param {Number} number=1, * number of elements to take from stream */function head(source, number) {= return slice(source, 0, number && number >= 0 ? number : 1)}exports.head = head/**N * Returns a stream equivalent to given `source` stream, except that the firstN * `number` of elements are omitted. If `source` stream has less than `number`O * of elements, then empty stream is returned. `number` defaults to `1` if it's * not passed. * @param {Function} source& * source stream to return tail of. * @param {Number} number=1. * Number of elements that will be omitted. */function tail(source, number) {: return slice(source, number && number >= 0 ? number : 1)}exports.tail = tail/**O * Returns a stream that contains all elements of each stream in the order theyL * appear in the original streams. If any of the `source` streams is stoppedM * with an error than it propagates to the resulting stream and it also get's * stopped. * @examples5 * var stream = append(list(1, 2), list('a', 'b')) * stream(console.log) * // 1 * // 2 * // 'a' * // 'b' */function append() {8 var streams = Array.prototype.slice.call(arguments, 0)& return function stream(next, stop) {* var source, sources = streams.slice(0) function onStop(error) {+ if (error) return stop && stop(error): if ((source = sources.shift())) source(next, onStop) else return stop && stop() } onStop() }}exports.append = append/**J * Returns a stream that contains all elements of each stream of the givenP * source stream. `source` is stream of streams whose elements will be containedK * by the resulting stream. Any error from any stream will propagate to theP * resulting stream. Stream is stopped when all streams from `source` and sourceI * itself is ended. Elements of the stream are position in order they areL * delivered so it could happen that elements from second stream will appear2 * before or between elements of the first stream. * @param {Function} sourceL * Stream of streams whose elements will be contained by resulting stream * @examples" * function async(next, stop) { * setTimeout(function() { * next('async') * stop() * }, 10) * }4 * var stream = merge(list(async, list(1, 2, 3))) * stream(console.log) * // 1 * // 2 * // 3 * // 'async' */function merge(source) {& return function stream(next, stop) { var open = 1, alive function onStop(error) {0 if (!open || false === alive) return false if (error) open = 0 else open -- if (!open) stop(error) }& source(function onStream(stream) { open ++% stream(function onNext(value) {D return open && false !== alive ? alive = next(value) : false }, onStop) }, onStop) }}exports.merge = merge/**% * Utility function to print streams. * @param {Function} stream * stream to print * @examples# * print(list('Hello', 'world')) */function print(stream) { console.log('>>')< stream(console.log.bind(console), function onStop(error) {# if (error) console.error(error) else console.log('<<') })}exports.print = print/**H * Returns a stream equivalent to a given `source`, with difference thatK * all the consumers will start reading it from the point it's at the givenM * moment. This is useful with streams such as user generated events (clicks,M * keypress, etc..) where multiple stream readers might need to read from the, * same source. In other words, this is yourK * [pub / sub](http://en.wikipedia.org/wiki/Publish/subscribe) for streams. * @param {Function} source; * Stream whose elements get published to a subscribers. * @return {Function}5 * Stream that multiple subscribers can read from. * @examples" * function range(start, end) {, * return function stream(next, stop) { * var number = start - 1( * setTimeout(function onNext() { * if (++number >= end) * return stop()' * if (false !== next(number))# * setTimeout(onNext, 2) * }, 2) * } * } * function printer(index) {' * return function print(stream) {> * stream(console.log.bind(console, '#' + index + '>'),9 * console.log.bind(console, '<#' + index)) * } * } * var numbers = range(1, 5) * printer(1)(numbers)8 * setTimeout(function () { printer(2)(numbers) }, 5) *. * // Output will look something like this: * #1> 1 * #1> 2 * #1> 3 * #2> 1 * #1> 4 * #2> 2 * <#1 * #2> 3 * #2> 4 * <#2 *L * // If you noticed second print started form the first `1` element. Now* * // lets do similar thing with a hub. *$ * var numbers = hub(range(1, 5)) * printer(1)(numbers)8 * setTimeout(function () { printer(2)(numbers) }, 5) */ * // In this case output will be different: * * #1> 1 * #1> 2 * #1> 3 * #1> 4 * #2> 4 * <#1 * <#2 *L * // Notice this time second print only printed only following elements. */function hub(source) {/ var listeners = [], isStopped = false, reason# source(function onNext(element) { var index = 0E // Maybe it'd be better to just iterate on sliced array instead ?& while (index < listeners.length) {3 if (listeners[index++][0](element) === false)$ listeners.splice(--index, 1) } }, function onStop(error) { isStopped = true reason = error var listener, stop- while ((listener = listeners.shift())) {, if ((stop = listener[1])) stop(reason) } })& return function stream(next, stop) {: // If stream is already stopped, we notify a listener.' if (isStopped && stop) stop(reason)! // Else we register listener.' else listeners.push([ next, stop ]) }}exports.hub = hub/**O * Returns a stream equivalent to a given `source` by caching all it's elementsN * into memory for faster reads. This is useful with `source` streams that areL * expensive to compute (requires access to the network for example). Use itD * carefully though, do not cache infinite streams and be aware thatB * asynchronous stream when cached will yield some or all elementsL * synchronously. Also be aware, that unlike other functions, this is greedyF * which means that it will start reading `source` stream immediately. * @param {Function} source * source stream to cache. * @returns {Function}B * cached equivalent of source that can be read multiple times. */function cache(source) { var buffer = []@ // Creating a stream that streams element of the buffer array. function cached(next, stop) { var index = 0! while (index < buffer.length)7 if (false === next(buffer[index++])) return false stop() }9 return append(cached, hub(function stream(next, stop) {( source(function onElement(element) { buffer.push(element) return next(element) }, stop) }));}exports.cache = cache/**N * Returns stream equivalent to a given `source` with a difference that it hasL * a state, meaning that if reader stops reading on n-th element next readerM * will continue reading from n-th element. Purpose is to wrap any other typeL * of stream, such that each element of `source` can be read only once. ThisO * allow element distribution across different consumers with a help of `head`, * `tail` and similars. * @param {Function} source0 * source stream to create stack stream from. * @returns {Function}< * stack equivalent of source that can be read only once. */function stack(source) {M var readers = [], buffer = [], isStopped = false, isStarted = false, reason function update() {5 if (!buffer.length || !readers.length) return nil. var resume = readers[0][0](buffer.shift())) if (false === resume) readers.shift() update() } function onNext(element) { update(buffer.push(element)) } function onStop(error) { isStopped = true reason = error var reader = readers.shift()F return reader ? onStop(error, reader[1] && reader[1](error)) : nil }& return function stream(next, stop) {: // If stream is already stopped, we notify a listener.@ if (isStopped && !buffer.length) return stop && stop(reason) readers.push([ next, stop ]) update()B // If `source` stream is not yet being read, start reading it. if (isStarted) return nil isStarted = true source(onNext, onStop) }}exports.stack = stack/**J * Returns a stream that contains all elements of each stream of the givenP * source stream. `source` is stream of streams whose elements will be containedK * by the resulting stream. Any error from any stream will propagate to theP * resulting stream. Stream is stopped when all streams from `source` and sourceO * itself are ended. Elements of the stream are position in order, all elements6 * of first stream, all elements of second stream etc. * @param {Function} sourceL * Stream of streams whose elements will be contained by resulting stream * @examples" * function async(next, stop) { * setTimeout(function() { * next('async') * stop() * }, 10) * }3 * var stream = join(list(async, list(1, 2, 3))) * stream(console.log) * // 'async' * // 1 * // 2 * // 3 */function join(source) {& return function stream(next, stop) {H var streams = stack(source), open = 0, alive = true, stopped = false stop = limit(stop) !function recur(error) { console.log('@')/ head(streams)(function onStream(stream) { console.log(stream) open += 2 console.log(' >')+ console.log(' + ', stream.name), stream(function onElement(element) {* console.log(' |- ', element)J // If steam is still open and read is not interrupted we deliverB // element to the reader, otherwise we interrupt source.6 return !stopped && open && false !== alive ?. alive = next(element) : false$ }, function onStop(error) { open --+ console.log(' - ', stream.name) if (error) stop(error)! else if (!open) recur() })! }, function onStop(error) { open -- console.log(' <') if (error) stop(error) if (open === 0) recur()$ else if (open === -1) stop() }) console.log('#') }() }}exports.join = join});5Ѓ_Р132qяяяя^^,v,NRY2хqsx хqsw5Ѓ_Р243rяяяя^^,v,NRY6хqsx console.log()5Ѓ_Р354rяяяя^^,v,NRY6хqsx console.log('')5Ѓ_Р465rяяяя^^,v,NRY8јхqsx console.log('>')5Ѓ_Р576[яяяя^^,v,NRYPх[]y х[]x5Ѓ_Р687\яяяя__,v,NRYSЅх[]y console.log()5Ѓ_Р798Vяяяя__,v,NRYѓхVXz хVXy5Ѓ_Р8:9W яяяя``,v,NRYЋхVXz var index5Ѓ_Р9;:\ яяяя``,v,NRY‘х[]z/ head(streams)(function onStream(stream) {5Ѓ_Р:<;\яяяя``,v,NRY•х[]z0 slice(streams)(function onStream(stream) {5Ѓ_Р;=<\яяяя``,v,NRYЎх[]z: slice(streams, index, 1)(function onStream(stream) {5Ѓ_Р<>=Wяяяя``,v,NRYҐїхVXz var index = -15Ѓ_Р=?>Vяяяя``,v,NRY°хUWzH var streams = stack(source), open = 0, alive = true, stopped = false5Ѓ_Р>A?Vяяяя``,v,NRYІБхUWzB var streams = source), open = 0, alive = true, stopped = false5Ѓ_Р?B@A\яяяя``,v,NRZКх[]z< slice(streams, index++, 1)(function onStream(stream) {5Ѓ_РACB\яяяя``,v,NRZМВх[]z: slice(streams, index, 1)(function onStream(stream) {5Ѓ_РBDCoяяяя``,v,NR[дхno console.log(' <')5Ѓ_РCEDsяяяя``,v,NR[ехrs console.log('#')5Ѓ_РDFE_яяяя``,v,NR[их^_ console.log(' >')5Ѓ_РEGF_яяяя__,v,NR[их^_+ console.log(' + ', stream.name)5Ѓ_РFHG[яяяя__,v,NR[кГхZ[ console.log('@')5Ѓ_РGIH\яяяя^^,v,NR[рх[\ console.log(stream)5Ѓ_РHJI^яяяя]],v,NR[сДх]^* console.log(' |- ', element)5Ѓ_РIKJd яяяя]],v,NR[цЕхcd+ console.log(' - ', stream.name)5Ѓ_РJLKV!яяяя]],v,NR\"ЖхUWrA var streams = source, open = 0, alive = true, stopped = false5Ѓ_РKMLeяяяя]],v,NR\(Зхdfr! else if (!open) recur()5Ѓ_РLNMjяяяя]],v,NR\-хij if (open === 0) recur()5Ѓ_РMONj яяяя]],v,NR\/хikq$ else if (open === -1) stop()5Ѓ_РNPOjяяяя]],v,NR\2хikq if (open === -1) stop()5Ѓ_РOQPjяяяя]],v,NR\5хikq$ else if (open === -1) stop()5Ѓ_РPRQjяяяя]],v,NR\7хikq% else if (!open === -1) stop()5Ѓ_РQSRdяяяя]],v,NR\;хdfr хdfq5Ѓ_РRTSeяяяя]],v,NR\>хdfr if ()5Ѓ_РSUTe яяяя]],v,NR\Aхdfr if (!open)5Ѓ_РTVUeяяяя]],v,NR\BИхdfr else if (!open)5Ѓ_РUWVYяяяя]],v,NR\LхY[s хY[r5Ѓ_РVXWZяяяя^^,v,NR\cхY[s function onStop()5Ѓ_РWYXZяяяя^^,v,NR\cхY\s function onStop() {}5Ѓ_РXZYkяяяяkmvNR\jхjlt open -- if (error) stop(error) else if (!open) stop()5Ѓ_РY[ZZяяяяkk%vNR\kхZ^s хZ\r5Ѓ_РZ\[\яяяяnn%vNR\mх[]u if (error) stop(error)5Ѓ_Р[]\]яяяяnn%vNR\oЙх\^u else if (!open) stop()5Ѓ_Р\^]m яяяяm ovNR\хlnu! }, function onStop(error) { })5Ѓ_Р]_^m яяяяm mvNR\Ђхlns }, )5Ѓ_Р^`_h яяяяm mvNR\‡хgh open --5Ѓ_Р_a`h яяяяl lvNR\‰хgh if (error) stop(error)5Ѓ_Р`bah яяяяk kvNR\Љхgh else if (!open) stop()5Ѓ_Рacbg$яяяяj jvNR\Ќхfhp$ }, function onStop(error) {5Ѓ_Рbdcgяяяяj jvNR\’хfhp }, function stopped()5Ѓ_Рcedg яяяяj jvNR\“хfip! }, function stopped() {}5Ѓ_Рdfehяяяяk kvNR\”хgh }5Ѓ_Рegfgяяяяj jvNR\–хfhp }, function stopped() {5Ѓ_Рfhghяяяяj jvNR\™хgip else recur()5Ѓ_Рgihg яяяяj jvNR\љхgiq хgip5Ѓ_Рhjihяяяяk kvNR\ќхgiq onStop()5Ѓ_Рikjhяяяяk kvNR\џКхgiq onStop(exports)5Ѓ_РjlkZяяяяk kvNR\ІЛхY[q function onStop() {5Ѓ_Рkmlh яяяяk kvNR\ахfhq% }, function stopped(error) { onStop(error)хgiq onStop(error)5Ѓ_Рlnmg3яяяяj jvNR\вхfhp3 }, function stopped(error) { onStop(error)5Ѓ_Рmonh яяяяj jvNR\гхfhp5 }, function stopped(error) { onStop(error), recur()хgip recur()5Ѓ_Рnpohяяяяi ivNR\жМхfho< }, function stopped(error) { onStop(error), recur()})хgio })5Ѓ_Рoqp_яяяяh hvNR\нх_ao х_an5Ѓ_Рprq`яяяяi ivNR\рх_ao onStream()5Ѓ_Рqsr`яяяяi ivNR\хх_ao onStop())5Ѓ_Рrts`яяяяi ivNR\чх_ao onStop()i5Ѓ_Рsut` яяяяi ivNR\шНх_ao onStop()5Ѓ_Рtvuhяяяяhh=v=NR\яхgio? }, function stopped(error) { onStop(error), recur() })5Ѓ_Рuwvhяяяяhh=v=NR\яхgio }, )5Ѓ_Рvywhяяяяhh=v=NR]Пхgio }, recur)5Ѓ_РwzxyV!яяяяhh=v=NR]РхUWoA var streams = source, open = 1, alive = true, stopped = false5Ѓ_Рy{z\яяяяhh=v=NR]Eх\^o5Ѓ_Рz|{]яяяяii=v=NR]Fх[]p if (error) stop(error)х\^p5Ѓ_Р{|\яяяяhh=v=NR]LСх[]o if (error) stop(error)5Ѓ_Р|Ђ}WяяяяV2V8v8NR]АФхUWoA var streams = source, open = 2, alive = true, stopped = false index = 0хVXo var index = 05Ѓ_РЃЂXяяяяV2V8v8NR]ГхWX stop = limit(stop)5Ѓ_РЂ‚ЃZяяяяV2V8v8NR]ИХхY[m* if (error) open = false, stop(error)5Ѓ_РЃѓ‚ZяяяяV2V8v8NR]РхY[m* if (error) open = false, stop(error)5Ѓ_Р‚„ѓZяяяяV2V8v8NR]ТЦхY[m* if (error) open = false, stop(error)5Ѓ_Рѓ…„Z*яяяяV2V8v8NR]ЩЧхY[m6 if (error && !stopped) open = false, stop(error)5Ѓ_Р„†…[яяяяV2V8v8NR]кШхZ\m else if (!open) stop()5Ѓ_Р…‡†["яяяяV2V8v8NR]ххZ\m( else if (!open && !stopped) stop()5Ѓ_Р†€‡Z:яяяяV2V8v8NR]эЪхY[mG if (error && !stopped) open = false, stopped = error, stop(error)5Ѓ_Р‡‰€eяяяяV2V8v8NR^хcem6 return !stopped && open && false !== alive ?alive = next(element) : falseхdfm. alive = next(element) : false5Ѓ_Р€Љ‰d7яяяяV2V8v8NR^хcflT return !stopped && open && false !== alive ? alive = next(element) : false5Ѓ_Р‰‹Љe яяяяV2V8v8NR^Ыхdfm' alive = next(element) : false5Ѓ_РЉЊ‹bJяяяяV2V8v8NR^RхacmJ // If steam is still open and read is not interrupted we deliver5Ѓ_Р‹ЌЊcяяяяV2V8v8NR^WЬхbdmB // element to the reader, otherwise we interrupt source.5Ѓ_РЊЋЌc#яяяяV2V8v8NR^]хbdmC // elements to the reader, otherwise we interrupt source.5Ѓ_РЌЏЋc#яяяяV2V8v8NR^^Эхbdm# // elements to the reader5Ѓ_РЋђЏc#яяяяV2V8v8NR^`хcem5Ѓ_РЏ‘ђd яяяяV2V8v8NR^aхcd //5Ѓ_Рђ’‘c$яяяяV2V8v8NR^dЮхbdm$ // elements to the reader.5Ѓ_Р‘“’`яяяяV2V8v8NR^zх_am open += 25Ѓ_Р’”“`яяяяV2V8v8NR^‚х_am open += 2 // Increment 5Ѓ_Р“•”`MяяяяV2V8v8NR^•х_amM open += 2 // Increment number of open steams (2 cause each is closed 5Ѓ_Р”–•`5яяяяV2V8v8NR^х_bmR open += 2 // Increment number of open steams (2 cause each is closed twice5Ѓ_Р•—–_яяяяV2V8v8NR^љх_ao х_an5Ѓ_Р–—aяяяяaa3v3NR^џх`bo4 open += 2 // Increment number of open steams5Ѓ_Р—™`яяяяaa3v3NR^ х_ao // 5Ѓ_Рљ™`яяяяaa3v3NR^Јх_ao- // // Increment number of open steams5Ѓ_Р™›љbяяяяbb$v$NR^§хaco% (2 cause each is closed twice5Ѓ_Рљњ›bяяяяbb$v$NR^Ёхab 5Ѓ_Р›ќњ`*яяяяbb$v$NR^©х_an* // Increment number of open steams5Ѓ_Рњћќ`,яяяяbb$v$NR^®х_anH // Increment number of open steams (2 cause each is closed twice5Ѓ_Рќџћ`/яяяяbb$v$NR^°х_anJ // Increment number of open steams by 2 cause each is closed twice5Ѓ_Рћ џ`0яяяяbb$v$NR^іх_anK // Increment number of open steams by 2, cause each is closed twice5Ѓ_РџЎ `+яяяяbb$v$NR^µх_anJ // Increment number of open steams by 2 cause each is closed twice5Ѓ_Р ўЎ`:яяяяbb$v$NR^ѕх_anN // Increment number of open steams (twice 2 cause each is closed twice5Ѓ_РЎЈў`Lяяяяbb$v$NR^Вх_anL // Increment number of open steams (twice since each is closed twice5Ѓ_Рў¤Ј`;яяяяbb$v$NR^Мх_aE // Increment number of open steams (twice since we decriment 5Ѓ_РЈ¦¤`Eяяяяbb$v$NR^Рхх_bnE // Increment number of open steams (twice since we decrement 5Ѓ_Р¤§Ґ¦яяяя$$vNReнхo5Ѓ_Р¦Ё§Mяяяя%%vNRe хpM var readers = [], buffer = [], isStopped = false, isStarted = false, reason5Ѓ_Р§©Ёяяяя&&vNReгхq updating5Ѓ_РЁЄ©яяяя&&vNReхq5Ѓ_Р©«Єяяяя&&vNReх if5Ѓ_РЄ«яяяя%%vNReехp5 if (!buffer.length || !readers.length) return nil5Ѓ_Р«®¬!яяяя%%vNRe-жх "p update()5Ѓ_РЇ®яяяя%%vNRe7хp updating = true5Ѓ_Р®°Їяяяя%%vNRe;зх q х p5Ѓ_РЇі°яяяя&&vNReAпхq updating = true5Ѓ_Р°ґ±іaяяяя""vNRhЈх`bq@ slice(streams, index, ++index)(function onStream(stream) {5Ѓ_РіµґaяяяяaavNRh¦х`bqE head(slice(streams, index, ++index)(function onStream(stream) {5Ѓ_Рґ¶µaяяяяaavNRh©х`bq? head(streams, index, ++index)(function onStream(stream) {5Ѓ_Рµ·¶XяяяяaavNRhЇхWYqL var streams = source, open = 2, alive = true, stopped = false, index = 05Ѓ_Р¶ё·XяяяяaavNRhґсхWYqR var streams = stack(source, open = 2, alive = true, stopped = false, index = 05Ѓ_Р·№ёXSяяяяaavNRhАхWYqS var streams = stack(source), open = 2, alive = true, stopped = false, index = 05Ѓ_Рёј№XGяяяяaavNRhВэхWYqH var streams = stack(source), open = 2, alive = true, stopped = false5Ѓ_Р№їєјdяяяяaavNRqhхce open += 2 5Ѓ_РјАѕїяяяяaavNRt хq return index <= end ?5Ѓ_РїБАяяяяaavNRt хq return 8next(element), index === end ? (stop(), false) : true) :хqF (next(element), index === end ? (stop(), false) : true) :5Ѓ_РАВБ$яяяя``vNRt!хpE return next(element), index === end ? (stop(), false) : true) :5Ѓ_РБГВDяяяя``vNRt.хpD return next(element), index <= end ? (stop(), false) : true) :5Ѓ_РВДГ яяяя``vNRt/х (stop(), false)5Ѓ_РГД#яяяя__vNRt‡хoA return next(element), index <= end ? (stop(), false) : true5Ѓ_РјЅїѕяяяяaavNRsйхq return next()5Ѓ_РјѕЅяяяяaavNRsжхq 5Ѓ_Р№»јєяяяяaavNRi=ьхq5 if (!buffer.length || !readers.length) return nil5Ѓ_Рє»"яяяяaavNRi@чх!#q update()5Ѓ_Р°Іі±"яяяя""vNRhЌх!#q update()5Ѓ_Р±І!яяяя%%vNRhЋх!"q х!#rH assert.deepEqual(buffer, [ 1, 2, 3 ], 'all elements were yielded')\ assert.deepEqual(stops, [ undefined, undefined, undefined, undefined ], 'stopped 3 times')5Ѓ_Р«¬!яяяя%%vNRe#х "p update(up)5Ѓ_Р¤¦Ґgяяяяcc$v$NR^шхgho5Ѓ_Р|~}VAяяяяV2V8v8NR]kТхUWo0 var streams = source, open = 2, alive = true5Ѓ_Р}~WяяяяV2V8v8NR]oУхVXo index = 0хUXo; var streams = source, open = 2, alive = true, index = 05Ѓ_РwyxWяяяяgg=v=NR]хVX5Ѓ_Р?A@\яяяя``,v,NRYдАх[]zD slice(streams, index++, index + 1)(function onStream(stream) {5Ѓ_Р"$# яяяя\\,v,NRVcхw9(next(element), index === end ? (stop(), false) : true) :хwU return index <= end ? (next(element), index === end ? (stop(), false) : true) :5Ѓ_Ряяяя\\,v,NRUЄхv# if (index end) next(element)5Ѓ_Рнояяяя\\,v,NRTuќхu хv index >= end ? ()5Ѓ_Ряяяя\\,v,NRTхv index >= end ? (stop())5Ѓ_Ряяяя\\,v,NRTЃхv$ index >= end ? (stop(), false)5Ѓ_Р$яяяя\\,v,NRTѓхv- index >= end ? (stop(), false) : next()5Ѓ_Р,яяяя\\,v,NRT‰хv4 index >= end ? (stop(), false) : next(element)5Ѓ_Ряяяя\\,v,NRT‹хv; return index >= end ? (stop(), false) : next(element)5Ѓ_Р яяяя[[,v,NRTљљх5Ѓ_Р яяяя)v)NRTмхu: return index < end ? (stop(), false) : next(element)5Ѓ_Р яяяя)v)NRTрхu+ return index < end ? : next(element)5Ѓ_Р яяяя)v)NRTтхu* return index < end ? ; next(element)5Ѓ_Р яяяя)v)NRTфхu* return index < end ? : next(element)5Ѓ_Р *яяяя)v)NRTххu+ return index < end ? : next(element) 5Ѓ_Р яяяя)v)NRTщхu) return index < end ? next(element) 5Ѓ_Р)яяяя)v)NRTъњхu: return index < end ? next(element) : (stop(), false)5Ѓ_Р яяяя[[,v,NRTД—хu< return index === end ? (stop(), false) : next(element)5Ѓ_Рнпояяяя\\,v,NRQ«хu хv next()5Ѓ_Рорпяяяя\\,v,NRQхv next(element)5Ѓ_Рпсряяяя\\,v,NRQІхv/ if (index === end ? (stop(), false) : nil5Ѓ_Рртсяяяя\\,v,NRQ·хv0 if (index === end) ? (stop(), false) : nil5Ѓ_Рсутяяяя]],v,NRQёхv if (index === end) { stop(), false) : nil5Ѓ_Ртфуяяяя]],v,NRQјхw stop() false) : nil5Ѓ_Рухфяяяя^^,v,NRQЅхw stop() return false) : nil5Ѓ_Рфцхяяяя__,v,NRQАхx return false }) : nil5Ѓ_РхчцяяяяyVNRQГЊхy }5Ѓ_Рцшчi%яяяяyVNRRGхhjy+ console.log(' - ', strict.name)5Ѓ_Рчщшi%яяяяyVNRRHЌхhjy+ console.log(' - ', stream.name)5Ѓ_РшъщяяяяyVNRSРЏхy if (index => end) {5Ѓ_РщыъяяяяyVNRSдхy if (index > end) {5Ѓ_РъьыяяяяyVNRSе“хy if (index >= end) {5Ѓ_РыэьяяяяyVNRT"хy$ var index = 0, interrupt = false5Ѓ_РьяэяяяяyVNRT+’хy& var index = 0, interrupted = false5Ѓ_РэюяяяяяyVNRT7хy& return interrupted next(element)5Ѓ_РяяяяяyVNRT?хy) return interrupted || next(element)5Ѓ_РэяюяяяятVNRT2хy return next(element)хyy'/* vim:set ts=2 sw=2 sts=2 expandtab */?/*jshint asi: true undef: true es5: true node: true devel: true' forin: false latedef: false *//*global define: true */н!(typeof(define) !== "function" ? function($){ $(typeof(require) !== 'function' ? (function() { throw Error('require unsupported'); }) : require, typeof(exports) === 'undefined' ? this : exports); } : define)(function(require, exports) { 'use strict';"var nil // Shortcut for undefined./**H * Internal utility function that takes a `source` function and optionalG * `number` arguments and returns a function that calls `source` with aG * given arguments only first `number` of times it's called. Useful for@ * wrapping callbacks that must be called only ones for example. */ function limit(source, number) { number = number || 1 return function limited() {G return number-- > 0 && source ? source.apply(this, arguments) : nil }}function normalize(source) {& return function stream(next, stop) {' var stopped = false, reading = true( source(function onElement(element) {( if (!stopped && false !== reading)( return (reading = next(element)) }, function onStop(reason) {; return stopped ? nil : (stopped = true, stop(reason)) }) }}/**K * Utility function that returns streams of elements of given `array`. ThisI * function is dangerous as array mutations will have side effects on theJ * returned stream so it should be used with a care, reader of such streamL * **MUST NOT** mutate source array, this is also reason why we don't export * this function. */ function streamArray(elements) {& return function stream(next, stop) { var index = 0# while (index < elements.length)< // If stream reader interrupts reading we just return.9 if (false === next(elements[index++])) return falseK // Once all elements were yielded we stop a stream if such callback was // passed. if (stop) stop() }}/**$ * Creates stream of given elements. * @examples# * list('a', 2, {})(console.log) */function list() {; return streamArray(Array.prototype.slice.call(arguments))}exports.list = list/*8 * Creates empty stream. This is equivalent of `list()`. */function empty() {> return function stream(next, stop) { return stop && stop() }}exports.empty = empty/**# * Returns stream of mapped values. * @param {Function} lambda# * function that maps each value * @param {Function} input * source stream to be mapped * @examples: * var stream = list({ name: 'foo' }, { name: 'bar' })D * var names = map(function(value) { return value.name }, stream) * names(console.log) * // 'foo' * // 'bar'! * var numbers = list(1, 2, 3)N * var mapped = map(function onEach(number) { return number * 2 }, numbers) * mapped(console.log) * // 2 * // 4 * // 6 */function map(lambda, source) {& return function stream(next, stop) {( source(function onElement(element) {" return next(lambda(element)) }, stop) }}exports.map = map/**% * Returns stream of filtered values. * @param {Function} lambda" * function that filters values * @param {Function} source" * source stream to be filtered * @examples* * var numbers = list(10, 23, 2, 7, 17)+ * var digits = filter(function(value) {' * return value >= 0 && value <= 9 * }, numbers) * digits(console.log) * // 2 * // 7 */!function filter(lambda, source) {& return function stream(next, stop) {( source(function onElement(element) {3 return lambda(element) ? next(element) : true }, stop) }}exports.filter = filter/**# * Returns stream of reduced values * @param {Function} source * stream to reduce. * @param {Function} reducer * reducer function * @param initial * initial value * @examples! * var numbers = list(2, 3, 8)> * var sum = reduce(function onElement(previous, current) {( * return (previous || 0) + current * }, numbers) * sum(console.log) * // 13 */+function reduce(reducer, source, initial) {& return function stream(next, stop) { var value = initial( source(function onElement(element) {% value = reducer(value, element) }, function onStop(error) {# if (error) return stop(error) next(value) if (stop) stop() }) }}exports.reduce = reduce/**L * This function returns stream of tuples, where the n-th tuple contains theI * n-th element from each of the argument streams. The returned stream isE * truncated in length to the length of the shortest argument stream. * @params {Function}" * source steams to be combined * @examples% * var a = list([ 'a', 'b', 'c' ])" * var b = list([ 1, 2, 3, 4 ])/ * var c = list([ '!', '@', '#', '$', '%' ]) * var abc = zip(a, b, c) * abs(console.log) * // [ 'a', 1, '!' ] * // [ 'b', 2, '@' ] * // [ 'c', 3, '#' ] */var zip = (function Zip() {+ // Returns weather array is empty or not.2 function isEmpty(array) { return !array.length }G // Utility function that check if each array in given array of arraysA // has at least one element (in which case we do have a tuple).: function hasTuple(array) { return !array.some(isEmpty) }F // Utility function that creates tuple by shifting element from each // array of arrays. function shiftTuple(array) {( var index = array.length, tuple = []< while (0 <= --index) tuple.unshift(array[index].shift()) return tuple } return function zip() {7 var sources = Array.prototype.slice.call(arguments)( return function stream(next, stop) {? var buffers = [], id, reason, isStopped = false, shortest' function onElement(id, element) {N // If resulting stream is already stopped (we are in truncate mode) orP // if this stream is stopped (we deal with badly implemented stream that> // yields value after it's stopped) we ignore element." if (isStopped) return null* // Otherwise we buffer an element.! buffers[id].push(element)) // If tuple is ready we yield it.C return hasTuple(buffers) ? next(shiftTuple(buffers)) : true }" function onStop(id, error) {N // If shortest stream was already stopped then we are in truncate mode@ // which means we ignore all the following stream stops." if (isStopped) return nullL // If stream being stopped is the first one to be stopped or if it'sK // shorter then the shortest one stopped, we update stop reason and- // shortest stopped stream reference.@ if (!shortest || shortest.length > buffers[id].length) { shortest = buffers[id] reason = error }P // If shortest stream has no buffered elements, we stop resulting stream // & do some clean up. if (!shortest.length) {' // Marking stream as stopped. isStopped = true // Stopping a stream. stop(reason)K // Setting all closure captured elements to `null` so that gc can // collect them.# buffers = shortest = null } } // Initializing buffers. id = sources.length( while (0 <= --id) buffers.push([]) // Start reading streams. id = sources.length while (0 <= --id)D sources[id](onElement.bind(null, id), onStop.bind(null, id)) } }})()exports.zip = zip/**K * Returns stream containing first `n` elements of given `source`, on which * given lambda returns `true`. * * @param {Function} lambda# * function that takes elements. * @param {Function} source* * source stream to take elements from. * @examples* * var numbers = list(10, 23, 2, 7, 17)) * var digits = take(function(value) { * return value >= 10 * }, numbers) * digits(console.log) * // 10 * // 23 */function take(lambda, source) {& return function stream(next, stop) {( source(function onElement(element) {> return lambda(element) ? next(element) : stop() && false }, stop = limit(stop)) }}exports.take = take/**M * Returns a stream consisting of the given `source` stream elements startingL * form the `start` zero-based index till `end` zero-based index element. If5 * `end` is not passed all elements will be included. */$function slice(source, start, end) {3 // Zero-based index at which to begin extraction. start = start || 00 // Zero-based index at which to end extraction end = end || Infinity& return function stream(next, stop) { var index = 0 filter(function(element) { return start <= index ++, }, source)(function onElement(element) { next(element) if (index === end) { stop() return false } }, stop = limit(stop)) }}exports.slice = slice/**K * Returns a stream containing only first `number` of elements of the givenM * `source` stream or all elements, if `source` stream has less than `number`= * of elements. If `number` is not passed it defaults to `1`. * @param {Function} source * source stream * @param {Number} number=1, * number of elements to take from stream */function head(source, number) {= return slice(source, 0, number && number >= 0 ? number : 1)}exports.head = head/**N * Returns a stream equivalent to given `source` stream, except that the firstN * `number` of elements are omitted. If `source` stream has less than `number`O * of elements, then empty stream is returned. `number` defaults to `1` if it's * not passed. * @param {Function} source& * source stream to return tail of. * @param {Number} number=1. * Number of elements that will be omitted. */function tail(source, number) {: return slice(source, number && number >= 0 ? number : 1)}exports.tail = tail/**O * Returns a stream that contains all elements of each stream in the order theyL * appear in the original streams. If any of the `source` streams is stoppedM * with an error than it propagates to the resulting stream and it also get's * stopped. * @examples5 * var stream = append(list(1, 2), list('a', 'b')) * stream(console.log) * // 1 * // 2 * // 'a' * // 'b' */function append() {8 var streams = Array.prototype.slice.call(arguments, 0)& return function stream(next, stop) {* var source, sources = streams.slice(0) function onStop(error) {+ if (error) return stop && stop(error): if ((source = sources.shift())) source(next, onStop) else return stop && stop() } onStop() }}exports.append = append/**J * Returns a stream that contains all elements of each stream of the givenP * source stream. `source` is stream of streams whose elements will be containedK * by the resulting stream. Any error from any stream will propagate to theP * resulting stream. Stream is stopped when all streams from `source` and sourceI * itself is ended. Elements of the stream are position in order they areL * delivered so it could happen that elements from second stream will appear2 * before or between elements of the first stream. * @param {Function} sourceL * Stream of streams whose elements will be contained by resulting stream * @examples" * function async(next, stop) { * setTimeout(function() { * next('async') * stop() * }, 10) * }4 * var stream = merge(list(async, list(1, 2, 3))) * stream(console.log) * // 1 * // 2 * // 3 * // 'async' */function merge(source) {& return function stream(next, stop) { var open = 1, alive function onStop(error) {0 if (!open || false === alive) return false if (error) open = 0 else open -- if (!open) stop(error) }& source(function onStream(stream) { open ++% stream(function onNext(value) {D return open && false !== alive ? alive = next(value) : false }, onStop) }, onStop) }}exports.merge = merge/**% * Utility function to print streams. * @param {Function} stream * stream to print * @examples# * print(list('Hello', 'world')) */function print(stream) { console.log('>>')< stream(console.log.bind(console), function onStop(error) {# if (error) console.error(error) else console.log('<<') })}exports.print = print/**H * Returns a stream equivalent to a given `source`, with difference thatK * all the consumers will start reading it from the point it's at the givenM * moment. This is useful with streams such as user generated events (clicks,M * keypress, etc..) where multiple stream readers might need to read from the, * same source. In other words, this is yourK * [pub / sub](http://en.wikipedia.org/wiki/Publish/subscribe) for streams. * @param {Function} source; * Stream whose elements get published to a subscribers. * @return {Function}5 * Stream that multiple subscribers can read from. * @examples" * function range(start, end) {, * return function stream(next, stop) { * var number = start - 1( * setTimeout(function onNext() { * if (++number >= end) * return stop()' * if (false !== next(number))# * setTimeout(onNext, 2) * }, 2) * } * } * function printer(index) {' * return function print(stream) {> * stream(console.log.bind(console, '#' + index + '>'),9 * console.log.bind(console, '<#' + index)) * } * } * var numbers = range(1, 5) * printer(1)(numbers)8 * setTimeout(function () { printer(2)(numbers) }, 5) *. * // Output will look something like this: * #1> 1 * #1> 2 * #1> 3 * #2> 1 * #1> 4 * #2> 2 * <#1 * #2> 3 * #2> 4 * <#2 *L * // If you noticed second print started form the first `1` element. Now* * // lets do similar thing with a hub. *$ * var numbers = hub(range(1, 5)) * printer(1)(numbers)8 * setTimeout(function () { printer(2)(numbers) }, 5) */ * // In this case output will be different: * * #1> 1 * #1> 2 * #1> 3 * #1> 4 * #2> 4 * <#1 * <#2 *L * // Notice this time second print only printed only following elements. */function hub(source) {/ var listeners = [], isStopped = false, reason# source(function onNext(element) { var index = 0E // Maybe it'd be better to just iterate on sliced array instead ?& while (index < listeners.length) {3 if (listeners[index++][0](element) === false)$ listeners.splice(--index, 1) } }, function onStop(error) { isStopped = true reason = error var listener, stop- while ((listener = listeners.shift())) {, if ((stop = listener[1])) stop(reason) } })& return function stream(next, stop) {: // If stream is already stopped, we notify a listener.' if (isStopped && stop) stop(reason)! // Else we register listener.' else listeners.push([ next, stop ]) }}exports.hub = hub/**O * Returns a stream equivalent to a given `source` by caching all it's elementsN * into memory for faster reads. This is useful with `source` streams that areL * expensive to compute (requires access to the network for example). Use itD * carefully though, do not cache infinite streams and be aware thatB * asynchronous stream when cached will yield some or all elementsL * synchronously. Also be aware, that unlike other functions, this is greedyF * which means that it will start reading `source` stream immediately. * @param {Function} source * source stream to cache. * @returns {Function}B * cached equivalent of source that can be read multiple times. */function cache(source) { var buffer = []@ // Creating a stream that streams element of the buffer array. function cached(next, stop) { var index = 0! while (index < buffer.length)7 if (false === next(buffer[index++])) return false stop() }9 return append(cached, hub(function stream(next, stop) {( source(function onElement(element) { buffer.push(element) return next(element) }, stop) }));}exports.cache = cache/**N * Returns stream equivalent to a given `source` with a difference that it hasL * a state, meaning that if reader stops reading on n-th element next readerM * will continue reading from n-th element. Purpose is to wrap any other typeL * of stream, such that each element of `source` can be read only once. ThisO * allow element distribution across different consumers with a help of `head`, * `tail` and similars. * @param {Function} source0 * source stream to create stack stream from. * @returns {Function}< * stack equivalent of source that can be read only once. */function stack(source) {M var readers = [], buffer = [], isStopped = false, isStarted = false, reason function update() {5 if (!buffer.length || !readers.length) return nil. var resume = readers[0][0](buffer.shift())) if (false === resume) readers.shift() update() } function onNext(element) { update(buffer.push(element)) } function onStop(error) { isStopped = true reason = error var reader = readers.shift()F return reader ? onStop(error, reader[1] && reader[1](error)) : nil }& return function stream(next, stop) {: // If stream is already stopped, we notify a listener.@ if (isStopped && !buffer.length) return stop && stop(reason) readers.push([ next, stop ]) update()B // If `source` stream is not yet being read, start reading it. if (isStarted) return nil isStarted = true source(onNext, onStop) }}exports.stack = stack/**J * Returns a stream that contains all elements of each stream of the givenP * source stream. `source` is stream of streams whose elements will be containedK * by the resulting stream. Any error from any stream will propagate to theP * resulting stream. Stream is stopped when all streams from `source` and sourceO * itself are ended. Elements of the stream are position in order, all elements6 * of first stream, all elements of second stream etc. * @param {Function} sourceL * Stream of streams whose elements will be contained by resulting stream * @examples" * function async(next, stop) { * setTimeout(function() { * next('async') * stop() * }, 10) * }3 * var stream = join(list(async, list(1, 2, 3))) * stream(console.log) * // 'async' * // 1 * // 2 * // 3 */function join(source) {& return function stream(next, stop) {H var streams = stack(source), open = 0, alive = true, stopped = false stop = limit(stop) !function recur(error) {/ head(streams)(function onStream(stream) { console.log('!!!!!!') open += 2 console.log(' >')+ console.log(' + ', stream.name), stream(function onElement(element) {* console.log(' |- ', element)J // If steam is still open and read is not interrupted we deliverB // element to the reader, otherwise we interrupt source.6 return !stopped && open && false !== alive ?. alive = next(element) : false$ }, function onStop(error) { open --+ console.log(' - ', stream.name) if (error) stop(error)! else if (!open) recur() })! }, function onStop(error) { open -- console.log('') if (error) stop(error) if (open === 0) recur()$ else if (open === -1) stop() }) }() }}exports.join = join});5Ѓ_РРТнСkяяяя[[,v,NRKЊzхjlu console.log(' <')5Ѓ_РСУТe%яяяяuVNRK•‰хdfu+ console.log(' - ', stream.name)5Ѓ_РТФУ-'яяяя[[,v,NRLх,.uK // If stream is already stopped, and buffer is empty notify a listener.5Ѓ_РУХФ-Kяяяя[[,v,NRL}х,.uJ // If stream is already stopped, and buffer is empty we stop a reader.5Ѓ_РФЦХ/яяяя\\,v,NRL'х.0u // 5Ѓ_РХЧЦ/яяяя\\,v,NRL*х.0v5Ѓ_РЦШЧ0яяяя\\,v,NRL+х/1v // otherwise wi 5Ѓ_РЧЩШ0яяяя\\,v,NRL0х/1v // Otherwise wi 5Ѓ_РШЪЩ0яяяя\\,v,NRL1~х/1v" // Otherwise we save a reader.5Ѓ_РЩЫЪ5яяяя\\,v,NRLXх46v if (!isStarted) return nil5Ѓ_РЪЬЫ5яяяя\\,v,NRLYх46v if (!isStarted) {}5Ѓ_РЫЭЬ5яяяя78vNRLZх46v if (!isStarted) { }5Ѓ_РЬЮЭ7яяяя77vNRL_х69w 5Ѓ_РЭЯЮ7яяяя77vNRL`х685Ѓ_РЮаЯ5яяяя99vNRL`х56u х57v isStarted = true source(onNext, onStop)5Ѓ_РЯва7яяяя""vNRLb€х68w source(onNext, onStop)5Ѓ_Рагбв"яяяя""vNRL‚х!#w update()5Ѓ_Рвйг!яяяя##vNRLѓ†х!"w х!#x buffer.push(element)5Ѓ_Ргкей,яяяя$$vNRMЅ‡хx хy reader5Ѓ_Рйлкяяяя%%vNRMЗхy хz var reason5Ѓ_Ркмляяяя%%vNRMПхz var reader = readers.shift()5Ѓ_Рлмяяяя$$vNRMрх5Ѓ_Ргждйе( яяяя##vNRM…х()x х(*y if ()5Ѓ_Резж)яяяя##vNRMх(*y if (readers.length)5Ѓ_Ржиз)яяяя##vNRMх(*y if (readers.length) {}5Ѓ_Рзи)яяяя##vNRMх(*y if (readers.length) { }5Ѓ_Ргед)яяяя##vNRLъх)*x5Ѓ_Равб5яяяя99vNRLtх46w return if (!isStarted) {5Ѓ_РЇ±ґ°T яяяя\\,v,NRJ хTUt хTVu var task5Ѓ_Р°І±Xяяяя]],v,NRJ)хXYu хXZv task = head()5Ѓ_Р±іІYяяяя]],v,NRJ0хXZv task = head(streams)5Ѓ_РІіZяяяя]],v,NRJ8хY[v& task(function onStream(stream) {5Ѓ_РЌЏЋXяяяяZZ0v0NRF|хWYq< var stream = head(streams)(function onStream(stream) {5Ѓ_Р‰‹Љe яяяяZZ0v0NREшхdf5Ѓ_Р„†…_5яяяяZZ0v0NREvх^`r4 return !stopped && open && false !== alive/ ? alive = next(element) : false5Ѓ_РЃЂbяяяяZZ0v0NRCххacr6 console.log(' < close', stream.name, open)5Ѓ_РxzyQяяяя\\0v0NRCСхQRrхQSsopen 5Ѓ_Р яяяяvNPтхvм!(typeof(define) === "undefined" ? function($){ $(typeof(require) === 'undefined' ? function() { throw Error('require unsupported') } : require , typeof(exports) === 'undefined' ? this : export); } : define)(function(require, exports) {5Ѓ_Р яяяяvNPтхvм!(typeof(define) === "undefined' ? function($){ $(typeof(require) === 'undefined' ? function() { throw Error('require unsupported') } : require , typeof(exports) === 'undefined' ? this : export); } : define)(function(require, exports) {5Ѓ_Р яяяяvNPтхvм!(typeof(define) === 'undefined' ? function($){ $(typeof(require) === 'undefined' ? function() { throw Error('require unsupported') } : require , typeof(exports) === 'undefined' ? this : export); } : define)(function(require, exports) {5Ѓ_Р‡–ўЎ_яяяяvNPм–х^`q/ head(streams)(function jnStream(stream) {5Ѓ_Р‡™€Ў–pяяяяvNPK хoqq var open = 0, alive5Ѓ_Р–љ—™tяяяяvNPKНхsu5Ѓ_Р™›љuяяяяvNPKОхuvp хuwq else open--5Ѓ_Рљњ›qяяяяvNPKйхqrq хqsr console.log()5Ѓ_Р›ќњrяяяяvNPKохqsr console.log('')5Ѓ_РњћќrяяяяvNPKохqsr console.log('>>')5Ѓ_РќџћrяяяяvNPKфхqsr console.log('!!')5Ѓ_Рћ џrяяяяvNPKяхqsr console.log('!!', open)5Ѓ_Рџ sяяяяvNPLMхrtr' if (false === alive) return false5Ѓ_Р–™—tяяяяvNPKхsu5Ѓ_Р—uяяяяvNPK хuvp хuwq else open --5Ѓ_Р‡‰–€яяяяvNPJFхq var index = 0, tail = 5Ѓ_Р€Љ‰яяяяvNPJOхq 5Ѓ_Р‰‹ЉяяяяvNPJPхq5 var index = 0, tail = filter(function(element) { 5Ѓ_РЉЊ‹яяяяvNPJTхq 5Ѓ_Р‹ЌЊ5яяяяvNPJVхqQ var index = 0, tail = filter(function(element) { return start <= index ++ }, 5Ѓ_РЊЋЌяяяяvNPJ_хq var index = 0, tailB tail = filter(function(element) { return start <= index ++ }, 5Ѓ_РЌЏЋBяяяяvNPJbхrI tail = filter(function(element) { return start <= index ++ }, source)5Ѓ_РЋђЏяяяяvNPJeх5Ѓ_РЏ‘ђяяяяvNPJgх5Ѓ_Рђ“‘яяяяvNPJkхp& tail(function onElement(element) {5Ѓ_Р‘”’“яяяяvNPJЈхp хq stop = limit()5Ѓ_Р“•”яяяяvNPJ§хq stop = limit(stop)5Ѓ_Р”•яяяяvNPJ«хq }, stop)5Ѓ_Р‘“’яяяяvNPJ…хp var index = 0, tail, stop5Ѓ_РX[YѓZ*яяяяvNPG©пхq8 return next(element), index === end ? stop() : nil5Ѓ_РZ\[яяяяvNPHXрхяq(function take(lambda, source, include) {5Ѓ_Р[]\.яяяяvNPHfхqG return lambda(element) ? next(element) : include stop() && false5Ѓ_Р\^]/яяяяvNPHyхq. return lambda(element) ? next(element) :% include stop() && false5Ѓ_Р]_^яяяяvNPH|хr. include ? next() stop() && false5Ѓ_Р^`_яяяяvNPH‚хr6 include ? next(elements) stop() && false5Ѓ_Р_a`$яяяяvNPH…хr5 include ? next(element) stop() && false5Ѓ_Р`ba$яяяяvNPH†хr8 include ? next(element) && stop() && false5Ѓ_Рacb)яяяяvNPHџхr3 include ? next(element)stop() && false5Ѓ_Рbdc$яяяяvNPHЎхr4 include ? next(element) stop() && false5Ѓ_РcedяяяяvNPHЈхr5 include ? (next(element) stop() && false5Ѓ_Рdfe%яяяяvNPH§хr6 include ? (next(element), stop() && false5Ѓ_Рegf-яяяяvNPH¬хr7 include ? (next(element), stop(), && false5Ѓ_Рfhg2яяяяvNPH®хr4 include ? (next(element), stop(), false5Ѓ_Рgih4яяяяvNPH±хr5 include ? (next(element), stop(), false)5Ѓ_Рhji яяяяvNPHѕхr6 (include ? (next(element), stop(), false)5Ѓ_РikjяяяяvNPHБхr5 (include ? next(element), stop(), false)5Ѓ_Рjlk%яяяяvNPHЕхr; (include ? next(element) : nil, stop(), false)5Ѓ_Рkml яяяяvNPHПхr.(include ? next(element) : nil, stop(), false)хr\ return lambda(element) ? next(element) :(include ? next(element) : nil, stop(), false)5Ѓ_Рlnm-яяяяvNPHУхq, return lambda(element) ? next(element)L :(include ? next(element) : nil, stop(), false)5Ѓ_РmonяяяяvNPHШухrM : (include ? next(element) : nil, stop(), false)5Ѓ_РnpoяяяяvNPIхr take(function() {! }, filter(function(element) {5Ѓ_РoqpяяяяvNPIхs }, )5Ѓ_РprqяяяяvNPIхs }, true)5Ѓ_РqsrяяяяvNPI!хs3 }, source), true)(function onElement(element) {5Ѓ_РrtsяяяяvNPI&хs }, source), true)" (function onElement(element) {5Ѓ_РsutяяяяvNPI'х5Ѓ_РtvuяяяяvNPI'х5Ѓ_РuwvяяяяvNPI(х5Ѓ_РvxwяяяяvNPI,хqreturn start <= index ++хq: }, filter(function(element) { return start <= index ++5Ѓ_РwyxяяяяvNPI.хp}, source), true)хpL }, filter(function(element) { return start <= index ++ }, source), true)5Ѓ_РxzyяяяяvNPI@хo take(function(element) {5Ѓ_Рy{zяяяяvNPICххo хp index < end5Ѓ_Рz}{яяяяvNPIXчхp return index < end5Ѓ_Р{~|}"яяяяvNPIЊхp! }, filter(function(element) {0 return start <= index ++ }, source), true)5Ѓ_Р}~яяяяvNPIЏхq return start <= index ++ }, source), true)5Ѓ_Р~ЂяяяяvNPI‘хr }, source), true)()5Ѓ_РЃЂяяяяvNPI’ъхr! }, source), true)(next, stop)5Ѓ_РЂ‚ЃцяяяяvNPI«хцчr * хцшs * @param {Boolean} include5Ѓ_РЃ‚чяяяяvNPI№хчшs * хчщt) * if true will include first element 5Ѓ_Р{}|GяяяяvNPI†хpF }, filter(function(element) { return start <= index ++ }, source), true)5Ѓ_РXZY яяяяvNPG¤хq: return (next(element), index === stop ? stop() : nil5Ѓ_Р57V6яяяяvNPEхq хr if ()5Ѓ_Р6P7 яяяяvNPEхr if (index === ended)5Ѓ_Р7QOPяяяяvNPG7хr if (index === end)5Ѓ_РPRQяяяяvNPG9хr if (index === end) {}5Ѓ_РQSRяяяяvNPG:хr if (index === end) { }5Ѓ_РRTSяяяяvNPG;хs хt stop()5Ѓ_РSUTяяяяvNPG>кхt хu return false5Ѓ_РTUяяяяvNPGHлхu }, stop)5Ѓ_Р78POяяяяvNPG2хr if (index === ended) {}5Ѓ_Р79O8яяяяvNPEхr if (index === end)5Ѓ_Р8:9яяяяvNPEйхr if (index === end) stop()5Ѓ_Р9;:яяяяvNPFbахr }, stop)5Ѓ_Р:<;яяяяvNPFiхr& return if (index === end) stop()5Ѓ_Р;=<яяяяvNPFoхr" return index === end) stop()5Ѓ_Р<>=яяяяvNPFrхr# return index === end ? stop()5Ѓ_Р=?>яяяяvNPF{хr$ return index === end ? (stop()5Ѓ_Р>@?$яяяяvNPF|бхr2 return index === end ? (stop(), false) : nil5Ѓ_Р?A@%яяяяvNPF“хr4 return index === end ? (stop() && false) : nil5Ѓ_Р@BAяяяяvNPF–хr3 return index === end ? stop() && false) : nil5Ѓ_РACB-яяяяvNPFвхr2 return index === end ? stop() && false : nil5Ѓ_РBDC&яяяяvNPF›хr2 return index === end ? stop() \\ false : nil5Ѓ_РCED&яяяяvNPFќдхr2 return index === end ? stop() || false : nil5Ѓ_РDFE&яяяяvNPFВхr0 return index === end ? stop(), false : nil5Ѓ_РEGFяяяяvNPFЕхr1 return index === end ? (stop(), false : nil5Ѓ_РFHG+яяяяvNPFИехr2 return index === end ? (stop(), false) : nil5Ѓ_РGIHяяяяvNPFМхr3 var val index === end ? (stop(), false) : nil5Ѓ_РHJI яяяяvNPFОхr5 var val = index === end ? (stop(), false) : nil5Ѓ_РIKJяяяяvNPFПхr хs console.log()5Ѓ_РJLKяяяяvNPFФхs console.log(val)5Ѓ_РKMLяяяяvNPFШжхs хt return val5Ѓ_РLNMяяяяvNPFнхt хu console.log()5Ѓ_РMNяяяяvNPFсихu console.log(index === end)5Ѓ_Р*,3+ яяяяvNPDКхq+ index <= end ? stop() : next(element)5Ѓ_Р+-,яяяяvNPDНхq% index <= end ? : next(element)5Ѓ_Р,.-яяяяvNPDОхq" index <= end ? next(element)5Ѓ_Р-/."яяяяvNPDФхq" index <= end ? next(element)5Ѓ_Р.1/яяяяvNPDШхq# iindex <= end ? next(element)5Ѓ_Р/201яяяяvNPDЮхq& if (index <= end ? next(element)5Ѓ_Р12яяяяvNPDгхq' if (index <= end) ? next(element)5Ѓ_Р/10яяяяvNPDЪхq end = endf || Infinity5Ѓ_Р(*)яяяяvNPD¶Ыхq. index + 1 < end ? stop() : next(element)5Ѓ_РяяяяvNPDхq return index < end5Ѓ_РяяяяvNPDхq return index < end 5Ѓ_РяяяяvNPC&Чхq return index + 1<= end5Ѓ_РяяяяvNPC(Цхq return index + 1 <= end5Ѓ_РяяяяvNPC)Ххq return index + 1 < end5Ѓ_Р яяяяvNPBРхq return end > index + 15Ѓ_РяяяяvNPBіхq return end > index5Ѓ_Р яяяяvNPB‡Нхq return end > index5Ѓ_Р яяяяvNPB хq var start = 05Ѓ_Р яяяяvNPBхq var startIndex = 05Ѓ_РяяяяvNPB хq var startIndex = 0, 5Ѓ_РяяяяvNPB*Ихq! var startIndex = 0, stopIndex5Ѓ_РяяяяvNPB;Йх5Ѓ_РяяяяvNPB>Кхp return end >= index5Ѓ_РяяяяvNPAЫЖхq return end >= ++ index - 15Ѓ_РшьщэыяяяяvNP@Чхq return start <= index5Ѓ_РыьяяяяvNP@ЩБхq return start <= ++index5Ѓ_РшъыщяяяяvNP@Лхq return start < index ++5Ѓ_РщъяяяяvNP@Лїхq return start < index ++5Ѓ_РртсяяяяvNP@’хp return end >= index ++# }, filter(function(element) { return start <= index ++ }, source))5Ѓ_РорпяяяяvNP@Њхp source))хm source))хn 5Ѓ_РкмляяяяvNP@1»хo return end > index ++5Ѓ_РЬЯЭаЮяяяяvNP?Ёхo return index < end5Ѓ_РЮЯяяяяvNP?©µхo return index++ < end5Ѓ_РЬЮЭяяяяvNP?њґхo return ++ index <= end5Ѓ_РКМЛяяяяppvNP>рхx return (function(element) {5Ѓ_Р–—[яяяяjjvNP9$хZ\5Ѓ_РxzyW(яяяяXXvNP0Ц‹хVXnH var streams = stack(source), open = 1, alive = true, stopped = false5Ѓ_РlmonYяяяяXXvNP0хYZp хY[q 5Ѓ_РlnmZяяяяXXvNP0хY[pK error || !open ? (open = false, stopped = true, stop(error)) :5Ѓ_РjlkZ яяяяXXvNP/юхY[pA error ? (open = fale, stopped = true, stop(error)) :5Ѓ_РcefdY яяяяXXvNP/ЬхXZp return !stopped ? nil :5Ѓ_РdeYяяяяXXvNP/ЭхXZp& return !stopped && !open ? nil :5Ѓ_Р"$#_яяяяff!vNP-{{х^`5Ѓ_Р ZяяяяZZ!vNP+*хY\5Ѓ_РцшчYяяяяpp'v'NP*/хXZx console.log('sto')5Ѓ_Ркмлj яяяяJ JvNP(\хik5ЃзЄ