{"version":3,"sources":["webpack:///../node_modules/redux-api-middleware/lib/index.umd.js"],"names":[],"mappings":";;;;;;;;;;;AAAA;AACA,EAAE,KAA4D;AAC9D,EAAE,SACkE;AACpE,CAAC,4BAA4B;;AAE7B;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,OAAO;AACP;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,KAAK;AACL;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;;AAEA;AACA;;AAEA;AACA,mBAAmB,sBAAsB;AACzC;;AAEA;AACA;AACA;AACA,SAAS;AACT,OAAO;AACP;AACA,OAAO;AACP;AACA;AACA,SAAS;AACT;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA,6EAA6E;AAC7E;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,mDAAmD,gBAAgB;;AAEnE;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA,+CAA+C,+BAA+B;AAC9E;;AAEA;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,OAAO;AACP;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,oBAAoB,YAAY,EAAE;AAClC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,2CAA2C;AAC3C,GAAG;;AAEH;AACA,+BAA+B;AAC/B,yCAAyC;AACzC,GAAG;AACH;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA,mCAAmC,QAAQ,mBAAmB,UAAU,EAAE,EAAE;AAC5E,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,0DAA0D,mBAAmB,UAAU,EAAE,EAAE;AAC3F,GAAG;;AAEH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK,YAAY;AACjB;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,GAAG;AACH;AACA;AACA;;AAEA,yBAAyB;AACzB;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA,KAAK;AACL;AACA;AACA;AACA,GAAG;AACH;AACA,GAAG;AACH,GAAG;;AAEH;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,uFAAuF,wBAAwB;AAC/G,sEAAsE;AACtE,iEAAiE;AACjE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AACjB,kBAAkB;AAClB;;AAEA,mBAAmB;;AAEnB;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;;;AAGA,+BAA+B,oBAAoB;;AAEnD;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;;AAGA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA,8DAA8D;AAC9D;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,YAAY,eAAe;AAClC;AACA,OAAO;AACP;AACA;;AAEA;AACA;AACA;AACA,2CAA2C,cAAc;AACzD,KAAK;AACL;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB,eAAe;AACf;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB,eAAe;AACf;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB,eAAe;AACf;;;AAGA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB,eAAe;AACf;;;AAGA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA,KAAK;AACL;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,KAAK;AACL;AACA,KAAK;AACL;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB,eAAe;AACf;;;AAGA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA,aAAa,MAAM;AACnB;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB;;;AAGA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB;;;AAGA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB,aAAa,OAAO;AACpB;AACA;;;AAGA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,GAAG;;AAEH;AACA;AACA,sDAAsD;;AAEtD;AACA,uEAAuE;AACvE,GAAG;AACH;AACA;AACA;AACA,GAAG;AACH,GAAG;;AAEH;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA,GAAG;;AAEH;;AAEA;AACA;AACA,8BAA8B,kBAAkB,EAAE;;AAElD;AACA;AACA;AACA;AACA,KAAK,YAAY;AACjB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL;;AAEA;;AAEA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,yCAAyC,iBAAiB,EAAE;AAC5D;AACA;AACA;AACA;AACA;AACA,uEAAuE,gBAAgB;AACvF;AACA;AACA,KAAK,4CAA4C,gCAAgC;AACjF;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;;AAEH;;;AAGA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;;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;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,yCAAyC,sBAAsB,EAAE;AACjE;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;AACA,kBAAkB;AAClB;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;;AAEA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,cAAc;AACd,KAAK;AACL,cAAc;AACd;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA,2EAA2E,iCAAiC;AAC5G;;AAEA;;AAEA;AACA;AACA;AACA;AACA,wBAAwB,aAAa;AACrC,KAAK;AACL;;AAEA;AACA;;AAEA;AACA;AACA,mCAAmC,qBAAqB;AACxD;AACA,mCAAmC,SAAS,EAAE;AAC9C,GAAG,YAAY;;AAEf;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B,SAAS,qBAAqB;AAC7D,qCAAqC,aAAa;AAClD;AACA,KAAK,YAAY;AACjB;AACA;;AAEA;AACA;;;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B;AAC3B;AACA;;AAEA;AACA;AACA;AACA;AACA,iDAAiD;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK,YAAY;AACjB,GAAG;;AAEH;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,sCAAsC;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,aAAa;AACb,WAAW;AACX,SAAS;AACT;AACA;AACA;AACA;AACA,+CAA+C;AAC/C;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX,qBAAqB,kCAAkC;AACvD,WAAW;AACX;AACA;AACA,SAAS;AACT;AACA;AACA,OAAO;AACP;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,iBAAiB,uCAAuC;AACxD;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,oCAAoC;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC;AACpC;AACA;AACA;AACA;AACA,yBAAyB,0BAA0B;AACnD;AACA;AACA,WAAW;AACX;AACA;AACA,SAAS;AACT,OAAO;AACP;AACA;AACA;AACA;AACA,KAAK;AACL,oBAAoB,yBAAyB,KAAK;AAClD;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA,mBAAmB;AACnB,0BAA0B;AAC1B,kBAAkB;AAClB,sBAAsB;AACtB,0BAA0B;AAC1B,kBAAkB;AAClB,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,4DAA4D,oBAAoB;AAChF;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX,SAAS;AACT;AACA,OAAO;AACP;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,OAAO;AACP;AACA;AACA;AACA,GAAG;;AAEH;;AAEA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA,oBAAoB;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB,OAAO;AACP,gBAAgB;AAChB;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,2DAA2D;AAC3D;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;;AAEA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,aAAa;AACb;;AAEA;AACA;AACA,0CAA0C,WAAW;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,WAAW;AACX;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,6BAA6B;AAC7B;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW;AACX;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,WAAW;AACX;AACA;AACA;AACA;;AAEA;;AAEA,WAAW;AACX;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,WAAW;AACX;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,sCAAsC,cAAc;AACpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,OAAO;AACP;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA,mCAAmC,kBAAkB;AACrD;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,mBAAmB;;AAEnB;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,0BAA0B,iBAAiB;AAC3C;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,cAAc;AACd;AACA;;AAEA;AACA,cAAc;AACd;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;;AAEP;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,OAAO;;AAEP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,gDAAgD,QAAQ;AACxD;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,eAAe;AACf;AACA;;AAEA,aAAa;AACb;AACA;AACA;;AAEA,aAAa;AACb;AACA;AACA;;AAEA,aAAa;AACb;AACA;AACA;AACA;AACA,OAAO;;AAEP;AACA,gDAAgD,QAAQ;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,OAAO;;AAEP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,SAAS;AACT;AACA;;AAEA;AACA,OAAO;;AAEP;AACA,gDAAgD,QAAQ;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;;AAEP;AACA,gDAAgD,QAAQ;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,OAAO;;AAEP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA,iBAAiB,cAAc;AAC/B;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB,eAAe;AACf;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,MAAM;AACnB,eAAe;AACf;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,KAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB,aAAa,MAAM;AACnB,eAAe;AACf;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB,eAAe,OAAO;AACtB;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,KAAK;AACL;AACA;;AAEA;AACA,6BAA6B;AAC7B;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;;;AAIA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA,cAAc;;AAEd;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;;;;;;AAMA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,UAAU,EAAE;AAClD,qBAAqB,sCAAsC;AAC3D,GAAG,qCAAqC;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;;AAEH;;;AAGA,4CAA4C,wBAAwB;;AAEpE;AACA;AACA;AACA,YAAY;AACZ;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ,eAAe;AACf;AACA;;AAEA;AACA;AACA,4CAA4C;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,uBAAuB;AACvB;;AAEA;;AAEA;AACA;AACA;AACA,+KAA+K;AAC/K;AACA,0QAA0Q;;AAE1Q;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,uDAAuD;AACvD;AACA;AACA,qBAAqB;;AAErB;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,uDAAuD;AACvD;AACA;AACA,qBAAqB;;AAErB;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,uDAAuD;AACvD;AACA;AACA,qBAAqB;;AAErB;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,uDAAuD;AACvD;AACA;AACA,qBAAqB;;AAErB;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,uDAAuD;AACvD;AACA;AACA,qBAAqB;;AAErB;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,8DAA8D;AAC9D;AACA;AACA;AACA;AACA,qBAAqB;;AAErB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,uDAAuD;AACvD;AACA;AACA,qBAAqB;;AAErB;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,uDAAuD;AACvD;AACA;AACA,qBAAqB;;AAErB;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,uDAAuD;AACvD;AACA,qBAAqB;;AAErB;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb,WAAW;AACX;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,gDAAgD,cAAc;;AAE9D,CAAC","file":"vendor.redux-api-middleware.56bfd86734cccac8cc64.js","sourcesContent":["(function (global, factory) {\n typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :\n typeof define === 'function' && define.amd ? define(['exports'], factory) :\n (global = global || self, factory(global.ReduxApiMiddleware = {}));\n}(this, (function (exports) { 'use strict';\n\n /**\n * String key that carries API call info interpreted by this Redux middleware.\n *\n * @constant {string}\n * @access public\n * @deprecated To be made private (implementation detail). Use `createAction` instead.\n * @default\n */\n var RSAA = '@@redux-api-middleware/RSAA';\n\n function _typeof(obj) {\n \"@babel/helpers - typeof\";\n\n if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n _typeof = function (obj) {\n return typeof obj;\n };\n } else {\n _typeof = function (obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n };\n }\n\n return _typeof(obj);\n }\n\n function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n try {\n var info = gen[key](arg);\n var value = info.value;\n } catch (error) {\n reject(error);\n return;\n }\n\n if (info.done) {\n resolve(value);\n } else {\n Promise.resolve(value).then(_next, _throw);\n }\n }\n\n function _asyncToGenerator(fn) {\n return function () {\n var self = this,\n args = arguments;\n return new Promise(function (resolve, reject) {\n var gen = fn.apply(self, args);\n\n function _next(value) {\n asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n }\n\n function _throw(err) {\n asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n }\n\n _next(undefined);\n });\n };\n }\n\n function _classCallCheck(instance, Constructor) {\n if (!(instance instanceof Constructor)) {\n throw new TypeError(\"Cannot call a class as a function\");\n }\n }\n\n function _defineProperty(obj, key, value) {\n if (key in obj) {\n Object.defineProperty(obj, key, {\n value: value,\n enumerable: true,\n configurable: true,\n writable: true\n });\n } else {\n obj[key] = value;\n }\n\n return obj;\n }\n\n function ownKeys(object, enumerableOnly) {\n var keys = Object.keys(object);\n\n if (Object.getOwnPropertySymbols) {\n var symbols = Object.getOwnPropertySymbols(object);\n if (enumerableOnly) symbols = symbols.filter(function (sym) {\n return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n });\n keys.push.apply(keys, symbols);\n }\n\n return keys;\n }\n\n function _objectSpread2(target) {\n for (var i = 1; i < arguments.length; i++) {\n var source = arguments[i] != null ? arguments[i] : {};\n\n if (i % 2) {\n ownKeys(Object(source), true).forEach(function (key) {\n _defineProperty(target, key, source[key]);\n });\n } else if (Object.getOwnPropertyDescriptors) {\n Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n } else {\n ownKeys(Object(source)).forEach(function (key) {\n Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n });\n }\n }\n\n return target;\n }\n\n function _inherits(subClass, superClass) {\n if (typeof superClass !== \"function\" && superClass !== null) {\n throw new TypeError(\"Super expression must either be null or a function\");\n }\n\n subClass.prototype = Object.create(superClass && superClass.prototype, {\n constructor: {\n value: subClass,\n writable: true,\n configurable: true\n }\n });\n if (superClass) _setPrototypeOf(subClass, superClass);\n }\n\n function _getPrototypeOf(o) {\n _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n return o.__proto__ || Object.getPrototypeOf(o);\n };\n return _getPrototypeOf(o);\n }\n\n function _setPrototypeOf(o, p) {\n _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n o.__proto__ = p;\n return o;\n };\n\n return _setPrototypeOf(o, p);\n }\n\n function isNativeReflectConstruct() {\n if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n if (Reflect.construct.sham) return false;\n if (typeof Proxy === \"function\") return true;\n\n try {\n Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));\n return true;\n } catch (e) {\n return false;\n }\n }\n\n function _construct(Parent, args, Class) {\n if (isNativeReflectConstruct()) {\n _construct = Reflect.construct;\n } else {\n _construct = function _construct(Parent, args, Class) {\n var a = [null];\n a.push.apply(a, args);\n var Constructor = Function.bind.apply(Parent, a);\n var instance = new Constructor();\n if (Class) _setPrototypeOf(instance, Class.prototype);\n return instance;\n };\n }\n\n return _construct.apply(null, arguments);\n }\n\n function _isNativeFunction(fn) {\n return Function.toString.call(fn).indexOf(\"[native code]\") !== -1;\n }\n\n function _wrapNativeSuper(Class) {\n var _cache = typeof Map === \"function\" ? new Map() : undefined;\n\n _wrapNativeSuper = function _wrapNativeSuper(Class) {\n if (Class === null || !_isNativeFunction(Class)) return Class;\n\n if (typeof Class !== \"function\") {\n throw new TypeError(\"Super expression must either be null or a function\");\n }\n\n if (typeof _cache !== \"undefined\") {\n if (_cache.has(Class)) return _cache.get(Class);\n\n _cache.set(Class, Wrapper);\n }\n\n function Wrapper() {\n return _construct(Class, arguments, _getPrototypeOf(this).constructor);\n }\n\n Wrapper.prototype = Object.create(Class.prototype, {\n constructor: {\n value: Wrapper,\n enumerable: false,\n writable: true,\n configurable: true\n }\n });\n return _setPrototypeOf(Wrapper, Class);\n };\n\n return _wrapNativeSuper(Class);\n }\n\n function _assertThisInitialized(self) {\n if (self === void 0) {\n throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n }\n\n return self;\n }\n\n function _possibleConstructorReturn(self, call) {\n if (call && (typeof call === \"object\" || typeof call === \"function\")) {\n return call;\n }\n\n return _assertThisInitialized(self);\n }\n\n function _slicedToArray(arr, i) {\n return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();\n }\n\n function _toConsumableArray(arr) {\n return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();\n }\n\n function _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) {\n for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];\n\n return arr2;\n }\n }\n\n function _arrayWithHoles(arr) {\n if (Array.isArray(arr)) return arr;\n }\n\n function _iterableToArray(iter) {\n if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter);\n }\n\n function _iterableToArrayLimit(arr, i) {\n if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === \"[object Arguments]\")) {\n return;\n }\n\n var _arr = [];\n var _n = true;\n var _d = false;\n var _e = undefined;\n\n try {\n for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n _arr.push(_s.value);\n\n if (i && _arr.length === i) break;\n }\n } catch (err) {\n _d = true;\n _e = err;\n } finally {\n try {\n if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n } finally {\n if (_d) throw _e;\n }\n }\n\n return _arr;\n }\n\n function _nonIterableSpread() {\n throw new TypeError(\"Invalid attempt to spread non-iterable instance\");\n }\n\n function _nonIterableRest() {\n throw new TypeError(\"Invalid attempt to destructure non-iterable instance\");\n }\n\n function createCommonjsModule(fn, module) {\n \treturn module = { exports: {} }, fn(module, module.exports), module.exports;\n }\n\n var _global = createCommonjsModule(function (module) {\n // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\n var global = module.exports = typeof window != 'undefined' && window.Math == Math\n ? window : typeof self != 'undefined' && self.Math == Math ? self\n // eslint-disable-next-line no-new-func\n : Function('return this')();\n if (typeof __g == 'number') __g = global; // eslint-disable-line no-undef\n });\n\n var _core = createCommonjsModule(function (module) {\n var core = module.exports = { version: '2.5.7' };\n if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef\n });\n var _core_1 = _core.version;\n\n var _isObject = function (it) {\n return typeof it === 'object' ? it !== null : typeof it === 'function';\n };\n\n var _anObject = function (it) {\n if (!_isObject(it)) throw TypeError(it + ' is not an object!');\n return it;\n };\n\n var _fails = function (exec) {\n try {\n return !!exec();\n } catch (e) {\n return true;\n }\n };\n\n // Thank's IE8 for his funny defineProperty\n var _descriptors = !_fails(function () {\n return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;\n });\n\n var document$1 = _global.document;\n // typeof document.createElement is 'object' in old IE\n var is = _isObject(document$1) && _isObject(document$1.createElement);\n var _domCreate = function (it) {\n return is ? document$1.createElement(it) : {};\n };\n\n var _ie8DomDefine = !_descriptors && !_fails(function () {\n return Object.defineProperty(_domCreate('div'), 'a', { get: function () { return 7; } }).a != 7;\n });\n\n // 7.1.1 ToPrimitive(input [, PreferredType])\n\n // instead of the ES6 spec version, we didn't implement @@toPrimitive case\n // and the second argument - flag - preferred type is a string\n var _toPrimitive = function (it, S) {\n if (!_isObject(it)) return it;\n var fn, val;\n if (S && typeof (fn = it.toString) == 'function' && !_isObject(val = fn.call(it))) return val;\n if (typeof (fn = it.valueOf) == 'function' && !_isObject(val = fn.call(it))) return val;\n if (!S && typeof (fn = it.toString) == 'function' && !_isObject(val = fn.call(it))) return val;\n throw TypeError(\"Can't convert object to primitive value\");\n };\n\n var dP = Object.defineProperty;\n\n var f = _descriptors ? Object.defineProperty : function defineProperty(O, P, Attributes) {\n _anObject(O);\n P = _toPrimitive(P, true);\n _anObject(Attributes);\n if (_ie8DomDefine) try {\n return dP(O, P, Attributes);\n } catch (e) { /* empty */ }\n if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!');\n if ('value' in Attributes) O[P] = Attributes.value;\n return O;\n };\n\n var _objectDp = {\n \tf: f\n };\n\n var _propertyDesc = function (bitmap, value) {\n return {\n enumerable: !(bitmap & 1),\n configurable: !(bitmap & 2),\n writable: !(bitmap & 4),\n value: value\n };\n };\n\n var _hide = _descriptors ? function (object, key, value) {\n return _objectDp.f(object, key, _propertyDesc(1, value));\n } : function (object, key, value) {\n object[key] = value;\n return object;\n };\n\n var hasOwnProperty = {}.hasOwnProperty;\n var _has = function (it, key) {\n return hasOwnProperty.call(it, key);\n };\n\n var id = 0;\n var px = Math.random();\n var _uid = function (key) {\n return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));\n };\n\n var _redefine = createCommonjsModule(function (module) {\n var SRC = _uid('src');\n var TO_STRING = 'toString';\n var $toString = Function[TO_STRING];\n var TPL = ('' + $toString).split(TO_STRING);\n\n _core.inspectSource = function (it) {\n return $toString.call(it);\n };\n\n (module.exports = function (O, key, val, safe) {\n var isFunction = typeof val == 'function';\n if (isFunction) _has(val, 'name') || _hide(val, 'name', key);\n if (O[key] === val) return;\n if (isFunction) _has(val, SRC) || _hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key)));\n if (O === _global) {\n O[key] = val;\n } else if (!safe) {\n delete O[key];\n _hide(O, key, val);\n } else if (O[key]) {\n O[key] = val;\n } else {\n _hide(O, key, val);\n }\n // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative\n })(Function.prototype, TO_STRING, function toString() {\n return typeof this == 'function' && this[SRC] || $toString.call(this);\n });\n });\n\n var _aFunction = function (it) {\n if (typeof it != 'function') throw TypeError(it + ' is not a function!');\n return it;\n };\n\n // optional / simple context binding\n\n var _ctx = function (fn, that, length) {\n _aFunction(fn);\n if (that === undefined) return fn;\n switch (length) {\n case 1: return function (a) {\n return fn.call(that, a);\n };\n case 2: return function (a, b) {\n return fn.call(that, a, b);\n };\n case 3: return function (a, b, c) {\n return fn.call(that, a, b, c);\n };\n }\n return function (/* ...args */) {\n return fn.apply(that, arguments);\n };\n };\n\n var PROTOTYPE = 'prototype';\n\n var $export = function (type, name, source) {\n var IS_FORCED = type & $export.F;\n var IS_GLOBAL = type & $export.G;\n var IS_STATIC = type & $export.S;\n var IS_PROTO = type & $export.P;\n var IS_BIND = type & $export.B;\n var target = IS_GLOBAL ? _global : IS_STATIC ? _global[name] || (_global[name] = {}) : (_global[name] || {})[PROTOTYPE];\n var exports = IS_GLOBAL ? _core : _core[name] || (_core[name] = {});\n var expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {});\n var key, own, out, exp;\n if (IS_GLOBAL) source = name;\n for (key in source) {\n // contains in native\n own = !IS_FORCED && target && target[key] !== undefined;\n // export native or passed\n out = (own ? target : source)[key];\n // bind timers to global for call from export context\n exp = IS_BIND && own ? _ctx(out, _global) : IS_PROTO && typeof out == 'function' ? _ctx(Function.call, out) : out;\n // extend global\n if (target) _redefine(target, key, out, type & $export.U);\n // export\n if (exports[key] != out) _hide(exports, key, exp);\n if (IS_PROTO && expProto[key] != out) expProto[key] = out;\n }\n };\n _global.core = _core;\n // type bitmap\n $export.F = 1; // forced\n $export.G = 2; // global\n $export.S = 4; // static\n $export.P = 8; // proto\n $export.B = 16; // bind\n $export.W = 32; // wrap\n $export.U = 64; // safe\n $export.R = 128; // real proto method for `library`\n var _export = $export;\n\n var toString = {}.toString;\n\n var _cof = function (it) {\n return toString.call(it).slice(8, -1);\n };\n\n // 7.2.2 IsArray(argument)\n\n var _isArray = Array.isArray || function isArray(arg) {\n return _cof(arg) == 'Array';\n };\n\n // 22.1.2.2 / 15.4.3.2 Array.isArray(arg)\n\n\n _export(_export.S, 'Array', { isArray: _isArray });\n\n // fallback for non-array-like ES3 and non-enumerable old V8 strings\n\n // eslint-disable-next-line no-prototype-builtins\n var _iobject = Object('z').propertyIsEnumerable(0) ? Object : function (it) {\n return _cof(it) == 'String' ? it.split('') : Object(it);\n };\n\n // 7.2.1 RequireObjectCoercible(argument)\n var _defined = function (it) {\n if (it == undefined) throw TypeError(\"Can't call method on \" + it);\n return it;\n };\n\n // to indexed object, toObject with fallback for non-array-like ES3 strings\n\n\n var _toIobject = function (it) {\n return _iobject(_defined(it));\n };\n\n // 7.1.4 ToInteger\n var ceil = Math.ceil;\n var floor = Math.floor;\n var _toInteger = function (it) {\n return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);\n };\n\n // 7.1.15 ToLength\n\n var min = Math.min;\n var _toLength = function (it) {\n return it > 0 ? min(_toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991\n };\n\n var max = Math.max;\n var min$1 = Math.min;\n var _toAbsoluteIndex = function (index, length) {\n index = _toInteger(index);\n return index < 0 ? max(index + length, 0) : min$1(index, length);\n };\n\n // false -> Array#indexOf\n // true -> Array#includes\n\n\n\n var _arrayIncludes = function (IS_INCLUDES) {\n return function ($this, el, fromIndex) {\n var O = _toIobject($this);\n var length = _toLength(O.length);\n var index = _toAbsoluteIndex(fromIndex, length);\n var value;\n // Array#includes uses SameValueZero equality algorithm\n // eslint-disable-next-line no-self-compare\n if (IS_INCLUDES && el != el) while (length > index) {\n value = O[index++];\n // eslint-disable-next-line no-self-compare\n if (value != value) return true;\n // Array#indexOf ignores holes, Array#includes - not\n } else for (;length > index; index++) if (IS_INCLUDES || index in O) {\n if (O[index] === el) return IS_INCLUDES || index || 0;\n } return !IS_INCLUDES && -1;\n };\n };\n\n var _strictMethod = function (method, arg) {\n return !!method && _fails(function () {\n // eslint-disable-next-line no-useless-call\n arg ? method.call(null, function () { /* empty */ }, 1) : method.call(null);\n });\n };\n\n var $indexOf = _arrayIncludes(false);\n var $native = [].indexOf;\n var NEGATIVE_ZERO = !!$native && 1 / [1].indexOf(1, -0) < 0;\n\n _export(_export.P + _export.F * (NEGATIVE_ZERO || !_strictMethod($native)), 'Array', {\n // 22.1.3.11 / 15.4.4.14 Array.prototype.indexOf(searchElement [, fromIndex])\n indexOf: function indexOf(searchElement /* , fromIndex = 0 */) {\n return NEGATIVE_ZERO\n // convert -0 to +0\n ? $native.apply(this, arguments) || 0\n : $indexOf(this, searchElement, arguments[1]);\n }\n });\n\n /**\n * Is the argument a plain object?\n * Inspired by lodash.isplainobject\n *\n * @function isPlainObject\n * @param {object} obj - The object to check\n * @returns {boolean}\n */\n\n function isPlainObject(obj) {\n return obj && _typeof(obj) == 'object' && Object.getPrototypeOf(obj) === Object.prototype;\n }\n /**\n * Is the given action a plain JavaScript object with an [RSAA] property?\n *\n * @function isRSAA\n * @access public\n * @param {object} action - The action to check\n * @returns {boolean}\n */\n\n\n function isRSAA(action) {\n return isPlainObject(action) && action.hasOwnProperty(RSAA);\n }\n /**\n * Is the given object a valid type descriptor?\n *\n * @function isValidTypeDescriptor\n * @access private\n * @param {object} obj - The object to check agains the type descriptor definition\n * @returns {boolean}\n */\n\n\n function isValidTypeDescriptor(obj) {\n var validKeys = ['type', 'payload', 'meta'];\n\n if (!isPlainObject(obj)) {\n return false;\n }\n\n for (var key in obj) {\n if (!~validKeys.indexOf(key)) {\n return false;\n }\n }\n\n if (!('type' in obj)) {\n return false;\n } else if (typeof obj.type !== 'string' && _typeof(obj.type) !== 'symbol') {\n return false;\n }\n\n return true;\n }\n /**\n * Checks an action against the RSAA definition, returning a (possibly empty)\n * array of validation errors.\n *\n * @function validateRSAA\n * @access public\n * @param {object} action - The action to check against the RSAA definition\n * @returns {array}\n */\n\n\n function validateRSAA(action) {\n var validationErrors = [];\n var validCallAPIKeys = ['endpoint', 'options', 'method', 'body', 'headers', 'credentials', 'bailout', 'types', 'fetch', 'ok'];\n var validMethods = ['GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'];\n var validCredentials = ['omit', 'same-origin', 'include'];\n\n if (!isRSAA(action)) {\n validationErrors.push('RSAAs must be plain JavaScript objects with an [RSAA] property');\n return validationErrors;\n }\n\n var callAPI = action[RSAA];\n\n if (!isPlainObject(callAPI)) {\n validationErrors.push('[RSAA] property must be a plain JavaScript object');\n }\n\n for (var key in callAPI) {\n if (!~validCallAPIKeys.indexOf(key)) {\n validationErrors.push(\"Invalid [RSAA] key: \".concat(key));\n }\n }\n\n var endpoint = callAPI.endpoint,\n method = callAPI.method,\n headers = callAPI.headers,\n options = callAPI.options,\n credentials = callAPI.credentials,\n types = callAPI.types,\n bailout = callAPI.bailout,\n fetch = callAPI.fetch,\n ok = callAPI.ok;\n\n if (typeof endpoint === 'undefined') {\n validationErrors.push('[RSAA] must have an endpoint property');\n } else if (typeof endpoint !== 'string' && typeof endpoint !== 'function') {\n validationErrors.push('[RSAA].endpoint property must be a string or a function');\n }\n\n if (typeof method === 'undefined') {\n validationErrors.push('[RSAA] must have a method property');\n } else if (typeof method !== 'string') {\n validationErrors.push('[RSAA].method property must be a string');\n } else if (!~validMethods.indexOf(method.toUpperCase())) {\n validationErrors.push(\"Invalid [RSAA].method: \".concat(method.toUpperCase()));\n }\n\n if (typeof headers !== 'undefined' && !isPlainObject(headers) && typeof headers !== 'function') {\n validationErrors.push('[RSAA].headers property must be undefined, a plain JavaScript object, or a function');\n }\n\n if (typeof options !== 'undefined' && !isPlainObject(options) && typeof options !== 'function') {\n validationErrors.push('[RSAA].options property must be undefined, a plain JavaScript object, or a function');\n }\n\n if (typeof credentials !== 'undefined') {\n if (typeof credentials !== 'string') {\n validationErrors.push('[RSAA].credentials property must be undefined, or a string');\n } else if (!~validCredentials.indexOf(credentials)) {\n validationErrors.push(\"Invalid [RSAA].credentials: \".concat(credentials));\n }\n }\n\n if (typeof bailout !== 'undefined' && typeof bailout !== 'boolean' && typeof bailout !== 'function') {\n validationErrors.push('[RSAA].bailout property must be undefined, a boolean, or a function');\n }\n\n if (typeof types === 'undefined') {\n validationErrors.push('[RSAA] must have a types property');\n } else if (!Array.isArray(types) || types.length !== 3) {\n validationErrors.push('[RSAA].types property must be an array of length 3');\n } else {\n var _types = _slicedToArray(types, 3),\n requestType = _types[0],\n successType = _types[1],\n failureType = _types[2];\n\n if (typeof requestType !== 'string' && _typeof(requestType) !== 'symbol' && !isValidTypeDescriptor(requestType)) {\n validationErrors.push('Invalid request type');\n }\n\n if (typeof successType !== 'string' && _typeof(successType) !== 'symbol' && !isValidTypeDescriptor(successType)) {\n validationErrors.push('Invalid success type');\n }\n\n if (typeof failureType !== 'string' && _typeof(failureType) !== 'symbol' && !isValidTypeDescriptor(failureType)) {\n validationErrors.push('Invalid failure type');\n }\n }\n\n if (typeof fetch !== 'undefined') {\n if (typeof fetch !== 'function') {\n validationErrors.push('[RSAA].fetch property must be a function');\n }\n }\n\n if (typeof ok !== 'undefined') {\n if (typeof ok !== 'function') {\n validationErrors.push('[RSAA].ok property must be a function');\n }\n }\n\n return validationErrors;\n }\n /**\n * Is the given action a valid RSAA?\n *\n * @function isValidRSAA\n * @access public\n * @param {object} action - The action to check against the RSAA definition\n * @returns {boolean}\n */\n\n\n function isValidRSAA(action) {\n return !validateRSAA(action).length;\n }\n\n var dP$1 = _objectDp.f;\n var FProto = Function.prototype;\n var nameRE = /^\\s*function ([^ (]*)/;\n var NAME = 'name';\n\n // 19.2.4.2 name\n NAME in FProto || _descriptors && dP$1(FProto, NAME, {\n configurable: true,\n get: function () {\n try {\n return ('' + this).match(nameRE)[1];\n } catch (e) {\n return '';\n }\n }\n });\n\n /**\n * Error class for an RSAA that does not conform to the RSAA definition\n *\n * @class InvalidRSAA\n * @access public\n * @param {array} validationErrors - an array of validation errors\n */\n var InvalidRSAA = /*#__PURE__*/function (_Error) {\n _inherits(InvalidRSAA, _Error);\n\n function InvalidRSAA(validationErrors) {\n var _this;\n\n _classCallCheck(this, InvalidRSAA);\n\n _this = _possibleConstructorReturn(this, _getPrototypeOf(InvalidRSAA).call(this));\n _this.name = 'InvalidRSAA';\n _this.message = 'Invalid RSAA';\n _this.validationErrors = validationErrors;\n return _this;\n }\n\n return InvalidRSAA;\n }( /*#__PURE__*/_wrapNativeSuper(Error));\n /**\n * Error class for a custom `payload` or `meta` function throwing\n *\n * @class InternalError\n * @access public\n * @param {string} message - the error message\n */\n\n\n var InternalError = /*#__PURE__*/function (_Error2) {\n _inherits(InternalError, _Error2);\n\n function InternalError(message) {\n var _this2;\n\n _classCallCheck(this, InternalError);\n\n _this2 = _possibleConstructorReturn(this, _getPrototypeOf(InternalError).call(this));\n _this2.name = 'InternalError';\n _this2.message = message;\n return _this2;\n }\n\n return InternalError;\n }( /*#__PURE__*/_wrapNativeSuper(Error));\n /**\n * Error class for an error raised trying to make an API call\n *\n * @class RequestError\n * @access public\n * @param {string} message - the error message\n */\n\n\n var RequestError = /*#__PURE__*/function (_Error3) {\n _inherits(RequestError, _Error3);\n\n function RequestError(message) {\n var _this3;\n\n _classCallCheck(this, RequestError);\n\n _this3 = _possibleConstructorReturn(this, _getPrototypeOf(RequestError).call(this));\n _this3.name = 'RequestError';\n _this3.message = message;\n return _this3;\n }\n\n return RequestError;\n }( /*#__PURE__*/_wrapNativeSuper(Error));\n /**\n * Error class for an API response outside the 200 range\n *\n * @class ApiError\n * @access public\n * @param {number} status - the status code of the API response\n * @param {string} statusText - the status text of the API response\n * @param {object} response - the parsed JSON response of the API server if the\n * 'Content-Type' header signals a JSON response\n */\n\n\n var ApiError = /*#__PURE__*/function (_Error4) {\n _inherits(ApiError, _Error4);\n\n function ApiError(status, statusText, response) {\n var _this4;\n\n _classCallCheck(this, ApiError);\n\n _this4 = _possibleConstructorReturn(this, _getPrototypeOf(ApiError).call(this));\n _this4.name = 'ApiError';\n _this4.status = status;\n _this4.statusText = statusText;\n _this4.response = response;\n _this4.message = \"\".concat(status, \" - \").concat(statusText);\n return _this4;\n }\n\n return ApiError;\n }( /*#__PURE__*/_wrapNativeSuper(Error));\n\n var _shared = createCommonjsModule(function (module) {\n var SHARED = '__core-js_shared__';\n var store = _global[SHARED] || (_global[SHARED] = {});\n\n (module.exports = function (key, value) {\n return store[key] || (store[key] = value !== undefined ? value : {});\n })('versions', []).push({\n version: _core.version,\n mode: 'global',\n copyright: '© 2018 Denis Pushkarev (zloirock.ru)'\n });\n });\n\n var _wks = createCommonjsModule(function (module) {\n var store = _shared('wks');\n\n var Symbol = _global.Symbol;\n var USE_SYMBOL = typeof Symbol == 'function';\n\n var $exports = module.exports = function (name) {\n return store[name] || (store[name] =\n USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : _uid)('Symbol.' + name));\n };\n\n $exports.store = store;\n });\n\n // getting tag from 19.1.3.6 Object.prototype.toString()\n\n var TAG = _wks('toStringTag');\n // ES3 wrong here\n var ARG = _cof(function () { return arguments; }()) == 'Arguments';\n\n // fallback for IE11 Script Access Denied error\n var tryGet = function (it, key) {\n try {\n return it[key];\n } catch (e) { /* empty */ }\n };\n\n var _classof = function (it) {\n var O, T, B;\n return it === undefined ? 'Undefined' : it === null ? 'Null'\n // @@toStringTag case\n : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T\n // builtinTag case\n : ARG ? _cof(O)\n // ES3 arguments fallback\n : (B = _cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;\n };\n\n var _anInstance = function (it, Constructor, name, forbiddenField) {\n if (!(it instanceof Constructor) || (forbiddenField !== undefined && forbiddenField in it)) {\n throw TypeError(name + ': incorrect invocation!');\n } return it;\n };\n\n // call something on iterator step with safe closing on error\n\n var _iterCall = function (iterator, fn, value, entries) {\n try {\n return entries ? fn(_anObject(value)[0], value[1]) : fn(value);\n // 7.4.6 IteratorClose(iterator, completion)\n } catch (e) {\n var ret = iterator['return'];\n if (ret !== undefined) _anObject(ret.call(iterator));\n throw e;\n }\n };\n\n var _iterators = {};\n\n // check on default Array iterator\n\n var ITERATOR = _wks('iterator');\n var ArrayProto = Array.prototype;\n\n var _isArrayIter = function (it) {\n return it !== undefined && (_iterators.Array === it || ArrayProto[ITERATOR] === it);\n };\n\n var ITERATOR$1 = _wks('iterator');\n\n var core_getIteratorMethod = _core.getIteratorMethod = function (it) {\n if (it != undefined) return it[ITERATOR$1]\n || it['@@iterator']\n || _iterators[_classof(it)];\n };\n\n var _forOf = createCommonjsModule(function (module) {\n var BREAK = {};\n var RETURN = {};\n var exports = module.exports = function (iterable, entries, fn, that, ITERATOR) {\n var iterFn = ITERATOR ? function () { return iterable; } : core_getIteratorMethod(iterable);\n var f = _ctx(fn, that, entries ? 2 : 1);\n var index = 0;\n var length, step, iterator, result;\n if (typeof iterFn != 'function') throw TypeError(iterable + ' is not iterable!');\n // fast case for arrays with default iterator\n if (_isArrayIter(iterFn)) for (length = _toLength(iterable.length); length > index; index++) {\n result = entries ? f(_anObject(step = iterable[index])[0], step[1]) : f(iterable[index]);\n if (result === BREAK || result === RETURN) return result;\n } else for (iterator = iterFn.call(iterable); !(step = iterator.next()).done;) {\n result = _iterCall(iterator, f, step.value, entries);\n if (result === BREAK || result === RETURN) return result;\n }\n };\n exports.BREAK = BREAK;\n exports.RETURN = RETURN;\n });\n\n // 7.3.20 SpeciesConstructor(O, defaultConstructor)\n\n\n var SPECIES = _wks('species');\n var _speciesConstructor = function (O, D) {\n var C = _anObject(O).constructor;\n var S;\n return C === undefined || (S = _anObject(C)[SPECIES]) == undefined ? D : _aFunction(S);\n };\n\n // fast apply, http://jsperf.lnkit.com/fast-apply/5\n var _invoke = function (fn, args, that) {\n var un = that === undefined;\n switch (args.length) {\n case 0: return un ? fn()\n : fn.call(that);\n case 1: return un ? fn(args[0])\n : fn.call(that, args[0]);\n case 2: return un ? fn(args[0], args[1])\n : fn.call(that, args[0], args[1]);\n case 3: return un ? fn(args[0], args[1], args[2])\n : fn.call(that, args[0], args[1], args[2]);\n case 4: return un ? fn(args[0], args[1], args[2], args[3])\n : fn.call(that, args[0], args[1], args[2], args[3]);\n } return fn.apply(that, args);\n };\n\n var document$2 = _global.document;\n var _html = document$2 && document$2.documentElement;\n\n var process = _global.process;\n var setTask = _global.setImmediate;\n var clearTask = _global.clearImmediate;\n var MessageChannel = _global.MessageChannel;\n var Dispatch = _global.Dispatch;\n var counter = 0;\n var queue = {};\n var ONREADYSTATECHANGE = 'onreadystatechange';\n var defer, channel, port;\n var run = function () {\n var id = +this;\n // eslint-disable-next-line no-prototype-builtins\n if (queue.hasOwnProperty(id)) {\n var fn = queue[id];\n delete queue[id];\n fn();\n }\n };\n var listener = function (event) {\n run.call(event.data);\n };\n // Node.js 0.9+ & IE10+ has setImmediate, otherwise:\n if (!setTask || !clearTask) {\n setTask = function setImmediate(fn) {\n var args = [];\n var i = 1;\n while (arguments.length > i) args.push(arguments[i++]);\n queue[++counter] = function () {\n // eslint-disable-next-line no-new-func\n _invoke(typeof fn == 'function' ? fn : Function(fn), args);\n };\n defer(counter);\n return counter;\n };\n clearTask = function clearImmediate(id) {\n delete queue[id];\n };\n // Node.js 0.8-\n if (_cof(process) == 'process') {\n defer = function (id) {\n process.nextTick(_ctx(run, id, 1));\n };\n // Sphere (JS game engine) Dispatch API\n } else if (Dispatch && Dispatch.now) {\n defer = function (id) {\n Dispatch.now(_ctx(run, id, 1));\n };\n // Browsers with MessageChannel, includes WebWorkers\n } else if (MessageChannel) {\n channel = new MessageChannel();\n port = channel.port2;\n channel.port1.onmessage = listener;\n defer = _ctx(port.postMessage, port, 1);\n // Browsers with postMessage, skip WebWorkers\n // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'\n } else if (_global.addEventListener && typeof postMessage == 'function' && !_global.importScripts) {\n defer = function (id) {\n _global.postMessage(id + '', '*');\n };\n _global.addEventListener('message', listener, false);\n // IE8-\n } else if (ONREADYSTATECHANGE in _domCreate('script')) {\n defer = function (id) {\n _html.appendChild(_domCreate('script'))[ONREADYSTATECHANGE] = function () {\n _html.removeChild(this);\n run.call(id);\n };\n };\n // Rest old browsers\n } else {\n defer = function (id) {\n setTimeout(_ctx(run, id, 1), 0);\n };\n }\n }\n var _task = {\n set: setTask,\n clear: clearTask\n };\n\n var macrotask = _task.set;\n var Observer = _global.MutationObserver || _global.WebKitMutationObserver;\n var process$1 = _global.process;\n var Promise$1 = _global.Promise;\n var isNode = _cof(process$1) == 'process';\n\n var _microtask = function () {\n var head, last, notify;\n\n var flush = function () {\n var parent, fn;\n if (isNode && (parent = process$1.domain)) parent.exit();\n while (head) {\n fn = head.fn;\n head = head.next;\n try {\n fn();\n } catch (e) {\n if (head) notify();\n else last = undefined;\n throw e;\n }\n } last = undefined;\n if (parent) parent.enter();\n };\n\n // Node.js\n if (isNode) {\n notify = function () {\n process$1.nextTick(flush);\n };\n // browsers with MutationObserver, except iOS Safari - https://github.com/zloirock/core-js/issues/339\n } else if (Observer && !(_global.navigator && _global.navigator.standalone)) {\n var toggle = true;\n var node = document.createTextNode('');\n new Observer(flush).observe(node, { characterData: true }); // eslint-disable-line no-new\n notify = function () {\n node.data = toggle = !toggle;\n };\n // environments with maybe non-completely correct, but existent Promise\n } else if (Promise$1 && Promise$1.resolve) {\n // Promise.resolve without an argument throws an error in LG WebOS 2\n var promise = Promise$1.resolve(undefined);\n notify = function () {\n promise.then(flush);\n };\n // for other environments - macrotask based on:\n // - setImmediate\n // - MessageChannel\n // - window.postMessag\n // - onreadystatechange\n // - setTimeout\n } else {\n notify = function () {\n // strange IE + webpack dev server bug - use .call(global)\n macrotask.call(_global, flush);\n };\n }\n\n return function (fn) {\n var task = { fn: fn, next: undefined };\n if (last) last.next = task;\n if (!head) {\n head = task;\n notify();\n } last = task;\n };\n };\n\n // 25.4.1.5 NewPromiseCapability(C)\n\n\n function PromiseCapability(C) {\n var resolve, reject;\n this.promise = new C(function ($$resolve, $$reject) {\n if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor');\n resolve = $$resolve;\n reject = $$reject;\n });\n this.resolve = _aFunction(resolve);\n this.reject = _aFunction(reject);\n }\n\n var f$1 = function (C) {\n return new PromiseCapability(C);\n };\n\n var _newPromiseCapability = {\n \tf: f$1\n };\n\n var _perform = function (exec) {\n try {\n return { e: false, v: exec() };\n } catch (e) {\n return { e: true, v: e };\n }\n };\n\n var navigator = _global.navigator;\n\n var _userAgent = navigator && navigator.userAgent || '';\n\n var _promiseResolve = function (C, x) {\n _anObject(C);\n if (_isObject(x) && x.constructor === C) return x;\n var promiseCapability = _newPromiseCapability.f(C);\n var resolve = promiseCapability.resolve;\n resolve(x);\n return promiseCapability.promise;\n };\n\n var _redefineAll = function (target, src, safe) {\n for (var key in src) _redefine(target, key, src[key], safe);\n return target;\n };\n\n var def = _objectDp.f;\n\n var TAG$1 = _wks('toStringTag');\n\n var _setToStringTag = function (it, tag, stat) {\n if (it && !_has(it = stat ? it : it.prototype, TAG$1)) def(it, TAG$1, { configurable: true, value: tag });\n };\n\n var SPECIES$1 = _wks('species');\n\n var _setSpecies = function (KEY) {\n var C = _global[KEY];\n if (_descriptors && C && !C[SPECIES$1]) _objectDp.f(C, SPECIES$1, {\n configurable: true,\n get: function () { return this; }\n });\n };\n\n var ITERATOR$2 = _wks('iterator');\n var SAFE_CLOSING = false;\n\n try {\n var riter = [7][ITERATOR$2]();\n riter['return'] = function () { SAFE_CLOSING = true; };\n // eslint-disable-next-line no-throw-literal\n Array.from(riter, function () { throw 2; });\n } catch (e) { /* empty */ }\n\n var _iterDetect = function (exec, skipClosing) {\n if (!skipClosing && !SAFE_CLOSING) return false;\n var safe = false;\n try {\n var arr = [7];\n var iter = arr[ITERATOR$2]();\n iter.next = function () { return { done: safe = true }; };\n arr[ITERATOR$2] = function () { return iter; };\n exec(arr);\n } catch (e) { /* empty */ }\n return safe;\n };\n\n var task = _task.set;\n var microtask = _microtask();\n\n\n\n\n var PROMISE = 'Promise';\n var TypeError$1 = _global.TypeError;\n var process$2 = _global.process;\n var versions = process$2 && process$2.versions;\n var v8 = versions && versions.v8 || '';\n var $Promise = _global[PROMISE];\n var isNode$1 = _classof(process$2) == 'process';\n var empty = function () { /* empty */ };\n var Internal, newGenericPromiseCapability, OwnPromiseCapability, Wrapper;\n var newPromiseCapability = newGenericPromiseCapability = _newPromiseCapability.f;\n\n var USE_NATIVE = !!function () {\n try {\n // correct subclassing with @@species support\n var promise = $Promise.resolve(1);\n var FakePromise = (promise.constructor = {})[_wks('species')] = function (exec) {\n exec(empty, empty);\n };\n // unhandled rejections tracking support, NodeJS Promise without it fails @@species test\n return (isNode$1 || typeof PromiseRejectionEvent == 'function')\n && promise.then(empty) instanceof FakePromise\n // v8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables\n // https://bugs.chromium.org/p/chromium/issues/detail?id=830565\n // we can't detect it synchronously, so just check versions\n && v8.indexOf('6.6') !== 0\n && _userAgent.indexOf('Chrome/66') === -1;\n } catch (e) { /* empty */ }\n }();\n\n // helpers\n var isThenable = function (it) {\n var then;\n return _isObject(it) && typeof (then = it.then) == 'function' ? then : false;\n };\n var notify = function (promise, isReject) {\n if (promise._n) return;\n promise._n = true;\n var chain = promise._c;\n microtask(function () {\n var value = promise._v;\n var ok = promise._s == 1;\n var i = 0;\n var run = function (reaction) {\n var handler = ok ? reaction.ok : reaction.fail;\n var resolve = reaction.resolve;\n var reject = reaction.reject;\n var domain = reaction.domain;\n var result, then, exited;\n try {\n if (handler) {\n if (!ok) {\n if (promise._h == 2) onHandleUnhandled(promise);\n promise._h = 1;\n }\n if (handler === true) result = value;\n else {\n if (domain) domain.enter();\n result = handler(value); // may throw\n if (domain) {\n domain.exit();\n exited = true;\n }\n }\n if (result === reaction.promise) {\n reject(TypeError$1('Promise-chain cycle'));\n } else if (then = isThenable(result)) {\n then.call(result, resolve, reject);\n } else resolve(result);\n } else reject(value);\n } catch (e) {\n if (domain && !exited) domain.exit();\n reject(e);\n }\n };\n while (chain.length > i) run(chain[i++]); // variable length - can't use forEach\n promise._c = [];\n promise._n = false;\n if (isReject && !promise._h) onUnhandled(promise);\n });\n };\n var onUnhandled = function (promise) {\n task.call(_global, function () {\n var value = promise._v;\n var unhandled = isUnhandled(promise);\n var result, handler, console;\n if (unhandled) {\n result = _perform(function () {\n if (isNode$1) {\n process$2.emit('unhandledRejection', value, promise);\n } else if (handler = _global.onunhandledrejection) {\n handler({ promise: promise, reason: value });\n } else if ((console = _global.console) && console.error) {\n console.error('Unhandled promise rejection', value);\n }\n });\n // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should\n promise._h = isNode$1 || isUnhandled(promise) ? 2 : 1;\n } promise._a = undefined;\n if (unhandled && result.e) throw result.v;\n });\n };\n var isUnhandled = function (promise) {\n return promise._h !== 1 && (promise._a || promise._c).length === 0;\n };\n var onHandleUnhandled = function (promise) {\n task.call(_global, function () {\n var handler;\n if (isNode$1) {\n process$2.emit('rejectionHandled', promise);\n } else if (handler = _global.onrejectionhandled) {\n handler({ promise: promise, reason: promise._v });\n }\n });\n };\n var $reject = function (value) {\n var promise = this;\n if (promise._d) return;\n promise._d = true;\n promise = promise._w || promise; // unwrap\n promise._v = value;\n promise._s = 2;\n if (!promise._a) promise._a = promise._c.slice();\n notify(promise, true);\n };\n var $resolve = function (value) {\n var promise = this;\n var then;\n if (promise._d) return;\n promise._d = true;\n promise = promise._w || promise; // unwrap\n try {\n if (promise === value) throw TypeError$1(\"Promise can't be resolved itself\");\n if (then = isThenable(value)) {\n microtask(function () {\n var wrapper = { _w: promise, _d: false }; // wrap\n try {\n then.call(value, _ctx($resolve, wrapper, 1), _ctx($reject, wrapper, 1));\n } catch (e) {\n $reject.call(wrapper, e);\n }\n });\n } else {\n promise._v = value;\n promise._s = 1;\n notify(promise, false);\n }\n } catch (e) {\n $reject.call({ _w: promise, _d: false }, e); // wrap\n }\n };\n\n // constructor polyfill\n if (!USE_NATIVE) {\n // 25.4.3.1 Promise(executor)\n $Promise = function Promise(executor) {\n _anInstance(this, $Promise, PROMISE, '_h');\n _aFunction(executor);\n Internal.call(this);\n try {\n executor(_ctx($resolve, this, 1), _ctx($reject, this, 1));\n } catch (err) {\n $reject.call(this, err);\n }\n };\n // eslint-disable-next-line no-unused-vars\n Internal = function Promise(executor) {\n this._c = []; // <- awaiting reactions\n this._a = undefined; // <- checked in isUnhandled reactions\n this._s = 0; // <- state\n this._d = false; // <- done\n this._v = undefined; // <- value\n this._h = 0; // <- rejection state, 0 - default, 1 - handled, 2 - unhandled\n this._n = false; // <- notify\n };\n Internal.prototype = _redefineAll($Promise.prototype, {\n // 25.4.5.3 Promise.prototype.then(onFulfilled, onRejected)\n then: function then(onFulfilled, onRejected) {\n var reaction = newPromiseCapability(_speciesConstructor(this, $Promise));\n reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true;\n reaction.fail = typeof onRejected == 'function' && onRejected;\n reaction.domain = isNode$1 ? process$2.domain : undefined;\n this._c.push(reaction);\n if (this._a) this._a.push(reaction);\n if (this._s) notify(this, false);\n return reaction.promise;\n },\n // 25.4.5.1 Promise.prototype.catch(onRejected)\n 'catch': function (onRejected) {\n return this.then(undefined, onRejected);\n }\n });\n OwnPromiseCapability = function () {\n var promise = new Internal();\n this.promise = promise;\n this.resolve = _ctx($resolve, promise, 1);\n this.reject = _ctx($reject, promise, 1);\n };\n _newPromiseCapability.f = newPromiseCapability = function (C) {\n return C === $Promise || C === Wrapper\n ? new OwnPromiseCapability(C)\n : newGenericPromiseCapability(C);\n };\n }\n\n _export(_export.G + _export.W + _export.F * !USE_NATIVE, { Promise: $Promise });\n _setToStringTag($Promise, PROMISE);\n _setSpecies(PROMISE);\n Wrapper = _core[PROMISE];\n\n // statics\n _export(_export.S + _export.F * !USE_NATIVE, PROMISE, {\n // 25.4.4.5 Promise.reject(r)\n reject: function reject(r) {\n var capability = newPromiseCapability(this);\n var $$reject = capability.reject;\n $$reject(r);\n return capability.promise;\n }\n });\n _export(_export.S + _export.F * ( !USE_NATIVE), PROMISE, {\n // 25.4.4.6 Promise.resolve(x)\n resolve: function resolve(x) {\n return _promiseResolve( this, x);\n }\n });\n _export(_export.S + _export.F * !(USE_NATIVE && _iterDetect(function (iter) {\n $Promise.all(iter)['catch'](empty);\n })), PROMISE, {\n // 25.4.4.1 Promise.all(iterable)\n all: function all(iterable) {\n var C = this;\n var capability = newPromiseCapability(C);\n var resolve = capability.resolve;\n var reject = capability.reject;\n var result = _perform(function () {\n var values = [];\n var index = 0;\n var remaining = 1;\n _forOf(iterable, false, function (promise) {\n var $index = index++;\n var alreadyCalled = false;\n values.push(undefined);\n remaining++;\n C.resolve(promise).then(function (value) {\n if (alreadyCalled) return;\n alreadyCalled = true;\n values[$index] = value;\n --remaining || resolve(values);\n }, reject);\n });\n --remaining || resolve(values);\n });\n if (result.e) reject(result.v);\n return capability.promise;\n },\n // 25.4.4.4 Promise.race(iterable)\n race: function race(iterable) {\n var C = this;\n var capability = newPromiseCapability(C);\n var reject = capability.reject;\n var result = _perform(function () {\n _forOf(iterable, false, function (promise) {\n C.resolve(promise).then(capability.resolve, reject);\n });\n });\n if (result.e) reject(result.v);\n return capability.promise;\n }\n });\n\n // 19.1.3.6 Object.prototype.toString()\n\n var test = {};\n test[_wks('toStringTag')] = 'z';\n if (test + '' != '[object z]') {\n _redefine(Object.prototype, 'toString', function toString() {\n return '[object ' + _classof(this) + ']';\n }, true);\n }\n\n var runtime = createCommonjsModule(function (module) {\n /**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n !(function(global) {\n\n var Op = Object.prototype;\n var hasOwn = Op.hasOwnProperty;\n var undefined$1; // More compressible than void 0.\n var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n var runtime = global.regeneratorRuntime;\n if (runtime) {\n {\n // If regeneratorRuntime is defined globally and we're in a module,\n // make the exports object identical to regeneratorRuntime.\n module.exports = runtime;\n }\n // Don't bother evaluating the rest of this file if the runtime was\n // already defined globally.\n return;\n }\n\n // Define the runtime globally (as expected by generated code) as either\n // module.exports (if we're in a module) or a new, empty object.\n runtime = global.regeneratorRuntime = module.exports ;\n\n function wrap(innerFn, outerFn, self, tryLocsList) {\n // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n var generator = Object.create(protoGenerator.prototype);\n var context = new Context(tryLocsList || []);\n\n // The ._invoke method unifies the implementations of the .next,\n // .throw, and .return methods.\n generator._invoke = makeInvokeMethod(innerFn, self, context);\n\n return generator;\n }\n runtime.wrap = wrap;\n\n // Try/catch helper to minimize deoptimizations. Returns a completion\n // record like context.tryEntries[i].completion. This interface could\n // have been (and was previously) designed to take a closure to be\n // invoked without arguments, but in all the cases we care about we\n // already have an existing method we want to call, so there's no need\n // to create a new function object. We can even get away with assuming\n // the method takes exactly one argument, since that happens to be true\n // in every case, so we don't have to touch the arguments object. The\n // only additional allocation required is the completion record, which\n // has a stable shape and so hopefully should be cheap to allocate.\n function tryCatch(fn, obj, arg) {\n try {\n return { type: \"normal\", arg: fn.call(obj, arg) };\n } catch (err) {\n return { type: \"throw\", arg: err };\n }\n }\n\n var GenStateSuspendedStart = \"suspendedStart\";\n var GenStateSuspendedYield = \"suspendedYield\";\n var GenStateExecuting = \"executing\";\n var GenStateCompleted = \"completed\";\n\n // Returning this object from the innerFn has the same effect as\n // breaking out of the dispatch switch statement.\n var ContinueSentinel = {};\n\n // Dummy constructor functions that we use as the .constructor and\n // .constructor.prototype properties for functions that return Generator\n // objects. For full spec compliance, you may wish to configure your\n // minifier not to mangle the names of these two functions.\n function Generator() {}\n function GeneratorFunction() {}\n function GeneratorFunctionPrototype() {}\n\n // This is a polyfill for %IteratorPrototype% for environments that\n // don't natively support it.\n var IteratorPrototype = {};\n IteratorPrototype[iteratorSymbol] = function () {\n return this;\n };\n\n var getProto = Object.getPrototypeOf;\n var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n if (NativeIteratorPrototype &&\n NativeIteratorPrototype !== Op &&\n hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n // This environment has a native %IteratorPrototype%; use it instead\n // of the polyfill.\n IteratorPrototype = NativeIteratorPrototype;\n }\n\n var Gp = GeneratorFunctionPrototype.prototype =\n Generator.prototype = Object.create(IteratorPrototype);\n GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;\n GeneratorFunctionPrototype.constructor = GeneratorFunction;\n GeneratorFunctionPrototype[toStringTagSymbol] =\n GeneratorFunction.displayName = \"GeneratorFunction\";\n\n // Helper for defining the .next, .throw, and .return methods of the\n // Iterator interface in terms of a single ._invoke method.\n function defineIteratorMethods(prototype) {\n [\"next\", \"throw\", \"return\"].forEach(function(method) {\n prototype[method] = function(arg) {\n return this._invoke(method, arg);\n };\n });\n }\n\n runtime.isGeneratorFunction = function(genFun) {\n var ctor = typeof genFun === \"function\" && genFun.constructor;\n return ctor\n ? ctor === GeneratorFunction ||\n // For the native GeneratorFunction constructor, the best we can\n // do is to check its .name property.\n (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n : false;\n };\n\n runtime.mark = function(genFun) {\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n } else {\n genFun.__proto__ = GeneratorFunctionPrototype;\n if (!(toStringTagSymbol in genFun)) {\n genFun[toStringTagSymbol] = \"GeneratorFunction\";\n }\n }\n genFun.prototype = Object.create(Gp);\n return genFun;\n };\n\n // Within the body of any async function, `await x` is transformed to\n // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n // meant to be awaited.\n runtime.awrap = function(arg) {\n return { __await: arg };\n };\n\n function AsyncIterator(generator) {\n function invoke(method, arg, resolve, reject) {\n var record = tryCatch(generator[method], generator, arg);\n if (record.type === \"throw\") {\n reject(record.arg);\n } else {\n var result = record.arg;\n var value = result.value;\n if (value &&\n typeof value === \"object\" &&\n hasOwn.call(value, \"__await\")) {\n return Promise.resolve(value.__await).then(function(value) {\n invoke(\"next\", value, resolve, reject);\n }, function(err) {\n invoke(\"throw\", err, resolve, reject);\n });\n }\n\n return Promise.resolve(value).then(function(unwrapped) {\n // When a yielded Promise is resolved, its final value becomes\n // the .value of the Promise<{value,done}> result for the\n // current iteration. If the Promise is rejected, however, the\n // result for this iteration will be rejected with the same\n // reason. Note that rejections of yielded Promises are not\n // thrown back into the generator function, as is the case\n // when an awaited Promise is rejected. This difference in\n // behavior between yield and await is important, because it\n // allows the consumer to decide what to do with the yielded\n // rejection (swallow it and continue, manually .throw it back\n // into the generator, abandon iteration, whatever). With\n // await, by contrast, there is no opportunity to examine the\n // rejection reason outside the generator function, so the\n // only option is to throw it from the await expression, and\n // let the generator function handle the exception.\n result.value = unwrapped;\n resolve(result);\n }, reject);\n }\n }\n\n var previousPromise;\n\n function enqueue(method, arg) {\n function callInvokeWithMethodAndArg() {\n return new Promise(function(resolve, reject) {\n invoke(method, arg, resolve, reject);\n });\n }\n\n return previousPromise =\n // If enqueue has been called before, then we want to wait until\n // all previous Promises have been resolved before calling invoke,\n // so that results are always delivered in the correct order. If\n // enqueue has not been called before, then it is important to\n // call invoke immediately, without waiting on a callback to fire,\n // so that the async generator function has the opportunity to do\n // any necessary setup in a predictable way. This predictability\n // is why the Promise constructor synchronously invokes its\n // executor callback, and why async functions synchronously\n // execute code before the first await. Since we implement simple\n // async functions in terms of async generators, it is especially\n // important to get this right, even though it requires care.\n previousPromise ? previousPromise.then(\n callInvokeWithMethodAndArg,\n // Avoid propagating failures to Promises returned by later\n // invocations of the iterator.\n callInvokeWithMethodAndArg\n ) : callInvokeWithMethodAndArg();\n }\n\n // Define the unified helper method that is used to implement .next,\n // .throw, and .return (see defineIteratorMethods).\n this._invoke = enqueue;\n }\n\n defineIteratorMethods(AsyncIterator.prototype);\n AsyncIterator.prototype[asyncIteratorSymbol] = function () {\n return this;\n };\n runtime.AsyncIterator = AsyncIterator;\n\n // Note that simple async functions are implemented on top of\n // AsyncIterator objects; they just return a Promise for the value of\n // the final result produced by the iterator.\n runtime.async = function(innerFn, outerFn, self, tryLocsList) {\n var iter = new AsyncIterator(\n wrap(innerFn, outerFn, self, tryLocsList)\n );\n\n return runtime.isGeneratorFunction(outerFn)\n ? iter // If outerFn is a generator, return the full iterator.\n : iter.next().then(function(result) {\n return result.done ? result.value : iter.next();\n });\n };\n\n function makeInvokeMethod(innerFn, self, context) {\n var state = GenStateSuspendedStart;\n\n return function invoke(method, arg) {\n if (state === GenStateExecuting) {\n throw new Error(\"Generator is already running\");\n }\n\n if (state === GenStateCompleted) {\n if (method === \"throw\") {\n throw arg;\n }\n\n // Be forgiving, per 25.3.3.3.3 of the spec:\n // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n return doneResult();\n }\n\n context.method = method;\n context.arg = arg;\n\n while (true) {\n var delegate = context.delegate;\n if (delegate) {\n var delegateResult = maybeInvokeDelegate(delegate, context);\n if (delegateResult) {\n if (delegateResult === ContinueSentinel) continue;\n return delegateResult;\n }\n }\n\n if (context.method === \"next\") {\n // Setting context._sent for legacy support of Babel's\n // function.sent implementation.\n context.sent = context._sent = context.arg;\n\n } else if (context.method === \"throw\") {\n if (state === GenStateSuspendedStart) {\n state = GenStateCompleted;\n throw context.arg;\n }\n\n context.dispatchException(context.arg);\n\n } else if (context.method === \"return\") {\n context.abrupt(\"return\", context.arg);\n }\n\n state = GenStateExecuting;\n\n var record = tryCatch(innerFn, self, context);\n if (record.type === \"normal\") {\n // If an exception is thrown from innerFn, we leave state ===\n // GenStateExecuting and loop back for another invocation.\n state = context.done\n ? GenStateCompleted\n : GenStateSuspendedYield;\n\n if (record.arg === ContinueSentinel) {\n continue;\n }\n\n return {\n value: record.arg,\n done: context.done\n };\n\n } else if (record.type === \"throw\") {\n state = GenStateCompleted;\n // Dispatch the exception by looping back around to the\n // context.dispatchException(context.arg) call above.\n context.method = \"throw\";\n context.arg = record.arg;\n }\n }\n };\n }\n\n // Call delegate.iterator[context.method](context.arg) and handle the\n // result, either by returning a { value, done } result from the\n // delegate iterator, or by modifying context.method and context.arg,\n // setting context.delegate to null, and returning the ContinueSentinel.\n function maybeInvokeDelegate(delegate, context) {\n var method = delegate.iterator[context.method];\n if (method === undefined$1) {\n // A .throw or .return when the delegate iterator has no .throw\n // method always terminates the yield* loop.\n context.delegate = null;\n\n if (context.method === \"throw\") {\n if (delegate.iterator.return) {\n // If the delegate iterator has a return method, give it a\n // chance to clean up.\n context.method = \"return\";\n context.arg = undefined$1;\n maybeInvokeDelegate(delegate, context);\n\n if (context.method === \"throw\") {\n // If maybeInvokeDelegate(context) changed context.method from\n // \"return\" to \"throw\", let that override the TypeError below.\n return ContinueSentinel;\n }\n }\n\n context.method = \"throw\";\n context.arg = new TypeError(\n \"The iterator does not provide a 'throw' method\");\n }\n\n return ContinueSentinel;\n }\n\n var record = tryCatch(method, delegate.iterator, context.arg);\n\n if (record.type === \"throw\") {\n context.method = \"throw\";\n context.arg = record.arg;\n context.delegate = null;\n return ContinueSentinel;\n }\n\n var info = record.arg;\n\n if (! info) {\n context.method = \"throw\";\n context.arg = new TypeError(\"iterator result is not an object\");\n context.delegate = null;\n return ContinueSentinel;\n }\n\n if (info.done) {\n // Assign the result of the finished delegate to the temporary\n // variable specified by delegate.resultName (see delegateYield).\n context[delegate.resultName] = info.value;\n\n // Resume execution at the desired location (see delegateYield).\n context.next = delegate.nextLoc;\n\n // If context.method was \"throw\" but the delegate handled the\n // exception, let the outer generator proceed normally. If\n // context.method was \"next\", forget context.arg since it has been\n // \"consumed\" by the delegate iterator. If context.method was\n // \"return\", allow the original .return call to continue in the\n // outer generator.\n if (context.method !== \"return\") {\n context.method = \"next\";\n context.arg = undefined$1;\n }\n\n } else {\n // Re-yield the result returned by the delegate method.\n return info;\n }\n\n // The delegate iterator is finished, so forget it and continue with\n // the outer generator.\n context.delegate = null;\n return ContinueSentinel;\n }\n\n // Define Generator.prototype.{next,throw,return} in terms of the\n // unified ._invoke helper method.\n defineIteratorMethods(Gp);\n\n Gp[toStringTagSymbol] = \"Generator\";\n\n // A Generator should always return itself as the iterator object when the\n // @@iterator function is called on it. Some browsers' implementations of the\n // iterator prototype chain incorrectly implement this, causing the Generator\n // object to not be returned from this call. This ensures that doesn't happen.\n // See https://github.com/facebook/regenerator/issues/274 for more details.\n Gp[iteratorSymbol] = function() {\n return this;\n };\n\n Gp.toString = function() {\n return \"[object Generator]\";\n };\n\n function pushTryEntry(locs) {\n var entry = { tryLoc: locs[0] };\n\n if (1 in locs) {\n entry.catchLoc = locs[1];\n }\n\n if (2 in locs) {\n entry.finallyLoc = locs[2];\n entry.afterLoc = locs[3];\n }\n\n this.tryEntries.push(entry);\n }\n\n function resetTryEntry(entry) {\n var record = entry.completion || {};\n record.type = \"normal\";\n delete record.arg;\n entry.completion = record;\n }\n\n function Context(tryLocsList) {\n // The root entry object (effectively a try statement without a catch\n // or a finally block) gives us a place to store values thrown from\n // locations where there is no enclosing try statement.\n this.tryEntries = [{ tryLoc: \"root\" }];\n tryLocsList.forEach(pushTryEntry, this);\n this.reset(true);\n }\n\n runtime.keys = function(object) {\n var keys = [];\n for (var key in object) {\n keys.push(key);\n }\n keys.reverse();\n\n // Rather than returning an object with a next method, we keep\n // things simple and return the next function itself.\n return function next() {\n while (keys.length) {\n var key = keys.pop();\n if (key in object) {\n next.value = key;\n next.done = false;\n return next;\n }\n }\n\n // To avoid creating an additional object, we just hang the .value\n // and .done properties off the next function object itself. This\n // also ensures that the minifier will not anonymize the function.\n next.done = true;\n return next;\n };\n };\n\n function values(iterable) {\n if (iterable) {\n var iteratorMethod = iterable[iteratorSymbol];\n if (iteratorMethod) {\n return iteratorMethod.call(iterable);\n }\n\n if (typeof iterable.next === \"function\") {\n return iterable;\n }\n\n if (!isNaN(iterable.length)) {\n var i = -1, next = function next() {\n while (++i < iterable.length) {\n if (hasOwn.call(iterable, i)) {\n next.value = iterable[i];\n next.done = false;\n return next;\n }\n }\n\n next.value = undefined$1;\n next.done = true;\n\n return next;\n };\n\n return next.next = next;\n }\n }\n\n // Return an iterator with no values.\n return { next: doneResult };\n }\n runtime.values = values;\n\n function doneResult() {\n return { value: undefined$1, done: true };\n }\n\n Context.prototype = {\n constructor: Context,\n\n reset: function(skipTempReset) {\n this.prev = 0;\n this.next = 0;\n // Resetting context._sent for legacy support of Babel's\n // function.sent implementation.\n this.sent = this._sent = undefined$1;\n this.done = false;\n this.delegate = null;\n\n this.method = \"next\";\n this.arg = undefined$1;\n\n this.tryEntries.forEach(resetTryEntry);\n\n if (!skipTempReset) {\n for (var name in this) {\n // Not sure about the optimal order of these conditions:\n if (name.charAt(0) === \"t\" &&\n hasOwn.call(this, name) &&\n !isNaN(+name.slice(1))) {\n this[name] = undefined$1;\n }\n }\n }\n },\n\n stop: function() {\n this.done = true;\n\n var rootEntry = this.tryEntries[0];\n var rootRecord = rootEntry.completion;\n if (rootRecord.type === \"throw\") {\n throw rootRecord.arg;\n }\n\n return this.rval;\n },\n\n dispatchException: function(exception) {\n if (this.done) {\n throw exception;\n }\n\n var context = this;\n function handle(loc, caught) {\n record.type = \"throw\";\n record.arg = exception;\n context.next = loc;\n\n if (caught) {\n // If the dispatched exception was caught by a catch block,\n // then let that catch block handle the exception normally.\n context.method = \"next\";\n context.arg = undefined$1;\n }\n\n return !! caught;\n }\n\n for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n var entry = this.tryEntries[i];\n var record = entry.completion;\n\n if (entry.tryLoc === \"root\") {\n // Exception thrown outside of any try block that could handle\n // it, so set the completion value of the entire function to\n // throw the exception.\n return handle(\"end\");\n }\n\n if (entry.tryLoc <= this.prev) {\n var hasCatch = hasOwn.call(entry, \"catchLoc\");\n var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n if (hasCatch && hasFinally) {\n if (this.prev < entry.catchLoc) {\n return handle(entry.catchLoc, true);\n } else if (this.prev < entry.finallyLoc) {\n return handle(entry.finallyLoc);\n }\n\n } else if (hasCatch) {\n if (this.prev < entry.catchLoc) {\n return handle(entry.catchLoc, true);\n }\n\n } else if (hasFinally) {\n if (this.prev < entry.finallyLoc) {\n return handle(entry.finallyLoc);\n }\n\n } else {\n throw new Error(\"try statement without catch or finally\");\n }\n }\n }\n },\n\n abrupt: function(type, arg) {\n for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n var entry = this.tryEntries[i];\n if (entry.tryLoc <= this.prev &&\n hasOwn.call(entry, \"finallyLoc\") &&\n this.prev < entry.finallyLoc) {\n var finallyEntry = entry;\n break;\n }\n }\n\n if (finallyEntry &&\n (type === \"break\" ||\n type === \"continue\") &&\n finallyEntry.tryLoc <= arg &&\n arg <= finallyEntry.finallyLoc) {\n // Ignore the finally entry if control is not jumping to a\n // location outside the try/catch block.\n finallyEntry = null;\n }\n\n var record = finallyEntry ? finallyEntry.completion : {};\n record.type = type;\n record.arg = arg;\n\n if (finallyEntry) {\n this.method = \"next\";\n this.next = finallyEntry.finallyLoc;\n return ContinueSentinel;\n }\n\n return this.complete(record);\n },\n\n complete: function(record, afterLoc) {\n if (record.type === \"throw\") {\n throw record.arg;\n }\n\n if (record.type === \"break\" ||\n record.type === \"continue\") {\n this.next = record.arg;\n } else if (record.type === \"return\") {\n this.rval = this.arg = record.arg;\n this.method = \"return\";\n this.next = \"end\";\n } else if (record.type === \"normal\" && afterLoc) {\n this.next = afterLoc;\n }\n\n return ContinueSentinel;\n },\n\n finish: function(finallyLoc) {\n for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n var entry = this.tryEntries[i];\n if (entry.finallyLoc === finallyLoc) {\n this.complete(entry.completion, entry.afterLoc);\n resetTryEntry(entry);\n return ContinueSentinel;\n }\n }\n },\n\n \"catch\": function(tryLoc) {\n for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n var entry = this.tryEntries[i];\n if (entry.tryLoc === tryLoc) {\n var record = entry.completion;\n if (record.type === \"throw\") {\n var thrown = record.arg;\n resetTryEntry(entry);\n }\n return thrown;\n }\n }\n\n // The context.catch method must only be called with a location\n // argument that corresponds to a known catch block.\n throw new Error(\"illegal catch attempt\");\n },\n\n delegateYield: function(iterable, resultName, nextLoc) {\n this.delegate = {\n iterator: values(iterable),\n resultName: resultName,\n nextLoc: nextLoc\n };\n\n if (this.method === \"next\") {\n // Deliberately forget the last sent value so that we don't\n // accidentally pass it on to the delegate.\n this.arg = undefined$1;\n }\n\n return ContinueSentinel;\n }\n };\n })(\n // In sloppy mode, unbound `this` refers to the global object, fallback to\n // Function constructor if we're in global strict mode. That is sadly a form\n // of indirect eval which violates Content Security Policy.\n (function() { return this })() || Function(\"return this\")()\n );\n });\n\n /**\n * Extract JSON body from a server response\n *\n * @function getJSON\n * @access public\n * @param {object} res - A raw response object\n * @returns {promise|undefined}\n */\n\n function getJSON(_x) {\n return _getJSON.apply(this, arguments);\n }\n /**\n * Blow up string or symbol types into full-fledged type descriptors,\n * and add defaults\n *\n * @function normalizeTypeDescriptors\n * @access private\n * @param {array} types - The [RSAA].types from a validated RSAA\n * @returns {array}\n */\n\n\n function _getJSON() {\n _getJSON = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(res) {\n var contentType, emptyCodes;\n return regeneratorRuntime.wrap(function _callee$(_context) {\n while (1) {\n switch (_context.prev = _context.next) {\n case 0:\n contentType = res.headers.get('Content-Type');\n emptyCodes = [204, 205];\n\n if (!(!~emptyCodes.indexOf(res.status) && contentType && ~contentType.indexOf('json'))) {\n _context.next = 8;\n break;\n }\n\n _context.next = 5;\n return res.json();\n\n case 5:\n return _context.abrupt(\"return\", _context.sent);\n\n case 8:\n _context.next = 10;\n return Promise.resolve();\n\n case 10:\n return _context.abrupt(\"return\", _context.sent);\n\n case 11:\n case \"end\":\n return _context.stop();\n }\n }\n }, _callee);\n }));\n return _getJSON.apply(this, arguments);\n }\n\n function normalizeTypeDescriptors(types) {\n var _types = _slicedToArray(types, 3),\n requestType = _types[0],\n successType = _types[1],\n failureType = _types[2];\n\n if (typeof requestType === 'string' || _typeof(requestType) === 'symbol') {\n requestType = {\n type: requestType\n };\n }\n\n if (typeof successType === 'string' || _typeof(successType) === 'symbol') {\n successType = {\n type: successType\n };\n }\n\n successType = _objectSpread2({\n payload: function payload(action, state, res) {\n return getJSON(res);\n }\n }, successType);\n\n if (typeof failureType === 'string' || _typeof(failureType) === 'symbol') {\n failureType = {\n type: failureType\n };\n }\n\n failureType = _objectSpread2({\n payload: function payload(action, state, res) {\n return getJSON(res).then(function (json) {\n return new ApiError(res.status, res.statusText, json);\n });\n }\n }, failureType);\n return [requestType, successType, failureType];\n }\n /**\n * Evaluate a type descriptor to an FSA\n *\n * @function actionWith\n * @access private\n * @param {object} descriptor - A type descriptor\n * @param {array} args - The array of arguments for `payload` and `meta` function properties\n * @returns {object}\n */\n\n\n function actionWith(_x2) {\n return _actionWith.apply(this, arguments);\n }\n /**\n * Create RSAA action\n *\n * @function createAction\n * @access public\n * @param {object} clientCall - The options for the RSAA action\n * @returns {object} RSAA Action\n */\n\n\n function _actionWith() {\n _actionWith = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(descriptor) {\n var args,\n _args2 = arguments;\n return regeneratorRuntime.wrap(function _callee2$(_context2) {\n while (1) {\n switch (_context2.prev = _context2.next) {\n case 0:\n args = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : [];\n _context2.prev = 1;\n\n if (!(typeof descriptor.payload === 'function')) {\n _context2.next = 8;\n break;\n }\n\n _context2.next = 5;\n return descriptor.payload.apply(descriptor, _toConsumableArray(args));\n\n case 5:\n _context2.t0 = _context2.sent;\n _context2.next = 9;\n break;\n\n case 8:\n _context2.t0 = descriptor.payload;\n\n case 9:\n descriptor.payload = _context2.t0;\n _context2.next = 16;\n break;\n\n case 12:\n _context2.prev = 12;\n _context2.t1 = _context2[\"catch\"](1);\n descriptor.payload = new InternalError(_context2.t1.message);\n descriptor.error = true;\n\n case 16:\n _context2.prev = 16;\n\n if (!(typeof descriptor.meta === 'function')) {\n _context2.next = 23;\n break;\n }\n\n _context2.next = 20;\n return descriptor.meta.apply(descriptor, _toConsumableArray(args));\n\n case 20:\n _context2.t2 = _context2.sent;\n _context2.next = 24;\n break;\n\n case 23:\n _context2.t2 = descriptor.meta;\n\n case 24:\n descriptor.meta = _context2.t2;\n _context2.next = 32;\n break;\n\n case 27:\n _context2.prev = 27;\n _context2.t3 = _context2[\"catch\"](16);\n delete descriptor.meta;\n descriptor.payload = new InternalError(_context2.t3.message);\n descriptor.error = true;\n\n case 32:\n return _context2.abrupt(\"return\", descriptor);\n\n case 33:\n case \"end\":\n return _context2.stop();\n }\n }\n }, _callee2, null, [[1, 12], [16, 27]]);\n }));\n return _actionWith.apply(this, arguments);\n }\n\n function createAction(clientCall) {\n return _defineProperty({}, RSAA, clientCall);\n }\n\n var shared = _shared('keys');\n\n var _sharedKey = function (key) {\n return shared[key] || (shared[key] = _uid(key));\n };\n\n var arrayIndexOf = _arrayIncludes(false);\n var IE_PROTO = _sharedKey('IE_PROTO');\n\n var _objectKeysInternal = function (object, names) {\n var O = _toIobject(object);\n var i = 0;\n var result = [];\n var key;\n for (key in O) if (key != IE_PROTO) _has(O, key) && result.push(key);\n // Don't enum bug & hidden keys\n while (names.length > i) if (_has(O, key = names[i++])) {\n ~arrayIndexOf(result, key) || result.push(key);\n }\n return result;\n };\n\n // IE 8- don't enum bug keys\n var _enumBugKeys = (\n 'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'\n ).split(',');\n\n // 19.1.2.14 / 15.2.3.14 Object.keys(O)\n\n\n\n var _objectKeys = Object.keys || function keys(O) {\n return _objectKeysInternal(O, _enumBugKeys);\n };\n\n var f$2 = Object.getOwnPropertySymbols;\n\n var _objectGops = {\n \tf: f$2\n };\n\n var f$3 = {}.propertyIsEnumerable;\n\n var _objectPie = {\n \tf: f$3\n };\n\n // 7.1.13 ToObject(argument)\n\n var _toObject = function (it) {\n return Object(_defined(it));\n };\n\n // 19.1.2.1 Object.assign(target, source, ...)\n\n\n\n\n\n var $assign = Object.assign;\n\n // should work with symbols and should have deterministic property order (V8 bug)\n var _objectAssign = !$assign || _fails(function () {\n var A = {};\n var B = {};\n // eslint-disable-next-line no-undef\n var S = Symbol();\n var K = 'abcdefghijklmnopqrst';\n A[S] = 7;\n K.split('').forEach(function (k) { B[k] = k; });\n return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K;\n }) ? function assign(target, source) { // eslint-disable-line no-unused-vars\n var T = _toObject(target);\n var aLen = arguments.length;\n var index = 1;\n var getSymbols = _objectGops.f;\n var isEnum = _objectPie.f;\n while (aLen > index) {\n var S = _iobject(arguments[index++]);\n var keys = getSymbols ? _objectKeys(S).concat(getSymbols(S)) : _objectKeys(S);\n var length = keys.length;\n var j = 0;\n var key;\n while (length > j) if (isEnum.call(S, key = keys[j++])) T[key] = S[key];\n } return T;\n } : $assign;\n\n // 19.1.3.1 Object.assign(target, source)\n\n\n _export(_export.S + _export.F, 'Object', { assign: _objectAssign });\n\n /**\n * Default options for redux-api-middleware\n * These can be customized by passing options into `createMiddleware`\n * @type {Object}\n */\n\n var defaults = {\n ok: function ok(res) {\n return res.ok;\n }\n };\n /**\n * A middleware creator used to create a ReduxApiMiddleware\n * with custom defaults\n *\n * @type {function}\n * @returns {ReduxMiddleware}\n * @access public\n */\n\n function createMiddleware() {\n var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n var middlewareOptions = Object.assign({}, defaults, options);\n return function (_ref) {\n var getState = _ref.getState;\n return function (next) {\n return function (action) {\n // Do not process actions without an [RSAA] property\n if (!isRSAA(action)) {\n return next(action);\n }\n\n return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {\n var validationErrors, _callAPI, _requestType, callAPI, endpoint, body, headers, _callAPI$options, options, _callAPI$fetch, doFetch, _callAPI$ok, ok, method, credentials, bailout, types, _normalizeTypeDescrip, _normalizeTypeDescrip2, requestType, successType, failureType, res, isOk;\n\n return regeneratorRuntime.wrap(function _callee$(_context) {\n while (1) {\n switch (_context.prev = _context.next) {\n case 0:\n // Try to dispatch an error request FSA for invalid RSAAs\n validationErrors = validateRSAA(action);\n\n if (!validationErrors.length) {\n _context.next = 5;\n break;\n }\n\n _callAPI = action[RSAA];\n\n if (_callAPI.types && Array.isArray(_callAPI.types)) {\n _requestType = _callAPI.types[0];\n\n if (_requestType && _requestType.type) {\n _requestType = _requestType.type;\n }\n\n next({\n type: _requestType,\n payload: new InvalidRSAA(validationErrors),\n error: true\n });\n }\n\n return _context.abrupt(\"return\");\n\n case 5:\n // Parse the validated RSAA action\n callAPI = action[RSAA];\n endpoint = callAPI.endpoint, body = callAPI.body, headers = callAPI.headers, _callAPI$options = callAPI.options, options = _callAPI$options === void 0 ? {} : _callAPI$options, _callAPI$fetch = callAPI.fetch, doFetch = _callAPI$fetch === void 0 ? middlewareOptions.fetch || fetch : _callAPI$fetch, _callAPI$ok = callAPI.ok, ok = _callAPI$ok === void 0 ? middlewareOptions.ok : _callAPI$ok;\n method = callAPI.method, credentials = callAPI.credentials, bailout = callAPI.bailout, types = callAPI.types;\n _normalizeTypeDescrip = normalizeTypeDescriptors(types), _normalizeTypeDescrip2 = _slicedToArray(_normalizeTypeDescrip, 3), requestType = _normalizeTypeDescrip2[0], successType = _normalizeTypeDescrip2[1], failureType = _normalizeTypeDescrip2[2]; // Should we bail out?\n\n _context.prev = 9;\n\n if (!(typeof bailout === 'boolean' && bailout || typeof bailout === 'function' && bailout(getState()))) {\n _context.next = 12;\n break;\n }\n\n return _context.abrupt(\"return\");\n\n case 12:\n _context.next = 21;\n break;\n\n case 14:\n _context.prev = 14;\n _context.t0 = _context[\"catch\"](9);\n _context.t1 = next;\n _context.next = 19;\n return actionWith(_objectSpread2({}, failureType, {\n payload: new RequestError('[RSAA].bailout function failed'),\n error: true\n }), [action, getState()]);\n\n case 19:\n _context.t2 = _context.sent;\n return _context.abrupt(\"return\", (0, _context.t1)(_context.t2));\n\n case 21:\n if (!(typeof endpoint === 'function')) {\n _context.next = 35;\n break;\n }\n\n _context.prev = 22;\n _context.next = 25;\n return endpoint(getState());\n\n case 25:\n endpoint = _context.sent;\n _context.next = 35;\n break;\n\n case 28:\n _context.prev = 28;\n _context.t3 = _context[\"catch\"](22);\n _context.t4 = next;\n _context.next = 33;\n return actionWith(_objectSpread2({}, failureType, {\n payload: new RequestError('[RSAA].endpoint function failed'),\n error: true\n }), [action, getState()]);\n\n case 33:\n _context.t5 = _context.sent;\n return _context.abrupt(\"return\", (0, _context.t4)(_context.t5));\n\n case 35:\n if (!(typeof body === 'function')) {\n _context.next = 49;\n break;\n }\n\n _context.prev = 36;\n _context.next = 39;\n return body(getState());\n\n case 39:\n body = _context.sent;\n _context.next = 49;\n break;\n\n case 42:\n _context.prev = 42;\n _context.t6 = _context[\"catch\"](36);\n _context.t7 = next;\n _context.next = 47;\n return actionWith(_objectSpread2({}, failureType, {\n payload: new RequestError('[RSAA].body function failed'),\n error: true\n }), [action, getState()]);\n\n case 47:\n _context.t8 = _context.sent;\n return _context.abrupt(\"return\", (0, _context.t7)(_context.t8));\n\n case 49:\n if (!(typeof headers === 'function')) {\n _context.next = 63;\n break;\n }\n\n _context.prev = 50;\n _context.next = 53;\n return headers(getState());\n\n case 53:\n headers = _context.sent;\n _context.next = 63;\n break;\n\n case 56:\n _context.prev = 56;\n _context.t9 = _context[\"catch\"](50);\n _context.t10 = next;\n _context.next = 61;\n return actionWith(_objectSpread2({}, failureType, {\n payload: new RequestError('[RSAA].headers function failed'),\n error: true\n }), [action, getState()]);\n\n case 61:\n _context.t11 = _context.sent;\n return _context.abrupt(\"return\", (0, _context.t10)(_context.t11));\n\n case 63:\n if (!(typeof options === 'function')) {\n _context.next = 77;\n break;\n }\n\n _context.prev = 64;\n _context.next = 67;\n return options(getState());\n\n case 67:\n options = _context.sent;\n _context.next = 77;\n break;\n\n case 70:\n _context.prev = 70;\n _context.t12 = _context[\"catch\"](64);\n _context.t13 = next;\n _context.next = 75;\n return actionWith(_objectSpread2({}, failureType, {\n payload: new RequestError('[RSAA].options function failed'),\n error: true\n }), [action, getState()]);\n\n case 75:\n _context.t14 = _context.sent;\n return _context.abrupt(\"return\", (0, _context.t13)(_context.t14));\n\n case 77:\n if (!(typeof requestType.payload === 'function' || typeof requestType.meta === 'function')) {\n _context.next = 85;\n break;\n }\n\n _context.t15 = next;\n _context.next = 81;\n return actionWith(requestType, [action, getState()]);\n\n case 81:\n _context.t16 = _context.sent;\n (0, _context.t15)(_context.t16);\n _context.next = 86;\n break;\n\n case 85:\n next(requestType);\n\n case 86:\n _context.prev = 86;\n _context.next = 89;\n return doFetch(endpoint, _objectSpread2({}, options, {\n method: method,\n body: body || undefined,\n credentials: credentials,\n headers: headers || {}\n }));\n\n case 89:\n res = _context.sent;\n _context.next = 99;\n break;\n\n case 92:\n _context.prev = 92;\n _context.t17 = _context[\"catch\"](86);\n _context.t18 = next;\n _context.next = 97;\n return actionWith(_objectSpread2({}, failureType, {\n payload: new RequestError(_context.t17.message),\n error: true\n }), [action, getState()]);\n\n case 97:\n _context.t19 = _context.sent;\n return _context.abrupt(\"return\", (0, _context.t18)(_context.t19));\n\n case 99:\n _context.prev = 99;\n isOk = ok(res);\n _context.next = 110;\n break;\n\n case 103:\n _context.prev = 103;\n _context.t20 = _context[\"catch\"](99);\n _context.t21 = next;\n _context.next = 108;\n return actionWith(_objectSpread2({}, failureType, {\n payload: new InternalError('[RSAA].ok function failed'),\n error: true\n }), [action, getState(), res]);\n\n case 108:\n _context.t22 = _context.sent;\n return _context.abrupt(\"return\", (0, _context.t21)(_context.t22));\n\n case 110:\n if (!isOk) {\n _context.next = 118;\n break;\n }\n\n _context.t23 = next;\n _context.next = 114;\n return actionWith(successType, [action, getState(), res]);\n\n case 114:\n _context.t24 = _context.sent;\n return _context.abrupt(\"return\", (0, _context.t23)(_context.t24));\n\n case 118:\n _context.t25 = next;\n _context.next = 121;\n return actionWith(_objectSpread2({}, failureType, {\n error: true\n }), [action, getState(), res]);\n\n case 121:\n _context.t26 = _context.sent;\n return _context.abrupt(\"return\", (0, _context.t25)(_context.t26));\n\n case 123:\n case \"end\":\n return _context.stop();\n }\n }\n }, _callee, null, [[9, 14], [22, 28], [36, 42], [50, 56], [64, 70], [86, 92], [99, 103]]);\n }))();\n };\n };\n };\n }\n /**\n * A Redux middleware that processes RSAA actions.\n *\n * @type {ReduxMiddleware}\n * @access public\n * @deprecated since v3.2.0 use `createMiddleware`\n */\n\n\n function apiMiddleware(_ref3) {\n var getState = _ref3.getState;\n return createMiddleware()({\n getState: getState\n });\n }\n\n exports.ApiError = ApiError;\n exports.InternalError = InternalError;\n exports.InvalidRSAA = InvalidRSAA;\n exports.RSAA = RSAA;\n exports.RequestError = RequestError;\n exports.apiMiddleware = apiMiddleware;\n exports.createAction = createAction;\n exports.createMiddleware = createMiddleware;\n exports.getJSON = getJSON;\n exports.isRSAA = isRSAA;\n exports.isValidRSAA = isValidRSAA;\n exports.validateRSAA = validateRSAA;\n\n Object.defineProperty(exports, '__esModule', { value: true });\n\n})));\n"],"sourceRoot":""}