1 /*! *****************************************************************************
\r
2 Copyright (c) Microsoft Corporation.
\r
4 Permission to use, copy, modify, and/or distribute this software for any
\r
5 purpose with or without fee is hereby granted.
\r
7 THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
\r
8 REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
\r
9 AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
\r
10 INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
\r
11 LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
\r
12 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
\r
13 PERFORMANCE OF THIS SOFTWARE.
\r
14 ***************************************************************************** */
\r
16 /* global global, define, System, Reflect, Promise */
\r
31 var __asyncGenerator;
\r
32 var __asyncDelegator;
\r
34 var __makeTemplateObject;
\r
36 var __importDefault;
\r
37 var __classPrivateFieldGet;
\r
38 var __classPrivateFieldSet;
\r
39 var __createBinding;
\r
40 (function (factory) {
\r
41 var root = typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : {};
\r
42 if (typeof define === "function" && define.amd) {
\r
43 define("tslib", ["exports"], function (exports) { factory(createExporter(root, createExporter(exports))); });
\r
45 else if (typeof module === "object" && typeof module.exports === "object") {
\r
46 factory(createExporter(root, createExporter(module.exports)));
\r
49 factory(createExporter(root));
\r
51 function createExporter(exports, previous) {
\r
52 if (exports !== root) {
\r
53 if (typeof Object.create === "function") {
\r
54 Object.defineProperty(exports, "__esModule", { value: true });
\r
57 exports.__esModule = true;
\r
60 return function (id, v) { return exports[id] = previous ? previous(id, v) : v; };
\r
63 (function (exporter) {
\r
64 var extendStatics = Object.setPrototypeOf ||
\r
65 ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
\r
66 function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
\r
68 __extends = function (d, b) {
\r
69 extendStatics(d, b);
\r
70 function __() { this.constructor = d; }
\r
71 d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
\r
74 __assign = Object.assign || function (t) {
\r
75 for (var s, i = 1, n = arguments.length; i < n; i++) {
\r
77 for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
\r
82 __rest = function (s, e) {
\r
84 for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
\r
86 if (s != null && typeof Object.getOwnPropertySymbols === "function")
\r
87 for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
\r
88 if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
\r
94 __decorate = function (decorators, target, key, desc) {
\r
95 var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
\r
96 if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
\r
97 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
98 return c > 3 && r && Object.defineProperty(target, key, r), r;
\r
101 __param = function (paramIndex, decorator) {
\r
102 return function (target, key) { decorator(target, key, paramIndex); }
\r
105 __metadata = function (metadataKey, metadataValue) {
\r
106 if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
\r
109 __awaiter = function (thisArg, _arguments, P, generator) {
\r
110 function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
\r
111 return new (P || (P = Promise))(function (resolve, reject) {
\r
112 function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
\r
113 function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
\r
114 function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
\r
115 step((generator = generator.apply(thisArg, _arguments || [])).next());
\r
119 __generator = function (thisArg, body) {
\r
120 var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
\r
121 return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
\r
122 function verb(n) { return function (v) { return step([n, v]); }; }
\r
123 function step(op) {
\r
124 if (f) throw new TypeError("Generator is already executing.");
\r
126 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
127 if (y = 0, t) op = [op[0] & 2, t.value];
\r
129 case 0: case 1: t = op; break;
\r
130 case 4: _.label++; return { value: op[1], done: false };
\r
131 case 5: _.label++; y = op[1]; op = [0]; continue;
\r
132 case 7: op = _.ops.pop(); _.trys.pop(); continue;
\r
134 if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
\r
135 if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
\r
136 if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
\r
137 if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
\r
138 if (t[2]) _.ops.pop();
\r
139 _.trys.pop(); continue;
\r
141 op = body.call(thisArg, _);
\r
142 } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
\r
143 if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
\r
147 __createBinding = function(o, m, k, k2) {
\r
148 if (k2 === undefined) k2 = k;
\r
152 __exportStar = function (m, exports) {
\r
153 for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) exports[p] = m[p];
\r
156 __values = function (o) {
\r
157 var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
\r
158 if (m) return m.call(o);
\r
159 if (o && typeof o.length === "number") return {
\r
160 next: function () {
\r
161 if (o && i >= o.length) o = void 0;
\r
162 return { value: o && o[i++], done: !o };
\r
165 throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
\r
168 __read = function (o, n) {
\r
169 var m = typeof Symbol === "function" && o[Symbol.iterator];
\r
171 var i = m.call(o), r, ar = [], e;
\r
173 while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
\r
175 catch (error) { e = { error: error }; }
\r
178 if (r && !r.done && (m = i["return"])) m.call(i);
\r
180 finally { if (e) throw e.error; }
\r
185 __spread = function () {
\r
186 for (var ar = [], i = 0; i < arguments.length; i++)
\r
187 ar = ar.concat(__read(arguments[i]));
\r
191 __spreadArrays = function () {
\r
192 for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
\r
193 for (var r = Array(s), k = 0, i = 0; i < il; i++)
\r
194 for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
\r
199 __await = function (v) {
\r
200 return this instanceof __await ? (this.v = v, this) : new __await(v);
\r
203 __asyncGenerator = function (thisArg, _arguments, generator) {
\r
204 if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
\r
205 var g = generator.apply(thisArg, _arguments || []), i, q = [];
\r
206 return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
\r
207 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
208 function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
\r
209 function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
\r
210 function fulfill(value) { resume("next", value); }
\r
211 function reject(value) { resume("throw", value); }
\r
212 function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
\r
215 __asyncDelegator = function (o) {
\r
217 return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
\r
218 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
221 __asyncValues = function (o) {
\r
222 if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
\r
223 var m = o[Symbol.asyncIterator], i;
\r
224 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
225 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
226 function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
\r
229 __makeTemplateObject = function (cooked, raw) {
\r
230 if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
\r
234 __importStar = function (mod) {
\r
235 if (mod && mod.__esModule) return mod;
\r
237 if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
\r
238 result["default"] = mod;
\r
242 __importDefault = function (mod) {
\r
243 return (mod && mod.__esModule) ? mod : { "default": mod };
\r
246 __classPrivateFieldGet = function (receiver, privateMap) {
\r
247 if (!privateMap.has(receiver)) {
\r
248 throw new TypeError("attempted to get private field on non-instance");
\r
250 return privateMap.get(receiver);
\r
253 __classPrivateFieldSet = function (receiver, privateMap, value) {
\r
254 if (!privateMap.has(receiver)) {
\r
255 throw new TypeError("attempted to set private field on non-instance");
\r
257 privateMap.set(receiver, value);
\r
261 exporter("__extends", __extends);
\r
262 exporter("__assign", __assign);
\r
263 exporter("__rest", __rest);
\r
264 exporter("__decorate", __decorate);
\r
265 exporter("__param", __param);
\r
266 exporter("__metadata", __metadata);
\r
267 exporter("__awaiter", __awaiter);
\r
268 exporter("__generator", __generator);
\r
269 exporter("__exportStar", __exportStar);
\r
270 exporter("__createBinding", __createBinding);
\r
271 exporter("__values", __values);
\r
272 exporter("__read", __read);
\r
273 exporter("__spread", __spread);
\r
274 exporter("__spreadArrays", __spreadArrays);
\r
275 exporter("__await", __await);
\r
276 exporter("__asyncGenerator", __asyncGenerator);
\r
277 exporter("__asyncDelegator", __asyncDelegator);
\r
278 exporter("__asyncValues", __asyncValues);
\r
279 exporter("__makeTemplateObject", __makeTemplateObject);
\r
280 exporter("__importStar", __importStar);
\r
281 exporter("__importDefault", __importDefault);
\r
282 exporter("__classPrivateFieldGet", __classPrivateFieldGet);
\r
283 exporter("__classPrivateFieldSet", __classPrivateFieldSet);
\r