VimUnDob[  r`O="d<a3PZ$_Py;5_Py;""5_ Py> "use strict"5_ Py>function reducer5_PyIfunction reducer()5_PyKfunction reducer(process)5_PyLfunction reducer(process) {}5_ PyR 5_ PyY return function reducer()5_ PyY return function reducer() {}5_ Pya return function reducer() {5_ )Pyh, return function reducer(source, options) {5_  (Pyi+ return function reducer(source, option) {5_ (Pyj 5_Pyt return reducible()5_Pyv return reducible(function())5_!Pyv# return reducible(function() {})5_Py{! return reducible(function() {5_*Py~5_Py 5_Py  accumulate()5_"Py " accumulate(source, function)5_#Py # accumulate(source, function()5_%Py & accumulate(source, function() {}5_Py  }5_!Py   5_Py  process()5_Py  process(option, )5_"Py % accumulate(source, function() {5_Py 5_ Py5_! Py5_ "!Py var reduce = require("./reduce")5_!#" Py var reduce = require("./reduce")5_"$#"Py$var accumulate = require("./reduce")5_#%$ Py  process(option, next, )5_$&% *Py   5_%'& Py  if ()5_&(' Py  if (isError())5_')( Py  if (isError(value))5_(*) !Py " if (isError(value)) next()5_)+* Pz / if (isError(value)) next(value, result)5_*,+ Pz 6 if (isError(value)) return next(value, result)5_+-, Pz : return (isError(value)) return next(value, result)5_,.- Pz  9 return isError(value)) return next(value, result)5_-/. %Pz  8 return isError(value) return next(value, result)5_.0/ Pz , process(option, next, value, result)5_/10 Pz D process(option, next, value, result)5_021 3Pz 3 return isError(value) ? next(value, result)5_132Pz#5_243Pz(var isError = require()5_354Pz(var isError = require("")5_4J5 Pz2 3 process(option, next, value, result)5_5P6J vPz 5_JQKP  vP 5_PRQ  vP 5_QSR  vP   5_RTS  vP  value 5_SUT  vP  value 5_TVU   vP  value === end5_UWV   vP 5 return isError(value) ? next(value, result) :5_VXWvP  5_WYX vP  return value === end5_XZY $vP % return value === end ? next()5_Y\Z 2vP 2 return value === end ? next(value, result)5_Z][\"vP5_\^]vPvar end = require()5_]_^vP var end = require("")5_^`_PEo(var accumulate = require("./accumulate")5__a`.PEr0var accumulate = require("reducible/accumulate")5_`baPEt,var accumulate = require("reducible/reduce")5_acbPEx&var reducible = require("./reducible")5_bdcPE|#var isError = require("./is-error")5_cedPEvar end = require("./end")5_dfePE(var isError = require("reduce/is-error")5_egfPEvar end = require("/end")5_fhgPE +var reducible = require("reduce/reducible")5_gih PE  2 accumulate(source, function(value, result) {5_hji PE   5_ikj )PE ) Function takes transformation function 5_jlk ,PE , Function produces transformation function 5_kml 0PE 0 Function produces transformation function by s5_lnm 4PE = Function produces transformation by simply taking function 5_mon ,PE ? Function produces transformation by simply taking a function 5_npo BPE  takes  C Function produces transformation from a simple taking a function 5_oqp PE  takes f, next, value, result5_prq PE  takes `f, next, value, result5_qsr PE ! takes `f, next, value, result` 5_rts PE ! takes `f` next, value, result` 5_sut PE " takes `f`, next, value, result` 5_tvu PE # takes `f`, `next, value, result` 5_uwv PE # takes `f`, `next` value, result` 5_vxw PE $ takes `f`, `next`, value, result` 5_wyx PF % takes `f`, `next`, `value, result` 5_xzy PF & takes `f`, `next`, `value`, result` 5_y{z PF & takes `f`, `next`, `value`, result` 5_z|{ 'PF ' takes `f`, `next`, `value`, `result` 5_{}| 1PF 1 takes `f`, `next`, `value`, `result` arguments.5_|~} PF  1 takes `f`, `next`, `value`, `result` arguments 5_}~ PF" + `f`, `next`, `value`, `result` arguments 5_~ "PF; L Function produces transformation from a simple `process`-ing function that5_ PFF   5_ PFP 5_ PFR  transform(source, f)5_ PFR   5_PFW5_PFc It takes $a simple `process`-ing function that+ from a simple `process`-ing function that5_ PFd/ It takes a simple `process`-ing function that5_PFg4 It takes a much simple `process`-ing function that5_5PFi5 It takes a much simpler `process`-ing function that5_5PFs5 It takes a much simpler `process`-ing function that5_FPFzF It takes a much simpler `process`-ing function that for each element5_PF5_PF takes:5_PF> `f` - Function that is `next`, `value`, `result` arguments 5_PFB - `f` - Function that is `next`, `value`, `result` arguments 5_PFC 1. `f` - Function that is `next`, `value`, `result` arguments 5_.PF] 1. `f` - Function passed to the resulting function. `next`, `value`, `result` arguments 5_HPFl 1. `f` - Function passed to the resulting transformation function. `next`, `value`, `result` arguments 5_PF+ 2. `next`, `value`, `result` arguments 5_PF6 2. `next` - Function `value`, `result` arguments 5_PF 2. `next` - Function 5_3PF3 2. `next` - Function which needs to be invoked 5_IPF I 2. `next` - Function which needs to be invoked with transformed value5_JPF!J 2. `next` - Function which needs to be invoked with transformed value,5_PF" or simply skipped 5_PF) if it needs to be skipped result i5_PF 5_PF  `value`, `result` arguments 5_PF # 3. `value`, `result` arguments 5_CPG  V 3. `value` - Last value emitted by a collection being reduced. `result` arguments 5_PG! 4. `result` arguments 5_PG!( 4. `result` - Accumulate darguments 5_'PG!' 4. `result` - Accumulate arguments 5_#PG!# 4. `result` - Accumulate value 5_"PG" !5_%PG0". Function is supposed to return new `result` 5_.PG4". Function is supposed to return new `result` 5_$PG8". Function is supposed to return new `result` 5_;PG:"; Function is supposed to return new, accumulated `result` 5_"PGR#" pass mapped transformed `value` 5_2PG]#7 pass mapped transformed `value` and `result` to next 5_<PG_#< pass mapped transformed `value` and `result` to the `next 5_ PGf% $5_PGl& %5_-PG|'. For example see `map` and `filter` function.5_PG'. return reducible(function(next, initial) {5_PG'. return reducible(function(next, initial) {5_PG'. reduce(source, function(value, result) {5_ PG ( *  '5_ PG  Convinience 5_ PG ( Convenience 5_ +PG (: Convenience function to simplify defining tarsformation 5_ 4PG (C Convenience function to simplify of transformation tarsformation 5_ 2PG (A Convenience function to simplify definitions of tarsformation 5_ 2PG @ Convenience function to simplify definitions of tarsformation 5_ APG (A Convenience function to simplify definitions of transformation 5_ JPG (J Convenience function to simplify definitions of transformation function.5_ PG (B Function produces transformation that has a following signature:5_ PG (9 produces transformation that has a following signature:5_ PG (? takes produces transformation that has a following signature:5_ PH (9 produces transformation that has a following signature:5_ PH (8 creates transformation that has a following signature:5_ ?PH (@ creates typical transformation that has a following signature:5_ )PH (* creates typical transformation function:5_ DPH" (E creates typical transformation function with a following signatuer:5_PH')(5_PH3) From a pure .`process`-ing function that for each value for)H It takes a much simpler `process`-ing function that for each value for5_PH9(A From a pure data `process`-ing function that for each value fora sequence is passed:( a sequence is passed:5_ PHE'W From a pure data `process`-ing function that for each value for a sequence is passed:5_.PHK'S From a pure data `process` function that for each value for a sequence is passed:5_5PHP'Y From a pure data `process` function that is called each value for a sequence is passed:5_IPHR'\ From a pure data `process` function that is called on each value for a sequence is passed:5_ PHS( sequence is passed:5_PHV( collection is passed:5_%PH^(5_PH`)5_PHj!+ !*5_ PHs!+ // Generate reducible5_ PHw!+ // Create a reducible5_ PH , // Create a reducible that will call to 5_ JPH *M Convenience function to simplify definitions of transformation function. It5_PH , function. ItCcreates typical transformation function with a following signature: ,E creates typical transformation function with a following signature:5_ HPH +R function. It creates typical transformation function with a following signature:5_"PH"$- "$,5_#PH"$- // Reduce 5_!PH!$. !#-5_PH transform(source, f)5_PH/ Transform(source, f)5_ PH0 transform(source, f)0 /5_ PH / signature:5_PI/ transform(source, f)5_ PI /F 1. `f` - Function passed to the resulting transformation function.5_PI/L 1. `options` - Function passed to the resulting transformation function.5_$PI/T 1. `options` - Options Function passed to the resulting transformation function.5_KPI most commonly that/K 1. `options` - Options passed to the resulting transformation function.5_,PI%0: most commonly that's a function like map(source, f)5_;PI&0; most commonly that's a function like `map(source, f)5_,PI(0< most commonly that's a function like `map(source, f)`5_?PI* 0? most commonly that's a function like in `map(source, f)`5_'?PI=')1 ')05_(PIK')1$ // If value is end of source5_(PIL')1% // If value is `end of source5_(&PIO'*1& // If value is `end` of source5_)PIi(*2! // otherwise call process5_)"PIj(*2" // otherwise call `process5_)BPIu$(+2B // otherwise call `process` with all the curried arguments5_PY3 "use strict";(var reduce = require("reducible/reduce").var reducible = require("reducible/reducible")+var isError = require("reducible/is-error")"var end = require("reducible/end")function reducer(process) { /**M Convenience function to simplify definitions of transformation function, toL avoid manual definition of `reducible` results and currying transformationG function. It creates typical transformation function with a following signature: transform(source, options)H From a pure data `process` function that is called on each value for a& collection with following arguments:J 1. `options` - Options passed to the resulting transformation function@ most commonly that's a function like in `map(source, f)`.J 2. `next` - Function which needs to be invoked with transformed value,. or simply not called to skip the value.B 3. `value` - Last value emitted by a collection being reduced.# 4. `result` - Accumulate value.I Function is supposed to return new, accumulated `result`. It may eitherI pass mapped transformed `value` and `result` to the `next` continuation or skip it./ For example see `map` and `filter` functions. **/, return function reducer(source, options) {F // When return transformation function is called with a source and // `options`< return reducible(function reduceReducer(next, initial) { // When actual result is B reduce(source, function reduceReducerSource(value, result) {J // If value is `end` of source or an error just propagate through,M // otherwise call `process` with all the curried `options` and `next`! // continuation function.4 return value === end ? next(value, result) :5 isError(value) ? next(value, result) :4 process(options, next, value, result) }) }) }}module.exports = reducer5_PZ "use strict";(var accumulate = require("./accumulate")&var reducible = require("./reducible")#var isError = require("./is-error")var end = require("./end")function reducer(process) {, return function reducer(source, options) {. return reducible(function(next, initial) {2 accumulate(source, function(value, result) {4 return value === end ? next(value, result) :5 isError(value) ? next(value, result) :4 process(options, next, value, result) }) }) }}module.exports = reducer5_PH='Y From a pure data `tarnsform`-ing function that for each value for a sequence is passed:5_Z\[ -vP - return reducible(function(next, initial) 5_JLPK vP #function reducer(source, process) {5_KML  vP 5_LNM vP5_MON  vP, return reducible(function(next, initial) {0 accumulate(source, function(value, result) {3 return isError(value) ? next(value, result) :2 process(options, next, value, result) }) })5_NO VP  ) process(next, value, result)5_57J6PzFfunction Reducer()5_687PzKfunction Reducer() {}5_798PzLfunction Reducer() {}5_8:9PzNfunction Reducer(process) {5_9;:PzO   this.process = process5_:<; PzY  accumulate.define accumulate.define()5_;=< Pz] &accumulate.define(Reducer, function())5_<>= $Pz`  ;Pzh ?accumulate.define(Reducer, function(reducer, next, initial) {})5_>@? =Pzi =accumulate.define(Reducer, function(reducer, next, initial) {})5_?A@ Pz|    accumulate()5_@BA Pz  return reducible5_ACB vPz#function Reducer(process, source) {5_BDC vPz    this.source source5_CED vPz  return new Reducer()5_DFE vPz' return new Reducer(process, source)5_EGF  vPz  this.source = source5_FHG& vPz0 return new Reducer(process, source, options)5_GIH  vPz,function Reducer(process, source, options) {5_HI  vPz    this.options = options5