VimџUnDoеn8 var names = map(data, function(value) { return value.name })+ print(names) // => **/? return transform(source, function(next, value, accumulated) {& return next(f(value), accumulated) })}5Ѓ_Р яяяяvPѓ”&х&var transform = require("./transform")5Ѓ_Р!яяяяvPѓ”)х#var reduce = require("./transform")5Ѓ_РяяяяvPѓ”,хх5Ѓ_Р яяяяvPѓ”.х var reduce = require("./reduce")5Ѓ_Р!яяяяvPѓ”3х#var reducible = require("./reduce")5Ѓ_РяяяяvPѓ”8х5Ѓ_Р яяяяvPѓ”9хmodule.exports = map5Ѓ_Р 'яяяяvPѓ”Nх 7 Flattens given `reducible` collection of `reducible`s5Ѓ_Р яяяяvPѓ”Pх * Flattens given sequences of `reducible`s5Ѓ_Р 'яяяяvPѓ”Rх ) Flattens given sequence of `reducible`s5Ѓ_Р 'яяяяvPѓ”Tх ( Flattens given sequence of `sequence`s5Ѓ_Р яяяяvPѓ”Uх ' Flattens given sequence of `sequences5Ѓ_РяяяяvPѓ”Vх & Flattens given sequence of sequences3to a `reducible` with items of nested `reducibles`.х 5 to a `reducible` with items of nested `reducibles`.5Ѓ_Р6яяяяvPѓ”Xх Z Flattens given sequence of sequences to a `reducible` with items of nested `reducibles`.5Ѓ_РCяяяяvPѓ”bх W Flattens given sequence of sequences to a sequence with items of nested `reducibles`.5Ѓ_РяяяяvPѓ”gх all nested `reducibles`.5Ѓ_РяяяяvPѓ”jх all nested sequence.5Ѓ_РяяяяvPѓ”†х all nested sequences.5Ѓ_Р=яяяяvPѓ”іх C all nested sequences. Note that function does no guarantees about5Ѓ_Р:яяяяvPѓ”єх : all nested sequences. Note that function does not about5Ѓ_Р )яяяяvPѓ”Дх) an order of items in resulting sequence5Ѓ_РGяяяяvPѓ”Шх G all nested sequences. Note that function does not deals with ordering5Ѓ_Р 9яяяяvPѓ”ах9 of items in resulting sequence. Items there will appear5Ѓ_Р яяяяvPѓ”йх appear 5Ѓ_Р яяяяvPѓ•х are ordered by time 5Ѓ_Р яяяяvPѓ•х are ordered by the time 5Ѓ_РяяяяvPѓ•0х " item from the second subsequnce 5Ѓ_РяяяяvPѓ•1х # item from the second subssequnce 5Ѓ_Р яяяяvPѓ•7х # item from the second sub-sequnce 5Ѓ_Р! $яяяяvPѓ•:х $ item from the second sub-sequence 5Ѓ_Р "!яяяяvPѓ•iх sequence too.5Ѓ_Р!#"яяяяvPѓ•p х sequence too. If you need to 5Ѓ_Р"$#-яяяяvPѓ•Ѓх- sequence too. If you need to keep order of 5Ѓ_Р#%$5яяяяvPѓ•€х: sequence too. If you need to keep order by sequence you 5Ѓ_Р$&%7яяяяvPѓ•‹ х7 sequence too. If you need to keep order by index you 5Ѓ_Р%'&яяяяvPѓ•“х sequential5Ѓ_Р&('яяяяvPѓ•х sequential ordering5Ѓ_Р')("яяяяvPѓ•¤х" sequential ordering by wrapping 5Ѓ_Р(*)8яяяяvPѓ•«х8 sequential ordering by wrapping `source` into sequence5Ѓ_Р)+*яяяяvPѓ•Г х printх х5Ѓ_Р*,+&яяяяvPѓ•Ьх& print(flatten([ [1, 2], [ 3, 4 ] ]))5Ѓ_Р+-,=яяяяvPѓ•их> print(flatten([ [1, 2], [ 3, 4 ] ])) // => 5Ѓ_Р,.-яяяяP€JcхM/*jshint asi: true undef: true es5: true node: true browser: true devel: true5Ѓ_Р-/. яяяяP€Jcх9 forin: true latedef: false globalstrict: true */5Ѓ_Р.0/яяяяP€Jdх5Ѓ_Р/10яяяяP€Jdх 'use strict';5Ѓ_Р021яяяяP€Jfх "use strict';5Ѓ_Р132яяяя vяяяPЉ бххх5Ѓ_Р243Yяяяя vяяяPЉ пх]print(flatten([ ["A", "B"] , flatten([ [ "a", "b" ], flatten([ [ 1 ], [ 2 ], [ 3 ] ]) ])) ]))5Ѓ_Р3543яяяя[vPЉ(х х5Ѓ_Р465яяяя [ vPЉ,х console.log()5Ѓ_Р576яяяя [ vPЉ,х console.log("")5Ѓ_Р687яяяя [ vPЉ3х console.log(nested)5Ѓ_Р798яяяя[vPЉ;х х5Ѓ_Р8:9яяяя [ vPЉ>х console.log()5Ѓ_Р9;: яяяя [ vPЉcх\print(flatten([ ["A", "B"] , flatten([ [ "a", "b" ], flatten([ [ 1 ], [ 2 ], [ 3 ] ]) ]) ]))5Ѓ_Р:<; яяяя [ vPЉeх ^//print(flatten([ ["A", "B"] , flatten([ [ "a", "b" ], flatten([ [ 1 ], [ 2 ], [ 3 ] ]) ]) ]))5Ѓ_Р;=<яяяя [ vPЉeх5Ѓ_Р<>=яяяя[vPЉfх5Ѓ_Р=?>яяяя[vPЉіхх5Ѓ_Р>@?яяяя[vPЉ·хvar eventual = require()5Ѓ_Р?A@яяяя[vPЉ·хvar eventual = require("")5Ѓ_Р@BAяяяя[vPЉЅх4 return reduce(source, function(result, nested) {5Ѓ_РACBяяяя[vPЉДх }, initial)5Ѓ_РBDCяяяя[vPЉЬх$var eventual = require("./eventual")5Ѓ_РCED яяяя[vPЉЭх"var eventual = require("eventual")5Ѓ_РDFEяяяя[vPЉэх console.log(value)5Ѓ_РEGF#яяяя[vPЉ"х= return reduce(source, eventual(function(result, nested) {5Ѓ_РFHGяяяя[vPЉ-х }), initial)5Ѓ_РGIHяяяя[vPЉ0х х5Ѓ_РHJIяяяя[vPЉ5х console.log()5Ѓ_РIKJяяяя[vPЉFх х5Ѓ_РJLKяяяя[vPЉIх console.log()5Ѓ_РKMLяяяя[vPЉАх х5Ѓ_РLNMяяяя [ vPЉНх }, initial)5Ѓ_РMON)яяяя [ vPЉСх4 return reduce(source, function(result, nested) {5Ѓ_РNPO+яяяя [ vPЉшх5 return reduce(nested, function(result, value) {5Ѓ_РOQPяяяя [ vPЉых }, result)5Ѓ_РPRQяяяя [ vPЉюх" return next(result, value)5Ѓ_РQZRяяяя [ vPЉ х( var result = next(result, value)5Ѓ_РR[WZяяяя [ vPЉ Ч"х7 return reducible(source, function(_, next, initial) {5Ѓ_РZ\[яяяя [ vPЉ Ьх$ result = next(result, value)5Ѓ_Р[]\яяяя [ vPЉ Ях var result = initial5Ѓ_Р\^]яяяя[vPЉ бх! console.log(result, nested)5Ѓ_Р]_^$яяяя[vPЉ жх/ return reduce(source, function(_, nested) {5Ѓ_Р^`_&яяяя[vPЉ их0 return reduce(nested, function(_, value) {5Ѓ_Р_a`яяяя[vPЉ лх })5Ѓ_Р`baяяяя[vPЉ ох }, resulting)5Ѓ_Рacbяяяя[vPЉ т#х })5Ѓ_Рbdcяяяя[vPЉ†х5 return reducible(null, function(_, next, initial) {5Ѓ_Рced яяяя[vPЉђхfunction andхх5Ѓ_Рdfeяяяя [ vPЉ“хfunction and()5Ѓ_Рegfяяяя [ vPЉ“х function and() {}5Ѓ_Рfhg яяяя![!vPЉ•х function and() {5Ѓ_Рgihяяяя![!vPЉ—х ! х 5Ѓ_Рhjiяяяя"["vPЉљх ! when()5Ѓ_Рikjяяяя"["vPЉџх ! when(a, function())5Ѓ_Рjlkяяяя"["vPЉџх ! when(a, function() {})5Ѓ_Рkmlяяяя#[#vPЉ х "5Ѓ_Рlnmяяяя$[$vPЉЁх when(a, function() {5Ѓ_Рmonяяяя#[#vPЉЁх5Ѓ_Рnpoяяяя"["vPЉ©х })5Ѓ_Рoqpяяяя![!vPЉёх function and(a, b) {5Ѓ_Рprq яяяя![!vPЉјх var and = function and(a, b) {5Ѓ_Рqsrяяяя![!vPЉїх 'var and = eventual(function and(a, b) {}х }5Ѓ_Рrts(яяяя [ vPЉБ$х(var and = eventual(function and(a, b) {}5Ѓ_Рsut яяяя [ vPЉЗх5 return reduce(nested, function(result, value) {5Ѓ_Рtvuяяяя [ vPЉМ%х }, result)5Ѓ_Рuwv(яяяя [ vPЉэ&х)var and = eventual(function and(a, b) {})5Ѓ_Рvxwяяяя [ vPЉ'хvar and = eventual(Array)5Ѓ_Рwyxяяяя [ vPЉЂ(хA return and(result, reduce(nested, function(result, value) {5Ѓ_Рx€yяяяя [ vPЉн2х х5Ѓ_Рy‰z€яяяяvPЉ.х" // х!5Ѓ_Р€Љ‰яяяяvPЉ1х" console.log()5Ѓ_Р‰‹ЉяяяяvPЉ2х" console.log('')5Ѓ_РЉЊ‹яяяяvPЉ33х" console.log('>>>>')5Ѓ_Р‹ЌЊяяяяPЉk4х! console.log('>>>>', nested)5Ѓ_РЊЋЌяяяяPЊ.45х!7 return reducible(source, function(_, next, initial) {5Ѓ_РЌЏЋяяяяPЊ6Cх!5 return reducible(null, function(_, next, initial) {5Ѓ_РЋ›ЏяяяяPЊ6I>х!/ return reducible(function(_, next, initial) {5Ѓ_РЏњ—›5яяяя*vPђD?х!@ print(flatten([ [1, 2], [ 3, 4 ] ])) // => 5Ѓ_Р›ќњ/яяяя*vPђQµх" х!5Ѓ_Рњћќяяяя*vPђQ№х" console.log()5Ѓ_Рќџћяяяя*vPђQєх" console.log('')5Ѓ_Рћ џяяяя*vPђQ»@х" console.log('>>>')5Ѓ_РџЎ яяяя*vPђRLх# х"5Ѓ_Р ¤Ўяяяя*vPђRSх# var promise = deliver()5Ѓ_РЎҐў¤яяяя*vPђRdх var promise = defer()5Ѓ_Р¤¦Ґяяяя*vPђRhх"C return group(result, reduce(nested, function(result, value) {5Ѓ_РҐ§¦яяяя*vPђRkх" }, result))5Ѓ_Р¦Ё§яяяя*vPђRmAх" console.log('>>>', result)5Ѓ_Р§©Ёяяяя*vPђRчх" х!5Ѓ_РЁЄ©яяяя*vPђRях" }, initial)5Ѓ_Р©«Є+яяяя*vPђSх"5 return reduce(nested, function(result, value) {5Ѓ_РЄ¬«яяяя*vPђSх"" return next(result, value)5Ѓ_Р«¬)яяяя*vPђSх"4 return reduce(source, function(result, nested) {5Ѓ_Р¬®яяяя*vPђSх" var state = initial5Ѓ_РЇ®яяяя*vPђSх" var results5Ѓ_Р®°Ї яяяя*vPђSх"# state = next(result, value)5Ѓ_РЇ±°яяяя*vPђS#х" }, result)5Ѓ_Р°І±яяяя*vPђS*х" })5Ѓ_Р±іІяяяя*vPђS-х" })5Ѓ_РІґіяяяя*vPђS5Bх# х"5Ѓ_Ріµґ$яяяя*vPђSћх#/ return reduce(source, function(_, nested) {5Ѓ_Рґ¶µяяяя*vPђS¬х # }, null)5Ѓ_Рµ·¶ яяяя*vPђS°х#0 return reduce(nested, function(_, value) {5Ѓ_Р¶ё·яяяя*vPђS·Cх# }, null)5Ѓ_Р·№ёяяяяvPђT'х$х#5Ѓ_РёЕ№яяяяvPђT+хfunction identical5Ѓ_Р№ЖєЕяяяяvPђTћхvar group = eventual(Array)5Ѓ_РЕПЖяяяяvPђTџEх5Ѓ_РЖРЗПяяяяvPђTех!@ return group(previous, reduce(nested, function(_, value) {5Ѓ_РПСРяяяяvPђTих! }, null))5Ѓ_РРТС яяяяvPђTкх" х!5Ѓ_РСУТ9яяяяvPђUх#? // Result is accumulated into this outer variable as nested5Ѓ_РТФУ?яяяяvPђUх#E // Result is accumulated into this outer variable as items nested5Ѓ_РУХФDяяяяvPђUх#J // Result is accumulated into this outer variable as items from nested5Ѓ_РФЦХяяяяvPђUх$ // nestedcollections х$ // collections 5Ѓ_РХЧЦяяяяvPђU!х# // nested collections 5Ѓ_РЦШЧ&яяяяvPђU*х/ // nested collections can come in arbitary 5Ѓ_РЧЩШ0яяяяvPђU+х#0 // nested collections can come in arbitrary 5Ѓ_РШЪЩ6яяяяvPђU6Fх#6 // nested collections can come in arbitrary order.5Ѓ_РЩЫЪ7яяяяvPђU<х#7 // nested collections can come in time based order.5Ѓ_РЪЬЫ яяяяvPђUOх$ // to 5Ѓ_РЫЭЬ+яяяяvPђU]х$6 return reduce(source, function(previous, nested) {5Ѓ_РЬЮЭяяяяvPђU|Gх return result5Ѓ_РЭЯЮяяяяvPђUх#5 return reduce(source, function(promise, nested) {5Ѓ_РЮаЯ яяяяvPђU…х!$ х!#5Ѓ_РЯба яяяяvPђU€х!$ when()5Ѓ_Равб яяяяvPђUЋх!$ when(promise, function())5Ѓ_Рбгв яяяяvPђUЋх!$ when(promise, function() {})5Ѓ_РвдгяяяяvPђUћх$+var eventual = require("eventual/decorate")5Ѓ_Ргед%яяяяvPђU Jх$'var when = require("eventual/decorate")5Ѓ_РджеяяяяvPђ[qх$#var when = require("eventual/when")5Ѓ_Резж%яяяяvPђ[uKх$'var eventual = require("eventual/when")5Ѓ_Ржиз(яяяяvPђ[zхvar first = eventualх%х$5Ѓ_Рзйияяяя vPђ[‚х&var first = eventual()5Ѓ_Рикйяяяя vPђ[„х& var first = eventual(function())5Ѓ_Рйлк!яяяя vPђ[…х&#var first = eventual(function() {})5Ѓ_Ркмляяяя vPђ[‡х&$var first = eventual(function() { })5Ѓ_Рлнм"яяяя vPђ[€х&(var first = eventual(function(item) { })5Ѓ_Рмон&яяяя vPђ[Љх&)var first = eventual(function(value) { })5Ѓ_Рнпояяяя vPђ[‘х&< var promise = reduce(source, function(promise, nested) {5Ѓ_Рорп"яяяя vPђ[”х!"/ when(promise, function() { return result })5Ѓ_Рпсряяяя vPђ[–х%. reduce(source, function(promise, nested) {5Ѓ_Рртс яяяя vPђ[™х%0 return reduce(nested, function(_, value) {5Ѓ_Рсутяяяя vPђ[Ўх%? return first(promise, reduce(nested, function(_, value) {5Ѓ_Ртфу яяяя vPђ[ҐLх!% }, null)5Ѓ_Рухфяяяя vPђ[¶х!& х!%5Ѓ_РфЦх яяяя vPђ[ёzх!& return resulting5Ѓ_РхЧцЦяяяя vPђПТх &$ result = next(result, value)5Ѓ_РЦШЧяяяя vPђПХ{х & result = next(value)5Ѓ_РЧЩШяяяя vPђПг|х&6 return first(reduce(nested, function(_, value) {5Ѓ_РШЪЩяяяя vPђПях'х&5Ѓ_РЩЫЪяяяя vPђРх'var when = require()5Ѓ_РЪЬЫяяяя vPђР}х'var when = require("")5Ѓ_РЫЭЬ яяяя vPђР х ( // х '5Ѓ_РЬЮЭяяяя vPђРх ( when()5Ѓ_РЭЯЮяяяя vPђРх ( return when()5Ѓ_РЮаЯ%яяяя vPђР х (& return when(promise, function())5Ѓ_РЯба'яяяя vPђР х!() return when(promise, function() [])5Ѓ_Равб яяяя vPђР!х ])5Ѓ_Рбгв яяяя vPђР$х!(: return first(accumulate(nested, function(_, value) {5Ѓ_Рвдг!яяяя vPђР(х "($ result = next(value, result)5Ѓ_Ргед"яяяя vPђР*х!#( return result5Ѓ_Рдже#яяяя vPђР,х"$( }, null), promise)5Ѓ_Резж#яяяя vPђР6х"$( }, null), promise)5Ѓ_Ржиз#яяяя vPђР9х"$( }), promise)5Ѓ_Рзйи# яяяя vPђРDх#%) х#%(5Ѓ_Рикй'яяяя vPђРJх )' return when(promise, function() [5Ѓ_Рйлк'яяяя vPђРKх )( return when(promise, function() []5Ѓ_Ркмл(яяяя vPђРNх )( return when(promise, function() {}5Ѓ_Рлнм$яяяя vPђРQ~х#%) }5Ѓ_Рмоняяяя vяяяPђРbх*х)5Ѓ_Рнпояяяя vяяяPђРdх5Ѓ_Рорп яяяя vяяяPђРeх* var reduce = require("./reduce")5Ѓ_Рпср"яяяя v PђРlЂх*$var accumulate = require("./reduce")5Ѓ_Рртс!яяяя v PђРѕх "*/ accumulate(nested, function(_, value) {5Ѓ_Рсут!яяяя v PђРАЃх "*6 return accumulate(nested, function(_, value) {5Ѓ_Ртфу& яяяя v PђРах&(*5Ѓ_Рухф'яяяя v PђРз‚х&'5Ѓ_Рфцх!%яяяя v PђС¬х!#+ х!#*5Ѓ_Рхчц"яяяя v PђС®х!#+ console.log()5Ѓ_Рцшч"яяяя v PђСЇх!#+ console.log("")5Ѓ_Рчщш"яяяя v PђС±ѓх!#+ console.log(">>>>>")5Ѓ_Ршъщ' яяяя v PђСЗх'), х')+5Ѓ_Рщыъ яяяя v PђСПх,5 return reduce(source, function(promise, nested) {5Ѓ_Ръьы(яяяя v PђСХх'), when5Ѓ_Рыэь( яяяя v PђСХх'), when()5Ѓ_Рьюэ(яяяя v PђСШх'), when(promise)5Ѓ_Рэяю(яяяя v PђСЬх'), when(promise, function())5Ѓ_Рюя(!яяяя v PђСах')," when(promise, function(value))5Ѓ_Ря(#яяяя v PђСбх'),# when(promise, function(value) )5Ѓ_Р(#яяяя v PђСгх'),$ when(promise, function(value) {}5Ѓ_Р()яяяя v PђСзх'),+ when(promise, function(value) { next()}5Ѓ_Р(4яяяя v PђСлх'),5 when(promise, function(value) { next(end, value)}5Ѓ_Р(6яяяя v PђСм„х'),6 when(promise, function(value) { next(end, value) }5Ѓ_Р(;яяяя v PђСу…х'),< when(promise, function(value) { next(end, value) }, end)5Ѓ_Ряяяя v PђТх-х,5Ѓ_Ряяяя v PђТх-var end = require()5Ѓ_Р яяяя v PђТ†х-var end = require("")5Ѓ_Р !яяяя v PђТlх "-' return when(promise, function() {5Ѓ_Р !яяяя v PђТoх ! return function() {5Ѓ_Р &яяяя v PђТp‡х%& })5Ѓ_Р !яяяя% !vPђТ~€х &+2 return reduce(nested, function(_, value) {% console.log(">>>>>", value)& result = next(value, result) return result })5Ѓ_Р 1яяяя% !vPђТ™‰х+< var promise = reduce(source, function(promise, nested) {5Ѓ_Р ! яяяя% !vPђТБх "+0 return reduce(nested, function(_, value) {5Ѓ_Р+яяяя% !vPђТЗх+6 var promise = reduce(source, function(_, nested) {5Ѓ_Р%яяяя% !vPђТМЉх$&+ })5Ѓ_Р"яяяя% !vPђТъ‹х!"# console.log(">>>>>", value)5Ѓ_РхчЦцяяяя vPђ[Ъх'! "use strict"; var reduce = require("./reduce")&var reducible = require("./reducible")+var eventual = require("eventual/decorate")var group = eventual(Array)function flatten(source) { /**B Flattens given sequence of sequences to a sequence with items ofA all nested sequences. Note that items in the resulting sequence> are ordered by the time rather then index, in other words ifD item from the second sub-sequence is deliver earlier then the itemD from first sub-sequence it will in appear earlier in the resultingE sequence too. If you need to keep order by index you should enforceC sequential ordering by wrapping `source` into `sequential` before passing it to flatten.@ print(flatten([ [1, 2], [ 3, 4 ] ])) // => **/, return reducible(function(next, initial) {4 return reduce(source, function(result, nested) {J // we group results to make sure flattened stream won't finish until& // all the streams are finished.C return group(result, reduce(nested, function(result, value) {" return next(result, value) }, result)) }, initial) })}module.exports = flatten5Ѓ_Рцшчяяяя vPђe!yх"& "use strict"; var reduce = require("./reduce")&var reducible = require("./reducible")+var eventual = require("eventual/decorate")6var first = eventual(function(value) { return value })function flatten(source) { /**B Flattens given sequence of sequences to a sequence with items ofA all nested sequences. Note that items in the resulting sequence> are ordered by the time rather then index, in other words ifD item from the second sub-sequence is deliver earlier then the itemD from first sub-sequence it will in appear earlier in the resultingE sequence too. If you need to keep order by index you should enforceC sequential ordering by wrapping `source` into `sequential` before passing it to flatten.: print(flatten([ [1, 2], [ 3, 4 ] ])) // => < 1 2 3 4 /> **/, return reducible(function(next, initial) {H // Result is accumulated into this outer variable as items from thenL // nested collections can come in time based order so it won't be passed! // to in to reducer function. var result = initial5 return reduce(source, function(promise, nested) {J // we group results to make sure flattened stream won't finish until& // all the streams are finished.6 return first(reduce(nested, function(_, value) {$ result = next(result, value) return result }, null), promise) }, source) })}module.exports = flatten5Ѓ_Рчщшяяяя vPђe@х'! "use strict"; var reduce = require("./reduce")&var reducible = require("./reducible")+var eventual = require("eventual/decorate")var group = eventual(Array)function flatten(source) { /**B Flattens given sequence of sequences to a sequence with items ofA all nested sequences. Note that items in the resulting sequence> are ordered by the time rather then index, in other words ifD item from the second sub-sequence is deliver earlier then the itemD from first sub-sequence it will in appear earlier in the resultingE sequence too. If you need to keep order by index you should enforceC sequential ordering by wrapping `source` into `sequential` before passing it to flatten.@ print(flatten([ [1, 2], [ 3, 4 ] ])) // => **/, return reducible(function(next, initial) {4 return reduce(source, function(result, nested) {J // we group results to make sure flattened stream won't finish until& // all the streams are finished.C return group(result, reduce(nested, function(result, value) {" return next(result, value) }, result)) }, initial) })}module.exports = flatten5Ѓ_Ршъщяяяя vPђ‘iх !х!"function reducer5Ѓ_Рщыъ! яяяя vPђ‘qх "#reducer5Ѓ_Ръьы!яяяя vPђ‘sх "# reducer()5Ѓ_Рыэь!яяяя vPђ‘tх "#reducer(function flatten())5Ѓ_Рьюэ!яяяя vPђ‘xх "#reducer(function flatten() {})5Ѓ_Рэяю!яяяя vPђ‘xх "#reducer(function flatten() {})5Ѓ_Рюя!яяяя vPђ‘~х "$*reducer(function flatten(value, results) {5Ѓ_Ря!яяяя vPђ‘Ќх "5Ѓ_Р!яяяя vPђ‘Ќх "5Ѓ_Ряяяя vPђ‘х"8 return accumulate(source, function(result, nested) {5Ѓ_Р яяяя vPђ‘џх"$var accumulate = require("./reduce")5Ѓ_РяяяяvPђ‘ўх5Ѓ_РяяяяvPђ‘ўх5Ѓ_РяяяяvPђ‘ЈNх5Ѓ_Р&яяяяvPђ‘ґOх@ return accumulate(source, function forward(result, nested) {5Ѓ_Р .яяяяvPђ‘ёхP return accumulate(source, function accumulateFlattenSource(result, nested) {5Ѓ_Р яяяяvPђ‘ГPх> return reducible(function accumulateFlatten(next, initial) {5Ѓ_Р GяяяяvPђ‘ЛQхH return accumulate(source, function accumulateFlattenSource(nested) {5Ѓ_Р =яяяяvPђ‘Ух5Ѓ_Р яяяяvPђ‘Шх function forward()5Ѓ_Р яяяяvPђ‘бх function forward() {}5Ѓ_Р яяяяvPђ‘вх function forward() { }5Ѓ_РяяяяvPђ‘дх!5Ѓ_РяяяяvPђ‘их"% function forward(value, result) {5Ѓ_Р"яяяяvPђ‘ых" function forward(value) {5Ѓ_РяяяяvPђ‘ьх"5Ѓ_РяяяяvPђ‘юх# var state = initial5Ѓ_РяяяяvPђ’х# х$ if ()5Ѓ_Р яяяяvPђ’х$ if (value)5Ѓ_РяяяяvPђ’х$ if (value === end)5Ѓ_РяяяяvPђ’х$ if (value === end) cou5Ѓ_РяяяяvPђ’х$ х% var open = 15Ѓ_РяяяяvPђ’.х%' if (value === end) open = open -15Ѓ_Р&яяяяvPђ’3х%( if (value === end) open = open - 15Ѓ_РяяяяvPђ’6х%) if (value === end) {open = open - 15Ѓ_РяяяяvPђ’7х% if (value === end) { open = open - 15Ѓ_РяяяяvPђ’7х& х' }5Ѓ_РяяяяvPђ’9х' х( if ()5Ѓ_Р яяяяvPђ’:х( if (open)5Ѓ_Р! яяяяvPђ’=х( if (open === 0)5Ѓ_Р "!яяяяvPђ’Gх( if (open === 0) next()5Ѓ_Р!#"яяяяvPђ’Iх(! if (open === 0) next(end)5Ѓ_Р"$#яяяяvPђ’Pх( if (open === 0) return next(end)5Ѓ_Р#%$яяяяvPђ’Sх)return next(end)х)( if (open === 0) return next(end)5Ѓ_Р$&%яяяяvPђ’Xх(х)var end = require()5Ѓ_Р%'&яяяяvPђ’\х)var end = require("")5Ѓ_Р&*'яяяяvPђ’\х) var end = require("./reducible")5Ѓ_Р'+(*яяяяvPђ’oх) } else if5Ѓ_Р*,+яяяяvPђ’wх) } else if ()5Ѓ_Р+-,яяяяvPђ’wх) } else if (isEnd())5Ѓ_Р,.-яяяяvPђ’yх) } else if (isError())5Ѓ_Р-/.яяяяvPђ’{х) } else if (isError(value))5Ѓ_Р.0/яяяяvPђ’}х)! } else if (isError(value) )5Ѓ_Р/10!яяяяvPђ’Љх) } else {}5Ѓ_Р021яяяяvPђ’’х) } else { }5Ѓ_Р132яяяяvPђ’’х* х+ return next()5Ѓ_Р243яяяяvPђ’—х+! return next(value, state)5Ѓ_Р354яяяяvPђ’Јх +5Ѓ_Р465!яяяяvPђ’єх!", х!#- accumulate()5Ѓ_Р576"яяяяvPђ’Гх!#-! accumulate(nested, forward)5Ѓ_Р687" яяяяvPђ’Ох!#-' accumulate(nested, forward, null)5Ѓ_Р798!%яяяяvPђ’Шх!"- х!#. if ()5Ѓ_Р8:9" яяяяvPђ’Эх!#. if (nested === 0)5Ѓ_Р9;:"яяяяvPђ’зх!#. if (nested === end)5Ѓ_Р:<;"яяяяvPђ’их!#.# if (nested === end) forward()5Ѓ_Р;=<""яяяяvPђ’лх!#.) if (nested === end) forward(nested)5Ѓ_Р<>=" яяяяvPђ’хх!#./ if (isEnd(nested === end) forward(nested)5Ѓ_Р=?>"яяяяvPђ’шх!#.' if (isEnd(nested) forward(nested)5Ѓ_Р>@?"яяяяvPђ’ыRх!#.) if (isError(nested) forward(nested)5Ѓ_Р?A@яяяяvPђ“х.х/var isError = require()5Ѓ_Р@BAяяяяvPђ“х/var isError = require("")5Ѓ_РACBяяяяvPђ“Sх/ var isError = require("./error")5Ѓ_РBDCяяяяvPђ“ Tх/#var isError = require("./is-error")5Ѓ_РCED#яяяяvPђ“х"$/* if (isError(nested)) forward(nested)5Ѓ_РDFE$яяяяvPђ“х#%/, else accumulate(nested, forward, null)5Ѓ_РEGF%яяяяvPђ“х$&5Ѓ_РFHG%яяяяvPђ“х$&5Ѓ_РGIH%яяяяvPђ“х$&5Ѓ_РHJI%яяяяvPђ“х$&5Ѓ_РIKJ%яяяяvPђ“х$&5Ѓ_РJLK%яяяяvPђ“ х$&* }, null)5Ѓ_РKML"яяяяvPђ“(х!#*H return accumulate(source, function accumulateFlattenSource(nested) {5Ѓ_РLNMяяяяvPђ“.Uх* var open = 15Ѓ_РMONяяяяvPђ“<х* if (value === end && ()) {5Ѓ_РNPOяяяяvPђ“?х*/ if (value === end && (open = open - 1)) {5Ѓ_РOQPяяяяvPђ“Gх*0 if (value === end && !(open = open - 1)) {5Ѓ_РPRQяяяяvPђ“Kх5Ѓ_РQSR0яяяяvPђ“Kх). if (value === end && !(open = open - 1))5Ѓ_РRTSяяяяvPђ“Nх) return next(end)5Ѓ_РSUTяяяяvPђ“Vх) х* return 5Ѓ_РTVU яяяяvPђ“Xх*$value === end && !(open = open - 1))х*1 return value === end && !(open = open - 1))5Ѓ_РUWV1яяяяvPђ“[х)9 return value === end && !(open = open - 1) ? next()5Ѓ_РVXW8яяяяvPђ“^х)< return value === end && !(open = open - 1) ? next(end)5Ѓ_РWYX<яяяяvPђ“`х)> return value === end && !(open = open - 1) ? next(end) : nextх next()5Ѓ_РXZYяяяяvPђ“dх* next(value, state)5Ѓ_РY[ZяяяяvPђ“nх5Ѓ_РZ\[яяяяvPђ“oх5Ѓ_Р[]\яяяяvPђ“oх5Ѓ_Р\^]яяяяvPђ“oWх5Ѓ_Р]_^яяяяvPђ“Ґх& х 'H // If there is an error or end of `source` collection just forward // 5Ѓ_Р^`_HяяяяvPђ“Вх (I // If there is an error or end of `source` collection just forward`5Ѓ_Р_a`AяяяяvPђ“Гх (J // If there is an error or end of `source` collection just `forward`5Ѓ_Р`ba яяяяvPђ“Нх!( // it 5Ѓ_РacbAяяяяvPђ“Цх (H // If there is an error or end of `source` collection just pass it // to `forward`5Ѓ_Рbdc!яяяяvPђ“Ых "5Ѓ_Рced яяяяvPђ“ЫXх!(. // to `forward` it will take care of it.5Ѓ_Рdfe!яяяяvPђ“жх "(1 if (isError(nested)) return forward(nested)5Ѓ_Рegf !яяяяvPђ“их !( // х ") return 5Ѓ_Рfhg" яяяяvPђ“лх!#)'isError(nested)) return forward(nested)х #)4 return isError(nested)) return forward(nested)5Ѓ_Рgih!яяяяvPђ“ох "(3 return isError(nested) return forward(nested)5Ѓ_Рhji!$яяяяvPђ“пх "(. return isError(nested) ? forward(nested)5Ѓ_Рikj .яяяяvPђ“сх!(G // to `forward` it will take care of detecting weather it's error // or `end` 5Ѓ_Рjlk!яяяяvPђ”х ")( // or `end` and if everything has 5Ѓ_Рkml!яяяяvPђ”х ")1 // or `end` and in later if everything has 5Ѓ_Рlnm!!яяяяvPђ”х ")3 // or `end` and in later case everything has 5Ѓ_Рmon!#яяяяvPђ”х ")6 // or `end` and in later case if everything has 5Ѓ_Рnqo!6яяяяvPђ”х ")9 // or `end` and in later case if everything should 5Ѓ_Рorpq!яяяяvPђ”Iх ")6 // or `end`. in later case if everything should 5Ѓ_Рqsr!яяяяvPђ”Kх ")6 // or `end`. In later case if everything should 5Ѓ_Рrts!6яяяяvPђ”Nх ")G // or `end`. In later case it will also figure out if this is the // kA5Ѓ_Рsut!GяяяяvPђ”^х "*I // or `end`. In later case it will also figure out if it's `end` of) // result to and act appropriately.5Ѓ_Рtvu#яяяяvPђ”|х"$5Ѓ_Рuwv$яяяяvPђ”~х#%*. accumulate(nested, forward, null)5Ѓ_Рvxw#.яяяяvPђ”Ѓх"$*0 return isError(nested) ? forward(nested) :5Ѓ_Рwyx#/яяяяvPђ”€х#$* х#%+B // If `nested` item is not end nor error just accumulate it 5Ѓ_Рxzy$4яяяяvPђ”њх#%+C // If `nested` item is not end nor error just `accumulate it 5Ѓ_Рy{z$?яяяяvPђ”ќх#%+D // If `nested` item is not end nor error just `accumulate` it 5Ѓ_Рz|{$DяяяяvPђ”џх#%+G // If `nested` item is not end nor error just `accumulate` it via //5Ѓ_Р{}|$GяяяяvPђ”Ўх#%,G // If `nested` item is not end nor error just `accumulate` it via5Ѓ_Р|~}%яяяяvPђ”¤х$&,, // `forward` that will also make sure 5Ѓ_Р}~"(яяяяvPђ”Ах"#, // х"$- open = open + 15Ѓ_Р~Ђяяяя##vPђ”КYх- var open = 05Ѓ_РЃЂ#яяяя##vPђ”Пх"$- 5Ѓ_РЂ‚Ѓ#яяяя##vPђ”Рх"$5Ѓ_РЃѓ‚яяяя$$vPђ”СZх, х - open = open + 15Ѓ_Р‚„ѓ&,яяяя$$vPђ”ех%'-F // `forward` that keeps track of all collections that are concat5Ѓ_Рѓ…„&Fяяяя$$vPђ”шх%'-L // `forward` that keeps track of all collections that are bing forward5Ѓ_Р„†…&Lяяяя$$vPђ•[х%'-N // `forward` that keeps track of all collections that are bing forwarded // to it.5Ѓ_Р…‡†яяяя$$vPђ•Й\х.var end = require("./end")5Ѓ_Р†€‡яяяя%%vPђ•Шх. х/ console.log()5Ѓ_Р‡‰€яяяя%%vPђ•Ы]х/% console.log(open, value, state)5Ѓ_Р€Љ‰ яяяя%%vPђ•р_х/' state = next(value, state)5Ѓ_Р‰‹Љяяяя%%vPђ–`х/- console.log(">>>>", open, value, state)5Ѓ_РЉЊ‹яяяя''vPђ–4х/ х0 con5Ѓ_Р‹ЌЊ!яяяя''vPђ–8х "1A accumulate(source, function accumulateFlattenSource(nested) {5Ѓ_РЊЋЌяяяя''vPђ–:х 1 connso5Ѓ_РЌЏЋяяяя&&vPђ–;х 5Ѓ_РЋђЏ яяяя''vPђ–<х !0 х "1 console.log()5Ѓ_РЏ‘ђ!яяяя''vPђ–?aх "1 console.log(nested)5Ѓ_Рђ’‘!яяяя''vPђ–Lbх "1 console.log(arguments)5Ѓ_Р‘“’"яяяя''vPђ–^cх1(var accumulate = require("./accumulate")5Ѓ_Р’”“!яяяя&&vPђ–ddх "5Ѓ_Р“•”яяяя%%vPђ–ѓeх5Ѓ_Р”–•яяяя%%vPђ–±fх/ var open = 15Ѓ_Р•—–яяяя&&vPђ–Гх/ х0 console.log()5Ѓ_Р–—яяяя&&vPђ–Ох0 console.log("")5Ѓ_Р—™яяяя&&vPђ–Рх0 console.log(">>")5Ѓ_Рљ™яяяя&&vPђ–Тх0! console.log(">>", open, "")5Ѓ_Р™›љяяяя&&vPђ–Чх0$ console.log(">>", open, ">>>")5Ѓ_Рљњ›#яяяя vPђ–Щgх0+ console.log(">>", open, ">>>", value)5Ѓ_Р›ќњ*яяяя vPђ–юhх0: console.log(">>", open, ">>>", value, value === end)5Ѓ_Рњћќяяяя vPђ—х0J console.log(">>", value === end ? open, ">>>", value, value === end)5Ѓ_Рќџћ,яяяя vPђ—х0T console.log(">>", value === end ? open -1 : open, ">>>", value, value === end)5Ѓ_Рћ џSяяяя vPђ—iх07 console.log(">>", value === end ? open -1 : open)5Ѓ_РџЎ 6яяяя vPђ—jх07 console.log(">>", value === end ? open -1 : open)5Ѓ_Р ўЎяяяя vPђ—[х05Ѓ_РЎЈўяяяя vPђіЬх20 "use strict";(var accumulate = require("./accumulate")&var reducible = require("./reducible")var end = require("./end")#var isError = require("./is-error")function flatten(source) { /**B Flattens given sequence of sequences to a sequence with items ofA all nested sequences. Note that items in the resulting sequence> are ordered by the time rather then index, in other words ifD item from the second sub-sequence is deliver earlier then the itemD from first sub-sequence it will in appear earlier in the resultingE sequence too. If you need to keep order by index you should enforceC sequential ordering by wrapping `source` into `sequential` before passing it to flatten.@ print(flatten([ [1, 2], [ 3, 4 ] ])) // => **/> return reducible(function accumulateFlatten(next, initial) { var state = initial var open = 1 function forward(value) {7 console.log(">>", value === end ? open -1 : open)> return value === end && !(open = open - 1) ? next(end) :' state = next(value, state) }A accumulate(source, function accumulateFlattenSource(nested) { open = open + 1H // If there is an error or end of `source` collection just pass itG // to `forward` it will take care of detecting weather it's errorI // or `end`. In later case it will also figure out if it's `end` of) // result to and act appropriately.0 return isError(nested) ? forward(nested) :G // If `nested` item is not end nor error just `accumulate` it viaN // `forward` that keeps track of all collections that are bing forwarded // to it.. accumulate(nested, forward, null) }, null) })}module.exports = flatten5Ѓ_Рў¤Ј6яяяя vPђішkх0> console.log(">>", value === end ? open -1 : open, value)5Ѓ_РЈҐ¤яяяя vPђґlх0@ console.log("\n>>", value === end ? open -1 : open, value)5Ѓ_Р¤¦Ґяяяя vPђґ?х0= return value === end && (open = open - 1) ? next(end) :5Ѓ_РҐ§¦/яяяя vPђґCх0@ return value === end && (open = open - 1) == ? next(end) :5Ѓ_Р¦Ё§1яяяя vPђґEх0 х1 if ()5Ѓ_Р§©Ё яяяя vPђґGх1 if (value === end)5Ѓ_РЁЄ©яяяя vPђґJх1 if (value === end) {}5Ѓ_Р©«Єяяяя vPђґKх1 if (value === end) { }5Ѓ_РЄ¬«яяяя vPђґMх2 х3 open = open - 15Ѓ_Р«¬яяяя vPђґTх3 х4 if ()5Ѓ_Р¬®яяяя vPђґUх4 if (open === 0)5Ѓ_РЇ®яяяя vPђґZх4% if (open === 0) return next()5Ѓ_Р®°Ї$яяяя vPђґ]х4( if (open === 0) return next(end)5Ѓ_РЇ±°яяяя vPђґaх 5Ѓ_Р°І± яяяя vPђґbх 3 state = next(value, state)5Ѓ_Р±іІяяяя vPђґhmх 3 х!4 return state5Ѓ_РІ¶іяяяя vPђґnnх5Ѓ_Рі·ґ¶яяяя vPђґђх3 } else {}5Ѓ_Р¶ё·яяяя vPђґ’х3 } else {5Ѓ_Р·№ёяяяя vPђґ”х3" state = next(value, state)5Ѓ_Рё»№яяяяvPђґ•pх3 х 4 }5Ѓ_Р№јє»%яяяяvPђµ(х$&5Ѓ_Р»Ѕј(яяяяvPђµ*х()3 // х(*4 if ()5Ѓ_РјѕЅ) яяяяvPђµ.х(*4 if (isError())5Ѓ_РЅїѕ)яяяяvPђµ0х(*4 if (isError(nested))5Ѓ_РѕАї)яяяяvPђµ2х(*4 if (isError(nested)) {}5Ѓ_РїБА)яяяяvPђµ2х(*4 if (isError(nested)) { }5Ѓ_РАВБ)яяяяvPђµ4х(*5 if (isError(nested))5Ѓ_РБГВ)яяяяvPђµ6х(*5+ if (isError(nested)) return forward()5Ѓ_РВДГ)*яяяяvPђµ8х(*51 if (isError(nested)) return forward(nested)5Ѓ_РГЕД*яяяяvPђµ<х)+5Ѓ_РДЖЕ*яяяяvPђµ>х)+5Ѓ_РЕЗЖ,яяяяvPђµAх,-3 // х,.4 open = open + 15Ѓ_РЖИЗ. яяяяvPђµFqх-/4' accumulate(nested, forward, null)5Ѓ_РЗЙИ( яяяяvPђДсх()4 // х(*5 if ()5Ѓ_РИКЙ) яяяяvPђДфх(*5 if (nested === end)5Ѓ_РЙЛК)яяяяvPђДях(*5* if (nested === end) return forward()5Ѓ_РКМЛ))яяяяvPђЕrх(*5- if (nested === end) return forward(end)5Ѓ_РЛНМ$+яяяяvPђЕQх$%5 х$&6 console.log()5Ѓ_РМОН%яяяяvPђЕVх$&6 console.log(nested)5Ѓ_РНПО%яяяяvPђЕXsх$&6 console.log("!", nested)5Ѓ_РОРПяяяяvPђЕ’х6 х7 console.log()5Ѓ_РПСРяяяяvPђЕ—х7 console.log("")5Ѓ_РРТСяяяяvPђЕ™х7 console.log("~")5Ѓ_РСУТяяяяvPђЕ›uх7 console.log("~", value)5Ѓ_РТФУяяяяvPђИ-vх5Ѓ_РУХФ%яяяяvPђИ/wх$&5Ѓ_РФХ0яяяя5VPђОaxх/15 }, initial)5Ѓ_Р№»єяяяяvPђµх43 if (open = open - 1 === 0) return next(end)5Ѓ_Ріµ¶ґяяяя vPђґЂх3 } else {}5Ѓ_Рґµяяяя vPђґѓх3 } else {5Ѓ_Рoqp!яяяяvPђ”Cх ")5 // or `end` in later case if everything should 5Ѓ_Р')*(яяяяvPђ’fх) if (value === end) next()5Ѓ_Р()яяяяvPђ’hх)" if (value === end) next(end)5Ѓ_РЖИПЗяяяяvPђTЁх!0 return reduce(nested, function(_, value) {5Ѓ_РЗЙИяяяяvPђT«х! }, null)5Ѓ_РИКЙяяяяvPђT±х5Ѓ_РЙЛК яяяяvPђTґх }, initial)5Ѓ_РКМЛ яяяяvPђT¶х }, source)5Ѓ_РЛНМяяяяvPђTјх }, )5Ѓ_РМОН+яяяяvPђTВх 4 return reduce(source, function(result, nested) {5Ѓ_РНО яяяяvPђTХх }, result)5Ѓ_Р№»Еє яяяяvPђT,х#var identity = eventual(Array)5Ѓ_Рєј»яяяяvPђT2х##var identity = eventual(function())5Ѓ_Р»Ѕј"яяяяvPђT3х#&var identity = eventual(function() {})5Ѓ_РјѕЅ$яяяяvPђT4х#$var identity = eventual(function() {})5Ѓ_РЅїѕ яяяя**v*PђT6х$-var identity = eventual(function identity() {5Ѓ_РѕАї*яяяя**v*PђT9х$2var identity = eventual(function identity(value) {5Ѓ_РїБА.яяяя**v*PђT;х$ х % return value5Ѓ_РАВБяяяяvPђTAх%C return identity(previous, reduce(nested, function(_, value) {5Ѓ_РБГВяяяяvPђTDх%; return identity(, reduce(nested, function(_, value) {5Ѓ_РВДГяяяяvPђTEх%9 return identity(reduce(nested, function(_, value) {5Ѓ_РГД яяяяvPђTGDх!% }, null), previous)5Ѓ_РЎЈ¤ўяяяя*vPђRZх5Ѓ_РўЈ яяяя*vPђR^х"; var promise = reduce(source, function(result, nested) {5Ѓ_РЏ–›—*яяяя*0vPЏўґх!4 return group(result, reduce(nested, , result))5Ѓ_Р—™*яяяя*0vPЏўґ<х8 return group(result, reduce(nested, next, result))5Ѓ_Рљ™яяяя*0vPЏЈ/х* return reduce(nested, next, result))5Ѓ_Р™љ*яяяя*0vPЏЈ0=х) return reduce(nested, next, result)5Ѓ_РЏђ—–яяяяPЋ/¦х"! "use strict"; var reduce = require("./reduce")&var reducible = require("./reducible")+var eventual = require("eventual/decorate")var group = eventual(Array)function flatten(source) { /**B Flattens given sequence of sequences to a sequence with items ofA all nested sequences. Note that items in the resulting sequence> are ordered by the time rather then index, in other words ifD item from the second sub-sequence is deliver earlier then the itemD from first sub-sequence it will in appear earlier in the resultingE sequence too. If you need to keep order by index you should enforceC sequential ordering by wrapping `source` into `sequential` before passing it to flatten.@ print(flatten([ [1, 2], [ 3, 4 ] ])) // => **/7 return reducible(source, function(_, next, initial) {4 return reduce(source, function(result, nested) {J // we group results to make sure flattened stream won't finish until& // all the streams are finished.C return group(result, reduce(nested, function(result, value) {" return next(result, value) }, result)) }, initial) })}module.exports = flatten5Ѓ_РЏ‘–ђяяяяPЊ6тх!* return convert(function(next, initial) {5Ѓ_Рђ’‘яяяяPЊ6х7х!0 return convert(null, function(next, initial) {5Ѓ_Р‘“’яяяяPЊ6ьх!х"var convert = require()5Ѓ_Р’”“яяяяPЊ6ях"var convert = require("")5Ѓ_Р“•”яяяяPЊ78х""var convert = require("./convert")5Ѓ_Р”• яяяяPЊ79х"3 return convert(null, function(_, next, initial) {5Ѓ_Рy„€zяяяяvPЉх!= return group(, reduce(nested, function(result, value) {5Ѓ_Рz…{„яяяяvPЉb/х!; return group(reduce(nested, function(result, value) {5Ѓ_Р„†…яяяяvPЉ}х!5 return reduce(nested, function(result, value) {5Ѓ_Р…‡†яяяяvPЉх! }, result)5Ѓ_Р†‡ яяяяvPЉЂ0х!. reduce(nested, function(result, value) {5Ѓ_Рz|„{яяяяvPЉх!; return group(reduce(nested, function(result, value) {5Ѓ_Р{}|яяяяvPЉ *х! }, result), result)5Ѓ_Р|~}яяяяvPЉЌх!5 return reduce(nested, function(result, value) {5Ѓ_Р}~яяяяvPЉ‘+х! }, result)5Ѓ_Р~Ѓ яяяяvPЉ-х!. reduce(nested, function(result, value) {5Ѓ_Р‚ЂЃяяяяvPЉ;.х! next(result, value)5Ѓ_РЃѓ‚яяяяvPЉLх! // х" console.log()5Ѓ_Р‚ѓяяяяvPЉSх" console.log(rde)5Ѓ_РЃЂяяяяvPЉ&х! next(result, value)5Ѓ_РRXSZWяяяя [ vPЉ Нх+ return reduce({}, function(_, nested) {5Ѓ_РWYXяяяя [ vPЉ Пх* return reduce(), function(_, nested) {5Ѓ_РXYяяяя [ vPЉ С!х- return reduce(null, function(_, nested) {5Ѓ_РRTWSяяяя[vPЉ х5Ѓ_РSUT$яяяя[vPЉ Fх. return reduce(source, function(, nested) {5Ѓ_РTVU#яяяя[vPЉ Iх/ return reduce(source, function(, nested) {5Ѓ_РUV#яяяя[vPЉ Kх. return reduce(source, function(, nested) {5Ѓ_Р 'яяяяvPѓ”Iх " Flattens given ` of `reducible`s5ЃзЄ