diff --git a/dist/README.md b/dist/README.md index b2ec8c3..968e877 100644 --- a/dist/README.md +++ b/dist/README.md @@ -13,8 +13,9 @@ as a row in the data frame, otherwise the result object will be the only row. format that can be parsed by `moment()` (e.g. ISO8601). * Nested types will be flattened into dot-delimited fields. * Grafana variables should be substituted directly in the query (instead of -using GraphQL variables). The dashboard time ranges are available in `$timeFrom` -and `$timeTo` variables as millisecond epoch. +using GraphQL variables). The dashboard time ranges are available in the +[global variables](https://grafana.com/docs/grafana/latest/variables/global-variables/) +`$__from` and `$__to` as millisecond epoch. * Group by can be used to group elements into multiple data points. * Alias by is used to alter the name of the field displayed in the legend. `$field_` is substituted with the values of the field and `$fieldName` is substituted with the name of the field. @@ -29,7 +30,7 @@ examples and tutorials. ```graphql query { - submissions(user:"$user", from:"$timeFrom", to:"$timeTo"){ + submissions(user:"$user", from:"$__from", to:"$__to"){ Time:submitTime idle running completed } @@ -37,14 +38,14 @@ query { ``` * Data path: `submissions` -Note the use of the special `$timeFrom` and `$timeTo` variables to insert the +Note the use of the global `$__from` and `$__to` variables to insert the dashboard time range into the query, alongside a dashboard variable `$user`. ## Alias and group by ```graphql query { - data:queryAll(from:"$timeFrom", to:"$timeTo", sourceId:"default") { + data:queryAll(from:"$__from", to:"$__to", sourceId:"default") { batteryVoltage { Time:dateMillis packet { @@ -74,7 +75,7 @@ querying multiple numeric fields that you want displayed in your graph. ```graphql query { - server1:queryEvents(from: "$timeFrom", to:"$timeTo", server:"server1") { + server1:queryEvents(from: "$__from", to:"$__to", server:"server1") { birthdayEvent { Time:dateMillis person { @@ -82,7 +83,7 @@ query { } } } - server2:queryEvents(from: "$timeFrom", to:"$timeTo", server:"server2") { + server2:queryEvents(from: "$__from", to:"$__to", server:"server2") { birthdayEvent { Time:dateMillis person { diff --git a/dist/module.js b/dist/module.js index 96dd04a..9f85d79 100644 --- a/dist/module.js +++ b/dist/module.js @@ -2892,8 +2892,9 @@ function flatten(object, path, separator) { return Object.keys(object).reduce(function (acc, key) { var _a; + var isObject = _typeof(object[key]) === 'object' && object[key] != null; var newPath = [path, key].filter(Boolean).join(separator); - return _typeof(object[key]) === 'object' ? Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__assign"])(Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__assign"])({}, acc), flatten(object[key], newPath, separator)) : Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__assign"])(Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__assign"])({}, acc), (_a = {}, _a[newPath] = object[key], _a)); + return isObject ? Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__assign"])(Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__assign"])({}, acc), flatten(object[key], newPath, separator)) : Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__assign"])(Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__assign"])({}, acc), (_a = {}, _a[newPath] = object[key], _a)); }, {}); } diff --git a/dist/module.js.map b/dist/module.js.map index 212546a..09061cc 100644 --- a/dist/module.js.map +++ b/dist/module.js.map @@ -1 +1 @@ -{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///../node_modules/lodash/_Symbol.js","webpack:///../node_modules/lodash/_apply.js","webpack:///../node_modules/lodash/_arrayLikeKeys.js","webpack:///../node_modules/lodash/_baseGetTag.js","webpack:///../node_modules/lodash/_baseIsArguments.js","webpack:///../node_modules/lodash/_baseIsNative.js","webpack:///../node_modules/lodash/_baseIsTypedArray.js","webpack:///../node_modules/lodash/_baseKeysIn.js","webpack:///../node_modules/lodash/_baseRest.js","webpack:///../node_modules/lodash/_baseSetToString.js","webpack:///../node_modules/lodash/_baseTimes.js","webpack:///../node_modules/lodash/_baseUnary.js","webpack:///../node_modules/lodash/_coreJsData.js","webpack:///../node_modules/lodash/_defineProperty.js","webpack:///../node_modules/lodash/_freeGlobal.js","webpack:///../node_modules/lodash/_getNative.js","webpack:///../node_modules/lodash/_getRawTag.js","webpack:///../node_modules/lodash/_getValue.js","webpack:///../node_modules/lodash/_isIndex.js","webpack:///../node_modules/lodash/_isIterateeCall.js","webpack:///../node_modules/lodash/_isMasked.js","webpack:///../node_modules/lodash/_isPrototype.js","webpack:///../node_modules/lodash/_nativeKeysIn.js","webpack:///../node_modules/lodash/_nodeUtil.js","webpack:///../node_modules/lodash/_objectToString.js","webpack:///../node_modules/lodash/_overRest.js","webpack:///../node_modules/lodash/_root.js","webpack:///../node_modules/lodash/_setToString.js","webpack:///../node_modules/lodash/_shortOut.js","webpack:///../node_modules/lodash/_toSource.js","webpack:///../node_modules/lodash/constant.js","webpack:///../node_modules/lodash/defaults.js","webpack:///../node_modules/lodash/eq.js","webpack:///../node_modules/lodash/identity.js","webpack:///../node_modules/lodash/isArguments.js","webpack:///../node_modules/lodash/isArray.js","webpack:///../node_modules/lodash/isArrayLike.js","webpack:///../node_modules/lodash/isBuffer.js","webpack:///../node_modules/lodash/isFunction.js","webpack:///../node_modules/lodash/isLength.js","webpack:///../node_modules/lodash/isObject.js","webpack:///../node_modules/lodash/isObjectLike.js","webpack:///../node_modules/lodash/isTypedArray.js","webpack:///../node_modules/lodash/keysIn.js","webpack:///../node_modules/lodash/stubFalse.js","webpack:///../node_modules/tslib/tslib.es6.js","webpack:///../node_modules/webpack/buildin/global.js","webpack:///../node_modules/webpack/buildin/module.js","webpack:///./ConfigEditor.tsx","webpack:///./DataSource.ts","webpack:///./GraphQLAnnotationsQueryCtrl.tsx","webpack:///./QueryEditor.tsx","webpack:///./module.ts","webpack:///./types.ts","webpack:///./util.ts","webpack:///external \"@grafana/data\"","webpack:///external \"@grafana/ui\"","webpack:///external \"lodash\"","webpack:///external \"react\""],"names":[],"mappings":";QAAA;QACA;;QAEA;QACA;;QAEA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;;QAEA;QACA;;QAEA;QACA;;QAEA;QACA;QACA;;;QAGA;QACA;;QAEA;QACA;;QAEA;QACA;QACA;QACA,0CAA0C,gCAAgC;QAC1E;QACA;;QAEA;QACA;QACA;QACA,wDAAwD,kBAAkB;QAC1E;QACA,iDAAiD,cAAc;QAC/D;;QAEA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA,yCAAyC,iCAAiC;QAC1E,gHAAgH,mBAAmB,EAAE;QACrI;QACA;;QAEA;QACA;QACA;QACA,2BAA2B,0BAA0B,EAAE;QACvD,iCAAiC,eAAe;QAChD;QACA;QACA;;QAEA;QACA,sDAAsD,+DAA+D;;QAErH;QACA;;;QAGA;QACA;;;;;;;;;;;;AClFA,WAAW,mBAAO,CAAC,gDAAS;;AAE5B;AACA;;AAEA;;;;;;;;;;;;ACLA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,EAAE;AACb,WAAW,MAAM;AACjB,aAAa,EAAE;AACf;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;ACpBA,gBAAgB,mBAAO,CAAC,0DAAc;AACtC,kBAAkB,mBAAO,CAAC,4DAAe;AACzC,cAAc,mBAAO,CAAC,oDAAW;AACjC,eAAe,mBAAO,CAAC,sDAAY;AACnC,cAAc,mBAAO,CAAC,sDAAY;AAClC,mBAAmB,mBAAO,CAAC,8DAAgB;;AAE3C;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,WAAW,QAAQ;AACnB,aAAa,MAAM;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;AChDA,aAAa,mBAAO,CAAC,oDAAW;AAChC,gBAAgB,mBAAO,CAAC,0DAAc;AACtC,qBAAqB,mBAAO,CAAC,oEAAmB;;AAEhD;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;AC3BA,iBAAiB,mBAAO,CAAC,4DAAe;AACxC,mBAAmB,mBAAO,CAAC,8DAAgB;;AAE3C;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;ACjBA,iBAAiB,mBAAO,CAAC,0DAAc;AACvC,eAAe,mBAAO,CAAC,wDAAa;AACpC,eAAe,mBAAO,CAAC,sDAAY;AACnC,eAAe,mBAAO,CAAC,wDAAa;;AAEpC;AACA;AACA;AACA;AACA,oCAAoC;;AAEpC;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;AC9CA,iBAAiB,mBAAO,CAAC,4DAAe;AACxC,eAAe,mBAAO,CAAC,sDAAY;AACnC,mBAAmB,mBAAO,CAAC,8DAAgB;;AAE3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;AC3DA,eAAe,mBAAO,CAAC,sDAAY;AACnC,kBAAkB,mBAAO,CAAC,8DAAgB;AAC1C,mBAAmB,mBAAO,CAAC,gEAAiB;;AAE5C;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;AChCA,eAAe,mBAAO,CAAC,sDAAY;AACnC,eAAe,mBAAO,CAAC,wDAAa;AACpC,kBAAkB,mBAAO,CAAC,8DAAgB;;AAE1C;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,OAAO;AAClB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;AChBA,eAAe,mBAAO,CAAC,sDAAY;AACnC,qBAAqB,mBAAO,CAAC,oEAAmB;AAChD,eAAe,mBAAO,CAAC,sDAAY;;AAEnC;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;;;;;;;;;;;;ACrBA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,SAAS;AACpB,aAAa,MAAM;AACnB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;ACnBA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;ACbA,WAAW,mBAAO,CAAC,gDAAS;;AAE5B;AACA;;AAEA;;;;;;;;;;;;ACLA,gBAAgB,mBAAO,CAAC,0DAAc;;AAEtC;AACA;AACA;AACA,WAAW,QAAQ;AACnB;AACA,GAAG;AACH,CAAC;;AAED;;;;;;;;;;;;ACVA;AACA;;AAEA;;;;;;;;;;;;;ACHA,mBAAmB,mBAAO,CAAC,gEAAiB;AAC5C,eAAe,mBAAO,CAAC,wDAAa;;AAEpC;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,EAAE;AACf;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;AChBA,aAAa,mBAAO,CAAC,oDAAW;;AAEhC;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;AC7CA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,EAAE;AACf;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;ACZA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,WAAW,OAAO;AAClB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;ACxBA,SAAS,mBAAO,CAAC,0CAAM;AACvB,kBAAkB,mBAAO,CAAC,4DAAe;AACzC,cAAc,mBAAO,CAAC,sDAAY;AAClC,eAAe,mBAAO,CAAC,sDAAY;;AAEnC;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,WAAW,EAAE;AACb,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;AC7BA,iBAAiB,mBAAO,CAAC,4DAAe;;AAExC;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;ACnBA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;;;;;;;;;;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;ACnBA,+DAAiB,mBAAO,CAAC,4DAAe;;AAExC;AACA,kBAAkB,KAA0B;;AAE5C;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,GAAG;AACH,CAAC;;AAED;;;;;;;;;;;;;AC7BA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;ACrBA,YAAY,mBAAO,CAAC,kDAAU;;AAE9B;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,OAAO;AAClB,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;ACnCA,iBAAiB,mBAAO,CAAC,4DAAe;;AAExC;AACA;;AAEA;AACA;;AAEA;;;;;;;;;;;;ACRA,sBAAsB,mBAAO,CAAC,sEAAoB;AAClD,eAAe,mBAAO,CAAC,wDAAa;;AAEpC;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;;AAEA;;;;;;;;;;;;ACbA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;ACpCA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,SAAS;AACpB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;;;;;;;;;;;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,SAAS;AACtB;AACA;AACA,wCAAwC,SAAS;AACjD;AACA;AACA,WAAW,SAAS,GAAG,SAAS;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;ACzBA,eAAe,mBAAO,CAAC,wDAAa;AACpC,SAAS,mBAAO,CAAC,0CAAM;AACvB,qBAAqB,mBAAO,CAAC,oEAAmB;AAChD,aAAa,mBAAO,CAAC,kDAAU;;AAE/B;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,UAAU;AACrB,aAAa,OAAO;AACpB;AACA;AACA;AACA,eAAe,SAAS,GAAG,SAAS,GAAG,SAAS;AAChD,UAAU;AACV;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,CAAC;;AAED;;;;;;;;;;;;AC/DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA,iBAAiB;AACjB,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,EAAE;AACf;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;ACpBA,sBAAsB,mBAAO,CAAC,sEAAoB;AAClD,mBAAmB,mBAAO,CAAC,8DAAgB;;AAE3C;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA,6BAA6B,kBAAkB,EAAE;AACjD;AACA;AACA;AACA;AACA;AACA,8CAA8C,kBAAkB,EAAE;AAClE;AACA;AACA;;AAEA;;;;;;;;;;;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;ACzBA,iBAAiB,mBAAO,CAAC,0DAAc;AACvC,eAAe,mBAAO,CAAC,sDAAY;;AAEnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;AChCA,yDAAW,mBAAO,CAAC,gDAAS;AAC5B,gBAAgB,mBAAO,CAAC,wDAAa;;AAErC;AACA,kBAAkB,KAA0B;;AAE5C;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;;ACrCA,iBAAiB,mBAAO,CAAC,4DAAe;AACxC,eAAe,mBAAO,CAAC,sDAAY;;AAEnC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;ACpCA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA,oBAAoB;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;AC5BA,uBAAuB,mBAAO,CAAC,wEAAqB;AACpD,gBAAgB,mBAAO,CAAC,0DAAc;AACtC,eAAe,mBAAO,CAAC,wDAAa;;AAEpC;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,EAAE;AACb,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;AC1BA,oBAAoB,mBAAO,CAAC,kEAAkB;AAC9C,iBAAiB,mBAAO,CAAC,4DAAe;AACxC,kBAAkB,mBAAO,CAAC,4DAAe;;AAEzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;;ACjBA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA;AACA,+DAA+D;AAC/D;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,UAAU,gBAAgB,sCAAsC,iBAAiB,EAAE;AACnF,yBAAyB,uDAAuD;AAChF;AACA;;AAEO;AACP;AACA,mBAAmB,sBAAsB;AACzC;AACA;;AAEO;AACP;AACA,gDAAgD,OAAO;AACvD;AACA;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","file":"module.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = \"./module.ts\");\n","var root = require('./_root');\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nmodule.exports = Symbol;\n","/**\n * A faster alternative to `Function#apply`, this function invokes `func`\n * with the `this` binding of `thisArg` and the arguments of `args`.\n *\n * @private\n * @param {Function} func The function to invoke.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} args The arguments to invoke `func` with.\n * @returns {*} Returns the result of `func`.\n */\nfunction apply(func, thisArg, args) {\n switch (args.length) {\n case 0: return func.call(thisArg);\n case 1: return func.call(thisArg, args[0]);\n case 2: return func.call(thisArg, args[0], args[1]);\n case 3: return func.call(thisArg, args[0], args[1], args[2]);\n }\n return func.apply(thisArg, args);\n}\n\nmodule.exports = apply;\n","var baseTimes = require('./_baseTimes'),\n isArguments = require('./isArguments'),\n isArray = require('./isArray'),\n isBuffer = require('./isBuffer'),\n isIndex = require('./_isIndex'),\n isTypedArray = require('./isTypedArray');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n var isArr = isArray(value),\n isArg = !isArr && isArguments(value),\n isBuff = !isArr && !isArg && isBuffer(value),\n isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n skipIndexes = isArr || isArg || isBuff || isType,\n result = skipIndexes ? baseTimes(value.length, String) : [],\n length = result.length;\n\n for (var key in value) {\n if ((inherited || hasOwnProperty.call(value, key)) &&\n !(skipIndexes && (\n // Safari 9 has enumerable `arguments.length` in strict mode.\n key == 'length' ||\n // Node.js 0.10 has enumerable non-index properties on buffers.\n (isBuff && (key == 'offset' || key == 'parent')) ||\n // PhantomJS 2 has enumerable non-index properties on typed arrays.\n (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n // Skip index properties.\n isIndex(key, length)\n ))) {\n result.push(key);\n }\n }\n return result;\n}\n\nmodule.exports = arrayLikeKeys;\n","var Symbol = require('./_Symbol'),\n getRawTag = require('./_getRawTag'),\n objectToString = require('./_objectToString');\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n if (value == null) {\n return value === undefined ? undefinedTag : nullTag;\n }\n return (symToStringTag && symToStringTag in Object(value))\n ? getRawTag(value)\n : objectToString(value);\n}\n\nmodule.exports = baseGetTag;\n","var baseGetTag = require('./_baseGetTag'),\n isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]';\n\n/**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\nfunction baseIsArguments(value) {\n return isObjectLike(value) && baseGetTag(value) == argsTag;\n}\n\nmodule.exports = baseIsArguments;\n","var isFunction = require('./isFunction'),\n isMasked = require('./_isMasked'),\n isObject = require('./isObject'),\n toSource = require('./_toSource');\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n * else `false`.\n */\nfunction baseIsNative(value) {\n if (!isObject(value) || isMasked(value)) {\n return false;\n }\n var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n return pattern.test(toSource(value));\n}\n\nmodule.exports = baseIsNative;\n","var baseGetTag = require('./_baseGetTag'),\n isLength = require('./isLength'),\n isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n arrayTag = '[object Array]',\n boolTag = '[object Boolean]',\n dateTag = '[object Date]',\n errorTag = '[object Error]',\n funcTag = '[object Function]',\n mapTag = '[object Map]',\n numberTag = '[object Number]',\n objectTag = '[object Object]',\n regexpTag = '[object RegExp]',\n setTag = '[object Set]',\n stringTag = '[object String]',\n weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n dataViewTag = '[object DataView]',\n float32Tag = '[object Float32Array]',\n float64Tag = '[object Float64Array]',\n int8Tag = '[object Int8Array]',\n int16Tag = '[object Int16Array]',\n int32Tag = '[object Int32Array]',\n uint8Tag = '[object Uint8Array]',\n uint8ClampedTag = '[object Uint8ClampedArray]',\n uint16Tag = '[object Uint16Array]',\n uint32Tag = '[object Uint32Array]';\n\n/** Used to identify `toStringTag` values of typed arrays. */\nvar typedArrayTags = {};\ntypedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\ntypedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\ntypedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\ntypedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\ntypedArrayTags[uint32Tag] = true;\ntypedArrayTags[argsTag] = typedArrayTags[arrayTag] =\ntypedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\ntypedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\ntypedArrayTags[errorTag] = typedArrayTags[funcTag] =\ntypedArrayTags[mapTag] = typedArrayTags[numberTag] =\ntypedArrayTags[objectTag] = typedArrayTags[regexpTag] =\ntypedArrayTags[setTag] = typedArrayTags[stringTag] =\ntypedArrayTags[weakMapTag] = false;\n\n/**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\nfunction baseIsTypedArray(value) {\n return isObjectLike(value) &&\n isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n}\n\nmodule.exports = baseIsTypedArray;\n","var isObject = require('./isObject'),\n isPrototype = require('./_isPrototype'),\n nativeKeysIn = require('./_nativeKeysIn');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeysIn(object) {\n if (!isObject(object)) {\n return nativeKeysIn(object);\n }\n var isProto = isPrototype(object),\n result = [];\n\n for (var key in object) {\n if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n result.push(key);\n }\n }\n return result;\n}\n\nmodule.exports = baseKeysIn;\n","var identity = require('./identity'),\n overRest = require('./_overRest'),\n setToString = require('./_setToString');\n\n/**\n * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n */\nfunction baseRest(func, start) {\n return setToString(overRest(func, start, identity), func + '');\n}\n\nmodule.exports = baseRest;\n","var constant = require('./constant'),\n defineProperty = require('./_defineProperty'),\n identity = require('./identity');\n\n/**\n * The base implementation of `setToString` without support for hot loop shorting.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar baseSetToString = !defineProperty ? identity : function(func, string) {\n return defineProperty(func, 'toString', {\n 'configurable': true,\n 'enumerable': false,\n 'value': constant(string),\n 'writable': true\n });\n};\n\nmodule.exports = baseSetToString;\n","/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n var index = -1,\n result = Array(n);\n\n while (++index < n) {\n result[index] = iteratee(index);\n }\n return result;\n}\n\nmodule.exports = baseTimes;\n","/**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\nfunction baseUnary(func) {\n return function(value) {\n return func(value);\n };\n}\n\nmodule.exports = baseUnary;\n","var root = require('./_root');\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\nmodule.exports = coreJsData;\n","var getNative = require('./_getNative');\n\nvar defineProperty = (function() {\n try {\n var func = getNative(Object, 'defineProperty');\n func({}, '', {});\n return func;\n } catch (e) {}\n}());\n\nmodule.exports = defineProperty;\n","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nmodule.exports = freeGlobal;\n","var baseIsNative = require('./_baseIsNative'),\n getValue = require('./_getValue');\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n var value = getValue(object, key);\n return baseIsNative(value) ? value : undefined;\n}\n\nmodule.exports = getNative;\n","var Symbol = require('./_Symbol');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n var isOwn = hasOwnProperty.call(value, symToStringTag),\n tag = value[symToStringTag];\n\n try {\n value[symToStringTag] = undefined;\n var unmasked = true;\n } catch (e) {}\n\n var result = nativeObjectToString.call(value);\n if (unmasked) {\n if (isOwn) {\n value[symToStringTag] = tag;\n } else {\n delete value[symToStringTag];\n }\n }\n return result;\n}\n\nmodule.exports = getRawTag;\n","/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n return object == null ? undefined : object[key];\n}\n\nmodule.exports = getValue;\n","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n var type = typeof value;\n length = length == null ? MAX_SAFE_INTEGER : length;\n\n return !!length &&\n (type == 'number' ||\n (type != 'symbol' && reIsUint.test(value))) &&\n (value > -1 && value % 1 == 0 && value < length);\n}\n\nmodule.exports = isIndex;\n","var eq = require('./eq'),\n isArrayLike = require('./isArrayLike'),\n isIndex = require('./_isIndex'),\n isObject = require('./isObject');\n\n/**\n * Checks if the given arguments are from an iteratee call.\n *\n * @private\n * @param {*} value The potential iteratee value argument.\n * @param {*} index The potential iteratee index or key argument.\n * @param {*} object The potential iteratee object argument.\n * @returns {boolean} Returns `true` if the arguments are from an iteratee call,\n * else `false`.\n */\nfunction isIterateeCall(value, index, object) {\n if (!isObject(object)) {\n return false;\n }\n var type = typeof index;\n if (type == 'number'\n ? (isArrayLike(object) && isIndex(index, object.length))\n : (type == 'string' && index in object)\n ) {\n return eq(object[index], value);\n }\n return false;\n}\n\nmodule.exports = isIterateeCall;\n","var coreJsData = require('./_coreJsData');\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n return !!maskSrcKey && (maskSrcKey in func);\n}\n\nmodule.exports = isMasked;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n var Ctor = value && value.constructor,\n proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n return value === proto;\n}\n\nmodule.exports = isPrototype;\n","/**\n * This function is like\n * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * except that it includes inherited enumerable properties.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction nativeKeysIn(object) {\n var result = [];\n if (object != null) {\n for (var key in Object(object)) {\n result.push(key);\n }\n }\n return result;\n}\n\nmodule.exports = nativeKeysIn;\n","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Detect free variable `process` from Node.js. */\nvar freeProcess = moduleExports && freeGlobal.process;\n\n/** Used to access faster Node.js helpers. */\nvar nodeUtil = (function() {\n try {\n // Use `util.types` for Node.js 10+.\n var types = freeModule && freeModule.require && freeModule.require('util').types;\n\n if (types) {\n return types;\n }\n\n // Legacy `process.binding('util')` for Node.js < 10.\n return freeProcess && freeProcess.binding && freeProcess.binding('util');\n } catch (e) {}\n}());\n\nmodule.exports = nodeUtil;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n return nativeObjectToString.call(value);\n}\n\nmodule.exports = objectToString;\n","var apply = require('./_apply');\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max;\n\n/**\n * A specialized version of `baseRest` which transforms the rest array.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @param {Function} transform The rest array transform.\n * @returns {Function} Returns the new function.\n */\nfunction overRest(func, start, transform) {\n start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n return function() {\n var args = arguments,\n index = -1,\n length = nativeMax(args.length - start, 0),\n array = Array(length);\n\n while (++index < length) {\n array[index] = args[start + index];\n }\n index = -1;\n var otherArgs = Array(start + 1);\n while (++index < start) {\n otherArgs[index] = args[index];\n }\n otherArgs[start] = transform(array);\n return apply(func, this, otherArgs);\n };\n}\n\nmodule.exports = overRest;\n","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nmodule.exports = root;\n","var baseSetToString = require('./_baseSetToString'),\n shortOut = require('./_shortOut');\n\n/**\n * Sets the `toString` method of `func` to return `string`.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar setToString = shortOut(baseSetToString);\n\nmodule.exports = setToString;\n","/** Used to detect hot functions by number of calls within a span of milliseconds. */\nvar HOT_COUNT = 800,\n HOT_SPAN = 16;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeNow = Date.now;\n\n/**\n * Creates a function that'll short out and invoke `identity` instead\n * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`\n * milliseconds.\n *\n * @private\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new shortable function.\n */\nfunction shortOut(func) {\n var count = 0,\n lastCalled = 0;\n\n return function() {\n var stamp = nativeNow(),\n remaining = HOT_SPAN - (stamp - lastCalled);\n\n lastCalled = stamp;\n if (remaining > 0) {\n if (++count >= HOT_COUNT) {\n return arguments[0];\n }\n } else {\n count = 0;\n }\n return func.apply(undefined, arguments);\n };\n}\n\nmodule.exports = shortOut;\n","/** Used for built-in method references. */\nvar funcProto = Function.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n if (func != null) {\n try {\n return funcToString.call(func);\n } catch (e) {}\n try {\n return (func + '');\n } catch (e) {}\n }\n return '';\n}\n\nmodule.exports = toSource;\n","/**\n * Creates a function that returns `value`.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {*} value The value to return from the new function.\n * @returns {Function} Returns the new constant function.\n * @example\n *\n * var objects = _.times(2, _.constant({ 'a': 1 }));\n *\n * console.log(objects);\n * // => [{ 'a': 1 }, { 'a': 1 }]\n *\n * console.log(objects[0] === objects[1]);\n * // => true\n */\nfunction constant(value) {\n return function() {\n return value;\n };\n}\n\nmodule.exports = constant;\n","var baseRest = require('./_baseRest'),\n eq = require('./eq'),\n isIterateeCall = require('./_isIterateeCall'),\n keysIn = require('./keysIn');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Assigns own and inherited enumerable string keyed properties of source\n * objects to the destination object for all destination properties that\n * resolve to `undefined`. Source objects are applied from left to right.\n * Once a property is set, additional values of the same property are ignored.\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n * @see _.defaultsDeep\n * @example\n *\n * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\n * // => { 'a': 1, 'b': 2 }\n */\nvar defaults = baseRest(function(object, sources) {\n object = Object(object);\n\n var index = -1;\n var length = sources.length;\n var guard = length > 2 ? sources[2] : undefined;\n\n if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n length = 1;\n }\n\n while (++index < length) {\n var source = sources[index];\n var props = keysIn(source);\n var propsIndex = -1;\n var propsLength = props.length;\n\n while (++propsIndex < propsLength) {\n var key = props[propsIndex];\n var value = object[key];\n\n if (value === undefined ||\n (eq(value, objectProto[key]) && !hasOwnProperty.call(object, key))) {\n object[key] = source[key];\n }\n }\n }\n\n return object;\n});\n\nmodule.exports = defaults;\n","/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n return value === other || (value !== value && other !== other);\n}\n\nmodule.exports = eq;\n","/**\n * This method returns the first argument it receives.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'a': 1 };\n *\n * console.log(_.identity(object) === object);\n * // => true\n */\nfunction identity(value) {\n return value;\n}\n\nmodule.exports = identity;\n","var baseIsArguments = require('./_baseIsArguments'),\n isObjectLike = require('./isObjectLike');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n * else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nvar isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n !propertyIsEnumerable.call(value, 'callee');\n};\n\nmodule.exports = isArguments;\n","/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\nmodule.exports = isArray;\n","var isFunction = require('./isFunction'),\n isLength = require('./isLength');\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n return value != null && isLength(value.length) && !isFunction(value);\n}\n\nmodule.exports = isArrayLike;\n","var root = require('./_root'),\n stubFalse = require('./stubFalse');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\nvar isBuffer = nativeIsBuffer || stubFalse;\n\nmodule.exports = isBuffer;\n","var baseGetTag = require('./_baseGetTag'),\n isObject = require('./isObject');\n\n/** `Object#toString` result references. */\nvar asyncTag = '[object AsyncFunction]',\n funcTag = '[object Function]',\n genTag = '[object GeneratorFunction]',\n proxyTag = '[object Proxy]';\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n if (!isObject(value)) {\n return false;\n }\n // The use of `Object#toString` avoids issues with the `typeof` operator\n // in Safari 9 which returns 'object' for typed arrays and other constructors.\n var tag = baseGetTag(value);\n return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\nmodule.exports = isFunction;\n","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n return typeof value == 'number' &&\n value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\nmodule.exports = isLength;\n","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n var type = typeof value;\n return value != null && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isObject;\n","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n return value != null && typeof value == 'object';\n}\n\nmodule.exports = isObjectLike;\n","var baseIsTypedArray = require('./_baseIsTypedArray'),\n baseUnary = require('./_baseUnary'),\n nodeUtil = require('./_nodeUtil');\n\n/* Node.js helper references. */\nvar nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n/**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\nvar isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\nmodule.exports = isTypedArray;\n","var arrayLikeKeys = require('./_arrayLikeKeys'),\n baseKeysIn = require('./_baseKeysIn'),\n isArrayLike = require('./isArrayLike');\n\n/**\n * Creates an array of the own and inherited enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keysIn(new Foo);\n * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n */\nfunction keysIn(object) {\n return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n}\n\nmodule.exports = keysIn;\n","/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\nfunction stubFalse() {\n return false;\n}\n\nmodule.exports = stubFalse;\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n extendStatics = Object.setPrototypeOf ||\r\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n extendStatics(d, b);\r\n function __() { this.constructor = d; }\r\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n __assign = Object.assign || function __assign(t) {\r\n for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n s = arguments[i];\r\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n }\r\n return t;\r\n }\r\n return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n var t = {};\r\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n t[p] = s[p];\r\n if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n t[p[i]] = s[p[i]];\r\n }\r\n return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n return new (P || (P = Promise))(function (resolve, reject) {\r\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n function verb(n) { return function (v) { return step([n, v]); }; }\r\n function step(op) {\r\n if (f) throw new TypeError(\"Generator is already executing.\");\r\n while (_) try {\r\n if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n if (y = 0, t) op = [op[0] & 2, t.value];\r\n switch (op[0]) {\r\n case 0: case 1: t = op; break;\r\n case 4: _.label++; return { value: op[1], done: false };\r\n case 5: _.label++; y = op[1]; op = [0]; continue;\r\n case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n default:\r\n if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n if (t[2]) _.ops.pop();\r\n _.trys.pop(); continue;\r\n }\r\n op = body.call(thisArg, _);\r\n } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n }\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n if (m) return m.call(o);\r\n if (o && typeof o.length === \"number\") return {\r\n next: function () {\r\n if (o && i >= o.length) o = void 0;\r\n return { value: o && o[i++], done: !o };\r\n }\r\n };\r\n throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n if (!m) return o;\r\n var i = m.call(o), r, ar = [], e;\r\n try {\r\n while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n }\r\n catch (error) { e = { error: error }; }\r\n finally {\r\n try {\r\n if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n }\r\n finally { if (e) throw e.error; }\r\n }\r\n return ar;\r\n}\r\n\r\nexport function __spread() {\r\n for (var ar = [], i = 0; i < arguments.length; i++)\r\n ar = ar.concat(__read(arguments[i]));\r\n return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n r[k] = a[j];\r\n return r;\r\n};\r\n\r\nexport function __await(v) {\r\n return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n function fulfill(value) { resume(\"next\", value); }\r\n function reject(value) { resume(\"throw\", value); }\r\n function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n var i, p;\r\n return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n var m = o[Symbol.asyncIterator], i;\r\n return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n if (mod && mod.__esModule) return mod;\r\n var result = {};\r\n if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n result.default = mod;\r\n return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n if (!privateMap.has(receiver)) {\r\n throw new TypeError(\"attempted to get private field on non-instance\");\r\n }\r\n return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n if (!privateMap.has(receiver)) {\r\n throw new TypeError(\"attempted to set private field on non-instance\");\r\n }\r\n privateMap.set(receiver, value);\r\n return value;\r\n}\r\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","module.exports = function(module) {\n\tif (!module.webpackPolyfill) {\n\t\tmodule.deprecate = function() {};\n\t\tmodule.paths = [];\n\t\t// module.parent = undefined by default\n\t\tif (!module.children) module.children = [];\n\t\tObject.defineProperty(module, \"loaded\", {\n\t\t\tenumerable: true,\n\t\t\tget: function() {\n\t\t\t\treturn module.l;\n\t\t\t}\n\t\t});\n\t\tObject.defineProperty(module, \"id\", {\n\t\t\tenumerable: true,\n\t\t\tget: function() {\n\t\t\t\treturn module.i;\n\t\t\t}\n\t\t});\n\t\tmodule.webpackPolyfill = 1;\n\t}\n\treturn module;\n};\n","import React from 'react';\nimport { DataSourceHttpSettings } from '@grafana/ui';\nimport { DataSourcePluginOptionsEditorProps } from '@grafana/data';\nimport { MyDataSourceOptions } from './types';\n\nexport type Props = DataSourcePluginOptionsEditorProps;\nexport const ConfigEditor = (props: Props) => {\n const { options, onOptionsChange } = props;\n\n return (\n <>\n \n \n );\n};\n","import defaults from 'lodash/defaults';\n\nimport {\n AnnotationEvent,\n AnnotationQueryRequest,\n DataQueryRequest,\n DataQueryResponse,\n DataSourceApi,\n DataSourceInstanceSettings,\n ScopedVars,\n TimeRange,\n} from '@grafana/data';\n\nimport { MyQuery, MyDataSourceOptions, defaultQuery } from './types';\nimport { dateTime, MutableDataFrame, FieldType, DataFrame } from '@grafana/data';\nimport _ from 'lodash';\nimport { flatten } from './util';\n\nexport class DataSource extends DataSourceApi {\n basicAuth: string | undefined;\n withCredentials: boolean | undefined;\n url: string | undefined;\n\n constructor(instanceSettings: DataSourceInstanceSettings, private backendSrv: any, private templateSrv: any) {\n super(instanceSettings);\n this.basicAuth = instanceSettings.basicAuth;\n this.withCredentials = instanceSettings.withCredentials;\n this.url = instanceSettings.url;\n }\n\n private request(data: string) {\n const options: any = {\n url: this.url,\n method: 'POST',\n data: {\n query: data,\n },\n };\n\n if (this.basicAuth || this.withCredentials) {\n options.withCredentials = true;\n }\n if (this.basicAuth) {\n options.headers = {\n Authorization: this.basicAuth,\n };\n }\n\n return this.backendSrv.datasourceRequest(options);\n }\n\n private postQuery(query: Partial, payload: string) {\n return this.request(payload)\n .then((results: any) => {\n return { query, results };\n })\n .catch((err: any) => {\n if (err.data && err.data.error) {\n throw {\n message: 'GraphQL error: ' + err.data.error.reason,\n error: err.data.error,\n };\n }\n\n throw err;\n });\n }\n\n private createQuery(query: MyQuery, range: TimeRange | undefined, scopedVars: ScopedVars | undefined = undefined) {\n let payload = query.queryText;\n if (range) {\n payload = payload.replace(/\\$timeFrom/g, range.from.valueOf().toString());\n payload = payload.replace(/\\$timeTo/g, range.to.valueOf().toString());\n }\n payload = this.templateSrv.replace(payload, scopedVars);\n\n //console.log(payload);\n return this.postQuery(query, payload);\n }\n private static getDocs(resultsData: any, dataPath: string): any[] {\n if (!resultsData) {\n throw 'resultsData was null or undefined';\n }\n let data = dataPath.split('.').reduce((d: any, p: any) => {\n if (!d) {\n return null;\n }\n return d[p];\n }, resultsData.data);\n if (!data) {\n const errors: any[] = resultsData.errors;\n if (errors && errors.length !== 0) {\n throw errors[0];\n }\n throw 'Your data path did not exist! dataPath: ' + dataPath;\n }\n if (resultsData.errors) {\n // There can still be errors even if there is data\n console.log('Got GraphQL errors:');\n console.log(resultsData.errors);\n }\n const docs: any[] = [];\n let pushDoc = (originalDoc: object) => {\n docs.push(flatten(originalDoc));\n };\n if (Array.isArray(data)) {\n for (const element of data) {\n pushDoc(element);\n }\n } else {\n pushDoc(data);\n }\n return docs;\n }\n private static getDataPathArray(dataPathString: string): string[] {\n const dataPathArray: string[] = [];\n for (const dataPath of dataPathString.split(',')) {\n const trimmed = dataPath.trim();\n if (trimmed) {\n dataPathArray.push(trimmed);\n }\n }\n if (!dataPathArray) {\n throw 'data path is empty!';\n }\n return dataPathArray;\n }\n\n async query(options: DataQueryRequest): Promise {\n return Promise.all(\n options.targets.map(target => {\n return this.createQuery(defaults(target, defaultQuery), options.range, options.scopedVars);\n })\n ).then((results: any) => {\n const dataFrameArray: DataFrame[] = [];\n for (let res of results) {\n const dataPathArray: string[] = DataSource.getDataPathArray(res.query.dataPath);\n const { groupBy, aliasBy } = res.query;\n const split = groupBy.split(',');\n const groupByList: string[] = [];\n for (const element of split) {\n const trimmed = element.trim();\n if (trimmed) {\n groupByList.push(trimmed);\n }\n }\n for (const dataPath of dataPathArray) {\n const docs: any[] = DataSource.getDocs(res.results.data, dataPath);\n\n const dataFrameMap = new Map();\n for (const doc of docs) {\n if (doc.Time) {\n doc.Time = dateTime(doc.Time);\n }\n const identifiers: string[] = [];\n for (const groupByElement of groupByList) {\n identifiers.push(doc[groupByElement]);\n }\n const identifiersString = identifiers.toString();\n let dataFrame = dataFrameMap.get(identifiersString);\n if (!dataFrame) {\n // we haven't initialized the dataFrame for this specific identifier that we group by yet\n dataFrame = new MutableDataFrame({ fields: [] });\n const generalReplaceObject: any = {};\n for (const fieldName in doc) {\n generalReplaceObject['field_' + fieldName] = doc[fieldName];\n }\n for (const fieldName in doc) {\n let t: FieldType = FieldType.string;\n if (fieldName === 'Time') {\n t = FieldType.time;\n } else if (_.isNumber(doc[fieldName])) {\n t = FieldType.number;\n }\n let title;\n if (identifiers.length !== 0) {\n // if we have any identifiers\n title = identifiersString + '_' + fieldName;\n } else {\n title = fieldName;\n }\n if (aliasBy) {\n title = aliasBy;\n const replaceObject = { ...generalReplaceObject };\n replaceObject['fieldName'] = fieldName;\n for (const replaceKey in replaceObject) {\n const replaceValue = replaceObject[replaceKey];\n const regex = new RegExp('\\\\$' + replaceKey, 'g');\n title = title.replace(regex, replaceValue);\n }\n title = this.templateSrv.replace(title, options.scopedVars);\n }\n dataFrame.addField({\n name: fieldName,\n type: t,\n config: { title: title },\n }).parse = (v: any) => {\n return v || '';\n };\n }\n dataFrameMap.set(identifiersString, dataFrame);\n }\n\n dataFrame.add(doc);\n }\n for (const dataFrame of dataFrameMap.values()) {\n dataFrameArray.push(dataFrame);\n }\n }\n }\n return { data: dataFrameArray };\n });\n }\n annotationQuery(options: AnnotationQueryRequest): Promise {\n const query = defaults(options.annotation, defaultQuery);\n return Promise.all([this.createQuery(query, options.range)]).then((results: any) => {\n const r: AnnotationEvent[] = [];\n for (const res of results) {\n const dataPathArray: string[] = DataSource.getDataPathArray(res.query.dataPath);\n for (const dataPath of dataPathArray) {\n const docs: any[] = DataSource.getDocs(res.results.data, dataPath);\n for (const doc of docs) {\n const annotation: AnnotationEvent = {};\n if (doc.Time) {\n annotation.time = dateTime(doc.Time).valueOf();\n }\n if (doc.TimeEnd) {\n annotation.isRegion = true;\n annotation.timeEnd = dateTime(doc.TimeEnd).valueOf();\n }\n let title = query.annotationTitle;\n let text = query.annotationText;\n let tags = query.annotationTags;\n for (const fieldName in doc) {\n const fieldValue = doc[fieldName];\n const replaceKey = 'field_' + fieldName;\n const regex = new RegExp('\\\\$' + replaceKey, 'g');\n title = title.replace(regex, fieldValue);\n text = text.replace(regex, fieldValue);\n tags = tags.replace(regex, fieldValue);\n }\n\n annotation.title = title;\n annotation.text = text;\n const tagsList: string[] = [];\n for (const element of tags.split(',')) {\n const trimmed = element.trim();\n if (trimmed) {\n tagsList.push(trimmed);\n }\n }\n annotation.tags = tagsList;\n r.push(annotation);\n }\n }\n }\n return r;\n });\n }\n\n testDatasource() {\n const q = `{\n __schema{\n queryType{name}\n }\n }`;\n return this.postQuery(defaultQuery, q).then(\n (res: any) => {\n if (res.errors) {\n console.log(res.errors);\n return {\n status: 'error',\n message: 'GraphQL Error: ' + res.errors[0].message,\n };\n }\n return {\n status: 'success',\n message: 'Success',\n };\n },\n (err: any) => {\n console.log(err);\n return {\n status: 'error',\n message: 'HTTP Response ' + err.status + ': ' + err.statusText,\n };\n }\n );\n }\n}\n","export class GraphQLAnnotationsQueryCtrl {\n static templateUrl = 'partials/annotations.editor.html';\n annotation: any;\n constructor() {}\n}\n","import defaults from 'lodash/defaults';\n\nimport React, { PureComponent, ChangeEvent } from 'react';\nimport { QueryEditorProps } from '@grafana/data';\nimport { FormField } from '@grafana/ui';\nimport { DataSource } from './DataSource';\nimport { MyQuery, MyDataSourceOptions, defaultQuery } from './types';\n\ntype Props = QueryEditorProps;\n\ninterface State {}\n\nexport class QueryEditor extends PureComponent {\n onComponentDidMount() {}\n\n onQueryTextChange = (event: ChangeEvent) => {\n const { onChange, query } = this.props;\n onChange({ ...query, queryText: event.target.value });\n };\n\n onDataPathTextChange = (event: ChangeEvent) => {\n const { onChange, query } = this.props;\n onChange({ ...query, dataPath: event.target.value });\n };\n onGroupByTextChange = (event: ChangeEvent) => {\n const { onChange, query } = this.props;\n onChange({ ...query, groupBy: event.target.value });\n };\n\n onAliasByTextChange = (event: ChangeEvent) => {\n const { onChange, query } = this.props;\n onChange({ ...query, aliasBy: event.target.value });\n };\n\n render() {\n const query = defaults(this.props.query, defaultQuery);\n const { queryText, dataPath, groupBy, aliasBy } = query;\n\n return (\n <>\n