VimUnDoZ0C8ߎ|!$]KU2=g" dispatch(null, result)4P_PI5_PK:<var zip = new function() {5_PK<=5_PK<=""5_ PK?=5_ PKA> "use strict"5_PKF ?>5_ PKIE5_  PKMEfunction zip()5_ PKPEfunction zip(left, right)5_ PKPEfunction zip(left, right) {}5_ PK[G F5_   PKfG reduce()5_ PKkG reduce(left, function())5_PKkG reduce(left, function() {})5_PKlI H5_ PKrI reduce()5_PKtI reduce(right, function())5_PKuI reduce(right, function() {})5_PK~KJ5_PKKvar accumulate = require()5_PKKvar accumulate = require("")5_+PKK5_PKL reduce(left, function() {5_PK L reduce(right, function() {5_PKL accumulate(left, function() {5_PK L accumulate(right, function() {5_ PK L# accumulate(right, function(_, ) {5_PKM L5_PKM var pairs = []5_ PKM var pairs = [[]]5_! PKN M5_ "!PKN function accumulator()5_!#"!PK O  N5_"$#PK O queue.push()5_#%$PK P  O5_$&% PKP var pairs = [[], []]5_%'&PL P var leftQueue = [[], []]5_&('PL Q P5_')( PL Q if pa5_(*) PL$ Q if ()5_)+* PL0 Q if (leftQueue.length)5_*,+PLCR Q5_+-,PLISR5_,.- PL]S return 5_-/.PL`S return convert()5_.0/PL`S return convert({})5_/10PLbS return convert({}, function())5_021!PLb S# return convert({}, function() {})5_132vPLe T })5_243vPLf 5_354vPLg S var leftQueue = []5_465 vPLh S var rightQueue = []5_576 vPLk S# function accumulator(queue, item)5_687 vPLm S queue.push(item)5_798 vPLn S. if (leftQueue.length && rightQueue.length)5_8:9 vPLy T  S5_9;: vPL} T })5_:<;vPLUT5_;=<  vPLUfunction accumulator()5_<>=  vPLUfunction accumulator() {}5_=?>  vPLUfunction accumulator() {}5_>@?  vPL V5_?A@  vPLWfunction accumulator() {5_@BA   vPLX W5_ACB   vPLX queues[]5_BDC   vPLX queues[0]5_CED  vPLX if ()5_DFE   vPLX if (queues[])5_EGF  vPLX if (queues[1])5_FHG  vPLX if (queues[1].length)5_GIH  vPL X if (queues[1].length) {}5_HJI  vPLY$function accumulator(queues, item) {5_IKJ  vPLY if (queues[1].length) {5_JLK   vPLY if (state.length) {5_KML  vPL Z  Y5_LNM vPL  function Zip [ Z5_MON vPL \function Zip()5_NPO vPL \function Zip() {}5_OQP vPL ]function Zip() {} ]}5_PRQ vPL ] \5_QSR vPL ]accumulate.define()5_RTS !vPL ]"accumulate.define(Zip, function())5_SUT #vPL ]%accumulate.define(Zip, function() {})5_TVUvPM _ ^5_UWVvPM` _5_VXWvPMa `5_WYXvPMb a5_XZYvPM,c b5_Y[ZvPM5d c5_Z\[ vPM9e d5_[]\vPM=! return convert({}, function() {5_\^]vPM= var leftQueue = []5_]_^vPM= var rightQueue = []5_^`_vPM= })5__a`vPM>% function accumulator(queue, item)5_`bavPM> queue.push(item)5_acbvPM>0 if (leftQueue.length && rightQueue.length)5_bdcvPM># accumulate(left, function(_, l) {5_cedvPM> })5_dfevPM>$ accumulate(right, function(_, r) {5_egfvPM? })5_fhgvPM?}5_gih vPMK Y#accumulate.define(Zip, function() {5_hji 4vPM] Z  Y5_ikjvPMi Z accumulator()5_jlk vPMy [  Z5_kml vPM} [ accumulate()5_lnmvPM accumulator(zipped, )5_mon'vPM Z( accumulate(zipped.left, accumulator, )5_npo,vPM[ Z5_oqpvPM[ accumulator()5_prq vPM[ accumulate()5_qsrvPM[#function accumulator(state, item) {5_rts-vPM [. accumulate(zipped.left, accumulator, zipped)5_sut(vPM [* accumulate(zipped.left, accumulator, [])5_tvu9vPM [; accumulate(zipped.left, accumulator, [zipped.leftBuffer])5_uwv(vPM [= accumulate(zipped.left, accumulator, [zipped.leftBuffer, ])5_vxw)vPM [E accumulate(zipped.left, accumulator, { queue: zipped.leftBuffer, ])5_wyxvPM\ queue: zipped.leftBuffer, ])5_xzyvPM\ queue: zipped.leftQueue, ])5_y{zvPM\ queue: zipped.leftQueue ])5_z|{vPM] queue: zipped.leftQueue5_{}|vPN^ value.bufferLeft = []5_|~}vPN^ value.bufferRight = []5_}~vPN!^ ])5_~vPN#_ ^5_vPN2_ next: zipped.next5_.'vPN>_/ accumulate(zipped.right, accumulator, zipped)5_ 'vPNAc queue: zipped.leftQueue,5_ 'vPNCc buffer: zipped.rightQueue,5_ 'vPNGc queued: zipped.rightQueue,5_vPNIc queue: zipped.rightQueue, next: next5_vPNJb next: next5_vPNLc b5_vPNM5_vPNTc$function accumulator(zipped, item) {5_vPNXc if (state.other.length) {5_vPN\ state.push()5_vPN] c  b5_ vPNm d  c5_vPN d var result = initial5_vPN d var result = {}5_ vPNe d5_vPNe next: next5_vPNe next: next5_vPN f state.next()5_$vPN f% state.result.value = state.next()5_%vPN f' state.result.value = state.next([])5_vPN5_vPN#function accumulator(state, item) {5_vPN if (state.buffer.length) {5_vPN( state.result.value = state.next([ ])5_vPN }5_vPN}5_vPNa`5_vPNafunction accumulateLeft()5_vPNafunction accumulateLeft() {}5_vPN c b5_vPO cfunction accumulateRight()5_vPO cfunction accumulateRight() {}5_ vPO d5_vPO e5_vPOffunction accumulateLeft() {5_ vPO g  f5_vPO g var state = {}5_vPO  g var state = { value}5_vPO* g, var state = { result: initial, next: next}5_vPO,h result: initial, next: next}5_vPO. leftQueue: }i next: next}5_vPO6j leftQueue: []}5_vPO7l k5_ vPO<l leftQueue: []5_vPO>l rightQueue: []5_vPOH l var state = {result: initial,l result: initial,5_vPOJ k var state = { result: initial, next: next,k next: next,5_vPOK j, var state = { result: initial, next: next,left: []j left: []5_vPOM i5 var state = { result: initial, next: next, left: [] right: []i right: []5_?vPON h? var state = { result: initial, next: next, left: [] right: []5_5vPOQ hA var state = { result: initial, next: next, left: [] right: [] }5_vPOS }5_vPOWh g5_vPO]h function accumulateLeft(state) {5_vPO_h if5_vPO`h if ()5_vPOeh if (state.right.length)5_vPOf h if (state.right.length) {}5_vPOg j  i5_vPOv j state.result = 5_vPO{ j state.result = state.next()5_vPO j2 state.result = state.next(state.right.shift())5_9vPO j: state.result = state.next([ item, state.right.shift())5_ vPO j }5_ vPO j } else {}5_ vPO l  k5_ vPO l state.left.push()5_(vPOl( accumulate(zipped.left, accumulator, {5_(vPOm l5_ vPOm accumulate()5_vPO queue: zipped.leftQueue,5_vPO buffer: zipped.rightQueue,5_vPO next: next,5_vPO result: result5_vPO })5_vPO) accumulate(zipped.right, accumulator, {5_vPO queue: zipped.rightQueue,5_vPO buffer: zipped.leftQueue,5_vPO next: next,5_vPO result: result5_vPO })5_vPO! var result = { value: initial }5_@vPOaB var state = { result: initial, next: next, left: [], right: [] }5_OvPOaQ var state = { result: initial, next: next, left: [], right: [], ended: failed }5_%vPOb a5_vPOb if ()5_vPOb if (state.ended)5_vPO b if (state.ended) {}5_vPO d  c5_vPOdvar transformer 5_vPOdvar accumulated = require()5_vPOdvar accumulated = require("")5_'vPOd)var accumulated = require("accumulated/")5_!vPOd(var accumulated = require("accumulated")5_!vPO d return accumulated()5_!vPPd if (state.ended) { return accumulated(state.result) d$ return accumulated(state.result)5_!vPP }5_!vPPc b5_!vPPdc5_!vPP(dfunction accumulateAt()5_!vPP,dfunction accumulateAt(index)5_ !vPP3dfunction accumulate5_!vPP4dfunction Accumulate5_!vPP6dfunction AccumulateAt()5_ !vPP=dfunction makeAccumulator()5_!vPPDdfunction makeAccumulator()5_!vPPFdfunction makeAccumulator(side)5_ !vPPFd!function makeAccumulator(side) {}5_!vPPIf e5_!vPPUf return function accumulate()5_)!vPPWf) return function accumulate(item, state)5_+!vPPX f, return function accumulate(item, state) {}5_!vPPZ h  g5_!vPP[ h if ()5_!vPP^ h if (state.ended)5_(!vPPe h) if (state.ended) return accumulated()5_*!vPPi   // we i  h5_ !vPP  j5 // If one of the streams is ended, tell the otherwe're done accumulating. j // we're done accumulating.5_ 4!vPP j  i5_!vPPk j5_!vPPk var other = side === ""5_!vPPk var other = side === "left"5_!!vPPk" var other = side === "left" : ""5_!vPPk' var other = side === "left" : "right"5_'!vPPk' var other = side === "left" ? "right"5_+!vPPk, var other = side === "left" ? "right" : ""5_ !vPP k if ()5_ !vPP k if (state[])5_ !vPP k if (state[oethr])5_ !vPP k if (state[other])5_!vPP l  k5_!vPP l var index = side === ""5_!vPP l var index = side === "length"5_!vPP l var index = side === "left"5_ !!vPP l" var index = side === "left" ? ""5_  !vPQ l if (state[other].length)5_   !vPQ l if (state[other].length) {}5_   !vPQ& n  m5_   !vPQ* o  n5_  !vPQ,  value5_  !vPQ2 n var value = []5_ !vPQ8  var value = 5_ !vPQ: n  m5_ !vPQA n state[]5_ !vPQB n state[side]5_ !vPQI n state[side].push()5_   vPQN n state[side].push(item)5_   vPQN o  n5_ vPQP  p  o5_ vPQW p // queue current value5_ vPQY p5_vPQ[q if (state[other].length) {5_vPQ\ 5_vPQ] }5_vPQ^o if (state[other].length) 5_vPQ`o if (state[other].length) {}5_vPQaq p5_  vPQkq! state.result = state.next()5_! !vPQkq# state.result = state.next([])5_ "!4vPQqq6 state.result = state.next([ state.left.shift()])5_!#"IvPQxqK state.result = state.next([ state.left.shift(), state.right.shift()])5_"$#vPQq }5_#%$ vPQq } else {}5_$&%vPQ q }r } else { }5_%'&  vPQ r  q5_&*'  vPQ  5_'+(*  vPQ r  q5_*,+ ! vPQ r+ return function accumulate(item, state) {5_+-,  vPQ  // queue current value.5_,.-  vPQ  state[side].push(item)5_-/.  vPQ p5_.0/  vPQ r q5_/10  vPQ r if ()5_021  vPQ r if (value.isBoxed)5_132  vPR  r if (value.isBoxed) 5_243 % vPR r& if (value && value.isBoxed) next()5_354 vPR  #value.isBoxed ? next(value, result)5_465$ vPR  < : f(next, value, result)5_576  vPR% p9 if (value && value.isBoxed) next(value, state.result)5_687  vPR( 5_798  vPR. p  o5_8:9  vPR4 p? if (value && value.isBoxed) state.next(value, state.result) p else 5_9;:  vPR9 o? if (value && value.isBoxed) state.next(value, state.result)5_:<;  vPR: q  p5_;=< vPR@ q }5_<>=  vPRC q } else {}5_=?> vPREs r5_>@? vPR~ts5_?A@ vPRtfunction queue()5_@BA vPRtfunction queue() {}5_ACB vPR u5_BDC vPRvfunction queue() {5_CED vPRv5_DFE vPRfunction queue(state, value) {5_EGF vPR5_FHG vPR}5_GIH vPR5_HJI vPRs state.value5_IKJ  vPRs state[]5_JLK vPRs state[side]5_KML vPRs state[side].push()5_LNMvPRs if (state[other].length) {L state.result = state.next([ state.left.shift(), state.right.shift() ]) }5_MONvPRr q5_NPOvPRtL state.result = state.next([ state.left.shift(), state.right.shift() ])5_OQPvPRt }5_PRQvPRt }t 5_QSR  vPRt s5_RTS  vPR return st5_SUT  vPRt s5_TVU  vPRt state.result5_UWV  vPRt return state.result5_VXW -  vPSZ u  t5_WYX   vPS[ u result.is === accumulated5_XZY   vPS_ u! if (result.is === accumulated5_Y[Z   vPSb u if (value.is === accumulated5_Z\[ )  vPSf u) if (value && value.is === accumulated5_[]\ +  vPSk u+ if (value && value.is === accumulated) 5_\^] ,  vPSk u- if (value && value.is === accumulated) {}5_]_^   vPSm w  v5_^`_  vPSwN state.result = state.next([ state.left.shift(), state.right.shift() ])5__a`   vPSx w5_`ba   vPSx if ()5_acb  vPSx return state5_bdc  vPSx if (result && res)5_ced0  vPSx0 if (result && result.is === accumulated)5_dfe2  vPSx3 if (result && result.is === accumulated) {}5_egf  vPSz y5_fhg  vPSz next()5_gih   vPS {  z5_hji  vPS{L var result = state.next([ state.left.shift(), state.right.shift() ])5_ikj  vPS{ state.next()5_jlk   vPS{ next()5_kml  vPS{ next(end())5_lnm  vPS{2 if (result && result.is === accumulated) {next(end(), result){ next(end(), result)5_mon  vPS }5_npo   vPSz y5_oqp0vPS{z5_prq.0vPS|0var accumulated = require("reduced/accumulated")5_qsr0vPS|(var accumulated = require("reduced/end")5_rts0vPS, if (value && value.is === accumulated) {5_sut0vPS state.ended = true5_tvu0vPS }5_uwv0vPTy state.result = result5_vxw10vPT-yD if (result && result.is === accumulated) next(end(), result)5_wyx0vPT/z state = result5_xzy 0vPT1{ z5_y{z0vPT7{5_z|{0vPT:} |5_{}|0vPT?5_|~} 0vPTB| }5_}~0vPTD| } else {}5_~0vPTE~ }5_ 0vPTR ~N // If one of the streams is ended, tell the other we're done accumulating.5_ 10vPT] ~P // If one of the streams have ended, tell the other we're done accumulating.5_ /0vPTa ~N // If one of the streams have ended, signal other we're done accumulating.5_ E0vPTe ~R // If one of the streams have ended, signal the other we're done accumulating.5_0vPTj 5_0vPT } else {5_0vPT 5_0vPT5_ 0vPT var take()5_0vPT 5_0vPTvar take(1, side)5_0vPT5_#0vPT# // Otherwise enqueue the value 5_0vPT 5_:0vPU 5_(0vPUM. // If consumer is done consuming mark 5_00vPUS0 // If consumer is done consumption mark 5_ 0vPUxB // If consumer is done consumption, dispatch end, and mark,stream ended so that other one will be able 7 // stream ended so that other one will be able 5_J0vPU|o // If consumer is done consumption, dispatch end, and mark stream ended so that other one will be able 5_00vPU0 // ended so that other one will be able 5_0vPU 5_%0vPU) state.left = state.right = null5_7G0vPU68P var state = { result: initial, next: next, left: [], right: [], ended: false }5_7O0vPU 68Q var state = { result: initial, next: next, left: [], right: [], active: false }5_0vPU 5 if (state.ended) return accumulated(state.result)5_0vPU! 6 if (state.active) return accumulated(state.result)5_ 0vPU6 state.left = state.right = state.next = null5_ 0vPU" state.ended = true5_ 0vPU 5_ 0vPU# // dispatch stream end5_ 0vPU  var next = state.next5_  vPU$F var result = next([ state.left.shift(), state.right.shift() ])5_  vPU% next(end(), result)5_   vPV & state = result5_   vPV%! // dispatch stream end.5_!  vPV('! // Dispatch stream end.5_  vPV/!5_   vPV0 5_$  vPV2($ // Dispatch end of stream.5_  vPVC! !5_   vPX*! // 5_'  vPY')5_(  vPY '(5_(  vPY '(&function accumulateLeft(item, state) {5_(  vPY '( // If done accumulating5_(  vPY '(3 if (state.ended) return accumulated(state.result)5_(  vPY '( if (state.right.length) {5_(  vPY '(< state.result = state.next([ item, state.right.shift() ])5_(  vPY!'( } else {5_(  vPY!'( state.left.push(item)5_(  vPY!'( }5_(  vPY!'(}5_(  vPY"'(5_(  vPY"'(function accumulateRight() {5_(  vPY#'(}5_(  vPY#'*y5_) vPY3(*zvar accumulateLeft = accumulate5_)% vPY5(*z&var accumulateLeft = makeAccumulator()5_)& vPY5(*z(var accumulateLeft = makeAccumulator("")5_)) vPY6)+{)+z5_*& vPY=)+{'var accumulateRight = makeAccumulator()5_*' vPY=)+{)var accumulateRight = makeAccumulator("")5_*+ vPY?+*,{5_| vPYD|5_>{,vPYR=>@var zip = new function() { var end = {}; function drained(branch) { return !branch.queued.length }: function pending(branch) { return branch.queued.length }9 function shift(branch) { return branch.queued.shift() }< function ended(branch) { return branch.queued[0] === end } function react(state) {% if (state.branches.some(ended)) {* realize(state.promise, state.result)* state.result = reduced(state.result)/ } else if (state.branches.every(pending)) {, var zipped = state.branches.map(shift)5 state.result = state.next(state.result, zipped)2 realize(state.pending.shift(), state.result) }" if (is(state.result, reduced))0 realize(state.promise, state.result.value) } return function zip() {" var sources = slice(arguments), return reducible(function(next, start) { var state = { pending: [], promise: defer(), result: start, value: defer(), next: next,0 branches: sources.map(function(source) {< return { source: source, queued: [], pending: [] } }) }/ state.branches.forEach(function(branch) { var index = 00 var result = reduce(function(_, value) {% var pending = state.pendingC var result = pending[index] || (pending[index] = defer()) index ++# branch.queued.push(value) react(state) return result }, branch.source) go(function() {! branch.queued.push(end) react(state) }, result) })( return go(identity, state.promise) }) }}exports.zip = zip5_<>,vPYS;<5_<=,vPYT;<5_;<,vPYT,:;5_:;,vPYW-::5_"=,vPY= <5_ >-vPY= if ()5_>-vPY= if (value)5_>-vPY= if (value.is === end)5_>-vPY= if (value.is === end) {}5_?.vPY? >5_@/vPY? if (value.is === end) {5_@/vPY }5_?.vPY> if (value.is === end);state.active = state.left = state.right = state.next = null>C state.active = state.left = state.right = state.next = null5_>-vPY.=W if (value.is === end) state.active = state.left = state.right = state.next = null5_?.vPY/? >5_!@/vPY?.var accumulate = require("reduced/accumulate")5_"@/vPY?/var accumulate = require("reducers/accumulate")5_"@/vPY?0var accumulated = require("reduced/accumulated")5_@/vPY0? var end = require("reduced/end")5_2(@/vPZ13?) accumulate(zipped.left, accumulateLeft)5_3*@/vPZ!124?+ accumulate(zipped.right, accumulateRight)5_05@/vPZ$/1?8accumulate.define(Zip, function(zipped, next, initial) {5_1020.v.PZ(302?P var state = { result: initial, next: next, left: [], right: [], active: true }5_020.v.PZ35?% state.next(value, state.result)5_ !020.v.P\X @  ?5_ 121.v.P\[6 @ console.log()5_ 121.v.Pk7  console.log(value, state)5_020.v.Pld? if (value.is === end)5_$020.v.Pli?& if (value.is === end && state[])5_*020.v.Pln?+ if (value.is === end && state[other])5_)020.v.Plw?2 if (value.is === end && state[other].length)5_020.v.Pl|9?1 if (value.is === end && state[side].length)5_6020.v.Pm 57?function zip(left, right) {5_6020.v.Pm457?function zip(left, right, ) {5_6020.v.Pm757?function zip(left, right) {5_6%020.v.PmB57?(function zip(left, right/*, ...rest*/) {5_6020.v.PmD57?&function zip(left, right/*, ...rest) {5_6020.v.PmF68@ 68?5_7020.v.PmG68@ if ()5_7020.v.PmI68@ if ()5_7 020.v.PmK68@ if (rest)5_7020.v.PmW67 if (rest) {}5_6020.v.PmX68@ 68?5_7 020.v.Pma68@ switch arguments.length5_7020.v.Pmb68@ switch (arguments.length5_7020.v.Pmc7:A 79@5_9020.v.Pmu8:B left5_9020.v.Pmw8:B map(left5_9020.v.Pmz9;C 9;B5_9020.v.Pm8:C map(left, Array)5_7020.v.Pm68C switch (arguments.length)5_7020.v.Pm68C switch (arguments.length) {}5_;020.v.Pm:<C var value = new Zip()5_<020.v.Pm;=C value.left = left5_=020.v.Pm<>C value.right = right5_>020.v.Pm=?C value.leftQueue = []5_?020.v.Pm>@C value.rightQueue = []5_@020.v.Pm?AC return value5_@020.v.Pm@CD @BC5_6020.v.Pm57E!function zip(left, right, rest) {5_6 020.v.Pm57E#function zip(left, right/*, rest) {5_6020.v.Pm:57E%function zip(left, right/*, rest*/) {5_020.v.PmFE5_121.v.PmFvar map = require()5_121.v.Pm;Fvar map = require("")5_C121.v.PmCEG CEF5_C 121.v.PmBDG reduce5_ 121.v.Pm H G5_  !222.v.Pm< H5_   E323.v.PmDFI 5_   E323.v.PmDFI slicer.call5_   E323.v.PmDFI slicer.call()5_  E323.v.PmDFI slicer.call(arguments, 2)5_ E'323.v.PmDFI( slicer.call(arguments, 2).reduce()5_E1323.v.PmDFI2 slicer.call(arguments, 2).reduce(function())5_E3323.v.PmDGI5 slicer.call(arguments, 2).reduce(function() {})5_E0323.v.Pm=DFJ3 slicer.call(arguments, 2).reduce(function() {5_8323.v.Pm8:K8:J5_9323.v.Pn8:Kfunction append()5_9323.v.Pn8;Kfunction append() {}5_9323.v.Pn8:Lfunction append() {5_:323.v.Pn :<L5_9323.v.Pn 9;N 9;M5_: 323.v.Pn9;N array.push()5_:323.v.Pn:<O :<N5_J@323.v.PnIKO@ slicer.call(arguments, 2).reduce(function(zipped, right) {5_K323.v.Pn#>JK })5_J-323.v.Pn0IKN. slicer.call(arguments, 2).reduce(append)5_J0323.v.Pn2IKN2 slicer.call(arguments, 2).reduce(function())5_J<323.v.Pn5IKN= slicer.call(arguments, 2).reduce(function(left, right))5_ J>323.v.Pn5ILN@ slicer.call(arguments, 2).reduce(function(left, right) {})5_! J323.v.Pn7JLP JLO5_ "!K 323.v.Pn8JLP zip()5_!#"K323.v.Pn>JLP zip(left, right)5_"$#K323.v.Pn?JLP map(zip(left, right)5_#%$K323.v.PnHJLP% map(zip(left, right), append)5_$&%<323.v.PnW=?function concatzip<?Q<>P5_%'&9323.v.Pnb8:Rfunction append(array, item) {5_&('>323.v.Pnh=?Rfunction concatzip()5_')(>$323.v.Pnr=?R$function concatzip(zipped, sequence)5_(*)>&323.v.Pnr=@R'function concatzip(zipped, sequence) {}5_)+*>FFvPn>@T >@S5_*,+=GGvPn=?U=?T5_+-,>HHvPn=> function zip25_,.-?GGvPn>@T var value = new Zip()5_-/.? GGvPn>@T zipped()5_.0/?GGvPn>@T zip()5_/10?GGvPn>@T zip(zipped, sequence)5_021?GGvPn>@T map(zip(zipped, sequence)5_1329 GGvPn8:Tfunction push(array, item) {5_2439GGvPn8:Tfunction append(array, item) {5_354?!99 v Pn>@T" map(zip(zipped, sequence), push)5_465?99 v Pn>@T$ map(zip(zipped, sequence), concat)5_576N>99 v PnMOT> slicer.call(arguments, 2).reduce(function(left, right) {5_687O99 v PnNO, return map(zip(left, right), append)5_798O99 v Pn?NO })5_8:9899 v Pn8:S8:R5_9;:9:: v Pn8:Sfunction array()5_:<;9:: v Pn8;Sfunction array() {}5_;=<:;; v Pn:<T5_<>=9<< v Pn8:Ufunction array() {5_=?>9<< v Pn9;V 9;U5_>@?: == v Pn9;V return []5_?A@:== v Po8:Vfunction array(item) { return [item]9;V return [item]5_@BA:<< v Po@8:U$function array(item) { return [item]}9;U}5_ACBG;; v PoFHT return map(left, Array)5_BDCG!;; v PoFHT" return map(left, argumentsy)5_CEDG ;; v Po BFHT! return map(left, arguments)5_DFEP0;; v PoMOQT1 slicer.call(arguments, 2).reduce(concatzip)5_EaFP6;; v PoPEOQT8 slicer.call(arguments, 2).reduce(concatzip, zip())5_FbHaCvPrrT5 // If value was indication of end then cleanup.2 if (value.is === end && !state[side].length)C state.active = state.left = state.right = state.next = null }5_acb IvPrtQ }5_bdcIvPrwR // Q5_cedIvPr{U6 if // If value was indication of end then cleanup.5_dfeIvPr}U4 i// If value was indication of end then cleanup.5_egfIvPr~U2 if (value.is === end && !state[side].length)5_fhg>vPrU> // if value is boxed meta item, just propagate it through.3 // If value was indication of end then cleanup.5_gih>vPrT7 // If value was indication of end then cleanup.5_hji>vPrUT5_ikj>vPr5_jlk>vPr5_kml>vPrT! if (value && value.isBoxed) {5_lwm>vPrNT0 if (value.is === end && !state[side].length)5_mxnw4L>vPwO35TN var state = { result: start, next: next, left: [], right: [], active: true }5_wyx>vPwU T5_xzy>vPwU var left = value[]5_y{z>vPwV7 if (!state.active) return accumulated(state.result)5_z|{>vPwV> if (!other.accumulated) return accumulated(state.result)5_{}|>vPwV9 if (!other.active) return accumulated(state.result)5_|~}>vPwV7 if (!other.active) return accumulated(state.result)5_}~>vPx VF if (!other.active && this.length) return accumulated(state.result)5_~>vPxVG if (!other.active && !this.length) return accumulated(state.result)5_>vPxVI if (!state[].active && !this.length) return accumulated(state.result)5_%>vPxVN if (!state[other].active && !this.length) return accumulated(state.result)5_'>vPx VQ if (!state[other].active && !state[].length) return accumulated(state.result)5_>vPx,V5_+>vPx5WU if (!state[other].active && !state[side].length) return accumulated(state.result)5_D>vPx<WD // If one of the streams have ended, signal the other we're done5_>vPxTPW // accumulating.5_6>vPxwWV if (!state[other].active && !state[other].length) return accumulated(state.result)5_5>vPxyX5 if (!state[other].active && !state[other].length)5_8>vPx{X8 if (!state[other].active && !state[other].length) {}5_%>vPx{Y X5_>vPxY7 if (!state[other].active && !state[other].length) {5_>vPx  var dispatch = state.next5_>vPx  var left = state.left5_>vPx  var right = state.right5_>vPx 5_>vPx }5_A>vPxTA if (!state || !state[other].active && !state[other].length) {5_>>vPxT5_>vPx5_>vPxT5_ >vPx V  U5_>vPx V if ()5_>vPx V if (!state)5_>vPx V$ if (!state) return accumulated()5_*>vPx V+ if (!state.active) return accumulated()5_>vPx V7 if (!state.active) return accumulated(state.result)5_>vPxV? if (!state || !state[other].active && !state[other].length)5_>vPxVD else if (!state || !state[other].active && !state[other].length)5_>vPxV; else if ()!state[other].active && !state[other].length)5_ >vPxQ W  V5_!>vPy W! // If this stream was already5_>vPy : // If this stream was already notified but it's still 5_>vPyR 5 if (!state.next) return accumulated(state.result)5_ >vPyU: else if (!state[other].active && !state[other].length)5_5>vPyU5 if (!state[other].active && !state[other].length)5_8>vPy U8 if (!state[other].active && !state[other].length) {}5_>vPy3V U5_ >vPy?V state[]5_>vPyB state5_%>vPyDV U5_>vPyM5_>vPyOU9 if (value && value.is === end && !state[side].length)5_!>vPySV U5_>vPy^V3 // If value was indication of end then cleanup.5_=>vPylV> else if (value && value.is === end && !state[side].length)5_%>vPyoW V5_ >vPyxW if ()5_>vPyyW if (state[])5_ >vPy|W if (state[other])5_>vPy~W if (!state[other])5_>vPyW if (!state[other].left)5_>vPyW5_ >vPy Y  X5_>vPy Y var queue = state[]5_>vPyZ Y5_>vPyZ var buffer = state[]5_>vPyZ7 if (!state[other].active && !state[other].length) {5_'>vPyZ1 if (!buffer.active && !state[other].length) {5_!>vPyZ+ if (!buffer.active && !queued.length) {5_ >vPyZ* if (!buffer.active && !queue.length) {5_>vPyZK // If the other stream has ended and there is nothing left in the queue5_%>vPyZK // If buffer is empty has ended and there is nothing left in the queue5_K>vPyZK // If buffer is empty and closed and there is nothing left in the queue5_>vPyZ+ if (!buffer.active && !buffer.length) {5_>vPyZ* if (!buffer.close && !buffer.length) {5_ >vPyZ) if (!buffer.open && !buffer.length) {5_>vPyZ( if (buffer.open && !buffer.length) {5_>vPySZ* if (buffer.clsoed && !buffer.length) {5_>vPzZ% // If buffer is empty and closed notify this stream we're done.Z% // notify this stream we're done.5_&>vPz YD // If buffer is empty and closed notify this stream we're done.5_C>vPzTYC // If buffer is empty and closed notify this stream we're done.5_>vPz,Z2 // If value is indication of end then cleanup.5_J>vPz5ZJ // If this is an end of this stream is indication of end then cleanup.5_&>vPz8[ Z5_'>vPzBU[' // If this is an end of this stream5_>vPzY5_>vPz\V[ if (!state[other].length)5_>vPzj[ if (!queue.length)5_>vPzn[ if (!queue.length) next()5_>vPzz\ [5_>vPzW\ var dispatch = state.nexn5_>vPz\2 if (!queue.length) next(value, state.result)5_>vPzX] \5_>vPz]6 if (!queue.length) dispatch(value, state.result)5_>vPz_ ^5_>vPz_ return accumulated()5_">vPz_/ return accumulated(value, state.result)5_>vPz` _5_>vPzYC state.active = state.left = state.right = state.next = null5_>vPz_@ // If queue is empty then also notify consumer we're done.5_(>vPz_D // If queue is empty and then also notify consumer we're done.5_ >vPz_J // If queue is empty, send end of stream notify consumer we're done.5_M>vPz_M // If queue is empty, forward end of stream notify consumer we're done.5_#>vPz_B // If queue is empty, forward end of stream to consumer and 5_C>vPz_C // If queue is empty, dispatch end of stream to consumer and 5_>>vPzZ_> // If queue is empty, dispatch end of stream, and notify5_>vP{( return accumulated(state.result)5_>vP{^ if (!queue.length) {dispatch(value, state.result)^% dispatch(value, state.result)5_>vP{[ }5_'>vP{\' else if (value && value.is === end)5_*>vP{\* else if (value && value.is === end) {}5_>vP{\> // if value is boxed meta item, just propagate it through.5_ >vP{\> // If value is boxed meta item, just propagate it through.5_2>vP{!\N // If any other boxed value is boxed meta item, just propagate it through.5_/>vP{'\; // If any other boxed value, just propagate it through.5_>vP{/\< // If any other boxed value, just propagate it through.5_0>vP{2\; // If any other meta value, just propagate it through.5_.>vP{4\\9 // If any other meta value, just propagateit through.5_>vP{7^\: // If any other meta value, just propagate it through.5_#>vP{W"$\ state[side].push(value)5_# >vP{Z_"$\ queued.push(value)5_%>vP{r`$&\ if (state[other].length) {5_$>vP{#%\; // If both values are queued than shift and dispatch.5_$2>vP{#%\K // If values on both streams are are queued than shift and dispatch.5_$ >vP{#%\H // If values on both streams are buffered than shift and dispatch.5_$>vP{#%\Q // If there is values on both streams are buffered than shift and dispatch.5_$>vP{#%\G // If there is both streams are buffered than shift and dispatch.5_$>vP{#%\J // If there is a value streams are buffered than shift and dispatch.5_$>vP{#%\J // If there is a value streams are buffered than shift and dispatch.5_$%>vP{#%\S // If there is a buffered value streams are buffered than shift and dispatch.5_$)>vP{#%\V // If there is a buffered value on streams are buffered than shift and dispatch.5_$H>vP{a#%\[ // If there is a buffered value on both streams are buffered than shift and dispatch.5_>vP{] \5_>vP{] if ()5_>vP{] if (closed)5_>vP{] if (state.closed)5_>vP{] if (state.closed) {}5_>vP{_ ^5_>vP{_ return accumulated()5_>vP{` _5_>vP{`* if (buffer.closed && !buffer.length) {5_>vP{b` // 5_>vP|#`& return accumulated(state.result)5_>vP|$` return state.result)5_ >vP|&` if (state.closed) {5_  >vP|'` if (state.closed) return state.result` return state.result5_   >vP|) }5_   />vP|T^/ else if (buffer.closed && !buffer.length) {5_   >vP|U }5_  >vP|Xc]- else if (buffer.closed && !buffer.length) return accumulated(state.result)]& return accumulated(state.result)5_ &>vP|a\& else if (value && value.isBoxed) {5_>vP|b\% else if (value && value.isBoxed) dispatch(value, state.result) \# dispatch(value, state.result)5_&>vP|d[C else if (value && value.isBoxed) dispatch(value, state.result)5_>vP|ed }5_*>vP|)+ZE state.active = state.left = state.right = state.next = null5_$ >vP|e$&[ $&Z5_+>vP|f+-\ +-[5_>vP|\* if (state.closed) return state.result5_>vP|h\& if (dispatch) return state.result5_- >vP|,/\ } else {5_. >vP|-/] eelse {5_. >vP|-/] else {5_/ >vP|./- // otherwise just update the state.5_/ >vP|./ state.result = result5_.>vP}n-/[ else if {5_ .>vP}o-/[ else if () {5_! .->vP}w-/[0 else if (buffer.closed && buffer.left) {5_ "!.">vP}{-/[2 else if (buffer.closed && buffer.length) {5_!#".>vP}.0\ .0[5_"$#/>vP}i.0\ return accumulated()5_#%$/(>vP~ /1] /1\5_$&%0>vP~ /1] dispatch()5_%'&0>vP~ /1] dispatch(end())5_&('(/(1(2v5P~,')]2 if (result && result.is === accumulated) {5_')(../.vP~2-/]3 else if (buffer.closed && !buffer.length) {5_(-)(2./.vP~6k(*^ ) {'*]5 if (result && result.is === accumulated ||) {5_).*-////vP~_./ else if () {5_-/./ ///vP~`./* return accumulated(state.result)5_.0// ///vP~`./! dispatch(end(), result)5_/10////vP~al./ }5_021%///vP~$% state.result = result5_132,./.vP~,.Z ,.Y5_243-%///vP~,.Z& state.result = accumulated()5_354. ///vP~-/Z }5_465.///vP~-0Z } else {}5_576.0/0vP~m.0\ .0[5_687%+1/1vP~$'\I // If consumer is done consumption, dispatch end, and mark stream5_798%12/2vP~$&]1 // If consumer is done consumption or if 5_8:9' 2/2vP~%']( // dispatch end, and mark stream6ended so that other one will stop queueing values too.&(]A // ended so that other one will stop queueing values too.5_9;:&/1/1vP~%'\_ // dispatch end, and mark stream ended so that other one will stop queueing values too.5_:<;&I1/1vP~%'\b // dispatch end, and mark stream ended to so that other one will stop queueing values too.5_;=<&71/1vP~%'\K // dispatch end, and mark stream ended to stop queueing values too.5_<>=&L1/1vP~n%(\W // dispatch end, and mark stream ended to stop streams and queueing values too.5_=?>2/2vP N else if (buffer.closed && !buffer.length) return accumulated(state.result)5_>@?1/1vP B // If buffer is empty and closed notify this stream we're done5_?G@0/0vP p // consuming.5_@HAG///vPyZ6 if (!queue.length) dispatch(value, state.result)5_GIH0/0vPz\ [5_HJI1/1vP] \5_IKJ2/2vP] state.next = null5_JMK"2/2vP^ ]5_KNLM3/3vP_ ^5_MON#4/4vPq_$ state.result = accumulated()5_NPO* 4/4vP)+_2 if (result && result.is === accumulated ||5_OQP*04/4vP)+_3 if ((result && result.is === accumulated ||5_PRQ+ 4/4vP*,_. buffer.closed && !buffer.length) {5_QSR+-4/4vPr*,_/ (buffer.closed && !buffer.length) {5_RTS 4/4vP+s % var index = side === "left" ? 0 : 15_SUT 3/3vP _  ^5_TVU 4/4vPt _ console.log()5_UWV 4/4vPLu _ console.log(state)5_VXW 4/4vPv _ console.log(side, state)5_WYX!4/4vPA` _5_XZY 5/5vPC` if ()5_Y[Z 5/5vPK` if ())5_Z\[-5/5vPUw`- if (state && state.is === accumulated))5_[]\ 5/5vP `# console.log(side, state, value)5_\^] )5/5vPy `* console.log(side, value, state, value)5_]_^35/5vPz`3 if (state && state.is === accumulated) return5_^`_' 5/5vP&)`J var result = dispatch([ state.left.shift(), state.right.shift() ])5__a`(6/6vP'*a4 state.left.shift(), state.right.shift() ])5_`ba)7/7vP(+b state.right.shift() ])5_acb* 8/8vP})+c ])5_bdc_8/8vP~^`cC slicer.call(arguments, 2).reduce(concatzip, zip(left, right))5_ced 8/8vP@ # console.log(side, value, state)5_dfeI7/7vPuHJbfunction concat(array, item) {5_egfI7/7vPyHJbfunction concat() {5_fhgO*7/7vPNPb+ return map(zip(zipped, sequence), concat)5_gihI7/7vPHJbfunction concat(value) {5_hjiJ7/7vPIKb array.push(item)5_ikjJ7/7vPIKb value.push(item)5_jlkJ7/7vPIKb value[].push(item)5_kmlJ7/7vPIKb value[0].push(item)5_lnmJ7/7vPIKb value[0].push(value[])5_monK7/7vPJLb return array5_npoK7/7vPJLb return value[]5_oqp +7/7vPc c  b5_prq 8/8vPl c console.log()5_qsr! ! !BvP "cB else if (value && value.isBoxed) dispatch(value, state.result)# // Otherwise enqueue the value.5_rts ! !BvP 9 // If any other meta item, just propagate it through.5_sut  BvP / else if // Otherwise enqueue the value.5_tvu# BvP#&a #%`5_uv$ BvP#%b> (value && value.isBoxed) dispatch(value, state.result)5_vw$ BvPa#%bA if (value && value.isBoxed) dispatch(value, state.result)5_$ BvPc#%bD if (buffer[] && value.isBoxed) dispatch(value, state.result)5_$$$ v Ph#%bE if (buffer[0] && value.isBoxed) dispatch(value, state.result)5_$,$$ v Pq#&bI if (buffer[0] && buffer[0].isBoxed) dispatch(value, state.result)5_%$$ v Pt$&c' dispatch(value, state.result)5_%$$ v Py$&c* dispatch(buffer[], state.result)5_%($$ v P%'d %'c5_&$$ v P%'d else if ()5_&$$ v P%'d else if (queue[])5_&$$ v P%'d else if (queue[0])5_&#$$ v P%'d% else if (queue[0] && queue[])5_&%$$ v P%'d& else if (queue[0] && queue[0])5_&,$$ v P&(e &(d5_'$$ v P&(e dispatch()5_' $$ v P&(e! dispatch(queue.shift())5_'-$$ v P')f ')e5_($$ v P'( else 5_($$ v P(*f(*e5_) $$ v P(*f if ()5_)$$ v P(*f if (buffer.length)5_)$$ v P(*f if (buffer.length) {}5_**:vP);f var result = dispatch([ state.left.shift(), state.right.shift() ], state.result)K // If consumer is done consumption or if buffer is empty and closedK // dispatch end, and mark stream ended to stop streams and queueing // values too.4 if ((result && result.is === accumulated) ||0 (buffer.closed && !buffer.length)) {A // Dispatch end of stream and cleanup state attributes.! dispatch(end(), result)6 state.left = state.right = state.next = null state.closed = true, state.result = accumulated(result) } else { state.result = result }5_: *:vP:<g :<f5_)*:vP(*g if (buffer.length) {5_ *:vP) # console.log(side, value, state)5_P;var end = require("./end")5_PCe) else if (value && value.is === end) {5_PFe else if (value === end) {5_2PQ13e# dispatch(end(), result)5_" P!#e+ if (buffer[0] && buffer[0].isBoxed)5_"P!#e3 if (isError(buffer[0] && buffer[0].isBoxed)5_"3P!#e4 if (isError(buffer[0]) && buffer[0].isBoxed)5_$P#%e. else if (queue[0] && queue[0].isBoxed)5_$!P#%e6 else if (isError(queue[0] && queue[0].isBoxed)5_$6P#%e7 else if (isError(queue[0]) && queue[0].isBoxed)5_Pfe5_Pfvar isError = require()5_Pfvar isError = require("")5_Pf*var accumulated = require("./accumulated")5_$Pf&var reduced = require("./accumulated")5_Pgf5_Pgvar isReduced = require()5_Pgvar isReduced = require("")5_+Pg9 if (state && state.is === accumulated) return state5_Pg# if (isReduced()) return state5_"Pg* state.result = accumulated(result)5_Pg% state.result = reduce(result)5_1P02g6 if ((result && result.is === accumulated) ||5_1P02g@ if ((isReduced(result && result.is === accumulated) ||5_1 1 1<v<P02gA if ((isReduced(result) && result.is === accumulated) ||5_1!1 1<v<P02g$ if ((isReduced(result)) ||5_11 1<v<P02g# if ((isReduced(result) ||5_21 1<v<P02g" if (isReduced(result) ||$(buffer.closed && !buffer.length)) {13g2 (buffer.closed && !buffer.length)) {5_6&1 1<v<P57f. state.result = accumulated(result)5_Pܶ g f5_Pܺ gvar end = require()5_Pܺ gvar end = require("")5_Pܽg else if (value === null) {5_4P35g" dispatch(null, result)5_vxw#  BvP#$b #%c if ()5_wyx$  BvP#%c if (buffer[])5_xzy$ BvP#%c if (buffer[0])5_y{z$ BvP#%c" if (buffer[0] && buffer[])5_z|{$  BvP#%c# if (buffer[0] && buffer[0])5_{}|$" BvP#%c+ if (buffer[0] && buffer[0].isBoxed)5_|~}$+ BvP #%c+ if (buffer[0] && buffer[0].isBoxed)5_}~% BvP $&d 5_~$+ BvP#%d* if (buffer[0] && buffer[0].isBoxed queue$& queue[]5_% BvP$&e queue[0]5_% BvP$&e queue[0] && queue[]5_% BvP$&e queue[0] && queue[0]5_%  BvP$&e( queue[0] && queue[0].isBoxed5_%( BvP!$&e) queue[0] && queue[0].isBoxed)5_%) BvP"$&e, queue[0] && queue[0].isBoxed) {}5_%+ BvP#$&e+ queue[0] && queue[0].isBoxed) { }5_&  BvP$%'f }5_$* BvP&#%f- if (buffer[0] && buffer[0].isBoxed &&5_KML3/3vP^ state.closed = tru5_@BGA 0/0vPI Z [function endZip()5_ACB 0/0vPR [function endZip() {}5_BDC 1/1vPR [function endZip() {}5_CED 1/1vPU \function zipEnd() {5_DFE 1/1vPX \function zipEnd(state) {5_EF 2/2vPZ \5_)+-*)-0/0vP~<j)*^ )+_ 5_*,+)-1/1vP~A(*_, buffer.closed && !buffer.length) {5_+,+0/0vP~C*,5_.>vP}l-/5_>vP|g\' if (!dispatch) return state.result5_>vPxW9 if (!state.next && ) return accumulated(state.result)5_mown>vPrT; if (!state.leftActive) return accumulated(state.result)5_npo>vPrTO if (!state.leftActive && state.rightAtive) return accumulated(state.result)5_oqp)>vPrTP if (!state.leftActive && state.rightActive) return accumulated(state.result)5_prq0>vPrLT/ if (!state.leftActive && state.rightActive)& return accumulated(state.result)5_qsr>vPrMU0 if (!state.leftActive && !state.rightActive)5_rts>vPrU1 if (!state.left.Active && !state.rightActive)5_sut>vPrU1 if (!state.left.active && !state.rightActive)5_tvu+>vPrU1 if (!state.left.active && !state.rightActive)5_uv*>vPrU2 if (!state.left.active && !state.right.active)5_FIGaH << v Pp T  U console.log()5_HJI<< v PpF U console.log(value, state)5_IKJ<< v PpG U$ console.log('>>>', value, state)5_JLK << v PqU6 if (state.active) return accumulated(state.result)5_KML<< v PqUC if (state.left && state.right) return accumulated(state.result)5_LNM<< v PqUD if (!state.left && state.right) return accumulated(state.result)5_MON<< v PqHUE if (!state.left && !state.right) return accumulated(state.result)5_NPO;; v PqI 5_OQP(<< v Pr T //5_PRQ;; v Pr 5_QSR<< v Pr T U if ()5_RTS<< v Pr U" if (value && value.is === end)5_SUT"<< v PrU% if (value && value.is === end) {}5_TVU$<< v PrU% if (value && value.is === end) {}5_UWV$== v PrU$ if (value && value.is === end) { }5_VXW== v PrV& else if (value && value.isBoxed) {5_WYX>> v Pr,V W if ()5_XZY >> v Pr-W if (value[])5_Y[Z>> v Pr0W if (value[other])5_Z\[>> v Pr3W if (value[other] ===)5_[]\?? v Pr5W X value[]5_\^] ?? v Pr7X value[this]5_]_^>> v Pr95_^`_>> v PrXW if (value[other] ===) 5__`>> v PrYW if (value[other] === 5_FHGP;; v PoVOQTC slicer.call(arguments, 1).reduce(concatzip, zip(left, right))5_7 020.v.PmP68@ if (rest) { }5_8020.v.PmQ79A } else {}5_8 020.v.PmT79A } else {5_,,,vPYN+}}+--5_')*( vPQq r) value.isBoxed ? next(value, result)< : f(next, value, result)5_() vPQsI var value = state.next([ state.left.shift(), state.right.shift() ])5