text: "use strict";
  
  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  
  /*! *****************************************************************************
  Copyright (c) Microsoft Corporation. All rights reserved.
  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
  this file except in compliance with the License. You may obtain a copy of the
  License at http://www.apache.org/licenses/LICENSE-2.0
  
  THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
  WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
  MERCHANTABLITY OR NON-INFRINGEMENT.
  
  See the Apache Version 2.0 License for specific language governing permissions
  and limitations under the License.
  ***************************************************************************** */
  /* global global, define, System, Reflect, Promise */
  var __extends;
  var __assign;
  var __rest;
  var __decorate;
  var __param;
  var __metadata;
  var __awaiter;
  var __generator;
  var __exportStar;
  var __values;
  var __read;
  var __spread;
  var _await;
  var __asyncGenerator;
  var __asyncDelegator;
  var __asyncValues;
  var __makeTemplateObject;
  var __importStar;
  var __importDefault;
  (function (factory) {
      var root = (typeof global === "undefined" ? "undefined" : _typeof(global)) === "object" ? global : (typeof self === "undefined" ? "undefined" : _typeof(self)) === "object" ? self : _typeof(this) === "object" ? this : {};
      if (typeof define === "function" && define.amd) {
          define("tslib", ["exports"], function (exports) {
              factory(createExporter(root, createExporter(exports)));
          });
      } else if ((typeof module === "undefined" ? "undefined" : _typeof(module)) === "object" && _typeof(module.exports) === "object") {
          factory(createExporter(root, createExporter(module.exports)));
      } else {
          factory(createExporter(root));
      }
      function createExporter(exports, previous) {
          if (exports !== root) {
              if (typeof Object.create === "function") {
                  Object.defineProperty(exports, "__esModule", { value: true });
              } else {
                  exports.__esModule = true;
              }
          }
          return function (id, v) {
              return exports[id] = previous ? previous(id, v) : v;
          };
      }
  })(function (exporter) {
      var extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function (d, b) {
          d.__proto__ = b;
      } || function (d, b) {
          for (var p in b) {
              if (b.hasOwnProperty(p)) d[p] = b[p];
          }
      };
  
      __extends = function __extends(d, b) {
          extendStatics(d, b);
          function __() {
              this.constructor = d;
          }
          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
  
      __assign = Object.assign || function (t) {
          for (var s, i = 1, n = arguments.length; i < n; i++) {
              s = arguments[i];
              for (var p in s) {
                  if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
              }
          }
          return t;
      };
  
      __rest = function __rest(s, e) {
          var t = {};
          for (var p in s) {
              if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
          }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
              if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
          }return t;
      };
  
      __decorate = function __decorate(decorators, target, key, desc) {
          var c = arguments.length,
              r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc,
              d;
          if ((typeof Reflect === "undefined" ? "undefined" : _typeof(Reflect)) === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);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;
          }return c > 3 && r && Object.defineProperty(target, key, r), r;
      };
  
      __param = function __param(paramIndex, decorator) {
          return function (target, key) {
              decorator(target, key, paramIndex);
          };
      };
  
      __metadata = function __metadata(metadataKey, metadataValue) {
          if ((typeof Reflect === "undefined" ? "undefined" : _typeof(Reflect)) === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
      };
  
      __awaiter = function __awaiter(thisArg, _arguments, P, generator) {
          return new (P || (P = Promise))(function (resolve, reject) {
              function fulfilled(value) {
                  try {
                      step(generator.next(value));
                  } catch (e) {
                      reject(e);
                  }
              }
              function rejected(value) {
                  try {
                      step(generator["throw"](value));
                  } catch (e) {
                      reject(e);
                  }
              }
              function step(result) {
                  result.done ? resolve(result.value) : new P(function (resolve) {
                      resolve(result.value);
                  }).then(fulfilled, rejected);
              }
              step((generator = generator.apply(thisArg, _arguments || [])).next());
          });
      };
  
      __generator = function __generator(thisArg, body) {
          var _ = { label: 0, sent: function sent() {
                  if (t[0] & 1) throw t[1];return t[1];
              }, trys: [], ops: [] },
              f,
              y,
              t,
              g;
          return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
              return this;
          }), g;
          function verb(n) {
              return function (v) {
                  return step([n, v]);
              };
          }
          function step(op) {
              if (f) throw new TypeError("Generator is already executing.");
              while (_) {
                  try {
                      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;
                      if (y = 0, t) op = [op[0] & 2, t.value];
                      switch (op[0]) {
                          case 0:case 1:
                              t = op;break;
                          case 4:
                              _.label++;return { value: op[1], done: false };
                          case 5:
                              _.label++;y = op[1];op = [0];continue;
                          case 7:
                              op = _.ops.pop();_.trys.pop();continue;
                          default:
                              if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
                                  _ = 0;continue;
                              }
                              if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
                                  _.label = op[1];break;
                              }
                              if (op[0] === 6 && _.label < t[1]) {
                                  _.label = t[1];t = op;break;
                              }
                              if (t && _.label < t[2]) {
                                  _.label = t[2];_.ops.push(op);break;
                              }
                              if (t[2]) _.ops.pop();
                              _.trys.pop();continue;
                      }
                      op = body.call(thisArg, _);
                  } catch (e) {
                      op = [6, e];y = 0;
                  } finally {
                      f = t = 0;
                  }
              }if (op[0] & 5) throw op[1];return { value: op[0] ? op[1] : void 0, done: true };
          }
      };
  
      __exportStar = function __exportStar(m, exports) {
          for (var p in m) {
              if (!exports.hasOwnProperty(p)) exports[p] = m[p];
          }
      };
  
      __values = function __values(o) {
          var m = typeof Symbol === "function" && o[Symbol.iterator],
              i = 0;
          if (m) return m.call(o);
          return {
              next: function next() {
                  if (o && i >= o.length) o = void 0;
                  return { value: o && o[i++], done: !o };
              }
          };
      };
  
      __read = function __read(o, n) {
          var m = typeof Symbol === "function" && o[Symbol.iterator];
          if (!m) return o;
          var i = m.call(o),
              r,
              ar = [],
              e;
          try {
              while ((n === void 0 || n-- > 0) && !(r = i.next()).done) {
                  ar.push(r.value);
              }
          } catch (error) {
              e = { error: error };
          } finally {
              try {
                  if (r && !r.done && (m = i["return"])) m.call(i);
              } finally {
                  if (e) throw e.error;
              }
          }
          return ar;
      };
  
      __spread = function __spread() {
          for (var ar = [], i = 0; i < arguments.length; i++) {
              ar = ar.concat(__read(arguments[i]));
          }return ar;
      };
  
      _await = function __await(v) {
          return this instanceof _await ? (this.v = v, this) : new _await(v);
      };
  
      __asyncGenerator = function __asyncGenerator(thisArg, _arguments, generator) {
          if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
          var g = generator.apply(thisArg, _arguments || []),
              i,
              q = [];
          return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () {
              return this;
          }, i;
          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);
                  });
              };
          }
          function resume(n, v) {
              try {
                  step(g[n](v));
              } catch (e) {
                  settle(q[0][3], e);
              }
          }
          function step(r) {
              r.value instanceof _await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
          }
          function fulfill(value) {
              resume("next", value);
          }
          function reject(value) {
              resume("throw", value);
          }
          function settle(f, v) {
              if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
          }
      };
  
      __asyncDelegator = function __asyncDelegator(o) {
          var i, p;
          return i = {}, verb("next"), verb("throw", function (e) {
              throw e;
          }), verb("return"), i[Symbol.iterator] = function () {
              return this;
          }, i;
          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;
          }
      };
  
      __asyncValues = function __asyncValues(o) {
          if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
          var m = o[Symbol.asyncIterator],
              i;
          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);
          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);
                  });
              };
          }
          function settle(resolve, reject, d, v) {
              Promise.resolve(v).then(function (v) {
                  resolve({ value: v, done: d });
              }, reject);
          }
      };
  
      __makeTemplateObject = function __makeTemplateObject(cooked, raw) {
          if (Object.defineProperty) {
              Object.defineProperty(cooked, "raw", { value: raw });
          } else {
              cooked.raw = raw;
          }
          return cooked;
      };
  
      __importStar = function __importStar(mod) {
          if (mod && mod.__esModule) return mod;
          var result = {};
          if (mod != null) for (var k in mod) {
              if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
          }result["default"] = mod;
          return result;
      };
  
      __importDefault = function __importDefault(mod) {
          return mod && mod.__esModule ? mod : { "default": mod };
      };
  
      exporter("__extends", __extends);
      exporter("__assign", __assign);
      exporter("__rest", __rest);
      exporter("__decorate", __decorate);
      exporter("__param", __param);
      exporter("__metadata", __metadata);
      exporter("__awaiter", __awaiter);
      exporter("__generator", __generator);
      exporter("__exportStar", __exportStar);
      exporter("__values", __values);
      exporter("__read", __read);
      exporter("__spread", __spread);
      exporter("__await", _await);
      exporter("__asyncGenerator", __asyncGenerator);
      exporter("__asyncDelegator", __asyncDelegator);
      exporter("__asyncValues", __asyncValues);
      exporter("__makeTemplateObject", __makeTemplateObject);
      exporter("__importStar", __importStar);
      exporter("__importDefault", __importDefault);
  });