{"version":3,"sources":["../node_modules/rxjs/util/root.js","../node_modules/rxjs/Observable.js","../node_modules/rxjs/Subscriber.js","../node_modules/rxjs/util/isFunction.js","../node_modules/rxjs/Subscription.js","../node_modules/rxjs/util/errorObject.js","../node_modules/webpack/buildin/global.js","../node_modules/rxjs/util/isObject.js","../node_modules/rxjs/util/tryCatch.js","../node_modules/rxjs/Observer.js","../node_modules/rxjs/symbol/rxSubscriber.js","../node_modules/rxjs/symbol/observable.js","../node_modules/rxjs/scheduler/AsyncAction.js","../node_modules/rxjs/scheduler/AsyncScheduler.js","../node_modules/rxjs/scheduler/async.js","../node_modules/rxjs/operators/throttle.js","../node_modules/lodash-es/_freeGlobal.js","../node_modules/rxjs/scheduler/animationFrame.js","../node_modules/lodash-es/isObject.js","../node_modules/lodash-es/_root.js","../node_modules/lodash-es/now.js","../node_modules/lodash-es/_Symbol.js","../node_modules/lodash-es/_getRawTag.js","../node_modules/lodash-es/_objectToString.js","../node_modules/lodash-es/_baseGetTag.js","../node_modules/lodash-es/isObjectLike.js","../node_modules/lodash-es/isSymbol.js","../node_modules/lodash-es/toNumber.js","../node_modules/lodash-es/debounce.js","../node_modules/lodash-es/throttle.js","../node_modules/rxjs/util/toSubscriber.js","../node_modules/rxjs/util/isArray.js","../node_modules/rxjs/util/UnsubscriptionError.js","../node_modules/rxjs/util/pipe.js","../node_modules/rxjs/util/noop.js","../node_modules/rxjs/scheduler/AnimationFrameAction.js","../node_modules/rxjs/scheduler/Action.js","../node_modules/rxjs/util/AnimationFrame.js","../node_modules/rxjs/scheduler/AnimationFrameScheduler.js","../node_modules/rxjs/Scheduler.js","../node_modules/rxjs/add/observable/fromEvent.js","../node_modules/rxjs/observable/fromEvent.js","../node_modules/rxjs/observable/FromEventObservable.js","../node_modules/rxjs/add/operator/throttleTime.js","../node_modules/rxjs/operator/throttleTime.js","../node_modules/rxjs/OuterSubscriber.js","../node_modules/rxjs/util/subscribeToResult.js","../node_modules/rxjs/util/isArrayLike.js","../node_modules/rxjs/util/isPromise.js","../node_modules/rxjs/symbol/iterator.js","../node_modules/rxjs/InnerSubscriber.js","../node_modules/rxjs/operators/throttleTime.js"],"names":["__window","window","__self","self","WorkerGlobalScope","_root","global","exports","root","Error","root_1","toSubscriber_1","observable_1","pipe_1","Observable","subscribe","this","_isScalar","_subscribe","prototype","lift","operator","observable","source","observerOrNext","error","complete","sink","toSubscriber","call","add","syncErrorThrowable","_trySubscribe","syncErrorThrown","syncErrorValue","err","forEach","next","PromiseCtor","_this","Rx","config","Promise","resolve","reject","subscription","value","unsubscribe","subscriber","pipe","operations","_i","arguments","length","pipeFromArray","toPromise","x","create","__extends","d","b","p","hasOwnProperty","__","constructor","Object","isFunction_1","Subscription_1","Observer_1","rxSubscriber_1","Subscriber","_super","destinationOrNext","isStopped","destination","empty","isTrustedSubscriber","trustedSubscriber","rxSubscriber","SafeSubscriber","_next","_error","_complete","closed","_unsubscribeAndRecycle","_parent","_parents","Subscription","_parentSubscriber","context","isFunction","bind","_context","__tryOrSetError","__tryOrUnsub","wrappedComplete","fn","parent","_unsubscribe","obj","isArray_1","isObject_1","tryCatch_1","errorObject_1","UnsubscriptionError_1","_subscriptions","errors","hasErrors","index","len","remove","tryCatch","errorObject","e","UnsubscriptionError","flattenUnsubscriptionErrors","isArray","sub","isObject","concat","push","teardown","EMPTY","_addParent","tmp","subscriptions","subscriptionIndex","indexOf","splice","reduce","errs","g","Function","module","tryCatchTarget","tryCatcher","apply","Symbol","for","$$rxSubscriber","getSymbolObservable","$$observable","AsyncAction","scheduler","work","pending","schedule","state","delay","id","recycleAsyncId","requestAsyncId","setInterval","flush","clearInterval","execute","_execute","errored","errorValue","undefined","actions","Action","AsyncScheduler","active","scheduled","action","shift","Scheduler","AsyncAction_1","AsyncScheduler_1","async","OuterSubscriber_1","subscribeToResult_1","defaultThrottleConfig","leading","trailing","throttle","durationSelector","ThrottleOperator","ThrottleSubscriber","_leading","_trailing","_hasTrailingValue","throttled","_trailingValue","duration","tryDurationSelector","subscribeToResult","_sendTrailing","_a","notifyNext","outerValue","innerValue","outerIndex","innerIndex","innerSub","notifyComplete","OuterSubscriber","freeGlobal","AnimationFrameAction_1","AnimationFrameScheduler_1","animationFrame","AnimationFrameScheduler","AnimationFrameAction","type","freeSelf","Date","now","objectProto","nativeObjectToString","toString","symToStringTag","toStringTag","isOwn","tag","unmasked","result","reTrim","reIsBadHex","reIsBinary","reIsOctal","freeParseInt","parseInt","other","valueOf","replace","isBinary","test","slice","nativeMax","Math","max","nativeMin","min","func","wait","options","lastArgs","lastThis","maxWait","timerId","lastCallTime","lastInvokeTime","maxing","TypeError","invokeFunc","time","args","thisArg","leadingEdge","setTimeout","timerExpired","shouldInvoke","timeSinceLastCall","trailingEdge","timeWaiting","remainingWait","debounced","isInvoking","clearTimeout","cancel","Subscriber_1","nextOrObserver","Array","map","i","join","name","stack","message","noop_1","fns","input","prev","noop","AnimationFrame_1","AnimationFrame","requestAnimationFrame","cancelAnimationFrame","RequestAnimationFrameDefinition","mozRequestAnimationFrame","mozCancelAnimationFrame","webkitRequestAnimationFrame","webkitCancelAnimationFrame","msRequestAnimationFrame","msCancelAnimationFrame","oRequestAnimationFrame","oCancelAnimationFrame","cb","count","SchedulerAction","Observable_1","fromEvent_1","fromEvent","FromEventObservable_1","FromEventObservable","sourceObj","eventName","selector","target","setupSubscription","handler","isNodeList","isHTMLCollection","addEventListener","removeEventListener","isEventTarget","source_1","on","off","isJQueryStyleEventEmitter","source_2","addListener","removeListener","isNodeStyleEventEmitter","source_3","throttleTime_1","throttleTime","async_1","throttle_1","notifyError","isArrayLike_1","isPromise_1","iterator_1","InnerSubscriber_1","outerSubscriber","InnerSubscriber","isArrayLike","isPromise","then","iterator","item","done","obs","msg","symbolIteratorPonyfill","Set_1","Set","Map_1","Map","keys","getOwnPropertyNames","key","$$iterator","ThrottleTimeOperator","ThrottleTimeSubscriber","dispatchNext","clearThrottle","arg"],"mappings":"yFAAA,YAIA,IAAIA,EAA6B,oBAAXC,QAA0BA,OAC5CC,EAAyB,oBAATC,MAAqD,oBAAtBC,mBAC/CD,gBAAgBC,mBAAqBD,KAErCE,EAAQL,QADqB,IAAXM,GAA0BA,GACZJ,EACpCK,EAAQC,KAAOH,EAIf,WACI,IAAKA,EACD,MAAM,IAAII,MAAM,iEAFxB,K,8CCZA,IAAIC,EAAS,EAAQ,GACjBC,EAAiB,EAAQ,IACzBC,EAAe,EAAQ,IACvBC,EAAS,EAAQ,IAOjBC,EAAc,WAQd,SAASA,EAAWC,GAChBC,KAAKC,WAAY,EACbF,IACAC,KAAKE,WAAaH,GAuR1B,OA7QAD,EAAWK,UAAUC,KAAO,SAAUC,GAClC,IAAIC,EAAa,IAAIR,EAGrB,OAFAQ,EAAWC,OAASP,KACpBM,EAAWD,SAAWA,EACfC,GAoHXR,EAAWK,UAAUJ,UAAY,SAAUS,EAAgBC,EAAOC,GAC9D,IAAIL,EAAWL,KAAKK,SAChBM,EAAOhB,EAAeiB,aAAaJ,EAAgBC,EAAOC,GAO9D,GANIL,EACAA,EAASQ,KAAKF,EAAMX,KAAKO,QAGzBI,EAAKG,IAAId,KAAKO,SAAWI,EAAKI,mBAAqBf,KAAKE,WAAWS,GAAQX,KAAKgB,cAAcL,IAE9FA,EAAKI,qBACLJ,EAAKI,oBAAqB,EACtBJ,EAAKM,iBACL,MAAMN,EAAKO,eAGnB,OAAOP,GAEXb,EAAWK,UAAUa,cAAgB,SAAUL,GAC3C,IACI,OAAOX,KAAKE,WAAWS,GAE3B,MAAOQ,GACHR,EAAKM,iBAAkB,EACvBN,EAAKO,eAAiBC,EACtBR,EAAKF,MAAMU,KAUnBrB,EAAWK,UAAUiB,QAAU,SAAUC,EAAMC,GAC3C,IAAIC,EAAQvB,KASZ,GARKsB,IACG5B,EAAOF,KAAKgC,IAAM9B,EAAOF,KAAKgC,GAAGC,QAAU/B,EAAOF,KAAKgC,GAAGC,OAAOC,QACjEJ,EAAc5B,EAAOF,KAAKgC,GAAGC,OAAOC,QAE/BhC,EAAOF,KAAKkC,UACjBJ,EAAc5B,EAAOF,KAAKkC,WAG7BJ,EACD,MAAM,IAAI7B,MAAM,yBAEpB,OAAO,IAAI6B,GAAY,SAAUK,EAASC,GAGtC,IAAIC,EACJA,EAAeN,EAAMxB,WAAU,SAAU+B,GACrC,GAAID,EAKA,IACIR,EAAKS,GAET,MAAOX,GACHS,EAAOT,GACPU,EAAaE,mBAUjBV,EAAKS,KAEVF,EAAQD,OAGkB7B,EAAWK,UAAUD,WAAa,SAAU8B,GAC7E,OAAOhC,KAAKO,OAAOR,UAAUiC,IAOjClC,EAAWK,UAAUP,EAAaU,YAAc,WAC5C,OAAON,MAqBXF,EAAWK,UAAU8B,KAAO,WAExB,IADA,IAAIC,EAAa,GACRC,EAAK,EAAGA,EAAKC,UAAUC,OAAQF,IACpCD,EAAWC,EAAK,GAAKC,UAAUD,GAEnC,OAA0B,IAAtBD,EAAWG,OACJrC,KAEJH,EAAOyC,cAAcJ,EAArBrC,CAAiCG,OAG5CF,EAAWK,UAAUoC,UAAY,SAAUjB,GACvC,IAAIC,EAAQvB,KASZ,GARKsB,IACG5B,EAAOF,KAAKgC,IAAM9B,EAAOF,KAAKgC,GAAGC,QAAU/B,EAAOF,KAAKgC,GAAGC,OAAOC,QACjEJ,EAAc5B,EAAOF,KAAKgC,GAAGC,OAAOC,QAE/BhC,EAAOF,KAAKkC,UACjBJ,EAAc5B,EAAOF,KAAKkC,WAG7BJ,EACD,MAAM,IAAI7B,MAAM,yBAEpB,OAAO,IAAI6B,GAAY,SAAUK,EAASC,GACtC,IAAIE,EACJP,EAAMxB,WAAU,SAAUyC,GAAK,OAAOV,EAAQU,KAAM,SAAUrB,GAAO,OAAOS,EAAOT,MAAS,WAAc,OAAOQ,EAAQG,UAajIhC,EAAW2C,OAAS,SAAU1C,GAC1B,OAAO,IAAID,EAAWC,IAEnBD,EAlSM,GAoSjBP,EAAQO,WAAaA,G,6BC9SrB,IAAI4C,EAAa1C,MAAQA,KAAK0C,WAAc,SAAUC,EAAGC,GACrD,IAAK,IAAIC,KAAKD,EAAOA,EAAEE,eAAeD,KAAIF,EAAEE,GAAKD,EAAEC,IACnD,SAASE,IAAO/C,KAAKgD,YAAcL,EACnCA,EAAExC,UAAkB,OAANyC,EAAaK,OAAOR,OAAOG,IAAMG,EAAG5C,UAAYyC,EAAEzC,UAAW,IAAI4C,IAE/EG,EAAe,EAAQ,GACvBC,EAAiB,EAAQ,GACzBC,EAAa,EAAQ,IACrBC,EAAiB,EAAQ,IAWzBC,EAAc,SAAUC,GAUxB,SAASD,EAAWE,EAAmB/C,EAAOC,GAM1C,OALA6C,EAAO1C,KAAKb,MACZA,KAAKkB,eAAiB,KACtBlB,KAAKiB,iBAAkB,EACvBjB,KAAKe,oBAAqB,EAC1Bf,KAAKyD,WAAY,EACTrB,UAAUC,QACd,KAAK,EACDrC,KAAK0D,YAAcN,EAAWO,MAC9B,MACJ,KAAK,EACD,IAAKH,EAAmB,CACpBxD,KAAK0D,YAAcN,EAAWO,MAC9B,MAEJ,GAAiC,iBAAtBH,EAAgC,CAGvC,GAAII,EAAoBJ,GAAoB,CACxC,IAAIK,EAAoBL,EAAkBH,EAAeS,gBACzD9D,KAAKe,mBAAqB8C,EAAkB9C,mBAC5Cf,KAAK0D,YAAcG,EACnBA,EAAkB/C,IAAId,WAGtBA,KAAKe,oBAAqB,EAC1Bf,KAAK0D,YAAc,IAAIK,EAAe/D,KAAMwD,GAEhD,MAER,QACIxD,KAAKe,oBAAqB,EAC1Bf,KAAK0D,YAAc,IAAIK,EAAe/D,KAAMwD,EAAmB/C,EAAOC,IAuFlF,OAhIAgC,EAAUY,EAAYC,GA6CtBD,EAAWnD,UAAUkD,EAAeS,cAAgB,WAAc,OAAO9D,MAYzEsD,EAAWb,OAAS,SAAUpB,EAAMZ,EAAOC,GACvC,IAAIsB,EAAa,IAAIsB,EAAWjC,EAAMZ,EAAOC,GAE7C,OADAsB,EAAWjB,oBAAqB,EACzBiB,GASXsB,EAAWnD,UAAUkB,KAAO,SAAUS,GAC7B9B,KAAKyD,WACNzD,KAAKgE,MAAMlC,IAUnBwB,EAAWnD,UAAUM,MAAQ,SAAUU,GAC9BnB,KAAKyD,YACNzD,KAAKyD,WAAY,EACjBzD,KAAKiE,OAAO9C,KASpBmC,EAAWnD,UAAUO,SAAW,WACvBV,KAAKyD,YACNzD,KAAKyD,WAAY,EACjBzD,KAAKkE,cAGbZ,EAAWnD,UAAU4B,YAAc,WAC3B/B,KAAKmE,SAGTnE,KAAKyD,WAAY,EACjBF,EAAOpD,UAAU4B,YAAYlB,KAAKb,QAEtCsD,EAAWnD,UAAU6D,MAAQ,SAAUlC,GACnC9B,KAAK0D,YAAYrC,KAAKS,IAE1BwB,EAAWnD,UAAU8D,OAAS,SAAU9C,GACpCnB,KAAK0D,YAAYjD,MAAMU,GACvBnB,KAAK+B,eAETuB,EAAWnD,UAAU+D,UAAY,WAC7BlE,KAAK0D,YAAYhD,WACjBV,KAAK+B,eAE4BuB,EAAWnD,UAAUiE,uBAAyB,WAC/E,IAAeC,EAANrE,KAAmBqE,QAASC,EAA5BtE,KAA0CsE,SAQnD,OAPAtE,KAAKqE,QAAU,KACfrE,KAAKsE,SAAW,KAChBtE,KAAK+B,cACL/B,KAAKmE,QAAS,EACdnE,KAAKyD,WAAY,EACjBzD,KAAKqE,QAAUA,EACfrE,KAAKsE,SAAWA,EACTtE,MAEJsD,EAjIM,CAkIfH,EAAeoB,cACjBhF,EAAQ+D,WAAaA,EAMrB,IAAIS,EAAkB,SAAUR,GAE5B,SAASQ,EAAeS,EAAmBhE,EAAgBC,EAAOC,GAG9D,IAAIW,EAFJkC,EAAO1C,KAAKb,MACZA,KAAKwE,kBAAoBA,EAEzB,IAAIC,EAAUzE,KACVkD,EAAawB,WAAWlE,GACxBa,EAAOb,EAEFA,IACLa,EAAOb,EAAea,KACtBZ,EAAQD,EAAeC,MACvBC,EAAWF,EAAeE,SACtBF,IAAmB4C,EAAWO,QAC9Bc,EAAUxB,OAAOR,OAAOjC,GACpB0C,EAAawB,WAAWD,EAAQ1C,cAChC/B,KAAKc,IAAI2D,EAAQ1C,YAAY4C,KAAKF,IAEtCA,EAAQ1C,YAAc/B,KAAK+B,YAAY4C,KAAK3E,QAGpDA,KAAK4E,SAAWH,EAChBzE,KAAKgE,MAAQ3C,EACbrB,KAAKiE,OAASxD,EACdT,KAAKkE,UAAYxD,EAmFrB,OA3GAgC,EAAUqB,EAAgBR,GA0B1BQ,EAAe5D,UAAUkB,KAAO,SAAUS,GACtC,IAAK9B,KAAKyD,WAAazD,KAAKgE,MAAO,CAC/B,IAAIQ,EAAoBxE,KAAKwE,kBACxBA,EAAkBzD,mBAGdf,KAAK6E,gBAAgBL,EAAmBxE,KAAKgE,MAAOlC,IACzD9B,KAAK+B,cAHL/B,KAAK8E,aAAa9E,KAAKgE,MAAOlC,KAO1CiC,EAAe5D,UAAUM,MAAQ,SAAUU,GACvC,IAAKnB,KAAKyD,UAAW,CACjB,IAAIe,EAAoBxE,KAAKwE,kBAC7B,GAAIxE,KAAKiE,OACAO,EAAkBzD,oBAKnBf,KAAK6E,gBAAgBL,EAAmBxE,KAAKiE,OAAQ9C,GACrDnB,KAAK+B,gBALL/B,KAAK8E,aAAa9E,KAAKiE,OAAQ9C,GAC/BnB,KAAK+B,mBAOR,KAAKyC,EAAkBzD,mBAExB,MADAf,KAAK+B,cACCZ,EAGNqD,EAAkBtD,eAAiBC,EACnCqD,EAAkBvD,iBAAkB,EACpCjB,KAAK+B,iBAIjBgC,EAAe5D,UAAUO,SAAW,WAChC,IAAIa,EAAQvB,KACZ,IAAKA,KAAKyD,UAAW,CACjB,IAAIe,EAAoBxE,KAAKwE,kBAC7B,GAAIxE,KAAKkE,UAAW,CAChB,IAAIa,EAAkB,WAAc,OAAOxD,EAAM2C,UAAUrD,KAAKU,EAAMqD,WACjEJ,EAAkBzD,oBAKnBf,KAAK6E,gBAAgBL,EAAmBO,GACxC/E,KAAK+B,gBALL/B,KAAK8E,aAAaC,GAClB/E,KAAK+B,oBAQT/B,KAAK+B,gBAIjBgC,EAAe5D,UAAU2E,aAAe,SAAUE,EAAIlD,GAClD,IACIkD,EAAGnE,KAAKb,KAAK4E,SAAU9C,GAE3B,MAAOX,GAEH,MADAnB,KAAK+B,cACCZ,IAGd4C,EAAe5D,UAAU0E,gBAAkB,SAAUI,EAAQD,EAAIlD,GAC7D,IACIkD,EAAGnE,KAAKb,KAAK4E,SAAU9C,GAE3B,MAAOX,GAGH,OAFA8D,EAAO/D,eAAiBC,EACxB8D,EAAOhE,iBAAkB,GAClB,EAEX,OAAO,GAE0B8C,EAAe5D,UAAU+E,aAAe,WACzE,IAAIV,EAAoBxE,KAAKwE,kBAC7BxE,KAAK4E,SAAW,KAChB5E,KAAKwE,kBAAoB,KACzBA,EAAkBzC,eAEfgC,EA5GU,CA6GnBT,GACF,SAASM,EAAoBuB,GACzB,OAAOA,aAAe7B,GAAe,uBAAwB6B,GAAOA,EAAI9B,EAAeS,gB,6BCxQ3FvE,EAAQmF,WAHR,SAAoBlC,GAChB,MAAoB,mBAANA,I,6BCDlB,IAAI4C,EAAY,EAAQ,IACpBC,EAAa,EAAQ,GACrBnC,EAAe,EAAQ,GACvBoC,EAAa,EAAQ,GACrBC,EAAgB,EAAQ,GACxBC,EAAwB,EAAQ,IAahCjB,EAAgB,WAKhB,SAASA,EAAaxC,GAKlB/B,KAAKmE,QAAS,EACdnE,KAAKqE,QAAU,KACfrE,KAAKsE,SAAW,KAChBtE,KAAKyF,eAAiB,KAClB1D,IACA/B,KAAKkF,aAAenD,GAoJN,IAAU4B,EAIhC,OA/IAY,EAAapE,UAAU4B,YAAc,WACjC,IACI2D,EADAC,GAAY,EAEhB,IAAI3F,KAAKmE,OAAT,CAGA,IAAeE,EAANrE,KAAmBqE,QAASC,EAA5BtE,KAA0CsE,SAAUY,EAApDlF,KAAsEkF,aAAcO,EAApFzF,KAAwGyF,eACjHzF,KAAKmE,QAAS,EACdnE,KAAKqE,QAAU,KACfrE,KAAKsE,SAAW,KAGhBtE,KAAKyF,eAAiB,KAKtB,IAJA,IAAIG,GAAS,EACTC,EAAMvB,EAAWA,EAASjC,OAAS,EAGhCgC,GACHA,EAAQyB,OAAO9F,MAGfqE,IAAYuB,EAAQC,GAAOvB,EAASsB,IAAU,KAElD,GAAI1C,EAAawB,WAAWQ,GACZI,EAAWS,SAASb,GAAcrE,KAAKb,QACrCuF,EAAcS,cACxBL,GAAY,EACZD,EAASA,IAAWH,EAAcS,YAAYC,aAAaT,EAAsBU,oBAC7EC,EAA4BZ,EAAcS,YAAYC,EAAEP,QAAU,CAACH,EAAcS,YAAYC,KAGzG,GAAIb,EAAUgB,QAAQX,GAGlB,IAFAG,GAAS,EACTC,EAAMJ,EAAepD,SACZuD,EAAQC,GAAK,CAClB,IAAIQ,EAAMZ,EAAeG,GACzB,GAAIP,EAAWiB,SAASD,GAEpB,GADYf,EAAWS,SAASM,EAAItE,aAAalB,KAAKwF,KACxCd,EAAcS,YAAa,CACrCL,GAAY,EACZD,EAASA,GAAU,GACnB,IAAIvE,EAAMoE,EAAcS,YAAYC,EAChC9E,aAAeqE,EAAsBU,oBACrCR,EAASA,EAAOa,OAAOJ,EAA4BhF,EAAIuE,SAGvDA,EAAOc,KAAKrF,IAMhC,GAAIwE,EACA,MAAM,IAAIH,EAAsBU,oBAAoBR,KAqB5DnB,EAAapE,UAAUW,IAAM,SAAU2F,GACnC,IAAKA,GAAaA,IAAalC,EAAamC,MACxC,OAAOnC,EAAamC,MAExB,GAAID,IAAazG,KACb,OAAOA,KAEX,IAAI6B,EAAe4E,EACnB,cAAeA,GACX,IAAK,WACD5E,EAAe,IAAI0C,EAAakC,GACpC,IAAK,SACD,GAAI5E,EAAasC,QAA8C,mBAA7BtC,EAAaE,YAC3C,OAAOF,EAEN,GAAI7B,KAAKmE,OAEV,OADAtC,EAAaE,cACNF,EAEN,GAAuC,mBAA5BA,EAAa8E,WAA6C,CACtE,IAAIC,EAAM/E,GACVA,EAAe,IAAI0C,GACNkB,eAAiB,CAACmB,GAEnC,MACJ,QACI,MAAM,IAAInH,MAAM,yBAA2BgH,EAAW,2BAK9D,OAHoBzG,KAAKyF,iBAAmBzF,KAAKyF,eAAiB,KACpDe,KAAK3E,GACnBA,EAAa8E,WAAW3G,MACjB6B,GAQX0C,EAAapE,UAAU2F,OAAS,SAAUjE,GACtC,IAAIgF,EAAgB7G,KAAKyF,eACzB,GAAIoB,EAAe,CACf,IAAIC,EAAoBD,EAAcE,QAAQlF,IACnB,IAAvBiF,GACAD,EAAcG,OAAOF,EAAmB,KAIpDvC,EAAapE,UAAUwG,WAAa,SAAU1B,GAC1C,IAAeZ,EAANrE,KAAmBqE,QAASC,EAA5BtE,KAA0CsE,SAC9CD,GAAWA,IAAYY,EAKlBX,GAK6B,IAA9BA,EAASyC,QAAQ9B,IAEtBX,EAASkC,KAAKvB,GAJdjF,KAAKsE,SAAW,CAACW,GALjBjF,KAAKqE,QAAUY,GAYvBV,EAAamC,QAAmB/C,EAG9B,IAAIY,GAFIJ,QAAS,EACRR,GAEJY,EAvKQ,GA0KnB,SAAS4B,EAA4BT,GACjC,OAAOA,EAAOuB,QAAO,SAAUC,EAAM/F,GAAO,OAAO+F,EAAKX,OAAQpF,aAAeqE,EAAsBU,oBAAuB/E,EAAIuE,OAASvE,KAAS,IAFtJ5B,EAAQgF,aAAeA,G,6BC1LvBhF,EAAQyG,YAAc,CAAEC,EAAG,K,cCF3B,IAAIkB,EAGJA,EAAI,WACH,OAAOnH,KADJ,GAIJ,IAECmH,EAAIA,GAAK,IAAIC,SAAS,cAAb,GACR,MAAOnB,GAEc,iBAAXhH,SAAqBkI,EAAIlI,QAOrCoI,EAAO9H,QAAU4H,G,6BCfjB5H,EAAQ+G,SAHR,SAAkB9D,GACd,OAAY,MAALA,GAA0B,iBAANA,I,6BCD/B,IACI8E,EADA/B,EAAgB,EAAQ,GAE5B,SAASgC,IACL,IACI,OAAOD,EAAeE,MAAMxH,KAAMoC,WAEtC,MAAO6D,GAEH,OADAV,EAAcS,YAAYC,EAAIA,EACvBV,EAAcS,aAO7BzG,EAAQwG,SAJR,SAAkBf,GAEd,OADAsC,EAAiBtC,EACVuC,I,6BCbXhI,EAAQoE,MAAQ,CACZQ,QAAQ,EACR9C,KAAM,SAAUS,KAChBrB,MAAO,SAAUU,GAAO,MAAMA,GAC9BT,SAAU,e,6BCJd,IACI+G,EADS,EAAQ,GACDjI,KAAKiI,OACzBlI,EAAQuE,aAAkC,mBAAX2D,GAA+C,mBAAfA,EAAOC,IAClED,EAAOC,IAAI,gBAAkB,iBAIjCnI,EAAQoI,eAAiBpI,EAAQuE,c,6BCPjC,IAAIpE,EAAS,EAAQ,GACrB,SAASkI,EAAoBnD,GACzB,IAAIoD,EACAJ,EAAShD,EAAQgD,OAarB,MAZsB,mBAAXA,EACHA,EAAOnH,WACPuH,EAAeJ,EAAOnH,YAGtBuH,EAAeJ,EAAO,cACtBA,EAAOnH,WAAauH,GAIxBA,EAAe,eAEZA,EAEXtI,EAAQqI,oBAAsBA,EAC9BrI,EAAQe,WAAasH,EAAoBlI,EAAOF,MAIhDD,EAAQsI,aAAetI,EAAQe,Y,6BCvB/B,IAAIoC,EAAa1C,MAAQA,KAAK0C,WAAc,SAAUC,EAAGC,GACrD,IAAK,IAAIC,KAAKD,EAAOA,EAAEE,eAAeD,KAAIF,EAAEE,GAAKD,EAAEC,IACnD,SAASE,IAAO/C,KAAKgD,YAAcL,EACnCA,EAAExC,UAAkB,OAANyC,EAAaK,OAAOR,OAAOG,IAAMG,EAAG5C,UAAYyC,EAAEzC,UAAW,IAAI4C,IAE/ErD,EAAS,EAAQ,GAOjBoI,EAAe,SAAUvE,GAEzB,SAASuE,EAAYC,EAAWC,GAC5BzE,EAAO1C,KAAKb,KAAM+H,EAAWC,GAC7BhI,KAAK+H,UAAYA,EACjB/H,KAAKiI,SAAU,EACfjI,KAAKgI,KAAOA,EAuHhB,OA5HAtF,EAAUoF,EAAavE,GAOvBuE,EAAY3H,UAAU+H,SAAW,SAAUC,EAAOC,GAE9C,QADc,IAAVA,IAAoBA,EAAQ,GAC5BpI,KAAKmE,OACL,OAAOnE,KAGXA,KAAKmI,MAAQA,EAGbnI,KAAKiI,SAAU,EACf,IAAII,EAAKrI,KAAKqI,GACVN,EAAY/H,KAAK+H,UA4BrB,OANU,MAANM,IACArI,KAAKqI,GAAKrI,KAAKsI,eAAeP,EAAWM,EAAID,IAEjDpI,KAAKoI,MAAQA,EAEbpI,KAAKqI,GAAKrI,KAAKqI,IAAMrI,KAAKuI,eAAeR,EAAW/H,KAAKqI,GAAID,GACtDpI,MAEX8H,EAAY3H,UAAUoI,eAAiB,SAAUR,EAAWM,EAAID,GAE5D,YADc,IAAVA,IAAoBA,EAAQ,GACzB1I,EAAOF,KAAKgJ,YAAYT,EAAUU,MAAM9D,KAAKoD,EAAW/H,MAAOoI,IAE1EN,EAAY3H,UAAUmI,eAAiB,SAAUP,EAAWM,EAAID,GAG5D,QAFc,IAAVA,IAAoBA,EAAQ,GAElB,OAAVA,GAAkBpI,KAAKoI,QAAUA,IAA0B,IAAjBpI,KAAKiI,QAC/C,OAAOI,EAIJ3I,EAAOF,KAAKkJ,cAAcL,IAMrCP,EAAY3H,UAAUwI,QAAU,SAAUR,EAAOC,GAC7C,GAAIpI,KAAKmE,OACL,OAAO,IAAI1E,MAAM,gCAErBO,KAAKiI,SAAU,EACf,IAAIxH,EAAQT,KAAK4I,SAAST,EAAOC,GACjC,GAAI3H,EACA,OAAOA,GAEe,IAAjBT,KAAKiI,SAAgC,MAAXjI,KAAKqI,KAcpCrI,KAAKqI,GAAKrI,KAAKsI,eAAetI,KAAK+H,UAAW/H,KAAKqI,GAAI,QAG/DP,EAAY3H,UAAUyI,SAAW,SAAUT,EAAOC,GAC9C,IAAIS,GAAU,EACVC,OAAaC,EACjB,IACI/I,KAAKgI,KAAKG,GAEd,MAAOlC,GACH4C,GAAU,EACVC,IAAe7C,GAAKA,GAAK,IAAIxG,MAAMwG,GAEvC,GAAI4C,EAEA,OADA7I,KAAK+B,cACE+G,GAGsBhB,EAAY3H,UAAU+E,aAAe,WACtE,IAAImD,EAAKrI,KAAKqI,GACVN,EAAY/H,KAAK+H,UACjBiB,EAAUjB,EAAUiB,QACpBpD,EAAQoD,EAAQjC,QAAQ/G,MAC5BA,KAAKgI,KAAO,KACZhI,KAAKmI,MAAQ,KACbnI,KAAKiI,SAAU,EACfjI,KAAK+H,UAAY,MACF,IAAXnC,GACAoD,EAAQhC,OAAOpB,EAAO,GAEhB,MAANyC,IACArI,KAAKqI,GAAKrI,KAAKsI,eAAeP,EAAWM,EAAI,OAEjDrI,KAAKoI,MAAQ,MAEVN,EA7HO,CANH,EAAQ,IAoIZmB,QACX1J,EAAQuI,YAAcA,G,6BC3ItB,IAAIpF,EAAa1C,MAAQA,KAAK0C,WAAc,SAAUC,EAAGC,GACrD,IAAK,IAAIC,KAAKD,EAAOA,EAAEE,eAAeD,KAAIF,EAAEE,GAAKD,EAAEC,IACnD,SAASE,IAAO/C,KAAKgD,YAAcL,EACnCA,EAAExC,UAAkB,OAANyC,EAAaK,OAAOR,OAAOG,IAAMG,EAAG5C,UAAYyC,EAAEzC,UAAW,IAAI4C,IAG/EmG,EAAkB,SAAU3F,GAE5B,SAAS2F,IACL3F,EAAOiE,MAAMxH,KAAMoC,WACnBpC,KAAKgJ,QAAU,GAMfhJ,KAAKmJ,QAAS,EAOdnJ,KAAKoJ,eAAYL,EAuBrB,OAvCArG,EAAUwG,EAAgB3F,GAkB1B2F,EAAe/I,UAAUsI,MAAQ,SAAUY,GACvC,IAAIL,EAAUhJ,KAAKgJ,QACnB,GAAIhJ,KAAKmJ,OACLH,EAAQxC,KAAK6C,OADjB,CAIA,IAAI5I,EACJT,KAAKmJ,QAAS,EACd,GACI,GAAI1I,EAAQ4I,EAAOV,QAAQU,EAAOlB,MAAOkB,EAAOjB,OAC5C,YAECiB,EAASL,EAAQM,SAE1B,GADAtJ,KAAKmJ,QAAS,EACV1I,EAAO,CACP,KAAO4I,EAASL,EAAQM,SACpBD,EAAOtH,cAEX,MAAMtB,KAGPyI,EAxCU,CADH,EAAQ,IA0CZK,WACdhK,EAAQ2J,eAAiBA,G,6BChDzB,IAAIM,EAAgB,EAAQ,IACxBC,EAAmB,EAAQ,IA2C/BlK,EAAQmK,MAAQ,IAAID,EAAiBP,eAAeM,EAAc1B,c,6BC5ClE,IAAIpF,EAAa1C,MAAQA,KAAK0C,WAAc,SAAUC,EAAGC,GACrD,IAAK,IAAIC,KAAKD,EAAOA,EAAEE,eAAeD,KAAIF,EAAEE,GAAKD,EAAEC,IACnD,SAASE,IAAO/C,KAAKgD,YAAcL,EACnCA,EAAExC,UAAkB,OAANyC,EAAaK,OAAOR,OAAOG,IAAMG,EAAG5C,UAAYyC,EAAEzC,UAAW,IAAI4C,IAE/E4G,EAAoB,EAAQ,IAC5BC,EAAsB,EAAQ,IAClCrK,EAAQsK,sBAAwB,CAC5BC,SAAS,EACTC,UAAU,GA8CdxK,EAAQyK,SAJR,SAAkBC,EAAkBxI,GAEhC,YADe,IAAXA,IAAqBA,EAASlC,EAAQsK,uBACnC,SAAUtJ,GAAU,OAAOA,EAAOH,KAAK,IAAI8J,EAAiBD,EAAkBxI,EAAOqI,QAASrI,EAAOsI,aAGhH,IAAIG,EAAoB,WACpB,SAASA,EAAiBD,EAAkBH,EAASC,GACjD/J,KAAKiK,iBAAmBA,EACxBjK,KAAK8J,QAAUA,EACf9J,KAAK+J,SAAWA,EAKpB,OAHAG,EAAiB/J,UAAUU,KAAO,SAAUmB,EAAYzB,GACpD,OAAOA,EAAOR,UAAU,IAAIoK,EAAmBnI,EAAYhC,KAAKiK,iBAAkBjK,KAAK8J,QAAS9J,KAAK+J,YAElGG,EATY,GAgBnBC,EAAsB,SAAU5G,GAEhC,SAAS4G,EAAmBzG,EAAauG,EAAkBG,EAAUC,GACjE9G,EAAO1C,KAAKb,KAAM0D,GAClB1D,KAAK0D,YAAcA,EACnB1D,KAAKiK,iBAAmBA,EACxBjK,KAAKoK,SAAWA,EAChBpK,KAAKqK,UAAYA,EACjBrK,KAAKsK,mBAAoB,EA0D7B,OAjEA5H,EAAUyH,EAAoB5G,GAS9B4G,EAAmBhK,UAAU6D,MAAQ,SAAUlC,GAC3C,GAAI9B,KAAKuK,UACDvK,KAAKqK,YACLrK,KAAKsK,mBAAoB,EACzBtK,KAAKwK,eAAiB1I,OAGzB,CACD,IAAI2I,EAAWzK,KAAK0K,oBAAoB5I,GACpC2I,GACAzK,KAAKc,IAAId,KAAKuK,UAAYX,EAAoBe,kBAAkB3K,KAAMyK,IAEtEzK,KAAKoK,WACLpK,KAAK0D,YAAYrC,KAAKS,GAClB9B,KAAKqK,YACLrK,KAAKsK,mBAAoB,EACzBtK,KAAKwK,eAAiB1I,MAKtCqI,EAAmBhK,UAAUuK,oBAAsB,SAAU5I,GACzD,IACI,OAAO9B,KAAKiK,iBAAiBnI,GAEjC,MAAOX,GAEH,OADAnB,KAAK0D,YAAYjD,MAAMU,GAChB,OAGsBgJ,EAAmBhK,UAAU+E,aAAe,WAC7E,IAAeqF,EAANvK,KAAqBuK,UAArBvK,KAAoDwK,eAApDxK,KAA2FsK,kBAA3FtK,KAA6HqK,UACtIrK,KAAKwK,eAAiB,KACtBxK,KAAKsK,mBAAoB,EACrBC,IACAvK,KAAK8F,OAAOyE,GACZvK,KAAKuK,UAAY,KACjBA,EAAUxI,gBAGlBoI,EAAmBhK,UAAUyK,cAAgB,WACzC,IAAIC,EAAK7K,KAAM0D,EAAcmH,EAAGnH,YAAa6G,EAAYM,EAAGN,UAAWF,EAAYQ,EAAGR,UAAWG,EAAiBK,EAAGL,eAAgBF,EAAoBO,EAAGP,kBACxJC,GAAaF,GAAaC,IAC1B5G,EAAYrC,KAAKmJ,GACjBxK,KAAKwK,eAAiB,KACtBxK,KAAKsK,mBAAoB,IAGjCH,EAAmBhK,UAAU2K,WAAa,SAAUC,EAAYC,EAAYC,EAAYC,EAAYC,GAChGnL,KAAK4K,gBACL5K,KAAKkF,gBAETiF,EAAmBhK,UAAUiL,eAAiB,WAC1CpL,KAAK4K,gBACL5K,KAAKkF,gBAEFiF,EAlEc,CAmEvBR,EAAkB0B,kB,+BC5IpB,YACA,IAAIC,EAA8B,iBAAVhM,GAAsBA,GAAUA,EAAO2D,SAAWA,QAAU3D,EAErE,Q,8CCFf,IAAIiM,EAAyB,EAAQ,IACjCC,EAA4B,EAAQ,IA+BxCjM,EAAQkM,eAAiB,IAAID,EAA0BE,wBAAwBH,EAAuBI,uB,6BCHvF,MALf,SAAkB7J,GAChB,IAAI8J,SAAc9J,EAClB,OAAgB,MAATA,IAA0B,UAAR8J,GAA4B,YAARA,I,QCxB3CC,EAA0B,iBAAR1M,MAAoBA,MAAQA,KAAK8D,SAAWA,QAAU9D,KAK7D,EAFJ,KAAc0M,GAAYzE,SAAS,cAATA,GCgBtB,EAJL,WACR,OAAO,EAAK0E,KAAKC,OCdJ,EAFF,EAAKtE,OCAduE,EAAc/I,OAAO9C,UAGrB,EAAiB6L,EAAYlJ,eAO7BmJ,EAAuBD,EAAYE,SAGnCC,EAAiB,EAAS,EAAOC,iBAAcrD,EA6BpC,MApBf,SAAmBjH,GACjB,IAAIuK,EAAQ,EAAexL,KAAKiB,EAAOqK,GACnCG,EAAMxK,EAAMqK,GAEhB,IACErK,EAAMqK,QAAkBpD,EACxB,IAAIwD,GAAW,EACf,MAAOtG,IAET,IAAIuG,EAASP,EAAqBpL,KAAKiB,GAQvC,OAPIyK,IACEF,EACFvK,EAAMqK,GAAkBG,SAEjBxK,EAAMqK,IAGVK,GClCL,EAPcvJ,OAAO9C,UAOc+L,SAaxB,MAJf,SAAwBpK,GACtB,OAAO,EAAqBjB,KAAKiB,ICT/B,EAAiB,EAAS,EAAOsK,iBAAcrD,EAkBpC,MATf,SAAoBjH,GAClB,OAAa,MAATA,OACeiH,IAAVjH,EAdQ,qBADL,gBAiBJ,GAAkB,KAAkBmB,OAAOnB,GAC/C,EAAUA,GACV,EAAeA,ICIN,MAJf,SAAsBA,GACpB,OAAgB,MAATA,GAAiC,iBAATA,GCGlB,MALf,SAAkBA,GAChB,MAAuB,iBAATA,GACX,EAAaA,IArBF,mBAqBY,EAAWA,IClBnC2K,EAAS,aAGTC,EAAa,qBAGbC,EAAa,aAGbC,EAAY,cAGZC,EAAeC,SA8CJ,MArBf,SAAkBhL,GAChB,GAAoB,iBAATA,EACT,OAAOA,EAET,GAAI,EAASA,GACX,OA7CM,IA+CR,GAAI,EAASA,GAAQ,CACnB,IAAIiL,EAAgC,mBAAjBjL,EAAMkL,QAAwBlL,EAAMkL,UAAYlL,EACnEA,EAAQ,EAASiL,GAAUA,EAAQ,GAAMA,EAE3C,GAAoB,iBAATjL,EACT,OAAiB,IAAVA,EAAcA,GAASA,EAEhCA,EAAQA,EAAMmL,QAAQR,EAAQ,IAC9B,IAAIS,EAAWP,EAAWQ,KAAKrL,GAC/B,OAAQoL,GAAYN,EAAUO,KAAKrL,GAC/B+K,EAAa/K,EAAMsL,MAAM,GAAIF,EAAW,EAAI,GAC3CR,EAAWS,KAAKrL,GA1Db,KA0D6BA,GCtDnCuL,EAAYC,KAAKC,IACjBC,EAAYF,KAAKG,IAqLN,MA7Hf,SAAkBC,EAAMC,EAAMC,GAC5B,IAAIC,EACAC,EACAC,EACAvB,EACAwB,EACAC,EACAC,EAAiB,EACjBpE,GAAU,EACVqE,GAAS,EACTpE,GAAW,EAEf,GAAmB,mBAAR2D,EACT,MAAM,IAAIU,UAzEQ,uBAmFpB,SAASC,EAAWC,GAClB,IAAIC,EAAOV,EACPW,EAAUV,EAKd,OAHAD,EAAWC,OAAW/E,EACtBmF,EAAiBI,EACjB9B,EAASkB,EAAKlG,MAAMgH,EAASD,GAI/B,SAASE,EAAYH,GAMnB,OAJAJ,EAAiBI,EAEjBN,EAAUU,WAAWC,EAAchB,GAE5B7D,EAAUuE,EAAWC,GAAQ9B,EAatC,SAASoC,EAAaN,GACpB,IAAIO,EAAoBP,EAAOL,EAM/B,YAAyBlF,IAAjBkF,GAA+BY,GAAqBlB,GACzDkB,EAAoB,GAAOV,GANJG,EAAOJ,GAM8BH,EAGjE,SAASY,IACP,IAAIL,EAAO,IACX,GAAIM,EAAaN,GACf,OAAOQ,EAAaR,GAGtBN,EAAUU,WAAWC,EA3BvB,SAAuBL,GACrB,IAEIS,EAAcpB,GAFMW,EAAOL,GAI/B,OAAOE,EACHX,EAAUuB,EAAahB,GAJDO,EAAOJ,IAK7Ba,EAoB+BC,CAAcV,IAGnD,SAASQ,EAAaR,GAKpB,OAJAN,OAAUjF,EAINgB,GAAY8D,EACPQ,EAAWC,IAEpBT,EAAWC,OAAW/E,EACfyD,GAeT,SAASyC,IACP,IAAIX,EAAO,IACPY,EAAaN,EAAaN,GAM9B,GAJAT,EAAWzL,UACX0L,EAAW9N,KACXiO,EAAeK,EAEXY,EAAY,CACd,QAAgBnG,IAAZiF,EACF,OAAOS,EAAYR,GAErB,GAAIE,EAIF,OAFAgB,aAAanB,GACbA,EAAUU,WAAWC,EAAchB,GAC5BU,EAAWJ,GAMtB,YAHgBlF,IAAZiF,IACFA,EAAUU,WAAWC,EAAchB,IAE9BnB,EAIT,OA3GAmB,EAAO,EAASA,IAAS,EACrB,EAASC,KACX9D,IAAY8D,EAAQ9D,QAEpBiE,GADAI,EAAS,YAAaP,GACHP,EAAU,EAASO,EAAQG,UAAY,EAAGJ,GAAQI,EACrEhE,EAAW,aAAc6D,IAAYA,EAAQ7D,SAAWA,GAoG1DkF,EAAUG,OApCV,gBACkBrG,IAAZiF,GACFmB,aAAanB,GAEfE,EAAiB,EACjBL,EAAWI,EAAeH,EAAWE,OAAUjF,GAgCjDkG,EAAUxG,MA7BV,WACE,YAAmBM,IAAZiF,EAAwBxB,EAASsC,EAAa,MA6BhDG,GCvHM,IAlBf,SAAkBvB,EAAMC,EAAMC,GAC5B,IAAI9D,GAAU,EACVC,GAAW,EAEf,GAAmB,mBAAR2D,EACT,MAAM,IAAIU,UAnDQ,uBAyDpB,OAJI,EAASR,KACX9D,EAAU,YAAa8D,IAAYA,EAAQ9D,QAAUA,EACrDC,EAAW,aAAc6D,IAAYA,EAAQ7D,SAAWA,GAEnD,EAAS2D,EAAMC,EAAM,CAC1B,QAAW7D,EACX,QAAW6D,EACX,SAAY5D,M,8BC/DhB,IAAIsF,EAAe,EAAQ,GACvBhM,EAAiB,EAAQ,IACzBD,EAAa,EAAQ,IAezB7D,EAAQqB,aAdR,SAAsB0O,EAAgB7O,EAAOC,GACzC,GAAI4O,EAAgB,CAChB,GAAIA,aAA0BD,EAAa/L,WACvC,OAAOgM,EAEX,GAAIA,EAAejM,EAAeS,cAC9B,OAAOwL,EAAejM,EAAeS,gBAG7C,OAAKwL,GAAmB7O,GAAUC,EAG3B,IAAI2O,EAAa/L,WAAWgM,EAAgB7O,EAAOC,GAF/C,IAAI2O,EAAa/L,WAAWF,EAAWO,S,6BCbtDpE,EAAQ6G,QAAUmJ,MAAMnJ,SAAW,SAAW5D,GAAK,OAAOA,GAAyB,iBAAbA,EAAEH,S,6BCAxE,IAAIK,EAAa1C,MAAQA,KAAK0C,WAAc,SAAUC,EAAGC,GACrD,IAAK,IAAIC,KAAKD,EAAOA,EAAEE,eAAeD,KAAIF,EAAEE,GAAKD,EAAEC,IACnD,SAASE,IAAO/C,KAAKgD,YAAcL,EACnCA,EAAExC,UAAkB,OAANyC,EAAaK,OAAOR,OAAOG,IAAMG,EAAG5C,UAAYyC,EAAEzC,UAAW,IAAI4C,IAM/EmD,EAAuB,SAAU3C,GAEjC,SAAS2C,EAAoBR,GACzBnC,EAAO1C,KAAKb,MACZA,KAAK0F,OAASA,EACd,IAAIvE,EAAM1B,MAAMoB,KAAKb,KAAM0F,EACvBA,EAAOrD,OAAS,8CAAgDqD,EAAO8J,KAAI,SAAUrO,EAAKsO,GAAK,OAASA,EAAI,EAAK,KAAOtO,EAAI+K,cAAgBwD,KAAK,QAAU,IAC/J1P,KAAK2P,KAAOxO,EAAIwO,KAAO,sBACvB3P,KAAK4P,MAAQzO,EAAIyO,MACjB5P,KAAK6P,QAAU1O,EAAI0O,QAEvB,OAVAnN,EAAUwD,EAAqB3C,GAUxB2C,EAXe,CAYxBzG,OACFF,EAAQ2G,oBAAsBA,G,6BCtB9B,IAAI4J,EAAS,EAAQ,IAWrB,SAASxN,EAAcyN,GACnB,OAAKA,EAGc,IAAfA,EAAI1N,OACG0N,EAAI,GAER,SAAeC,GAClB,OAAOD,EAAI9I,QAAO,SAAUgJ,EAAMjL,GAAM,OAAOA,EAAGiL,KAAUD,IANrDF,EAAOI,KAJtB3Q,EAAQ0C,KAPR,WAEI,IADA,IAAI8N,EAAM,GACD5N,EAAK,EAAGA,EAAKC,UAAUC,OAAQF,IACpC4N,EAAI5N,EAAK,GAAKC,UAAUD,GAE5B,OAAOG,EAAcyN,IAezBxQ,EAAQ+C,cAAgBA,G,6BCpBxB/C,EAAQ2Q,KADR,c,6BCDA,IAAIxN,EAAa1C,MAAQA,KAAK0C,WAAc,SAAUC,EAAGC,GACrD,IAAK,IAAIC,KAAKD,EAAOA,EAAEE,eAAeD,KAAIF,EAAEE,GAAKD,EAAEC,IACnD,SAASE,IAAO/C,KAAKgD,YAAcL,EACnCA,EAAExC,UAAkB,OAANyC,EAAaK,OAAOR,OAAOG,IAAMG,EAAG5C,UAAYyC,EAAEzC,UAAW,IAAI4C,IAE/EyG,EAAgB,EAAQ,IACxB2G,EAAmB,EAAQ,IAM3BxE,EAAwB,SAAUpI,GAElC,SAASoI,EAAqB5D,EAAWC,GACrCzE,EAAO1C,KAAKb,KAAM+H,EAAWC,GAC7BhI,KAAK+H,UAAYA,EACjB/H,KAAKgI,KAAOA,EAiChB,OArCAtF,EAAUiJ,EAAsBpI,GAMhCoI,EAAqBxL,UAAUoI,eAAiB,SAAUR,EAAWM,EAAID,GAGrE,YAFc,IAAVA,IAAoBA,EAAQ,GAElB,OAAVA,GAAkBA,EAAQ,EACnB7E,EAAOpD,UAAUoI,eAAe1H,KAAKb,KAAM+H,EAAWM,EAAID,IAGrEL,EAAUiB,QAAQxC,KAAKxG,MAIhB+H,EAAUqB,YAAcrB,EAAUqB,UAAY+G,EAAiBC,eAAeC,sBAAsBtI,EAAUU,MAAM9D,KAAKoD,EAAW,UAE/I4D,EAAqBxL,UAAUmI,eAAiB,SAAUP,EAAWM,EAAID,GAKrE,QAJc,IAAVA,IAAoBA,EAAQ,GAIjB,OAAVA,GAAkBA,EAAQ,GAAiB,OAAVA,GAAkBpI,KAAKoI,MAAQ,EACjE,OAAO7E,EAAOpD,UAAUmI,eAAezH,KAAKb,KAAM+H,EAAWM,EAAID,GAKpC,IAA7BL,EAAUiB,QAAQ3G,SAClB8N,EAAiBC,eAAeE,qBAAqBjI,GACrDN,EAAUqB,eAAYL,IAKvB4C,EAtCgB,CAuCzBnC,EAAc1B,aAChBvI,EAAQoM,qBAAuBA,G,6BCpD/B,IAAIjJ,EAAa1C,MAAQA,KAAK0C,WAAc,SAAUC,EAAGC,GACrD,IAAK,IAAIC,KAAKD,EAAOA,EAAEE,eAAeD,KAAIF,EAAEE,GAAKD,EAAEC,IACnD,SAASE,IAAO/C,KAAKgD,YAAcL,EACnCA,EAAExC,UAAkB,OAANyC,EAAaK,OAAOR,OAAOG,IAAMG,EAAG5C,UAAYyC,EAAEzC,UAAW,IAAI4C,IAiB/EkG,EAAU,SAAU1F,GAEpB,SAAS0F,EAAOlB,EAAWC,GACvBzE,EAAO1C,KAAKb,MAgBhB,OAlBA0C,EAAUuG,EAAQ1F,GAclB0F,EAAO9I,UAAU+H,SAAW,SAAUC,EAAOC,GAEzC,YADc,IAAVA,IAAoBA,EAAQ,GACzBpI,MAEJiJ,EAnBE,CAfQ,EAAQ,GAmCZ1E,cACjBhF,EAAQ0J,OAASA,G,6BCzCjB,IAAIvJ,EAAS,EAAQ,GACjB6Q,EACA,SAAyC/Q,GACjCA,EAAK6Q,uBACLrQ,KAAKsQ,qBAAuB9Q,EAAK8Q,qBAAqB3L,KAAKnF,GAC3DQ,KAAKqQ,sBAAwB7Q,EAAK6Q,sBAAsB1L,KAAKnF,IAExDA,EAAKgR,0BACVxQ,KAAKsQ,qBAAuB9Q,EAAKiR,wBAAwB9L,KAAKnF,GAC9DQ,KAAKqQ,sBAAwB7Q,EAAKgR,yBAAyB7L,KAAKnF,IAE3DA,EAAKkR,6BACV1Q,KAAKsQ,qBAAuB9Q,EAAKmR,2BAA2BhM,KAAKnF,GACjEQ,KAAKqQ,sBAAwB7Q,EAAKkR,4BAA4B/L,KAAKnF,IAE9DA,EAAKoR,yBACV5Q,KAAKsQ,qBAAuB9Q,EAAKqR,uBAAuBlM,KAAKnF,GAC7DQ,KAAKqQ,sBAAwB7Q,EAAKoR,wBAAwBjM,KAAKnF,IAE1DA,EAAKsR,wBACV9Q,KAAKsQ,qBAAuB9Q,EAAKuR,sBAAsBpM,KAAKnF,GAC5DQ,KAAKqQ,sBAAwB7Q,EAAKsR,uBAAuBnM,KAAKnF,KAG9DQ,KAAKsQ,qBAAuB9Q,EAAK2P,aAAaxK,KAAKnF,GACnDQ,KAAKqQ,sBAAwB,SAAUW,GAAM,OAAOxR,EAAKkP,WAAWsC,EAAI,IAAO,OAK3FzR,EAAQgR,gCAAkCA,EAC1ChR,EAAQ6Q,eAAiB,IAAIG,EAAgC7Q,EAAOF,O,6BC/BpE,IAAIkD,EAAa1C,MAAQA,KAAK0C,WAAc,SAAUC,EAAGC,GACrD,IAAK,IAAIC,KAAKD,EAAOA,EAAEE,eAAeD,KAAIF,EAAEE,GAAKD,EAAEC,IACnD,SAASE,IAAO/C,KAAKgD,YAAcL,EACnCA,EAAExC,UAAkB,OAANyC,EAAaK,OAAOR,OAAOG,IAAMG,EAAG5C,UAAYyC,EAAEzC,UAAW,IAAI4C,IAG/E2I,EAA2B,SAAUnI,GAErC,SAASmI,IACLnI,EAAOiE,MAAMxH,KAAMoC,WAuBvB,OAzBAM,EAAUgJ,EAAyBnI,GAInCmI,EAAwBvL,UAAUsI,MAAQ,SAAUY,GAChDrJ,KAAKmJ,QAAS,EACdnJ,KAAKoJ,eAAYL,EACjB,IACItI,EADAuI,EAAUhJ,KAAKgJ,QAEfpD,GAAS,EACTqL,EAAQjI,EAAQ3G,OACpBgH,EAASA,GAAUL,EAAQM,QAC3B,GACI,GAAI7I,EAAQ4I,EAAOV,QAAQU,EAAOlB,MAAOkB,EAAOjB,OAC5C,cAEGxC,EAAQqL,IAAU5H,EAASL,EAAQM,UAE9C,GADAtJ,KAAKmJ,QAAS,EACV1I,EAAO,CACP,OAASmF,EAAQqL,IAAU5H,EAASL,EAAQM,UACxCD,EAAOtH,cAEX,MAAMtB,IAGPiL,EA1BmB,CADP,EAAQ,IA4BZxC,gBACnB3J,EAAQmM,wBAA0BA,G,6BClBlC,IAAInC,EAAa,WACb,SAASA,EAAU2H,EAAiBnF,QACpB,IAARA,IAAkBA,EAAMxC,EAAUwC,KACtC/L,KAAKkR,gBAAkBA,EACvBlR,KAAK+L,IAAMA,EAwBf,OALAxC,EAAUpJ,UAAU+H,SAAW,SAAUF,EAAMI,EAAOD,GAElD,YADc,IAAVC,IAAoBA,EAAQ,GACzB,IAAIpI,KAAKkR,gBAAgBlR,KAAMgI,GAAME,SAASC,EAAOC,IAEhEmB,EAAUwC,IAAMD,KAAKC,IAAMD,KAAKC,IAAM,WAAc,OAAQ,IAAID,MACzDvC,EA5BK,GA8BhBhK,EAAQgK,UAAYA,G,6BC9CpB,IAAI4H,EAAe,EAAQ,GACvBC,EAAc,EAAQ,IAC1BD,EAAarR,WAAWuR,UAAYD,EAAYC,W,6BCFhD,IAAIC,EAAwB,EAAQ,IACpC/R,EAAQ8R,UAAYC,EAAsBC,oBAAoB9O,Q,6BCD9D,IAAIC,EAAa1C,MAAQA,KAAK0C,WAAc,SAAUC,EAAGC,GACrD,IAAK,IAAIC,KAAKD,EAAOA,EAAEE,eAAeD,KAAIF,EAAEE,GAAKD,EAAEC,IACnD,SAASE,IAAO/C,KAAKgD,YAAcL,EACnCA,EAAExC,UAAkB,OAANyC,EAAaK,OAAOR,OAAOG,IAAMG,EAAG5C,UAAYyC,EAAEzC,UAAW,IAAI4C,IAE/EoO,EAAe,EAAQ,GACvB7L,EAAa,EAAQ,GACrBpC,EAAe,EAAQ,GACvBqC,EAAgB,EAAQ,GACxBpC,EAAiB,EAAQ,GACzB+I,EAAWjJ,OAAO9C,UAAU+L,SAqBhC,IAAIqF,EAAuB,SAAUhO,GAEjC,SAASgO,EAAoBC,EAAWC,EAAWC,EAAU9D,GACzDrK,EAAO1C,KAAKb,MACZA,KAAKwR,UAAYA,EACjBxR,KAAKyR,UAAYA,EACjBzR,KAAK0R,SAAWA,EAChB1R,KAAK4N,QAAUA,EA6KnB,OAnLAlL,EAAU6O,EAAqBhO,GA6H/BgO,EAAoB9O,OAAS,SAAUkP,EAAQF,EAAW7D,EAAS8D,GAK/D,OAJIxO,EAAawB,WAAWkJ,KACxB8D,EAAW9D,EACXA,OAAU7E,GAEP,IAAIwI,EAAoBI,EAAQF,EAAWC,EAAU9D,IAEhE2D,EAAoBK,kBAAoB,SAAUJ,EAAWC,EAAWI,EAAS7P,EAAY4L,GACzF,IAAI7L,EACJ,GArJR,SAAoByP,GAChB,QAASA,GAA0C,sBAA7BtF,EAASrL,KAAK2Q,GAoJ5BM,CAAWN,IAlJvB,SAA0BA,GACtB,QAASA,GAA0C,4BAA7BtF,EAASrL,KAAK2Q,GAiJHO,CAAiBP,GAC1C,IAAK,IAAI/B,EAAI,EAAG5J,EAAM2L,EAAUnP,OAAQoN,EAAI5J,EAAK4J,IAC7C8B,EAAoBK,kBAAkBJ,EAAU/B,GAAIgC,EAAWI,EAAS7P,EAAY4L,QAGvF,GApJb,SAAuB4D,GACnB,QAASA,GAAmD,mBAA/BA,EAAUQ,kBAA4E,mBAAlCR,EAAUS,oBAmJ9EC,CAAcV,GAAY,CAC/B,IAAIW,EAAWX,EACfA,EAAUQ,iBAAiBP,EAAWI,EAASjE,GAC/C7L,EAAc,WAAc,OAAOoQ,EAASF,oBAAoBR,EAAWI,EAASjE,SAEnF,GAlKb,SAAmC4D,GAC/B,QAASA,GAAqC,mBAAjBA,EAAUY,IAA8C,mBAAlBZ,EAAUa,IAiKhEC,CAA0Bd,GAAY,CAC3C,IAAIe,EAAWf,EACfA,EAAUY,GAAGX,EAAWI,GACxB9P,EAAc,WAAc,OAAOwQ,EAASF,IAAIZ,EAAWI,QAE1D,KA1Kb,SAAiCL,GAC7B,QAASA,GAA8C,mBAA1BA,EAAUgB,aAAkE,mBAA7BhB,EAAUiB,eAyKzEC,CAAwBlB,GAM7B,MAAM,IAAIpD,UAAU,wBALpB,IAAIuE,EAAWnB,EACfA,EAAUgB,YAAYf,EAAWI,GACjC9P,EAAc,WAAc,OAAO4Q,EAASF,eAAehB,EAAWI,IAK1E7P,EAAWlB,IAAI,IAAIqC,EAAeoB,aAAaxC,KAEdwP,EAAoBpR,UAAUD,WAAa,SAAU8B,GACtF,IAAIwP,EAAYxR,KAAKwR,UACjBC,EAAYzR,KAAKyR,UACjB7D,EAAU5N,KAAK4N,QACf8D,EAAW1R,KAAK0R,SAChBG,EAAUH,EAAW,WAErB,IADA,IAAInD,EAAO,GACFpM,EAAK,EAAGA,EAAKC,UAAUC,OAAQF,IACpCoM,EAAKpM,EAAK,GAAKC,UAAUD,GAE7B,IAAIqK,EAASlH,EAAWS,SAAS2L,GAAUlK,WAAM,EAAQ+G,GACrD/B,IAAWjH,EAAcS,YACzBhE,EAAWvB,MAAM8E,EAAcS,YAAYC,GAG3CjE,EAAWX,KAAKmL,IAEpB,SAAUvG,GAAK,OAAOjE,EAAWX,KAAK4E,IAC1CsL,EAAoBK,kBAAkBJ,EAAWC,EAAWI,EAAS7P,EAAY4L,IAE9E2D,EApLe,CAqLxBJ,EAAarR,YACfP,EAAQgS,oBAAsBA,G,6BCrN9B,IAAIJ,EAAe,EAAQ,GACvByB,EAAiB,EAAQ,IAC7BzB,EAAarR,WAAWK,UAAU0S,aAAeD,EAAeC,c,6BCFhE,IAAIC,EAAU,EAAQ,IAClBC,EAAa,EAAQ,IACrBH,EAAiB,EAAQ,IA6C7BrT,EAAQsT,aALR,SAAsBpI,EAAU1C,EAAWtG,GAGvC,YAFkB,IAAdsG,IAAwBA,EAAY+K,EAAQpJ,YACjC,IAAXjI,IAAqBA,EAASsR,EAAWlJ,uBACtC+I,EAAeC,aAAapI,EAAU1C,EAAWtG,EAAjDmR,CAAyD5S,Q,6BC7CpE,IAAI0C,EAAa1C,MAAQA,KAAK0C,WAAc,SAAUC,EAAGC,GACrD,IAAK,IAAIC,KAAKD,EAAOA,EAAEE,eAAeD,KAAIF,EAAEE,GAAKD,EAAEC,IACnD,SAASE,IAAO/C,KAAKgD,YAAcL,EACnCA,EAAExC,UAAkB,OAANyC,EAAaK,OAAOR,OAAOG,IAAMG,EAAG5C,UAAYyC,EAAEzC,UAAW,IAAI4C,IAQ/EsI,EAAmB,SAAU9H,GAE7B,SAAS8H,IACL9H,EAAOiE,MAAMxH,KAAMoC,WAWvB,OAbAM,EAAU2I,EAAiB9H,GAI3B8H,EAAgBlL,UAAU2K,WAAa,SAAUC,EAAYC,EAAYC,EAAYC,EAAYC,GAC7FnL,KAAK0D,YAAYrC,KAAK2J,IAE1BK,EAAgBlL,UAAU6S,YAAc,SAAUvS,EAAO0K,GACrDnL,KAAK0D,YAAYjD,MAAMA,IAE3B4K,EAAgBlL,UAAUiL,eAAiB,SAAUD,GACjDnL,KAAK0D,YAAYhD,YAEd2K,EAdW,CANH,EAAQ,GAqBZ/H,YACf/D,EAAQ8L,gBAAkBA,G,6BC3B1B,IAAI3L,EAAS,EAAQ,GACjBuT,EAAgB,EAAQ,IACxBC,EAAc,EAAQ,IACtB7N,EAAa,EAAQ,GACrB8L,EAAe,EAAQ,GACvBgC,EAAa,EAAQ,IACrBC,EAAoB,EAAQ,IAC5BxT,EAAe,EAAQ,IAqE3BL,EAAQoL,kBApER,SAA2B0I,EAAiB7G,EAAQzB,EAAYE,GAC5D,IAAIvH,EAAc,IAAI0P,EAAkBE,gBAAgBD,EAAiBtI,EAAYE,GACrF,GAAIvH,EAAYS,OACZ,OAAO,KAEX,GAAIqI,aAAkB2E,EAAarR,WAC/B,OAAI0M,EAAOvM,WACPyD,EAAYrC,KAAKmL,EAAO1K,OACxB4B,EAAYhD,WACL,OAGPgD,EAAY3C,oBAAqB,EAC1ByL,EAAOzM,UAAU2D,IAG3B,GAAIuP,EAAcM,YAAY/G,GAAS,CACxC,IAAK,IAAIiD,EAAI,EAAG5J,EAAM2G,EAAOnK,OAAQoN,EAAI5J,IAAQnC,EAAYS,OAAQsL,IACjE/L,EAAYrC,KAAKmL,EAAOiD,IAEvB/L,EAAYS,QACbT,EAAYhD,eAGf,IAAIwS,EAAYM,UAAUhH,GAW3B,OAVAA,EAAOiH,MAAK,SAAU3R,GACb4B,EAAYS,SACbT,EAAYrC,KAAKS,GACjB4B,EAAYhD,eAEjB,SAAUS,GAAO,OAAOuC,EAAYjD,MAAMU,MACxCsS,KAAK,MAAM,SAAUtS,GAEtBzB,EAAOF,KAAKkP,YAAW,WAAc,MAAMvN,QAExCuC,EAEN,GAAI8I,GAAiD,mBAAhCA,EAAO2G,EAAWO,UAExC,IADA,IAAIA,EAAWlH,EAAO2G,EAAWO,cAC9B,CACC,IAAIC,EAAOD,EAASrS,OACpB,GAAIsS,EAAKC,KAAM,CACXlQ,EAAYhD,WACZ,MAGJ,GADAgD,EAAYrC,KAAKsS,EAAK7R,OAClB4B,EAAYS,OACZ,WAIP,GAAIqI,GAAqD,mBAApCA,EAAO5M,EAAaU,YAA4B,CACtE,IAAIuT,EAAMrH,EAAO5M,EAAaU,cAC9B,GAA6B,mBAAlBuT,EAAI9T,UAIX,OAAO8T,EAAI9T,UAAU,IAAIqT,EAAkBE,gBAAgBD,EAAiBtI,EAAYE,IAHxFvH,EAAYjD,MAAM,IAAI2N,UAAU,uEAMnC,CACD,IACI0F,EAAO,iBADCzO,EAAWiB,SAASkG,GAAU,oBAAsB,IAAMA,EAAS,KACrE,4FAEV9I,EAAYjD,MAAM,IAAI2N,UAAU0F,KAEpC,OAAO,O,6BC1EXvU,EAAQgU,YAAc,SAAW/Q,GAAK,OAAOA,GAAyB,iBAAbA,EAAEH,S,6BCG3D9C,EAAQiU,UAHR,SAAmB1R,GACf,OAAOA,GAAoC,mBAApBA,EAAM/B,WAAkD,mBAAf+B,EAAM2R,O,6BCD1E,IAAI/T,EAAS,EAAQ,GACrB,SAASqU,EAAuBvU,GAC5B,IAAIiI,EAASjI,EAAKiI,OAClB,GAAsB,mBAAXA,EAIP,OAHKA,EAAOiM,WACRjM,EAAOiM,SAAWjM,EAAO,sBAEtBA,EAAOiM,SAId,IAAIM,EAAQxU,EAAKyU,IACjB,GAAID,GAA8C,mBAA9B,IAAIA,GAAQ,cAC5B,MAAO,aAEX,IAAIE,EAAQ1U,EAAK2U,IAEjB,GAAID,EAEA,IADA,IAAIE,EAAOnR,OAAOoR,oBAAoBH,EAAM/T,WACnCsP,EAAI,EAAGA,EAAI2E,EAAK/R,SAAUoN,EAAG,CAClC,IAAI6E,EAAMF,EAAK3E,GAEf,GAAY,YAAR6E,GAA6B,SAARA,GAAkBJ,EAAM/T,UAAUmU,KAASJ,EAAM/T,UAAmB,QACzF,OAAOmU,EAInB,MAAO,aAGf/U,EAAQwU,uBAAyBA,EACjCxU,EAAQmU,SAAWK,EAAuBrU,EAAOF,MAIjDD,EAAQgV,WAAahV,EAAQmU,U,6BCnC7B,IAAIhR,EAAa1C,MAAQA,KAAK0C,WAAc,SAAUC,EAAGC,GACrD,IAAK,IAAIC,KAAKD,EAAOA,EAAEE,eAAeD,KAAIF,EAAEE,GAAKD,EAAEC,IACnD,SAASE,IAAO/C,KAAKgD,YAAcL,EACnCA,EAAExC,UAAkB,OAANyC,EAAaK,OAAOR,OAAOG,IAAMG,EAAG5C,UAAYyC,EAAEzC,UAAW,IAAI4C,IAQ/EuQ,EAAmB,SAAU/P,GAE7B,SAAS+P,EAAgBrO,EAAQ8F,EAAYE,GACzC1H,EAAO1C,KAAKb,MACZA,KAAKiF,OAASA,EACdjF,KAAK+K,WAAaA,EAClB/K,KAAKiL,WAAaA,EAClBjL,KAAK4F,MAAQ,EAajB,OAnBAlD,EAAU4Q,EAAiB/P,GAQ3B+P,EAAgBnT,UAAU6D,MAAQ,SAAUlC,GACxC9B,KAAKiF,OAAO6F,WAAW9K,KAAK+K,WAAYjJ,EAAO9B,KAAKiL,WAAYjL,KAAK4F,QAAS5F,OAElFsT,EAAgBnT,UAAU8D,OAAS,SAAUxD,GACzCT,KAAKiF,OAAO+N,YAAYvS,EAAOT,MAC/BA,KAAK+B,eAETuR,EAAgBnT,UAAU+D,UAAY,WAClClE,KAAKiF,OAAOmG,eAAepL,MAC3BA,KAAK+B,eAEFuR,EApBW,CANH,EAAQ,GA2BZhQ,YACf/D,EAAQ+T,gBAAkBA,G,6BCjC1B,IAAI5Q,EAAa1C,MAAQA,KAAK0C,WAAc,SAAUC,EAAGC,GACrD,IAAK,IAAIC,KAAKD,EAAOA,EAAEE,eAAeD,KAAIF,EAAEE,GAAKD,EAAEC,IACnD,SAASE,IAAO/C,KAAKgD,YAAcL,EACnCA,EAAExC,UAAkB,OAANyC,EAAaK,OAAOR,OAAOG,IAAMG,EAAG5C,UAAYyC,EAAEzC,UAAW,IAAI4C,IAE/EsM,EAAe,EAAQ,GACvByD,EAAU,EAAQ,IAClBC,EAAa,EAAQ,IA6CzBxT,EAAQsT,aALR,SAAsBpI,EAAU1C,EAAWtG,GAGvC,YAFkB,IAAdsG,IAAwBA,EAAY+K,EAAQpJ,YACjC,IAAXjI,IAAqBA,EAASsR,EAAWlJ,uBACtC,SAAUtJ,GAAU,OAAOA,EAAOH,KAAK,IAAIoU,EAAqB/J,EAAU1C,EAAWtG,EAAOqI,QAASrI,EAAOsI,aAGvH,IAAIyK,EAAwB,WACxB,SAASA,EAAqB/J,EAAU1C,EAAW+B,EAASC,GACxD/J,KAAKyK,SAAWA,EAChBzK,KAAK+H,UAAYA,EACjB/H,KAAK8J,QAAUA,EACf9J,KAAK+J,SAAWA,EAKpB,OAHAyK,EAAqBrU,UAAUU,KAAO,SAAUmB,EAAYzB,GACxD,OAAOA,EAAOR,UAAU,IAAI0U,EAAuBzS,EAAYhC,KAAKyK,SAAUzK,KAAK+H,UAAW/H,KAAK8J,QAAS9J,KAAK+J,YAE9GyK,EAVgB,GAiBvBC,EAA0B,SAAUlR,GAEpC,SAASkR,EAAuB/Q,EAAa+G,EAAU1C,EAAW+B,EAASC,GACvExG,EAAO1C,KAAKb,KAAM0D,GAClB1D,KAAKyK,SAAWA,EAChBzK,KAAK+H,UAAYA,EACjB/H,KAAK8J,QAAUA,EACf9J,KAAK+J,SAAWA,EAChB/J,KAAKsK,mBAAoB,EACzBtK,KAAKwK,eAAiB,KA6B1B,OArCA9H,EAAU+R,EAAwBlR,GAUlCkR,EAAuBtU,UAAU6D,MAAQ,SAAUlC,GAC3C9B,KAAKuK,UACDvK,KAAK+J,WACL/J,KAAKwK,eAAiB1I,EACtB9B,KAAKsK,mBAAoB,IAI7BtK,KAAKc,IAAId,KAAKuK,UAAYvK,KAAK+H,UAAUG,SAASwM,EAAc1U,KAAKyK,SAAU,CAAEzI,WAAYhC,QACzFA,KAAK8J,SACL9J,KAAK0D,YAAYrC,KAAKS,KAIlC2S,EAAuBtU,UAAUwU,cAAgB,WAC7C,IAAIpK,EAAYvK,KAAKuK,UACjBA,IACIvK,KAAK+J,UAAY/J,KAAKsK,oBACtBtK,KAAK0D,YAAYrC,KAAKrB,KAAKwK,gBAC3BxK,KAAKwK,eAAiB,KACtBxK,KAAKsK,mBAAoB,GAE7BC,EAAUxI,cACV/B,KAAK8F,OAAOyE,GACZvK,KAAKuK,UAAY,OAGlBkK,EAtCkB,CAuC3BpF,EAAa/L,YACf,SAASoR,EAAaE,GACDA,EAAI5S,WACV2S","file":"static/js/28.modern.fda6edba.chunk.js","sourcesContent":["\"use strict\";\n// CommonJS / Node have global context exposed as \"global\" variable.\n// We don't want to include the whole node.d.ts this this compilation unit so we'll just fake\n// the global \"global\" var for now.\nvar __window = typeof window !== 'undefined' && window;\nvar __self = typeof self !== 'undefined' && typeof WorkerGlobalScope !== 'undefined' &&\n    self instanceof WorkerGlobalScope && self;\nvar __global = typeof global !== 'undefined' && global;\nvar _root = __window || __global || __self;\nexports.root = _root;\n// Workaround Closure Compiler restriction: The body of a goog.module cannot use throw.\n// This is needed when used with angular/tsickle which inserts a goog.module statement.\n// Wrap in IIFE\n(function () {\n    if (!_root) {\n        throw new Error('RxJS could not find any global context (window, self, global)');\n    }\n})();\n//# sourceMappingURL=root.js.map","\"use strict\";\nvar root_1 = require('./util/root');\nvar toSubscriber_1 = require('./util/toSubscriber');\nvar observable_1 = require('./symbol/observable');\nvar pipe_1 = require('./util/pipe');\n/**\n * A representation of any set of values over any amount of time. This is the most basic building block\n * of RxJS.\n *\n * @class Observable<T>\n */\nvar Observable = (function () {\n    /**\n     * @constructor\n     * @param {Function} subscribe the function that is called when the Observable is\n     * initially subscribed to. This function is given a Subscriber, to which new values\n     * can be `next`ed, or an `error` method can be called to raise an error, or\n     * `complete` can be called to notify of a successful completion.\n     */\n    function Observable(subscribe) {\n        this._isScalar = false;\n        if (subscribe) {\n            this._subscribe = subscribe;\n        }\n    }\n    /**\n     * Creates a new Observable, with this Observable as the source, and the passed\n     * operator defined as the new observable's operator.\n     * @method lift\n     * @param {Operator} operator the operator defining the operation to take on the observable\n     * @return {Observable} a new observable with the Operator applied\n     */\n    Observable.prototype.lift = function (operator) {\n        var observable = new Observable();\n        observable.source = this;\n        observable.operator = operator;\n        return observable;\n    };\n    /**\n     * Invokes an execution of an Observable and registers Observer handlers for notifications it will emit.\n     *\n     * <span class=\"informal\">Use it when you have all these Observables, but still nothing is happening.</span>\n     *\n     * `subscribe` is not a regular operator, but a method that calls Observable's internal `subscribe` function. It\n     * might be for example a function that you passed to a {@link create} static factory, but most of the time it is\n     * a library implementation, which defines what and when will be emitted by an Observable. This means that calling\n     * `subscribe` is actually the moment when Observable starts its work, not when it is created, as it is often\n     * thought.\n     *\n     * Apart from starting the execution of an Observable, this method allows you to listen for values\n     * that an Observable emits, as well as for when it completes or errors. You can achieve this in two\n     * following ways.\n     *\n     * The first way is creating an object that implements {@link Observer} interface. It should have methods\n     * defined by that interface, but note that it should be just a regular JavaScript object, which you can create\n     * yourself in any way you want (ES6 class, classic function constructor, object literal etc.). In particular do\n     * not attempt to use any RxJS implementation details to create Observers - you don't need them. Remember also\n     * that your object does not have to implement all methods. If you find yourself creating a method that doesn't\n     * do anything, you can simply omit it. Note however, that if `error` method is not provided, all errors will\n     * be left uncaught.\n     *\n     * The second way is to give up on Observer object altogether and simply provide callback functions in place of its methods.\n     * This means you can provide three functions as arguments to `subscribe`, where first function is equivalent\n     * of a `next` method, second of an `error` method and third of a `complete` method. Just as in case of Observer,\n     * if you do not need to listen for something, you can omit a function, preferably by passing `undefined` or `null`,\n     * since `subscribe` recognizes these functions by where they were placed in function call. When it comes\n     * to `error` function, just as before, if not provided, errors emitted by an Observable will be thrown.\n     *\n     * Whatever style of calling `subscribe` you use, in both cases it returns a Subscription object.\n     * This object allows you to call `unsubscribe` on it, which in turn will stop work that an Observable does and will clean\n     * up all resources that an Observable used. Note that cancelling a subscription will not call `complete` callback\n     * provided to `subscribe` function, which is reserved for a regular completion signal that comes from an Observable.\n     *\n     * Remember that callbacks provided to `subscribe` are not guaranteed to be called asynchronously.\n     * It is an Observable itself that decides when these functions will be called. For example {@link of}\n     * by default emits all its values synchronously. Always check documentation for how given Observable\n     * will behave when subscribed and if its default behavior can be modified with a {@link Scheduler}.\n     *\n     * @example <caption>Subscribe with an Observer</caption>\n     * const sumObserver = {\n     *   sum: 0,\n     *   next(value) {\n     *     console.log('Adding: ' + value);\n     *     this.sum = this.sum + value;\n     *   },\n     *   error() { // We actually could just remove this method,\n     *   },        // since we do not really care about errors right now.\n     *   complete() {\n     *     console.log('Sum equals: ' + this.sum);\n     *   }\n     * };\n     *\n     * Rx.Observable.of(1, 2, 3) // Synchronously emits 1, 2, 3 and then completes.\n     * .subscribe(sumObserver);\n     *\n     * // Logs:\n     * // \"Adding: 1\"\n     * // \"Adding: 2\"\n     * // \"Adding: 3\"\n     * // \"Sum equals: 6\"\n     *\n     *\n     * @example <caption>Subscribe with functions</caption>\n     * let sum = 0;\n     *\n     * Rx.Observable.of(1, 2, 3)\n     * .subscribe(\n     *   function(value) {\n     *     console.log('Adding: ' + value);\n     *     sum = sum + value;\n     *   },\n     *   undefined,\n     *   function() {\n     *     console.log('Sum equals: ' + sum);\n     *   }\n     * );\n     *\n     * // Logs:\n     * // \"Adding: 1\"\n     * // \"Adding: 2\"\n     * // \"Adding: 3\"\n     * // \"Sum equals: 6\"\n     *\n     *\n     * @example <caption>Cancel a subscription</caption>\n     * const subscription = Rx.Observable.interval(1000).subscribe(\n     *   num => console.log(num),\n     *   undefined,\n     *   () => console.log('completed!') // Will not be called, even\n     * );                                // when cancelling subscription\n     *\n     *\n     * setTimeout(() => {\n     *   subscription.unsubscribe();\n     *   console.log('unsubscribed!');\n     * }, 2500);\n     *\n     * // Logs:\n     * // 0 after 1s\n     * // 1 after 2s\n     * // \"unsubscribed!\" after 2.5s\n     *\n     *\n     * @param {Observer|Function} observerOrNext (optional) Either an observer with methods to be called,\n     *  or the first of three possible handlers, which is the handler for each value emitted from the subscribed\n     *  Observable.\n     * @param {Function} error (optional) A handler for a terminal event resulting from an error. If no error handler is provided,\n     *  the error will be thrown as unhandled.\n     * @param {Function} complete (optional) A handler for a terminal event resulting from successful completion.\n     * @return {ISubscription} a subscription reference to the registered handlers\n     * @method subscribe\n     */\n    Observable.prototype.subscribe = function (observerOrNext, error, complete) {\n        var operator = this.operator;\n        var sink = toSubscriber_1.toSubscriber(observerOrNext, error, complete);\n        if (operator) {\n            operator.call(sink, this.source);\n        }\n        else {\n            sink.add(this.source || !sink.syncErrorThrowable ? this._subscribe(sink) : this._trySubscribe(sink));\n        }\n        if (sink.syncErrorThrowable) {\n            sink.syncErrorThrowable = false;\n            if (sink.syncErrorThrown) {\n                throw sink.syncErrorValue;\n            }\n        }\n        return sink;\n    };\n    Observable.prototype._trySubscribe = function (sink) {\n        try {\n            return this._subscribe(sink);\n        }\n        catch (err) {\n            sink.syncErrorThrown = true;\n            sink.syncErrorValue = err;\n            sink.error(err);\n        }\n    };\n    /**\n     * @method forEach\n     * @param {Function} next a handler for each value emitted by the observable\n     * @param {PromiseConstructor} [PromiseCtor] a constructor function used to instantiate the Promise\n     * @return {Promise} a promise that either resolves on observable completion or\n     *  rejects with the handled error\n     */\n    Observable.prototype.forEach = function (next, PromiseCtor) {\n        var _this = this;\n        if (!PromiseCtor) {\n            if (root_1.root.Rx && root_1.root.Rx.config && root_1.root.Rx.config.Promise) {\n                PromiseCtor = root_1.root.Rx.config.Promise;\n            }\n            else if (root_1.root.Promise) {\n                PromiseCtor = root_1.root.Promise;\n            }\n        }\n        if (!PromiseCtor) {\n            throw new Error('no Promise impl found');\n        }\n        return new PromiseCtor(function (resolve, reject) {\n            // Must be declared in a separate statement to avoid a RefernceError when\n            // accessing subscription below in the closure due to Temporal Dead Zone.\n            var subscription;\n            subscription = _this.subscribe(function (value) {\n                if (subscription) {\n                    // if there is a subscription, then we can surmise\n                    // the next handling is asynchronous. Any errors thrown\n                    // need to be rejected explicitly and unsubscribe must be\n                    // called manually\n                    try {\n                        next(value);\n                    }\n                    catch (err) {\n                        reject(err);\n                        subscription.unsubscribe();\n                    }\n                }\n                else {\n                    // if there is NO subscription, then we're getting a nexted\n                    // value synchronously during subscription. We can just call it.\n                    // If it errors, Observable's `subscribe` will ensure the\n                    // unsubscription logic is called, then synchronously rethrow the error.\n                    // After that, Promise will trap the error and send it\n                    // down the rejection path.\n                    next(value);\n                }\n            }, reject, resolve);\n        });\n    };\n    /** @deprecated internal use only */ Observable.prototype._subscribe = function (subscriber) {\n        return this.source.subscribe(subscriber);\n    };\n    /**\n     * An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable\n     * @method Symbol.observable\n     * @return {Observable} this instance of the observable\n     */\n    Observable.prototype[observable_1.observable] = function () {\n        return this;\n    };\n    /* tslint:enable:max-line-length */\n    /**\n     * Used to stitch together functional operators into a chain.\n     * @method pipe\n     * @return {Observable} the Observable result of all of the operators having\n     * been called in the order they were passed in.\n     *\n     * @example\n     *\n     * import { map, filter, scan } from 'rxjs/operators';\n     *\n     * Rx.Observable.interval(1000)\n     *   .pipe(\n     *     filter(x => x % 2 === 0),\n     *     map(x => x + x),\n     *     scan((acc, x) => acc + x)\n     *   )\n     *   .subscribe(x => console.log(x))\n     */\n    Observable.prototype.pipe = function () {\n        var operations = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            operations[_i - 0] = arguments[_i];\n        }\n        if (operations.length === 0) {\n            return this;\n        }\n        return pipe_1.pipeFromArray(operations)(this);\n    };\n    /* tslint:enable:max-line-length */\n    Observable.prototype.toPromise = function (PromiseCtor) {\n        var _this = this;\n        if (!PromiseCtor) {\n            if (root_1.root.Rx && root_1.root.Rx.config && root_1.root.Rx.config.Promise) {\n                PromiseCtor = root_1.root.Rx.config.Promise;\n            }\n            else if (root_1.root.Promise) {\n                PromiseCtor = root_1.root.Promise;\n            }\n        }\n        if (!PromiseCtor) {\n            throw new Error('no Promise impl found');\n        }\n        return new PromiseCtor(function (resolve, reject) {\n            var value;\n            _this.subscribe(function (x) { return value = x; }, function (err) { return reject(err); }, function () { return resolve(value); });\n        });\n    };\n    // HACK: Since TypeScript inherits static properties too, we have to\n    // fight against TypeScript here so Subject can have a different static create signature\n    /**\n     * Creates a new cold Observable by calling the Observable constructor\n     * @static true\n     * @owner Observable\n     * @method create\n     * @param {Function} subscribe? the subscriber function to be passed to the Observable constructor\n     * @return {Observable} a new cold observable\n     */\n    Observable.create = function (subscribe) {\n        return new Observable(subscribe);\n    };\n    return Observable;\n}());\nexports.Observable = Observable;\n//# sourceMappingURL=Observable.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar isFunction_1 = require('./util/isFunction');\nvar Subscription_1 = require('./Subscription');\nvar Observer_1 = require('./Observer');\nvar rxSubscriber_1 = require('./symbol/rxSubscriber');\n/**\n * Implements the {@link Observer} interface and extends the\n * {@link Subscription} class. While the {@link Observer} is the public API for\n * consuming the values of an {@link Observable}, all Observers get converted to\n * a Subscriber, in order to provide Subscription-like capabilities such as\n * `unsubscribe`. Subscriber is a common type in RxJS, and crucial for\n * implementing operators, but it is rarely used as a public API.\n *\n * @class Subscriber<T>\n */\nvar Subscriber = (function (_super) {\n    __extends(Subscriber, _super);\n    /**\n     * @param {Observer|function(value: T): void} [destinationOrNext] A partially\n     * defined Observer or a `next` callback function.\n     * @param {function(e: ?any): void} [error] The `error` callback of an\n     * Observer.\n     * @param {function(): void} [complete] The `complete` callback of an\n     * Observer.\n     */\n    function Subscriber(destinationOrNext, error, complete) {\n        _super.call(this);\n        this.syncErrorValue = null;\n        this.syncErrorThrown = false;\n        this.syncErrorThrowable = false;\n        this.isStopped = false;\n        switch (arguments.length) {\n            case 0:\n                this.destination = Observer_1.empty;\n                break;\n            case 1:\n                if (!destinationOrNext) {\n                    this.destination = Observer_1.empty;\n                    break;\n                }\n                if (typeof destinationOrNext === 'object') {\n                    // HACK(benlesh): To resolve an issue where Node users may have multiple\n                    // copies of rxjs in their node_modules directory.\n                    if (isTrustedSubscriber(destinationOrNext)) {\n                        var trustedSubscriber = destinationOrNext[rxSubscriber_1.rxSubscriber]();\n                        this.syncErrorThrowable = trustedSubscriber.syncErrorThrowable;\n                        this.destination = trustedSubscriber;\n                        trustedSubscriber.add(this);\n                    }\n                    else {\n                        this.syncErrorThrowable = true;\n                        this.destination = new SafeSubscriber(this, destinationOrNext);\n                    }\n                    break;\n                }\n            default:\n                this.syncErrorThrowable = true;\n                this.destination = new SafeSubscriber(this, destinationOrNext, error, complete);\n                break;\n        }\n    }\n    Subscriber.prototype[rxSubscriber_1.rxSubscriber] = function () { return this; };\n    /**\n     * A static factory for a Subscriber, given a (potentially partial) definition\n     * of an Observer.\n     * @param {function(x: ?T): void} [next] The `next` callback of an Observer.\n     * @param {function(e: ?any): void} [error] The `error` callback of an\n     * Observer.\n     * @param {function(): void} [complete] The `complete` callback of an\n     * Observer.\n     * @return {Subscriber<T>} A Subscriber wrapping the (partially defined)\n     * Observer represented by the given arguments.\n     */\n    Subscriber.create = function (next, error, complete) {\n        var subscriber = new Subscriber(next, error, complete);\n        subscriber.syncErrorThrowable = false;\n        return subscriber;\n    };\n    /**\n     * The {@link Observer} callback to receive notifications of type `next` from\n     * the Observable, with a value. The Observable may call this method 0 or more\n     * times.\n     * @param {T} [value] The `next` value.\n     * @return {void}\n     */\n    Subscriber.prototype.next = function (value) {\n        if (!this.isStopped) {\n            this._next(value);\n        }\n    };\n    /**\n     * The {@link Observer} callback to receive notifications of type `error` from\n     * the Observable, with an attached {@link Error}. Notifies the Observer that\n     * the Observable has experienced an error condition.\n     * @param {any} [err] The `error` exception.\n     * @return {void}\n     */\n    Subscriber.prototype.error = function (err) {\n        if (!this.isStopped) {\n            this.isStopped = true;\n            this._error(err);\n        }\n    };\n    /**\n     * The {@link Observer} callback to receive a valueless notification of type\n     * `complete` from the Observable. Notifies the Observer that the Observable\n     * has finished sending push-based notifications.\n     * @return {void}\n     */\n    Subscriber.prototype.complete = function () {\n        if (!this.isStopped) {\n            this.isStopped = true;\n            this._complete();\n        }\n    };\n    Subscriber.prototype.unsubscribe = function () {\n        if (this.closed) {\n            return;\n        }\n        this.isStopped = true;\n        _super.prototype.unsubscribe.call(this);\n    };\n    Subscriber.prototype._next = function (value) {\n        this.destination.next(value);\n    };\n    Subscriber.prototype._error = function (err) {\n        this.destination.error(err);\n        this.unsubscribe();\n    };\n    Subscriber.prototype._complete = function () {\n        this.destination.complete();\n        this.unsubscribe();\n    };\n    /** @deprecated internal use only */ Subscriber.prototype._unsubscribeAndRecycle = function () {\n        var _a = this, _parent = _a._parent, _parents = _a._parents;\n        this._parent = null;\n        this._parents = null;\n        this.unsubscribe();\n        this.closed = false;\n        this.isStopped = false;\n        this._parent = _parent;\n        this._parents = _parents;\n        return this;\n    };\n    return Subscriber;\n}(Subscription_1.Subscription));\nexports.Subscriber = Subscriber;\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar SafeSubscriber = (function (_super) {\n    __extends(SafeSubscriber, _super);\n    function SafeSubscriber(_parentSubscriber, observerOrNext, error, complete) {\n        _super.call(this);\n        this._parentSubscriber = _parentSubscriber;\n        var next;\n        var context = this;\n        if (isFunction_1.isFunction(observerOrNext)) {\n            next = observerOrNext;\n        }\n        else if (observerOrNext) {\n            next = observerOrNext.next;\n            error = observerOrNext.error;\n            complete = observerOrNext.complete;\n            if (observerOrNext !== Observer_1.empty) {\n                context = Object.create(observerOrNext);\n                if (isFunction_1.isFunction(context.unsubscribe)) {\n                    this.add(context.unsubscribe.bind(context));\n                }\n                context.unsubscribe = this.unsubscribe.bind(this);\n            }\n        }\n        this._context = context;\n        this._next = next;\n        this._error = error;\n        this._complete = complete;\n    }\n    SafeSubscriber.prototype.next = function (value) {\n        if (!this.isStopped && this._next) {\n            var _parentSubscriber = this._parentSubscriber;\n            if (!_parentSubscriber.syncErrorThrowable) {\n                this.__tryOrUnsub(this._next, value);\n            }\n            else if (this.__tryOrSetError(_parentSubscriber, this._next, value)) {\n                this.unsubscribe();\n            }\n        }\n    };\n    SafeSubscriber.prototype.error = function (err) {\n        if (!this.isStopped) {\n            var _parentSubscriber = this._parentSubscriber;\n            if (this._error) {\n                if (!_parentSubscriber.syncErrorThrowable) {\n                    this.__tryOrUnsub(this._error, err);\n                    this.unsubscribe();\n                }\n                else {\n                    this.__tryOrSetError(_parentSubscriber, this._error, err);\n                    this.unsubscribe();\n                }\n            }\n            else if (!_parentSubscriber.syncErrorThrowable) {\n                this.unsubscribe();\n                throw err;\n            }\n            else {\n                _parentSubscriber.syncErrorValue = err;\n                _parentSubscriber.syncErrorThrown = true;\n                this.unsubscribe();\n            }\n        }\n    };\n    SafeSubscriber.prototype.complete = function () {\n        var _this = this;\n        if (!this.isStopped) {\n            var _parentSubscriber = this._parentSubscriber;\n            if (this._complete) {\n                var wrappedComplete = function () { return _this._complete.call(_this._context); };\n                if (!_parentSubscriber.syncErrorThrowable) {\n                    this.__tryOrUnsub(wrappedComplete);\n                    this.unsubscribe();\n                }\n                else {\n                    this.__tryOrSetError(_parentSubscriber, wrappedComplete);\n                    this.unsubscribe();\n                }\n            }\n            else {\n                this.unsubscribe();\n            }\n        }\n    };\n    SafeSubscriber.prototype.__tryOrUnsub = function (fn, value) {\n        try {\n            fn.call(this._context, value);\n        }\n        catch (err) {\n            this.unsubscribe();\n            throw err;\n        }\n    };\n    SafeSubscriber.prototype.__tryOrSetError = function (parent, fn, value) {\n        try {\n            fn.call(this._context, value);\n        }\n        catch (err) {\n            parent.syncErrorValue = err;\n            parent.syncErrorThrown = true;\n            return true;\n        }\n        return false;\n    };\n    /** @deprecated internal use only */ SafeSubscriber.prototype._unsubscribe = function () {\n        var _parentSubscriber = this._parentSubscriber;\n        this._context = null;\n        this._parentSubscriber = null;\n        _parentSubscriber.unsubscribe();\n    };\n    return SafeSubscriber;\n}(Subscriber));\nfunction isTrustedSubscriber(obj) {\n    return obj instanceof Subscriber || ('syncErrorThrowable' in obj && obj[rxSubscriber_1.rxSubscriber]);\n}\n//# sourceMappingURL=Subscriber.js.map","\"use strict\";\nfunction isFunction(x) {\n    return typeof x === 'function';\n}\nexports.isFunction = isFunction;\n//# sourceMappingURL=isFunction.js.map","\"use strict\";\nvar isArray_1 = require('./util/isArray');\nvar isObject_1 = require('./util/isObject');\nvar isFunction_1 = require('./util/isFunction');\nvar tryCatch_1 = require('./util/tryCatch');\nvar errorObject_1 = require('./util/errorObject');\nvar UnsubscriptionError_1 = require('./util/UnsubscriptionError');\n/**\n * Represents a disposable resource, such as the execution of an Observable. A\n * Subscription has one important method, `unsubscribe`, that takes no argument\n * and just disposes the resource held by the subscription.\n *\n * Additionally, subscriptions may be grouped together through the `add()`\n * method, which will attach a child Subscription to the current Subscription.\n * When a Subscription is unsubscribed, all its children (and its grandchildren)\n * will be unsubscribed as well.\n *\n * @class Subscription\n */\nvar Subscription = (function () {\n    /**\n     * @param {function(): void} [unsubscribe] A function describing how to\n     * perform the disposal of resources when the `unsubscribe` method is called.\n     */\n    function Subscription(unsubscribe) {\n        /**\n         * A flag to indicate whether this Subscription has already been unsubscribed.\n         * @type {boolean}\n         */\n        this.closed = false;\n        this._parent = null;\n        this._parents = null;\n        this._subscriptions = null;\n        if (unsubscribe) {\n            this._unsubscribe = unsubscribe;\n        }\n    }\n    /**\n     * Disposes the resources held by the subscription. May, for instance, cancel\n     * an ongoing Observable execution or cancel any other type of work that\n     * started when the Subscription was created.\n     * @return {void}\n     */\n    Subscription.prototype.unsubscribe = function () {\n        var hasErrors = false;\n        var errors;\n        if (this.closed) {\n            return;\n        }\n        var _a = this, _parent = _a._parent, _parents = _a._parents, _unsubscribe = _a._unsubscribe, _subscriptions = _a._subscriptions;\n        this.closed = true;\n        this._parent = null;\n        this._parents = null;\n        // null out _subscriptions first so any child subscriptions that attempt\n        // to remove themselves from this subscription will noop\n        this._subscriptions = null;\n        var index = -1;\n        var len = _parents ? _parents.length : 0;\n        // if this._parent is null, then so is this._parents, and we\n        // don't have to remove ourselves from any parent subscriptions.\n        while (_parent) {\n            _parent.remove(this);\n            // if this._parents is null or index >= len,\n            // then _parent is set to null, and the loop exits\n            _parent = ++index < len && _parents[index] || null;\n        }\n        if (isFunction_1.isFunction(_unsubscribe)) {\n            var trial = tryCatch_1.tryCatch(_unsubscribe).call(this);\n            if (trial === errorObject_1.errorObject) {\n                hasErrors = true;\n                errors = errors || (errorObject_1.errorObject.e instanceof UnsubscriptionError_1.UnsubscriptionError ?\n                    flattenUnsubscriptionErrors(errorObject_1.errorObject.e.errors) : [errorObject_1.errorObject.e]);\n            }\n        }\n        if (isArray_1.isArray(_subscriptions)) {\n            index = -1;\n            len = _subscriptions.length;\n            while (++index < len) {\n                var sub = _subscriptions[index];\n                if (isObject_1.isObject(sub)) {\n                    var trial = tryCatch_1.tryCatch(sub.unsubscribe).call(sub);\n                    if (trial === errorObject_1.errorObject) {\n                        hasErrors = true;\n                        errors = errors || [];\n                        var err = errorObject_1.errorObject.e;\n                        if (err instanceof UnsubscriptionError_1.UnsubscriptionError) {\n                            errors = errors.concat(flattenUnsubscriptionErrors(err.errors));\n                        }\n                        else {\n                            errors.push(err);\n                        }\n                    }\n                }\n            }\n        }\n        if (hasErrors) {\n            throw new UnsubscriptionError_1.UnsubscriptionError(errors);\n        }\n    };\n    /**\n     * Adds a tear down to be called during the unsubscribe() of this\n     * Subscription.\n     *\n     * If the tear down being added is a subscription that is already\n     * unsubscribed, is the same reference `add` is being called on, or is\n     * `Subscription.EMPTY`, it will not be added.\n     *\n     * If this subscription is already in an `closed` state, the passed\n     * tear down logic will be executed immediately.\n     *\n     * @param {TeardownLogic} teardown The additional logic to execute on\n     * teardown.\n     * @return {Subscription} Returns the Subscription used or created to be\n     * added to the inner subscriptions list. This Subscription can be used with\n     * `remove()` to remove the passed teardown logic from the inner subscriptions\n     * list.\n     */\n    Subscription.prototype.add = function (teardown) {\n        if (!teardown || (teardown === Subscription.EMPTY)) {\n            return Subscription.EMPTY;\n        }\n        if (teardown === this) {\n            return this;\n        }\n        var subscription = teardown;\n        switch (typeof teardown) {\n            case 'function':\n                subscription = new Subscription(teardown);\n            case 'object':\n                if (subscription.closed || typeof subscription.unsubscribe !== 'function') {\n                    return subscription;\n                }\n                else if (this.closed) {\n                    subscription.unsubscribe();\n                    return subscription;\n                }\n                else if (typeof subscription._addParent !== 'function' /* quack quack */) {\n                    var tmp = subscription;\n                    subscription = new Subscription();\n                    subscription._subscriptions = [tmp];\n                }\n                break;\n            default:\n                throw new Error('unrecognized teardown ' + teardown + ' added to Subscription.');\n        }\n        var subscriptions = this._subscriptions || (this._subscriptions = []);\n        subscriptions.push(subscription);\n        subscription._addParent(this);\n        return subscription;\n    };\n    /**\n     * Removes a Subscription from the internal list of subscriptions that will\n     * unsubscribe during the unsubscribe process of this Subscription.\n     * @param {Subscription} subscription The subscription to remove.\n     * @return {void}\n     */\n    Subscription.prototype.remove = function (subscription) {\n        var subscriptions = this._subscriptions;\n        if (subscriptions) {\n            var subscriptionIndex = subscriptions.indexOf(subscription);\n            if (subscriptionIndex !== -1) {\n                subscriptions.splice(subscriptionIndex, 1);\n            }\n        }\n    };\n    Subscription.prototype._addParent = function (parent) {\n        var _a = this, _parent = _a._parent, _parents = _a._parents;\n        if (!_parent || _parent === parent) {\n            // If we don't have a parent, or the new parent is the same as the\n            // current parent, then set this._parent to the new parent.\n            this._parent = parent;\n        }\n        else if (!_parents) {\n            // If there's already one parent, but not multiple, allocate an Array to\n            // store the rest of the parent Subscriptions.\n            this._parents = [parent];\n        }\n        else if (_parents.indexOf(parent) === -1) {\n            // Only add the new parent to the _parents list if it's not already there.\n            _parents.push(parent);\n        }\n    };\n    Subscription.EMPTY = (function (empty) {\n        empty.closed = true;\n        return empty;\n    }(new Subscription()));\n    return Subscription;\n}());\nexports.Subscription = Subscription;\nfunction flattenUnsubscriptionErrors(errors) {\n    return errors.reduce(function (errs, err) { return errs.concat((err instanceof UnsubscriptionError_1.UnsubscriptionError) ? err.errors : err); }, []);\n}\n//# sourceMappingURL=Subscription.js.map","\"use strict\";\n// typeof any so that it we don't have to cast when comparing a result to the error object\nexports.errorObject = { e: {} };\n//# sourceMappingURL=errorObject.js.map","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","\"use strict\";\nfunction isObject(x) {\n    return x != null && typeof x === 'object';\n}\nexports.isObject = isObject;\n//# sourceMappingURL=isObject.js.map","\"use strict\";\nvar errorObject_1 = require('./errorObject');\nvar tryCatchTarget;\nfunction tryCatcher() {\n    try {\n        return tryCatchTarget.apply(this, arguments);\n    }\n    catch (e) {\n        errorObject_1.errorObject.e = e;\n        return errorObject_1.errorObject;\n    }\n}\nfunction tryCatch(fn) {\n    tryCatchTarget = fn;\n    return tryCatcher;\n}\nexports.tryCatch = tryCatch;\n;\n//# sourceMappingURL=tryCatch.js.map","\"use strict\";\nexports.empty = {\n    closed: true,\n    next: function (value) { },\n    error: function (err) { throw err; },\n    complete: function () { }\n};\n//# sourceMappingURL=Observer.js.map","\"use strict\";\nvar root_1 = require('../util/root');\nvar Symbol = root_1.root.Symbol;\nexports.rxSubscriber = (typeof Symbol === 'function' && typeof Symbol.for === 'function') ?\n    Symbol.for('rxSubscriber') : '@@rxSubscriber';\n/**\n * @deprecated use rxSubscriber instead\n */\nexports.$$rxSubscriber = exports.rxSubscriber;\n//# sourceMappingURL=rxSubscriber.js.map","\"use strict\";\nvar root_1 = require('../util/root');\nfunction getSymbolObservable(context) {\n    var $$observable;\n    var Symbol = context.Symbol;\n    if (typeof Symbol === 'function') {\n        if (Symbol.observable) {\n            $$observable = Symbol.observable;\n        }\n        else {\n            $$observable = Symbol('observable');\n            Symbol.observable = $$observable;\n        }\n    }\n    else {\n        $$observable = '@@observable';\n    }\n    return $$observable;\n}\nexports.getSymbolObservable = getSymbolObservable;\nexports.observable = getSymbolObservable(root_1.root);\n/**\n * @deprecated use observable instead\n */\nexports.$$observable = exports.observable;\n//# sourceMappingURL=observable.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar root_1 = require('../util/root');\nvar Action_1 = require('./Action');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar AsyncAction = (function (_super) {\n    __extends(AsyncAction, _super);\n    function AsyncAction(scheduler, work) {\n        _super.call(this, scheduler, work);\n        this.scheduler = scheduler;\n        this.pending = false;\n        this.work = work;\n    }\n    AsyncAction.prototype.schedule = function (state, delay) {\n        if (delay === void 0) { delay = 0; }\n        if (this.closed) {\n            return this;\n        }\n        // Always replace the current state with the new state.\n        this.state = state;\n        // Set the pending flag indicating that this action has been scheduled, or\n        // has recursively rescheduled itself.\n        this.pending = true;\n        var id = this.id;\n        var scheduler = this.scheduler;\n        //\n        // Important implementation note:\n        //\n        // Actions only execute once by default, unless rescheduled from within the\n        // scheduled callback. This allows us to implement single and repeat\n        // actions via the same code path, without adding API surface area, as well\n        // as mimic traditional recursion but across asynchronous boundaries.\n        //\n        // However, JS runtimes and timers distinguish between intervals achieved by\n        // serial `setTimeout` calls vs. a single `setInterval` call. An interval of\n        // serial `setTimeout` calls can be individually delayed, which delays\n        // scheduling the next `setTimeout`, and so on. `setInterval` attempts to\n        // guarantee the interval callback will be invoked more precisely to the\n        // interval period, regardless of load.\n        //\n        // Therefore, we use `setInterval` to schedule single and repeat actions.\n        // If the action reschedules itself with the same delay, the interval is not\n        // canceled. If the action doesn't reschedule, or reschedules with a\n        // different delay, the interval will be canceled after scheduled callback\n        // execution.\n        //\n        if (id != null) {\n            this.id = this.recycleAsyncId(scheduler, id, delay);\n        }\n        this.delay = delay;\n        // If this action has already an async Id, don't request a new one.\n        this.id = this.id || this.requestAsyncId(scheduler, this.id, delay);\n        return this;\n    };\n    AsyncAction.prototype.requestAsyncId = function (scheduler, id, delay) {\n        if (delay === void 0) { delay = 0; }\n        return root_1.root.setInterval(scheduler.flush.bind(scheduler, this), delay);\n    };\n    AsyncAction.prototype.recycleAsyncId = function (scheduler, id, delay) {\n        if (delay === void 0) { delay = 0; }\n        // If this action is rescheduled with the same delay time, don't clear the interval id.\n        if (delay !== null && this.delay === delay && this.pending === false) {\n            return id;\n        }\n        // Otherwise, if the action's delay time is different from the current delay,\n        // or the action has been rescheduled before it's executed, clear the interval id\n        return root_1.root.clearInterval(id) && undefined || undefined;\n    };\n    /**\n     * Immediately executes this action and the `work` it contains.\n     * @return {any}\n     */\n    AsyncAction.prototype.execute = function (state, delay) {\n        if (this.closed) {\n            return new Error('executing a cancelled action');\n        }\n        this.pending = false;\n        var error = this._execute(state, delay);\n        if (error) {\n            return error;\n        }\n        else if (this.pending === false && this.id != null) {\n            // Dequeue if the action didn't reschedule itself. Don't call\n            // unsubscribe(), because the action could reschedule later.\n            // For example:\n            // ```\n            // scheduler.schedule(function doWork(counter) {\n            //   /* ... I'm a busy worker bee ... */\n            //   var originalAction = this;\n            //   /* wait 100ms before rescheduling the action */\n            //   setTimeout(function () {\n            //     originalAction.schedule(counter + 1);\n            //   }, 100);\n            // }, 1000);\n            // ```\n            this.id = this.recycleAsyncId(this.scheduler, this.id, null);\n        }\n    };\n    AsyncAction.prototype._execute = function (state, delay) {\n        var errored = false;\n        var errorValue = undefined;\n        try {\n            this.work(state);\n        }\n        catch (e) {\n            errored = true;\n            errorValue = !!e && e || new Error(e);\n        }\n        if (errored) {\n            this.unsubscribe();\n            return errorValue;\n        }\n    };\n    /** @deprecated internal use only */ AsyncAction.prototype._unsubscribe = function () {\n        var id = this.id;\n        var scheduler = this.scheduler;\n        var actions = scheduler.actions;\n        var index = actions.indexOf(this);\n        this.work = null;\n        this.state = null;\n        this.pending = false;\n        this.scheduler = null;\n        if (index !== -1) {\n            actions.splice(index, 1);\n        }\n        if (id != null) {\n            this.id = this.recycleAsyncId(scheduler, id, null);\n        }\n        this.delay = null;\n    };\n    return AsyncAction;\n}(Action_1.Action));\nexports.AsyncAction = AsyncAction;\n//# sourceMappingURL=AsyncAction.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Scheduler_1 = require('../Scheduler');\nvar AsyncScheduler = (function (_super) {\n    __extends(AsyncScheduler, _super);\n    function AsyncScheduler() {\n        _super.apply(this, arguments);\n        this.actions = [];\n        /**\n         * A flag to indicate whether the Scheduler is currently executing a batch of\n         * queued actions.\n         * @type {boolean}\n         */\n        this.active = false;\n        /**\n         * An internal ID used to track the latest asynchronous task such as those\n         * coming from `setTimeout`, `setInterval`, `requestAnimationFrame`, and\n         * others.\n         * @type {any}\n         */\n        this.scheduled = undefined;\n    }\n    AsyncScheduler.prototype.flush = function (action) {\n        var actions = this.actions;\n        if (this.active) {\n            actions.push(action);\n            return;\n        }\n        var error;\n        this.active = true;\n        do {\n            if (error = action.execute(action.state, action.delay)) {\n                break;\n            }\n        } while (action = actions.shift()); // exhaust the scheduler queue\n        this.active = false;\n        if (error) {\n            while (action = actions.shift()) {\n                action.unsubscribe();\n            }\n            throw error;\n        }\n    };\n    return AsyncScheduler;\n}(Scheduler_1.Scheduler));\nexports.AsyncScheduler = AsyncScheduler;\n//# sourceMappingURL=AsyncScheduler.js.map","\"use strict\";\nvar AsyncAction_1 = require('./AsyncAction');\nvar AsyncScheduler_1 = require('./AsyncScheduler');\n/**\n *\n * Async Scheduler\n *\n * <span class=\"informal\">Schedule task as if you used setTimeout(task, duration)</span>\n *\n * `async` scheduler schedules tasks asynchronously, by putting them on the JavaScript\n * event loop queue. It is best used to delay tasks in time or to schedule tasks repeating\n * in intervals.\n *\n * If you just want to \"defer\" task, that is to perform it right after currently\n * executing synchronous code ends (commonly achieved by `setTimeout(deferredTask, 0)`),\n * better choice will be the {@link asap} scheduler.\n *\n * @example <caption>Use async scheduler to delay task</caption>\n * const task = () => console.log('it works!');\n *\n * Rx.Scheduler.async.schedule(task, 2000);\n *\n * // After 2 seconds logs:\n * // \"it works!\"\n *\n *\n * @example <caption>Use async scheduler to repeat task in intervals</caption>\n * function task(state) {\n *   console.log(state);\n *   this.schedule(state + 1, 1000); // `this` references currently executing Action,\n *                                   // which we reschedule with new state and delay\n * }\n *\n * Rx.Scheduler.async.schedule(task, 3000, 0);\n *\n * // Logs:\n * // 0 after 3s\n * // 1 after 4s\n * // 2 after 5s\n * // 3 after 6s\n *\n * @static true\n * @name async\n * @owner Scheduler\n */\nexports.async = new AsyncScheduler_1.AsyncScheduler(AsyncAction_1.AsyncAction);\n//# sourceMappingURL=async.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar OuterSubscriber_1 = require('../OuterSubscriber');\nvar subscribeToResult_1 = require('../util/subscribeToResult');\nexports.defaultThrottleConfig = {\n    leading: true,\n    trailing: false\n};\n/**\n * Emits a value from the source Observable, then ignores subsequent source\n * values for a duration determined by another Observable, then repeats this\n * process.\n *\n * <span class=\"informal\">It's like {@link throttleTime}, but the silencing\n * duration is determined by a second Observable.</span>\n *\n * <img src=\"./img/throttle.png\" width=\"100%\">\n *\n * `throttle` emits the source Observable values on the output Observable\n * when its internal timer is disabled, and ignores source values when the timer\n * is enabled. Initially, the timer is disabled. As soon as the first source\n * value arrives, it is forwarded to the output Observable, and then the timer\n * is enabled by calling the `durationSelector` function with the source value,\n * which returns the \"duration\" Observable. When the duration Observable emits a\n * value or completes, the timer is disabled, and this process repeats for the\n * next source value.\n *\n * @example <caption>Emit clicks at a rate of at most one click per second</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var result = clicks.throttle(ev => Rx.Observable.interval(1000));\n * result.subscribe(x => console.log(x));\n *\n * @see {@link audit}\n * @see {@link debounce}\n * @see {@link delayWhen}\n * @see {@link sample}\n * @see {@link throttleTime}\n *\n * @param {function(value: T): SubscribableOrPromise} durationSelector A function\n * that receives a value from the source Observable, for computing the silencing\n * duration for each source value, returned as an Observable or a Promise.\n * @param {Object} config a configuration object to define `leading` and `trailing` behavior. Defaults\n * to `{ leading: true, trailing: false }`.\n * @return {Observable<T>} An Observable that performs the throttle operation to\n * limit the rate of emissions from the source.\n * @method throttle\n * @owner Observable\n */\nfunction throttle(durationSelector, config) {\n    if (config === void 0) { config = exports.defaultThrottleConfig; }\n    return function (source) { return source.lift(new ThrottleOperator(durationSelector, config.leading, config.trailing)); };\n}\nexports.throttle = throttle;\nvar ThrottleOperator = (function () {\n    function ThrottleOperator(durationSelector, leading, trailing) {\n        this.durationSelector = durationSelector;\n        this.leading = leading;\n        this.trailing = trailing;\n    }\n    ThrottleOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new ThrottleSubscriber(subscriber, this.durationSelector, this.leading, this.trailing));\n    };\n    return ThrottleOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc\n * @ignore\n * @extends {Ignored}\n */\nvar ThrottleSubscriber = (function (_super) {\n    __extends(ThrottleSubscriber, _super);\n    function ThrottleSubscriber(destination, durationSelector, _leading, _trailing) {\n        _super.call(this, destination);\n        this.destination = destination;\n        this.durationSelector = durationSelector;\n        this._leading = _leading;\n        this._trailing = _trailing;\n        this._hasTrailingValue = false;\n    }\n    ThrottleSubscriber.prototype._next = function (value) {\n        if (this.throttled) {\n            if (this._trailing) {\n                this._hasTrailingValue = true;\n                this._trailingValue = value;\n            }\n        }\n        else {\n            var duration = this.tryDurationSelector(value);\n            if (duration) {\n                this.add(this.throttled = subscribeToResult_1.subscribeToResult(this, duration));\n            }\n            if (this._leading) {\n                this.destination.next(value);\n                if (this._trailing) {\n                    this._hasTrailingValue = true;\n                    this._trailingValue = value;\n                }\n            }\n        }\n    };\n    ThrottleSubscriber.prototype.tryDurationSelector = function (value) {\n        try {\n            return this.durationSelector(value);\n        }\n        catch (err) {\n            this.destination.error(err);\n            return null;\n        }\n    };\n    /** @deprecated internal use only */ ThrottleSubscriber.prototype._unsubscribe = function () {\n        var _a = this, throttled = _a.throttled, _trailingValue = _a._trailingValue, _hasTrailingValue = _a._hasTrailingValue, _trailing = _a._trailing;\n        this._trailingValue = null;\n        this._hasTrailingValue = false;\n        if (throttled) {\n            this.remove(throttled);\n            this.throttled = null;\n            throttled.unsubscribe();\n        }\n    };\n    ThrottleSubscriber.prototype._sendTrailing = function () {\n        var _a = this, destination = _a.destination, throttled = _a.throttled, _trailing = _a._trailing, _trailingValue = _a._trailingValue, _hasTrailingValue = _a._hasTrailingValue;\n        if (throttled && _trailing && _hasTrailingValue) {\n            destination.next(_trailingValue);\n            this._trailingValue = null;\n            this._hasTrailingValue = false;\n        }\n    };\n    ThrottleSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {\n        this._sendTrailing();\n        this._unsubscribe();\n    };\n    ThrottleSubscriber.prototype.notifyComplete = function () {\n        this._sendTrailing();\n        this._unsubscribe();\n    };\n    return ThrottleSubscriber;\n}(OuterSubscriber_1.OuterSubscriber));\n//# sourceMappingURL=throttle.js.map","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nexport default freeGlobal;\n","\"use strict\";\nvar AnimationFrameAction_1 = require('./AnimationFrameAction');\nvar AnimationFrameScheduler_1 = require('./AnimationFrameScheduler');\n/**\n *\n * Animation Frame Scheduler\n *\n * <span class=\"informal\">Perform task when `window.requestAnimationFrame` would fire</span>\n *\n * When `animationFrame` scheduler is used with delay, it will fall back to {@link async} scheduler\n * behaviour.\n *\n * Without delay, `animationFrame` scheduler can be used to create smooth browser animations.\n * It makes sure scheduled task will happen just before next browser content repaint,\n * thus performing animations as efficiently as possible.\n *\n * @example <caption>Schedule div height animation</caption>\n * const div = document.querySelector('.some-div');\n *\n * Rx.Scheduler.schedule(function(height) {\n *   div.style.height = height + \"px\";\n *\n *   this.schedule(height + 1);  // `this` references currently executing Action,\n *                               // which we reschedule with new state\n * }, 0, 0);\n *\n * // You will see .some-div element growing in height\n *\n *\n * @static true\n * @name animationFrame\n * @owner Scheduler\n */\nexports.animationFrame = new AnimationFrameScheduler_1.AnimationFrameScheduler(AnimationFrameAction_1.AnimationFrameAction);\n//# sourceMappingURL=animationFrame.js.map","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\nexport default isObject;\n","import freeGlobal from './_freeGlobal.js';\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nexport default root;\n","import root from './_root.js';\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\nexport default now;\n","import root from './_root.js';\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nexport default Symbol;\n","import Symbol from './_Symbol.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\nexport default getRawTag;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\nexport default objectToString;\n","import Symbol from './_Symbol.js';\nimport getRawTag from './_getRawTag.js';\nimport objectToString from './_objectToString.js';\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n    undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\nexport default baseGetTag;\n","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\nexport default isObjectLike;\n","import baseGetTag from './_baseGetTag.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && baseGetTag(value) == symbolTag);\n}\n\nexport default isSymbol;\n","import isObject from './isObject.js';\nimport isSymbol from './isSymbol.js';\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = value.replace(reTrim, '');\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nexport default toNumber;\n","import isObject from './isObject.js';\nimport now from './now.js';\nimport toNumber from './toNumber.js';\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        timeWaiting = wait - timeSinceLastCall;\n\n    return maxing\n      ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)\n      : timeWaiting;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        clearTimeout(timerId);\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\nexport default debounce;\n","import debounce from './debounce.js';\nimport isObject from './isObject.js';\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a throttled function that only invokes `func` at most once per\n * every `wait` milliseconds. The throttled function comes with a `cancel`\n * method to cancel delayed `func` invocations and a `flush` method to\n * immediately invoke them. Provide `options` to indicate whether `func`\n * should be invoked on the leading and/or trailing edge of the `wait`\n * timeout. The `func` is invoked with the last arguments provided to the\n * throttled function. Subsequent calls to the throttled function return the\n * result of the last `func` invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the throttled function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.throttle` and `_.debounce`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to throttle.\n * @param {number} [wait=0] The number of milliseconds to throttle invocations to.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=true]\n *  Specify invoking on the leading edge of the timeout.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new throttled function.\n * @example\n *\n * // Avoid excessively updating the position while scrolling.\n * jQuery(window).on('scroll', _.throttle(updatePosition, 100));\n *\n * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.\n * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });\n * jQuery(element).on('click', throttled);\n *\n * // Cancel the trailing throttled invocation.\n * jQuery(window).on('popstate', throttled.cancel);\n */\nfunction throttle(func, wait, options) {\n  var leading = true,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  if (isObject(options)) {\n    leading = 'leading' in options ? !!options.leading : leading;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n  return debounce(func, wait, {\n    'leading': leading,\n    'maxWait': wait,\n    'trailing': trailing\n  });\n}\n\nexport default throttle;\n","\"use strict\";\nvar Subscriber_1 = require('../Subscriber');\nvar rxSubscriber_1 = require('../symbol/rxSubscriber');\nvar Observer_1 = require('../Observer');\nfunction toSubscriber(nextOrObserver, error, complete) {\n    if (nextOrObserver) {\n        if (nextOrObserver instanceof Subscriber_1.Subscriber) {\n            return nextOrObserver;\n        }\n        if (nextOrObserver[rxSubscriber_1.rxSubscriber]) {\n            return nextOrObserver[rxSubscriber_1.rxSubscriber]();\n        }\n    }\n    if (!nextOrObserver && !error && !complete) {\n        return new Subscriber_1.Subscriber(Observer_1.empty);\n    }\n    return new Subscriber_1.Subscriber(nextOrObserver, error, complete);\n}\nexports.toSubscriber = toSubscriber;\n//# sourceMappingURL=toSubscriber.js.map","\"use strict\";\nexports.isArray = Array.isArray || (function (x) { return x && typeof x.length === 'number'; });\n//# sourceMappingURL=isArray.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\n/**\n * An error thrown when one or more errors have occurred during the\n * `unsubscribe` of a {@link Subscription}.\n */\nvar UnsubscriptionError = (function (_super) {\n    __extends(UnsubscriptionError, _super);\n    function UnsubscriptionError(errors) {\n        _super.call(this);\n        this.errors = errors;\n        var err = Error.call(this, errors ?\n            errors.length + \" errors occurred during unsubscription:\\n  \" + errors.map(function (err, i) { return ((i + 1) + \") \" + err.toString()); }).join('\\n  ') : '');\n        this.name = err.name = 'UnsubscriptionError';\n        this.stack = err.stack;\n        this.message = err.message;\n    }\n    return UnsubscriptionError;\n}(Error));\nexports.UnsubscriptionError = UnsubscriptionError;\n//# sourceMappingURL=UnsubscriptionError.js.map","\"use strict\";\nvar noop_1 = require('./noop');\n/* tslint:enable:max-line-length */\nfunction pipe() {\n    var fns = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        fns[_i - 0] = arguments[_i];\n    }\n    return pipeFromArray(fns);\n}\nexports.pipe = pipe;\n/* @internal */\nfunction pipeFromArray(fns) {\n    if (!fns) {\n        return noop_1.noop;\n    }\n    if (fns.length === 1) {\n        return fns[0];\n    }\n    return function piped(input) {\n        return fns.reduce(function (prev, fn) { return fn(prev); }, input);\n    };\n}\nexports.pipeFromArray = pipeFromArray;\n//# sourceMappingURL=pipe.js.map","\"use strict\";\n/* tslint:disable:no-empty */\nfunction noop() { }\nexports.noop = noop;\n//# sourceMappingURL=noop.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar AsyncAction_1 = require('./AsyncAction');\nvar AnimationFrame_1 = require('../util/AnimationFrame');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar AnimationFrameAction = (function (_super) {\n    __extends(AnimationFrameAction, _super);\n    function AnimationFrameAction(scheduler, work) {\n        _super.call(this, scheduler, work);\n        this.scheduler = scheduler;\n        this.work = work;\n    }\n    AnimationFrameAction.prototype.requestAsyncId = function (scheduler, id, delay) {\n        if (delay === void 0) { delay = 0; }\n        // If delay is greater than 0, request as an async action.\n        if (delay !== null && delay > 0) {\n            return _super.prototype.requestAsyncId.call(this, scheduler, id, delay);\n        }\n        // Push the action to the end of the scheduler queue.\n        scheduler.actions.push(this);\n        // If an animation frame has already been requested, don't request another\n        // one. If an animation frame hasn't been requested yet, request one. Return\n        // the current animation frame request id.\n        return scheduler.scheduled || (scheduler.scheduled = AnimationFrame_1.AnimationFrame.requestAnimationFrame(scheduler.flush.bind(scheduler, null)));\n    };\n    AnimationFrameAction.prototype.recycleAsyncId = function (scheduler, id, delay) {\n        if (delay === void 0) { delay = 0; }\n        // If delay exists and is greater than 0, or if the delay is null (the\n        // action wasn't rescheduled) but was originally scheduled as an async\n        // action, then recycle as an async action.\n        if ((delay !== null && delay > 0) || (delay === null && this.delay > 0)) {\n            return _super.prototype.recycleAsyncId.call(this, scheduler, id, delay);\n        }\n        // If the scheduler queue is empty, cancel the requested animation frame and\n        // set the scheduled flag to undefined so the next AnimationFrameAction will\n        // request its own.\n        if (scheduler.actions.length === 0) {\n            AnimationFrame_1.AnimationFrame.cancelAnimationFrame(id);\n            scheduler.scheduled = undefined;\n        }\n        // Return undefined so the action knows to request a new async id if it's rescheduled.\n        return undefined;\n    };\n    return AnimationFrameAction;\n}(AsyncAction_1.AsyncAction));\nexports.AnimationFrameAction = AnimationFrameAction;\n//# sourceMappingURL=AnimationFrameAction.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscription_1 = require('../Subscription');\n/**\n * A unit of work to be executed in a {@link Scheduler}. An action is typically\n * created from within a Scheduler and an RxJS user does not need to concern\n * themselves about creating and manipulating an Action.\n *\n * ```ts\n * class Action<T> extends Subscription {\n *   new (scheduler: Scheduler, work: (state?: T) => void);\n *   schedule(state?: T, delay: number = 0): Subscription;\n * }\n * ```\n *\n * @class Action<T>\n */\nvar Action = (function (_super) {\n    __extends(Action, _super);\n    function Action(scheduler, work) {\n        _super.call(this);\n    }\n    /**\n     * Schedules this action on its parent Scheduler for execution. May be passed\n     * some context object, `state`. May happen at some point in the future,\n     * according to the `delay` parameter, if specified.\n     * @param {T} [state] Some contextual data that the `work` function uses when\n     * called by the Scheduler.\n     * @param {number} [delay] Time to wait before executing the work, where the\n     * time unit is implicit and defined by the Scheduler.\n     * @return {void}\n     */\n    Action.prototype.schedule = function (state, delay) {\n        if (delay === void 0) { delay = 0; }\n        return this;\n    };\n    return Action;\n}(Subscription_1.Subscription));\nexports.Action = Action;\n//# sourceMappingURL=Action.js.map","\"use strict\";\nvar root_1 = require('./root');\nvar RequestAnimationFrameDefinition = (function () {\n    function RequestAnimationFrameDefinition(root) {\n        if (root.requestAnimationFrame) {\n            this.cancelAnimationFrame = root.cancelAnimationFrame.bind(root);\n            this.requestAnimationFrame = root.requestAnimationFrame.bind(root);\n        }\n        else if (root.mozRequestAnimationFrame) {\n            this.cancelAnimationFrame = root.mozCancelAnimationFrame.bind(root);\n            this.requestAnimationFrame = root.mozRequestAnimationFrame.bind(root);\n        }\n        else if (root.webkitRequestAnimationFrame) {\n            this.cancelAnimationFrame = root.webkitCancelAnimationFrame.bind(root);\n            this.requestAnimationFrame = root.webkitRequestAnimationFrame.bind(root);\n        }\n        else if (root.msRequestAnimationFrame) {\n            this.cancelAnimationFrame = root.msCancelAnimationFrame.bind(root);\n            this.requestAnimationFrame = root.msRequestAnimationFrame.bind(root);\n        }\n        else if (root.oRequestAnimationFrame) {\n            this.cancelAnimationFrame = root.oCancelAnimationFrame.bind(root);\n            this.requestAnimationFrame = root.oRequestAnimationFrame.bind(root);\n        }\n        else {\n            this.cancelAnimationFrame = root.clearTimeout.bind(root);\n            this.requestAnimationFrame = function (cb) { return root.setTimeout(cb, 1000 / 60); };\n        }\n    }\n    return RequestAnimationFrameDefinition;\n}());\nexports.RequestAnimationFrameDefinition = RequestAnimationFrameDefinition;\nexports.AnimationFrame = new RequestAnimationFrameDefinition(root_1.root);\n//# sourceMappingURL=AnimationFrame.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar AsyncScheduler_1 = require('./AsyncScheduler');\nvar AnimationFrameScheduler = (function (_super) {\n    __extends(AnimationFrameScheduler, _super);\n    function AnimationFrameScheduler() {\n        _super.apply(this, arguments);\n    }\n    AnimationFrameScheduler.prototype.flush = function (action) {\n        this.active = true;\n        this.scheduled = undefined;\n        var actions = this.actions;\n        var error;\n        var index = -1;\n        var count = actions.length;\n        action = action || actions.shift();\n        do {\n            if (error = action.execute(action.state, action.delay)) {\n                break;\n            }\n        } while (++index < count && (action = actions.shift()));\n        this.active = false;\n        if (error) {\n            while (++index < count && (action = actions.shift())) {\n                action.unsubscribe();\n            }\n            throw error;\n        }\n    };\n    return AnimationFrameScheduler;\n}(AsyncScheduler_1.AsyncScheduler));\nexports.AnimationFrameScheduler = AnimationFrameScheduler;\n//# sourceMappingURL=AnimationFrameScheduler.js.map","\"use strict\";\n/**\n * An execution context and a data structure to order tasks and schedule their\n * execution. Provides a notion of (potentially virtual) time, through the\n * `now()` getter method.\n *\n * Each unit of work in a Scheduler is called an {@link Action}.\n *\n * ```ts\n * class Scheduler {\n *   now(): number;\n *   schedule(work, delay?, state?): Subscription;\n * }\n * ```\n *\n * @class Scheduler\n */\nvar Scheduler = (function () {\n    function Scheduler(SchedulerAction, now) {\n        if (now === void 0) { now = Scheduler.now; }\n        this.SchedulerAction = SchedulerAction;\n        this.now = now;\n    }\n    /**\n     * Schedules a function, `work`, for execution. May happen at some point in\n     * the future, according to the `delay` parameter, if specified. May be passed\n     * some context object, `state`, which will be passed to the `work` function.\n     *\n     * The given arguments will be processed an stored as an Action object in a\n     * queue of actions.\n     *\n     * @param {function(state: ?T): ?Subscription} work A function representing a\n     * task, or some unit of work to be executed by the Scheduler.\n     * @param {number} [delay] Time to wait before executing the work, where the\n     * time unit is implicit and defined by the Scheduler itself.\n     * @param {T} [state] Some contextual data that the `work` function uses when\n     * called by the Scheduler.\n     * @return {Subscription} A subscription in order to be able to unsubscribe\n     * the scheduled work.\n     */\n    Scheduler.prototype.schedule = function (work, delay, state) {\n        if (delay === void 0) { delay = 0; }\n        return new this.SchedulerAction(this, work).schedule(state, delay);\n    };\n    Scheduler.now = Date.now ? Date.now : function () { return +new Date(); };\n    return Scheduler;\n}());\nexports.Scheduler = Scheduler;\n//# sourceMappingURL=Scheduler.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar fromEvent_1 = require('../../observable/fromEvent');\nObservable_1.Observable.fromEvent = fromEvent_1.fromEvent;\n//# sourceMappingURL=fromEvent.js.map","\"use strict\";\nvar FromEventObservable_1 = require('./FromEventObservable');\nexports.fromEvent = FromEventObservable_1.FromEventObservable.create;\n//# sourceMappingURL=fromEvent.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Observable_1 = require('../Observable');\nvar tryCatch_1 = require('../util/tryCatch');\nvar isFunction_1 = require('../util/isFunction');\nvar errorObject_1 = require('../util/errorObject');\nvar Subscription_1 = require('../Subscription');\nvar toString = Object.prototype.toString;\nfunction isNodeStyleEventEmitter(sourceObj) {\n    return !!sourceObj && typeof sourceObj.addListener === 'function' && typeof sourceObj.removeListener === 'function';\n}\nfunction isJQueryStyleEventEmitter(sourceObj) {\n    return !!sourceObj && typeof sourceObj.on === 'function' && typeof sourceObj.off === 'function';\n}\nfunction isNodeList(sourceObj) {\n    return !!sourceObj && toString.call(sourceObj) === '[object NodeList]';\n}\nfunction isHTMLCollection(sourceObj) {\n    return !!sourceObj && toString.call(sourceObj) === '[object HTMLCollection]';\n}\nfunction isEventTarget(sourceObj) {\n    return !!sourceObj && typeof sourceObj.addEventListener === 'function' && typeof sourceObj.removeEventListener === 'function';\n}\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @extends {Ignored}\n * @hide true\n */\nvar FromEventObservable = (function (_super) {\n    __extends(FromEventObservable, _super);\n    function FromEventObservable(sourceObj, eventName, selector, options) {\n        _super.call(this);\n        this.sourceObj = sourceObj;\n        this.eventName = eventName;\n        this.selector = selector;\n        this.options = options;\n    }\n    /* tslint:enable:max-line-length */\n    /**\n     * Creates an Observable that emits events of a specific type coming from the\n     * given event target.\n     *\n     * <span class=\"informal\">Creates an Observable from DOM events, or Node.js\n     * EventEmitter events or others.</span>\n     *\n     * <img src=\"./img/fromEvent.png\" width=\"100%\">\n     *\n     * `fromEvent` accepts as a first argument event target, which is an object with methods\n     * for registering event handler functions. As a second argument it takes string that indicates\n     * type of event we want to listen for. `fromEvent` supports selected types of event targets,\n     * which are described in detail below. If your event target does not match any of the ones listed,\n     * you should use {@link fromEventPattern}, which can be used on arbitrary APIs.\n     * When it comes to APIs supported by `fromEvent`, their methods for adding and removing event\n     * handler functions have different names, but they all accept a string describing event type\n     * and function itself, which will be called whenever said event happens.\n     *\n     * Every time resulting Observable is subscribed, event handler function will be registered\n     * to event target on given event type. When that event fires, value\n     * passed as a first argument to registered function will be emitted by output Observable.\n     * When Observable is unsubscribed, function will be unregistered from event target.\n     *\n     * Note that if event target calls registered function with more than one argument, second\n     * and following arguments will not appear in resulting stream. In order to get access to them,\n     * you can pass to `fromEvent` optional project function, which will be called with all arguments\n     * passed to event handler. Output Observable will then emit value returned by project function,\n     * instead of the usual value.\n     *\n     * Remember that event targets listed below are checked via duck typing. It means that\n     * no matter what kind of object you have and no matter what environment you work in,\n     * you can safely use `fromEvent` on that object if it exposes described methods (provided\n     * of course they behave as was described above). So for example if Node.js library exposes\n     * event target which has the same method names as DOM EventTarget, `fromEvent` is still\n     * a good choice.\n     *\n     * If the API you use is more callback then event handler oriented (subscribed\n     * callback function fires only once and thus there is no need to manually\n     * unregister it), you should use {@link bindCallback} or {@link bindNodeCallback}\n     * instead.\n     *\n     * `fromEvent` supports following types of event targets:\n     *\n     * **DOM EventTarget**\n     *\n     * This is an object with `addEventListener` and `removeEventListener` methods.\n     *\n     * In the browser, `addEventListener` accepts - apart from event type string and event\n     * handler function arguments - optional third parameter, which is either an object or boolean,\n     * both used for additional configuration how and when passed function will be called. When\n     * `fromEvent` is used with event target of that type, you can provide this values\n     * as third parameter as well.\n     *\n     * **Node.js EventEmitter**\n     *\n     * An object with `addListener` and `removeListener` methods.\n     *\n     * **JQuery-style event target**\n     *\n     * An object with `on` and `off` methods\n     *\n     * **DOM NodeList**\n     *\n     * List of DOM Nodes, returned for example by `document.querySelectorAll` or `Node.childNodes`.\n     *\n     * Although this collection is not event target in itself, `fromEvent` will iterate over all Nodes\n     * it contains and install event handler function in every of them. When returned Observable\n     * is unsubscribed, function will be removed from all Nodes.\n     *\n     * **DOM HtmlCollection**\n     *\n     * Just as in case of NodeList it is a collection of DOM nodes. Here as well event handler function is\n     * installed and removed in each of elements.\n     *\n     *\n     * @example <caption>Emits clicks happening on the DOM document</caption>\n     * var clicks = Rx.Observable.fromEvent(document, 'click');\n     * clicks.subscribe(x => console.log(x));\n     *\n     * // Results in:\n     * // MouseEvent object logged to console every time a click\n     * // occurs on the document.\n     *\n     *\n     * @example <caption>Use addEventListener with capture option</caption>\n     * var clicksInDocument = Rx.Observable.fromEvent(document, 'click', true); // note optional configuration parameter\n     *                                                                          // which will be passed to addEventListener\n     * var clicksInDiv = Rx.Observable.fromEvent(someDivInDocument, 'click');\n     *\n     * clicksInDocument.subscribe(() => console.log('document'));\n     * clicksInDiv.subscribe(() => console.log('div'));\n     *\n     * // By default events bubble UP in DOM tree, so normally\n     * // when we would click on div in document\n     * // \"div\" would be logged first and then \"document\".\n     * // Since we specified optional `capture` option, document\n     * // will catch event when it goes DOWN DOM tree, so console\n     * // will log \"document\" and then \"div\".\n     *\n     * @see {@link bindCallback}\n     * @see {@link bindNodeCallback}\n     * @see {@link fromEventPattern}\n     *\n     * @param {EventTargetLike} target The DOM EventTarget, Node.js\n     * EventEmitter, JQuery-like event target, NodeList or HTMLCollection to attach the event handler to.\n     * @param {string} eventName The event name of interest, being emitted by the\n     * `target`.\n     * @param {EventListenerOptions} [options] Options to pass through to addEventListener\n     * @param {SelectorMethodSignature<T>} [selector] An optional function to\n     * post-process results. It takes the arguments from the event handler and\n     * should return a single value.\n     * @return {Observable<T>}\n     * @static true\n     * @name fromEvent\n     * @owner Observable\n     */\n    FromEventObservable.create = function (target, eventName, options, selector) {\n        if (isFunction_1.isFunction(options)) {\n            selector = options;\n            options = undefined;\n        }\n        return new FromEventObservable(target, eventName, selector, options);\n    };\n    FromEventObservable.setupSubscription = function (sourceObj, eventName, handler, subscriber, options) {\n        var unsubscribe;\n        if (isNodeList(sourceObj) || isHTMLCollection(sourceObj)) {\n            for (var i = 0, len = sourceObj.length; i < len; i++) {\n                FromEventObservable.setupSubscription(sourceObj[i], eventName, handler, subscriber, options);\n            }\n        }\n        else if (isEventTarget(sourceObj)) {\n            var source_1 = sourceObj;\n            sourceObj.addEventListener(eventName, handler, options);\n            unsubscribe = function () { return source_1.removeEventListener(eventName, handler, options); };\n        }\n        else if (isJQueryStyleEventEmitter(sourceObj)) {\n            var source_2 = sourceObj;\n            sourceObj.on(eventName, handler);\n            unsubscribe = function () { return source_2.off(eventName, handler); };\n        }\n        else if (isNodeStyleEventEmitter(sourceObj)) {\n            var source_3 = sourceObj;\n            sourceObj.addListener(eventName, handler);\n            unsubscribe = function () { return source_3.removeListener(eventName, handler); };\n        }\n        else {\n            throw new TypeError('Invalid event target');\n        }\n        subscriber.add(new Subscription_1.Subscription(unsubscribe));\n    };\n    /** @deprecated internal use only */ FromEventObservable.prototype._subscribe = function (subscriber) {\n        var sourceObj = this.sourceObj;\n        var eventName = this.eventName;\n        var options = this.options;\n        var selector = this.selector;\n        var handler = selector ? function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i - 0] = arguments[_i];\n            }\n            var result = tryCatch_1.tryCatch(selector).apply(void 0, args);\n            if (result === errorObject_1.errorObject) {\n                subscriber.error(errorObject_1.errorObject.e);\n            }\n            else {\n                subscriber.next(result);\n            }\n        } : function (e) { return subscriber.next(e); };\n        FromEventObservable.setupSubscription(sourceObj, eventName, handler, subscriber, options);\n    };\n    return FromEventObservable;\n}(Observable_1.Observable));\nexports.FromEventObservable = FromEventObservable;\n//# sourceMappingURL=FromEventObservable.js.map","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar throttleTime_1 = require('../../operator/throttleTime');\nObservable_1.Observable.prototype.throttleTime = throttleTime_1.throttleTime;\n//# sourceMappingURL=throttleTime.js.map","\"use strict\";\nvar async_1 = require('../scheduler/async');\nvar throttle_1 = require('../operators/throttle');\nvar throttleTime_1 = require('../operators/throttleTime');\n/**\n * Emits a value from the source Observable, then ignores subsequent source\n * values for `duration` milliseconds, then repeats this process.\n *\n * <span class=\"informal\">Lets a value pass, then ignores source values for the\n * next `duration` milliseconds.</span>\n *\n * <img src=\"./img/throttleTime.png\" width=\"100%\">\n *\n * `throttleTime` emits the source Observable values on the output Observable\n * when its internal timer is disabled, and ignores source values when the timer\n * is enabled. Initially, the timer is disabled. As soon as the first source\n * value arrives, it is forwarded to the output Observable, and then the timer\n * is enabled. After `duration` milliseconds (or the time unit determined\n * internally by the optional `scheduler`) has passed, the timer is disabled,\n * and this process repeats for the next source value. Optionally takes a\n * {@link IScheduler} for managing timers.\n *\n * @example <caption>Emit clicks at a rate of at most one click per second</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var result = clicks.throttleTime(1000);\n * result.subscribe(x => console.log(x));\n *\n * @see {@link auditTime}\n * @see {@link debounceTime}\n * @see {@link delay}\n * @see {@link sampleTime}\n * @see {@link throttle}\n *\n * @param {number} duration Time to wait before emitting another value after\n * emitting the last value, measured in milliseconds or the time unit determined\n * internally by the optional `scheduler`.\n * @param {Scheduler} [scheduler=async] The {@link IScheduler} to use for\n * managing the timers that handle the throttling.\n * @return {Observable<T>} An Observable that performs the throttle operation to\n * limit the rate of emissions from the source.\n * @method throttleTime\n * @owner Observable\n */\nfunction throttleTime(duration, scheduler, config) {\n    if (scheduler === void 0) { scheduler = async_1.async; }\n    if (config === void 0) { config = throttle_1.defaultThrottleConfig; }\n    return throttleTime_1.throttleTime(duration, scheduler, config)(this);\n}\nexports.throttleTime = throttleTime;\n//# sourceMappingURL=throttleTime.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('./Subscriber');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar OuterSubscriber = (function (_super) {\n    __extends(OuterSubscriber, _super);\n    function OuterSubscriber() {\n        _super.apply(this, arguments);\n    }\n    OuterSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {\n        this.destination.next(innerValue);\n    };\n    OuterSubscriber.prototype.notifyError = function (error, innerSub) {\n        this.destination.error(error);\n    };\n    OuterSubscriber.prototype.notifyComplete = function (innerSub) {\n        this.destination.complete();\n    };\n    return OuterSubscriber;\n}(Subscriber_1.Subscriber));\nexports.OuterSubscriber = OuterSubscriber;\n//# sourceMappingURL=OuterSubscriber.js.map","\"use strict\";\nvar root_1 = require('./root');\nvar isArrayLike_1 = require('./isArrayLike');\nvar isPromise_1 = require('./isPromise');\nvar isObject_1 = require('./isObject');\nvar Observable_1 = require('../Observable');\nvar iterator_1 = require('../symbol/iterator');\nvar InnerSubscriber_1 = require('../InnerSubscriber');\nvar observable_1 = require('../symbol/observable');\nfunction subscribeToResult(outerSubscriber, result, outerValue, outerIndex) {\n    var destination = new InnerSubscriber_1.InnerSubscriber(outerSubscriber, outerValue, outerIndex);\n    if (destination.closed) {\n        return null;\n    }\n    if (result instanceof Observable_1.Observable) {\n        if (result._isScalar) {\n            destination.next(result.value);\n            destination.complete();\n            return null;\n        }\n        else {\n            destination.syncErrorThrowable = true;\n            return result.subscribe(destination);\n        }\n    }\n    else if (isArrayLike_1.isArrayLike(result)) {\n        for (var i = 0, len = result.length; i < len && !destination.closed; i++) {\n            destination.next(result[i]);\n        }\n        if (!destination.closed) {\n            destination.complete();\n        }\n    }\n    else if (isPromise_1.isPromise(result)) {\n        result.then(function (value) {\n            if (!destination.closed) {\n                destination.next(value);\n                destination.complete();\n            }\n        }, function (err) { return destination.error(err); })\n            .then(null, function (err) {\n            // Escaping the Promise trap: globally throw unhandled errors\n            root_1.root.setTimeout(function () { throw err; });\n        });\n        return destination;\n    }\n    else if (result && typeof result[iterator_1.iterator] === 'function') {\n        var iterator = result[iterator_1.iterator]();\n        do {\n            var item = iterator.next();\n            if (item.done) {\n                destination.complete();\n                break;\n            }\n            destination.next(item.value);\n            if (destination.closed) {\n                break;\n            }\n        } while (true);\n    }\n    else if (result && typeof result[observable_1.observable] === 'function') {\n        var obs = result[observable_1.observable]();\n        if (typeof obs.subscribe !== 'function') {\n            destination.error(new TypeError('Provided object does not correctly implement Symbol.observable'));\n        }\n        else {\n            return obs.subscribe(new InnerSubscriber_1.InnerSubscriber(outerSubscriber, outerValue, outerIndex));\n        }\n    }\n    else {\n        var value = isObject_1.isObject(result) ? 'an invalid object' : \"'\" + result + \"'\";\n        var msg = (\"You provided \" + value + \" where a stream was expected.\")\n            + ' You can provide an Observable, Promise, Array, or Iterable.';\n        destination.error(new TypeError(msg));\n    }\n    return null;\n}\nexports.subscribeToResult = subscribeToResult;\n//# sourceMappingURL=subscribeToResult.js.map","\"use strict\";\nexports.isArrayLike = (function (x) { return x && typeof x.length === 'number'; });\n//# sourceMappingURL=isArrayLike.js.map","\"use strict\";\nfunction isPromise(value) {\n    return value && typeof value.subscribe !== 'function' && typeof value.then === 'function';\n}\nexports.isPromise = isPromise;\n//# sourceMappingURL=isPromise.js.map","\"use strict\";\nvar root_1 = require('../util/root');\nfunction symbolIteratorPonyfill(root) {\n    var Symbol = root.Symbol;\n    if (typeof Symbol === 'function') {\n        if (!Symbol.iterator) {\n            Symbol.iterator = Symbol('iterator polyfill');\n        }\n        return Symbol.iterator;\n    }\n    else {\n        // [for Mozilla Gecko 27-35:](https://mzl.la/2ewE1zC)\n        var Set_1 = root.Set;\n        if (Set_1 && typeof new Set_1()['@@iterator'] === 'function') {\n            return '@@iterator';\n        }\n        var Map_1 = root.Map;\n        // required for compatability with es6-shim\n        if (Map_1) {\n            var keys = Object.getOwnPropertyNames(Map_1.prototype);\n            for (var i = 0; i < keys.length; ++i) {\n                var key = keys[i];\n                // according to spec, Map.prototype[@@iterator] and Map.orototype.entries must be equal.\n                if (key !== 'entries' && key !== 'size' && Map_1.prototype[key] === Map_1.prototype['entries']) {\n                    return key;\n                }\n            }\n        }\n        return '@@iterator';\n    }\n}\nexports.symbolIteratorPonyfill = symbolIteratorPonyfill;\nexports.iterator = symbolIteratorPonyfill(root_1.root);\n/**\n * @deprecated use iterator instead\n */\nexports.$$iterator = exports.iterator;\n//# sourceMappingURL=iterator.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('./Subscriber');\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar InnerSubscriber = (function (_super) {\n    __extends(InnerSubscriber, _super);\n    function InnerSubscriber(parent, outerValue, outerIndex) {\n        _super.call(this);\n        this.parent = parent;\n        this.outerValue = outerValue;\n        this.outerIndex = outerIndex;\n        this.index = 0;\n    }\n    InnerSubscriber.prototype._next = function (value) {\n        this.parent.notifyNext(this.outerValue, value, this.outerIndex, this.index++, this);\n    };\n    InnerSubscriber.prototype._error = function (error) {\n        this.parent.notifyError(error, this);\n        this.unsubscribe();\n    };\n    InnerSubscriber.prototype._complete = function () {\n        this.parent.notifyComplete(this);\n        this.unsubscribe();\n    };\n    return InnerSubscriber;\n}(Subscriber_1.Subscriber));\nexports.InnerSubscriber = InnerSubscriber;\n//# sourceMappingURL=InnerSubscriber.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || function (d, b) {\n    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n    function __() { this.constructor = d; }\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = require('../Subscriber');\nvar async_1 = require('../scheduler/async');\nvar throttle_1 = require('./throttle');\n/**\n * Emits a value from the source Observable, then ignores subsequent source\n * values for `duration` milliseconds, then repeats this process.\n *\n * <span class=\"informal\">Lets a value pass, then ignores source values for the\n * next `duration` milliseconds.</span>\n *\n * <img src=\"./img/throttleTime.png\" width=\"100%\">\n *\n * `throttleTime` emits the source Observable values on the output Observable\n * when its internal timer is disabled, and ignores source values when the timer\n * is enabled. Initially, the timer is disabled. As soon as the first source\n * value arrives, it is forwarded to the output Observable, and then the timer\n * is enabled. After `duration` milliseconds (or the time unit determined\n * internally by the optional `scheduler`) has passed, the timer is disabled,\n * and this process repeats for the next source value. Optionally takes a\n * {@link IScheduler} for managing timers.\n *\n * @example <caption>Emit clicks at a rate of at most one click per second</caption>\n * var clicks = Rx.Observable.fromEvent(document, 'click');\n * var result = clicks.throttleTime(1000);\n * result.subscribe(x => console.log(x));\n *\n * @see {@link auditTime}\n * @see {@link debounceTime}\n * @see {@link delay}\n * @see {@link sampleTime}\n * @see {@link throttle}\n *\n * @param {number} duration Time to wait before emitting another value after\n * emitting the last value, measured in milliseconds or the time unit determined\n * internally by the optional `scheduler`.\n * @param {Scheduler} [scheduler=async] The {@link IScheduler} to use for\n * managing the timers that handle the throttling.\n * @return {Observable<T>} An Observable that performs the throttle operation to\n * limit the rate of emissions from the source.\n * @method throttleTime\n * @owner Observable\n */\nfunction throttleTime(duration, scheduler, config) {\n    if (scheduler === void 0) { scheduler = async_1.async; }\n    if (config === void 0) { config = throttle_1.defaultThrottleConfig; }\n    return function (source) { return source.lift(new ThrottleTimeOperator(duration, scheduler, config.leading, config.trailing)); };\n}\nexports.throttleTime = throttleTime;\nvar ThrottleTimeOperator = (function () {\n    function ThrottleTimeOperator(duration, scheduler, leading, trailing) {\n        this.duration = duration;\n        this.scheduler = scheduler;\n        this.leading = leading;\n        this.trailing = trailing;\n    }\n    ThrottleTimeOperator.prototype.call = function (subscriber, source) {\n        return source.subscribe(new ThrottleTimeSubscriber(subscriber, this.duration, this.scheduler, this.leading, this.trailing));\n    };\n    return ThrottleTimeOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar ThrottleTimeSubscriber = (function (_super) {\n    __extends(ThrottleTimeSubscriber, _super);\n    function ThrottleTimeSubscriber(destination, duration, scheduler, leading, trailing) {\n        _super.call(this, destination);\n        this.duration = duration;\n        this.scheduler = scheduler;\n        this.leading = leading;\n        this.trailing = trailing;\n        this._hasTrailingValue = false;\n        this._trailingValue = null;\n    }\n    ThrottleTimeSubscriber.prototype._next = function (value) {\n        if (this.throttled) {\n            if (this.trailing) {\n                this._trailingValue = value;\n                this._hasTrailingValue = true;\n            }\n        }\n        else {\n            this.add(this.throttled = this.scheduler.schedule(dispatchNext, this.duration, { subscriber: this }));\n            if (this.leading) {\n                this.destination.next(value);\n            }\n        }\n    };\n    ThrottleTimeSubscriber.prototype.clearThrottle = function () {\n        var throttled = this.throttled;\n        if (throttled) {\n            if (this.trailing && this._hasTrailingValue) {\n                this.destination.next(this._trailingValue);\n                this._trailingValue = null;\n                this._hasTrailingValue = false;\n            }\n            throttled.unsubscribe();\n            this.remove(throttled);\n            this.throttled = null;\n        }\n    };\n    return ThrottleTimeSubscriber;\n}(Subscriber_1.Subscriber));\nfunction dispatchNext(arg) {\n    var subscriber = arg.subscriber;\n    subscriber.clearThrottle();\n}\n//# sourceMappingURL=throttleTime.js.map"],"sourceRoot":""}