VimUnDow(a++~I MyR+BcC*Ap 4!PG_'g5g0v0P}&(function transform(source, f) {5_+;g5g0v0P}*,< : f(next, value, result)5_g g5g0v0P}^fiA return transform(source, function(next, value, result, state) {5_lg5g0v0P}mkm }, { drop: true })5_lg5g0v0P}okm }), { drop: true })5_gg5g0v0P}xfh! return accumulator(function() {5_g$g5g0v0P}}fh' return accumulator(function(active) {5_gg5g0v0P}~gi gi5_ig5g0v0P}hj< transform(source, function(next, value, result, state) {5_jg5g0v0P}ik return state.drop &&5_jg5g0v0P}ik return active &&5_j"g5g0v0P}ik" return active && active === 5_j*g5g0v0P}ik+ return active && active = predicate()5_j0g5g0v0P}ik0 return active && active = predicate(value)5_j:g5g0v0P}jl jl5_k8g5g0v0P}jl9 next()5_l g5g0v0P}kl7 (state.drop = predicate(value)) ? result :5_l/g5g0v0P}klB next(value, result)5_jg5g0v0P}ik; return active && active = predicate(value) ? result :5_j1g5g0v0P}ik< return active && (active = predicate(value) ? result :5_k3g5g0v0P}jlF next(value, result)5_lg5g0v0P}km })5_lg5g0v0P}ln ln5_mg5g0v0P}ln }5_!g5g0v0P}  "!function accumulator(source, f) {5_!g5g0v0P} "function accumulator(f) {5_ "g5g0v0P}"$ "$5_  #h5h0v0P}"$ make()5_   #h5h0v0P}"$ accumulate(make()5_   $h5h0v0P}#$/ return accumulate(f(source), next, initial)5_   #g5g0v0P}""$% accumulate(make(), next, initial)5_  F g5g0v0P~wEG"function take(source, predicate) {5_ O g5g0v0P~}NPexports.take = take5_Og5g0v0P~#NPexports.takeWhile = take5_Q g5g0v0P~PRfunction pick(source, n) {5_Qg5g0v0P~PRfunction take`(source, n) {5_` g5g0v0P~_aexports.pick = pick5_`g5g0v0P~$_aexports.take = pick5_Vg5g0v0P~UW. return reducible(function(_, next, result) {5_V-g5g0v0P~UW0 return accumulator(function(_, next, result) {5_Wg5g0v0P~VX var count = n5_Wg5g0v0P~WY WY5_Xh5h0v0P~WY return transform()5_X&h5h0v0P~WY( return transform(source, function())5_j@h5h0v0P~%ikC return transform(source, function(next, value, result, state) {5_X;h5h0v0P~WY; return transform(source, function(next, value, result))5_X<h5h0v0P~WZ= return transform(source, function(next, value, result) {}5_Yi5i0v0P~XZ }5_Yi5i0v0P~Y[ Y[5_ Xj5j0v0P~XZ XZ5_! Yk5k0v0P~Y[ Y[5_ "!Z l5l0v0PY[! return count === 0 ? next()5_!#"Z-l5l0v0PY[. return count === 0 ? next(accumulated())5_"$#Z4l5l0v0PY[6 return count === 0 ? next(accumulated(), next())5_#%$ZCl5l0v0PZ\ count > 0 ? nextY\C return count === 0 ? next(accumulated(), next(value, result))5_$&%[m5m0v0P"Z\ count > 0 ? next()5_%'&[,m5m0v0P(Z], count > 0 ? next(value, result)5_&('\n5n0v0P?[] 5_')(\n5n0v0PD[] next()5_(*)\+n5n0v0PG[], next(accumulated())5_)+*_n5n0v0PK^_2 return reduce(source, function(result, item) {5_*,+_m5m0v0PK^_ count = count - 15_+-,_l5l0v0PL^_8 return count === 0 ? reduced(next(result, item)) :5_,.-_ k5k0v0PL^_- count > 0 ? next(result, item) :5_-/._ j5j0v0PL^_ reduced(result)5_.0/_i5i0v0PM^_ }, result)5_/10_h5h0v0PM&^_ })5_021b g5g0v0P\'ac"function drop(source, predicate) {5_132o g5g0v0P`npexports.drop = drop5_243og5g0v0Pcnpexports.dropWhile = drop5_354tg5g0v0Pftv tv5_465ug5g0v0Pmtv return accumulator()5_576ug5g0v0Potv return accumulator(function())5_687u!g5g0v0Potw# return accumulator(function() {})5_798ug5g0v0Puw uw5_8:9vg5g0v0Pvx vx5_9;:wg5g0v0Pvx return transform()5_:=;w&g5g0v0Pvx( return transform(source, function())5_;><=w,g5g0v0Pvx. return transform(source, function(next, ))5_=?>w:g5g0v0Pvx; return transform(source, function(next, value, result))5_>@?w<g5g0v0Pvy> return transform(source, function(next, value, result) {})5_?A@wg5g0v0Pwy wy5_@BAxg5g0v0Pwy" return count -- > 0 ? result5_ACBx6g5g0v0Pxz nextwz6 return count -- > 0 ? next(accumulated(), result5_BDCy!g5g0v0Pxz" next()5_CFDxg5g0v0Pwy9 return count -- > 0 ? next(accumulated(), result) :5_DGEFy(g5g0v0Pxz) next(value, )5_FHG|g5g0v0P {|. return reducible(function(_, next, result) {5_GIH|g5g0v0P {| var count = n5_HJI|g5g0v0P {|2 return reduce(source, function(result, item) {5_IKJ|g5g0v0P {|7 return count -- > 0 ? result : next(result, item)5_JLK|g5g0v0P {| }, result)5_KML|g5g0v0P {| })5_LNMq~qvP(prfunction skip(source, n) { /**0 Reduces given `reducible` to a firs `n` items. **/! return accumulator(function() { var count = n || 0< return transform(source, function(next, value, result) {9 return count -- > 0 ? next(accumulated(), result) :/ next(value, result) }) })}exports.skip = skipfunction tail(source) {5_MON`qqvPaq`c`b5_NPOb vPacfunction skip(source, n) {5_OQPbvPacfunction dropWhile(source, n) {5_PRQn vPmoexports.skip = skip5_QSRnvP")moexports.drop = skip5_RTSFFPv P.EG 'function takeWhile(source, predicate) { /**J Composes version of given `source` containing only firs `n` items of it. **/9 return transform(source, function(next, value, state) {2 return predicate(value) ? next(value, state) :8 next(accumulated(), state) })}exports.takeWhile = takeWhilefunction take(source, n) {5_SUTeFFv P0*dq5_TVUpFFv P1op5_UWVpFFv P2+op5_VXWLFFv P,KM var count = n || Infinity5_WYXL FFv PKM+ var count = n === undefined || Infinity5_XZYL*FFv P-KM* var count = n === undefined ? Infinity5_Y[ZLFFv P'KM. var count = n === undefined ? Infinity : n5_Z\[LFFv P*KM% var count = n >= 0 ? Infinity : n5_[]\LFFv P.KM) var count = n >= 0 ? n ? Infinity : n5_\^]L)FFv P/.KM) var count = n >= 0 ? n : Infinity : n5_]b^\FFv PJ/[] var count = n || 05_^c_b^0FFv P]_9 return count -- > 0 ? next(accumulated(), result) :5_bdc^#FFv P0]_% return count -- > 0 ? result) :5_ced FFv P1 return skip(source, 1)5_dfe\FFv P2[] var count = n >= 0 ? n : 05_egfFFv P*5_fhgFFv P+function head(source) {5_gihFFv P+0 return reduce(source, function(result, item) {5_hjiFFv P+ return reduced(item)5_ikjFFv P, })5_jlkFFv P,}5_kmlFFv P,3exports.head = head5_lnmFFv P` function append(first, second) {5_monFFv Pbfunction append(left, second) {5_npovP function pop(source) { return tail(source)}exports.pop = popfunction peek(source) { return head(source)}exports.peek = peek5_opvP65_pvPvar reduce = Method5_vP'var reduce = Method()5_vP(var reduce = Method(function())5_ vP(7"var reduce = Method(function() {})5_vP8 5_vPE 5_vPX var reduce = Method(function() {5_-vP^0var reduce = Method(function(source, f, start) {5_vPc var accumulated = start5_ vPi }, start)5_?vP|? return value && value.is === end ? deliver(promise, result)5_3vP3 return value && value.is === end ? accumulated 5_ vP- return value && value.is === end ? result5_%vP7 : f(result, value)5_+vP9, 5_vP 5_<vP< // Default implementation assumes that all operations are 5_vP 2var reduce = Method(function(source, f, initial) {5_vPvar reduce = Method()5_vPfunction(source, f, initial) {5_vP2 // Default implementation assumes sync behaviour5_vP var accumulated = initial5_vP. accumulate(source, function(value, result) {5_vP4 accumulated = value && value.is === end ? result5_,vP> : f(result, value)5_vP  return accumulated5_vP  }, initial)5_vP })5_vP!:5_*vPH- return reducible(function(_, next, start) {5_ +%v%PM; }, start)5_+%v%P=5_+%v%PCEvar accumulated = Box('Indicator that source has being accumulateed')$var end = Box('end of the sequence')5_+%v%PD<Evar accumulated = Box('Indicator that source has being accumulateed')5_+%v%PG5_+%v%PH5_+%v%PI5_+%v%PL5_ +%v%PR5_+%v%PS=5_+%v%PX>5_vPK&function append(left, right) { /**4 Joins given `reducible`s into `reducible` of items7 of all the `reducibles` preserving an order of items. **/" return flatten(slice(arguments))}exports.append = append5// console.log(into(join([ 1, 2 ], [ 3 ], [ 3, 5 ])))function flatten(source) { /**7 Flattens given `reducible` collection of `reducible`s5 to a `reducible` with items of nested `reducibles`. **// return reducible(function(_, next, initial) {4 return reduce(source, function(result, nested) {5 return reduce(nested, function(result, value) {" return next(result, value) }, result) }, initial) })}exports.flatten = flattenA// console.log(into(flatten([ [1, 2], [ 3, 4 ], [], [ 7, 8 ] ])))function expand(source, f) { return flatten(map(source, f))}exports.expand = expand/*%console.log(into(expand(function(x) { return [ x, x * x ]}, [ 1, 2, 3 ])))*/5_vPL5_vPL?5_+vP@+-+-5_RTT v PQS! return accumulator(function() {5_bTT v Pac! return accumulator(function() {5_|TT v P{}! return accumulator(function() {5_|TT v P{} return transform(function() {5_'TT v P&(function accumulator(make) {5_,TT v P+-!exports.accumulator = accumulator5_,!TT v P+-!exports.transformer = accumulator5_%TT v P&(function accumulator%(%'5_'VV v P&(function accumulator()5_'VV v P&)function accumulator() {}5_'WW v P&(function accumulator() {5_'WW v P') ')5_(XX v P') return accumulate.implement()5_( XX v P')! return accumulate.implement({})5_'(+("v"PA&(function accumulator(f) {5_3"(+("v"PC24A return accumulate.implement({}, function(self, next, initial) {5_'(+("v"P1&("function accumulator(accumulate) {5_(,(+("v"P6')- return accumulate.implement({}, accumulate)5_'(+("v"P7&(function accumulator(f) {5_(#(+("v"P:E')$ return accumulate.implement({}, f)5_6B56CvP57C : f(next, value, result, state)5_2#56CvPG13&function transform(source, f, state) {5_)56CvPH)+)+5_*67CvP- accumulate(source, function(value, state) {5_67CvP  return state5_ 67CvP  state.push(value)5_ 67CvP I }, result)5_  vP9 6// Define a shortcut for `Array.prototype.slice.call`.5_  vP9 =var unbind = Function.call.bind(Function.bind, Function.call)5_  vP: 8var slice = Array.slice || unbind(Array.prototype.slice)5_  vP:K 5_/ vPk/1 /15_0 vPp/1 accumulate.define()5_0" vPr/1$ accumulate.define(Object.create())5_ 0* vPt/1* accumulate.define(Object.create(source))5_  1 vPxL/1+ accumulate.define(Object.create(source), function(self, next, initial) {024 return accumulator(function(self, next, initial) {5_   ##'vPN"$function transformer(make) {"$function accumulator(method) {) return accumulate.implement({}, method)}!exports.accumulator = accumulatorfunction transformer(make) {5_   +##vPgQ*,J accumulate.define(Object.create(source), function(self, next, initial) {5_   +##vPT*,M accumulate.implement(Object.create(source), function(self, next, initial) {5_ ##vP5_$$vPU 5_-%%%vPV,.T return accumulate.implement(Object.create(source), function(self, next, initial) {5_*%%vP*-*,5_,%%vP+, function 5_,%%vPW+,5_+%%vP+-+-5_,%%vP+- function 5_, %%vP+- function 5_,%%vP+-function reify5_,%%vP+-function reify()5_,%%vPX+,function reify(source)5_#%%vP#&#%5_%''vP$& function 5_% ''vP$& function 5_%''vP$%function transformer5_ %&&vP$%5_! *%%vP+-function convert*-*,5_ "!,%%vP+-function convert()5_!#", %%vP+- function convert(source, method)5_"$#,"%%vP+.#function convert(source, method) {}5_#%$,%%vP,. ,.5_$&%-%%vP,. return accumulate.implement()5_%'&-%%%vP,.' return accumulate.implement(create())5_&('-,%%vP,.- return accumulate.implement(create(source))5_')(1%%vP02M return accumulate.implement(create(source), function(self, next, initial) {5_(*)1%%vP 02@ return convert(create(source), function(self, next, initial) {5_)+*1%%vPY029 return convert(source), function(self, next, initial) {5_*,+.%%vPZ.0.05_+-,%%%vP3$&function transformer(make) {5_,.-'%%vP7&(, return accumulate(make(), next, initial)5_-/.%!%%vP;$&$function transformer(source, make) {5_.1/'%%%vP@[&(2 return accumulate(make(source), next, initial)5_/201& %%%vPI\%'A return accumulate.implement({}, function(self, next, initial) {5_132U%%%vPOTV! return transformer(function() {5_243U&%%%vPQTV) return transformer(source, function() {5_354e%%%vPXdf! return transformer(function() {5_465e%%%vP^df( return transformer(source, unction() {5_576e&%%%vP`df) return transformer(source, function() {5_687%%%vPd~! return transformer(function() {5_798&%%%vPg]~) return transformer(source, function() {5_8=9&%%%vP`%'E return accumulate.implement(source, function(self, next, initial) {5_9><="vP"$ "$5_=?>#vP"$ next()5_>@?# vPe"$ next(end())5_?A@vP2function capture//5_@BAvP9function capture()5_ACB!vP@!function capture(source, recover)5_BDC#vPB$function capture(source, recover) {}5_CEDvPF 5_DFE - -vPn transform()5_EGF - -vPq convert()5_FHG- -vPt convert(source, function())5_GIH/- -vP{0 convert(source, function(self, next, initial))5_HMI1VP|3 convert(source, function(self, next, initial) {})5_INJM.- -vP 5_MON- -vP accumulate()5_NPO- -vP accumulate(`)5_OQP- -vP accumulate(source, )5_PRQ!- -vP" accumulate(source, function())5_QSR#- -vP% accumulate(source, function() {})5_RTS - -vP# accumulate(source, function() {5_SUT- -vP })5_TVU - -vP 5_UWV - -vP if ()5_VXW - -vP! if (value && value.isBoxed)5_WYX&- -vP& if (value && value.is === error)5_XZY/- -vP 0 if (value && value.is === error) recover()5_Y[Z,- -vP / accumulate(source, function(value, state) {5_Z\[4,'v'P d5 if (value && value.is === error) recover(state)5_[]\','v'P 6 if (value && value.is === error) recover(result)5_\^]A,'v'P "A if (value && value.is === error) accumulate(recover(result)5_]i^C,'v'P BjC if (value && value.is === error) accumulate(recover(result), 5_^j_i2,'v'P A if (value && value.is === error) accumulate(recover(result)5_ikj:,'v'P  A if (value && value.is === error) accumulate(recover(result)5_jlk','v'P N if (value && value.is === error) accumulate(recover(value.value, result)5_kol/,'v'P 1k/ accumulate(recover(value.value, result)5_lpmo&,'v'P D& if (value && value.is === error)5_oqp),'v'P I) if (value && value.is === error) {}5_prq','v'P I 5_qsr,'v'P L 5_rts,'v'P Y }5_sut,'v'P [ } else {}5_tvu,'v'P \ 5_uwv ,'v'P bm next()5_vxw,'v'P oo5_wyx,'v'P p1 convert(source, function(self, next, initial) {5_xzy,'v'P function append//5_y{z,'v'P function append()5_z|{,'v'P function append(left, right)5_{}|,'v'P function append(left, right) {}5_|~},'v'P q5_}~,'v'P  5_~,'v'P  return convert()5_!,'v'P " return convert(left, function())5_#,'v'P % return convert(left, function() {})5_,'v'P 5_ ,'v'P r# return convert(left, function() {5_,'v'P 6 return convert(left, function(self, next, initial) {5_,'v'P  5_,'v'P   accumulate()5_,'v'P  accumulate(left, function())5_,,'v'P . accumulate(left, function(value, result`))5_,,'v'P - accumulate(left, function(value, result))5_.,'v'P 0 accumulate(left, function(value, result) {})5_,'v'P  })5_+,'v'P $ 5_ ,'v'P + if ()5_$,'v'P 5$ if (value && value.is === end)5_0,'v'P :1 if (value && value.is === end) accumulate()5_B,'v'P C 5_,'v'P Ks else next()5_,'v'P n 5_ ,'v'P q return :value && value.is === end) accumulate(right, next, result)D if (value && value.is === end) accumulate(right, next, result)5_','v'P uG return value && value.is === end) accumulate(right, next, result)5_H,'v'P wH return value && value.is === end ? accumulate(right, next, result)5_ ,'v'P zv else next(value, result)5_,'v'P w 5_,'v'P 5_,'v'P function append1()5_,'v'P function append1(left, right)5_,'v'P  function append1(left, right) {}5_,'v'P  5_vP %4 return convert({}, function(self, next, initial) {. accumulate(left, function(value, result) {J return value && value.is === end ? accumulate(right, next, result) :< next(value, result) }, initial) })}5_vP '5_vP )5_vP *2return convert({}, function(self, next, initial) {5_vP . }5_vP 0 5_vP 9 slice()5_vP ; slice(arguments)5_vP Bfunction append(left, right) {5_vP F 5_vP g return rest ? 5_vP i return rest ? slice()5_#vP k# return rest ? slice(arguments, 1)5_+vP m, return rest ? slice(arguments, 1).reduce()5_9vP s9 return rest ? slice(arguments, 1).reduce(append1, left)5_CvP vD return rest ? slice(arguments, 1).reduce(append1, left) : append()5_DvP wE return rest ? slice(arguments, 1).reduce(append1, left) : append1()5_<vP }P return rest ? slice(arguments, 1).reduce(append1, left) : append1(left, right)5_vP x slice(arguments).reduce()5_ vP y   5_vP 5_vP ~5_vP N return accumulated()5_vP function into(source, buffer) { /**& Adds items of given `reducible` into. given `array` or a new empty one if omitted. **/ var result = buffer || []& accumulate(source, function(value) {, if (value && value.isBoxed) return value result.push(value) }) return result}exports.into = into5_vP navar accumulate = Method()5_"vP nc#var accumulate = Method(function())5_$vP nd&var accumulate = Method(function() {})5_!vP ni$var accumulate = Method(function() {5_.vP nn5_(vP n{2var accumulate = Method(function(self, f, start) {5_vP n}5_vP n next()5_vP n next(self, start)5_vP n next(next(self, start)5_vP n next(next(self, start))5_CvCP Vexports.version = 5_CvCP aexports.version = ''5_CvCP mexports.version = '0.1'5_CvCP exports.version = '1.1'5_CvCP exports.version = '1.2'5_CvCP 5_P5_ vP reductions5_ vP 5_  vP function 5_ vPfunction reductions()5_* vP*function reductions(source, next, initial)5_, vP-function reductions(source, next, initial) {}5_ vP' 5_ vP2 return transform()5_ vP4 return transform(function())5_ vP4! return transform(function() {})5_  vPC,function reductions(source, next, initial) {5_ vPH return transform(function() {5_$ vPJ' return transform(source, function() {5_  vP] 5_ vP` var start5_  vPz 5_ vP~ return convert()5_" vP͂$ return convert(source, function())5_6 vP͉7 return convert(source, function(self, next, initial))5_8 vP͊: return convert(source, function(self, next, initial) {})5_ vP͌5_5 vP͔8 return convert(source, function(self, next, initial) {5_3 vP͖ 5_ vP͠ 5_ vPͪ accumulate()5_! vPͬ" accumulate(source, function())5_# vPͭ% accumulate(source, function() {})5_  vPͯ# accumulate(source, function() {5_ vPͳ })5_ vPͽ2 return transform(source, function(next, value) {5_ vPͽ })5_ vP 5_  vP next()5_  vP next(f())5_ vP next(f(state, value))5_ vP# next(f(state, value), result)5_ vP 5_ vP state = f()5_! vP* return next(f(state, value), result)5_  vP return next(state, result)5_ vP " result = next(state, result)5_ vP5_ vP5_ vPζ 5_  vPθ if ()5_ vPν if (result)5_! vP! if (value && value.isBoxed)5_ . vP/ if (value && value.isBoxed) return next()5_    vP 5_    vP state = 5_  , vP- state = value && value.isBoxed ? next()5_ : vP": state = value && value.isBoxed ? next(value, result)5_? vP$@ state = value && value.isBoxed ? next(value, result) : f()5_I vP'J state = value && value.isBoxed ? next(value, result) : f(state, vla)5_ vP+< if (value && value.isBoxed) return next(value, result)5_ vP, state = f(state, value)5_ vPBfunction revamp5_ vPFfunction revamp()5_ vPGfunction revamp(source, f)5_ vPHfunction revamp(source, f) {}5_ vPNfunction revamp(source, f) {5_! vPS 5_ vPf return accumulate()5_ vPm return accumulate(source, )5_ vPp return convert(source, )5_# vPr$ return convert(source, function())5_% vPr' return convert(source, function() {})5_" vPu% return convert(source, function() {5_ 3 vPy 5_!  vP~ 5_ "! vPڄ accumulate()5_!#"! vPچ" accumulate(source, function())5_"$## vPچ% accumulate(source, function() {})5_#%$  vPڌ# accumulate(source, function() {5_$&% vP%function revamp(source, f, initial) {5_%'&! vP 5_&(' vP * 5_')( vP Function takes `source` 5_(*)$ vP$ Function takes reducible `source` 5_)+*( vP( Function takes reducible `source`, `f`5_*,+B vPI Function takes reducible `source`, `f` transformer function and adjusts5_+-, vP reducible with adjustssource to a new  source to a new 5_,.- vP) reducible with adjusts source to a new 5_-/.! vP! reducible with source to a new 5_.0/ vP reducible that has desired 5_/10  vP< reducible adapted as nec5_021' vPA' reducible representing adapted as nec5_1325 vPG5 reducible representing adapted version of `source`.5_243H vPaH reducible representing adapted version of `source`. `f` is invoked for5_354 vPd each 5_465H vPfH reducible representing adapted version of `source`. `f` is invoked for5_576N vPhN reducible representing adapted version of `source`. `f` is invoked with eath5_687J vPjN reducible representing adapted version of `source`. `f` is invoked with each5_798 vPk each5_8:9 vPl each i5_9;:  vPm each item 5_:<;. vP6 each item and it's supposed to return pair `adjusted5_;=<- vP5 each item and it's supposed to return pair adjusted5_<>=5 vP5 each item and it's supposed to return pair adjusted5_=?>- vP< each item and it's supposed to return pair adjusted value 5_>@?? vP? each item and it's supposed to return pair of adjusted value 5_?A@G vPG each item and it's supposed to return pair of adjusted item and a new5_@BAA vPF each item and it's supposed to return pair of adjusted item and some5_ACBH vPH each item and it's supposed to return pair of adjusted item and a some5_BDC vP state5_CED vP& to be carried for a next invokation.5_DFE vP& to be carried for a next invocation.5_EGF% vP% to be carried to a next invocation.5_FHG vP to be carried to a next call.5_GIH. vP. to be carried to a next call. Initial `state5_HJI vPI each item and it's supposed to return pair of adjusted item and a state5_IKJA vP I Function takes reducible `source`, `f` transformer function and returns5_JLK vP `state` returns5_KML  vP `state`5_LNMB vPI Function takes reducible `source`, `f` transformer function and initial5_MONJ vPJ Function takes reducible `source`, `f` transformer function and `initial5_NPO  vP  `state`.5_OQP vP$ state.5_PSQ  vP) state. 5_QTRS vP> state 5_SUT vPB state. In return 5_TVU vPG state. Greducible representing adapted version of `source`. `f` is invoked withI reducible representing adapted version of `source`. `f` is invoked with5_UWV  vPJP state. reducible representing adapted version of `source`. `f` is invoked with5_VXW# vPPR state. Adreducible representing adapted version of `source`. `f` is invoked with5_WZX% vPT9 state. Adapted version of `source`. `f` is invoked with5_X[YZJ vPoO state. Adapted version of `source` is returned in result. `f` is invoked with5_Z\[  vPwW each item and curried state it's supposed to return pair of adjusted item and a state5_[]\+ vPe each item of the source and curried state it's supposed to return pair of adjusted item and a state5_\^]% vP> of it's supposed to return pair of adjusted item and a state5_]_^ vP of adjusted item and a state5_^`_  vP of adjusted item and new state5__a`  vP& of adjusted item and new state pair. to be carried to a next call. 5_`ba! vP% of adjusted item and new state pair5_acbJ vPJ of adjusted item and new state (which will be curried to next call) pair5_bdcJ vP 5_ced vP## 5_dfe vP ## 5_egf vP var content = 5_fhg vP5_gih% vP( var chunks = adjust(data, function() {5_hji1 vP 5_ikj vP var text = prefix + chunks5_jlk vP 5_kml vP var delimiterIndex = 5_lnm* vP* var delimiterIndex = text.lastIndexOf(5_mon vP5_npo vP& 5_oqp vP@% var data = [ 'hello my', 'friend', 5_prq$ vPO% var data = [ 'Hello my', 'friend', 5_qsr vPS) var data = [ Bite my shiny, metal ass! 5_rts vPX* var data = [ Bite my' shiny, metal ass! 5_sut' vP[- var data = [ Bite my', ' shiny, metal ass! 5_tvu) vP]. var data = [ Bite my', ' shiny, metal' ass! 5_uwv/ vPa/ var data = [ Bite my', ' shiny, metal' 'ass! 5_vxw  vPm1 var data = [ Bite my', ' shiny, metal' 'ass!' ]5_wzx  vPo5 var chunks = adjust(data, function(chunk, prefix) {5_x{yz vP var delimiterChar = '|'5_z}{  vP4 var words = adjust(data, function(chunk, prefix) {5_{~|} vP3 var chunks = [ Bite my', ' shiny, metal' 'ass!' ]5_}~* vP 5_~ vP var capturedChunk5_ vP  var capturedChunk5_% vP 5_G vP$G delimiterIndex = delimiterIndex >= 0 ? delimiterIndex : text.length5_ vP*= delimiterIndex = delimiterIndex >= 0 ? delimiterIndex : 05_ vP/8 var index = delimiterIndex >= 0 ? delimiterIndex : 05_& vP>& var capturedChunk = delimiterIndex5_G vPX 5_ vPaH var capturedChunk = splitIndex ? capturedChunk.substr(0, splitIndex)5_vPe var curriedChunk5_1vPmG var capturedPart = splitIndex ? capturedChunk.substr(0, splitIndex)5_vPo var curriedPart = 5_,vPt, var curriedPart = text.substr(splitIndex5_,vPw 5_vP 5_vP5_vP= var adjustedChunks = adjust(data, function(chunk, prefix) {5_ vP4 var chunks = [ 'Bite my', ' shiny, metal' 'ass!' ]5_vP> var capturedPart = splitIndex ? text.substr(0, splitIndex)5_vP- var curriedPart = text.substr(splitIndex)5_&vP( return [ capturedPart, curriedPart ]5_vP* return [ capturedPart, capturedChunk ]5_.vP1 var words = expand(adjustedChunks, function() {5_4vP7 var words = expand(adjustedChunks, function(chunks) {5_6vP6 var words = expand(adjustedChunks, function(chunk) {5_vP 5_)2vP%2 var data = [ 'Bite my', ' shiny, metal' 'ass!' ]5_%vPL? var capturedChunk = splitIndex ? text.substr(0, splitIndex)5_vP[5_vPn 5_vPs var 5_vPu 5_vP| var pair = f()5_ vP 5_vP 5_ vP if ()5_!vP! if (value && value.isBoxed)5_*vP+ if (value && value.isBoxed) return ()5_.vP/ if (value && value.isBoxed) return next()5_ vP var start = initial5_!vP" var pair = f(value, initial)5_vP })5_4vP7 return convert(source, function(self, next, result) {5_ vP }, result)5_5vP8 return convert(source, function(self, next, initial) {5_vP }, initial)5_vP 5_vP state = pair[]5_vP state = pair[0]5_vP 5_vP return next()5_vP return next(pair[])5_vP return next(pair[0])5_(vP?3 var data = [ 'Bite my', ' shiny, metal', 'ass!' ]5_vP 5_vP console.log(prefix, chunk5_vP console.log(prefix, chunk)5_vP }) 5_vP 5_vP convert5_vP 5_vP console.log()5_vP console.log(value)5_vP console.log('<<', value)5_v PO% console.log('>>>', prefix, chunk)5_v PS& console.log('<<', value, result)5_-.vP?. var curriedChunk = text.substr(splitIndex)5_) *v*PS+ return [ capturedChunk, capturedChunk ]5_=1v1P= var splitIndex = delimiterIndex >= 0 ? delimiterIndex : 05_#vP6 var words = expand(adjustedChunks, function(chunk) {5_vP- var words = expand(chunk, function(chunk) {5_vP return chunk.split('\n')5_(vP 5_vP * 5_vP#-per reduce) of coll by f, starting with init.5_vP(D Returns a lazy seq of the intermediate values of the reduction (as5_NvP7P Returns `reducible` collection of the intermediate values of the reduction (as5_vP; (as-per reduce) of coll by f, starting with init./ per reduce) of coll by f, starting with init.5_ vP=3 (as per reduce) of coll by f, starting with init.5_vPA3 (as per reduce) of coll by f, starting with init.5_vPC4 (as per reduce) of coll by `f, starting with init.5_0vPF5 (as per reduce) of coll by `f`, starting with init.5_5vPI6 (as per reduce) of coll by `f`, starting with `init.5_7vPK9 (as per reduce) of coll by `f`, starting with `initia`.5_9vPN: (as per reduce) of coll by `f`, starting with `initial`.5_@vPPA (as per reduce) of coll by `f`, starting with `initial` value..5_>vP` 5_vPd##5_vPe  ##5_vPl (reductions + [1 1 1 1])5_ vPn reductions + [1 1 1 1])5_vPq reductions(+ [1 1 1 1])5_vPt reductions([1 1 1 1])5_"vPx" reductions([1 1 1 1], function()5_!vP}' reductions([1 1 1 1], function() { })5_%vP+ reductions([1 1 1 1], function(x, p) { })5_(vP+ reductions([1 1 1 1], function(x, y) { })5_7vP8 reductions([1 1 1 1], function(x, y) { return x + y })5_9vP 5_vP // => 5_ vP // => (1 2 3 4)5_ vP // => [1 2 3 4)5_ vP // => [1, 2 3 4)5_vP // => [ 1, 2 3 4)5_vP // => [ 1, 2, 3 4)5_vP // => [ 1, 2, 3, 4)5_vP =>  5_vP => [ 5_ vP // => [ 5_ #v#P<$var end = Box('end of the sequence')5_" #v#P<$var end = Box("end of the sequence')5_ #v#P<$var end = Box("end of the sequence")5_vP>'/* vim:set ts=2 sw=2 sts=2 expandtab */5_vPryM/*jshint asi: true undef: true es5: true node: true browser: true devel: true9 forin: true latedef: false globalstrict: true */ 'use strict';var create = Object.createvar Method = require('method')var Box = require('./box')6// Define a shortcut for `Array.prototype.slice.call`.=var unbind = Function.call.bind(Function.bind, Function.call)8var slice = Array.slice || unbind(Array.prototype.slice)$var end = Box("End of the sequence")exports.end = endEvar accumulated = Box('Indicator that source has being accumulateed')!exports.accumulated = accumulatedvar error = Box('error')exports.error = error5var accumulate = Method(function(self, next, start) { next(end(), next(self, start))})exports.accumulate = accumulate9function accumulateEmpty(_, f, start) { f(end(), start) }-accumulate.define(undefined, accumulateEmpty)(accumulate.define(null, accumulateEmpty)9accumulate.define(Array, function(array, next, initial) {6 var state = initial, index = 0, count = array.length while (index < count) {' state = next(array[index++], state)0 if (state && state.is === accumulated) break } next(end(), state)}))function transformer(source, transform) {8 return convert(source, function(self, next, initial) {7 return accumulate(transform(source), next, initial) })}!exports.transformer = transformer"function convert(source, method) {5 return accumulate.implement(create(source), method)}exports.convert = convertfunction transform(source, f) {8 return convert(source, function(self, next, initial) {0 accumulate(source, function(value, result) {9 return value && value.isBoxed ? next(value, result)< : f(next, value, result) }, initial) })}exports.transform = transform$function filter(source, predicate) { /**M Composes filtered version of given `source`, such that only items contained- will be once on which `f(item)` was `true`. **/? return transform(source, function(next, value, accumulated) {D return predicate(value) ? next(value, accumulated) : accumulated })}exports.filter = filterfunction map(source, f) { /**S Composes version of given `source` where each item of source is mapped using `f`. **/? return transform(source, function(next, value, accumulated) {& return next(f(value), accumulated) })}exports.map = mapfunction take(source, n) { /**O Composes version of given `source` containing only element up until `f(item)` was true. **// return transformer(source, function(source) {% var count = n >= 0 ? n : Infinity< return transform(source, function(next, value, result) { count = count - 1E return count === 0 ? next(accumulated(), next(value, result)) :. count > 0 ? next(value, result) :4 next(accumulated(), result) }) })}exports.take = takefunction drop(source, n) { /**0 Reduces given `reducible` to a firs `n` items. **// return transformer(source, function(source) { var count = n >= 0 ? n : 1< return transform(source, function(next, value, result) {$ return count -- > 0 ? result :/ next(value, result) }) })}exports.drop = drop'function takeWhile(source, predicate) { /**J Composes version of given `source` containing only firs `n` items of it. **/9 return transform(source, function(next, value, state) {2 return predicate(value) ? next(value, state) :8 next(accumulated(), state) })}exports.takeWhile = takeWhile'function dropWhile(source, predicate) { /**3 Reduces `reducible` further by dropping first `n`, items to on which `f(item)` ruturns `true` **// return transformer(source, function(source) { var active = true< return transform(source, function(next, value, result) {= return active && (active = predicate(value)) ? result :H next(value, result) }) })}exports.dropWhile = dropWhilefunction tail(source) { return drop(source, 1)}exports.tail = tail2//console.log(into(skip(2, [ 1, 2, 3, 4, 5, 6 ])))//function append1(left, right) {4 return convert({}, function(self, next, initial) {. accumulate(left, function(value, result) {J return value && value.is === end ? accumulate(right, next, result) :< next(value, result) }, initial) })}$function append(left, right, rest) { /**4 Joins given `reducible`s into `reducible` of items7 of all the `reducibles` preserving an order of items. **/; return rest ? slice(arguments, 1).reduce(append1, left) :$ append1(left, right)}exports.append = append#function capture(source, recover) {8 return convert(source, function(self, next, initial) {0 accumulate(source, function(value, result) {( if (value && value.is === error) {> accumulate(recover(value.value, result), next, result) } else { next(value, result) } }, initial) })}exports.capture = capture)function reductions(source, f, initial) { /**L Returns `reducible` collection of the intermediate values of the reduction@ (as per reduce) of coll by `f`, starting with `initial` value. ## Example; reductions([1 1 1 1], function(x, y) { return x + y }, 0) // => [ 1, 2, 3, 4 ] **/7 return convert(source, function(self, next, result) { var state = initial0 accumulate(source, function(value, result) {L state = value && value.isBoxed ? next(value, result) : f(state, value) return next(state, result) }, result) })}exports.reductions = reductions%function adjust(source, f, initial) { /**K Function takes reducible `source`, `f` transformer function and `initial`N state. Adapted version of `source` is returned in result. `f` is called withK each item of the source and curried state and is expected to return arrayK of adjusted item and new state (which will be curried to next call) pair. ## Example var delimiterChar = ' '4 var data = [ 'Bite my', ' shiny, metal ', 'ass!' ]5 var chunks = adjust(data, function(chunk, prefix) { var text = prefix + chunk8 var delimiterIndex = text.lastIndexOf(delimiterChar)G var splitIndex = delimiterIndex >= 0 ? delimiterIndex : text.length2 var capturedChunk = text.substr(0, splitIndex)2 var curriedChunk = text.substr(splitIndex + 1)* return [ capturedChunk, curriedChunk ] }, ''). var words = expand(chunks, function(chunk) {% return chunk.split(delimiterChar) })2 // => [ 'Bite', 'my', 'shiny', 'metal', 'ass!' ] **/7 return convert(source, function(self, next, result) { var state = initial0 accumulate(source, function(value, result) {< if (value && value.isBoxed) return next(value, result) var pair = f(value, state) state = pair[1]" return next(pair[0], result) }, result) })}exports.adjust = adjust5_>,vPr=?5 return accumulate.implement(create(source), method)5_vPuexports.end = end5_vPuexports.end = require()5_vPuexports.end = require("")5_vPu$var end = Box('end of the sequence')5_vPuCvar accumulated = Box('Indicator that source has been accumulated')5_vPu5_!vPu!exports.accumulated = accumulated5_vPuexports.accumulated = require()5_vPu!exports.accumulated = require("")5_+vPu-exports.accumulated = require("./accumulate")5_vPu 5_vPu&exports.end = require("./end")5_ vPu' var end = 5_vPu(5_vPu-var accumulated = require()5_ vPu-var accumulated = require("")5_! 'vPu05_ "!vPu1exports.end = 5_!#".vPu2.exports.accumulated = require("./accumulated")5_"$# vPu5 exports.accumulated = accumulate5_#%$ vPu6 5_$&%vPu=  5_%'&vPu@ var error = require()5_&('vPuA var error = require("")5_')(vPuE5_(*)vPuFvar error = Box('error')5_)+*vPuGexports.error = error5_*,+vPuI5_+-,vPuMvar accumulate = require()5_,.-vPuMvar accumulate = require("")5_-/.vPuR5var accumulate = Method(function(self, next, start) {5_.0/vPuR next(end(), next(self, start))5_/10vPuS})5_021vPuSexports.accumulate = accumulate5_132vPuT5_243vPuT8// Implement accumulation for undefined and null values.5_354vPuUJ// Reducing/accumulating a null value will pass the initial start value to5_465vPuU'// the accumulating function, then end.5_576vPuU9function accumulateEmpty(_, f, start) { f(end(), start) }5_687vPuU-accumulate.define(undefined, accumulateEmpty)5_798vPuU(accumulate.define(null, accumulateEmpty)5_8:9vPuU5_9;:vPuVL// Implement accumulation method for native arrays, making arrays compatible5_:<;vPuV3// with reducer methods and other reducible values.5_;=<vPuV9accumulate.define(Array, function(array, next, initial) {5_<>=vPuV6 var state = initial, index = 0, count = array.length5_=?>vPuV while (index < count) {5_>@?vPuV' state = next(array[index++], state)5_?A@vPuW0 if (state && state.is === accumulated) break5_@BAvPuW }5_ACBvPuW next(end(), state)5_BDCvPuX})5_CEDvPuX5_DFE  vPu\5_EGF vPu`var transformer = require()5_FHG vPu`var transformer = require("")5_GIH' vPud5_HJI vPujvar transform = require()5_IKJ vPujvar transform = require("")5_JLK vPuo5_KML vPuo)function transformer(source, transform) {5_LNM vPup8 return convert(source, function(self, next, initial) {5_MON vPup7 return accumulate(transform(source), next, initial)5_NPO vPup })5_OQP vPuq}5_PRQ vPuq!exports.transformer = transformer5_QSR vPus5_RTS vPuwvar convert = require()5_SUT vPuwvar convert = require("")5_TVU vPu{5_UWV vPu|"function convert(source, method) {5_VXW vPu| /**5_WYX vPu|H Make a `source` object accumulatable by creating a prototypal copy and5_XZY vPu|G implementing the `accumulate` protocol on it with the given `method`.5_Y[Z vPu|, Returns an accumulatable/reducible object.5_Z\[ vPu} **/5_[]\ vPu}) return accumulate.implement({}, method)5_\^] vPu}}5_]_^ vPu}exports.convert = convert5_^`_ vPu}5__a` vPu}function transform(source, f) {5_`ba vPu~8 return convert(source, function(self, next, initial) {5_acb vPu~0 accumulate(source, function(value, result) {5_bdc vPu~9 return value && value.isBoxed ? next(value, result)5_ced$ vPu~< : f(next, value, result)5_dfe vPu~ }, initial)5_egf vPu~ })5_fhg vPu}5_gih vPuexports.transform = transform5_hji vPu5_ikj vPu5_jlk vPu5_kml vPu  5_lnm!!)vP{z " $function filter(source, predicate) { /**M Composes filtered version of given `source`, such that only items contained- will be once on which `f(item)` was `true`. **/? return transform(source, function(next, value, accumulated) {D return predicate(value) ? next(value, accumulated) : accumulated })}5_mon!!vP{5_npo""vP{var filter = require()5_oqp""vP{var filter = require("")5_prq%%,vP{$&function map(source, f) { /**S Composes version of given `source` where each item of source is mapped using `f`. **/? return transform(source, function(next, value, accumulated) {& return next(f(value), accumulated) })}5_qsr%%vP{5_rts&&vP{var map = require()5_sut&&vP{var map = require("")5_tvu"&&vP}!"5_uwv"%%vP}!"5_vxw#$$vP}"#5_wyx###vP}"#5_xzy%%3v P~ $&function take(source, n) { /**O Composes version of given `source` containing only element up until `f(item)` was true. **// return transformer(source, function(source) {% var count = n >= 0 ? n : Infinity< return transform(source, function(next, value, result) { count = count - 1E return count === 0 ? next(accumulated(), next(value, result)) :. count > 0 ? next(value, result) :4 next(accumulated(), result) }) })}exports.take = take5_y{z%%v P~5_z|{&&v P~var take = require()5_{}|&&v P~var take = require("")5_|~}%&&v PY$%5_}~''2vP&( function drop(source, n) { /**/ Reduces given `reducible` to first `n` items. **// return transformer(source, function(source) { var count = n >= 0 ? n : 1< return transform(source, function(next, value, result) {$ return count -- > 0 ? result :/ next(value, result) }) })}5_~&z''vP%&5_&y&&vP%&5_x&&vP5_y''vPvar drop = require()5_y''vPvar drop = require("")5_)y)1vP(* 'function takeWhile(source, predicate) { /**J Composes version of given `source` containing only firs `n` items of it. **/9 return transform(source, function(next, value, state) {2 return predicate(value) ? next(value, state) :8 next(accumulated(), state) })}5_q))vP5_r**vPvar takeWhile = require()5_r**vPvar takeWhile = require("")5_)r**vP()5_)q))vP()5_)p))vP)+)+5_q))vP5_r**vPvar dropWhile = require()5_r**vPvar dropWhile = require("")5_,r28vP<+-function tail(source) {+-'function dropWhile(source, predicate) { /**3 Reduces `reducible` further by dropping first `n`, items to on which `f(item)` ruturns `true` **// return transformer(source, function(source) { var active = true< return transform(source, function(next, value, result) {= return active && (active = predicate(value)) ? result :H next(value, result) }) })}exports.dropWhile = dropWhilefunction tail(source) {5_+b,,vP=+-5_6c--vP|565_6b--vP}562//console.log(into(skip(2, [ 1, 2, 3, 4, 5, 6 ])))5_6a--vP~56//5_6`--vP~565___qv0P5_``rv0Pvar reductions = require()5_``rv0Pvar reductions = require("")5__`_qv4P^`exports.reductions = reductions^`)function reductions(source, f, initial) { /**L Returns `reducible` collection of the intermediate values of the reduction@ (as per reduce) of coll by `f`, starting with `initial` value. ## Example; reductions([1 1 1 1], function(x, y) { return x + y }, 0) // => [ 1, 2, 3, 4 ] **/7 return convert(source, function(self, next, result) { var state = initial0 accumulate(source, function(value, result) {L state = value && value.isBoxed ? next(value, result) : f(state, value) return next(state, result) }, result) })}exports.reductions = reductions5____vP^`exports.reductions = reductions5_,__vP ,/,.5_ccvPb$%function adjust(source, f, initial) { /**K Function takes reducible `source`, `f` transformer function and `initial`N state. Adapted version of `source` is returned in result. `f` is called withK each item of the source and curried state and is expected to return arrayK of adjusted item and new state (which will be curried to next call) pair. ## Example var delimiterChar = ' '4 var data = [ 'Bite my', ' shiny, metal ', 'ass!' ]5 var chunks = adjust(data, function(chunk, prefix) { var text = prefix + chunk8 var delimiterIndex = text.lastIndexOf(delimiterChar)G var splitIndex = delimiterIndex >= 0 ? delimiterIndex : text.length2 var capturedChunk = text.substr(0, splitIndex)2 var curriedChunk = text.substr(splitIndex + 1)* return [ capturedChunk, curriedChunk ] }, ''). var words = expand(chunks, function(chunk) {% return chunk.split(delimiterChar) })2 // => [ 'Bite', 'my', 'shiny', 'metal', 'ass!' ] **/7 return convert(source, function(self, next, result) { var state = initial0 accumulate(source, function(value, result) {< if (value && value.isBoxed) return next(value, result) var pair = f(value, state) state = pair[1]" return next(pair[0], result) }, result) })}exports.adjust = adjust5_ccvP d c5_ddvP dvar adjust = require()5_ddvP dvar adjust = require("")5_EENvP>DE$function append(left, right, rest) {5_EEMvP>DE /**5_EELvP>DEN Concatenate multiple `reducible`s, returning a single `reducible` containing5_EEKvP>DE9 all the items from the original `reducibles`, in order.5_EEJvP?DE **/5_EEIvP?DE; return rest ? slice(arguments, 1).reduce(append1, left) :5_EEHvP?DE$ append1(left, right)5_EEGvP@DE}5_:EFvPC9:function append1(left, right) {5_:DEvPC9: /**5_:CDvPC9:7 The reducing function for append (below). Not public.5_:BCvPC9: **/5_:ABvPD9:4 return convert({}, function(self, next, initial) {5_:@AvPD9:. accumulate(left, function(value, result) {5_:?@vPD9:J return value && value.is === end ? accumulate(right, next, result) :5_:)>?vPD9:< next(value, result)5_:=>vPD9: }, initial)5_:<=vPE9: })5_:;<vPE9:}5_ :;vPJ!R!Q5_ ;<vPN!Rvar append = require()5_ ;<vPN!Rvar append = require("")5_; ;<vPW;=S;=R5_<;=vP`;=Sexports.concat = concat5_;;=vPc:<Sexports.append = append5_ ;=vPj!S var append = require("./concat")5_1;=vP015_1:<vP01function tail(source) {5_19;vP01 /**5_18:vP01$ Get the last value of a reducible.5_179vP01, Reduces a reducible to it's tailing value.5_168vP01 **/5_157vP01 return drop(source, 1)5_146vP01}5_135vP01exports.tail = tail5_124vP015_013vP/05_33DvP024H#function capture(source, recover) { /**I Capture any boxed errors that occur while reducing a given `source` and2 `recover` reduction using the provided function.P Allows you to bake error handling and recovery into your reductions -- crucial, for live data sources like XHR or Sockets. **/8 return convert(source, function(self, next, initial) {0 accumulate(source, function(value, result) {( if (value && value.is === error) {> accumulate(recover(value.value, result), next, result) } else { next(value, result) } }, initial) })}5_233vP11375_333vP9235_333vP:23exports.capture = capture5_333vP;235_333vP<235_ 33vP@ "4 "35_!44vPF "4var capture = require()5_!44vPF "4var capture = require("")5_1:<vP025_19;vP025_18:vP025_179vP025_168vP025_157vP025_146vP025_135vP025_124vP025_113vP025_002vP/15_vP> "use strict';5_ 7>vP> "use strict";5_+6=vPS_*,5_+5<vPS_*,5_+4;vPS_*,5_+3:vPS`*,5_+29vPS`*,5_+18vPS`*,5_+07vPSa*,5_+/6vPSa*,5_+.5vPSa*,5_+-4vPSb*,5_ +,3vPSb*,5_  ++2vPSc*,5_   +++vPS}*3function transform(source, f) 5_   +++vPS}*,5_   +++vPS~*,5_  +++vPS~*,5_vP" expand(chunks, function(chunk) {5_1vP&6 var capturedChunk = text.substr(0, splitIndex - 1)5_9vPA var splitIndex = delimiterIndex >= 0 ? delimiterIndex + 1 : 05_=vP= var splitIndex = delimiterIndex >= 0 ? delimiterIndex : 05_1vP6 var capturedChunk = text.substr(0, splitIndex + 1)5_5vP6 return convert(source, function(self, next, state) {5_5vP6 return convert(source, function(self, next, state) {5_"vP#function adjust(source, f, state) {5_?vPBA var capturedChunk = splitIndex ? text.substr(0, splitIndex) :5_27,v,P; var chunks = adjust(data, function(chunk, curriedChunk) {5_vP# var text = curriedChunk + chunk5_&vP) return [ capturedPart, curriedChunk ]5_{}| vP2 var chunks = [ Bit my', ' shiny, metal' 'ass!' ]5_xzy1 vP5_XZY< vPhW state. Adapted version of `source` is returned in result. On each `f` is invoked with5_QSRA vP6H Function takes reducible `source`, `f` transformer function, `initial`5_   / vP5_  : vP5_ vP  st5_ vPM }, )5_CvCP {5_ vP {5_CvCP exports.version = exports.version = ''5_CvCP %exports.version = '2.0'5_CvCP /exports.version = '3.0'5_vP }append.one = functionappend.one = function()5_vP "append.one = function(left, right)5_"vP %append.one = function(left, right) {}5_$vP $append.one = function(left, right) {}5_vP {,append.one = function append1(left, right) {5_vP  5_vP 5_vP 5_vP 5_vP | 4 return convert({}, function(self, next, initial) {. accumulate(left, function(value, result) {J return value && value.is === end ? accumulate(right, next, result) :< next(value, result) }, initial) })5_vP ' append.one(left, right)5_lnom-+'v'P 9/ accumulate(source, function(value, state) {5_mn'+'v'P =* accumulate(source, function(value, ) {5_^`i_-,'v'P i7 accumulate(source, function(value, result, start) {5__a`4,'v'P h7 accumulate(source, function(value, result, state) {5_`ba,'v'P &5_acb,'v'P '5_bdc,'v'P '5_ced,'v'P '5_dfe,'v'P '5_egf,'v'P '5_fhg,'v'P (5_gh,'v'P (g5_IKMJ.- -vP/ convert(source, function(self, next, state) {5_JLK+- -vP  if ()5_KL- -vP if (value)5_9:=<vP5_9;<:'%'vP %var first = Methodvar first = Method()5_:;(%(vP *_var rest = Method()5_/10%&%%%vPD$&.function transformer(source, transformation) {5_ +B##vP*,Q return accumulate.implement(Object.create(source), function(_, next, initial) {5_   +##vPP*,T return accumulate.implement(Object.create(source), function(self, next, initial) {5_bvPjac/ return accumulator(function(_, next, value) {5_vPDA// console.log(into(flatten([ [1, 2], [ 3, 4 ], [], [ 7, 8 ] ])))5_pr' 'vPA  accumulator()5_' 'vPM accumulator(function())5_' 'vPN accumulator(function() {})5_' 'vPO accumulator(function() { })5_' 'vPP  /*5_' 'vPT5  */5_' 'vP  accumulate()5_' 'vP" accumulate(source, function())5_!' 'vP% accumulate(source, function() {})5_#' 'vP# accumulate(source, function() { })5_ ' 'vP1 accumulate(source, function(nested, result) {5_-' 'vP5_.' 'vP) accumulate(source, function(nested) {5_' 'vP accumulate()5_' 'vP$ accumulate(nested, function())5_#' 'vP' accumulate(nested, function() {})5_%' 'vP% accumulate(nested, function() { })5_"' 'vP2 accumulate(nested, function(value, result) {5_.( (@v@P5_( (@v@P6 : accumulate.implement({}, function(self, next, initial) { })5_( (@v@PR5_( (@v@PT5_( (@v@PV 5_( (@v@Pi accumulate()5_( (@v@Pk" accumulate(source, function())5_ ( (@v@Pn( accumulate(source, function(nested))5_'( (@v@Pp+ accumulate(source, function(nested) {})5_)( (@v@Pp) accumulate(source, function(nested) { })5_%( (@v@P5_( (@v@P 5_( (@v@P accumulator()5_( (@v@P accumulate()5_( (@v@P" accumulate(nested, function)5_( (@v@P3@ accumulate.implement({}, function(self, next, initial) {5_psqrvP  return transform()5_rtsvP & return transform(source, function())5_sut$vP1 return transform(source, function(next, value))5_tvu0vP!4 return transform(source, function(next, value) {})5_uwv2vP"2 return transform(source, function(next, value) { })5_vxwvP*5_wyx/vP.3 return transform(source, function(next, nested) {5_xzy0vP:; return transform(source, function(next, nested, result) {5_y{zvP= return accumulate()5_z|{vPP) return accumulate(nested, function())5_{}|(vPV, return accumulate(nested, function() {})5_|~}*vPW* return accumulate(nested, function() { })5_}~'vP`1 return accumulate(nested, function(value, ) {5_~vPd }, result)5_vP }, [])5_vP  result.push()5_vP if (result.push()5_vP if (result) {}5_vP if (result) {5_vP if (result) result.push()5_vP# if (result) result.push(nested)5_vP })5_vP  else result = []5_vP# if (result) result.push(nested)5_ vP else { result = []5_vP3 return accumulate(nested, function(value, ) {5_vP }, result)5_vP'  }5_0vP39 return accumulate(nested, function(value, result) {5_872v2P<; return transform(source, function(next, nested, queued) {5_72v2PX# if (queued) result.push(nested)5_72v2P[# if (queued) queued.push(nested)5_ 72v2P_ queued = []5_72v2PT# if (queued) result.push(nested)5_6vP88 return accumulate(nested, function(value, start) {5_prqvP/5_^`b_]6FFv P]^ ]_ count = count - 15__a`_FFv P^`8 return count === 0 ? next(accumulated(), result) :5_`a_FFv P^` return count === 0 ?# next(accumulated(), result) :5_DFExg5g0v0Pwy; return count -- === 0 ? next(accumulated(), result) :5_;=<u!g5g0v0Ptv& return accumulator(function() {value5