-
Notifications
You must be signed in to change notification settings - Fork 2
/
tests.js.map
1 lines (1 loc) · 319 KB
/
tests.js.map
1
{"version":3,"sources":["webpack:///webpack/bootstrap 56cc3c0b9a05b4eb7623?e92f","webpack:///./src/tests.js","webpack:///./src/index.js?9552","webpack:///./src/Structure.js?d427","webpack:///./src/Composite.js?4471","webpack:///./src/Helper/WalkComposite.js?216e","webpack:///./~/walk-composite/index.js?d92f","webpack:///./src/Composite/Reducer.js?0749","webpack:///./src/Helper/ReduxAction.js?4ee8","webpack:///./src/Helper/DefaultMutationMethod.js?38ed","webpack:///./src/Composite/Middleware.js?18ff","webpack:///./src/Helper/InitWalk.js?320e","webpack:///./src/Composite/Equality.js?b245","webpack:///./src/Composite/Subscribe.js?76a3","webpack:///./src/Composite/Redux.js?fc4b","webpack:///./src/Composite/Memoize.js?5e19","webpack:///./src/Redux.js?5643","webpack:///./src/Memoize.js?0008","webpack:///./src/Prettify/Reduce.js?15af","webpack:///./src/Prettify/Expand.js?a629","webpack:///./~/redux/lib/index.js?5f19","webpack:///./~/process/browser.js?82e4","webpack:///./~/redux/lib/createStore.js?fe4c","webpack:///./~/lodash/isPlainObject.js?4342","webpack:///./~/lodash/_baseGetTag.js?0d07","webpack:///./~/lodash/_Symbol.js?dfe5","webpack:///./~/lodash/_root.js?c0bd","webpack:///./~/lodash/_freeGlobal.js?e849","webpack:///./~/lodash/_getRawTag.js?9b8e","webpack:///./~/lodash/_objectToString.js?e901","webpack:///./~/lodash/_getPrototype.js?1075","webpack:///./~/lodash/_overArg.js?12d5","webpack:///./~/lodash/isObjectLike.js?36be","webpack:///./~/symbol-observable/index.js?6982","webpack:///./~/symbol-observable/lib/index.js?631f","webpack:///(webpack)/buildin/module.js?c3c2","webpack:///./~/symbol-observable/lib/ponyfill.js?505d","webpack:///./~/redux/lib/combineReducers.js?1086","webpack:///./~/redux/lib/utils/warning.js?07c3","webpack:///./~/redux/lib/bindActionCreators.js?91d9","webpack:///./~/redux/lib/applyMiddleware.js?ee15","webpack:///./~/redux/lib/compose.js?a8c7","webpack:///./src/Test/Reducer.js","webpack:///./~/expect/lib/index.js","webpack:///./~/expect/lib/Expectation.js","webpack:///./~/has/src/index.js","webpack:///./~/function-bind/index.js","webpack:///./~/function-bind/implementation.js","webpack:///./~/tmatch/index.js","webpack:///./~/buffer/index.js","webpack:///./~/base64-js/index.js","webpack:///./~/ieee754/index.js","webpack:///./~/isarray/index.js","webpack:///./~/expect/lib/assert.js","webpack:///./~/object-inspect/index.js","webpack:///./~/expect/lib/SpyUtils.js","webpack:///./~/define-properties/index.js","webpack:///./~/object-keys/index.js","webpack:///./~/object-keys/isArguments.js","webpack:///./~/foreach/index.js","webpack:///./~/expect/lib/TestUtils.js","webpack:///./~/is-regex/index.js","webpack:///./~/is-equal/why.js","webpack:///./~/is-arrow-function/index.js","webpack:///./~/is-callable/index.js","webpack:///./~/is-boolean-object/index.js","webpack:///./~/is-date-object/index.js","webpack:///./~/is-generator-function/index.js","webpack:///./~/is-number-object/index.js","webpack:///./~/is-string/index.js","webpack:///./~/is-symbol/index.js","webpack:///./~/is-equal/getSymbolIterator.js","webpack:///./~/is-equal/getCollectionsForEach.js","webpack:///./~/expect/lib/extend.js","webpack:///./~/deep-freeze/index.js","webpack:///./src/Test/Middleware.js","webpack:///./src/Test/Equality.js","webpack:///./src/Test/Subscribe.js","webpack:///./src/Test/Redux.js","webpack:///./src/Test/Memoize.js","webpack:///./src/MemoizeChain.js","webpack:///./src/Test/ReduxThunk.js","webpack:///./~/redux-thunk/lib/index.js","webpack:///./src/Test/Prettify.js"],"names":["tests","Defaults","Reducer","Middleware","Equality","Subscribe","Redux","Memoize","Init","Store","Prettify","Reduce","Expand","Composite","parameters","Structure","Wrappers","structure","defaultEquality","prev","next","defaultMiddleware","action","applyMiddleware","middlewares","length","dispatch","getState","chain","map","middleware","reverse","reduce","resultMiddleware","originalSubscribe","equality","subscribe","undefined","listeners","initializedSubscribe","state","listener","originalMemoize","resolvedMemoize","memoize","result","callback","data","reducer","redux","message","compositeStructure","leaf","uglify","injection","parameter","withStructure","withoutStructure","wrapper","beforeWrapper","Array","isArray","filter","oneMiddleware","originalSubscriber","expand","r","m","store","reduxStore","initRedux","initMemoize","composite","createStore","init","prettify","preloadedState","enhancer","require","WalkComposite","allowFunction","leafCondition","isLeaf","LeafCondition","walkMethod","mutationMethod","key","ReduxAction","type","InitAction","MutateMethod","arg","ActionMutateMethod","indexOf","DefaultMutationMethod","MutationMethod","initMiddleware","initNextMiddleware","InitWalk","other","equal","initSubscribe","useStructure","node","WalkRedux","originalStore","keysMethod","KeysMethod","reducerMethod","add","ReducerMethod","ReduxByRedux","MemoizeWalk","memoizeStructure","MemoizeByMemoize","memoized","memoizationStructure","actions","payload","path","rest","push","Object","keys","join","compositeChecked","split","a","p","lastChecked","checked","test","item","substr","value","i","e","toggle","increment","calculator","checkBoth","expected","toEqual","calc","checker","complex","middlewareCalcCallback","toContain","middlewareIncrementCallback","previousState","setTimeout","anotherMiddlewareIncrementCallback","createComposite","FIXED_STATE","complexStore","anotherComplex","anotherComplexStore","states","middlewareMultiply2","middlewareAdd3","testStructure","testStore","simple","Math","abs","incrementMiddleware","calcTriggers","incrementSum","toggled","sum","squares","someFunction","b","test1","memoizeFunction","memoizeFunctionsStructure","test2","custom","test3","calculated","total","structureSimple","memoizeSimple","memoized1","finalMemoize1","memoized2","complexComposite","complexCalculated","complexMemoized","finalComplexMemoize","memoizeToggle","MemoizeChain","memoizeChain","memoizeToggleChain","memoizeToggleItem","calculatorThunkActor","reduced1","expanded1","reduced2","expanded2"],"mappings":"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AqBxF,SAAzB,EAAoC;AAChCwF,oCAAmBI,WAAnB;AACAzD,6BAAYqD,mBAAmB,EAAnB,GAAwB,EAApC;AACH,cAHD,MAGO,IAAIA,qBAAqBI,WAAzB,EAAsC;AACzC,uBAAM;AACF/E,8BAAS;AADP,kBAAN;AAGH;AACD,iBAAI2E,gBAAJ,EAAsB;AAClBrD,0CAAgBA,SAAhB,EAA8B3B,MAA9B;AACH,cAFD,MAEO;AACHA,wBAAOhB,GAAP,CAAW,UAACyG,KAAD,EAAQC,CAAR;AAAA,4BAAc/D,UAAU+D,CAAV,IAAeD,KAA7B;AAAA,kBAAX;AACH;AACJ,UA7Ce,CAAhB;AA8CA,gBAAO,EAAC9C,MAAM,WAAP,EAAoBhB,oBAApB,EAAP;AACH,MAjDD,CAiDE,OAAOgE,CAAP,EAAU;AACR;AACA,gBAAOlH,MAAP;AACH;AACJ,EAzDM;;mBA2DQV,M;;;;;;;;;AC3Df;;AAEA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,uCAAsC,uCAAuC,kBAAkB;;AAE/F;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,wC;;;;;;;;;;AC7CA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAS;AACT;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA,UAAS;AACT;AACA;AACA,MAAK;AACL;AACA;AACA,EAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA,UAAS;AACT;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA,UAAS;AACT;AACA;AACA;AACA;AACA;;;;AAIA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,wBAAuB,sBAAsB;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAqB;AACrB;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,sCAAqC;;AAErC;AACA;AACA;;AAEA,4BAA2B;AAC3B;AACA;AACA;AACA,6BAA4B,UAAU;;;;;;;;;;ACvLtC;;AAEA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,uCAAsC,uCAAuC,kBAAkB;;AAE/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAa,SAAS;AACtB;AACA;AACA,cAAa,IAAI;AACjB;AACA;AACA;AACA;AACA;AACA,cAAa,SAAS;AACtB;AACA;AACA;AACA;AACA,gBAAe,MAAM;AACrB;AACA;AACA,GAAE;AACF;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,gBAAe,IAAI;AACnB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAa,SAAS;AACtB,gBAAe,SAAS;AACxB;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA,gBAAe,OAAO;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,MAAK;AACL;AACA;;AAEA;AACA,oBAAmB,sBAAsB;AACzC;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAa,SAAS;AACtB,gBAAe;AACf;AACA;AACA;AACA;AACA;;AAEA;AACA,eAAc,yBAAyB;AACvC;;AAEA;AACA;AACA,gBAAe,WAAW;AAC1B;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,kBAAiB,OAAO;AACxB;AACA,oBAAmB,aAAa;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,iBAAgB;AAChB;AACA,MAAK;AACL;AACA,MAAK;AACL;;AAEA;AACA;AACA;AACA,aAAY,yBAAyB;;AAErC;AACA;AACA;AACA;AACA;AACA,IAAG;AACH,E;;;;;;;;;ACpQA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAW,EAAE;AACb,cAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAoB,iBAAiB;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;AC7DA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,YAAW,EAAE;AACb,cAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;AC3BA;;AAEA;AACA;;AAEA;;;;;;;;;;ACLA;;AAEA;AACA;;AAEA;AACA;;AAEA;;;;;;;;;;ACRA;AACA;;AAEA;;;;;;;;;;;ACHA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,YAAW,EAAE;AACb,cAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,IAAG;;AAEH;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;AC7CA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,YAAW,EAAE;AACb,cAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;;;;;;;;;;ACrBA;;AAEA;AACA;;AAEA;;;;;;;;;;ACLA;AACA;AACA;AACA;AACA,YAAW,SAAS;AACpB,YAAW,SAAS;AACpB,cAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAW,EAAE;AACb,cAAa,QAAQ;AACrB;AACA;AACA,qBAAoB;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;AC5BA;;;;;;;;;;ACAA;;AAEA;AACA;AACA,EAAC;;AAED;;AAEA;;AAEA,uCAAsC,uCAAuC,kBAAkB;;AAE/F,UAAS;;;AAGT;AACA;AACA,EAAC;AACD;AACA,EAAC;AACD;AACA,EAAC;AACD;AACA,EAAC;AACD;AACA;;AAEA;AACA,6B;;;;;;;;;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;ACTA;;AAEA;AACA;AACA,EAAC;AACD;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA,GAAE;AACF;AACA;;AAEA;AACA,G;;;;;;;;;ACtBA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,uCAAsC,uCAAuC,kBAAkB;;AAE/F;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,oEAAmE;AACnE;;AAEA;AACA;AACA,IAAG;;AAEH;AACA;AACA,IAAG;;AAEH;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,4CAA2C,sCAAsC;;AAEjF;AACA;AACA;;AAEA;AACA,oCAAmC,aAAa;AAChD;AACA;AACA,IAAG;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,YAAW,OAAO;AAClB;AACA;AACA;AACA;AACA;AACA;AACA,cAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA,kBAAiB,wBAAwB;AACzC;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,IAAG;AACH;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,qBAAoB,8BAA8B;AAClD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,E;;;;;;;;;;AC9IA;;AAEA;AACA;AACA;AACA;AACA;AACA,YAAW,OAAO;AAClB,cAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA,E;;;;;;;;;ACxBA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAW,gBAAgB;AAC3B;AACA;AACA;AACA,YAAW,SAAS;AACpB;AACA;AACA,cAAa,gBAAgB;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,kBAAiB,iBAAiB;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,E;;;;;;;;;AClDA;;AAEA;;AAEA,oDAAmD,gBAAgB,sBAAsB,OAAO,2BAA2B,0BAA0B,y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,EAAE,yDAAyD,qEAAqE,6DAA6D,oBAAoB,GAAG,EAAE;;AAEjjB;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,uCAAsC,uCAAuC,gBAAgB;;AAE7F,kDAAiD,0CAA0C,0DAA0D,EAAE;;AAEvJ;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,IAAG;AACH;AACA;AACA;;AAEA;AACA;AACA,IAAG;AACH;AACA;AACA;;AAEA;AACA;AACA,IAAG;AACH;AACA;AACA;;AAEA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;AACA,QAAO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,IAAG;AACH;AACA;AACA;;AAEA;AACA;AACA,IAAG;AACH;AACA;AACA;;AAEA;;AAEA;AACA;AACA,IAAG;AACH;AACA;AACA;;AAEA;;AAEA;AACA;AACA,IAAG;AACH;AACA;AACA;;AAEA;;AAEA;AACA;AACA,IAAG;AACH;AACA;AACA;;AAEA;;AAEA;AACA;AACA,IAAG;AACH;AACA;AACA;;AAEA;AACA;AACA,IAAG;AACH;AACA;AACA;;AAEA;AACA;AACA,IAAG;AACH;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA,IAAG;AACH;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA,IAAG;AACH;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA,IAAG;AACH;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA,QAAO;AACP;AACA,QAAO;AACP;AACA,QAAO;AACP;AACA;;AAEA;;AAEA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA,QAAO;AACP;AACA,QAAO;AACP;AACA,QAAO;AACP;AACA;;AAEA;;AAEA;AACA;AACA,IAAG;AACH;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA,QAAO;;AAEP;;AAEA;AACA;AACA,IAAG;AACH;AACA;AACA,yFAAwF,aAAa;AACrG;AACA;;AAEA;AACA;AACA,IAAG;AACH;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA,QAAO;;AAEP;;AAEA;AACA;AACA,IAAG;AACH;AACA;AACA,6FAA4F,eAAe;AAC3G;AACA;;AAEA;AACA;AACA,IAAG;AACH;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA,IAAG;AACH;AACA;AACA,iFAAgF,eAAe;AAC/F;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA,QAAO;;AAEP;AACA;AACA,IAAG;AACH;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA,IAAG;;AAEH;AACA,EAAC;;AAED;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA,uEAAsE,eAAe;AACrF;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA,EAAC,+BAA+B;;AAEhC;AACA;;AAEA;;AAEA;;AAEA;AACA,EAAC,4BAA4B;;AAE7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,EAAC,8B;;;;;;;;;ACzZD;;AAEA;;;;;;;;;;ACFA;;AAEA;;AAEA;;;;;;;;;;ACJA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAS;AACT;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,oBAAmB,iBAAiB;AACpC;AACA;;AAEA,+EAA8E,qCAAqC,EAAE;;AAErH;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;;;;;;;;;ACnDA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,MAAK;AACL;;AAEA,MAAK;AACL;;AAEA,MAAK;AACL;;AAEA,MAAK;AACL;AACA;;AAEA,IAAG;AACH;AACA;;AAEA,IAAG;AACH;AACA;;AAEA,IAAG;AACH;AACA;;AAEA,IAAG;AACH;AACA;;AAEA,IAAG;AACH;AACA;;AAEA,IAAG;AACH;AACA;AACA;;AAEA,IAAG;AACH;AACA;;AAEA,IAAG;AACH;AACA;;AAEA,IAAG;AACH;AACA;;AAEA,IAAG;AACH;AACA;;AAEA,IAAG;AACH;AACA;;AAEA,IAAG;AACH;AACA;;AAEA,IAAG;AACH;AACA;;AAEA,IAAG;AACH;AACA;;AAEA,IAAG;AACH;AACA;;AAEA,IAAG;AACH;AACA;AACA;AACA;AACA;AACA;;AAEA,IAAG;AACH;AACA;AACA;AACA,MAAK;AACL;;AAEA,sBAAqB,gBAAgB;;AAErC;AACA;;AAEA,IAAG;AACH;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAiB;AACjB;;AAEA;AACA,kCAAiC,QAAQ;AACzC;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;;;;;;;;;;ACzJA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,sBAAqB,mDAAmD;AACxE;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;;AAEA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,oBAAmB,UAAU;AAC7B;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,kBAAiB,YAAY;AAC7B;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,IAAG;AACH;AACA,IAAG;AACH;AACA;;AAEA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,2BAA0B;AAC1B;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA,wCAAuC,SAAS;AAChD;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,gBAAe,iBAAiB;AAChC;AACA;AACA;;AAEA;AACA;AACA,cAAa,iBAAiB;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,UAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,kBAAiB,SAAS;AAC1B;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,kBAAiB,SAAS;AAC1B;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,kBAAiB,SAAS;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,iDAAgD,EAAE;AAClD;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA,kBAAiB,SAAS;AAC1B;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,0CAAyC;AACzC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA,IAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;AACA;AACA,QAAO;AACP;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;AACA,yBAAwB,eAAe;AACvC;AACA;AACA;AACA,QAAO;AACP;AACA;AACA;AACA;AACA,IAAG;AACH;AACA,yBAAwB,QAAQ;AAChC;AACA,sBAAqB,eAAe;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,kBAAiB,YAAY;AAC7B;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA,UAAS;AACT;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,sBAAqB,SAAS;AAC9B;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,sBAAqB,SAAS;AAC9B;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA,sBAAqB,SAAS;AAC9B;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,kBAAiB,kBAAkB;AACnC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,IAAG;AACH;AACA;;AAEA;AACA;AACA;AACA,IAAG;AACH;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA,oBAAmB,cAAc;AACjC;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,wDAAuD,OAAO;AAC9D;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;AACA,wDAAuD,OAAO;AAC9D;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,mBAAkB;AAClB;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,sBAAqB,QAAQ;AAC7B;AACA;AACA,IAAG;AACH;AACA,gBAAe,SAAS;AACxB;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA,oBAAmB,SAAS;AAC5B;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;AACA,gBAAe,iBAAiB;AAChC;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA,kBAAiB,YAAY;AAC7B;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAS;AACT;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,MAAK;AACL;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,kBAAiB,gBAAgB;AACjC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,kBAAiB,gBAAgB;AACjC;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,kBAAiB,YAAY;AAC7B;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;;;;;;;;;;AC5vDA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,mCAAkC,SAAS;AAC3C;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;;AAEA,cAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,sBAAqB,SAAS;AAC9B;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,2CAA0C,UAAU;AACpD;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;;;;;;;;;ACjHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,SAAQ,WAAW;;AAEnB;AACA;AACA;AACA,SAAQ,WAAW;;AAEnB;AACA;AACA,IAAG;AACH;AACA,IAAG;AACH;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;;AAEA,SAAQ,WAAW;;AAEnB;AACA;AACA,SAAQ,UAAU;;AAElB;AACA;;;;;;;;;;ACnFA,kBAAiB;;AAEjB;AACA;AACA;;;;;;;;;;ACJA;;AAEA;AACA;AACA,EAAC;;AAED;;AAEA;;AAEA,uCAAsC,uCAAuC,gBAAgB;;AAE7F;AACA;AACA;AACA;AACA,IAAG;AACH;;AAEA;AACA,0FAAyF,aAAa;AACtG;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA,0B;;;;;;;;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAuB,kBAAkB;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAiB,iDAAiD;AAClE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,UAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAuC;AACvC,kBAAiB,wBAAwB;AACzC;AACA;AACA;;AAEA;AACA,2CAA0C;AAC1C;;AAEA,yBAAwB;AACxB,wBAAuB;AACvB,0BAAyB;AACzB,yBAAwB;AACxB,0BAAyB;AACzB,0BAAyB;AACzB,0BAAyB;AACzB,2BAA0B;;AAE1B,iEAAgE,oBAAoB;AACpF;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,mCAAkC,OAAO;AACzC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAS;AACT;AACA;AACA,iCAAgC;AAChC,MAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAS;AACT;AACA;AACA,iCAAgC;AAChC,MAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,cAAa,4CAA4C;AACzD;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,qCAAoC,2BAA2B;AAC/D;;AAEA;AACA;AACA;AACA;AACA;AACA,wBAAuB,gBAAgB;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAS;AACT;AACA;AACA;AACA;AACA;;;;;;;;;;ACvOA;;AAEA;AACA;AACA,EAAC;AACD;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,uCAAsC,uCAAuC,gBAAgB;;AAE7F,mCAAkC,0BAA0B,0CAA0C,gBAAgB,OAAO,kBAAkB,EAAE,aAAa,EAAE,OAAO,wBAAwB,EAAE,EAAE;;;AAGnM;;AAEA,2HAA0H;;AAE1H;AACA;AACA;;AAEA;;AAEA;AACA,iCAAgC,QAAQ;AACxC;AACA,IAAG;AACH;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,MAAK;;AAEL;;AAEA;;AAEA;AACA;;AAEA;AACA,sDAAqD,2EAA2E;AAChI,IAAG;AACH;AACA;AACA;AACA,MAAK,kBAAkB,gDAAgD;AACvE;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA,+FAA8F;;AAE9F;AACA;AACA,MAAK;AACL;;AAEA;AACA,G;;;;;;;;;ACxHA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,oCAAmC,gCAAgC;AACnE;AACA,6BAA4B,cAAc;AAC1C;AACA;AACA,GAAE,YAAY;AACd;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH,GAAE;AACF;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAE;AACF;;AAEA;;AAEA;;;;;;;;;;ACvDA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,0CAAyC,iBAAiB;AAC1D,uDAAsD;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAqC,cAAc;AACnD;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;AACA,EAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAE;AACF;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,kBAAiB,mBAAmB;AACpC;AACA;AACA;;AAEA;AACA,kBAAiB,mBAAmB;AACpC;AACA;AACA,GAAE;AACF;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,kBAAiB,sBAAsB;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA,GAAE;AACF;AACA;AACA;AACA;;AAEA;;;;;;;;;;AC3IA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;ACfA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAuB,OAAO;AAC9B;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;ACpBA;;AAEA;AACA;AACA,EAAC;AACD;;AAEA,qGAAoG,mBAAmB,EAAE,mBAAmB,kGAAkG;;AAE9O;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,uCAAsC,uCAAuC,gBAAgB;;AAE7F;AACA;AACA,kBAAiB;AACjB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;;AAEA;AACA;AACA;AACA;AACA,MAAK;AACL;;AAEA;AACA;AACA;AACA,MAAK;AACL;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,IAAG;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA,G;;;;;;;;;ACjJA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,GAAE;AACF;AACA,GAAE;AACF;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;;;;;;;;;ACtCA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAE;AACF;AACA;AACA;AACA;AACA;AACA,qCAAoC;AACpC,kBAAiB;AACjB;AACA,mCAAkC;AAClC,sCAAqC;AACrC;AACA,iEAAgE;AAChE;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,iEAAgE,OAAO;AACvE;;AAEA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH,GAAE;AACF;AACA;AACA;AACA,KAAI;AACJ,IAAG;AACH;AACA;AACA;AACA;AACA;;AAEA;AACA,wBAAuB,WAAW;AAClC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,oBAAmB,yCAAyC,qBAAqB;AACjF,sBAAqB,0CAA0C,oBAAoB;AACnF;AACA;AACA,qCAAoC,WAAW;AAC/C;AACA;;AAEA;AACA;AACA;AACA,sBAAqB,wCAAwC,qBAAqB;AAClF,wBAAuB,yCAAyC,oBAAoB;AACpF;AACA;AACA,6BAA4B,WAAW;AACvC;AACA;AACA;AACA,kCAAiC;AACjC,IAAG;AACH,mCAAkC;AAClC,IAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,sBAAqB,mCAAmC,eAAe;AACvE,wBAAuB,kCAAkC,gBAAgB;AACzE;AACA;AACA,gCAA+B,WAAW;AAC1C;AACA;;AAEA;AACA;AACA;AACA,oBAAmB,gDAAgD;AACnE,sBAAqB,gDAAgD;AACrE;AACA;AACA,+BAA8B,WAAW;AACzC;AACA;;AAEA;AACA;AACA;AACA,qBAAoB,kDAAkD;AACtE,uBAAsB,kDAAkD;AACxE;AACA;AACA,6CAA4C,WAAW;AACvD;AACA;;AAEA;AACA;AACA;AACA,qBAAoB,oDAAoD;AACxE,uBAAsB,oDAAoD;AAC1E;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAuC,iDAAiD,iBAAiB;AACzG,wCAAuC,gDAAgD,kBAAkB;AACzG;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,oBAAmB,kCAAkC,gBAAgB;AACrE,qCAAoC;AACpC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,oBAAmB,uCAAuC,gBAAgB;AAC1E,0CAAyC;AACzC;;AAEA;AACA;AACA;AACA,sBAAqB,6CAA6C,gBAAgB;AAClF,gDAA+C;AAC/C;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,gDAA+C,WAAW;;AAE1D;AACA,gDAA+C,MAAM,6BAA6B,MAAM;AACxF;AACA;AACA;;AAEA;AACA,uCAAsC,sFAAsF;AAC5H,oCAAmC,4DAA4D;AAC/F,oCAAmC,4DAA4D;AAC/F,yDAAwD,mDAAmD;;AAE3G;AACA;AACA;AACA;AACA;AACA;AACA,2BAA0B,oCAAoC,gBAAgB;AAC9E,yCAAwC;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL,6CAA4C,0DAA0D;AACtG,6CAA4C,0DAA0D;AACtG;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;AACA,sDAAqD,iEAAiE;AACtH,sDAAqD,iEAAiE;AACtH;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,4BAA2B,8CAA8C,kBAAkB;AAC3F;AACA;AACA;AACA,gCAA+B,sEAAsE,kBAAkB;AACvH,4EAA2E;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mDAAkD;AAClD;AACA;AACA;AACA;;AAEA;AACA;;;;;;;;;;ACpSA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,wBAAuB,cAAc;AACrC;AACA;AACA;AACA;AACA;;;;;;;;;;ACdA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,qEAAoE,EAAE;AACtE;AACA,GAAE;AACF,gBAAe;AACf;AACA;;AAEA;AACA;AACA,6BAA4B,cAAc;AAC1C;AACA;AACA,GAAE;AACF;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,eAAc,cAAc;AAC5B,iEAAgE,cAAc;AAC9E,uBAAsB,iCAAiC;AACvD,4BAA2B,cAAc;AACzC;AACA;AACA;;;;;;;;;;ACtCA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,GAAE;AACF;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,mCAAkC,aAAa;AAC/C,kCAAiC,cAAc;AAC/C;AACA;;;;;;;;;;ACpBA;;AAEA;AACA;AACA;AACA;AACA;AACA,GAAE;AACF;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,oDAAmD,cAAc;AACjE;AACA;;;;;;;;;;ACnBA;;AAEA;AACA;AACA;AACA;AACA;AACA,qCAAoC;AACpC;AACA;AACA;AACA;AACA,yCAAwC;AACxC,GAAE;AACF;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;AC/BA;;AAEA;AACA;AACA;AACA;AACA;AACA,GAAE;AACF;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,kCAAiC,aAAa;AAC9C,kCAAiC,cAAc;AAC/C;AACA;;;;;;;;;;ACnBA;;AAEA;AACA;AACA;AACA;AACA;AACA,GAAE;AACF;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,kCAAiC,aAAa;AAC9C,kCAAiC,cAAc;AAC/C;AACA;;;;;;;;;;ACnBA;;AAEA;AAC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","file":"tests.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\texports: {},\n \t\t\tid: moduleId,\n \t\t\tloaded: false\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.loaded = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(0);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap 56cc3c0b9a05b4eb7623","import TestReducer from './Test/Reducer';\nimport TestMiddleware from './Test/Middleware';\nimport TestEquality from './Test/Equality';\nimport TestSubscribe from './Test/Subscribe';\nimport TestRedux from './Test/Redux';\nimport TestMemoize from './Test/Memoize';\nimport TestReduxThunk from './Test/ReduxThunk';\nimport TestPrettify from './Test/Prettify';\n\nconst tests = () => {\n TestReducer();\n TestMiddleware();\n TestEquality();\n TestSubscribe();\n TestRedux();\n TestMemoize();\n TestReduxThunk();\n TestPrettify();\n};\ntests();\n\n\n\n// WEBPACK FOOTER //\n// ./src/tests.js","import CompositeClass, {Wrappers} from './Composite';\nimport Structure from './Structure';\n\nimport Reducer from './Composite/Reducer';\nimport Middleware from './Composite/Middleware';\nimport Equality from './Composite/Equality';\nimport Subscribe from './Composite/Subscribe';\nimport Redux from './Composite/Redux';\nimport Memoize from './Composite/Memoize';\nimport InitRedux from './Redux';\nimport InitMemoize from './Memoize';\nimport Reduce from './Prettify/Reduce';\nimport Expand from './Prettify/Expand';\n\nexport const Defaults = {Reducer, Middleware, Equality, Subscribe, Redux, Memoize, Init: {Store: InitRedux, Memoize: InitMemoize}, Prettify: {Reduce, Expand}};\nexport const Composite = parameters => new CompositeClass(parameters);\nexport * from './Structure';\n\nexport default {Composite, Structure, Defaults, Wrappers};\n\n\n\n// WEBPACK FOOTER //\n// ./src/index.js","import Composite from './Composite';\n\nexport const Structure = structure => new Composite({structure: structure});\nexport default Structure;\n\n\n\n// WEBPACK FOOTER //\n// ./src/Structure.js","import WalkComposite from './Helper/WalkComposite';\nimport Reducer from './Composite/Reducer';\nimport Middleware from './Composite/Middleware';\nimport Equality from './Composite/Equality';\nimport Subscribe from './Composite/Subscribe';\nimport Redux from './Composite/Redux';\nimport Memoize from './Composite/Memoize';\nimport InitRedux from './Redux';\nimport InitMemoize from './Memoize';\nimport Reduce from './Prettify/Reduce';\nimport Expand from './Prettify/Expand';\n\nconst defaultEquality = (prev, next) => prev === next;\n\nconst defaultMiddleware = () => next => action => next(action);\n\nconst applyMiddleware = middlewares => {\n if (middlewares.length === 0) {\n return defaultMiddleware;\n } else if (middlewares.length === 1) {\n return middlewares[0];\n }\n return ({dispatch, getState}) => {\n const chain = middlewares.map(middleware => middleware({dispatch, getState})).reverse();\n return next => chain.reduce((resultMiddleware, middleware) => middleware(resultMiddleware), next)\n };\n};\n\n\nexport const Wrappers = {\n Subscribe: (originalSubscribe, equality) => (dispatch, getState, subscribe = undefined) => listeners => {\n if (listeners === undefined) {\n return () => {};\n }\n const initializedSubscribe = originalSubscribe(dispatch, getState)(listeners);\n let state = getState();\n const listener = () => {\n const next = getState();\n if (!(equality === undefined ? defaultEquality : equality)(state, next)) {\n state = next;\n initializedSubscribe();\n }\n };\n return typeof subscribe === 'function' ? subscribe(listener) : listener;\n },\n Memoize: (originalMemoize, equality) => getState => {\n const resolvedMemoize = originalMemoize(getState);\n return {\n ...resolvedMemoize,\n memoize: callback => {\n let state = undefined,\n result = undefined;\n return (...parameters) => {\n const next = getState();\n if (!(equality === undefined ? defaultEquality : equality)(state, next)) {\n state = next;\n result = resolvedMemoize.memoize(callback)(...parameters);\n }\n return result;\n }\n }\n };\n }\n};\n\nclass Composite\n{\n constructor(data) {\n const {structure, reducer, middleware, equality, subscribe, redux, memoize} = data;\n\n if (structure === undefined && typeof reducer !== 'function') {\n throw {\n message: \"Not valid parameters: should be either structure or reducer\"\n }\n }\n\n const compositeStructure = structure === undefined\n ? undefined\n : WalkComposite({}, true)(\n leaf => {\n if (typeof leaf === 'function') {\n return new Composite({reducer: leaf})\n }\n if (leaf instanceof Composite && typeof leaf.uglify === 'function') {\n leaf.uglify();\n }\n return leaf;\n }\n )(structure);\n\n const injection = (parameter, withStructure, withoutStructure, wrapper) => {\n if (typeof parameter === 'function') {\n return structure === undefined\n ? parameter\n : parameter(compositeStructure)\n }\n const beforeWrapper = structure === undefined\n ? withoutStructure\n : withStructure(compositeStructure);\n return wrapper === undefined ? beforeWrapper : wrapper(beforeWrapper);\n };\n\n this.reducer = injection(reducer, Reducer);\n this.middleware = injection(\n structure === undefined && typeof middleware === 'object' && Array.isArray(middleware)\n ? applyMiddleware(middleware.filter(oneMiddleware => typeof oneMiddleware === 'function'))\n : middleware,\n Middleware,\n defaultMiddleware\n );\n this.equality = injection(\n equality,\n Equality,\n defaultEquality\n );\n this.subscribe = injection(\n subscribe,\n Subscribe,\n (dispatch, getState) => listener => () => listener({dispatch, getState}),\n (equality => originalSubscriber => Wrappers.Subscribe(originalSubscriber, equality))(this.equality)\n );\n\n this.redux = injection(\n redux,\n Redux,\n (dispatch, getState, subscribe) => ({\n redux: {dispatch, getState, subscribe}\n })\n );\n\n this.memoize = injection(\n memoize,\n Memoize,\n getState => ({memoize: callback => callback}),\n (equality => originalMemoize => Wrappers.Memoize(originalMemoize, equality))(this.equality)\n );\n\n const Prettify = ({reduce, expand} = {}) => {\n reduce = typeof reduce === 'function' ? reduce : Reduce;\n expand = typeof expand === 'function' ? expand : Expand;\n const r = this.reducer;\n const m = this.middleware;\n this.reducer = (state, action) => r(state, expand(action))\n this.middleware = store => next => action => m(store)(action => next(reduce(action)))(action)\n this.uglify = () => {\n this.reducer = r;\n this.middleware = m;\n delete this.uglify;\n }\n }\n\n const Init = (reduxStore, initRedux, initMemoize) => composite => {\n const {store, structure} = (store => store(composite)(reduxStore))(initRedux);\n composite.memoize = (memoize => memoize(composite.memoize, store))(initMemoize);\n delete composite.reducer;\n delete composite.middleware;\n delete composite.redux;\n delete composite.equality;\n composite.store = structure;\n composite.getState = store.getState\n composite.dispatch = store.dispatch;\n composite.subscribe = store.subscribe;\n return composite;\n }\n\n this.createStore = ({createStore = undefined, init = {}, prettify = {}} = {}) => (reducer, preloadedState, enhancer) => {\n // Prettify\n if (typeof prettify === 'object') {\n const reduce = typeof prettify.reduce === 'function' ? prettify.reduce : Reduce;\n const expand = typeof prettify.expand === 'function' ? prettify.expand : Expand;\n Prettify({reduce, expand});\n }\n\n // Create Store\n if (typeof createStore !== 'function') {\n createStore = require('redux').createStore;\n }\n reducer = typeof reducer === 'function' ? reducer(this.reducer) : this.reducer;\n if (typeof preloadedState === 'function' && enhancer === undefined) {\n enhancer = preloadedState;\n preloadedState = undefined\n }\n enhancer = typeof enhancer === 'function' ? enhancer(this.middleware) : require('redux').applyMiddleware(this.middleware)\n let Store = createStore(reducer, preloadedState, enhancer);\n\n // Init\n const initRedux = typeof init.store === 'function' ? init.store : InitRedux\n const initMemoize = typeof init.memoize === 'function' ? init.memoize : InitMemoize\n Init(Store, initRedux, initMemoize)(this);\n\n // Clean-up\n delete this.createStore;\n return Store;\n }\n }\n}\n\nexport default Composite;\n\n\n\n// WEBPACK FOOTER //\n// ./src/Composite.js","import {Walk, Defaults} from 'walk-composite';\nimport Composite from '../Composite';\n\nconst WalkComposite = (parameters = {}, allowFunction = false) => Walk({\n leafCondition: data => {\n const isLeaf = Defaults.LeafCondition(data);\n if (!(data instanceof Composite) && isLeaf && (!allowFunction || typeof data !== 'function')) {\n throw {\n message: \"Structure leafs could be only instance of Composite or reducer function\"\n };\n }\n return isLeaf || data instanceof Composite;\n },\n walkMethod: parameters => WalkComposite(parameters, allowFunction),\n ...parameters\n});\n\nexport default WalkComposite;\n\n\n\n// WEBPACK FOOTER //\n// ./src/Helper/WalkComposite.js","module.exports =\n/******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId])\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\texports: {},\n/******/ \t\t\tid: moduleId,\n/******/ \t\t\tloaded: false\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.loaded = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(0);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/*!*******************!*\\\n !*** multi index ***!\n \\*******************/\n/***/ (function(module, exports, __webpack_require__) {\n\n\tmodule.exports = __webpack_require__(/*! ./src/index.js */1);\n\n\n/***/ }),\n/* 1 */\n/*!**********************!*\\\n !*** ./src/index.js ***!\n \\**********************/\n/***/ (function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t value: true\n\t});\n\texports.Examples = exports.Defaults = undefined;\n\t\n\tvar _Composite = __webpack_require__(/*! ./Composite */ 2);\n\t\n\tObject.keys(_Composite).forEach(function (key) {\n\t if (key === \"default\" || key === \"__esModule\") return;\n\t Object.defineProperty(exports, key, {\n\t enumerable: true,\n\t get: function get() {\n\t return _Composite[key];\n\t }\n\t });\n\t});\n\t\n\tvar _Walk = __webpack_require__(/*! ./Walk */ 4);\n\t\n\tObject.keys(_Walk).forEach(function (key) {\n\t if (key === \"default\" || key === \"__esModule\") return;\n\t Object.defineProperty(exports, key, {\n\t enumerable: true,\n\t get: function get() {\n\t return _Walk[key];\n\t }\n\t });\n\t});\n\t\n\tvar _KeysMethod = __webpack_require__(/*! ./Default/KeysMethod */ 7);\n\t\n\tvar _KeysMethod2 = _interopRequireDefault(_KeysMethod);\n\t\n\tvar _LeafCondition = __webpack_require__(/*! ./Default/LeafCondition */ 5);\n\t\n\tvar _LeafCondition2 = _interopRequireDefault(_LeafCondition);\n\t\n\tvar _MutationMethod = __webpack_require__(/*! ./Default/MutationMethod */ 6);\n\t\n\tvar _MutationMethod2 = _interopRequireDefault(_MutationMethod);\n\t\n\tvar _ReducerMethod = __webpack_require__(/*! ./Default/ReducerMethod */ 8);\n\t\n\tvar _ReducerMethod2 = _interopRequireDefault(_ReducerMethod);\n\t\n\tvar _WalkFunction = __webpack_require__(/*! ./Example/WalkFunction */ 9);\n\t\n\tvar _WalkFunction2 = _interopRequireDefault(_WalkFunction);\n\t\n\tvar _Composite2 = _interopRequireDefault(_Composite);\n\t\n\tvar _Walk2 = _interopRequireDefault(_Walk);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tvar Defaults = exports.Defaults = { KeysMethod: _KeysMethod2.default, LeafCondition: _LeafCondition2.default, MutationMethod: _MutationMethod2.default, ReducerMethod: _ReducerMethod2.default };\n\tvar Examples = exports.Examples = { WalkFunction: _WalkFunction2.default };\n\texports.default = { Walk: _Walk2.default, Composite: _Composite2.default, Defaults: Defaults, Examples: Examples };\n\n/***/ }),\n/* 2 */\n/*!**************************!*\\\n !*** ./src/Composite.js ***!\n \\**************************/\n/***/ (function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t value: true\n\t});\n\texports.Composite = undefined;\n\t\n\tvar _InitDefault = __webpack_require__(/*! ./InitDefault */ 3);\n\t\n\tvar _InitDefault2 = _interopRequireDefault(_InitDefault);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }\n\t\n\tvar Composite = exports.Composite = function Composite(parameters) {\n\t var defaults = (0, _InitDefault2.default)(parameters);\n\t var reducerMethod = defaults.reducerMethod();\n\t return function (leafCallback) {\n\t return function () {\n\t for (var _len = arguments.length, data = Array(_len), _key = 0; _key < _len; _key++) {\n\t data[_key] = arguments[_key];\n\t }\n\t\n\t return defaults.keysMethod().apply(undefined, data).reduce(function (result, key) {\n\t var value = defaults.walkMethod()(parameters)(leafCallback).apply(undefined, _toConsumableArray(defaults.mutationMethod()(key).apply(undefined, data)));\n\t return reducerMethod.add(result, key, value);\n\t }, reducerMethod.init.apply(reducerMethod, data));\n\t };\n\t };\n\t};\n\t\n\texports.default = Composite;\n\n/***/ }),\n/* 3 */\n/*!****************************!*\\\n !*** ./src/InitDefault.js ***!\n \\****************************/\n/***/ (function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t value: true\n\t});\n\t\n\tvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\t\n\tvar _Walk = __webpack_require__(/*! ./Walk */ 4);\n\t\n\tvar _Walk2 = _interopRequireDefault(_Walk);\n\t\n\tvar _Composite = __webpack_require__(/*! ./Composite */ 2);\n\t\n\tvar _Composite2 = _interopRequireDefault(_Composite);\n\t\n\tvar _LeafCondition = __webpack_require__(/*! ./Default/LeafCondition */ 5);\n\t\n\tvar _LeafCondition2 = _interopRequireDefault(_LeafCondition);\n\t\n\tvar _MutationMethod = __webpack_require__(/*! ./Default/MutationMethod */ 6);\n\t\n\tvar _MutationMethod2 = _interopRequireDefault(_MutationMethod);\n\t\n\tvar _KeysMethod = __webpack_require__(/*! ./Default/KeysMethod */ 7);\n\t\n\tvar _KeysMethod2 = _interopRequireDefault(_KeysMethod);\n\t\n\tvar _ReducerMethod = __webpack_require__(/*! ./Default/ReducerMethod */ 8);\n\t\n\tvar _ReducerMethod2 = _interopRequireDefault(_ReducerMethod);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tvar InitDefault = function InitDefault(_ref) {\n\t var _leafCondition = _ref.leafCondition,\n\t _mutationMethod = _ref.mutationMethod,\n\t _walkMethod = _ref.walkMethod,\n\t _compositeMethod = _ref.compositeMethod,\n\t _keysMethod = _ref.keysMethod,\n\t _reducerMethod = _ref.reducerMethod;\n\t return {\n\t walkMethod: function walkMethod() {\n\t return typeof _walkMethod === 'function' ? _walkMethod : _Walk2.default;\n\t },\n\t compositeMethod: function compositeMethod() {\n\t return typeof _compositeMethod === 'function' ? _compositeMethod : _Composite2.default;\n\t },\n\t leafCondition: function leafCondition() {\n\t return typeof _leafCondition === 'function' ? _leafCondition : _LeafCondition2.default;\n\t },\n\t mutationMethod: function mutationMethod() {\n\t return typeof _mutationMethod === 'function' ? _mutationMethod : _MutationMethod2.default;\n\t },\n\t keysMethod: function keysMethod() {\n\t return typeof _keysMethod === 'function' ? _keysMethod : _KeysMethod2.default;\n\t },\n\t reducerMethod: function reducerMethod() {\n\t return (typeof _reducerMethod === 'undefined' ? 'undefined' : _typeof(_reducerMethod)) === 'object' && typeof _reducerMethod.add === 'function' && typeof _reducerMethod.init === 'function' ? _reducerMethod : _ReducerMethod2.default;\n\t }\n\t };\n\t};\n\t\n\texports.default = InitDefault;\n\n/***/ }),\n/* 4 */\n/*!*********************!*\\\n !*** ./src/Walk.js ***!\n \\*********************/\n/***/ (function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t value: true\n\t});\n\texports.Walk = undefined;\n\t\n\tvar _InitDefault = __webpack_require__(/*! ./InitDefault */ 3);\n\t\n\tvar _InitDefault2 = _interopRequireDefault(_InitDefault);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tvar Walk = exports.Walk = function Walk(parameters) {\n\t var defaults = (0, _InitDefault2.default)(parameters);\n\t return function (leafCallback) {\n\t return function () {\n\t return defaults.leafCondition().apply(undefined, arguments) ? leafCallback.apply(undefined, arguments) : defaults.compositeMethod()(parameters)(leafCallback).apply(undefined, arguments);\n\t };\n\t };\n\t};\n\texports.default = Walk;\n\n/***/ }),\n/* 5 */\n/*!**************************************!*\\\n !*** ./src/Default/LeafCondition.js ***!\n \\**************************************/\n/***/ (function(module, exports) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t value: true\n\t});\n\t\n\tvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\t\n\tvar LeafCondition = function LeafCondition(data) {\n\t return data === null || (typeof data === 'undefined' ? 'undefined' : _typeof(data)) !== 'object';\n\t};\n\texports.default = LeafCondition;\n\n/***/ }),\n/* 6 */\n/*!***************************************!*\\\n !*** ./src/Default/MutationMethod.js ***!\n \\***************************************/\n/***/ (function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t value: true\n\t});\n\t\n\tvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\t\n\tvar _LeafCondition = __webpack_require__(/*! ./LeafCondition */ 5);\n\t\n\tvar _LeafCondition2 = _interopRequireDefault(_LeafCondition);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tvar MutationMethod = function MutationMethod(key) {\n\t return function () {\n\t for (var _len = arguments.length, data = Array(_len), _key = 0; _key < _len; _key++) {\n\t data[_key] = arguments[_key];\n\t }\n\t\n\t return data.map(function (argument) {\n\t return _LeafCondition2.default.apply(undefined, data) || (typeof argument === 'undefined' ? 'undefined' : _typeof(argument)) !== 'object' || !argument.hasOwnProperty(key) ? undefined : argument[key];\n\t });\n\t };\n\t};\n\t\n\texports.default = MutationMethod;\n\n/***/ }),\n/* 7 */\n/*!***********************************!*\\\n !*** ./src/Default/KeysMethod.js ***!\n \\***********************************/\n/***/ (function(module, exports) {\n\n\t\"use strict\";\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t value: true\n\t});\n\tvar KeysMethod = function KeysMethod(data) {\n\t return Object.keys(data);\n\t};\n\texports.default = KeysMethod;\n\n/***/ }),\n/* 8 */\n/*!**************************************!*\\\n !*** ./src/Default/ReducerMethod.js ***!\n \\**************************************/\n/***/ (function(module, exports) {\n\n\t\"use strict\";\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t value: true\n\t});\n\t\n\tvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\t\n\tfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\t\n\tfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }\n\t\n\tvar ReducerMethod = {\n\t add: function add(result, key, value) {\n\t return Array.isArray(result) ? [].concat(_toConsumableArray(result), [value]) : _extends({}, result, _defineProperty({}, key, value));\n\t },\n\t init: function init(data) {\n\t return Array.isArray(data) ? [] : {};\n\t }\n\t};\n\t\n\texports.default = ReducerMethod;\n\n/***/ }),\n/* 9 */\n/*!*************************************!*\\\n !*** ./src/Example/WalkFunction.js ***!\n \\*************************************/\n/***/ (function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t value: true\n\t});\n\t\n\tvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\t\n\tvar _index = __webpack_require__(/*! ../index */ 1);\n\t\n\tvar WalkFunction = function WalkFunction() {\n\t var indices = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [0];\n\t var parameters = arguments[1];\n\t return (0, _index.Walk)(_extends({\n\t walkMethod: function walkMethod(parameters) {\n\t return WalkFunction(indices, parameters);\n\t },\n\t leafCondition: function leafCondition() {\n\t for (var _len = arguments.length, data = Array(_len), _key = 0; _key < _len; _key++) {\n\t data[_key] = arguments[_key];\n\t }\n\t\n\t if (!_index.Defaults.LeafCondition.apply(_index.Defaults, data)) {\n\t return false;\n\t }\n\t data.map(function (argument, i) {\n\t if (argument !== undefined && indices.indexOf(i) !== -1 && typeof argument !== 'function') {\n\t throw {\n\t message: \"Leaf data could be only function\",\n\t data: argument,\n\t index: i\n\t };\n\t }\n\t });\n\t return true;\n\t }\n\t }, parameters));\n\t};\n\texports.default = WalkFunction;\n\n/***/ })\n/******/ ]);\n//# sourceMappingURL=index.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/walk-composite/index.js\n// module id = 5\n// module chunks = 0 1","import WalkComposite from '../Helper/WalkComposite';\nimport {ReduxAction, ActionMutateMethod} from '../Helper/ReduxAction';\nimport DefaultMutationMethod from \"../Helper/DefaultMutationMethod\";\n\nconst Reducer = compositeStructure => (state, action) => WalkComposite({\n mutationMethod: key => (composite, state, action) => [\n DefaultMutationMethod(key)(composite),\n DefaultMutationMethod(key)(state),\n ActionMutateMethod(action, key)\n ]\n})(\n (composite, state, action) => state === undefined || action !== undefined\n ? composite.reducer(state, action)\n : state\n)(\n compositeStructure,\n state,\n ReduxAction(action)\n);\nexport default Reducer;\n\n\n\n// WEBPACK FOOTER //\n// ./src/Composite/Reducer.js","import DefaultMutationMethod from './DefaultMutationMethod';\n\nconst ReduxAction = action => typeof action === 'object' && action.type === 'COMPOSITE' ? action.composite : action;\nconst InitAction = callback => action => callback({type: 'COMPOSITE', composite: action});\nconst MutateMethod = (callback, key, structure) => action => {\n let arg = Array.isArray(structure) ? [] : {}\n arg[key] = action;\n return callback(arg);\n}\nconst ActionMutateMethod = (action, key) => typeof action === 'object' && typeof action.type === 'string' && action.type.indexOf('@@') === 0\n ? action\n : DefaultMutationMethod(key)(action);\n\nexport {ReduxAction, InitAction, MutateMethod, ActionMutateMethod};\nexport default ReduxAction;\n\n\n\n// WEBPACK FOOTER //\n// ./src/Helper/ReduxAction.js","import {Defaults} from 'walk-composite';\n\nconst DefaultMutationMethod = key => data => Defaults.MutationMethod(key)(data)[0];\nexport default DefaultMutationMethod;\n\n\n\n// WEBPACK FOOTER //\n// ./src/Helper/DefaultMutationMethod.js","import WalkComposite from '../Helper/WalkComposite';\nimport {ReduxAction, InitAction, MutateMethod} from '../Helper/ReduxAction';\nimport DefaultMutationMethod from '../Helper/DefaultMutationMethod';\nimport InitWalk from '../Helper/InitWalk';\n\nconst Middleware = compositeStructure => ({dispatch, getState}) => {\n const initMiddleware = InitWalk()(\n (composite, dispatch, getState) => composite.middleware({getState, dispatch})\n )(\n compositeStructure,\n dispatch,\n getState\n );\n return next => {\n const initNextMiddleware = WalkComposite({\n mutationMethod: key => (composite, next, middleware) => [\n DefaultMutationMethod(key)(composite),\n MutateMethod(next, key, composite),\n DefaultMutationMethod(key)(middleware)\n ]\n })(\n (composite, next, middleware) => middleware(next)\n )(\n compositeStructure,\n InitAction(next),\n initMiddleware\n );\n return action => action === undefined\n ? next(action)\n : WalkComposite()(\n (composite, next, action) => action === undefined ? undefined : next(action)\n )(\n compositeStructure,\n initNextMiddleware,\n ReduxAction(action)\n );\n };\n};\n\nexport default Middleware;\n\n\n\n// WEBPACK FOOTER //\n// ./src/Composite/Middleware.js","import WalkComposite from '../Helper/WalkComposite';\nimport {InitAction, MutateMethod} from '../Helper/ReduxAction';\nimport DefaultMutationMethod from '../Helper/DefaultMutationMethod';\nimport {Defaults} from 'walk-composite';\n\nconst InitWalk = (parameters = {}) => WalkComposite({\n mutationMethod: key => (composite, dispatch, getState, ...other) => [\n DefaultMutationMethod(key)(composite),\n MutateMethod(dispatch, key, composite),\n () => getState()[key],\n ...Defaults.MutationMethod(key)(...other)\n ],\n walkMethod: InitWalk,\n ...parameters\n});\n\nexport default InitWalk;\n\n\n\n// WEBPACK FOOTER //\n// ./src/Helper/InitWalk.js","import WalkComposite from '../Helper/WalkComposite';\n\nconst Equality = compositeStructure => (prev, next) => {\n if (prev === next) {\n return true;\n }\n let result = true;\n WalkComposite()((composite, prev, next) => {\n const equal = composite.equality(prev, next);\n result = result && equal;\n return equal;\n })(compositeStructure, prev, next);\n return result;\n};\nexport default Equality;\n\n\n\n// WEBPACK FOOTER //\n// ./src/Composite/Equality.js","import InitWalk from '../Helper/InitWalk';\nimport WalkComposite from '../Helper/WalkComposite';\n\nconst Subscribe = compositeStructure => (dispatch, getState) => listeners => {\n if (typeof listeners === 'function') {\n return () => listeners({dispatch, getState})\n }\n const initSubscribe = InitWalk()(\n (composite, dispatch, getState, listener) => composite.subscribe(dispatch, getState)(listener)\n )(\n compositeStructure,\n dispatch,\n getState,\n listeners\n );\n return () => WalkComposite()(\n (composite, subscribe) => subscribe()\n )(\n compositeStructure,\n initSubscribe\n )\n};\n\nexport default Subscribe;\n\n\n\n// WEBPACK FOOTER //\n// ./src/Composite/Subscribe.js","import WalkComposite from '../Helper/WalkComposite';\nimport {MutateMethod} from '../Helper/ReduxAction';\nimport DefaultMutationMethod from '../Helper/DefaultMutationMethod';\n\nconst Redux = compositeStructure => (dispatch, getState, subscribe) => {\n const redux = {dispatch, getState, subscribe};\n const structure = WalkComposite({\n mutationMethod: key => (composite, dispatch, getState, subscribe) => [\n DefaultMutationMethod(key)(composite),\n MutateMethod(dispatch, key, composite),\n () => getState()[key],\n listeners => {\n let arg = Array.isArray(composite) ? [] : {};\n arg[key] = listeners;\n return subscribe(arg)\n }\n ]\n })(\n (composite, dispatch, getState, subscribe) => composite.redux(dispatch, getState, subscribe)\n )(\n compositeStructure,\n dispatch,\n getState,\n subscribe\n );\n return {\n redux,\n structure\n };\n};\n\nexport default Redux;\n\n\n\n// WEBPACK FOOTER //\n// ./src/Composite/Redux.js","import WalkComposite from '../Helper/WalkComposite';\nimport DefaultMutationMethod from '../Helper/DefaultMutationMethod';\n\nconst Memoize = compositeStructure => getState => {\n const memoize = callback => callback;\n const structure = WalkComposite({\n mutationMethod: key => (composite, getState) => [\n DefaultMutationMethod(key)(composite),\n () => getState()[key]\n ]\n })(\n (composite, getState) => composite.memoize(getState)\n )(compositeStructure, getState);\n return {\n memoize,\n structure\n };\n};\n\nexport default Memoize;\n\n\n\n// WEBPACK FOOTER //\n// ./src/Composite/Memoize.js","import {Walk, Defaults} from 'walk-composite';\n\nconst useStructure = node => typeof node.redux === 'object' && node.structure !== undefined\n\nconst WalkRedux = (originalStore, parameters = {}) => Walk({\n leafCondition: node => node.redux !== undefined\n && (node.structure === undefined || originalStore !== node),\n keysMethod: node => Defaults.KeysMethod(useStructure(node) ? node.structure : node),\n mutationMethod: key => node => [(useStructure(node) ? node.structure : node)[key]],\n walkMethod: parameters => WalkRedux(originalStore, parameters),\n reducerMethod: {\n add: Defaults.ReducerMethod.add,\n init: node => Defaults.ReducerMethod.init(useStructure(node) ? node.structure : node)\n },\n ...parameters\n})\n\nconst ReduxByRedux = redux => ({\n structure: WalkRedux(redux)(leaf => useStructure(leaf) ? ReduxByRedux(leaf) : leaf.redux)(redux),\n store: redux.redux\n});\n\nexport const Redux = composite => ({dispatch, getState, subscribe}) => ReduxByRedux(composite.redux(\n dispatch,\n getState,\n composite.subscribe(dispatch, getState, subscribe)\n))\n\nexport default Redux;\n\n\n\n// WEBPACK FOOTER //\n// ./src/Redux.js","import {Walk, Defaults} from 'walk-composite';\nimport {MutateMethod} from './Helper/ReduxAction';\n\nconst useStructure = memoize => typeof memoize.memoize === 'function' && memoize.structure !== undefined\n\nconst MemoizeWalk = (originalMemoize, parameters = {}) => Walk({\n leafCondition: memoize => typeof memoize.memoize === 'function'\n && (memoize.structure === undefined || memoize !== originalMemoize),\n keysMethod: memoize => Defaults.KeysMethod(useStructure(memoize) ? memoize.structure : memoize),\n mutationMethod: key => (memoize, memoizeStructure, dispatch, getState, subscribe) => {\n const structure = useStructure(memoize) ? memoize.structure : memoize;\n return [\n structure[key],\n (structure => structure !== undefined && structure[key] !== undefined ? structure[key] : undefined)(useStructure(memoize) ? memoizeStructure.structure : memoizeStructure),\n MutateMethod(dispatch, key, structure),\n () => getState()[key],\n listeners => {\n let arg = Array.isArray(structure) ? [] : {};\n arg[key] = listeners;\n return subscribe(arg)\n }\n ]\n },\n reducerMethod: {\n add: Defaults.ReducerMethod.add,\n init: memoize => Defaults.ReducerMethod.init(useStructure(memoize) ? memoize.structure : memoize)\n },\n walkMethod: parameters => MemoizeWalk(originalMemoize, parameters),\n ...parameters\n})\n\nconst MemoizeByMemoize = memoize => ({dispatch, getState, subscribe}) => {\n return memoizationStructure => {\n const structure = MemoizeWalk(memoize)(\n (memoize, structure, dispatch, getState, subscribe) => structure === undefined ? undefined : (memoized => memoize.structure === undefined ? memoized : MemoizeByMemoize(memoize)({dispatch, getState, subscribe})(structure))(memoize.memoize(() => structure({\n dispatch,\n getState,\n structure,\n subscribe\n })))\n )(memoize, memoizationStructure, dispatch, getState, subscribe)\n return {\n structure,\n ...(memoizationStructure => typeof memoizationStructure === 'function' ? {\n memoize: memoize.memoize(() => memoizationStructure({structure, dispatch, getState, subscribe}))\n } : {})(typeof memoizationStructure === 'function' ? memoizationStructure : memoizationStructure.memoize)\n }\n }\n}\n\nexport const Memoize = (memoize, store) => MemoizeByMemoize(memoize(store.getState))(store)\n\nexport default Memoize\n\n\n\n// WEBPACK FOOTER //\n// ./src/Memoize.js","import {Walk, Defaults} from 'walk-composite';\n\nexport const Reduce = action => {\n let actions = [];\n let payload = undefined;\n if (typeof action !== 'object' || action === null || action.type !== 'COMPOSITE' || typeof action.composite !== 'object') {\n return action;\n }\n Walk({\n keysMethod: (action, path) => {\n const { type, ...rest } = action;\n if (type !== undefined && (type !== 'COMPOSITE' || typeof rest.composite !== 'object')) {\n actions.push(type + '\\\\' + path);\n if (Object.keys(rest).length !== 0) {\n if (payload === undefined) {\n payload = {};\n }\n payload[path] = rest;\n }\n }\n return Defaults.KeysMethod(rest);\n },\n mutationMethod: key => (action, path) => [\n Defaults.MutationMethod(key)(action)[0],\n action.type === 'COMPOSITE' && typeof action.composite === 'object' && key === 'composite'\n ? path\n : (key => path === '' ? key : path + '\\\\' + key)(Array.isArray(action) ? `[${key}]` : `{${key}}`)\n ]\n })(() => {})(action.composite, '')\n return {type: actions.join('\\n'), payload};\n}\n\nexport default Reduce;\n\n\n\n// WEBPACK FOOTER //\n// ./src/Prettify/Reduce.js","export const Expand = action => {\n if (typeof action !== 'object' || action === null || typeof action.type !== 'string') {\n return action;\n }\n try {\n let compositeChecked = undefined, composite = undefined;\n const actions = action.type.split('\\n').map(a => {\n const [type, ...path] = a.split('\\\\');\n if (type === undefined) {\n throw {\n message: 'action.type is undefined - use format \"ACTION_TYPE\\\\{key1}\\\\[key2]\\\\{key3}\"',\n type\n };\n }\n if (path.length === 0) {\n throw {\n message: 'path for composite is not defined - use format \"ACTION_TYPE\\\\{key1}\\\\[key2]\\\\{key3}\"',\n type: a\n }\n }\n let result = {\n type,\n ...((p => typeof action.payload === 'object' && action.payload !== null && typeof action.payload[p] === 'object' && action.payload[p] !== null ? action.payload[p] : {})(path.join('\\\\')))\n };\n let lastChecked = true;\n path.reverse().map(item => {\n let checked = /^\\{.*\\}$/.test(item) ? true : (/^\\[.*\\]$/.test(item) ? false : undefined );\n if (checked === undefined) {\n throw {\n message: 'path item is not in the right format: should be either {key} or [key]',\n item\n }\n }\n lastChecked = checked;\n checked = checked ? {} : [];\n checked[item.substr(1, item.length - 2)] = result;\n result = checked;\n })\n if (compositeChecked === undefined) {\n compositeChecked = lastChecked;\n composite = compositeChecked ? {} : [];\n } else if (compositeChecked !== lastChecked) {\n throw {\n message: 'inconsistency in action paths: [] !== {}'\n }\n }\n if (compositeChecked) {\n composite = {...composite, ...result};\n } else {\n result.map((value, i) => composite[i] = value);\n }\n })\n return {type: 'COMPOSITE', composite};\n } catch (e) {\n // console.warn('Action could not be expanded', e, action);\n return action;\n }\n}\n\nexport default Expand;\n\n\n\n// WEBPACK FOOTER //\n// ./src/Prettify/Expand.js","'use strict';\n\nexports.__esModule = true;\nexports.compose = exports.applyMiddleware = exports.bindActionCreators = exports.combineReducers = exports.createStore = undefined;\n\nvar _createStore = require('./createStore');\n\nvar _createStore2 = _interopRequireDefault(_createStore);\n\nvar _combineReducers = require('./combineReducers');\n\nvar _combineReducers2 = _interopRequireDefault(_combineReducers);\n\nvar _bindActionCreators = require('./bindActionCreators');\n\nvar _bindActionCreators2 = _interopRequireDefault(_bindActionCreators);\n\nvar _applyMiddleware = require('./applyMiddleware');\n\nvar _applyMiddleware2 = _interopRequireDefault(_applyMiddleware);\n\nvar _compose = require('./compose');\n\nvar _compose2 = _interopRequireDefault(_compose);\n\nvar _warning = require('./utils/warning');\n\nvar _warning2 = _interopRequireDefault(_warning);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\n/*\n* This is a dummy function to check if the function name has been altered by minification.\n* If the function has been minified and NODE_ENV !== 'production', warn the user.\n*/\nfunction isCrushed() {}\n\nif (process.env.NODE_ENV !== 'production' && typeof isCrushed.name === 'string' && isCrushed.name !== 'isCrushed') {\n (0, _warning2['default'])('You are currently using minified code outside of NODE_ENV === \\'production\\'. ' + 'This means that you are running a slower development build of Redux. ' + 'You can use loose-envify (https://github.com/zertosh/loose-envify) for browserify ' + 'or DefinePlugin for webpack (http://stackoverflow.com/questions/30030031) ' + 'to ensure you have the correct code for your production build.');\n}\n\nexports.createStore = _createStore2['default'];\nexports.combineReducers = _combineReducers2['default'];\nexports.bindActionCreators = _bindActionCreators2['default'];\nexports.applyMiddleware = _applyMiddleware2['default'];\nexports.compose = _compose2['default'];\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/redux/lib/index.js\n// module id = 19\n// module chunks = 0 1","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things. But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals. It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n throw new Error('clearTimeout has not been defined');\n}\n(function () {\n try {\n if (typeof setTimeout === 'function') {\n cachedSetTimeout = setTimeout;\n } else {\n cachedSetTimeout = defaultSetTimout;\n }\n } catch (e) {\n cachedSetTimeout = defaultSetTimout;\n }\n try {\n if (typeof clearTimeout === 'function') {\n cachedClearTimeout = clearTimeout;\n } else {\n cachedClearTimeout = defaultClearTimeout;\n }\n } catch (e) {\n cachedClearTimeout = defaultClearTimeout;\n }\n} ())\nfunction runTimeout(fun) {\n if (cachedSetTimeout === setTimeout) {\n //normal enviroments in sane situations\n return setTimeout(fun, 0);\n }\n // if setTimeout wasn't available but was latter defined\n if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n cachedSetTimeout = setTimeout;\n return setTimeout(fun, 0);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedSetTimeout(fun, 0);\n } catch(e){\n try {\n // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n return cachedSetTimeout.call(null, fun, 0);\n } catch(e){\n // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n return cachedSetTimeout.call(this, fun, 0);\n }\n }\n\n\n}\nfunction runClearTimeout(marker) {\n if (cachedClearTimeout === clearTimeout) {\n //normal enviroments in sane situations\n return clearTimeout(marker);\n }\n // if clearTimeout wasn't available but was latter defined\n if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n cachedClearTimeout = clearTimeout;\n return clearTimeout(marker);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedClearTimeout(marker);\n } catch (e){\n try {\n // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n return cachedClearTimeout.call(null, marker);\n } catch (e){\n // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n return cachedClearTimeout.call(this, marker);\n }\n }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n if (!draining || !currentQueue) {\n return;\n }\n draining = false;\n if (currentQueue.length) {\n queue = currentQueue.concat(queue);\n } else {\n queueIndex = -1;\n }\n if (queue.length) {\n drainQueue();\n }\n}\n\nfunction drainQueue() {\n if (draining) {\n return;\n }\n var timeout = runTimeout(cleanUpNextTick);\n draining = true;\n\n var len = queue.length;\n while(len) {\n currentQueue = queue;\n queue = [];\n while (++queueIndex < len) {\n if (currentQueue) {\n currentQueue[queueIndex].run();\n }\n }\n queueIndex = -1;\n len = queue.length;\n }\n currentQueue = null;\n draining = false;\n runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n var args = new Array(arguments.length - 1);\n if (arguments.length > 1) {\n for (var i = 1; i < arguments.length; i++) {\n args[i - 1] = arguments[i];\n }\n }\n queue.push(new Item(fun, args));\n if (queue.length === 1 && !draining) {\n runTimeout(drainQueue);\n }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n this.fun = fun;\n this.array = array;\n}\nItem.prototype.run = function () {\n this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/process/browser.js\n// module id = 20\n// module chunks = 0 1","'use strict';\n\nexports.__esModule = true;\nexports.ActionTypes = undefined;\nexports['default'] = createStore;\n\nvar _isPlainObject = require('lodash/isPlainObject');\n\nvar _isPlainObject2 = _interopRequireDefault(_isPlainObject);\n\nvar _symbolObservable = require('symbol-observable');\n\nvar _symbolObservable2 = _interopRequireDefault(_symbolObservable);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\n/**\n * These are private action types reserved by Redux.\n * For any unknown actions, you must return the current state.\n * If the current state is undefined, you must return the initial state.\n * Do not reference these action types directly in your code.\n */\nvar ActionTypes = exports.ActionTypes = {\n INIT: '@@redux/INIT'\n\n /**\n * Creates a Redux store that holds the state tree.\n * The only way to change the data in the store is to call `dispatch()` on it.\n *\n * There should only be a single store in your app. To specify how different\n * parts of the state tree respond to actions, you may combine several reducers\n * into a single reducer function by using `combineReducers`.\n *\n * @param {Function} reducer A function that returns the next state tree, given\n * the current state tree and the action to handle.\n *\n * @param {any} [preloadedState] The initial state. You may optionally specify it\n * to hydrate the state from the server in universal apps, or to restore a\n * previously serialized user session.\n * If you use `combineReducers` to produce the root reducer function, this must be\n * an object with the same shape as `combineReducers` keys.\n *\n * @param {Function} [enhancer] The store enhancer. You may optionally specify it\n * to enhance the store with third-party capabilities such as middleware,\n * time travel, persistence, etc. The only store enhancer that ships with Redux\n * is `applyMiddleware()`.\n *\n * @returns {Store} A Redux store that lets you read the state, dispatch actions\n * and subscribe to changes.\n */\n};function createStore(reducer, preloadedState, enhancer) {\n var _ref2;\n\n if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') {\n enhancer = preloadedState;\n preloadedState = undefined;\n }\n\n if (typeof enhancer !== 'undefined') {\n if (typeof enhancer !== 'function') {\n throw new Error('Expected the enhancer to be a function.');\n }\n\n return enhancer(createStore)(reducer, preloadedState);\n }\n\n if (typeof reducer !== 'function') {\n throw new Error('Expected the reducer to be a function.');\n }\n\n var currentReducer = reducer;\n var currentState = preloadedState;\n var currentListeners = [];\n var nextListeners = currentListeners;\n var isDispatching = false;\n\n function ensureCanMutateNextListeners() {\n if (nextListeners === currentListeners) {\n nextListeners = currentListeners.slice();\n }\n }\n\n /**\n * Reads the state tree managed by the store.\n *\n * @returns {any} The current state tree of your application.\n */\n function getState() {\n return currentState;\n }\n\n /**\n * Adds a change listener. It will be called any time an action is dispatched,\n * and some part of the state tree may potentially have changed. You may then\n * call `getState()` to read the current state tree inside the callback.\n *\n * You may call `dispatch()` from a change listener, with the following\n * caveats:\n *\n * 1. The subscriptions are snapshotted just before every `dispatch()` call.\n * If you subscribe or unsubscribe while the listeners are being invoked, this\n * will not have any effect on the `dispatch()` that is currently in progress.\n * However, the next `dispatch()` call, whether nested or not, will use a more\n * recent snapshot of the subscription list.\n *\n * 2. The listener should not expect to see all state changes, as the state\n * might have been updated multiple times during a nested `dispatch()` before\n * the listener is called. It is, however, guaranteed that all subscribers\n * registered before the `dispatch()` started will be called with the latest\n * state by the time it exits.\n *\n * @param {Function} listener A callback to be invoked on every dispatch.\n * @returns {Function} A function to remove this change listener.\n */\n function subscribe(listener) {\n if (typeof listener !== 'function') {\n throw new Error('Expected listener to be a function.');\n }\n\n var isSubscribed = true;\n\n ensureCanMutateNextListeners();\n nextListeners.push(listener);\n\n return function unsubscribe() {\n if (!isSubscribed) {\n return;\n }\n\n isSubscribed = false;\n\n ensureCanMutateNextListeners();\n var index = nextListeners.indexOf(listener);\n nextListeners.splice(index, 1);\n };\n }\n\n /**\n * Dispatches an action. It is the only way to trigger a state change.\n *\n * The `reducer` function, used to create the store, will be called with the\n * current state tree and the given `action`. Its return value will\n * be considered the **next** state of the tree, and the change listeners\n * will be notified.\n *\n * The base implementation only supports plain object actions. If you want to\n * dispatch a Promise, an Observable, a thunk, or something else, you need to\n * wrap your store creating function into the corresponding middleware. For\n * example, see the documentation for the `redux-thunk` package. Even the\n * middleware will eventually dispatch plain object actions using this method.\n *\n * @param {Object} action A plain object representing “what changed”. It is\n * a good idea to keep actions serializable so you can record and replay user\n * sessions, or use the time travelling `redux-devtools`. An action must have\n * a `type` property which may not be `undefined`. It is a good idea to use\n * string constants for action types.\n *\n * @returns {Object} For convenience, the same action object you dispatched.\n *\n * Note that, if you use a custom middleware, it may wrap `dispatch()` to\n * return something else (for example, a Promise you can await).\n */\n function dispatch(action) {\n if (!(0, _isPlainObject2['default'])(action)) {\n throw new Error('Actions must be plain objects. ' + 'Use custom middleware for async actions.');\n }\n\n if (typeof action.type === 'undefined') {\n throw new Error('Actions may not have an undefined \"type\" property. ' + 'Have you misspelled a constant?');\n }\n\n if (isDispatching) {\n throw new Error('Reducers may not dispatch actions.');\n }\n\n try {\n isDispatching = true;\n currentState = currentReducer(currentState, action);\n } finally {\n isDispatching = false;\n }\n\n var listeners = currentListeners = nextListeners;\n for (var i = 0; i < listeners.length; i++) {\n var listener = listeners[i];\n listener();\n }\n\n return action;\n }\n\n /**\n * Replaces the reducer currently used by the store to calculate the state.\n *\n * You might need this if your app implements code splitting and you want to\n * load some of the reducers dynamically. You might also need this if you\n * implement a hot reloading mechanism for Redux.\n *\n * @param {Function} nextReducer The reducer for the store to use instead.\n * @returns {void}\n */\n function replaceReducer(nextReducer) {\n if (typeof nextReducer !== 'function') {\n throw new Error('Expected the nextReducer to be a function.');\n }\n\n currentReducer = nextReducer;\n dispatch({ type: ActionTypes.INIT });\n }\n\n /**\n * Interoperability point for observable/reactive libraries.\n * @returns {observable} A minimal observable of state changes.\n * For more information, see the observable proposal:\n * https://github.com/tc39/proposal-observable\n */\n function observable() {\n var _ref;\n\n var outerSubscribe = subscribe;\n return _ref = {\n /**\n * The minimal observable subscription method.\n * @param {Object} observer Any object that can be used as an observer.\n * The observer object should have a `next` method.\n * @returns {subscription} An object with an `unsubscribe` method that can\n * be used to unsubscribe the observable from the store, and prevent further\n * emission of values from the observable.\n */\n subscribe: function subscribe(observer) {\n if (typeof observer !== 'object') {\n throw new TypeError('Expected the observer to be an object.');\n }\n\n function observeState() {\n if (observer.next) {\n observer.next(getState());\n }\n }\n\n observeState();\n var unsubscribe = outerSubscribe(observeState);\n return { unsubscribe: unsubscribe };\n }\n }, _ref[_symbolObservable2['default']] = function () {\n return this;\n }, _ref;\n }\n\n // When a store is created, an \"INIT\" action is dispatched so that every\n // reducer returns their initial state. This effectively populates\n // the initial state tree.\n dispatch({ type: ActionTypes.INIT });\n\n return _ref2 = {\n dispatch: dispatch,\n subscribe: subscribe,\n getState: getState,\n replaceReducer: replaceReducer\n }, _ref2[_symbolObservable2['default']] = observable, _ref2;\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/redux/lib/createStore.js\n// module id = 21\n// module chunks = 0 1","var baseGetTag = require('./_baseGetTag'),\n getPrototype = require('./_getPrototype'),\n isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar objectTag = '[object Object]';\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to infer the `Object` constructor. */\nvar objectCtorString = funcToString.call(Object);\n\n/**\n * Checks if `value` is a plain object, that is, an object created by the\n * `Object` constructor or one with a `[[Prototype]]` of `null`.\n *\n * @static\n * @memberOf _\n * @since 0.8.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * }\n *\n * _.isPlainObject(new Foo);\n * // => false\n *\n * _.isPlainObject([1, 2, 3]);\n * // => false\n *\n * _.isPlainObject({ 'x': 0, 'y': 0 });\n * // => true\n *\n * _.isPlainObject(Object.create(null));\n * // => true\n */\nfunction isPlainObject(value) {\n if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n return false;\n }\n var proto = getPrototype(value);\n if (proto === null) {\n return true;\n }\n var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n return typeof Ctor == 'function' && Ctor instanceof Ctor &&\n funcToString.call(Ctor) == objectCtorString;\n}\n\nmodule.exports = isPlainObject;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/isPlainObject.js\n// module id = 22\n// module chunks = 0 1","var Symbol = require('./_Symbol'),\n getRawTag = require('./_getRawTag'),\n objectToString = require('./_objectToString');\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\nmodule.exports = baseGetTag;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_baseGetTag.js\n// module id = 23\n// module chunks = 0 1","var root = require('./_root');\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nmodule.exports = Symbol;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_Symbol.js\n// module id = 24\n// module chunks = 0 1","var freeGlobal = require('./_freeGlobal');\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\nmodule.exports = root;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_root.js\n// module id = 25\n// module chunks = 0 1","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nmodule.exports = freeGlobal;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_freeGlobal.js\n// module id = 26\n// module chunks = 0 1","var Symbol = require('./_Symbol');\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\nmodule.exports = getRawTag;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_getRawTag.js\n// module id = 27\n// module chunks = 0 1","/** 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\nmodule.exports = objectToString;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_objectToString.js\n// module id = 28\n// module chunks = 0 1","var overArg = require('./_overArg');\n\n/** Built-in value references. */\nvar getPrototype = overArg(Object.getPrototypeOf, Object);\n\nmodule.exports = getPrototype;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_getPrototype.js\n// module id = 29\n// module chunks = 0 1","/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n return function(arg) {\n return func(transform(arg));\n };\n}\n\nmodule.exports = overArg;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/_overArg.js\n// module id = 30\n// module chunks = 0 1","/**\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\nmodule.exports = isObjectLike;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/lodash/isObjectLike.js\n// module id = 31\n// module chunks = 0 1","module.exports = require('./lib/index');\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/symbol-observable/index.js\n// module id = 32\n// module chunks = 0 1","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _ponyfill = require('./ponyfill');\n\nvar _ponyfill2 = _interopRequireDefault(_ponyfill);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar root; /* global window */\n\n\nif (typeof self !== 'undefined') {\n root = self;\n} else if (typeof window !== 'undefined') {\n root = window;\n} else if (typeof global !== 'undefined') {\n root = global;\n} else if (typeof module !== 'undefined') {\n root = module;\n} else {\n root = Function('return this')();\n}\n\nvar result = (0, _ponyfill2['default'])(root);\nexports['default'] = result;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/symbol-observable/lib/index.js\n// module id = 33\n// module chunks = 0 1","module.exports = function(module) {\r\n\tif(!module.webpackPolyfill) {\r\n\t\tmodule.deprecate = function() {};\r\n\t\tmodule.paths = [];\r\n\t\t// module.parent = undefined by default\r\n\t\tmodule.children = [];\r\n\t\tmodule.webpackPolyfill = 1;\r\n\t}\r\n\treturn module;\r\n}\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// (webpack)/buildin/module.js\n// module id = 34\n// module chunks = 0 1","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n\tvalue: true\n});\nexports['default'] = symbolObservablePonyfill;\nfunction symbolObservablePonyfill(root) {\n\tvar result;\n\tvar _Symbol = root.Symbol;\n\n\tif (typeof _Symbol === 'function') {\n\t\tif (_Symbol.observable) {\n\t\t\tresult = _Symbol.observable;\n\t\t} else {\n\t\t\tresult = _Symbol('observable');\n\t\t\t_Symbol.observable = result;\n\t\t}\n\t} else {\n\t\tresult = '@@observable';\n\t}\n\n\treturn result;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/symbol-observable/lib/ponyfill.js\n// module id = 35\n// module chunks = 0 1","'use strict';\n\nexports.__esModule = true;\nexports['default'] = combineReducers;\n\nvar _createStore = require('./createStore');\n\nvar _isPlainObject = require('lodash/isPlainObject');\n\nvar _isPlainObject2 = _interopRequireDefault(_isPlainObject);\n\nvar _warning = require('./utils/warning');\n\nvar _warning2 = _interopRequireDefault(_warning);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction getUndefinedStateErrorMessage(key, action) {\n var actionType = action && action.type;\n var actionName = actionType && '\"' + actionType.toString() + '\"' || 'an action';\n\n return 'Given action ' + actionName + ', reducer \"' + key + '\" returned undefined. ' + 'To ignore an action, you must explicitly return the previous state. ' + 'If you want this reducer to hold no value, you can return null instead of undefined.';\n}\n\nfunction getUnexpectedStateShapeWarningMessage(inputState, reducers, action, unexpectedKeyCache) {\n var reducerKeys = Object.keys(reducers);\n var argumentName = action && action.type === _createStore.ActionTypes.INIT ? 'preloadedState argument passed to createStore' : 'previous state received by the reducer';\n\n if (reducerKeys.length === 0) {\n return 'Store does not have a valid reducer. Make sure the argument passed ' + 'to combineReducers is an object whose values are reducers.';\n }\n\n if (!(0, _isPlainObject2['default'])(inputState)) {\n return 'The ' + argumentName + ' has unexpected type of \"' + {}.toString.call(inputState).match(/\\s([a-z|A-Z]+)/)[1] + '\". Expected argument to be an object with the following ' + ('keys: \"' + reducerKeys.join('\", \"') + '\"');\n }\n\n var unexpectedKeys = Object.keys(inputState).filter(function (key) {\n return !reducers.hasOwnProperty(key) && !unexpectedKeyCache[key];\n });\n\n unexpectedKeys.forEach(function (key) {\n unexpectedKeyCache[key] = true;\n });\n\n if (unexpectedKeys.length > 0) {\n return 'Unexpected ' + (unexpectedKeys.length > 1 ? 'keys' : 'key') + ' ' + ('\"' + unexpectedKeys.join('\", \"') + '\" found in ' + argumentName + '. ') + 'Expected to find one of the known reducer keys instead: ' + ('\"' + reducerKeys.join('\", \"') + '\". Unexpected keys will be ignored.');\n }\n}\n\nfunction assertReducerShape(reducers) {\n Object.keys(reducers).forEach(function (key) {\n var reducer = reducers[key];\n var initialState = reducer(undefined, { type: _createStore.ActionTypes.INIT });\n\n if (typeof initialState === 'undefined') {\n throw new Error('Reducer \"' + key + '\" returned undefined during initialization. ' + 'If the state passed to the reducer is undefined, you must ' + 'explicitly return the initial state. The initial state may ' + 'not be undefined. If you don\\'t want to set a value for this reducer, ' + 'you can use null instead of undefined.');\n }\n\n var type = '@@redux/PROBE_UNKNOWN_ACTION_' + Math.random().toString(36).substring(7).split('').join('.');\n if (typeof reducer(undefined, { type: type }) === 'undefined') {\n throw new Error('Reducer \"' + key + '\" returned undefined when probed with a random type. ' + ('Don\\'t try to handle ' + _createStore.ActionTypes.INIT + ' or other actions in \"redux/*\" ') + 'namespace. They are considered private. Instead, you must return the ' + 'current state for any unknown actions, unless it is undefined, ' + 'in which case you must return the initial state, regardless of the ' + 'action type. The initial state may not be undefined, but can be null.');\n }\n });\n}\n\n/**\n * Turns an object whose values are different reducer functions, into a single\n * reducer function. It will call every child reducer, and gather their results\n * into a single state object, whose keys correspond to the keys of the passed\n * reducer functions.\n *\n * @param {Object} reducers An object whose values correspond to different\n * reducer functions that need to be combined into one. One handy way to obtain\n * it is to use ES6 `import * as reducers` syntax. The reducers may never return\n * undefined for any action. Instead, they should return their initial state\n * if the state passed to them was undefined, and the current state for any\n * unrecognized action.\n *\n * @returns {Function} A reducer function that invokes every reducer inside the\n * passed object, and builds a state object with the same shape.\n */\nfunction combineReducers(reducers) {\n var reducerKeys = Object.keys(reducers);\n var finalReducers = {};\n for (var i = 0; i < reducerKeys.length; i++) {\n var key = reducerKeys[i];\n\n if (process.env.NODE_ENV !== 'production') {\n if (typeof reducers[key] === 'undefined') {\n (0, _warning2['default'])('No reducer provided for key \"' + key + '\"');\n }\n }\n\n if (typeof reducers[key] === 'function') {\n finalReducers[key] = reducers[key];\n }\n }\n var finalReducerKeys = Object.keys(finalReducers);\n\n var unexpectedKeyCache = void 0;\n if (process.env.NODE_ENV !== 'production') {\n unexpectedKeyCache = {};\n }\n\n var shapeAssertionError = void 0;\n try {\n assertReducerShape(finalReducers);\n } catch (e) {\n shapeAssertionError = e;\n }\n\n return function combination() {\n var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n var action = arguments[1];\n\n if (shapeAssertionError) {\n throw shapeAssertionError;\n }\n\n if (process.env.NODE_ENV !== 'production') {\n var warningMessage = getUnexpectedStateShapeWarningMessage(state, finalReducers, action, unexpectedKeyCache);\n if (warningMessage) {\n (0, _warning2['default'])(warningMessage);\n }\n }\n\n var hasChanged = false;\n var nextState = {};\n for (var _i = 0; _i < finalReducerKeys.length; _i++) {\n var _key = finalReducerKeys[_i];\n var reducer = finalReducers[_key];\n var previousStateForKey = state[_key];\n var nextStateForKey = reducer(previousStateForKey, action);\n if (typeof nextStateForKey === 'undefined') {\n var errorMessage = getUndefinedStateErrorMessage(_key, action);\n throw new Error(errorMessage);\n }\n nextState[_key] = nextStateForKey;\n hasChanged = hasChanged || nextStateForKey !== previousStateForKey;\n }\n return hasChanged ? nextState : state;\n };\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/redux/lib/combineReducers.js\n// module id = 36\n// module chunks = 0 1","'use strict';\n\nexports.__esModule = true;\nexports['default'] = warning;\n/**\n * Prints a warning in the console if it exists.\n *\n * @param {String} message The warning message.\n * @returns {void}\n */\nfunction warning(message) {\n /* eslint-disable no-console */\n if (typeof console !== 'undefined' && typeof console.error === 'function') {\n console.error(message);\n }\n /* eslint-enable no-console */\n try {\n // This error was thrown as a convenience so that if you enable\n // \"break on all exceptions\" in your console,\n // it would pause the execution at this line.\n throw new Error(message);\n /* eslint-disable no-empty */\n } catch (e) {}\n /* eslint-enable no-empty */\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/redux/lib/utils/warning.js\n// module id = 37\n// module chunks = 0 1","'use strict';\n\nexports.__esModule = true;\nexports['default'] = bindActionCreators;\nfunction bindActionCreator(actionCreator, dispatch) {\n return function () {\n return dispatch(actionCreator.apply(undefined, arguments));\n };\n}\n\n/**\n * Turns an object whose values are action creators, into an object with the\n * same keys, but with every function wrapped into a `dispatch` call so they\n * may be invoked directly. This is just a convenience method, as you can call\n * `store.dispatch(MyActionCreators.doSomething())` yourself just fine.\n *\n * For convenience, you can also pass a single function as the first argument,\n * and get a function in return.\n *\n * @param {Function|Object} actionCreators An object whose values are action\n * creator functions. One handy way to obtain it is to use ES6 `import * as`\n * syntax. You may also pass a single function.\n *\n * @param {Function} dispatch The `dispatch` function available on your Redux\n * store.\n *\n * @returns {Function|Object} The object mimicking the original object, but with\n * every action creator wrapped into the `dispatch` call. If you passed a\n * function as `actionCreators`, the return value will also be a single\n * function.\n */\nfunction bindActionCreators(actionCreators, dispatch) {\n if (typeof actionCreators === 'function') {\n return bindActionCreator(actionCreators, dispatch);\n }\n\n if (typeof actionCreators !== 'object' || actionCreators === null) {\n throw new Error('bindActionCreators expected an object or a function, instead received ' + (actionCreators === null ? 'null' : typeof actionCreators) + '. ' + 'Did you write \"import ActionCreators from\" instead of \"import * as ActionCreators from\"?');\n }\n\n var keys = Object.keys(actionCreators);\n var boundActionCreators = {};\n for (var i = 0; i < keys.length; i++) {\n var key = keys[i];\n var actionCreator = actionCreators[key];\n if (typeof actionCreator === 'function') {\n boundActionCreators[key] = bindActionCreator(actionCreator, dispatch);\n }\n }\n return boundActionCreators;\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/redux/lib/bindActionCreators.js\n// module id = 38\n// module chunks = 0 1","'use strict';\n\nexports.__esModule = true;\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nexports['default'] = applyMiddleware;\n\nvar _compose = require('./compose');\n\nvar _compose2 = _interopRequireDefault(_compose);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\n/**\n * Creates a store enhancer that applies middleware to the dispatch method\n * of the Redux store. This is handy for a variety of tasks, such as expressing\n * asynchronous actions in a concise manner, or logging every action payload.\n *\n * See `redux-thunk` package as an example of the Redux middleware.\n *\n * Because middleware is potentially asynchronous, this should be the first\n * store enhancer in the composition chain.\n *\n * Note that each middleware will be given the `dispatch` and `getState` functions\n * as named arguments.\n *\n * @param {...Function} middlewares The middleware chain to be applied.\n * @returns {Function} A store enhancer applying the middleware.\n */\nfunction applyMiddleware() {\n for (var _len = arguments.length, middlewares = Array(_len), _key = 0; _key < _len; _key++) {\n middlewares[_key] = arguments[_key];\n }\n\n return function (createStore) {\n return function (reducer, preloadedState, enhancer) {\n var store = createStore(reducer, preloadedState, enhancer);\n var _dispatch = store.dispatch;\n var chain = [];\n\n var middlewareAPI = {\n getState: store.getState,\n dispatch: function dispatch(action) {\n return _dispatch(action);\n }\n };\n chain = middlewares.map(function (middleware) {\n return middleware(middlewareAPI);\n });\n _dispatch = _compose2['default'].apply(undefined, chain)(store.dispatch);\n\n return _extends({}, store, {\n dispatch: _dispatch\n });\n };\n };\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/redux/lib/applyMiddleware.js\n// module id = 39\n// module chunks = 0 1","\"use strict\";\n\nexports.__esModule = true;\nexports[\"default\"] = compose;\n/**\n * Composes single-argument functions from right to left. The rightmost\n * function can take multiple arguments as it provides the signature for\n * the resulting composite function.\n *\n * @param {...Function} funcs The functions to compose.\n * @returns {Function} A function obtained by composing the argument functions\n * from right to left. For example, compose(f, g, h) is identical to doing\n * (...args) => f(g(h(...args))).\n */\n\nfunction compose() {\n for (var _len = arguments.length, funcs = Array(_len), _key = 0; _key < _len; _key++) {\n funcs[_key] = arguments[_key];\n }\n\n if (funcs.length === 0) {\n return function (arg) {\n return arg;\n };\n }\n\n if (funcs.length === 1) {\n return funcs[0];\n }\n\n return funcs.reduce(function (a, b) {\n return function () {\n return a(b.apply(undefined, arguments));\n };\n });\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/redux/lib/compose.js\n// module id = 40\n// module chunks = 0 1","import {Structure} from '../index';\nimport expect from 'expect';\nimport deepFreeze from 'deep-freeze';\n\nconst toggle = (state, action) => state === undefined ? false : (action.type === 'TOGGLE' ? !state : state);\nconst increment = (state, action) => state === undefined ? 0 : (action.type === 'INCREMENT' ? state + 1 : state);\nconst calculator = (state, action) => {\n if (state === undefined) {\n return 0;\n }\n switch (action.type) {\n case 'INCREMENT':\n return state + action.value;\n case 'DECREMENT':\n return state - action.value;\n default:\n return state;\n }\n};\n\nconst checkBoth = reducer => (expected, state, action) => {\n if (state !== undefined) {\n deepFreeze(state);\n }\n expect(reducer(state, action)).toEqual(expected);\n if (typeof action === 'object') {\n expect(reducer(state, {type: 'COMPOSITE', composite: action})).toEqual(expected);\n }\n};\n\nconst test = () => {\n const composite = Structure({toggle, calc: [increment, calculator]});\n let checker = checkBoth(composite.reducer);\n // Init state\n checker({toggle: false, calc: [0, 0]});\n // Run all at the same time\n checker(\n {toggle: false, calc: [2, 0]},\n {toggle: true, calc: [1, 2]},\n {\n toggle: {type: 'TOGGLE'},\n calc: [{type: 'INCREMENT'}, {type: 'DECREMENT', value: 2}]\n }\n );\n // Run only one\n checker(\n {toggle: false, calc: [2, 2]},\n {toggle: false, calc: [1, 2]},\n {\n toggle: {type: 'unknown'},\n calc: [{type: 'INCREMENT'}]\n }\n );\n\n const complex = Structure({increment, reducer: composite});\n checker = checkBoth(complex.reducer);\n // Init state\n checker({increment: 0, reducer: {toggle: false, calc: [0, 0]}});\n // Run all at the same time\n checker(\n {increment: 3, reducer: {toggle: false, calc: [2, 0]}},\n {increment: 2, reducer: {toggle: true, calc: [1, 2]}},\n {\n increment: {type: 'INCREMENT'},\n reducer: {\n toggle: {type: 'TOGGLE'},\n calc: [{type: 'INCREMENT'}, {type: 'DECREMENT', value: 2}]\n }\n }\n );\n // Run only one\n checker(\n {increment: 1, reducer: {toggle: false, calc: [2, 2]}},\n {increment: 1, reducer: {toggle: false, calc: [1, 2]}},\n {\n reducer: {\n toggle: {type: 'unknown'},\n calc: [{type: 'INCREMENT'}]\n }\n }\n );\n};\nexport {toggle, increment, calculator};\nexport default test;\n\n\n\n// WEBPACK FOOTER //\n// ./src/Test/Reducer.js","'use strict';\n\nvar _Expectation = require('./Expectation');\n\nvar _Expectation2 = _interopRequireDefault(_Expectation);\n\nvar _SpyUtils = require('./SpyUtils');\n\nvar _assert = require('./assert');\n\nvar _assert2 = _interopRequireDefault(_assert);\n\nvar _extend = require('./extend');\n\nvar _extend2 = _interopRequireDefault(_extend);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction expect(actual) {\n return new _Expectation2.default(actual);\n}\n\nexpect.createSpy = _SpyUtils.createSpy;\nexpect.spyOn = _SpyUtils.spyOn;\nexpect.isSpy = _SpyUtils.isSpy;\nexpect.restoreSpies = _SpyUtils.restoreSpies;\nexpect.assert = _assert2.default;\nexpect.extend = _extend2.default;\n\nmodule.exports = expect;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/expect/lib/index.js\n// module id = 42\n// module chunks = 1","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol ? \"symbol\" : typeof obj; };\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _has = require('has');\n\nvar _has2 = _interopRequireDefault(_has);\n\nvar _tmatch = require('tmatch');\n\nvar _tmatch2 = _interopRequireDefault(_tmatch);\n\nvar _assert = require('./assert');\n\nvar _assert2 = _interopRequireDefault(_assert);\n\nvar _SpyUtils = require('./SpyUtils');\n\nvar _TestUtils = require('./TestUtils');\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/**\n * An Expectation is a wrapper around an assertion that allows it to be written\n * in a more natural style, without the need to remember the order of arguments.\n * This helps prevent you from making mistakes when writing tests.\n */\n\nvar Expectation = function () {\n function Expectation(actual) {\n _classCallCheck(this, Expectation);\n\n this.actual = actual;\n\n if ((0, _TestUtils.isFunction)(actual)) {\n this.context = null;\n this.args = [];\n }\n }\n\n _createClass(Expectation, [{\n key: 'toExist',\n value: function toExist(message) {\n (0, _assert2.default)(this.actual, message || 'Expected %s to exist', this.actual);\n\n return this;\n }\n }, {\n key: 'toNotExist',\n value: function toNotExist(message) {\n (0, _assert2.default)(!this.actual, message || 'Expected %s to not exist', this.actual);\n\n return this;\n }\n }, {\n key: 'toBe',\n value: function toBe(value, message) {\n (0, _assert2.default)(this.actual === value, message || 'Expected %s to be %s', this.actual, value);\n\n return this;\n }\n }, {\n key: 'toNotBe',\n value: function toNotBe(value, message) {\n (0, _assert2.default)(this.actual !== value, message || 'Expected %s to not be %s', this.actual, value);\n\n return this;\n }\n }, {\n key: 'toEqual',\n value: function toEqual(value, message) {\n try {\n (0, _assert2.default)((0, _TestUtils.isEqual)(this.actual, value), message || 'Expected %s to equal %s', this.actual, value);\n } catch (error) {\n // These attributes are consumed by Mocha to produce a diff output.\n error.actual = this.actual;\n error.expected = value;\n error.showDiff = true;\n throw error;\n }\n\n return this;\n }\n }, {\n key: 'toNotEqual',\n value: function toNotEqual(value, message) {\n (0, _assert2.default)(!(0, _TestUtils.isEqual)(this.actual, value), message || 'Expected %s to not equal %s', this.actual, value);\n\n return this;\n }\n }, {\n key: 'toThrow',\n value: function toThrow(value, message) {\n (0, _assert2.default)((0, _TestUtils.isFunction)(this.actual), 'The \"actual\" argument in expect(actual).toThrow() must be a function, %s was given', this.actual);\n\n (0, _assert2.default)((0, _TestUtils.functionThrows)(this.actual, this.context, this.args, value), message || 'Expected %s to throw %s', this.actual, value || 'an error');\n\n return this;\n }\n }, {\n key: 'toNotThrow',\n value: function toNotThrow(value, message) {\n (0, _assert2.default)((0, _TestUtils.isFunction)(this.actual), 'The \"actual\" argument in expect(actual).toNotThrow() must be a function, %s was given', this.actual);\n\n (0, _assert2.default)(!(0, _TestUtils.functionThrows)(this.actual, this.context, this.args, value), message || 'Expected %s to not throw %s', this.actual, value || 'an error');\n\n return this;\n }\n }, {\n key: 'toBeA',\n value: function toBeA(value, message) {\n (0, _assert2.default)((0, _TestUtils.isFunction)(value) || typeof value === 'string', 'The \"value\" argument in toBeA(value) must be a function or a string');\n\n (0, _assert2.default)((0, _TestUtils.isA)(this.actual, value), message || 'Expected %s to be a %s', this.actual, value);\n\n return this;\n }\n }, {\n key: 'toNotBeA',\n value: function toNotBeA(value, message) {\n (0, _assert2.default)((0, _TestUtils.isFunction)(value) || typeof value === 'string', 'The \"value\" argument in toNotBeA(value) must be a function or a string');\n\n (0, _assert2.default)(!(0, _TestUtils.isA)(this.actual, value), message || 'Expected %s to not be a %s', this.actual, value);\n\n return this;\n }\n }, {\n key: 'toMatch',\n value: function toMatch(pattern, message) {\n (0, _assert2.default)((0, _tmatch2.default)(this.actual, pattern), message || 'Expected %s to match %s', this.actual, pattern);\n\n return this;\n }\n }, {\n key: 'toNotMatch',\n value: function toNotMatch(pattern, message) {\n (0, _assert2.default)(!(0, _tmatch2.default)(this.actual, pattern), message || 'Expected %s to not match %s', this.actual, pattern);\n\n return this;\n }\n }, {\n key: 'toBeLessThan',\n value: function toBeLessThan(value, message) {\n (0, _assert2.default)(typeof this.actual === 'number', 'The \"actual\" argument in expect(actual).toBeLessThan() must be a number');\n\n (0, _assert2.default)(typeof value === 'number', 'The \"value\" argument in toBeLessThan(value) must be a number');\n\n (0, _assert2.default)(this.actual < value, message || 'Expected %s to be less than %s', this.actual, value);\n\n return this;\n }\n }, {\n key: 'toBeLessThanOrEqualTo',\n value: function toBeLessThanOrEqualTo(value, message) {\n (0, _assert2.default)(typeof this.actual === 'number', 'The \"actual\" argument in expect(actual).toBeLessThanOrEqualTo() must be a number');\n\n (0, _assert2.default)(typeof value === 'number', 'The \"value\" argument in toBeLessThanOrEqualTo(value) must be a number');\n\n (0, _assert2.default)(this.actual <= value, message || 'Expected %s to be less than or equal to %s', this.actual, value);\n\n return this;\n }\n }, {\n key: 'toBeGreaterThan',\n value: function toBeGreaterThan(value, message) {\n (0, _assert2.default)(typeof this.actual === 'number', 'The \"actual\" argument in expect(actual).toBeGreaterThan() must be a number');\n\n (0, _assert2.default)(typeof value === 'number', 'The \"value\" argument in toBeGreaterThan(value) must be a number');\n\n (0, _assert2.default)(this.actual > value, message || 'Expected %s to be greater than %s', this.actual, value);\n\n return this;\n }\n }, {\n key: 'toBeGreaterThanOrEqualTo',\n value: function toBeGreaterThanOrEqualTo(value, message) {\n (0, _assert2.default)(typeof this.actual === 'number', 'The \"actual\" argument in expect(actual).toBeGreaterThanOrEqualTo() must be a number');\n\n (0, _assert2.default)(typeof value === 'number', 'The \"value\" argument in toBeGreaterThanOrEqualTo(value) must be a number');\n\n (0, _assert2.default)(this.actual >= value, message || 'Expected %s to be greater than or equal to %s', this.actual, value);\n\n return this;\n }\n }, {\n key: 'toInclude',\n value: function toInclude(value, compareValues, message) {\n if (typeof compareValues === 'string') {\n message = compareValues;\n compareValues = null;\n }\n\n if (compareValues == null) compareValues = _TestUtils.isEqual;\n\n var contains = false;\n\n if ((0, _TestUtils.isArray)(this.actual)) {\n contains = (0, _TestUtils.arrayContains)(this.actual, value, compareValues);\n } else if ((0, _TestUtils.isObject)(this.actual)) {\n contains = (0, _TestUtils.objectContains)(this.actual, value, compareValues);\n } else if (typeof this.actual === 'string') {\n contains = (0, _TestUtils.stringContains)(this.actual, value);\n } else {\n (0, _assert2.default)(false, 'The \"actual\" argument in expect(actual).toInclude() must be an array, object, or a string');\n }\n\n (0, _assert2.default)(contains, message || 'Expected %s to include %s', this.actual, value);\n\n return this;\n }\n }, {\n key: 'toExclude',\n value: function toExclude(value, compareValues, message) {\n if (typeof compareValues === 'string') {\n message = compareValues;\n compareValues = null;\n }\n\n if (compareValues == null) compareValues = _TestUtils.isEqual;\n\n var contains = false;\n\n if ((0, _TestUtils.isArray)(this.actual)) {\n contains = (0, _TestUtils.arrayContains)(this.actual, value, compareValues);\n } else if ((0, _TestUtils.isObject)(this.actual)) {\n contains = (0, _TestUtils.objectContains)(this.actual, value, compareValues);\n } else if (typeof this.actual === 'string') {\n contains = (0, _TestUtils.stringContains)(this.actual, value);\n } else {\n (0, _assert2.default)(false, 'The \"actual\" argument in expect(actual).toExclude() must be an array, object, or a string');\n }\n\n (0, _assert2.default)(!contains, message || 'Expected %s to exclude %s', this.actual, value);\n\n return this;\n }\n }, {\n key: 'toIncludeKeys',\n value: function toIncludeKeys(keys, comparator, message) {\n var _this = this;\n\n if (typeof comparator === 'string') {\n message = comparator;\n comparator = null;\n }\n\n if (comparator == null) comparator = _has2.default;\n\n (0, _assert2.default)(_typeof(this.actual) === 'object', 'The \"actual\" argument in expect(actual).toIncludeKeys() must be an object, not %s', this.actual);\n\n (0, _assert2.default)((0, _TestUtils.isArray)(keys), 'The \"keys\" argument in expect(actual).toIncludeKeys(keys) must be an array, not %s', keys);\n\n var contains = keys.every(function (key) {\n return comparator(_this.actual, key);\n });\n\n (0, _assert2.default)(contains, message || 'Expected %s to include key(s) %s', this.actual, keys.join(', '));\n\n return this;\n }\n }, {\n key: 'toIncludeKey',\n value: function toIncludeKey(key) {\n for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n args[_key - 1] = arguments[_key];\n }\n\n return this.toIncludeKeys.apply(this, [[key]].concat(args));\n }\n }, {\n key: 'toExcludeKeys',\n value: function toExcludeKeys(keys, comparator, message) {\n var _this2 = this;\n\n if (typeof comparator === 'string') {\n message = comparator;\n comparator = null;\n }\n\n if (comparator == null) comparator = _has2.default;\n\n (0, _assert2.default)(_typeof(this.actual) === 'object', 'The \"actual\" argument in expect(actual).toExcludeKeys() must be an object, not %s', this.actual);\n\n (0, _assert2.default)((0, _TestUtils.isArray)(keys), 'The \"keys\" argument in expect(actual).toIncludeKeys(keys) must be an array, not %s', keys);\n\n var contains = keys.every(function (key) {\n return comparator(_this2.actual, key);\n });\n\n (0, _assert2.default)(!contains, message || 'Expected %s to exclude key(s) %s', this.actual, keys.join(', '));\n\n return this;\n }\n }, {\n key: 'toExcludeKey',\n value: function toExcludeKey(key) {\n for (var _len2 = arguments.length, args = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {\n args[_key2 - 1] = arguments[_key2];\n }\n\n return this.toExcludeKeys.apply(this, [[key]].concat(args));\n }\n }, {\n key: 'toHaveBeenCalled',\n value: function toHaveBeenCalled(message) {\n var spy = this.actual;\n\n (0, _assert2.default)((0, _SpyUtils.isSpy)(spy), 'The \"actual\" argument in expect(actual).toHaveBeenCalled() must be a spy');\n\n (0, _assert2.default)(spy.calls.length > 0, message || 'spy was not called');\n\n return this;\n }\n }, {\n key: 'toHaveBeenCalledWith',\n value: function toHaveBeenCalledWith() {\n for (var _len3 = arguments.length, expectedArgs = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {\n expectedArgs[_key3] = arguments[_key3];\n }\n\n var spy = this.actual;\n\n (0, _assert2.default)((0, _SpyUtils.isSpy)(spy), 'The \"actual\" argument in expect(actual).toHaveBeenCalledWith() must be a spy');\n\n (0, _assert2.default)(spy.calls.some(function (call) {\n return (0, _TestUtils.isEqual)(call.arguments, expectedArgs);\n }), 'spy was never called with %s', expectedArgs);\n\n return this;\n }\n }, {\n key: 'toNotHaveBeenCalled',\n value: function toNotHaveBeenCalled(message) {\n var spy = this.actual;\n\n (0, _assert2.default)((0, _SpyUtils.isSpy)(spy), 'The \"actual\" argument in expect(actual).toNotHaveBeenCalled() must be a spy');\n\n (0, _assert2.default)(spy.calls.length === 0, message || 'spy was not supposed to be called');\n\n return this;\n }\n }]);\n\n return Expectation;\n}();\n\nvar deprecate = function deprecate(fn, message) {\n var alreadyWarned = false;\n\n return function () {\n if (!alreadyWarned) {\n alreadyWarned = true;\n console.warn(message);\n }\n\n for (var _len4 = arguments.length, args = Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {\n args[_key4] = arguments[_key4];\n }\n\n return fn.apply(this, args);\n };\n};\n\nExpectation.prototype.withContext = deprecate(function (context) {\n (0, _assert2.default)((0, _TestUtils.isFunction)(this.actual), 'The \"actual\" argument in expect(actual).withContext() must be a function');\n\n this.context = context;\n\n return this;\n}, '\\nwithContext is deprecated; use a closure instead.\\n\\n expect(fn).withContext(context).toThrow()\\n\\nbecomes\\n\\n expect(() => fn.call(context)).toThrow()\\n');\n\nExpectation.prototype.withArgs = deprecate(function () {\n var _args;\n\n (0, _assert2.default)((0, _TestUtils.isFunction)(this.actual), 'The \"actual\" argument in expect(actual).withArgs() must be a function');\n\n if (arguments.length) this.args = (_args = this.args).concat.apply(_args, arguments);\n\n return this;\n}, '\\nwithArgs is deprecated; use a closure instead.\\n\\n expect(fn).withArgs(a, b, c).toThrow()\\n\\nbecomes\\n\\n expect(() => fn(a, b, c)).toThrow()\\n');\n\nvar aliases = {\n toBeAn: 'toBeA',\n toNotBeAn: 'toNotBeA',\n toBeTruthy: 'toExist',\n toBeFalsy: 'toNotExist',\n toBeFewerThan: 'toBeLessThan',\n toBeMoreThan: 'toBeGreaterThan',\n toContain: 'toInclude',\n toNotContain: 'toExclude',\n toNotInclude: 'toExclude',\n toContainKeys: 'toIncludeKeys',\n toNotContainKeys: 'toExcludeKeys',\n toNotIncludeKeys: 'toExcludeKeys',\n toContainKey: 'toIncludeKey',\n toNotContainKey: 'toExcludeKey',\n toNotIncludeKey: 'toExcludeKey'\n};\n\nfor (var alias in aliases) {\n if (aliases.hasOwnProperty(alias)) Expectation.prototype[alias] = Expectation.prototype[aliases[alias]];\n}exports.default = Expectation;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/expect/lib/Expectation.js\n// module id = 43\n// module chunks = 1","var bind = require('function-bind');\n\nmodule.exports = bind.call(Function.call, Object.prototype.hasOwnProperty);\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/has/src/index.js\n// module id = 44\n// module chunks = 1","'use strict';\n\nvar implementation = require('./implementation');\n\nmodule.exports = Function.prototype.bind || implementation;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/function-bind/index.js\n// module id = 45\n// module chunks = 1","'use strict';\n\n/* eslint no-invalid-this: 1 */\n\nvar ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';\nvar slice = Array.prototype.slice;\nvar toStr = Object.prototype.toString;\nvar funcType = '[object Function]';\n\nmodule.exports = function bind(that) {\n var target = this;\n if (typeof target !== 'function' || toStr.call(target) !== funcType) {\n throw new TypeError(ERROR_MESSAGE + target);\n }\n var args = slice.call(arguments, 1);\n\n var bound;\n var binder = function () {\n if (this instanceof bound) {\n var result = target.apply(\n this,\n args.concat(slice.call(arguments))\n );\n if (Object(result) === result) {\n return result;\n }\n return this;\n } else {\n return target.apply(\n that,\n args.concat(slice.call(arguments))\n );\n }\n };\n\n var boundLength = Math.max(0, target.length - args.length);\n var boundArgs = [];\n for (var i = 0; i < boundLength; i++) {\n boundArgs.push('$' + i);\n }\n\n bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder);\n\n if (target.prototype) {\n var Empty = function Empty() {};\n Empty.prototype = target.prototype;\n bound.prototype = new Empty();\n Empty.prototype = null;\n }\n\n return bound;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/function-bind/implementation.js\n// module id = 46\n// module chunks = 1","'use strict'\n\nfunction isArguments (obj) {\n return Object.prototype.toString.call(obj) === '[object Arguments]'\n}\n\nmodule.exports = match\n\nfunction match (obj, pattern) {\n return match_(obj, pattern, [], [])\n}\n\n/* istanbul ignore next */\nvar log = (/\\btmatch\\b/.test(process.env.NODE_DEBUG || '')) ?\n console.error : function () {}\n\nfunction match_ (obj, pattern, ca, cb) {\n log('TMATCH', typeof obj, pattern)\n if (obj == pattern) {\n log('TMATCH same object or simple value, or problem')\n // if one is object, and the other isn't, then this is bogus\n if (obj === null || pattern === null) {\n return true\n\n } else if (typeof obj === 'object' && typeof pattern === 'object') {\n return true\n\n } else if (typeof obj === 'object' && typeof pattern !== 'object') {\n return false\n\n } else if (typeof obj !== 'object' && typeof pattern === 'object') {\n return false\n\n } else {\n return true\n }\n\n } else if (obj === null || pattern === null) {\n log('TMATCH null test, already failed ==')\n return false\n\n } else if (typeof obj === 'string' && pattern instanceof RegExp) {\n log('TMATCH string~=regexp test')\n return pattern.test(obj)\n\n } else if (typeof obj === 'string' && typeof pattern === 'string' && pattern) {\n log('TMATCH string~=string test')\n return obj.indexOf(pattern) !== -1\n\n } else if (obj instanceof Date && pattern instanceof Date) {\n log('TMATCH date test')\n return obj.getTime() === pattern.getTime()\n\n } else if (obj instanceof Date && typeof pattern === 'string') {\n log('TMATCH date~=string test')\n return obj.getTime() === new Date(pattern).getTime()\n\n } else if (isArguments(obj) || isArguments(pattern)) {\n log('TMATCH arguments test')\n var slice = Array.prototype.slice\n return match_(slice.call(obj), slice.call(pattern), ca, cb)\n\n } else if (pattern === Buffer) {\n log('TMATCH Buffer ctor')\n return Buffer.isBuffer(obj)\n\n } else if (pattern === Function) {\n log('TMATCH Function ctor')\n return typeof obj === 'function'\n\n } else if (pattern === Number) {\n log('TMATCH Number ctor (finite, not NaN)')\n return typeof obj === 'number' && obj === obj && isFinite(obj)\n\n } else if (pattern !== pattern) {\n log('TMATCH NaN')\n return obj !== obj\n\n } else if (pattern === String) {\n log('TMATCH String ctor')\n return typeof obj === 'string'\n\n } else if (pattern === Boolean) {\n log('TMATCH Boolean ctor')\n return typeof obj === 'boolean'\n\n } else if (pattern === Array) {\n log('TMATCH Array ctor', pattern, Array.isArray(obj))\n return Array.isArray(obj)\n\n } else if (typeof pattern === 'function' && typeof obj === 'object') {\n log('TMATCH object~=function')\n return obj instanceof pattern\n\n } else if (typeof obj !== 'object' || typeof pattern !== 'object') {\n log('TMATCH obj is not object, pattern is not object, false')\n return false\n\n } else if (obj instanceof RegExp && pattern instanceof RegExp) {\n log('TMATCH regexp~=regexp test')\n return obj.source === pattern.source &&\n obj.global === pattern.global &&\n obj.multiline === pattern.multiline &&\n obj.lastIndex === pattern.lastIndex &&\n obj.ignoreCase === pattern.ignoreCase\n\n } else if (Buffer.isBuffer(obj) && Buffer.isBuffer(pattern)) {\n log('TMATCH buffer test')\n if (obj.equals) {\n return obj.equals(pattern)\n } else {\n if (obj.length !== pattern.length) return false\n\n for (var j = 0; j < obj.length; j++) if (obj[j] != pattern[j]) return false\n\n return true\n }\n\n } else {\n // both are objects. interesting case!\n log('TMATCH object~=object test')\n var kobj = Object.keys(obj)\n var kpat = Object.keys(pattern)\n log(' TMATCH patternkeys=%j objkeys=%j', kpat, kobj)\n\n // don't bother with stack acrobatics if there's nothing there\n if (kobj.length === 0 && kpat.length === 0) return true\n\n // if we've seen this exact pattern and object already, then\n // it means that pattern and obj have matching cyclicalness\n // however, non-cyclical patterns can match cyclical objects\n log(' TMATCH check seen objects...')\n var cal = ca.length\n while (cal--) if (ca[cal] === obj && cb[cal] === pattern) return true\n ca.push(obj); cb.push(pattern)\n log(' TMATCH not seen previously')\n\n var key\n for (var l = kpat.length - 1; l >= 0; l--) {\n key = kpat[l]\n log(' TMATCH test obj[%j]', key, obj[key], pattern[key])\n if (!match_(obj[key], pattern[key], ca, cb)) return false\n }\n\n ca.pop()\n cb.pop()\n\n log(' TMATCH object pass')\n return true\n }\n\n /* istanbul ignore next */\n throw new Error('impossible to reach this point')\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/tmatch/index.js\n// module id = 47\n// module chunks = 1","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author Feross Aboukhadijeh <[email protected]> <http://feross.org>\n * @license MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n * === true Use Uint8Array implementation (fastest)\n * === false Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n * incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n ? global.TYPED_ARRAY_SUPPORT\n : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n try {\n var arr = new Uint8Array(1)\n arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n return arr.foo() === 42 && // typed array instances can be augmented\n typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n } catch (e) {\n return false\n }\n}\n\nfunction kMaxLength () {\n return Buffer.TYPED_ARRAY_SUPPORT\n ? 0x7fffffff\n : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n if (kMaxLength() < length) {\n throw new RangeError('Invalid typed array length')\n }\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n // Return an augmented `Uint8Array` instance, for best performance\n that = new Uint8Array(length)\n that.__proto__ = Buffer.prototype\n } else {\n // Fallback: Return an object instance of the Buffer class\n if (that === null) {\n that = new Buffer(length)\n }\n that.length = length\n }\n\n return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n return new Buffer(arg, encodingOrOffset, length)\n }\n\n // Common case.\n if (typeof arg === 'number') {\n if (typeof encodingOrOffset === 'string') {\n throw new Error(\n 'If encoding is specified then the first argument must be a string'\n )\n }\n return allocUnsafe(this, arg)\n }\n return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n arr.__proto__ = Buffer.prototype\n return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n if (typeof value === 'number') {\n throw new TypeError('\"value\" argument must not be a number')\n }\n\n if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n return fromArrayBuffer(that, value, encodingOrOffset, length)\n }\n\n if (typeof value === 'string') {\n return fromString(that, value, encodingOrOffset)\n }\n\n return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n Buffer.prototype.__proto__ = Uint8Array.prototype\n Buffer.__proto__ = Uint8Array\n if (typeof Symbol !== 'undefined' && Symbol.species &&\n Buffer[Symbol.species] === Buffer) {\n // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n Object.defineProperty(Buffer, Symbol.species, {\n value: null,\n configurable: true\n })\n }\n}\n\nfunction assertSize (size) {\n if (typeof size !== 'number') {\n throw new TypeError('\"size\" argument must be a number')\n } else if (size < 0) {\n throw new RangeError('\"size\" argument must not be negative')\n }\n}\n\nfunction alloc (that, size, fill, encoding) {\n assertSize(size)\n if (size <= 0) {\n return createBuffer(that, size)\n }\n if (fill !== undefined) {\n // Only pay attention to encoding if it's a string. This\n // prevents accidentally sending in a number that would\n // be interpretted as a start offset.\n return typeof encoding === 'string'\n ? createBuffer(that, size).fill(fill, encoding)\n : createBuffer(that, size).fill(fill)\n }\n return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n assertSize(size)\n that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n if (!Buffer.TYPED_ARRAY_SUPPORT) {\n for (var i = 0; i < size; ++i) {\n that[i] = 0\n }\n }\n return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n if (typeof encoding !== 'string' || encoding === '') {\n encoding = 'utf8'\n }\n\n if (!Buffer.isEncoding(encoding)) {\n throw new TypeError('\"encoding\" must be a valid string encoding')\n }\n\n var length = byteLength(string, encoding) | 0\n that = createBuffer(that, length)\n\n var actual = that.write(string, encoding)\n\n if (actual !== length) {\n // Writing a hex string, for example, that contains invalid characters will\n // cause everything after the first invalid character to be ignored. (e.g.\n // 'abxxcd' will be treated as 'ab')\n that = that.slice(0, actual)\n }\n\n return that\n}\n\nfunction fromArrayLike (that, array) {\n var length = array.length < 0 ? 0 : checked(array.length) | 0\n that = createBuffer(that, length)\n for (var i = 0; i < length; i += 1) {\n that[i] = array[i] & 255\n }\n return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n if (byteOffset < 0 || array.byteLength < byteOffset) {\n throw new RangeError('\\'offset\\' is out of bounds')\n }\n\n if (array.byteLength < byteOffset + (length || 0)) {\n throw new RangeError('\\'length\\' is out of bounds')\n }\n\n if (byteOffset === undefined && length === undefined) {\n array = new Uint8Array(array)\n } else if (length === undefined) {\n array = new Uint8Array(array, byteOffset)\n } else {\n array = new Uint8Array(array, byteOffset, length)\n }\n\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n // Return an augmented `Uint8Array` instance, for best performance\n that = array\n that.__proto__ = Buffer.prototype\n } else {\n // Fallback: Return an object instance of the Buffer class\n that = fromArrayLike(that, array)\n }\n return that\n}\n\nfunction fromObject (that, obj) {\n if (Buffer.isBuffer(obj)) {\n var len = checked(obj.length) | 0\n that = createBuffer(that, len)\n\n if (that.length === 0) {\n return that\n }\n\n obj.copy(that, 0, 0, len)\n return that\n }\n\n if (obj) {\n if ((typeof ArrayBuffer !== 'undefined' &&\n obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n if (typeof obj.length !== 'number' || isnan(obj.length)) {\n return createBuffer(that, 0)\n }\n return fromArrayLike(that, obj)\n }\n\n if (obj.type === 'Buffer' && isArray(obj.data)) {\n return fromArrayLike(that, obj.data)\n }\n }\n\n throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n // Note: cannot use `length < kMaxLength()` here because that fails when\n // length is NaN (which is otherwise coerced to zero.)\n if (length >= kMaxLength()) {\n throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n 'size: 0x' + kMaxLength().toString(16) + ' bytes')\n }\n return length | 0\n}\n\nfunction SlowBuffer (length) {\n if (+length != length) { // eslint-disable-line eqeqeq\n length = 0\n }\n return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n throw new TypeError('Arguments must be Buffers')\n }\n\n if (a === b) return 0\n\n var x = a.length\n var y = b.length\n\n for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n if (a[i] !== b[i]) {\n x = a[i]\n y = b[i]\n break\n }\n }\n\n if (x < y) return -1\n if (y < x) return 1\n return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n switch (String(encoding).toLowerCase()) {\n case 'hex':\n case 'utf8':\n case 'utf-8':\n case 'ascii':\n case 'latin1':\n case 'binary':\n case 'base64':\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return true\n default:\n return false\n }\n}\n\nBuffer.concat = function concat (list, length) {\n if (!isArray(list)) {\n throw new TypeError('\"list\" argument must be an Array of Buffers')\n }\n\n if (list.length === 0) {\n return Buffer.alloc(0)\n }\n\n var i\n if (length === undefined) {\n length = 0\n for (i = 0; i < list.length; ++i) {\n length += list[i].length\n }\n }\n\n var buffer = Buffer.allocUnsafe(length)\n var pos = 0\n for (i = 0; i < list.length; ++i) {\n var buf = list[i]\n if (!Buffer.isBuffer(buf)) {\n throw new TypeError('\"list\" argument must be an Array of Buffers')\n }\n buf.copy(buffer, pos)\n pos += buf.length\n }\n return buffer\n}\n\nfunction byteLength (string, encoding) {\n if (Buffer.isBuffer(string)) {\n return string.length\n }\n if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n return string.byteLength\n }\n if (typeof string !== 'string') {\n string = '' + string\n }\n\n var len = string.length\n if (len === 0) return 0\n\n // Use a for loop to avoid recursion\n var loweredCase = false\n for (;;) {\n switch (encoding) {\n case 'ascii':\n case 'latin1':\n case 'binary':\n return len\n case 'utf8':\n case 'utf-8':\n case undefined:\n return utf8ToBytes(string).length\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return len * 2\n case 'hex':\n return len >>> 1\n case 'base64':\n return base64ToBytes(string).length\n default:\n if (loweredCase) return utf8ToBytes(string).length // assume utf8\n encoding = ('' + encoding).toLowerCase()\n loweredCase = true\n }\n }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n var loweredCase = false\n\n // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n // property of a typed array.\n\n // This behaves neither like String nor Uint8Array in that we set start/end\n // to their upper/lower bounds if the value passed is out of range.\n // undefined is handled specially as per ECMA-262 6th Edition,\n // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n if (start === undefined || start < 0) {\n start = 0\n }\n // Return early if start > this.length. Done here to prevent potential uint32\n // coercion fail below.\n if (start > this.length) {\n return ''\n }\n\n if (end === undefined || end > this.length) {\n end = this.length\n }\n\n if (end <= 0) {\n return ''\n }\n\n // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n end >>>= 0\n start >>>= 0\n\n if (end <= start) {\n return ''\n }\n\n if (!encoding) encoding = 'utf8'\n\n while (true) {\n switch (encoding) {\n case 'hex':\n return hexSlice(this, start, end)\n\n case 'utf8':\n case 'utf-8':\n return utf8Slice(this, start, end)\n\n case 'ascii':\n return asciiSlice(this, start, end)\n\n case 'latin1':\n case 'binary':\n return latin1Slice(this, start, end)\n\n case 'base64':\n return base64Slice(this, start, end)\n\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return utf16leSlice(this, start, end)\n\n default:\n if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n encoding = (encoding + '').toLowerCase()\n loweredCase = true\n }\n }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n var i = b[n]\n b[n] = b[m]\n b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n var len = this.length\n if (len % 2 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 16-bits')\n }\n for (var i = 0; i < len; i += 2) {\n swap(this, i, i + 1)\n }\n return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n var len = this.length\n if (len % 4 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 32-bits')\n }\n for (var i = 0; i < len; i += 4) {\n swap(this, i, i + 3)\n swap(this, i + 1, i + 2)\n }\n return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n var len = this.length\n if (len % 8 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 64-bits')\n }\n for (var i = 0; i < len; i += 8) {\n swap(this, i, i + 7)\n swap(this, i + 1, i + 6)\n swap(this, i + 2, i + 5)\n swap(this, i + 3, i + 4)\n }\n return this\n}\n\nBuffer.prototype.toString = function toString () {\n var length = this.length | 0\n if (length === 0) return ''\n if (arguments.length === 0) return utf8Slice(this, 0, length)\n return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n if (this === b) return true\n return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n var str = ''\n var max = exports.INSPECT_MAX_BYTES\n if (this.length > 0) {\n str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n if (this.length > max) str += ' ... '\n }\n return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n if (!Buffer.isBuffer(target)) {\n throw new TypeError('Argument must be a Buffer')\n }\n\n if (start === undefined) {\n start = 0\n }\n if (end === undefined) {\n end = target ? target.length : 0\n }\n if (thisStart === undefined) {\n thisStart = 0\n }\n if (thisEnd === undefined) {\n thisEnd = this.length\n }\n\n if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n throw new RangeError('out of range index')\n }\n\n if (thisStart >= thisEnd && start >= end) {\n return 0\n }\n if (thisStart >= thisEnd) {\n return -1\n }\n if (start >= end) {\n return 1\n }\n\n start >>>= 0\n end >>>= 0\n thisStart >>>= 0\n thisEnd >>>= 0\n\n if (this === target) return 0\n\n var x = thisEnd - thisStart\n var y = end - start\n var len = Math.min(x, y)\n\n var thisCopy = this.slice(thisStart, thisEnd)\n var targetCopy = target.slice(start, end)\n\n for (var i = 0; i < len; ++i) {\n if (thisCopy[i] !== targetCopy[i]) {\n x = thisCopy[i]\n y = targetCopy[i]\n break\n }\n }\n\n if (x < y) return -1\n if (y < x) return 1\n return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n // Empty buffer means no match\n if (buffer.length === 0) return -1\n\n // Normalize byteOffset\n if (typeof byteOffset === 'string') {\n encoding = byteOffset\n byteOffset = 0\n } else if (byteOffset > 0x7fffffff) {\n byteOffset = 0x7fffffff\n } else if (byteOffset < -0x80000000) {\n byteOffset = -0x80000000\n }\n byteOffset = +byteOffset // Coerce to Number.\n if (isNaN(byteOffset)) {\n // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n byteOffset = dir ? 0 : (buffer.length - 1)\n }\n\n // Normalize byteOffset: negative offsets start from the end of the buffer\n if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n if (byteOffset >= buffer.length) {\n if (dir) return -1\n else byteOffset = buffer.length - 1\n } else if (byteOffset < 0) {\n if (dir) byteOffset = 0\n else return -1\n }\n\n // Normalize val\n if (typeof val === 'string') {\n val = Buffer.from(val, encoding)\n }\n\n // Finally, search either indexOf (if dir is true) or lastIndexOf\n if (Buffer.isBuffer(val)) {\n // Special case: looking for empty string/buffer always fails\n if (val.length === 0) {\n return -1\n }\n return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n } else if (typeof val === 'number') {\n val = val & 0xFF // Search for a byte value [0-255]\n if (Buffer.TYPED_ARRAY_SUPPORT &&\n typeof Uint8Array.prototype.indexOf === 'function') {\n if (dir) {\n return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n } else {\n return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n }\n }\n return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n }\n\n throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n var indexSize = 1\n var arrLength = arr.length\n var valLength = val.length\n\n if (encoding !== undefined) {\n encoding = String(encoding).toLowerCase()\n if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n encoding === 'utf16le' || encoding === 'utf-16le') {\n if (arr.length < 2 || val.length < 2) {\n return -1\n }\n indexSize = 2\n arrLength /= 2\n valLength /= 2\n byteOffset /= 2\n }\n }\n\n function read (buf, i) {\n if (indexSize === 1) {\n return buf[i]\n } else {\n return buf.readUInt16BE(i * indexSize)\n }\n }\n\n var i\n if (dir) {\n var foundIndex = -1\n for (i = byteOffset; i < arrLength; i++) {\n if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n if (foundIndex === -1) foundIndex = i\n if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n } else {\n if (foundIndex !== -1) i -= i - foundIndex\n foundIndex = -1\n }\n }\n } else {\n if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n for (i = byteOffset; i >= 0; i--) {\n var found = true\n for (var j = 0; j < valLength; j++) {\n if (read(arr, i + j) !== read(val, j)) {\n found = false\n break\n }\n }\n if (found) return i\n }\n }\n\n return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n offset = Number(offset) || 0\n var remaining = buf.length - offset\n if (!length) {\n length = remaining\n } else {\n length = Number(length)\n if (length > remaining) {\n length = remaining\n }\n }\n\n // must be an even number of digits\n var strLen = string.length\n if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n if (length > strLen / 2) {\n length = strLen / 2\n }\n for (var i = 0; i < length; ++i) {\n var parsed = parseInt(string.substr(i * 2, 2), 16)\n if (isNaN(parsed)) return i\n buf[offset + i] = parsed\n }\n return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n // Buffer#write(string)\n if (offset === undefined) {\n encoding = 'utf8'\n length = this.length\n offset = 0\n // Buffer#write(string, encoding)\n } else if (length === undefined && typeof offset === 'string') {\n encoding = offset\n length = this.length\n offset = 0\n // Buffer#write(string, offset[, length][, encoding])\n } else if (isFinite(offset)) {\n offset = offset | 0\n if (isFinite(length)) {\n length = length | 0\n if (encoding === undefined) encoding = 'utf8'\n } else {\n encoding = length\n length = undefined\n }\n // legacy write(string, encoding, offset, length) - remove in v0.13\n } else {\n throw new Error(\n 'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n )\n }\n\n var remaining = this.length - offset\n if (length === undefined || length > remaining) length = remaining\n\n if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n throw new RangeError('Attempt to write outside buffer bounds')\n }\n\n if (!encoding) encoding = 'utf8'\n\n var loweredCase = false\n for (;;) {\n switch (encoding) {\n case 'hex':\n return hexWrite(this, string, offset, length)\n\n case 'utf8':\n case 'utf-8':\n return utf8Write(this, string, offset, length)\n\n case 'ascii':\n return asciiWrite(this, string, offset, length)\n\n case 'latin1':\n case 'binary':\n return latin1Write(this, string, offset, length)\n\n case 'base64':\n // Warning: maxLength not taken into account in base64Write\n return base64Write(this, string, offset, length)\n\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return ucs2Write(this, string, offset, length)\n\n default:\n if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n encoding = ('' + encoding).toLowerCase()\n loweredCase = true\n }\n }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n return {\n type: 'Buffer',\n data: Array.prototype.slice.call(this._arr || this, 0)\n }\n}\n\nfunction base64Slice (buf, start, end) {\n if (start === 0 && end === buf.length) {\n return base64.fromByteArray(buf)\n } else {\n return base64.fromByteArray(buf.slice(start, end))\n }\n}\n\nfunction utf8Slice (buf, start, end) {\n end = Math.min(buf.length, end)\n var res = []\n\n var i = start\n while (i < end) {\n var firstByte = buf[i]\n var codePoint = null\n var bytesPerSequence = (firstByte > 0xEF) ? 4\n : (firstByte > 0xDF) ? 3\n : (firstByte > 0xBF) ? 2\n : 1\n\n if (i + bytesPerSequence <= end) {\n var secondByte, thirdByte, fourthByte, tempCodePoint\n\n switch (bytesPerSequence) {\n case 1:\n if (firstByte < 0x80) {\n codePoint = firstByte\n }\n break\n case 2:\n secondByte = buf[i + 1]\n if ((secondByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n if (tempCodePoint > 0x7F) {\n codePoint = tempCodePoint\n }\n }\n break\n case 3:\n secondByte = buf[i + 1]\n thirdByte = buf[i + 2]\n if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n codePoint = tempCodePoint\n }\n }\n break\n case 4:\n secondByte = buf[i + 1]\n thirdByte = buf[i + 2]\n fourthByte = buf[i + 3]\n if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n codePoint = tempCodePoint\n }\n }\n }\n }\n\n if (codePoint === null) {\n // we did not generate a valid codePoint so insert a\n // replacement char (U+FFFD) and advance only 1 byte\n codePoint = 0xFFFD\n bytesPerSequence = 1\n } else if (codePoint > 0xFFFF) {\n // encode to utf16 (surrogate pair dance)\n codePoint -= 0x10000\n res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n codePoint = 0xDC00 | codePoint & 0x3FF\n }\n\n res.push(codePoint)\n i += bytesPerSequence\n }\n\n return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n var len = codePoints.length\n if (len <= MAX_ARGUMENTS_LENGTH) {\n return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n }\n\n // Decode in chunks to avoid \"call stack size exceeded\".\n var res = ''\n var i = 0\n while (i < len) {\n res += String.fromCharCode.apply(\n String,\n codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n )\n }\n return res\n}\n\nfunction asciiSlice (buf, start, end) {\n var ret = ''\n end = Math.min(buf.length, end)\n\n for (var i = start; i < end; ++i) {\n ret += String.fromCharCode(buf[i] & 0x7F)\n }\n return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n var ret = ''\n end = Math.min(buf.length, end)\n\n for (var i = start; i < end; ++i) {\n ret += String.fromCharCode(buf[i])\n }\n return ret\n}\n\nfunction hexSlice (buf, start, end) {\n var len = buf.length\n\n if (!start || start < 0) start = 0\n if (!end || end < 0 || end > len) end = len\n\n var out = ''\n for (var i = start; i < end; ++i) {\n out += toHex(buf[i])\n }\n return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n var bytes = buf.slice(start, end)\n var res = ''\n for (var i = 0; i < bytes.length; i += 2) {\n res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n }\n return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n var len = this.length\n start = ~~start\n end = end === undefined ? len : ~~end\n\n if (start < 0) {\n start += len\n if (start < 0) start = 0\n } else if (start > len) {\n start = len\n }\n\n if (end < 0) {\n end += len\n if (end < 0) end = 0\n } else if (end > len) {\n end = len\n }\n\n if (end < start) end = start\n\n var newBuf\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n newBuf = this.subarray(start, end)\n newBuf.__proto__ = Buffer.prototype\n } else {\n var sliceLen = end - start\n newBuf = new Buffer(sliceLen, undefined)\n for (var i = 0; i < sliceLen; ++i) {\n newBuf[i] = this[i + start]\n }\n }\n\n return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n var val = this[offset]\n var mul = 1\n var i = 0\n while (++i < byteLength && (mul *= 0x100)) {\n val += this[offset + i] * mul\n }\n\n return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) {\n checkOffset(offset, byteLength, this.length)\n }\n\n var val = this[offset + --byteLength]\n var mul = 1\n while (byteLength > 0 && (mul *= 0x100)) {\n val += this[offset + --byteLength] * mul\n }\n\n return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 1, this.length)\n return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return ((this[offset]) |\n (this[offset + 1] << 8) |\n (this[offset + 2] << 16)) +\n (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset] * 0x1000000) +\n ((this[offset + 1] << 16) |\n (this[offset + 2] << 8) |\n this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n var val = this[offset]\n var mul = 1\n var i = 0\n while (++i < byteLength && (mul *= 0x100)) {\n val += this[offset + i] * mul\n }\n mul *= 0x80\n\n if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n var i = byteLength\n var mul = 1\n var val = this[offset + --i]\n while (i > 0 && (mul *= 0x100)) {\n val += this[offset + --i] * mul\n }\n mul *= 0x80\n\n if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 1, this.length)\n if (!(this[offset] & 0x80)) return (this[offset])\n return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n var val = this[offset] | (this[offset + 1] << 8)\n return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n var val = this[offset + 1] | (this[offset] << 8)\n return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset]) |\n (this[offset + 1] << 8) |\n (this[offset + 2] << 16) |\n (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset] << 24) |\n (this[offset + 1] << 16) |\n (this[offset + 2] << 8) |\n (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 8, this.length)\n return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 8, this.length)\n return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) {\n var maxBytes = Math.pow(2, 8 * byteLength) - 1\n checkInt(this, value, offset, byteLength, maxBytes, 0)\n }\n\n var mul = 1\n var i = 0\n this[offset] = value & 0xFF\n while (++i < byteLength && (mul *= 0x100)) {\n this[offset + i] = (value / mul) & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) {\n var maxBytes = Math.pow(2, 8 * byteLength) - 1\n checkInt(this, value, offset, byteLength, maxBytes, 0)\n }\n\n var i = byteLength - 1\n var mul = 1\n this[offset + i] = value & 0xFF\n while (--i >= 0 && (mul *= 0x100)) {\n this[offset + i] = (value / mul) & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n this[offset] = (value & 0xff)\n return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n if (value < 0) value = 0xffff + value + 1\n for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n (littleEndian ? i : 1 - i) * 8\n }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n } else {\n objectWriteUInt16(this, value, offset, true)\n }\n return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 8)\n this[offset + 1] = (value & 0xff)\n } else {\n objectWriteUInt16(this, value, offset, false)\n }\n return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n if (value < 0) value = 0xffffffff + value + 1\n for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset + 3] = (value >>> 24)\n this[offset + 2] = (value >>> 16)\n this[offset + 1] = (value >>> 8)\n this[offset] = (value & 0xff)\n } else {\n objectWriteUInt32(this, value, offset, true)\n }\n return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 24)\n this[offset + 1] = (value >>> 16)\n this[offset + 2] = (value >>> 8)\n this[offset + 3] = (value & 0xff)\n } else {\n objectWriteUInt32(this, value, offset, false)\n }\n return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) {\n var limit = Math.pow(2, 8 * byteLength - 1)\n\n checkInt(this, value, offset, byteLength, limit - 1, -limit)\n }\n\n var i = 0\n var mul = 1\n var sub = 0\n this[offset] = value & 0xFF\n while (++i < byteLength && (mul *= 0x100)) {\n if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n sub = 1\n }\n this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) {\n var limit = Math.pow(2, 8 * byteLength - 1)\n\n checkInt(this, value, offset, byteLength, limit - 1, -limit)\n }\n\n var i = byteLength - 1\n var mul = 1\n var sub = 0\n this[offset + i] = value & 0xFF\n while (--i >= 0 && (mul *= 0x100)) {\n if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n sub = 1\n }\n this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n if (value < 0) value = 0xff + value + 1\n this[offset] = (value & 0xff)\n return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n } else {\n objectWriteUInt16(this, value, offset, true)\n }\n return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 8)\n this[offset + 1] = (value & 0xff)\n } else {\n objectWriteUInt16(this, value, offset, false)\n }\n return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n this[offset + 2] = (value >>> 16)\n this[offset + 3] = (value >>> 24)\n } else {\n objectWriteUInt32(this, value, offset, true)\n }\n return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n if (value < 0) value = 0xffffffff + value + 1\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 24)\n this[offset + 1] = (value >>> 16)\n this[offset + 2] = (value >>> 8)\n this[offset + 3] = (value & 0xff)\n } else {\n objectWriteUInt32(this, value, offset, false)\n }\n return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n if (offset + ext > buf.length) throw new RangeError('Index out of range')\n if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n if (!noAssert) {\n checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n }\n ieee754.write(buf, value, offset, littleEndian, 23, 4)\n return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n if (!noAssert) {\n checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n }\n ieee754.write(buf, value, offset, littleEndian, 52, 8)\n return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n if (!start) start = 0\n if (!end && end !== 0) end = this.length\n if (targetStart >= target.length) targetStart = target.length\n if (!targetStart) targetStart = 0\n if (end > 0 && end < start) end = start\n\n // Copy 0 bytes; we're done\n if (end === start) return 0\n if (target.length === 0 || this.length === 0) return 0\n\n // Fatal error conditions\n if (targetStart < 0) {\n throw new RangeError('targetStart out of bounds')\n }\n if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n // Are we oob?\n if (end > this.length) end = this.length\n if (target.length - targetStart < end - start) {\n end = target.length - targetStart + start\n }\n\n var len = end - start\n var i\n\n if (this === target && start < targetStart && targetStart < end) {\n // descending copy from end\n for (i = len - 1; i >= 0; --i) {\n target[i + targetStart] = this[i + start]\n }\n } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n // ascending copy from start\n for (i = 0; i < len; ++i) {\n target[i + targetStart] = this[i + start]\n }\n } else {\n Uint8Array.prototype.set.call(\n target,\n this.subarray(start, start + len),\n targetStart\n )\n }\n\n return len\n}\n\n// Usage:\n// buffer.fill(number[, offset[, end]])\n// buffer.fill(buffer[, offset[, end]])\n// buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n // Handle string cases:\n if (typeof val === 'string') {\n if (typeof start === 'string') {\n encoding = start\n start = 0\n end = this.length\n } else if (typeof end === 'string') {\n encoding = end\n end = this.length\n }\n if (val.length === 1) {\n var code = val.charCodeAt(0)\n if (code < 256) {\n val = code\n }\n }\n if (encoding !== undefined && typeof encoding !== 'string') {\n throw new TypeError('encoding must be a string')\n }\n if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n throw new TypeError('Unknown encoding: ' + encoding)\n }\n } else if (typeof val === 'number') {\n val = val & 255\n }\n\n // Invalid ranges are not set to a default, so can range check early.\n if (start < 0 || this.length < start || this.length < end) {\n throw new RangeError('Out of range index')\n }\n\n if (end <= start) {\n return this\n }\n\n start = start >>> 0\n end = end === undefined ? this.length : end >>> 0\n\n if (!val) val = 0\n\n var i\n if (typeof val === 'number') {\n for (i = start; i < end; ++i) {\n this[i] = val\n }\n } else {\n var bytes = Buffer.isBuffer(val)\n ? val\n : utf8ToBytes(new Buffer(val, encoding).toString())\n var len = bytes.length\n for (i = 0; i < end - start; ++i) {\n this[i + start] = bytes[i % len]\n }\n }\n\n return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n // Node converts strings with length < 2 to ''\n if (str.length < 2) return ''\n // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n while (str.length % 4 !== 0) {\n str = str + '='\n }\n return str\n}\n\nfunction stringtrim (str) {\n if (str.trim) return str.trim()\n return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n if (n < 16) return '0' + n.toString(16)\n return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n units = units || Infinity\n var codePoint\n var length = string.length\n var leadSurrogate = null\n var bytes = []\n\n for (var i = 0; i < length; ++i) {\n codePoint = string.charCodeAt(i)\n\n // is surrogate component\n if (codePoint > 0xD7FF && codePoint < 0xE000) {\n // last char was a lead\n if (!leadSurrogate) {\n // no lead yet\n if (codePoint > 0xDBFF) {\n // unexpected trail\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n continue\n } else if (i + 1 === length) {\n // unpaired lead\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n continue\n }\n\n // valid lead\n leadSurrogate = codePoint\n\n continue\n }\n\n // 2 leads in a row\n if (codePoint < 0xDC00) {\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n leadSurrogate = codePoint\n continue\n }\n\n // valid surrogate pair\n codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n } else if (leadSurrogate) {\n // valid bmp char, but last char was a lead\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n }\n\n leadSurrogate = null\n\n // encode utf8\n if (codePoint < 0x80) {\n if ((units -= 1) < 0) break\n bytes.push(codePoint)\n } else if (codePoint < 0x800) {\n if ((units -= 2) < 0) break\n bytes.push(\n codePoint >> 0x6 | 0xC0,\n codePoint & 0x3F | 0x80\n )\n } else if (codePoint < 0x10000) {\n if ((units -= 3) < 0) break\n bytes.push(\n codePoint >> 0xC | 0xE0,\n codePoint >> 0x6 & 0x3F | 0x80,\n codePoint & 0x3F | 0x80\n )\n } else if (codePoint < 0x110000) {\n if ((units -= 4) < 0) break\n bytes.push(\n codePoint >> 0x12 | 0xF0,\n codePoint >> 0xC & 0x3F | 0x80,\n codePoint >> 0x6 & 0x3F | 0x80,\n codePoint & 0x3F | 0x80\n )\n } else {\n throw new Error('Invalid code point')\n }\n }\n\n return bytes\n}\n\nfunction asciiToBytes (str) {\n var byteArray = []\n for (var i = 0; i < str.length; ++i) {\n // Node's code seems to be doing this and not & 0x7F..\n byteArray.push(str.charCodeAt(i) & 0xFF)\n }\n return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n var c, hi, lo\n var byteArray = []\n for (var i = 0; i < str.length; ++i) {\n if ((units -= 2) < 0) break\n\n c = str.charCodeAt(i)\n hi = c >> 8\n lo = c % 256\n byteArray.push(lo)\n byteArray.push(hi)\n }\n\n return byteArray\n}\n\nfunction base64ToBytes (str) {\n return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n for (var i = 0; i < length; ++i) {\n if ((i + offset >= dst.length) || (i >= src.length)) break\n dst[i + offset] = src[i]\n }\n return i\n}\n\nfunction isnan (val) {\n return val !== val // eslint-disable-line no-self-compare\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/buffer/index.js\n// module id = 48\n// module chunks = 1","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n lookup[i] = code[i]\n revLookup[code.charCodeAt(i)] = i\n}\n\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction placeHoldersCount (b64) {\n var len = b64.length\n if (len % 4 > 0) {\n throw new Error('Invalid string. Length must be a multiple of 4')\n }\n\n // the number of equal signs (place holders)\n // if there are two placeholders, than the two characters before it\n // represent one byte\n // if there is only one, then the three characters before it represent 2 bytes\n // this is just a cheap hack to not do indexOf twice\n return b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0\n}\n\nfunction byteLength (b64) {\n // base64 is 4/3 + up to two characters of the original data\n return (b64.length * 3 / 4) - placeHoldersCount(b64)\n}\n\nfunction toByteArray (b64) {\n var i, l, tmp, placeHolders, arr\n var len = b64.length\n placeHolders = placeHoldersCount(b64)\n\n arr = new Arr((len * 3 / 4) - placeHolders)\n\n // if there are placeholders, only get up to the last complete 4 chars\n l = placeHolders > 0 ? len - 4 : len\n\n var L = 0\n\n for (i = 0; i < l; i += 4) {\n tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]\n arr[L++] = (tmp >> 16) & 0xFF\n arr[L++] = (tmp >> 8) & 0xFF\n arr[L++] = tmp & 0xFF\n }\n\n if (placeHolders === 2) {\n tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4)\n arr[L++] = tmp & 0xFF\n } else if (placeHolders === 1) {\n tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2)\n arr[L++] = (tmp >> 8) & 0xFF\n arr[L++] = tmp & 0xFF\n }\n\n return arr\n}\n\nfunction tripletToBase64 (num) {\n return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n var tmp\n var output = []\n for (var i = start; i < end; i += 3) {\n tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])\n output.push(tripletToBase64(tmp))\n }\n return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n var tmp\n var len = uint8.length\n var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n var output = ''\n var parts = []\n var maxChunkLength = 16383 // must be multiple of 3\n\n // go through the array every three bytes, we'll deal with trailing stuff later\n for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n }\n\n // pad the end with zeros, but make sure to not forget the extra bytes\n if (extraBytes === 1) {\n tmp = uint8[len - 1]\n output += lookup[tmp >> 2]\n output += lookup[(tmp << 4) & 0x3F]\n output += '=='\n } else if (extraBytes === 2) {\n tmp = (uint8[len - 2] << 8) + (uint8[len - 1])\n output += lookup[tmp >> 10]\n output += lookup[(tmp >> 4) & 0x3F]\n output += lookup[(tmp << 2) & 0x3F]\n output += '='\n }\n\n parts.push(output)\n\n return parts.join('')\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/base64-js/index.js\n// module id = 49\n// module chunks = 1","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n var e, m\n var eLen = nBytes * 8 - mLen - 1\n var eMax = (1 << eLen) - 1\n var eBias = eMax >> 1\n var nBits = -7\n var i = isLE ? (nBytes - 1) : 0\n var d = isLE ? -1 : 1\n var s = buffer[offset + i]\n\n i += d\n\n e = s & ((1 << (-nBits)) - 1)\n s >>= (-nBits)\n nBits += eLen\n for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n m = e & ((1 << (-nBits)) - 1)\n e >>= (-nBits)\n nBits += mLen\n for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n if (e === 0) {\n e = 1 - eBias\n } else if (e === eMax) {\n return m ? NaN : ((s ? -1 : 1) * Infinity)\n } else {\n m = m + Math.pow(2, mLen)\n e = e - eBias\n }\n return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n var e, m, c\n var eLen = nBytes * 8 - mLen - 1\n var eMax = (1 << eLen) - 1\n var eBias = eMax >> 1\n var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n var i = isLE ? 0 : (nBytes - 1)\n var d = isLE ? 1 : -1\n var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n value = Math.abs(value)\n\n if (isNaN(value) || value === Infinity) {\n m = isNaN(value) ? 1 : 0\n e = eMax\n } else {\n e = Math.floor(Math.log(value) / Math.LN2)\n if (value * (c = Math.pow(2, -e)) < 1) {\n e--\n c *= 2\n }\n if (e + eBias >= 1) {\n value += rt / c\n } else {\n value += rt * Math.pow(2, 1 - eBias)\n }\n if (value * c >= 2) {\n e++\n c /= 2\n }\n\n if (e + eBias >= eMax) {\n m = 0\n e = eMax\n } else if (e + eBias >= 1) {\n m = (value * c - 1) * Math.pow(2, mLen)\n e = e + eBias\n } else {\n m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n e = 0\n }\n }\n\n for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n e = (e << mLen) | m\n eLen += mLen\n for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n buffer[offset + i - d] |= s * 128\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/ieee754/index.js\n// module id = 50\n// module chunks = 1","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n return toString.call(arr) == '[object Array]';\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/isarray/index.js\n// module id = 51\n// module chunks = 1","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _objectInspect = require('object-inspect');\n\nvar _objectInspect2 = _interopRequireDefault(_objectInspect);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar formatString = function formatString(string, args) {\n var index = 0;\n return string.replace(/%s/g, function () {\n return (0, _objectInspect2.default)(args[index++]);\n });\n};\n\nvar assert = function assert(condition, createMessage) {\n for (var _len = arguments.length, extraArgs = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {\n extraArgs[_key - 2] = arguments[_key];\n }\n\n if (condition) return;\n\n var message = typeof createMessage === 'string' ? formatString(createMessage, extraArgs) : createMessage(extraArgs);\n\n throw new Error(message);\n};\n\nexports.default = assert;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/expect/lib/assert.js\n// module id = 52\n// module chunks = 1","var hasMap = typeof Map === 'function' && Map.prototype;\nvar mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, 'size') : null;\nvar mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === 'function' ? mapSizeDescriptor.get : null;\nvar mapForEach = hasMap && Map.prototype.forEach;\nvar hasSet = typeof Set === 'function' && Set.prototype;\nvar setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, 'size') : null;\nvar setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === 'function' ? setSizeDescriptor.get : null;\nvar setForEach = hasSet && Set.prototype.forEach;\nvar booleanValueOf = Boolean.prototype.valueOf;\nvar objectToString = Object.prototype.toString;\n\nmodule.exports = function inspect_ (obj, opts, depth, seen) {\n if (typeof obj === 'undefined') {\n return 'undefined';\n }\n if (obj === null) {\n return 'null';\n }\n if (typeof obj === 'boolean') {\n return obj ? 'true' : 'false';\n }\n if (typeof obj === 'string') {\n return inspectString(obj);\n }\n if (typeof obj === 'number') {\n if (obj === 0) {\n return Infinity / obj > 0 ? '0' : '-0';\n }\n return String(obj);\n }\n\n if (!opts) opts = {};\n\n var maxDepth = typeof opts.depth === 'undefined' ? 5 : opts.depth;\n if (typeof depth === 'undefined') depth = 0;\n if (depth >= maxDepth && maxDepth > 0 && typeof obj === 'object') {\n return '[Object]';\n }\n\n if (typeof seen === 'undefined') seen = [];\n else if (indexOf(seen, obj) >= 0) {\n return '[Circular]';\n }\n\n function inspect (value, from) {\n if (from) {\n seen = seen.slice();\n seen.push(from);\n }\n return inspect_(value, opts, depth + 1, seen);\n }\n\n if (typeof obj === 'function') {\n var name = nameOf(obj);\n return '[Function' + (name ? ': ' + name : '') + ']';\n }\n if (isSymbol(obj)) {\n var symString = Symbol.prototype.toString.call(obj);\n return typeof obj === 'object' ? markBoxed(symString) : symString;\n }\n if (isElement(obj)) {\n var s = '<' + String(obj.nodeName).toLowerCase();\n var attrs = obj.attributes || [];\n for (var i = 0; i < attrs.length; i++) {\n s += ' ' + attrs[i].name + '=\"' + quote(attrs[i].value) + '\"';\n }\n s += '>';\n if (obj.childNodes && obj.childNodes.length) s += '...';\n s += '</' + String(obj.nodeName).toLowerCase() + '>';\n return s;\n }\n if (isArray(obj)) {\n if (obj.length === 0) return '[]';\n return '[ ' + arrObjKeys(obj, inspect).join(', ') + ' ]';\n }\n if (isError(obj)) {\n var parts = arrObjKeys(obj, inspect);\n if (parts.length === 0) return '[' + String(obj) + ']';\n return '{ [' + String(obj) + '] ' + parts.join(', ') + ' }';\n }\n if (typeof obj === 'object' && typeof obj.inspect === 'function') {\n return obj.inspect();\n }\n if (isMap(obj)) {\n var parts = [];\n mapForEach.call(obj, function (value, key) {\n parts.push(inspect(key, obj) + ' => ' + inspect(value, obj));\n });\n return collectionOf('Map', mapSize.call(obj), parts);\n }\n if (isSet(obj)) {\n var parts = [];\n setForEach.call(obj, function (value ) {\n parts.push(inspect(value, obj));\n });\n return collectionOf('Set', setSize.call(obj), parts);\n }\n if (isNumber(obj)) {\n return markBoxed(Number(obj));\n }\n if (isBoolean(obj)) {\n return markBoxed(booleanValueOf.call(obj));\n }\n if (isString(obj)) {\n return markBoxed(inspect(String(obj)));\n }\n if (!isDate(obj) && !isRegExp(obj)) {\n var xs = arrObjKeys(obj, inspect);\n if (xs.length === 0) return '{}';\n return '{ ' + xs.join(', ') + ' }';\n }\n return String(obj);\n};\n\nfunction quote (s) {\n return String(s).replace(/\"/g, '"');\n}\n\nfunction isArray (obj) { return toStr(obj) === '[object Array]' }\nfunction isDate (obj) { return toStr(obj) === '[object Date]' }\nfunction isRegExp (obj) { return toStr(obj) === '[object RegExp]' }\nfunction isError (obj) { return toStr(obj) === '[object Error]' }\nfunction isSymbol (obj) { return toStr(obj) === '[object Symbol]' }\nfunction isString (obj) { return toStr(obj) === '[object String]' }\nfunction isNumber (obj) { return toStr(obj) === '[object Number]' }\nfunction isBoolean (obj) { return toStr(obj) === '[object Boolean]' }\n\nvar hasOwn = Object.prototype.hasOwnProperty || function (key) { return key in this; };\nfunction has (obj, key) {\n return hasOwn.call(obj, key);\n}\n\nfunction toStr (obj) {\n return objectToString.call(obj);\n}\n\nfunction nameOf (f) {\n if (f.name) return f.name;\n var m = String(f).match(/^function\\s*([\\w$]+)/);\n if (m) return m[1];\n}\n\nfunction indexOf (xs, x) {\n if (xs.indexOf) return xs.indexOf(x);\n for (var i = 0, l = xs.length; i < l; i++) {\n if (xs[i] === x) return i;\n }\n return -1;\n}\n\nfunction isMap (x) {\n if (!mapSize) {\n return false;\n }\n try {\n mapSize.call(x);\n try {\n setSize.call(x);\n } catch (s) {\n return true;\n }\n return x instanceof Map; // core-js workaround, pre-v2.5.0\n } catch (e) {}\n return false;\n}\n\nfunction isSet (x) {\n if (!setSize) {\n return false;\n }\n try {\n setSize.call(x);\n try {\n mapSize.call(x);\n } catch (m) {\n return true;\n }\n return x instanceof Set; // core-js workaround, pre-v2.5.0\n } catch (e) {}\n return false;\n}\n\nfunction isElement (x) {\n if (!x || typeof x !== 'object') return false;\n if (typeof HTMLElement !== 'undefined' && x instanceof HTMLElement) {\n return true;\n }\n return typeof x.nodeName === 'string'\n && typeof x.getAttribute === 'function'\n ;\n}\n\nfunction inspectString (str) {\n var s = str.replace(/(['\\\\])/g, '\\\\$1').replace(/[\\x00-\\x1f]/g, lowbyte);\n return \"'\" + s + \"'\";\n}\n\nfunction lowbyte (c) {\n var n = c.charCodeAt(0);\n var x = { 8: 'b', 9: 't', 10: 'n', 12: 'f', 13: 'r' }[n];\n if (x) return '\\\\' + x;\n return '\\\\x' + (n < 0x10 ? '0' : '') + n.toString(16);\n}\n\nfunction markBoxed (str) {\n return 'Object(' + str + ')';\n}\n\nfunction collectionOf (type, size, entries) {\n return type + ' (' + size + ') {' + entries.join(', ') + '}';\n}\n\nfunction arrObjKeys (obj, inspect) {\n var isArr = isArray(obj);\n var xs = [];\n if (isArr) {\n xs.length = obj.length;\n for (var i = 0; i < obj.length; i++) {\n xs[i] = has(obj, i) ? inspect(obj[i], obj) : '';\n }\n }\n for (var key in obj) {\n if (!has(obj, key)) continue;\n if (isArr && String(Number(key)) === key && key < obj.length) continue;\n if (/[^\\w$]/.test(key)) {\n xs.push(inspect(key, obj) + ': ' + inspect(obj[key], obj));\n } else {\n xs.push(key + ': ' + inspect(obj[key], obj));\n }\n }\n return xs;\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/object-inspect/index.js\n// module id = 53\n// module chunks = 1","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.spyOn = exports.createSpy = exports.restoreSpies = exports.isSpy = undefined;\n\nvar _defineProperties = require('define-properties');\n\nvar _assert = require('./assert');\n\nvar _assert2 = _interopRequireDefault(_assert);\n\nvar _TestUtils = require('./TestUtils');\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } /*eslint-disable prefer-rest-params, no-underscore-dangle*/\n\n\nvar noop = function noop() {};\n\nvar supportsConfigurableFnLength = _defineProperties.supportsDescriptors && Object.getOwnPropertyDescriptor(function () {}, 'length').configurable;\n\nvar isSpy = exports.isSpy = function isSpy(object) {\n return object && object.__isSpy === true;\n};\n\nvar spies = [];\n\nvar restoreSpies = exports.restoreSpies = function restoreSpies() {\n for (var i = spies.length - 1; i >= 0; i--) {\n spies[i].restore();\n }spies = [];\n};\n\nvar createSpy = exports.createSpy = function createSpy(fn) {\n var restore = arguments.length <= 1 || arguments[1] === undefined ? noop : arguments[1];\n\n if (fn == null) fn = noop;\n\n (0, _assert2.default)((0, _TestUtils.isFunction)(fn), 'createSpy needs a function');\n\n var targetFn = void 0,\n thrownValue = void 0,\n returnValue = void 0,\n spy = void 0;\n\n function spyLogic() {\n spy.calls.push({\n context: this,\n arguments: Array.prototype.slice.call(arguments, 0)\n });\n\n if (targetFn) return targetFn.apply(this, arguments);\n\n if (thrownValue) throw thrownValue;\n\n return returnValue;\n }\n\n if (supportsConfigurableFnLength) {\n spy = Object.defineProperty(spyLogic, 'length', { value: fn.length, writable: false, enumerable: false, configurable: true });\n } else {\n spy = new Function('spy', 'return function(' + // eslint-disable-line no-new-func\n [].concat(_toConsumableArray(Array(fn.length))).map(function (_, i) {\n return '_' + i;\n }).join(',') + ') {\\n return spy.apply(this, arguments)\\n }')(spyLogic);\n }\n\n spy.calls = [];\n\n spy.andCall = function (otherFn) {\n targetFn = otherFn;\n return spy;\n };\n\n spy.andCallThrough = function () {\n return spy.andCall(fn);\n };\n\n spy.andThrow = function (value) {\n thrownValue = value;\n return spy;\n };\n\n spy.andReturn = function (value) {\n returnValue = value;\n return spy;\n };\n\n spy.getLastCall = function () {\n return spy.calls[spy.calls.length - 1];\n };\n\n spy.reset = function () {\n spy.calls = [];\n };\n\n spy.restore = spy.destroy = restore;\n\n spy.__isSpy = true;\n\n spies.push(spy);\n\n return spy;\n};\n\nvar spyOn = exports.spyOn = function spyOn(object, methodName) {\n var original = object[methodName];\n\n if (!isSpy(original)) {\n (0, _assert2.default)((0, _TestUtils.isFunction)(original), 'Cannot spyOn the %s property; it is not a function', methodName);\n\n object[methodName] = createSpy(original, function () {\n object[methodName] = original;\n });\n }\n\n return object[methodName];\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/expect/lib/SpyUtils.js\n// module id = 54\n// module chunks = 1","'use strict';\n\nvar keys = require('object-keys');\nvar foreach = require('foreach');\nvar hasSymbols = typeof Symbol === 'function' && typeof Symbol() === 'symbol';\n\nvar toStr = Object.prototype.toString;\n\nvar isFunction = function (fn) {\n\treturn typeof fn === 'function' && toStr.call(fn) === '[object Function]';\n};\n\nvar arePropertyDescriptorsSupported = function () {\n\tvar obj = {};\n\ttry {\n\t\tObject.defineProperty(obj, 'x', { enumerable: false, value: obj });\n /* eslint-disable no-unused-vars, no-restricted-syntax */\n for (var _ in obj) { return false; }\n /* eslint-enable no-unused-vars, no-restricted-syntax */\n\t\treturn obj.x === obj;\n\t} catch (e) { /* this is IE 8. */\n\t\treturn false;\n\t}\n};\nvar supportsDescriptors = Object.defineProperty && arePropertyDescriptorsSupported();\n\nvar defineProperty = function (object, name, value, predicate) {\n\tif (name in object && (!isFunction(predicate) || !predicate())) {\n\t\treturn;\n\t}\n\tif (supportsDescriptors) {\n\t\tObject.defineProperty(object, name, {\n\t\t\tconfigurable: true,\n\t\t\tenumerable: false,\n\t\t\tvalue: value,\n\t\t\twritable: true\n\t\t});\n\t} else {\n\t\tobject[name] = value;\n\t}\n};\n\nvar defineProperties = function (object, map) {\n\tvar predicates = arguments.length > 2 ? arguments[2] : {};\n\tvar props = keys(map);\n\tif (hasSymbols) {\n\t\tprops = props.concat(Object.getOwnPropertySymbols(map));\n\t}\n\tforeach(props, function (name) {\n\t\tdefineProperty(object, name, map[name], predicates[name]);\n\t});\n};\n\ndefineProperties.supportsDescriptors = !!supportsDescriptors;\n\nmodule.exports = defineProperties;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/define-properties/index.js\n// module id = 55\n// module chunks = 1","'use strict';\n\n// modified from https://github.com/es-shims/es5-shim\nvar has = Object.prototype.hasOwnProperty;\nvar toStr = Object.prototype.toString;\nvar slice = Array.prototype.slice;\nvar isArgs = require('./isArguments');\nvar isEnumerable = Object.prototype.propertyIsEnumerable;\nvar hasDontEnumBug = !isEnumerable.call({ toString: null }, 'toString');\nvar hasProtoEnumBug = isEnumerable.call(function () {}, 'prototype');\nvar dontEnums = [\n\t'toString',\n\t'toLocaleString',\n\t'valueOf',\n\t'hasOwnProperty',\n\t'isPrototypeOf',\n\t'propertyIsEnumerable',\n\t'constructor'\n];\nvar equalsConstructorPrototype = function (o) {\n\tvar ctor = o.constructor;\n\treturn ctor && ctor.prototype === o;\n};\nvar excludedKeys = {\n\t$console: true,\n\t$external: true,\n\t$frame: true,\n\t$frameElement: true,\n\t$frames: true,\n\t$innerHeight: true,\n\t$innerWidth: true,\n\t$outerHeight: true,\n\t$outerWidth: true,\n\t$pageXOffset: true,\n\t$pageYOffset: true,\n\t$parent: true,\n\t$scrollLeft: true,\n\t$scrollTop: true,\n\t$scrollX: true,\n\t$scrollY: true,\n\t$self: true,\n\t$webkitIndexedDB: true,\n\t$webkitStorageInfo: true,\n\t$window: true\n};\nvar hasAutomationEqualityBug = (function () {\n\t/* global window */\n\tif (typeof window === 'undefined') { return false; }\n\tfor (var k in window) {\n\t\ttry {\n\t\t\tif (!excludedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') {\n\t\t\t\ttry {\n\t\t\t\t\tequalsConstructorPrototype(window[k]);\n\t\t\t\t} catch (e) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t}\n\t\t} catch (e) {\n\t\t\treturn true;\n\t\t}\n\t}\n\treturn false;\n}());\nvar equalsConstructorPrototypeIfNotBuggy = function (o) {\n\t/* global window */\n\tif (typeof window === 'undefined' || !hasAutomationEqualityBug) {\n\t\treturn equalsConstructorPrototype(o);\n\t}\n\ttry {\n\t\treturn equalsConstructorPrototype(o);\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\n\nvar keysShim = function keys(object) {\n\tvar isObject = object !== null && typeof object === 'object';\n\tvar isFunction = toStr.call(object) === '[object Function]';\n\tvar isArguments = isArgs(object);\n\tvar isString = isObject && toStr.call(object) === '[object String]';\n\tvar theKeys = [];\n\n\tif (!isObject && !isFunction && !isArguments) {\n\t\tthrow new TypeError('Object.keys called on a non-object');\n\t}\n\n\tvar skipProto = hasProtoEnumBug && isFunction;\n\tif (isString && object.length > 0 && !has.call(object, 0)) {\n\t\tfor (var i = 0; i < object.length; ++i) {\n\t\t\ttheKeys.push(String(i));\n\t\t}\n\t}\n\n\tif (isArguments && object.length > 0) {\n\t\tfor (var j = 0; j < object.length; ++j) {\n\t\t\ttheKeys.push(String(j));\n\t\t}\n\t} else {\n\t\tfor (var name in object) {\n\t\t\tif (!(skipProto && name === 'prototype') && has.call(object, name)) {\n\t\t\t\ttheKeys.push(String(name));\n\t\t\t}\n\t\t}\n\t}\n\n\tif (hasDontEnumBug) {\n\t\tvar skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);\n\n\t\tfor (var k = 0; k < dontEnums.length; ++k) {\n\t\t\tif (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {\n\t\t\t\ttheKeys.push(dontEnums[k]);\n\t\t\t}\n\t\t}\n\t}\n\treturn theKeys;\n};\n\nkeysShim.shim = function shimObjectKeys() {\n\tif (Object.keys) {\n\t\tvar keysWorksWithArguments = (function () {\n\t\t\t// Safari 5.0 bug\n\t\t\treturn (Object.keys(arguments) || '').length === 2;\n\t\t}(1, 2));\n\t\tif (!keysWorksWithArguments) {\n\t\t\tvar originalKeys = Object.keys;\n\t\t\tObject.keys = function keys(object) {\n\t\t\t\tif (isArgs(object)) {\n\t\t\t\t\treturn originalKeys(slice.call(object));\n\t\t\t\t} else {\n\t\t\t\t\treturn originalKeys(object);\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t} else {\n\t\tObject.keys = keysShim;\n\t}\n\treturn Object.keys || keysShim;\n};\n\nmodule.exports = keysShim;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/object-keys/index.js\n// module id = 56\n// module chunks = 1","'use strict';\n\nvar toStr = Object.prototype.toString;\n\nmodule.exports = function isArguments(value) {\n\tvar str = toStr.call(value);\n\tvar isArgs = str === '[object Arguments]';\n\tif (!isArgs) {\n\t\tisArgs = str !== '[object Array]' &&\n\t\t\tvalue !== null &&\n\t\t\ttypeof value === 'object' &&\n\t\t\ttypeof value.length === 'number' &&\n\t\t\tvalue.length >= 0 &&\n\t\t\ttoStr.call(value.callee) === '[object Function]';\n\t}\n\treturn isArgs;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/object-keys/isArguments.js\n// module id = 57\n// module chunks = 1","\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar toString = Object.prototype.toString;\n\nmodule.exports = function forEach (obj, fn, ctx) {\n if (toString.call(fn) !== '[object Function]') {\n throw new TypeError('iterator must be a function');\n }\n var l = obj.length;\n if (l === +l) {\n for (var i = 0; i < l; i++) {\n fn.call(ctx, obj[i], i, obj);\n }\n } else {\n for (var k in obj) {\n if (hasOwn.call(obj, k)) {\n fn.call(ctx, obj[k], k, obj);\n }\n }\n }\n};\n\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/foreach/index.js\n// module id = 58\n// module chunks = 1","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.stringContains = exports.objectContains = exports.arrayContains = exports.functionThrows = exports.isA = exports.isObject = exports.isArray = exports.isFunction = exports.isEqual = exports.whyNotEqual = undefined;\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol ? \"symbol\" : typeof obj; };\n\nvar _isRegex = require('is-regex');\n\nvar _isRegex2 = _interopRequireDefault(_isRegex);\n\nvar _why = require('is-equal/why');\n\nvar _why2 = _interopRequireDefault(_why);\n\nvar _objectKeys = require('object-keys');\n\nvar _objectKeys2 = _interopRequireDefault(_objectKeys);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n * Returns the reason why the given arguments are not *conceptually*\n * equal, if any; the empty string otherwise.\n */\nvar whyNotEqual = exports.whyNotEqual = function whyNotEqual(a, b) {\n return a == b ? '' : (0, _why2.default)(a, b);\n};\n\n/**\n * Returns true if the given arguments are *conceptually* equal.\n */\nvar isEqual = exports.isEqual = function isEqual(a, b) {\n return whyNotEqual(a, b) === '';\n};\n\n/**\n * Returns true if the given object is a function.\n */\nvar isFunction = exports.isFunction = function isFunction(object) {\n return typeof object === 'function';\n};\n\n/**\n * Returns true if the given object is an array.\n */\nvar isArray = exports.isArray = function isArray(object) {\n return Array.isArray(object);\n};\n\n/**\n * Returns true if the given object is an object.\n */\nvar isObject = exports.isObject = function isObject(object) {\n return object && !isArray(object) && (typeof object === 'undefined' ? 'undefined' : _typeof(object)) === 'object';\n};\n\n/**\n * Returns true if the given object is an instanceof value\n * or its typeof is the given value.\n */\nvar isA = exports.isA = function isA(object, value) {\n if (isFunction(value)) return object instanceof value;\n\n if (value === 'array') return Array.isArray(object);\n\n return (typeof object === 'undefined' ? 'undefined' : _typeof(object)) === value;\n};\n\n/**\n * Returns true if the given function throws the given value\n * when invoked. The value may be:\n *\n * - undefined, to merely assert there was a throw\n * - a constructor function, for comparing using instanceof\n * - a regular expression, to compare with the error message\n * - a string, to find in the error message\n */\nvar functionThrows = exports.functionThrows = function functionThrows(fn, context, args, value) {\n try {\n fn.apply(context, args);\n } catch (error) {\n if (value == null) return true;\n\n if (isFunction(value) && error instanceof value) return true;\n\n var message = error.message || error;\n\n if (typeof message === 'string') {\n if ((0, _isRegex2.default)(value) && value.test(error.message)) return true;\n\n if (typeof value === 'string' && message.indexOf(value) !== -1) return true;\n }\n }\n\n return false;\n};\n\n/**\n * Returns true if the given array contains the value, false\n * otherwise. The compareValues function must return false to\n * indicate a non-match.\n */\nvar arrayContains = exports.arrayContains = function arrayContains(array, value, compareValues) {\n return array.some(function (item) {\n return compareValues(item, value) !== false;\n });\n};\n\nvar ownEnumerableKeys = function ownEnumerableKeys(object) {\n if ((typeof Reflect === 'undefined' ? 'undefined' : _typeof(Reflect)) === 'object' && typeof Reflect.ownKeys === 'function') {\n return Reflect.ownKeys(object).filter(function (key) {\n return Object.getOwnPropertyDescriptor(object, key).enumerable;\n });\n }\n\n if (typeof Object.getOwnPropertySymbols === 'function') {\n return Object.getOwnPropertySymbols(object).filter(function (key) {\n return Object.getOwnPropertyDescriptor(object, key).enumerable;\n }).concat((0, _objectKeys2.default)(object));\n }\n\n return (0, _objectKeys2.default)(object);\n};\n\n/**\n * Returns true if the given object contains the value, false\n * otherwise. The compareValues function must return false to\n * indicate a non-match.\n */\nvar objectContains = exports.objectContains = function objectContains(object, value, compareValues) {\n return ownEnumerableKeys(value).every(function (k) {\n if (isObject(object[k]) && isObject(value[k])) return objectContains(object[k], value[k], compareValues);\n\n return compareValues(object[k], value[k]);\n });\n};\n\n/**\n * Returns true if the given string contains the value, false otherwise.\n */\nvar stringContains = exports.stringContains = function stringContains(string, value) {\n return string.indexOf(value) !== -1;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/expect/lib/TestUtils.js\n// module id = 59\n// module chunks = 1","'use strict';\n\nvar has = require('has');\nvar regexExec = RegExp.prototype.exec;\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nvar tryRegexExecCall = function tryRegexExec(value) {\n\ttry {\n\t\tvar lastIndex = value.lastIndex;\n\t\tvalue.lastIndex = 0;\n\n\t\tregexExec.call(value);\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t} finally {\n\t\tvalue.lastIndex = lastIndex;\n\t}\n};\nvar toStr = Object.prototype.toString;\nvar regexClass = '[object RegExp]';\nvar hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';\n\nmodule.exports = function isRegex(value) {\n\tif (!value || typeof value !== 'object') {\n\t\treturn false;\n\t}\n\tif (!hasToStringTag) {\n\t\treturn toStr.call(value) === regexClass;\n\t}\n\n\tvar descriptor = gOPD(value, 'lastIndex');\n\tvar hasLastIndexDataProperty = descriptor && has(descriptor, 'value');\n\tif (!hasLastIndexDataProperty) {\n\t\treturn false;\n\t}\n\n\treturn tryRegexExecCall(value);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/is-regex/index.js\n// module id = 60\n// module chunks = 1","'use strict';\n\nvar ObjectPrototype = Object.prototype;\nvar toStr = ObjectPrototype.toString;\nvar booleanValue = Boolean.prototype.valueOf;\nvar has = require('has');\nvar isArrowFunction = require('is-arrow-function');\nvar isBoolean = require('is-boolean-object');\nvar isDate = require('is-date-object');\nvar isGenerator = require('is-generator-function');\nvar isNumber = require('is-number-object');\nvar isRegex = require('is-regex');\nvar isString = require('is-string');\nvar isSymbol = require('is-symbol');\nvar isCallable = require('is-callable');\n\nvar isProto = Object.prototype.isPrototypeOf;\n\nvar namedFoo = function foo() {};\nvar functionsHaveNames = namedFoo.name === 'foo';\n\nvar symbolValue = typeof Symbol === 'function' ? Symbol.prototype.valueOf : null;\nvar symbolIterator = require('./getSymbolIterator')();\n\nvar collectionsForEach = require('./getCollectionsForEach')();\n\nvar getPrototypeOf = Object.getPrototypeOf;\nif (!getPrototypeOf) {\n\t/* eslint-disable no-proto */\n\tif (typeof 'test'.__proto__ === 'object') {\n\t\tgetPrototypeOf = function (obj) {\n\t\t\treturn obj.__proto__;\n\t\t};\n\t} else {\n\t\tgetPrototypeOf = function (obj) {\n\t\t\tvar constructor = obj.constructor,\n\t\t\t\toldConstructor;\n\t\t\tif (has(obj, 'constructor')) {\n\t\t\t\toldConstructor = constructor;\n\t\t\t\tif (!(delete obj.constructor)) { // reset constructor\n\t\t\t\t\treturn null; // can't delete obj.constructor, return null\n\t\t\t\t}\n\t\t\t\tconstructor = obj.constructor; // get real constructor\n\t\t\t\tobj.constructor = oldConstructor; // restore constructor\n\t\t\t}\n\t\t\treturn constructor ? constructor.prototype : ObjectPrototype; // needed for IE\n\t\t};\n\t}\n\t/* eslint-enable no-proto */\n}\n\nvar isArray = Array.isArray || function (value) {\n\treturn toStr.call(value) === '[object Array]';\n};\n\nvar normalizeFnWhitespace = function normalizeWhitespace(fnStr) {\n\t// this is needed in IE 9, at least, which has inconsistencies here.\n\treturn fnStr.replace(/^function ?\\(/, 'function (').replace('){', ') {');\n};\n\nvar tryMapSetEntries = function tryCollectionEntries(collection) {\n\tvar foundEntries = [];\n\ttry {\n\t\tcollectionsForEach.Map.call(collection, function (key, value) {\n\t\t\tfoundEntries.push([key, value]);\n\t\t});\n\t} catch (notMap) {\n\t\ttry {\n\t\t\tcollectionsForEach.Set.call(collection, function (value) {\n\t\t\t\tfoundEntries.push([value]);\n\t\t\t});\n\t\t} catch (notSet) {\n\t\t\treturn false;\n\t\t}\n\t}\n\treturn foundEntries;\n};\n\nmodule.exports = function whyNotEqual(value, other) {\n\tif (value === other) { return ''; }\n\tif (value == null || other == null) {\n\t\treturn value === other ? '' : String(value) + ' !== ' + String(other);\n\t}\n\n\tvar valToStr = toStr.call(value);\n\tvar otherToStr = toStr.call(other);\n\tif (valToStr !== otherToStr) {\n\t\treturn 'toStringTag is not the same: ' + valToStr + ' !== ' + otherToStr;\n\t}\n\n\tvar valIsBool = isBoolean(value);\n\tvar otherIsBool = isBoolean(other);\n\tif (valIsBool || otherIsBool) {\n\t\tif (!valIsBool) { return 'first argument is not a boolean; second argument is'; }\n\t\tif (!otherIsBool) { return 'second argument is not a boolean; first argument is'; }\n\t\tvar valBoolVal = booleanValue.call(value);\n\t\tvar otherBoolVal = booleanValue.call(other);\n\t\tif (valBoolVal === otherBoolVal) { return ''; }\n\t\treturn 'primitive value of boolean arguments do not match: ' + valBoolVal + ' !== ' + otherBoolVal;\n\t}\n\n\tvar valIsNumber = isNumber(value);\n\tvar otherIsNumber = isNumber(value);\n\tif (valIsNumber || otherIsNumber) {\n\t\tif (!valIsNumber) { return 'first argument is not a number; second argument is'; }\n\t\tif (!otherIsNumber) { return 'second argument is not a number; first argument is'; }\n\t\tvar valNum = Number(value);\n\t\tvar otherNum = Number(other);\n\t\tif (valNum === otherNum) { return ''; }\n\t\tvar valIsNaN = isNaN(value);\n\t\tvar otherIsNaN = isNaN(other);\n\t\tif (valIsNaN && !otherIsNaN) {\n\t\t\treturn 'first argument is NaN; second is not';\n\t\t} else if (!valIsNaN && otherIsNaN) {\n\t\t\treturn 'second argument is NaN; first is not';\n\t\t} else if (valIsNaN && otherIsNaN) {\n\t\t\treturn '';\n\t\t}\n\t\treturn 'numbers are different: ' + value + ' !== ' + other;\n\t}\n\n\tvar valIsString = isString(value);\n\tvar otherIsString = isString(other);\n\tif (valIsString || otherIsString) {\n\t\tif (!valIsString) { return 'second argument is string; first is not'; }\n\t\tif (!otherIsString) { return 'first argument is string; second is not'; }\n\t\tvar stringVal = String(value);\n\t\tvar otherVal = String(other);\n\t\tif (stringVal === otherVal) { return ''; }\n\t\treturn 'string values are different: \"' + stringVal + '\" !== \"' + otherVal + '\"';\n\t}\n\n\tvar valIsDate = isDate(value);\n\tvar otherIsDate = isDate(other);\n\tif (valIsDate || otherIsDate) {\n\t\tif (!valIsDate) { return 'second argument is Date, first is not'; }\n\t\tif (!otherIsDate) { return 'first argument is Date, second is not'; }\n\t\tvar valTime = +value;\n\t\tvar otherTime = +other;\n\t\tif (valTime === otherTime) { return ''; }\n\t\treturn 'Dates have different time values: ' + valTime + ' !== ' + otherTime;\n\t}\n\n\tvar valIsRegex = isRegex(value);\n\tvar otherIsRegex = isRegex(other);\n\tif (valIsRegex || otherIsRegex) {\n\t\tif (!valIsRegex) { return 'second argument is RegExp, first is not'; }\n\t\tif (!otherIsRegex) { return 'first argument is RegExp, second is not'; }\n\t\tvar regexStringVal = String(value);\n\t\tvar regexStringOther = String(other);\n\t\tif (regexStringVal === regexStringOther) { return ''; }\n\t\treturn 'regular expressions differ: ' + regexStringVal + ' !== ' + regexStringOther;\n\t}\n\n\tvar valIsArray = isArray(value);\n\tvar otherIsArray = isArray(other);\n\tif (valIsArray || otherIsArray) {\n\t\tif (!valIsArray) { return 'second argument is an Array, first is not'; }\n\t\tif (!otherIsArray) { return 'first argument is an Array, second is not'; }\n\t\tif (value.length !== other.length) {\n\t\t\treturn 'arrays have different length: ' + value.length + ' !== ' + other.length;\n\t\t}\n\n\t\tvar index = value.length - 1;\n\t\tvar equal = '';\n\t\tvar valHasIndex, otherHasIndex;\n\t\twhile (equal === '' && index >= 0) {\n\t\t\tvalHasIndex = has(value, index);\n\t\t\totherHasIndex = has(other, index);\n\t\t\tif (!valHasIndex && otherHasIndex) { return 'second argument has index ' + index + '; first does not'; }\n\t\t\tif (valHasIndex && !otherHasIndex) { return 'first argument has index ' + index + '; second does not'; }\n\t\t\tequal = whyNotEqual(value[index], other[index]);\n\t\t\tindex -= 1;\n\t\t}\n\t\treturn equal;\n\t}\n\n\tvar valueIsSym = isSymbol(value);\n\tvar otherIsSym = isSymbol(other);\n\tif (valueIsSym !== otherIsSym) {\n\t\tif (valueIsSym) { return 'first argument is Symbol; second is not'; }\n\t\treturn 'second argument is Symbol; first is not';\n\t}\n\tif (valueIsSym && otherIsSym) {\n\t\treturn symbolValue.call(value) === symbolValue.call(other) ? '' : 'first Symbol value !== second Symbol value';\n\t}\n\n\tvar valueIsGen = isGenerator(value);\n\tvar otherIsGen = isGenerator(other);\n\tif (valueIsGen !== otherIsGen) {\n\t\tif (valueIsGen) { return 'first argument is a Generator; second is not'; }\n\t\treturn 'second argument is a Generator; first is not';\n\t}\n\n\tvar valueIsArrow = isArrowFunction(value);\n\tvar otherIsArrow = isArrowFunction(other);\n\tif (valueIsArrow !== otherIsArrow) {\n\t\tif (valueIsArrow) { return 'first argument is an Arrow function; second is not'; }\n\t\treturn 'second argument is an Arrow function; first is not';\n\t}\n\n\tif (isCallable(value) || isCallable(other)) {\n\t\tif (functionsHaveNames && whyNotEqual(value.name, other.name) !== '') {\n\t\t\treturn 'Function names differ: \"' + value.name + '\" !== \"' + other.name + '\"';\n\t\t}\n\t\tif (whyNotEqual(value.length, other.length) !== '') {\n\t\t\treturn 'Function lengths differ: ' + value.length + ' !== ' + other.length;\n\t\t}\n\n\t\tvar valueStr = normalizeFnWhitespace(String(value));\n\t\tvar otherStr = normalizeFnWhitespace(String(other));\n\t\tif (whyNotEqual(valueStr, otherStr) === '') { return ''; }\n\n\t\tif (!valueIsGen && !valueIsArrow) {\n\t\t\treturn whyNotEqual(valueStr.replace(/\\)\\s*\\{/, '){'), otherStr.replace(/\\)\\s*\\{/, '){')) === '' ? '' : 'Function string representations differ';\n\t\t}\n\t\treturn whyNotEqual(valueStr, otherStr) === '' ? '' : 'Function string representations differ';\n\t}\n\n\tif (typeof value === 'object' || typeof other === 'object') {\n\t\tif (typeof value !== typeof other) { return 'arguments have a different typeof: ' + typeof value + ' !== ' + typeof other; }\n\t\tif (isProto.call(value, other)) { return 'first argument is the [[Prototype]] of the second'; }\n\t\tif (isProto.call(other, value)) { return 'second argument is the [[Prototype]] of the first'; }\n\t\tif (getPrototypeOf(value) !== getPrototypeOf(other)) { return 'arguments have a different [[Prototype]]'; }\n\n\t\tif (symbolIterator) {\n\t\t\tvar valueIteratorFn = value[symbolIterator];\n\t\t\tvar valueIsIterable = isCallable(valueIteratorFn);\n\t\t\tvar otherIteratorFn = other[symbolIterator];\n\t\t\tvar otherIsIterable = isCallable(otherIteratorFn);\n\t\t\tif (valueIsIterable !== otherIsIterable) {\n\t\t\t\tif (valueIsIterable) { return 'first argument is iterable; second is not'; }\n\t\t\t\treturn 'second argument is iterable; first is not';\n\t\t\t}\n\t\t\tif (valueIsIterable && otherIsIterable) {\n\t\t\t\tvar valueIterator = valueIteratorFn.call(value);\n\t\t\t\tvar otherIterator = otherIteratorFn.call(other);\n\t\t\t\tvar valueNext, otherNext, nextWhy;\n\t\t\t\tdo {\n\t\t\t\t\tvalueNext = valueIterator.next();\n\t\t\t\t\totherNext = otherIterator.next();\n\t\t\t\t\tif (!valueNext.done && !otherNext.done) {\n\t\t\t\t\t\tnextWhy = whyNotEqual(valueNext, otherNext);\n\t\t\t\t\t\tif (nextWhy !== '') {\n\t\t\t\t\t\t\treturn 'iteration results are not equal: ' + nextWhy;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} while (!valueNext.done && !otherNext.done);\n\t\t\t\tif (valueNext.done && !otherNext.done) { return 'first argument finished iterating before second'; }\n\t\t\t\tif (!valueNext.done && otherNext.done) { return 'second argument finished iterating before first'; }\n\t\t\t\treturn '';\n\t\t\t}\n\t\t} else if (collectionsForEach.Map || collectionsForEach.Set) {\n\t\t\tvar valueEntries = tryMapSetEntries(value);\n\t\t\tvar otherEntries = tryMapSetEntries(other);\n\t\t\tvar valueEntriesIsArray = isArray(valueEntries);\n\t\t\tvar otherEntriesIsArray = isArray(otherEntries);\n\t\t\tif (valueEntriesIsArray && !otherEntriesIsArray) { return 'first argument has Collection entries, second does not'; }\n\t\t\tif (!valueEntriesIsArray && otherEntriesIsArray) { return 'second argument has Collection entries, first does not'; }\n\t\t\tif (valueEntriesIsArray && otherEntriesIsArray) {\n\t\t\t\tvar entriesWhy = whyNotEqual(valueEntries, otherEntries);\n\t\t\t\treturn entriesWhy === '' ? '' : 'Collection entries differ: ' + entriesWhy;\n\t\t\t}\n\t\t}\n\n\t\tvar key, valueKeyIsRecursive, otherKeyIsRecursive, keyWhy;\n\t\tfor (key in value) {\n\t\t\tif (has(value, key)) {\n\t\t\t\tif (!has(other, key)) { return 'first argument has key \"' + key + '\"; second does not'; }\n\t\t\t\tvalueKeyIsRecursive = !!value[key] && value[key][key] === value;\n\t\t\t\totherKeyIsRecursive = !!other[key] && other[key][key] === other;\n\t\t\t\tif (valueKeyIsRecursive !== otherKeyIsRecursive) {\n\t\t\t\t\tif (valueKeyIsRecursive) { return 'first argument has a circular reference at key \"' + key + '\"; second does not'; }\n\t\t\t\t\treturn 'second argument has a circular reference at key \"' + key + '\"; first does not';\n\t\t\t\t}\n\t\t\t\tif (!valueKeyIsRecursive && !otherKeyIsRecursive) {\n\t\t\t\t\tkeyWhy = whyNotEqual(value[key], other[key]);\n\t\t\t\t\tif (keyWhy !== '') {\n\t\t\t\t\t\treturn 'value at key \"' + key + '\" differs: ' + keyWhy;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tfor (key in other) {\n\t\t\tif (has(other, key) && !has(value, key)) {\n\t\t\t\treturn 'second argument has key \"' + key + '\"; first does not';\n\t\t\t}\n\t\t}\n\t\treturn '';\n\t}\n\n\treturn false;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/is-equal/why.js\n// module id = 61\n// module chunks = 1","'use strict';\n\nvar isCallable = require('is-callable');\nvar fnToStr = Function.prototype.toString;\nvar isNonArrowFnRegex = /^\\s*function/;\nvar isArrowFnWithParensRegex = /^\\([^\\)]*\\) *=>/;\nvar isArrowFnWithoutParensRegex = /^[^=]*=>/;\n\nmodule.exports = function isArrowFunction(fn) {\n\tif (!isCallable(fn)) { return false; }\n\tvar fnStr = fnToStr.call(fn);\n\treturn fnStr.length > 0 &&\n\t\t!isNonArrowFnRegex.test(fnStr) &&\n\t\t(isArrowFnWithParensRegex.test(fnStr) || isArrowFnWithoutParensRegex.test(fnStr));\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/is-arrow-function/index.js\n// module id = 62\n// module chunks = 1","'use strict';\n\nvar fnToStr = Function.prototype.toString;\n\nvar constructorRegex = /^\\s*class /;\nvar isES6ClassFn = function isES6ClassFn(value) {\n\ttry {\n\t\tvar fnStr = fnToStr.call(value);\n\t\tvar singleStripped = fnStr.replace(/\\/\\/.*\\n/g, '');\n\t\tvar multiStripped = singleStripped.replace(/\\/\\*[.\\s\\S]*\\*\\//g, '');\n\t\tvar spaceStripped = multiStripped.replace(/\\n/mg, ' ').replace(/ {2}/g, ' ');\n\t\treturn constructorRegex.test(spaceStripped);\n\t} catch (e) {\n\t\treturn false; // not a function\n\t}\n};\n\nvar tryFunctionObject = function tryFunctionObject(value) {\n\ttry {\n\t\tif (isES6ClassFn(value)) { return false; }\n\t\tfnToStr.call(value);\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\nvar toStr = Object.prototype.toString;\nvar fnClass = '[object Function]';\nvar genClass = '[object GeneratorFunction]';\nvar hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';\n\nmodule.exports = function isCallable(value) {\n\tif (!value) { return false; }\n\tif (typeof value !== 'function' && typeof value !== 'object') { return false; }\n\tif (hasToStringTag) { return tryFunctionObject(value); }\n\tif (isES6ClassFn(value)) { return false; }\n\tvar strClass = toStr.call(value);\n\treturn strClass === fnClass || strClass === genClass;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/is-callable/index.js\n// module id = 63\n// module chunks = 1","'use strict';\n\nvar boolToStr = Boolean.prototype.toString;\n\nvar tryBooleanObject = function tryBooleanObject(value) {\n\ttry {\n\t\tboolToStr.call(value);\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\nvar toStr = Object.prototype.toString;\nvar boolClass = '[object Boolean]';\nvar hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';\n\nmodule.exports = function isBoolean(value) {\n\tif (typeof value === 'boolean') { return true; }\n\tif (typeof value !== 'object') { return false; }\n\treturn hasToStringTag ? tryBooleanObject(value) : toStr.call(value) === boolClass;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/is-boolean-object/index.js\n// module id = 64\n// module chunks = 1","'use strict';\n\nvar getDay = Date.prototype.getDay;\nvar tryDateObject = function tryDateObject(value) {\n\ttry {\n\t\tgetDay.call(value);\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\n\nvar toStr = Object.prototype.toString;\nvar dateClass = '[object Date]';\nvar hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';\n\nmodule.exports = function isDateObject(value) {\n\tif (typeof value !== 'object' || value === null) { return false; }\n\treturn hasToStringTag ? tryDateObject(value) : toStr.call(value) === dateClass;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/is-date-object/index.js\n// module id = 65\n// module chunks = 1","'use strict';\n\nvar toStr = Object.prototype.toString;\nvar fnToStr = Function.prototype.toString;\nvar isFnRegex = /^\\s*(?:function)?\\*/;\nvar hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';\nvar getProto = Object.getPrototypeOf;\nvar getGeneratorFunc = function () { // eslint-disable-line consistent-return\n\tif (!hasToStringTag) {\n\t\treturn false;\n\t}\n\ttry {\n\t\treturn Function('return function*() {}')();\n\t} catch (e) {\n\t}\n};\nvar generatorFunc = getGeneratorFunc();\nvar GeneratorFunction = generatorFunc ? getProto(generatorFunc) : {};\n\nmodule.exports = function isGeneratorFunction(fn) {\n\tif (typeof fn !== 'function') {\n\t\treturn false;\n\t}\n\tif (isFnRegex.test(fnToStr.call(fn))) {\n\t\treturn true;\n\t}\n\tif (!hasToStringTag) {\n\t\tvar str = toStr.call(fn);\n\t\treturn str === '[object GeneratorFunction]';\n\t}\n\treturn getProto(fn) === GeneratorFunction;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/is-generator-function/index.js\n// module id = 66\n// module chunks = 1","'use strict';\n\nvar numToStr = Number.prototype.toString;\nvar tryNumberObject = function tryNumberObject(value) {\n\ttry {\n\t\tnumToStr.call(value);\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\nvar toStr = Object.prototype.toString;\nvar numClass = '[object Number]';\nvar hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';\n\nmodule.exports = function isNumberObject(value) {\n\tif (typeof value === 'number') { return true; }\n\tif (typeof value !== 'object') { return false; }\n\treturn hasToStringTag ? tryNumberObject(value) : toStr.call(value) === numClass;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/is-number-object/index.js\n// module id = 67\n// module chunks = 1","'use strict';\n\nvar strValue = String.prototype.valueOf;\nvar tryStringObject = function tryStringObject(value) {\n\ttry {\n\t\tstrValue.call(value);\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\nvar toStr = Object.prototype.toString;\nvar strClass = '[object String]';\nvar hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';\n\nmodule.exports = function isString(value) {\n\tif (typeof value === 'string') { return true; }\n\tif (typeof value !== 'object') { return false; }\n\treturn hasToStringTag ? tryStringObject(value) : toStr.call(value) === strClass;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/is-string/index.js\n// module id = 68\n// module chunks = 1","'use strict';\n\nvar toStr = Object.prototype.toString;\nvar hasSymbols = typeof Symbol === 'function' && typeof Symbol() === 'symbol';\n\nif (hasSymbols) {\n\tvar symToStr = Symbol.prototype.toString;\n\tvar symStringRegex = /^Symbol\\(.*\\)$/;\n\tvar isSymbolObject = function isSymbolObject(value) {\n\t\tif (typeof value.valueOf() !== 'symbol') { return false; }\n\t\treturn symStringRegex.test(symToStr.call(value));\n\t};\n\tmodule.exports = function isSymbol(value) {\n\t\tif (typeof value === 'symbol') { return true; }\n\t\tif (toStr.call(value) !== '[object Symbol]') { return false; }\n\t\ttry {\n\t\t\treturn isSymbolObject(value);\n\t\t} catch (e) {\n\t\t\treturn false;\n\t\t}\n\t};\n} else {\n\tmodule.exports = function isSymbol(value) {\n\t\t// this environment does not support Symbols.\n\t\treturn false;\n\t};\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/is-symbol/index.js\n// module id = 69\n// module chunks = 1","'use strict';\n\nvar isSymbol = require('is-symbol');\n\nmodule.exports = function getSymbolIterator() {\n\tvar symbolIterator = typeof Symbol === 'function' && isSymbol(Symbol.iterator) ? Symbol.iterator : null;\n\n\tif (typeof Object.getOwnPropertyNames === 'function' && typeof Map === 'function' && typeof Map.prototype.entries === 'function') {\n\t\tObject.getOwnPropertyNames(Map.prototype).forEach(function (name) {\n\t\t\tif (name !== 'entries' && name !== 'size' && Map.prototype[name] === Map.prototype.entries) {\n\t\t\t\tsymbolIterator = name;\n\t\t\t}\n\t\t});\n\t}\n\n\treturn symbolIterator;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/is-equal/getSymbolIterator.js\n// module id = 70\n// module chunks = 1","'use strict';\n\nmodule.exports = function () {\n\tvar mapForEach = (function () {\n\t\tif (typeof Map !== 'function') { return null; }\n\t\ttry {\n\t\t\tMap.prototype.forEach.call({}, function () {});\n\t\t} catch (e) {\n\t\t\treturn Map.prototype.forEach;\n\t\t}\n\t\treturn null;\n\t}());\n\n\tvar setForEach = (function () {\n\t\tif (typeof Set !== 'function') { return null; }\n\t\ttry {\n\t\t\tSet.prototype.forEach.call({}, function () {});\n\t\t} catch (e) {\n\t\t\treturn Set.prototype.forEach;\n\t\t}\n\t\treturn null;\n\t}());\n\n\treturn { Map: mapForEach, Set: setForEach };\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/is-equal/getCollectionsForEach.js\n// module id = 71\n// module chunks = 1","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _Expectation = require('./Expectation');\n\nvar _Expectation2 = _interopRequireDefault(_Expectation);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar Extensions = [];\n\nfunction extend(extension) {\n if (Extensions.indexOf(extension) === -1) {\n Extensions.push(extension);\n\n for (var p in extension) {\n if (extension.hasOwnProperty(p)) _Expectation2.default.prototype[p] = extension[p];\n }\n }\n}\n\nexports.default = extend;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/expect/lib/extend.js\n// module id = 72\n// module chunks = 1","module.exports = function deepFreeze (o) {\n Object.freeze(o);\n\n Object.getOwnPropertyNames(o).forEach(function (prop) {\n if (o.hasOwnProperty(prop)\n && o[prop] !== null\n && (typeof o[prop] === \"object\" || typeof o[prop] === \"function\")\n && !Object.isFrozen(o[prop])) {\n deepFreeze(o[prop]);\n }\n });\n \n return o;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/deep-freeze/index.js\n// module id = 73\n// module chunks = 1","import {Structure, Composite} from '../index';\nimport expect from 'expect';\nimport {createStore, applyMiddleware} from 'redux';\nimport {toggle, increment, calculator} from './Reducer';\n\nconst middlewareCalcCallback = ({dispatch, getState}) => next => action => {\n expect(['INCREMENT', 'DECREMENT']).toContain(action.type);\n let result = next(action);\n if (action.type === 'INCREMENT') {\n let state = getState();\n result = dispatch({type: 'DECREMENT', value: 5});\n expect(getState()).toEqual(state - 5);\n }\n return result;\n};\nconst middlewareIncrementCallback = ({dispatch, getState}) => next => action => {\n const previousState = getState();\n const result = next(action);\n if (previousState % 2 === 0 || getState() === previousState) {\n return result;\n }\n\n setTimeout(() => {\n const previousState = getState();\n dispatch({type: 'INCREMENT'});\n expect(getState()).toEqual(previousState + 1);\n }, 0);\n return result;\n};\nconst anotherMiddlewareIncrementCallback = ({dispatch, getState}) => next => action => {\n let result = next(action);\n if (getState() % 4 === 1) {\n result = [...(new Array(3))].map(() => dispatch({type: 'INCREMENT'}))[2];\n }\n return result;\n};\n\nconst createComposite = () => Structure({toggle, calc: [\n Composite({reducer: increment, middleware: middlewareIncrementCallback}),\n Composite({reducer: calculator, middleware: middlewareCalcCallback})\n]});\n\nconst test = () => {\n const composite = createComposite();\n let store = composite.createStore()(r => r, {toggle: false, calc: [1, 2]});\n\n store.dispatch({type: 'COMPOSITE', composite: {calc:[ , {type: 'INCREMENT', value: 2}]}});\n // added 2, decreased by 5\n expect(store.getState()).toEqual({toggle: false, calc: [1, -1]});\n\n store.dispatch({type: 'COMPOSITE', composite: {calc:[{type: 'INCREMENT'}]}});\n expect(store.getState()).toEqual({toggle: false, calc: [2, -1]});\n store.dispatch({type: 'COMPOSITE', composite: {calc:[{type: 'INCREMENT'}]}});\n const FIXED_STATE = {toggle: false, calc: [3, -1]};\n expect(store.getState()).toEqual(FIXED_STATE);\n // after timeout increment will be changed to 4\n\n const complex = Structure({\n increment: Composite({reducer: increment, middleware: middlewareIncrementCallback}),\n reducer: createComposite()\n });\n let complexStore = complex.createStore()(r => r, {increment: 1, reducer: store.getState()});\n expect(complexStore.getState().reducer).toEqual(FIXED_STATE);\n // dispatch multiple actions on children !\n complexStore.dispatch({\n type: 'COMPOSITE',\n composite: {\n increment: {type: 'INCREMENT'},\n reducer: {\n toggle: {type: 'TOGGLE'},\n calc: [\n {type: 'INCREMENT'},\n {type: 'INCREMENT', value: 10}\n ]\n }\n }\n });\n expect(complexStore.getState()).toEqual({\n increment: 2,\n reducer: {\n toggle: true,\n calc: [4, 4]\n }\n });\n // but value in store stays 3 !\n expect(store.getState()).toEqual(FIXED_STATE);\n\n const anotherComplex = Structure({\n increment: Composite({reducer: increment, middleware: anotherMiddlewareIncrementCallback}),\n reducer: Structure({\n toggle,\n calc: [\n Composite({reducer: increment, middleware: anotherMiddlewareIncrementCallback}),\n calculator\n ]\n })\n });\n let anotherComplexStore = anotherComplex.createStore()(r => r, {increment: 1, reducer: {toggle: false, calc: [0, 1]}});\n anotherComplexStore.dispatch({type: 'COMPOSITE', composite: {\n increment: {type: 'INCREMENT'},\n reducer: {\n toggle: {type: 'TOGGLE'},\n calc: [{type: 'INCREMENT'}, {type: 'INCREMENT', value: 4}]\n }\n }});\n expect(anotherComplexStore.getState()).toEqual({\n increment: 2,\n reducer: {\n toggle: true,\n calc: [4, 5]\n }\n });\n\n // test several middlewares\n let states = [1, 1];\n const middlewareMultiply2 = i => () => next => action => {\n states[i] *= 2;\n return next(action);\n };\n const middlewareAdd3 = i => () => next => action => {\n states[i] += 3;\n return next(action);\n };\n\n const testStructure = Structure([\n Composite({\n reducer: toggle,\n middleware: [middlewareMultiply2(0), middlewareAdd3(0)]\n }),\n Composite({\n reducer: toggle,\n middleware: [middlewareAdd3(1), middlewareMultiply2(1)]\n })\n ]);\n let testStore = createStore(testStructure.reducer, applyMiddleware(testStructure.middleware));\n testStore.dispatch({type: 'COMPOSITE', composite: [{type: 'TOGGLE'}, {type: 'TOGGLE'}]});\n expect(states).toEqual([5, 8]);\n testStore.dispatch({type: 'COMPOSITE', composite: [{type: 'TOGGLE'}]});\n expect(states).toEqual([13, 8]);\n};\nexport default test;\n\n\n\n// WEBPACK FOOTER //\n// ./src/Test/Middleware.js","import {Structure, Composite} from '../index';\nimport {increment, toggle, calculator} from './Reducer';\nimport expect from 'expect';\n\nconst test = () => {\n const simple = Structure({\n toggle,\n calc: [increment, Composite({\n reducer: calculator,\n equality: (prev, next) => Math.abs(next - prev) < 3\n })]\n });\n expect(simple.equality(\n {toggle: true, calc: [0, 1]}, // prev\n {toggle: true, calc: [0, 1]} // next\n )).toEqual(true);\n expect(simple.equality(\n {toggle: true, calc: [0, 1]}, // prev\n {toggle: true, calc: [1, 1]} // next\n )).toEqual(false);\n expect(simple.equality(\n {toggle: true, calc: [0, 1]}, // prev\n {toggle: true, calc: [0, -1]} // next\n )).toEqual(true);\n expect(simple.equality(\n {toggle: true, calc: [0, 1]}, // prev\n {toggle: true, calc: [0, 4]} // next\n )).toEqual(false);\n\n const complex = Structure({\n increment: Composite({\n reducer: increment,\n equality: (prev, next) => Math.abs(next - prev) > 3\n }),\n reducer: simple\n });\n expect(complex.equality(\n {increment: 1, reducer: {toggle: true, calc: [0, 1]}}, // prev\n {increment: 1, reducer: {toggle: true, calc: [0, 1]}} // next\n )).toEqual(false);\n expect(complex.equality(\n {increment: 1, reducer: {toggle: true, calc: [0, 1]}}, // prev\n {increment: 5, reducer: {toggle: true, calc: [0, 3]}} // next\n )).toEqual(true);\n expect(complex.equality(\n {increment: 1, reducer: {toggle: true, calc: [0, 1]}}, // prev\n {increment: 4, reducer: {toggle: true, calc: [0, 3]}} // next\n )).toEqual(false);\n};\nexport default test;\n\n\n\n// WEBPACK FOOTER //\n// ./src/Test/Equality.js","import {Composite, Structure} from '../index';\nimport {calculator, increment, toggle} from './Reducer';\nimport expect from 'expect';\n\nconst incrementMiddleware = ({dispatch, getState}) => next => action => {\n let result = next(action);\n if (getState() % 4 === 1) {\n result = dispatch({type: 'INCREMENT'});\n }\n return result;\n};\n\nconst createComposite = () => Structure({\n toggle,\n calc: [\n Composite({reducer: increment, middleware: incrementMiddleware}),\n calculator\n ]\n});\n\nconst test = () => {\n const composite = createComposite();\n let store = composite.createStore()(r => r, {toggle: false, calc: [0, 1]});\n let calcTriggers = [0, 0];\n let incrementSum = 0;\n composite.subscribe({\n calc: [\n ({getState}) => {\n calcTriggers[0] += 1;\n incrementSum += getState();\n },\n () => calcTriggers[1] += 1\n ]\n });\n expect(calcTriggers).toEqual([0, 0]);\n store.dispatch({type: 'COMPOSITE', composite: {\n toggle: {type: 'TOGGLE'}\n }});\n expect(calcTriggers).toEqual([0, 0]); // not triggered\n store.dispatch({type: 'COMPOSITE', composite: {\n calc: [{type: 'INCREMENT'}, {type: 'INCREMENT', value: 3}]\n }});\n expect(calcTriggers).toEqual([2, 1]); // second increment is triggered from middleware\n expect(incrementSum).toEqual(3);\n\n const complex = Structure({\n increment,\n reducer: createComposite()\n });\n let complexStore = complex.createStore()(r => r, {increment: 2, reducer: {toggle: false, calc: [0, 1]}});\n complex.subscribe({\n increment: ({getState}) => {\n calcTriggers[0] += 1;\n incrementSum += getState();\n },\n reducer: {\n calc: [ , () => calcTriggers[1] += 1 ]\n }\n });\n complexStore.dispatch({type: 'COMPOSITE', composite: {\n increment: {type: 'INCREMENT'},\n reducer: {\n toggle: {type: 'TOGGLE'},\n calc: [{type: 'INCREMENT'}, {type: 'INCREMENT', value: 3}]\n }\n }});\n expect(complexStore.getState()).toEqual({increment: 3, reducer: {toggle: true, calc: [2, 4]}});\n expect(incrementSum).toEqual(6);\n expect(calcTriggers).toEqual([3, 2]);\n complex.subscribe(({getState, dispatch}) => {\n if (getState().reducer.toggle) {\n dispatch({type: 'COMPOSITE', composite: {\n reducer: {toggle: {type: 'TOGGLE'}}\n }})\n }\n });\n complex.dispatch({type: 'COMPOSITE', composite: {\n increment: {type: 'INCREMENT'}\n }});\n expect(complexStore.getState()).toEqual({increment: 4, reducer: {toggle: false, calc: [2, 4]}});\n};\nexport default test;\n\n\n\n// WEBPACK FOOTER //\n// ./src/Test/Subscribe.js","import {Structure, Composite} from '../index';\nimport expect from 'expect';\nimport {createStore, applyMiddleware} from 'redux';\nimport {toggle, increment, calculator} from './Reducer';\n\nconst test = () => {\n const createComposite = () => Structure({\n toggle,\n calc: [\n increment,\n calculator\n ]\n });\n const composite = createComposite();\n let store = composite.createStore()(r => r, {toggle: false, calc: [0, 1]});\n\n let structure = composite.store;\n\n // check getState\n expect(structure.toggle.getState()).toEqual(false);\n expect(structure.calc[0].getState()).toEqual(0);\n expect(structure.calc[1].getState()).toEqual(1);\n\n // check dispatch\n structure.toggle.dispatch({type: 'TOGGLE'});\n expect(store.getState()).toEqual({toggle: true, calc: [0, 1]});\n structure.calc[0].dispatch({type: 'INCREMENT'});\n expect(store.getState()).toEqual({toggle: true, calc: [1, 1]});\n structure.calc[1].dispatch({type: 'DECREMENT', value: 3});\n expect(store.getState()).toEqual({toggle: true, calc: [1, -2]});\n\n // check subscribe\n let toggled = 0;\n let sum = [0, 0];\n structure.toggle.subscribe(() => ++toggled);\n structure.calc[0].subscribe(({getState}) => sum[0] += getState());\n structure.calc[1].subscribe(({getState}) => sum[1] += getState());\n // remember the last state: {toggle: true, calc: [1, -2]}\n store.dispatch({type: 'COMPOSITE', composite: {\n toggle: {type: 'TOGGLE'},\n calc: [{type: 'INCREMENT'}, {type: 'INCREMENT', value: 5}]\n }});\n expect(store.getState()).toEqual({toggle: false, calc: [2, 3]});\n expect(toggled).toEqual(1);\n expect(sum).toEqual([2, 3]);\n store.dispatch({type: 'COMPOSITE', composite: {\n toggle: {type: 'TOGGLE'},\n calc: [{type: 'INCREMENT'}, {type: 'INCREMENT', value: 4}]\n }});\n expect(store.getState()).toEqual({toggle: true, calc: [3, 7]});\n expect(toggled).toEqual(2);\n expect(sum).toEqual([5, 10]);\n\n const complex = Structure({\n increment,\n reducer: createComposite()\n });\n let complexStore = complex.createStore()(r => r, {increment: 2, reducer: {toggle: false, calc: [0, 1]}});\n\n structure = complex.store;\n\n // check getState\n expect(structure.increment.getState()).toEqual(2);\n expect(structure.reducer.structure.toggle.getState()).toEqual(false);\n expect(structure.reducer.structure.calc[0].getState()).toEqual(0);\n expect(structure.reducer.structure.calc[1].getState()).toEqual(1);\n\n // check dispatch\n structure.increment.dispatch({type: 'INCREMENT'});\n expect(complexStore.getState()).toEqual({increment: 3, reducer: {toggle: false, calc: [0, 1]}});\n structure.reducer.structure.toggle.dispatch({type: 'TOGGLE'});\n expect(complexStore.getState()).toEqual({increment: 3, reducer: {toggle: true, calc: [0, 1]}});\n structure.reducer.structure.calc[0].dispatch({type: 'INCREMENT'});\n expect(complexStore.getState()).toEqual({increment: 3, reducer: {toggle: true, calc: [1, 1]}});\n structure.reducer.structure.calc[1].dispatch({type: 'DECREMENT', value: 3});\n expect(complexStore.getState()).toEqual({increment: 3, reducer: {toggle: true, calc: [1, -2]}});\n\n // check subscribe\n let squares = 0;\n structure.increment.subscribe(({getState}) => squares += getState() * getState());\n structure.reducer.structure.toggle.subscribe(() => ++toggled);\n structure.reducer.structure.calc[0].subscribe(({getState}) => sum[0] += getState());\n structure.reducer.structure.calc[1].subscribe(({getState}) => sum[1] += getState());\n // remember the last state: {increment: 3, reducer: {toggle: true, calc: [1, -2]}}\n complexStore.dispatch({type: 'COMPOSITE', composite: {\n increment: {type: 'INCREMENT'},\n reducer: {\n toggle: {type: 'TOGGLE'},\n calc: [{type: 'INCREMENT'}, {type: 'INCREMENT', value: 5}]\n }\n }});\n expect(complexStore.getState()).toEqual({increment: 4, reducer: {toggle: false, calc: [2, 3]}});\n expect(squares).toEqual(16);\n expect(toggled).toEqual(3);\n expect(sum).toEqual([7, 13]);\n\n complexStore.dispatch({type: 'COMPOSITE', composite: {\n increment: {type: 'INCREMENT'},\n reducer: {\n toggle: {type: 'TOGGLE'},\n calc: [{type: 'INCREMENT'}, {type: 'INCREMENT', value: 4}]\n }\n }});\n expect(complexStore.getState()).toEqual({increment: 5, reducer: {toggle: true, calc: [3, 7]}});\n expect(squares).toEqual(41);\n expect(toggled).toEqual(4);\n expect(sum).toEqual([10, 20]);\n};\nexport default test;\n\n\n\n// WEBPACK FOOTER //\n// ./src/Test/Redux.js","import {Structure} from '../index';\nimport expect from 'expect';\nimport {toggle, increment, calculator} from './Reducer';\nimport {createStore, applyMiddleware} from 'redux';\nimport MemoizeChain from '../MemoizeChain';\n\nconst someFunction = (a, b) => a + b;\n\nconst test1 = (memoize, dispatch) => {\n const memoizeFunction = memoize.memoize(someFunction);\n const memoizeFunctionsStructure = {\n toggle: memoize.structure.toggle.memoize(someFunction),\n calc: [\n memoize.structure.calc[0].memoize(someFunction)\n ]\n };\n expect(memoizeFunction(3, 4)).toEqual(7);\n // memoized\n expect(memoizeFunction(4, 5)).toEqual(7);\n expect(memoizeFunctionsStructure.toggle(5, 6)).toEqual(11);\n // memoized\n expect(memoizeFunctionsStructure.toggle(6, 7)).toEqual(11);\n expect(memoizeFunctionsStructure.calc[0](7, 8)).toEqual(15);\n // memoized\n expect(memoizeFunctionsStructure.calc[0](8, 9)).toEqual(15);\n\n // change state\n dispatch({type: 'COMPOSITE', composite: {\n calc: [{type: 'INCREMENT'}]\n }});\n // re-newed\n expect(memoizeFunctionsStructure.calc[0](9, 10)).toEqual(19);\n // re-newed\n expect(memoizeFunction(10, 11)).toEqual(21);\n // not updated!\n expect(memoizeFunctionsStructure.toggle(11, 12)).toEqual(11);\n\n // change state\n dispatch({type: 'COMPOSITE', composite: {\n toggle: {type: 'TOGGLE'}\n }});\n // re-newed\n expect(memoizeFunctionsStructure.toggle(12, 13)).toEqual(25);\n // re-newed\n expect(memoizeFunction(13, 14)).toEqual(27);\n // not updated!\n expect(memoizeFunctionsStructure.calc[0](14, 15)).toEqual(19);\n}\n\nconst test2 = (memoize, dispatch) => {\n // custom memoize\n const custom = MemoizeChain(\n memoize.structure.toggle.memoize,\n memoize.structure.calc[0].memoize\n )(someFunction);\n\n expect(custom(15, 16)).toEqual(31);\n dispatch({type: 'COMPOSITE', composite: {\n toggle: {type: 'TOGGLE'}\n }});\n expect(custom(16, 17)).toEqual(33);\n dispatch({type: 'COMPOSITE', composite: {\n calc: [ , {type: 'INCREMENT', value: 2}]\n }});\n // not changed: calc[1] is not part of memoize functions chain\n expect(custom(17, 18)).toEqual(33);\n dispatch({type: 'COMPOSITE', composite: {\n calc: [{type: 'INCREMENT'}, {type: 'INCREMENT', value: 2}]\n }});\n // this time updated: calc[0] is part of memoize functions chain\n expect(custom(18, 19)).toEqual(37);\n}\n\nconst test3 = createComposite => {\n const composite = createComposite();\n let store = composite.createStore()(r => r, {toggle: false, calc: [0, 1]});\n let calculated = {total: 0, structure: {toggle: 0, calc: [0, 0]}};\n\n const structureSimple = {\n memoize: ({structure}) => {\n calculated.total += 1;\n const {toggle, calc} = structure;\n return toggle() ? calc[0]() : calc[1]()\n },\n structure: {\n toggle: ({getState}) => {\n calculated.structure.toggle += 1;\n return getState();\n },\n calc: [\n ({getState}) => {\n calculated.structure.calc[0] += 1;\n return getState() - 1;\n },\n ({getState}) => {\n calculated.structure.calc[1] += 1;\n return getState() + 1;\n }\n ]\n }\n };\n\n const memoizeSimple = composite.memoize;\n const memoized1 = memoizeSimple(structureSimple)\n const finalMemoize1 = memoized1.memoize;\n\n // Expected behavior\n expect(finalMemoize1()).toEqual(2);\n expect(calculated).toEqual({total: 1, structure: {toggle: 1, calc: [0, 1]}});\n expect(finalMemoize1()).toEqual(2);\n expect(calculated).toEqual({total: 1, structure: {toggle: 1, calc: [0, 1]}});\n store.dispatch({type: 'COMPOSITE', composite: {toggle: {type: 'TOGGLE'}}});\n expect(finalMemoize1()).toEqual(-1);\n expect(calculated).toEqual({total: 2, structure: {toggle: 2, calc: [1, 1]}});\n expect(finalMemoize1()).toEqual(-1);\n expect(calculated).toEqual({total: 2, structure: {toggle: 2, calc: [1, 1]}});\n store.dispatch({type: 'COMPOSITE', composite: {calc: [{type: 'INCREMENT'}]}});\n expect(finalMemoize1()).toEqual(0);\n expect(calculated).toEqual({total: 3, structure: {toggle: 2, calc: [2, 1]}});\n store.dispatch({type: 'COMPOSITE', composite: {toggle: {type: 'TOGGLE'}, calc: [ , {type: 'DECREMENT', value: -5}]}});\n expect(finalMemoize1()).toEqual(7);\n expect(calculated).toEqual({total: 4, structure: {toggle: 3, calc: [2, 2]}});\n store.dispatch({type: 'COMPOSITE', composite: {toggle: {type: 'TOGGLE'}, calc: [ , {type: 'DECREMENT', value: -5}]}});\n expect(finalMemoize1()).toEqual(0);\n expect(calculated).toEqual({total: 5, structure: {toggle: 4, calc: [2, 2]}});\n\n const memoized2 = memoizeSimple({\n structure: {\n toggle: structureSimple.structure.toggle,\n calc: [structureSimple.structure.calc[0]]\n }\n }).structure;\n expect(memoized2.toggle()).toEqual(true);\n expect(memoized2.calc[0]()).toEqual(0);\n expect(calculated).toEqual({total: 5, structure: {toggle: 5, calc: [3, 2]}});\n store.dispatch({type: 'COMPOSITE', composite: {toggle: {type: 'TOGGLE'}}});\n expect(memoized2.toggle()).toEqual(false);\n expect(memoized2.calc[0]()).toEqual(0);\n expect(calculated).toEqual({total: 5, structure: {toggle: 6, calc: [3, 2]}});\n\n const complexComposite = Structure({\n increment,\n reducer: createComposite()\n })\n let complexStore = complexComposite.createStore()(r => r, {increment: 1, reducer: {toggle: false, calc: [0, 1]}})\n\n let complexCalculated = {total: 0, increment: 0}\n // reset\n calculated = {total: 0, structure: {toggle: 0, calc: [0, 0]}}\n\n const complexMemoized = complexComposite.memoize({\n memoize: ({structure}) => {\n complexCalculated.total += 1;\n const {increment, reducer} = structure;\n return increment() * reducer.memoize()\n },\n structure: {\n increment: ({getState}) => {\n complexCalculated.increment += 1\n return getState()\n },\n reducer: structureSimple\n }\n })\n const finalComplexMemoize = complexMemoized.memoize;\n expect(finalComplexMemoize()).toEqual(2);\n expect(calculated).toEqual({total: 1, structure: {toggle: 1, calc: [0, 1]}});\n expect(complexCalculated).toEqual({total: 1, increment: 1});\n expect(complexMemoized.structure.reducer.structure.calc[0]()).toEqual(-1);\n expect(calculated).toEqual({total: 1, structure: {toggle: 1, calc: [1, 1]}});\n complexStore.dispatch({type: 'COMPOSITE', composite: {increment: {type: 'INCREMENT'}, reducer: {toggle: {type: 'TOGGLE'}}}});\n expect(finalComplexMemoize()).toEqual(-2);\n expect(calculated).toEqual({total: 2, structure: {toggle: 2, calc: [1, 1]}});\n expect(complexCalculated).toEqual({total: 2, increment: 2});\n}\n\nconst test = () => {\n const createComposite = () => Structure({\n toggle,\n calc: [\n increment,\n calculator\n ]\n })\n const composite = createComposite();\n let store = createStore(\n composite.reducer,\n {toggle: false, calc: [0, 1]},\n applyMiddleware(composite.middleware)\n );\n\n expect(someFunction(2, 3)).toEqual(5);\n const memoize = composite.memoize(store.getState);\n\n test1(memoize, store.dispatch);\n\n test2(memoize, store.dispatch);\n\n test3(createComposite);\n};\n\nexport default test;\n\n\n\n// WEBPACK FOOTER //\n// ./src/Test/Memoize.js","const memoizeToggle = memoize => {\n let state = false;\n return memoize(() => {\n state = !state;\n return state;\n });\n};\n\nexport const MemoizeChain = (...memoizeChain) => {\n const memoizeToggleChain = memoizeChain.map(memoize => memoizeToggle(memoize));\n return callback => {\n let state = undefined,\n result = undefined;\n return (...parameters) => {\n const next = memoizeToggleChain.map(memoizeToggleItem => memoizeToggleItem() ? '1' : '0').join('');\n if (next !== state) {\n state = next;\n result = callback(...parameters);\n }\n return result;\n };\n };\n};\n\nexport default MemoizeChain;\n\n\n\n// WEBPACK FOOTER //\n// ./src/MemoizeChain.js","import {createStore, applyMiddleware} from 'redux';\nimport {toggle, increment, calculator} from './Reducer';\nimport {Structure, Composite} from '../index';\nimport thunk from 'redux-thunk';\nimport expect from 'expect';\n\nconst calculatorThunkActor = () => (dispatch, getState) => {\n if (getState() % 2 === 0) {\n dispatch({type: 'DECREMENT', value: 1});\n }\n};\n\nconst createComposite = () => Structure({\n toggle,\n calc: [\n increment,\n Composite({reducer: calculator, middleware: thunk})\n ]\n});\n\nconst test = () => {\n const composite = createComposite()\n let store = composite.createStore()(r => r, {toggle: false, calc: [1, 2]});\n store.dispatch({type: 'COMPOSITE', composite: {calc: [ , calculatorThunkActor()]}});\n expect(store.getState()).toEqual({toggle: false, calc: [1, 1]});\n composite.dispatch({type: 'COMPOSITE', composite: {calc: [ , calculatorThunkActor()]}});\n expect(composite.getState()).toEqual({toggle: false, calc: [1, 1]});\n\n const complex = Structure({\n increment,\n reducer: createComposite()\n });\n let complexStore = complex.createStore()(r => r, {increment: 1, reducer: {toggle: false, calc: [1, 2]}})\n complexStore.dispatch({\n type: 'COMPOSITE',\n composite: {\n increment: {type: 'INCREMENT'},\n reducer: {\n toggle: {type: 'TOGGLE'},\n calc: [\n {type: 'INCREMENT'},\n calculatorThunkActor()\n ]\n }\n }\n });\n expect(complex.getState()).toEqual({\n increment: 2,\n reducer: {\n toggle: true,\n calc: [2, 1]\n }\n });\n};\nexport default test;\n\n\n\n// WEBPACK FOOTER //\n// ./src/Test/ReduxThunk.js","'use strict';\n\nexports.__esModule = true;\nfunction createThunkMiddleware(extraArgument) {\n return function (_ref) {\n var dispatch = _ref.dispatch,\n getState = _ref.getState;\n return function (next) {\n return function (action) {\n if (typeof action === 'function') {\n return action(dispatch, getState, extraArgument);\n }\n\n return next(action);\n };\n };\n };\n}\n\nvar thunk = createThunkMiddleware();\nthunk.withExtraArgument = createThunkMiddleware;\n\nexports['default'] = thunk;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/redux-thunk/lib/index.js\n// module id = 81\n// module chunks = 1","import {Defaults} from '../index';\nimport expect from 'expect';\n\nconst {Reduce, Expand} = Defaults.Prettify;\n\nexport const test = () => {\n const reduced1 = {type: 'ACTION1\\\\{a}\\\\[1]\\nACTION2\\\\{b}\\\\[0]', payload: {'{b}\\\\[0]': {data: 'SOMETHING'}}};\n const expanded1 = {type: 'COMPOSITE', composite: {\n a: [ , {type: 'ACTION1'}],\n b: [{type: 'ACTION2', data: 'SOMETHING'}]\n }};\n const reduced2 = {type: 'SOME_ACTION', data: 'SOMETHING'};\n const expanded2 = reduced2;\n expect(Reduce(expanded1)).toEqual(reduced1);\n expect(Reduce(expanded2)).toEqual(reduced2);\n expect(Expand(reduced1)).toEqual(expanded1);\n expect(Expand(reduced2)).toEqual(expanded2);\n}\n\nexport default test;\n\n\n\n// WEBPACK FOOTER //\n// ./src/Test/Prettify.js"],"sourceRoot":""}