oro-sdk-apis 1.46.0 → 1.49.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -13,918 +13,501 @@ function hashToBase64String(value) {
13
13
  return Buffer.from(sha256().update(value).digest('hex'), 'hex').toString('base64');
14
14
  }
15
15
 
16
- function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
17
- try {
18
- var info = gen[key](arg);
19
- var value = info.value;
20
- } catch (error) {
21
- reject(error);
22
- return;
23
- }
24
-
25
- if (info.done) {
26
- resolve(value);
27
- } else {
28
- Promise.resolve(value).then(_next, _throw);
29
- }
30
- }
31
-
32
- function _asyncToGenerator(fn) {
33
- return function () {
34
- var self = this,
35
- args = arguments;
36
- return new Promise(function (resolve, reject) {
37
- var gen = fn.apply(self, args);
38
-
39
- function _next(value) {
40
- asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
41
- }
42
-
43
- function _throw(err) {
44
- asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
45
- }
46
-
47
- _next(undefined);
48
- });
49
- };
50
- }
51
-
52
- function _extends() {
53
- _extends = Object.assign || function (target) {
54
- for (var i = 1; i < arguments.length; i++) {
55
- var source = arguments[i];
56
-
57
- for (var key in source) {
58
- if (Object.prototype.hasOwnProperty.call(source, key)) {
59
- target[key] = source[key];
60
- }
61
- }
62
- }
63
-
64
- return target;
65
- };
66
-
67
- return _extends.apply(this, arguments);
68
- }
69
-
70
- function _inheritsLoose(subClass, superClass) {
71
- subClass.prototype = Object.create(superClass.prototype);
72
- subClass.prototype.constructor = subClass;
73
-
74
- _setPrototypeOf(subClass, superClass);
75
- }
16
+ function _regeneratorRuntime() {
17
+ /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
76
18
 
77
- function _getPrototypeOf(o) {
78
- _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
79
- return o.__proto__ || Object.getPrototypeOf(o);
19
+ _regeneratorRuntime = function () {
20
+ return exports;
80
21
  };
81
- return _getPrototypeOf(o);
82
- }
83
22
 
84
- function _setPrototypeOf(o, p) {
85
- _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
86
- o.__proto__ = p;
87
- return o;
88
- };
89
-
90
- return _setPrototypeOf(o, p);
91
- }
92
-
93
- function _isNativeReflectConstruct() {
94
- if (typeof Reflect === "undefined" || !Reflect.construct) return false;
95
- if (Reflect.construct.sham) return false;
96
- if (typeof Proxy === "function") return true;
97
-
98
- try {
99
- Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
100
- return true;
101
- } catch (e) {
102
- return false;
103
- }
104
- }
105
-
106
- function _construct(Parent, args, Class) {
107
- if (_isNativeReflectConstruct()) {
108
- _construct = Reflect.construct;
109
- } else {
110
- _construct = function _construct(Parent, args, Class) {
111
- var a = [null];
112
- a.push.apply(a, args);
113
- var Constructor = Function.bind.apply(Parent, a);
114
- var instance = new Constructor();
115
- if (Class) _setPrototypeOf(instance, Class.prototype);
116
- return instance;
117
- };
118
- }
119
-
120
- return _construct.apply(null, arguments);
121
- }
122
-
123
- function _isNativeFunction(fn) {
124
- return Function.toString.call(fn).indexOf("[native code]") !== -1;
125
- }
126
-
127
- function _wrapNativeSuper(Class) {
128
- var _cache = typeof Map === "function" ? new Map() : undefined;
129
-
130
- _wrapNativeSuper = function _wrapNativeSuper(Class) {
131
- if (Class === null || !_isNativeFunction(Class)) return Class;
132
-
133
- if (typeof Class !== "function") {
134
- throw new TypeError("Super expression must either be null or a function");
135
- }
136
-
137
- if (typeof _cache !== "undefined") {
138
- if (_cache.has(Class)) return _cache.get(Class);
139
-
140
- _cache.set(Class, Wrapper);
141
- }
142
-
143
- function Wrapper() {
144
- return _construct(Class, arguments, _getPrototypeOf(this).constructor);
145
- }
146
-
147
- Wrapper.prototype = Object.create(Class.prototype, {
148
- constructor: {
149
- value: Wrapper,
150
- enumerable: false,
151
- writable: true,
152
- configurable: true
153
- }
154
- });
155
- return _setPrototypeOf(Wrapper, Class);
156
- };
157
-
158
- return _wrapNativeSuper(Class);
159
- }
160
-
161
- function _assertThisInitialized(self) {
162
- if (self === void 0) {
163
- throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
164
- }
165
-
166
- return self;
167
- }
168
-
169
- function createCommonjsModule(fn, module) {
170
- return module = { exports: {} }, fn(module, module.exports), module.exports;
171
- }
172
-
173
- var runtime_1 = createCommonjsModule(function (module) {
174
- /**
175
- * Copyright (c) 2014-present, Facebook, Inc.
176
- *
177
- * This source code is licensed under the MIT license found in the
178
- * LICENSE file in the root directory of this source tree.
179
- */
180
-
181
- var runtime = (function (exports) {
182
-
183
- var Op = Object.prototype;
184
- var hasOwn = Op.hasOwnProperty;
185
- var undefined$1; // More compressible than void 0.
186
- var $Symbol = typeof Symbol === "function" ? Symbol : {};
187
- var iteratorSymbol = $Symbol.iterator || "@@iterator";
188
- var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
189
- var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
23
+ var exports = {},
24
+ Op = Object.prototype,
25
+ hasOwn = Op.hasOwnProperty,
26
+ $Symbol = "function" == typeof Symbol ? Symbol : {},
27
+ iteratorSymbol = $Symbol.iterator || "@@iterator",
28
+ asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
29
+ toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
190
30
 
191
31
  function define(obj, key, value) {
192
- Object.defineProperty(obj, key, {
32
+ return Object.defineProperty(obj, key, {
193
33
  value: value,
194
- enumerable: true,
195
- configurable: true,
196
- writable: true
197
- });
198
- return obj[key];
34
+ enumerable: !0,
35
+ configurable: !0,
36
+ writable: !0
37
+ }), obj[key];
199
38
  }
39
+
200
40
  try {
201
- // IE 8 has a broken Object.defineProperty that only works on DOM objects.
202
41
  define({}, "");
203
42
  } catch (err) {
204
- define = function(obj, key, value) {
43
+ define = function (obj, key, value) {
205
44
  return obj[key] = value;
206
45
  };
207
46
  }
208
47
 
209
48
  function wrap(innerFn, outerFn, self, tryLocsList) {
210
- // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
211
- var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
212
- var generator = Object.create(protoGenerator.prototype);
213
- var context = new Context(tryLocsList || []);
49
+ var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
50
+ generator = Object.create(protoGenerator.prototype),
51
+ context = new Context(tryLocsList || []);
52
+ return generator._invoke = function (innerFn, self, context) {
53
+ var state = "suspendedStart";
54
+ return function (method, arg) {
55
+ if ("executing" === state) throw new Error("Generator is already running");
56
+
57
+ if ("completed" === state) {
58
+ if ("throw" === method) throw arg;
59
+ return doneResult();
60
+ }
61
+
62
+ for (context.method = method, context.arg = arg;;) {
63
+ var delegate = context.delegate;
64
+
65
+ if (delegate) {
66
+ var delegateResult = maybeInvokeDelegate(delegate, context);
67
+
68
+ if (delegateResult) {
69
+ if (delegateResult === ContinueSentinel) continue;
70
+ return delegateResult;
71
+ }
72
+ }
214
73
 
215
- // The ._invoke method unifies the implementations of the .next,
216
- // .throw, and .return methods.
217
- generator._invoke = makeInvokeMethod(innerFn, self, context);
74
+ if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
75
+ if ("suspendedStart" === state) throw state = "completed", context.arg;
76
+ context.dispatchException(context.arg);
77
+ } else "return" === context.method && context.abrupt("return", context.arg);
78
+ state = "executing";
79
+ var record = tryCatch(innerFn, self, context);
80
+
81
+ if ("normal" === record.type) {
82
+ if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
83
+ return {
84
+ value: record.arg,
85
+ done: context.done
86
+ };
87
+ }
218
88
 
219
- return generator;
89
+ "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
90
+ }
91
+ };
92
+ }(innerFn, self, context), generator;
220
93
  }
221
- exports.wrap = wrap;
222
94
 
223
- // Try/catch helper to minimize deoptimizations. Returns a completion
224
- // record like context.tryEntries[i].completion. This interface could
225
- // have been (and was previously) designed to take a closure to be
226
- // invoked without arguments, but in all the cases we care about we
227
- // already have an existing method we want to call, so there's no need
228
- // to create a new function object. We can even get away with assuming
229
- // the method takes exactly one argument, since that happens to be true
230
- // in every case, so we don't have to touch the arguments object. The
231
- // only additional allocation required is the completion record, which
232
- // has a stable shape and so hopefully should be cheap to allocate.
233
95
  function tryCatch(fn, obj, arg) {
234
96
  try {
235
- return { type: "normal", arg: fn.call(obj, arg) };
97
+ return {
98
+ type: "normal",
99
+ arg: fn.call(obj, arg)
100
+ };
236
101
  } catch (err) {
237
- return { type: "throw", arg: err };
102
+ return {
103
+ type: "throw",
104
+ arg: err
105
+ };
238
106
  }
239
107
  }
240
108
 
241
- var GenStateSuspendedStart = "suspendedStart";
242
- var GenStateSuspendedYield = "suspendedYield";
243
- var GenStateExecuting = "executing";
244
- var GenStateCompleted = "completed";
245
-
246
- // Returning this object from the innerFn has the same effect as
247
- // breaking out of the dispatch switch statement.
109
+ exports.wrap = wrap;
248
110
  var ContinueSentinel = {};
249
111
 
250
- // Dummy constructor functions that we use as the .constructor and
251
- // .constructor.prototype properties for functions that return Generator
252
- // objects. For full spec compliance, you may wish to configure your
253
- // minifier not to mangle the names of these two functions.
254
112
  function Generator() {}
113
+
255
114
  function GeneratorFunction() {}
115
+
256
116
  function GeneratorFunctionPrototype() {}
257
117
 
258
- // This is a polyfill for %IteratorPrototype% for environments that
259
- // don't natively support it.
260
118
  var IteratorPrototype = {};
261
119
  define(IteratorPrototype, iteratorSymbol, function () {
262
120
  return this;
263
121
  });
122
+ var getProto = Object.getPrototypeOf,
123
+ NativeIteratorPrototype = getProto && getProto(getProto(values([])));
124
+ NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
125
+ var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
264
126
 
265
- var getProto = Object.getPrototypeOf;
266
- var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
267
- if (NativeIteratorPrototype &&
268
- NativeIteratorPrototype !== Op &&
269
- hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
270
- // This environment has a native %IteratorPrototype%; use it instead
271
- // of the polyfill.
272
- IteratorPrototype = NativeIteratorPrototype;
273
- }
274
-
275
- var Gp = GeneratorFunctionPrototype.prototype =
276
- Generator.prototype = Object.create(IteratorPrototype);
277
- GeneratorFunction.prototype = GeneratorFunctionPrototype;
278
- define(Gp, "constructor", GeneratorFunctionPrototype);
279
- define(GeneratorFunctionPrototype, "constructor", GeneratorFunction);
280
- GeneratorFunction.displayName = define(
281
- GeneratorFunctionPrototype,
282
- toStringTagSymbol,
283
- "GeneratorFunction"
284
- );
285
-
286
- // Helper for defining the .next, .throw, and .return methods of the
287
- // Iterator interface in terms of a single ._invoke method.
288
127
  function defineIteratorMethods(prototype) {
289
- ["next", "throw", "return"].forEach(function(method) {
290
- define(prototype, method, function(arg) {
128
+ ["next", "throw", "return"].forEach(function (method) {
129
+ define(prototype, method, function (arg) {
291
130
  return this._invoke(method, arg);
292
131
  });
293
132
  });
294
133
  }
295
134
 
296
- exports.isGeneratorFunction = function(genFun) {
297
- var ctor = typeof genFun === "function" && genFun.constructor;
298
- return ctor
299
- ? ctor === GeneratorFunction ||
300
- // For the native GeneratorFunction constructor, the best we can
301
- // do is to check its .name property.
302
- (ctor.displayName || ctor.name) === "GeneratorFunction"
303
- : false;
304
- };
305
-
306
- exports.mark = function(genFun) {
307
- if (Object.setPrototypeOf) {
308
- Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
309
- } else {
310
- genFun.__proto__ = GeneratorFunctionPrototype;
311
- define(genFun, toStringTagSymbol, "GeneratorFunction");
312
- }
313
- genFun.prototype = Object.create(Gp);
314
- return genFun;
315
- };
316
-
317
- // Within the body of any async function, `await x` is transformed to
318
- // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
319
- // `hasOwn.call(value, "__await")` to determine if the yielded value is
320
- // meant to be awaited.
321
- exports.awrap = function(arg) {
322
- return { __await: arg };
323
- };
324
-
325
135
  function AsyncIterator(generator, PromiseImpl) {
326
136
  function invoke(method, arg, resolve, reject) {
327
137
  var record = tryCatch(generator[method], generator, arg);
328
- if (record.type === "throw") {
329
- reject(record.arg);
330
- } else {
331
- var result = record.arg;
332
- var value = result.value;
333
- if (value &&
334
- typeof value === "object" &&
335
- hasOwn.call(value, "__await")) {
336
- return PromiseImpl.resolve(value.__await).then(function(value) {
337
- invoke("next", value, resolve, reject);
338
- }, function(err) {
339
- invoke("throw", err, resolve, reject);
340
- });
341
- }
342
138
 
343
- return PromiseImpl.resolve(value).then(function(unwrapped) {
344
- // When a yielded Promise is resolved, its final value becomes
345
- // the .value of the Promise<{value,done}> result for the
346
- // current iteration.
347
- result.value = unwrapped;
348
- resolve(result);
349
- }, function(error) {
350
- // If a rejected Promise was yielded, throw the rejection back
351
- // into the async generator function so it can be handled there.
139
+ if ("throw" !== record.type) {
140
+ var result = record.arg,
141
+ value = result.value;
142
+ return value && "object" == typeof value && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
143
+ invoke("next", value, resolve, reject);
144
+ }, function (err) {
145
+ invoke("throw", err, resolve, reject);
146
+ }) : PromiseImpl.resolve(value).then(function (unwrapped) {
147
+ result.value = unwrapped, resolve(result);
148
+ }, function (error) {
352
149
  return invoke("throw", error, resolve, reject);
353
150
  });
354
151
  }
152
+
153
+ reject(record.arg);
355
154
  }
356
155
 
357
156
  var previousPromise;
358
157
 
359
- function enqueue(method, arg) {
158
+ this._invoke = function (method, arg) {
360
159
  function callInvokeWithMethodAndArg() {
361
- return new PromiseImpl(function(resolve, reject) {
160
+ return new PromiseImpl(function (resolve, reject) {
362
161
  invoke(method, arg, resolve, reject);
363
162
  });
364
163
  }
365
164
 
366
- return previousPromise =
367
- // If enqueue has been called before, then we want to wait until
368
- // all previous Promises have been resolved before calling invoke,
369
- // so that results are always delivered in the correct order. If
370
- // enqueue has not been called before, then it is important to
371
- // call invoke immediately, without waiting on a callback to fire,
372
- // so that the async generator function has the opportunity to do
373
- // any necessary setup in a predictable way. This predictability
374
- // is why the Promise constructor synchronously invokes its
375
- // executor callback, and why async functions synchronously
376
- // execute code before the first await. Since we implement simple
377
- // async functions in terms of async generators, it is especially
378
- // important to get this right, even though it requires care.
379
- previousPromise ? previousPromise.then(
380
- callInvokeWithMethodAndArg,
381
- // Avoid propagating failures to Promises returned by later
382
- // invocations of the iterator.
383
- callInvokeWithMethodAndArg
384
- ) : callInvokeWithMethodAndArg();
385
- }
386
-
387
- // Define the unified helper method that is used to implement .next,
388
- // .throw, and .return (see defineIteratorMethods).
389
- this._invoke = enqueue;
390
- }
391
-
392
- defineIteratorMethods(AsyncIterator.prototype);
393
- define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
394
- return this;
395
- });
396
- exports.AsyncIterator = AsyncIterator;
397
-
398
- // Note that simple async functions are implemented on top of
399
- // AsyncIterator objects; they just return a Promise for the value of
400
- // the final result produced by the iterator.
401
- exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {
402
- if (PromiseImpl === void 0) PromiseImpl = Promise;
403
-
404
- var iter = new AsyncIterator(
405
- wrap(innerFn, outerFn, self, tryLocsList),
406
- PromiseImpl
407
- );
408
-
409
- return exports.isGeneratorFunction(outerFn)
410
- ? iter // If outerFn is a generator, return the full iterator.
411
- : iter.next().then(function(result) {
412
- return result.done ? result.value : iter.next();
413
- });
414
- };
415
-
416
- function makeInvokeMethod(innerFn, self, context) {
417
- var state = GenStateSuspendedStart;
418
-
419
- return function invoke(method, arg) {
420
- if (state === GenStateExecuting) {
421
- throw new Error("Generator is already running");
422
- }
423
-
424
- if (state === GenStateCompleted) {
425
- if (method === "throw") {
426
- throw arg;
427
- }
428
-
429
- // Be forgiving, per 25.3.3.3.3 of the spec:
430
- // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
431
- return doneResult();
432
- }
433
-
434
- context.method = method;
435
- context.arg = arg;
436
-
437
- while (true) {
438
- var delegate = context.delegate;
439
- if (delegate) {
440
- var delegateResult = maybeInvokeDelegate(delegate, context);
441
- if (delegateResult) {
442
- if (delegateResult === ContinueSentinel) continue;
443
- return delegateResult;
444
- }
445
- }
446
-
447
- if (context.method === "next") {
448
- // Setting context._sent for legacy support of Babel's
449
- // function.sent implementation.
450
- context.sent = context._sent = context.arg;
451
-
452
- } else if (context.method === "throw") {
453
- if (state === GenStateSuspendedStart) {
454
- state = GenStateCompleted;
455
- throw context.arg;
456
- }
457
-
458
- context.dispatchException(context.arg);
459
-
460
- } else if (context.method === "return") {
461
- context.abrupt("return", context.arg);
462
- }
463
-
464
- state = GenStateExecuting;
465
-
466
- var record = tryCatch(innerFn, self, context);
467
- if (record.type === "normal") {
468
- // If an exception is thrown from innerFn, we leave state ===
469
- // GenStateExecuting and loop back for another invocation.
470
- state = context.done
471
- ? GenStateCompleted
472
- : GenStateSuspendedYield;
473
-
474
- if (record.arg === ContinueSentinel) {
475
- continue;
476
- }
477
-
478
- return {
479
- value: record.arg,
480
- done: context.done
481
- };
482
-
483
- } else if (record.type === "throw") {
484
- state = GenStateCompleted;
485
- // Dispatch the exception by looping back around to the
486
- // context.dispatchException(context.arg) call above.
487
- context.method = "throw";
488
- context.arg = record.arg;
489
- }
490
- }
165
+ return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
491
166
  };
492
167
  }
493
168
 
494
- // Call delegate.iterator[context.method](context.arg) and handle the
495
- // result, either by returning a { value, done } result from the
496
- // delegate iterator, or by modifying context.method and context.arg,
497
- // setting context.delegate to null, and returning the ContinueSentinel.
498
169
  function maybeInvokeDelegate(delegate, context) {
499
170
  var method = delegate.iterator[context.method];
500
- if (method === undefined$1) {
501
- // A .throw or .return when the delegate iterator has no .throw
502
- // method always terminates the yield* loop.
503
- context.delegate = null;
504
-
505
- if (context.method === "throw") {
506
- // Note: ["return"] must be used for ES3 parsing compatibility.
507
- if (delegate.iterator["return"]) {
508
- // If the delegate iterator has a return method, give it a
509
- // chance to clean up.
510
- context.method = "return";
511
- context.arg = undefined$1;
512
- maybeInvokeDelegate(delegate, context);
513
-
514
- if (context.method === "throw") {
515
- // If maybeInvokeDelegate(context) changed context.method from
516
- // "return" to "throw", let that override the TypeError below.
517
- return ContinueSentinel;
518
- }
519
- }
520
171
 
521
- context.method = "throw";
522
- context.arg = new TypeError(
523
- "The iterator does not provide a 'throw' method");
172
+ if (undefined === method) {
173
+ if (context.delegate = null, "throw" === context.method) {
174
+ if (delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method)) return ContinueSentinel;
175
+ context.method = "throw", context.arg = new TypeError("The iterator does not provide a 'throw' method");
524
176
  }
525
177
 
526
178
  return ContinueSentinel;
527
179
  }
528
180
 
529
181
  var record = tryCatch(method, delegate.iterator, context.arg);
530
-
531
- if (record.type === "throw") {
532
- context.method = "throw";
533
- context.arg = record.arg;
534
- context.delegate = null;
535
- return ContinueSentinel;
536
- }
537
-
182
+ if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
538
183
  var info = record.arg;
539
-
540
- if (! info) {
541
- context.method = "throw";
542
- context.arg = new TypeError("iterator result is not an object");
543
- context.delegate = null;
544
- return ContinueSentinel;
545
- }
546
-
547
- if (info.done) {
548
- // Assign the result of the finished delegate to the temporary
549
- // variable specified by delegate.resultName (see delegateYield).
550
- context[delegate.resultName] = info.value;
551
-
552
- // Resume execution at the desired location (see delegateYield).
553
- context.next = delegate.nextLoc;
554
-
555
- // If context.method was "throw" but the delegate handled the
556
- // exception, let the outer generator proceed normally. If
557
- // context.method was "next", forget context.arg since it has been
558
- // "consumed" by the delegate iterator. If context.method was
559
- // "return", allow the original .return call to continue in the
560
- // outer generator.
561
- if (context.method !== "return") {
562
- context.method = "next";
563
- context.arg = undefined$1;
564
- }
565
-
566
- } else {
567
- // Re-yield the result returned by the delegate method.
568
- return info;
569
- }
570
-
571
- // The delegate iterator is finished, so forget it and continue with
572
- // the outer generator.
573
- context.delegate = null;
574
- return ContinueSentinel;
184
+ return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
575
185
  }
576
186
 
577
- // Define Generator.prototype.{next,throw,return} in terms of the
578
- // unified ._invoke helper method.
579
- defineIteratorMethods(Gp);
580
-
581
- define(Gp, toStringTagSymbol, "Generator");
582
-
583
- // A Generator should always return itself as the iterator object when the
584
- // @@iterator function is called on it. Some browsers' implementations of the
585
- // iterator prototype chain incorrectly implement this, causing the Generator
586
- // object to not be returned from this call. This ensures that doesn't happen.
587
- // See https://github.com/facebook/regenerator/issues/274 for more details.
588
- define(Gp, iteratorSymbol, function() {
589
- return this;
590
- });
591
-
592
- define(Gp, "toString", function() {
593
- return "[object Generator]";
594
- });
595
-
596
187
  function pushTryEntry(locs) {
597
- var entry = { tryLoc: locs[0] };
598
-
599
- if (1 in locs) {
600
- entry.catchLoc = locs[1];
601
- }
602
-
603
- if (2 in locs) {
604
- entry.finallyLoc = locs[2];
605
- entry.afterLoc = locs[3];
606
- }
607
-
608
- this.tryEntries.push(entry);
188
+ var entry = {
189
+ tryLoc: locs[0]
190
+ };
191
+ 1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
609
192
  }
610
193
 
611
194
  function resetTryEntry(entry) {
612
195
  var record = entry.completion || {};
613
- record.type = "normal";
614
- delete record.arg;
615
- entry.completion = record;
196
+ record.type = "normal", delete record.arg, entry.completion = record;
616
197
  }
617
198
 
618
199
  function Context(tryLocsList) {
619
- // The root entry object (effectively a try statement without a catch
620
- // or a finally block) gives us a place to store values thrown from
621
- // locations where there is no enclosing try statement.
622
- this.tryEntries = [{ tryLoc: "root" }];
623
- tryLocsList.forEach(pushTryEntry, this);
624
- this.reset(true);
200
+ this.tryEntries = [{
201
+ tryLoc: "root"
202
+ }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
625
203
  }
626
204
 
627
- exports.keys = function(object) {
628
- var keys = [];
629
- for (var key in object) {
630
- keys.push(key);
631
- }
632
- keys.reverse();
633
-
634
- // Rather than returning an object with a next method, we keep
635
- // things simple and return the next function itself.
636
- return function next() {
637
- while (keys.length) {
638
- var key = keys.pop();
639
- if (key in object) {
640
- next.value = key;
641
- next.done = false;
642
- return next;
643
- }
644
- }
645
-
646
- // To avoid creating an additional object, we just hang the .value
647
- // and .done properties off the next function object itself. This
648
- // also ensures that the minifier will not anonymize the function.
649
- next.done = true;
650
- return next;
651
- };
652
- };
653
-
654
205
  function values(iterable) {
655
206
  if (iterable) {
656
207
  var iteratorMethod = iterable[iteratorSymbol];
657
- if (iteratorMethod) {
658
- return iteratorMethod.call(iterable);
659
- }
660
-
661
- if (typeof iterable.next === "function") {
662
- return iterable;
663
- }
208
+ if (iteratorMethod) return iteratorMethod.call(iterable);
209
+ if ("function" == typeof iterable.next) return iterable;
664
210
 
665
211
  if (!isNaN(iterable.length)) {
666
- var i = -1, next = function next() {
667
- while (++i < iterable.length) {
668
- if (hasOwn.call(iterable, i)) {
669
- next.value = iterable[i];
670
- next.done = false;
671
- return next;
672
- }
673
- }
674
-
675
- next.value = undefined$1;
676
- next.done = true;
212
+ var i = -1,
213
+ next = function next() {
214
+ for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
677
215
 
678
- return next;
216
+ return next.value = undefined, next.done = !0, next;
679
217
  };
680
218
 
681
219
  return next.next = next;
682
220
  }
683
221
  }
684
222
 
685
- // Return an iterator with no values.
686
- return { next: doneResult };
223
+ return {
224
+ next: doneResult
225
+ };
687
226
  }
688
- exports.values = values;
689
227
 
690
228
  function doneResult() {
691
- return { value: undefined$1, done: true };
229
+ return {
230
+ value: undefined,
231
+ done: !0
232
+ };
692
233
  }
693
234
 
694
- Context.prototype = {
695
- constructor: Context,
696
-
697
- reset: function(skipTempReset) {
698
- this.prev = 0;
699
- this.next = 0;
700
- // Resetting context._sent for legacy support of Babel's
701
- // function.sent implementation.
702
- this.sent = this._sent = undefined$1;
703
- this.done = false;
704
- this.delegate = null;
705
-
706
- this.method = "next";
707
- this.arg = undefined$1;
708
-
709
- this.tryEntries.forEach(resetTryEntry);
710
-
711
- if (!skipTempReset) {
712
- for (var name in this) {
713
- // Not sure about the optimal order of these conditions:
714
- if (name.charAt(0) === "t" &&
715
- hasOwn.call(this, name) &&
716
- !isNaN(+name.slice(1))) {
717
- this[name] = undefined$1;
718
- }
719
- }
720
- }
721
- },
235
+ return GeneratorFunction.prototype = GeneratorFunctionPrototype, define(Gp, "constructor", GeneratorFunctionPrototype), define(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
236
+ var ctor = "function" == typeof genFun && genFun.constructor;
237
+ return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
238
+ }, exports.mark = function (genFun) {
239
+ return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
240
+ }, exports.awrap = function (arg) {
241
+ return {
242
+ __await: arg
243
+ };
244
+ }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
245
+ return this;
246
+ }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
247
+ void 0 === PromiseImpl && (PromiseImpl = Promise);
248
+ var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
249
+ return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
250
+ return result.done ? result.value : iter.next();
251
+ });
252
+ }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
253
+ return this;
254
+ }), define(Gp, "toString", function () {
255
+ return "[object Generator]";
256
+ }), exports.keys = function (object) {
257
+ var keys = [];
722
258
 
723
- stop: function() {
724
- this.done = true;
259
+ for (var key in object) keys.push(key);
725
260
 
726
- var rootEntry = this.tryEntries[0];
727
- var rootRecord = rootEntry.completion;
728
- if (rootRecord.type === "throw") {
729
- throw rootRecord.arg;
261
+ return keys.reverse(), function next() {
262
+ for (; keys.length;) {
263
+ var key = keys.pop();
264
+ if (key in object) return next.value = key, next.done = !1, next;
730
265
  }
731
266
 
267
+ return next.done = !0, next;
268
+ };
269
+ }, exports.values = values, Context.prototype = {
270
+ constructor: Context,
271
+ reset: function (skipTempReset) {
272
+ if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
273
+ },
274
+ stop: function () {
275
+ this.done = !0;
276
+ var rootRecord = this.tryEntries[0].completion;
277
+ if ("throw" === rootRecord.type) throw rootRecord.arg;
732
278
  return this.rval;
733
279
  },
734
-
735
- dispatchException: function(exception) {
736
- if (this.done) {
737
- throw exception;
738
- }
739
-
280
+ dispatchException: function (exception) {
281
+ if (this.done) throw exception;
740
282
  var context = this;
741
- function handle(loc, caught) {
742
- record.type = "throw";
743
- record.arg = exception;
744
- context.next = loc;
745
-
746
- if (caught) {
747
- // If the dispatched exception was caught by a catch block,
748
- // then let that catch block handle the exception normally.
749
- context.method = "next";
750
- context.arg = undefined$1;
751
- }
752
283
 
753
- return !! caught;
284
+ function handle(loc, caught) {
285
+ return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
754
286
  }
755
287
 
756
288
  for (var i = this.tryEntries.length - 1; i >= 0; --i) {
757
- var entry = this.tryEntries[i];
758
- var record = entry.completion;
759
-
760
- if (entry.tryLoc === "root") {
761
- // Exception thrown outside of any try block that could handle
762
- // it, so set the completion value of the entire function to
763
- // throw the exception.
764
- return handle("end");
765
- }
289
+ var entry = this.tryEntries[i],
290
+ record = entry.completion;
291
+ if ("root" === entry.tryLoc) return handle("end");
766
292
 
767
293
  if (entry.tryLoc <= this.prev) {
768
- var hasCatch = hasOwn.call(entry, "catchLoc");
769
- var hasFinally = hasOwn.call(entry, "finallyLoc");
294
+ var hasCatch = hasOwn.call(entry, "catchLoc"),
295
+ hasFinally = hasOwn.call(entry, "finallyLoc");
770
296
 
771
297
  if (hasCatch && hasFinally) {
772
- if (this.prev < entry.catchLoc) {
773
- return handle(entry.catchLoc, true);
774
- } else if (this.prev < entry.finallyLoc) {
775
- return handle(entry.finallyLoc);
776
- }
777
-
298
+ if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
299
+ if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
778
300
  } else if (hasCatch) {
779
- if (this.prev < entry.catchLoc) {
780
- return handle(entry.catchLoc, true);
781
- }
782
-
783
- } else if (hasFinally) {
784
- if (this.prev < entry.finallyLoc) {
785
- return handle(entry.finallyLoc);
786
- }
787
-
301
+ if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
788
302
  } else {
789
- throw new Error("try statement without catch or finally");
303
+ if (!hasFinally) throw new Error("try statement without catch or finally");
304
+ if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
790
305
  }
791
306
  }
792
307
  }
793
308
  },
794
-
795
- abrupt: function(type, arg) {
309
+ abrupt: function (type, arg) {
796
310
  for (var i = this.tryEntries.length - 1; i >= 0; --i) {
797
311
  var entry = this.tryEntries[i];
798
- if (entry.tryLoc <= this.prev &&
799
- hasOwn.call(entry, "finallyLoc") &&
800
- this.prev < entry.finallyLoc) {
312
+
313
+ if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
801
314
  var finallyEntry = entry;
802
315
  break;
803
316
  }
804
317
  }
805
318
 
806
- if (finallyEntry &&
807
- (type === "break" ||
808
- type === "continue") &&
809
- finallyEntry.tryLoc <= arg &&
810
- arg <= finallyEntry.finallyLoc) {
811
- // Ignore the finally entry if control is not jumping to a
812
- // location outside the try/catch block.
813
- finallyEntry = null;
814
- }
815
-
319
+ finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
816
320
  var record = finallyEntry ? finallyEntry.completion : {};
817
- record.type = type;
818
- record.arg = arg;
819
-
820
- if (finallyEntry) {
821
- this.method = "next";
822
- this.next = finallyEntry.finallyLoc;
823
- return ContinueSentinel;
824
- }
825
-
826
- return this.complete(record);
321
+ return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
827
322
  },
828
-
829
- complete: function(record, afterLoc) {
830
- if (record.type === "throw") {
831
- throw record.arg;
832
- }
833
-
834
- if (record.type === "break" ||
835
- record.type === "continue") {
836
- this.next = record.arg;
837
- } else if (record.type === "return") {
838
- this.rval = this.arg = record.arg;
839
- this.method = "return";
840
- this.next = "end";
841
- } else if (record.type === "normal" && afterLoc) {
842
- this.next = afterLoc;
843
- }
844
-
845
- return ContinueSentinel;
323
+ complete: function (record, afterLoc) {
324
+ if ("throw" === record.type) throw record.arg;
325
+ return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
846
326
  },
847
-
848
- finish: function(finallyLoc) {
327
+ finish: function (finallyLoc) {
849
328
  for (var i = this.tryEntries.length - 1; i >= 0; --i) {
850
329
  var entry = this.tryEntries[i];
851
- if (entry.finallyLoc === finallyLoc) {
852
- this.complete(entry.completion, entry.afterLoc);
853
- resetTryEntry(entry);
854
- return ContinueSentinel;
855
- }
330
+ if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
856
331
  }
857
332
  },
858
-
859
- "catch": function(tryLoc) {
333
+ catch: function (tryLoc) {
860
334
  for (var i = this.tryEntries.length - 1; i >= 0; --i) {
861
335
  var entry = this.tryEntries[i];
336
+
862
337
  if (entry.tryLoc === tryLoc) {
863
338
  var record = entry.completion;
864
- if (record.type === "throw") {
339
+
340
+ if ("throw" === record.type) {
865
341
  var thrown = record.arg;
866
342
  resetTryEntry(entry);
867
343
  }
344
+
868
345
  return thrown;
869
346
  }
870
347
  }
871
348
 
872
- // The context.catch method must only be called with a location
873
- // argument that corresponds to a known catch block.
874
349
  throw new Error("illegal catch attempt");
875
350
  },
876
-
877
- delegateYield: function(iterable, resultName, nextLoc) {
878
- this.delegate = {
351
+ delegateYield: function (iterable, resultName, nextLoc) {
352
+ return this.delegate = {
879
353
  iterator: values(iterable),
880
354
  resultName: resultName,
881
355
  nextLoc: nextLoc
882
- };
356
+ }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
357
+ }
358
+ }, exports;
359
+ }
360
+
361
+ function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
362
+ try {
363
+ var info = gen[key](arg);
364
+ var value = info.value;
365
+ } catch (error) {
366
+ reject(error);
367
+ return;
368
+ }
369
+
370
+ if (info.done) {
371
+ resolve(value);
372
+ } else {
373
+ Promise.resolve(value).then(_next, _throw);
374
+ }
375
+ }
376
+
377
+ function _asyncToGenerator(fn) {
378
+ return function () {
379
+ var self = this,
380
+ args = arguments;
381
+ return new Promise(function (resolve, reject) {
382
+ var gen = fn.apply(self, args);
883
383
 
884
- if (this.method === "next") {
885
- // Deliberately forget the last sent value so that we don't
886
- // accidentally pass it on to the delegate.
887
- this.arg = undefined$1;
384
+ function _next(value) {
385
+ asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
888
386
  }
889
387
 
890
- return ContinueSentinel;
388
+ function _throw(err) {
389
+ asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
390
+ }
391
+
392
+ _next(undefined);
393
+ });
394
+ };
395
+ }
396
+
397
+ function _extends() {
398
+ _extends = Object.assign ? Object.assign.bind() : function (target) {
399
+ for (var i = 1; i < arguments.length; i++) {
400
+ var source = arguments[i];
401
+
402
+ for (var key in source) {
403
+ if (Object.prototype.hasOwnProperty.call(source, key)) {
404
+ target[key] = source[key];
405
+ }
406
+ }
891
407
  }
408
+
409
+ return target;
892
410
  };
411
+ return _extends.apply(this, arguments);
412
+ }
413
+
414
+ function _inheritsLoose(subClass, superClass) {
415
+ subClass.prototype = Object.create(superClass.prototype);
416
+ subClass.prototype.constructor = subClass;
417
+
418
+ _setPrototypeOf(subClass, superClass);
419
+ }
893
420
 
894
- // Regardless of whether this script is executing as a CommonJS module
895
- // or not, return the runtime object so that we can declare the variable
896
- // regeneratorRuntime in the outer scope, which allows this module to be
897
- // injected easily by `bin/regenerator --include-runtime script.js`.
898
- return exports;
899
-
900
- }(
901
- // If this script is executing as a CommonJS module, use module.exports
902
- // as the regeneratorRuntime namespace. Otherwise create a new empty
903
- // object. Either way, the resulting object will be used to initialize
904
- // the regeneratorRuntime variable at the top of this file.
905
- module.exports
906
- ));
907
-
908
- try {
909
- regeneratorRuntime = runtime;
910
- } catch (accidentalStrictMode) {
911
- // This module should not be running in strict mode, so the above
912
- // assignment should always work unless something is misconfigured. Just
913
- // in case runtime.js accidentally runs in strict mode, in modern engines
914
- // we can explicitly access globalThis. In older engines we can escape
915
- // strict mode using a global Function call. This could conceivably fail
916
- // if a Content Security Policy forbids using Function, but in that case
917
- // the proper solution is to fix the accidental strict mode problem. If
918
- // you've misconfigured your bundler to force strict mode and applied a
919
- // CSP to forbid Function, and you're not willing to fix either of those
920
- // problems, please detail your unique predicament in a GitHub issue.
921
- if (typeof globalThis === "object") {
922
- globalThis.regeneratorRuntime = runtime;
421
+ function _getPrototypeOf(o) {
422
+ _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
423
+ return o.__proto__ || Object.getPrototypeOf(o);
424
+ };
425
+ return _getPrototypeOf(o);
426
+ }
427
+
428
+ function _setPrototypeOf(o, p) {
429
+ _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
430
+ o.__proto__ = p;
431
+ return o;
432
+ };
433
+ return _setPrototypeOf(o, p);
434
+ }
435
+
436
+ function _isNativeReflectConstruct() {
437
+ if (typeof Reflect === "undefined" || !Reflect.construct) return false;
438
+ if (Reflect.construct.sham) return false;
439
+ if (typeof Proxy === "function") return true;
440
+
441
+ try {
442
+ Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
443
+ return true;
444
+ } catch (e) {
445
+ return false;
446
+ }
447
+ }
448
+
449
+ function _construct(Parent, args, Class) {
450
+ if (_isNativeReflectConstruct()) {
451
+ _construct = Reflect.construct.bind();
923
452
  } else {
924
- Function("r", "regeneratorRuntime = r")(runtime);
453
+ _construct = function _construct(Parent, args, Class) {
454
+ var a = [null];
455
+ a.push.apply(a, args);
456
+ var Constructor = Function.bind.apply(Parent, a);
457
+ var instance = new Constructor();
458
+ if (Class) _setPrototypeOf(instance, Class.prototype);
459
+ return instance;
460
+ };
461
+ }
462
+
463
+ return _construct.apply(null, arguments);
464
+ }
465
+
466
+ function _isNativeFunction(fn) {
467
+ return Function.toString.call(fn).indexOf("[native code]") !== -1;
468
+ }
469
+
470
+ function _wrapNativeSuper(Class) {
471
+ var _cache = typeof Map === "function" ? new Map() : undefined;
472
+
473
+ _wrapNativeSuper = function _wrapNativeSuper(Class) {
474
+ if (Class === null || !_isNativeFunction(Class)) return Class;
475
+
476
+ if (typeof Class !== "function") {
477
+ throw new TypeError("Super expression must either be null or a function");
478
+ }
479
+
480
+ if (typeof _cache !== "undefined") {
481
+ if (_cache.has(Class)) return _cache.get(Class);
482
+
483
+ _cache.set(Class, Wrapper);
484
+ }
485
+
486
+ function Wrapper() {
487
+ return _construct(Class, arguments, _getPrototypeOf(this).constructor);
488
+ }
489
+
490
+ Wrapper.prototype = Object.create(Class.prototype, {
491
+ constructor: {
492
+ value: Wrapper,
493
+ enumerable: false,
494
+ writable: true,
495
+ configurable: true
496
+ }
497
+ });
498
+ return _setPrototypeOf(Wrapper, Class);
499
+ };
500
+
501
+ return _wrapNativeSuper(Class);
502
+ }
503
+
504
+ function _assertThisInitialized(self) {
505
+ if (self === void 0) {
506
+ throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
925
507
  }
508
+
509
+ return self;
926
510
  }
927
- });
928
511
 
929
512
  var AxiosService = /*#__PURE__*/function () {
930
513
  function AxiosService(config) {
@@ -935,8 +518,8 @@ var AxiosService = /*#__PURE__*/function () {
935
518
  var _proto = AxiosService.prototype;
936
519
 
937
520
  _proto.apiRequest = /*#__PURE__*/function () {
938
- var _apiRequest = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(config, url, data) {
939
- return runtime_1.wrap(function _callee$(_context) {
521
+ var _apiRequest = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(config, url, data) {
522
+ return _regeneratorRuntime().wrap(function _callee$(_context) {
940
523
  while (1) {
941
524
  switch (_context.prev = _context.next) {
942
525
  case 0:
@@ -965,8 +548,8 @@ var AxiosService = /*#__PURE__*/function () {
965
548
  }();
966
549
 
967
550
  _proto.apiRequestHeader = /*#__PURE__*/function () {
968
- var _apiRequestHeader = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(config, url, headerToRetrieve, data) {
969
- return runtime_1.wrap(function _callee2$(_context2) {
551
+ var _apiRequestHeader = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(config, url, headerToRetrieve, data) {
552
+ return _regeneratorRuntime().wrap(function _callee2$(_context2) {
970
553
  while (1) {
971
554
  switch (_context2.prev = _context2.next) {
972
555
  case 0:
@@ -1069,9 +652,9 @@ var APIService = /*#__PURE__*/function (_AxiosService) {
1069
652
  });
1070
653
 
1071
654
  createAuthRefreshInterceptor(_this.axios, /*#__PURE__*/function () {
1072
- var _ref = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(failedRequest) {
655
+ var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(failedRequest) {
1073
656
  var tokenResp;
1074
- return runtime_1.wrap(function _callee$(_context) {
657
+ return _regeneratorRuntime().wrap(function _callee$(_context) {
1075
658
  while (1) {
1076
659
  switch (_context.prev = _context.next) {
1077
660
  case 0:
@@ -1187,11 +770,11 @@ var ApisPracticeManager = /*#__PURE__*/function () {
1187
770
  _proto.get =
1188
771
  /*#__PURE__*/
1189
772
  function () {
1190
- var _get = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(practiceUuid) {
773
+ var _get = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(practiceUuid) {
1191
774
  var _this = this;
1192
775
 
1193
776
  var practiceInstance, newPracticeInstance, authTokenFunc;
1194
- return runtime_1.wrap(function _callee2$(_context2) {
777
+ return _regeneratorRuntime().wrap(function _callee2$(_context2) {
1195
778
  while (1) {
1196
779
  switch (_context2.prev = _context2.next) {
1197
780
  case 0:
@@ -1208,8 +791,8 @@ var ApisPracticeManager = /*#__PURE__*/function () {
1208
791
  newPracticeInstance = init(this.serviceCollReq, undefined, this.useLocalStorage); // Create one auth token callback per practice since the practice uuid needs to change
1209
792
 
1210
793
  authTokenFunc = /*#__PURE__*/function () {
1211
- var _ref = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee() {
1212
- return runtime_1.wrap(function _callee$(_context) {
794
+ var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
795
+ return _regeneratorRuntime().wrap(function _callee$(_context) {
1213
796
  while (1) {
1214
797
  switch (_context.prev = _context.next) {
1215
798
  case 0:
@@ -1984,9 +1567,9 @@ var DiagnosisService = /*#__PURE__*/function () {
1984
1567
  _proto.getAllDrugs =
1985
1568
  /*#__PURE__*/
1986
1569
  function () {
1987
- var _getAllDrugs = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(uuidPractice) {
1570
+ var _getAllDrugs = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(uuidPractice) {
1988
1571
  var res;
1989
- return runtime_1.wrap(function _callee$(_context) {
1572
+ return _regeneratorRuntime().wrap(function _callee$(_context) {
1990
1573
  while (1) {
1991
1574
  switch (_context.prev = _context.next) {
1992
1575
  case 0:
@@ -2062,10 +1645,10 @@ var GuardService = /*#__PURE__*/function () {
2062
1645
  _proto.m2mToken =
2063
1646
  /*#__PURE__*/
2064
1647
  function () {
2065
- var _m2mToken = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(req) {
1648
+ var _m2mToken = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(req) {
2066
1649
  var resp, config, _e$response, code;
2067
1650
 
2068
- return runtime_1.wrap(function _callee$(_context) {
1651
+ return _regeneratorRuntime().wrap(function _callee$(_context) {
2069
1652
  while (1) {
2070
1653
  switch (_context.prev = _context.next) {
2071
1654
  case 0:
@@ -2140,10 +1723,10 @@ var GuardService = /*#__PURE__*/function () {
2140
1723
  _proto.authToken =
2141
1724
  /*#__PURE__*/
2142
1725
  function () {
2143
- var _authToken = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(req) {
1726
+ var _authToken = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(req) {
2144
1727
  var resp, config, _e$response2, code;
2145
1728
 
2146
- return runtime_1.wrap(function _callee2$(_context2) {
1729
+ return _regeneratorRuntime().wrap(function _callee2$(_context2) {
2147
1730
  while (1) {
2148
1731
  switch (_context2.prev = _context2.next) {
2149
1732
  case 0:
@@ -2220,9 +1803,9 @@ var GuardService = /*#__PURE__*/function () {
2220
1803
  _proto.authRefresh =
2221
1804
  /*#__PURE__*/
2222
1805
  function () {
2223
- var _authRefresh = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(refreshToken) {
1806
+ var _authRefresh = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(refreshToken) {
2224
1807
  var config;
2225
- return runtime_1.wrap(function _callee3$(_context3) {
1808
+ return _regeneratorRuntime().wrap(function _callee3$(_context3) {
2226
1809
  while (1) {
2227
1810
  switch (_context3.prev = _context3.next) {
2228
1811
  case 0:
@@ -2256,8 +1839,8 @@ var GuardService = /*#__PURE__*/function () {
2256
1839
  _proto.authLogout =
2257
1840
  /*#__PURE__*/
2258
1841
  function () {
2259
- var _authLogout = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4() {
2260
- return runtime_1.wrap(function _callee4$(_context4) {
1842
+ var _authLogout = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4() {
1843
+ return _regeneratorRuntime().wrap(function _callee4$(_context4) {
2261
1844
  while (1) {
2262
1845
  switch (_context4.prev = _context4.next) {
2263
1846
  case 0:
@@ -2288,8 +1871,8 @@ var GuardService = /*#__PURE__*/function () {
2288
1871
  _proto.authRecover =
2289
1872
  /*#__PURE__*/
2290
1873
  function () {
2291
- var _authRecover = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(req) {
2292
- return runtime_1.wrap(function _callee5$(_context5) {
1874
+ var _authRecover = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(req) {
1875
+ return _regeneratorRuntime().wrap(function _callee5$(_context5) {
2293
1876
  while (1) {
2294
1877
  switch (_context5.prev = _context5.next) {
2295
1878
  case 0:
@@ -2321,10 +1904,10 @@ var GuardService = /*#__PURE__*/function () {
2321
1904
  _proto.identityCreate =
2322
1905
  /*#__PURE__*/
2323
1906
  function () {
2324
- var _identityCreate = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee6(req) {
1907
+ var _identityCreate = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(req) {
2325
1908
  var resp, _e$response3, code;
2326
1909
 
2327
- return runtime_1.wrap(function _callee6$(_context6) {
1910
+ return _regeneratorRuntime().wrap(function _callee6$(_context6) {
2328
1911
  while (1) {
2329
1912
  switch (_context6.prev = _context6.next) {
2330
1913
  case 0:
@@ -2396,11 +1979,11 @@ var GuardService = /*#__PURE__*/function () {
2396
1979
  _proto.identityGet =
2397
1980
  /*#__PURE__*/
2398
1981
  function () {
2399
- var _identityGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee7(identityID, skipCache) {
1982
+ var _identityGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(identityID, skipCache) {
2400
1983
  var _tokens$accessToken, _tokens$refreshToken;
2401
1984
 
2402
1985
  var tokens, cacheKey, identity;
2403
- return runtime_1.wrap(function _callee7$(_context7) {
1986
+ return _regeneratorRuntime().wrap(function _callee7$(_context7) {
2404
1987
  while (1) {
2405
1988
  switch (_context7.prev = _context7.next) {
2406
1989
  case 0:
@@ -2460,11 +2043,11 @@ var GuardService = /*#__PURE__*/function () {
2460
2043
  _proto.whoAmI =
2461
2044
  /*#__PURE__*/
2462
2045
  function () {
2463
- var _whoAmI = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee8(refreshCache) {
2046
+ var _whoAmI = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8(refreshCache) {
2464
2047
  var _this$api$getTokens$a;
2465
2048
 
2466
2049
  var cacheKey;
2467
- return runtime_1.wrap(function _callee8$(_context8) {
2050
+ return _regeneratorRuntime().wrap(function _callee8$(_context8) {
2468
2051
  while (1) {
2469
2052
  switch (_context8.prev = _context8.next) {
2470
2053
  case 0:
@@ -2514,8 +2097,8 @@ var GuardService = /*#__PURE__*/function () {
2514
2097
  _proto.identityUpdate =
2515
2098
  /*#__PURE__*/
2516
2099
  function () {
2517
- var _identityUpdate = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee9(identityID, req) {
2518
- return runtime_1.wrap(function _callee9$(_context9) {
2100
+ var _identityUpdate = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9(identityID, req) {
2101
+ return _regeneratorRuntime().wrap(function _callee9$(_context9) {
2519
2102
  while (1) {
2520
2103
  switch (_context9.prev = _context9.next) {
2521
2104
  case 0:
@@ -2548,9 +2131,9 @@ var GuardService = /*#__PURE__*/function () {
2548
2131
  _proto.identityMFAQRCode =
2549
2132
  /*#__PURE__*/
2550
2133
  function () {
2551
- var _identityMFAQRCode = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee10(identityID, password) {
2134
+ var _identityMFAQRCode = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10(identityID, password) {
2552
2135
  var req;
2553
- return runtime_1.wrap(function _callee10$(_context10) {
2136
+ return _regeneratorRuntime().wrap(function _callee10$(_context10) {
2554
2137
  while (1) {
2555
2138
  switch (_context10.prev = _context10.next) {
2556
2139
  case 0:
@@ -2588,8 +2171,8 @@ var GuardService = /*#__PURE__*/function () {
2588
2171
  _proto.identitySendConfirmEmail =
2589
2172
  /*#__PURE__*/
2590
2173
  function () {
2591
- var _identitySendConfirmEmail = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee11(req) {
2592
- return runtime_1.wrap(function _callee11$(_context11) {
2174
+ var _identitySendConfirmEmail = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee11(req) {
2175
+ return _regeneratorRuntime().wrap(function _callee11$(_context11) {
2593
2176
  while (1) {
2594
2177
  switch (_context11.prev = _context11.next) {
2595
2178
  case 0:
@@ -2620,8 +2203,8 @@ var GuardService = /*#__PURE__*/function () {
2620
2203
  _proto.identityGetByCustomerEmail =
2621
2204
  /*#__PURE__*/
2622
2205
  function () {
2623
- var _identityGetByCustomerEmail = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee12(email) {
2624
- return runtime_1.wrap(function _callee12$(_context12) {
2206
+ var _identityGetByCustomerEmail = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee12(email) {
2207
+ return _regeneratorRuntime().wrap(function _callee12$(_context12) {
2625
2208
  while (1) {
2626
2209
  switch (_context12.prev = _context12.next) {
2627
2210
  case 0:
@@ -2652,8 +2235,8 @@ var GuardService = /*#__PURE__*/function () {
2652
2235
  _proto.identityGetByHash =
2653
2236
  /*#__PURE__*/
2654
2237
  function () {
2655
- var _identityGetByHash = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee13(b64Hash) {
2656
- return runtime_1.wrap(function _callee13$(_context13) {
2238
+ var _identityGetByHash = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee13(b64Hash) {
2239
+ return _regeneratorRuntime().wrap(function _callee13$(_context13) {
2657
2240
  while (1) {
2658
2241
  switch (_context13.prev = _context13.next) {
2659
2242
  case 0:
@@ -3056,8 +2639,8 @@ var TellerService = /*#__PURE__*/function () {
3056
2639
  var _proto = TellerService.prototype;
3057
2640
 
3058
2641
  _proto.lockboxDataStore = /*#__PURE__*/function () {
3059
- var _lockboxDataStore = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(lockboxUuid, req, lockboxOwnerUuid, previousDataUuid) {
3060
- return runtime_1.wrap(function _callee$(_context) {
2642
+ var _lockboxDataStore = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(lockboxUuid, req, lockboxOwnerUuid, previousDataUuid) {
2643
+ return _regeneratorRuntime().wrap(function _callee$(_context) {
3061
2644
  while (1) {
3062
2645
  switch (_context.prev = _context.next) {
3063
2646
  case 0:
@@ -3165,8 +2748,8 @@ var VaultService = /*#__PURE__*/function () {
3165
2748
  var _proto = VaultService.prototype;
3166
2749
 
3167
2750
  _proto.lockboxCreate = /*#__PURE__*/function () {
3168
- var _lockboxCreate = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(lockboxMetadata) {
3169
- return runtime_1.wrap(function _callee$(_context) {
2751
+ var _lockboxCreate = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(lockboxMetadata) {
2752
+ return _regeneratorRuntime().wrap(function _callee$(_context) {
3170
2753
  while (1) {
3171
2754
  switch (_context.prev = _context.next) {
3172
2755
  case 0:
@@ -3188,8 +2771,8 @@ var VaultService = /*#__PURE__*/function () {
3188
2771
  }();
3189
2772
 
3190
2773
  _proto.lockboxMetadataAdd = /*#__PURE__*/function () {
3191
- var _lockboxMetadataAdd = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(lockboxUuid, lockboxMetadata, lockboxOwnerUuid) {
3192
- return runtime_1.wrap(function _callee2$(_context2) {
2774
+ var _lockboxMetadataAdd = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(lockboxUuid, lockboxMetadata, lockboxOwnerUuid) {
2775
+ return _regeneratorRuntime().wrap(function _callee2$(_context2) {
3193
2776
  while (1) {
3194
2777
  switch (_context2.prev = _context2.next) {
3195
2778
  case 0:
@@ -3215,8 +2798,8 @@ var VaultService = /*#__PURE__*/function () {
3215
2798
  }();
3216
2799
 
3217
2800
  _proto.lockboxSecretGet = /*#__PURE__*/function () {
3218
- var _lockboxSecretGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(lockboxUuid, lockboxOwnerUuid) {
3219
- return runtime_1.wrap(function _callee3$(_context3) {
2801
+ var _lockboxSecretGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(lockboxUuid, lockboxOwnerUuid) {
2802
+ return _regeneratorRuntime().wrap(function _callee3$(_context3) {
3220
2803
  while (1) {
3221
2804
  switch (_context3.prev = _context3.next) {
3222
2805
  case 0:
@@ -3242,8 +2825,8 @@ var VaultService = /*#__PURE__*/function () {
3242
2825
  }();
3243
2826
 
3244
2827
  _proto.lockboxGrant = /*#__PURE__*/function () {
3245
- var _lockboxGrant = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(lockboxUuid, req, lockboxOwnerUuid) {
3246
- return runtime_1.wrap(function _callee4$(_context4) {
2828
+ var _lockboxGrant = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(lockboxUuid, req, lockboxOwnerUuid) {
2829
+ return _regeneratorRuntime().wrap(function _callee4$(_context4) {
3247
2830
  while (1) {
3248
2831
  switch (_context4.prev = _context4.next) {
3249
2832
  case 0:
@@ -3277,8 +2860,8 @@ var VaultService = /*#__PURE__*/function () {
3277
2860
  _proto.grantsGet =
3278
2861
  /*#__PURE__*/
3279
2862
  function () {
3280
- var _grantsGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5() {
3281
- return runtime_1.wrap(function _callee5$(_context5) {
2863
+ var _grantsGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5() {
2864
+ return _regeneratorRuntime().wrap(function _callee5$(_context5) {
3282
2865
  while (1) {
3283
2866
  switch (_context5.prev = _context5.next) {
3284
2867
  case 0:
@@ -3313,8 +2896,8 @@ var VaultService = /*#__PURE__*/function () {
3313
2896
  _proto.lockboxDataStore =
3314
2897
  /*#__PURE__*/
3315
2898
  function () {
3316
- var _lockboxDataStore = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee6(lockboxUuid, req, lockboxOwnerUuid, previousDataUuid) {
3317
- return runtime_1.wrap(function _callee6$(_context6) {
2899
+ var _lockboxDataStore = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(lockboxUuid, req, lockboxOwnerUuid, previousDataUuid) {
2900
+ return _regeneratorRuntime().wrap(function _callee6$(_context6) {
3318
2901
  while (1) {
3319
2902
  switch (_context6.prev = _context6.next) {
3320
2903
  case 0:
@@ -3341,9 +2924,9 @@ var VaultService = /*#__PURE__*/function () {
3341
2924
  }();
3342
2925
 
3343
2926
  _proto.lockboxDataGet = /*#__PURE__*/function () {
3344
- var _lockboxDataGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee7(lockboxUuid, dataUuid, lockboxOwnerUuid, stream) {
2927
+ var _lockboxDataGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(lockboxUuid, dataUuid, lockboxOwnerUuid, stream) {
3345
2928
  var data;
3346
- return runtime_1.wrap(function _callee7$(_context7) {
2929
+ return _regeneratorRuntime().wrap(function _callee7$(_context7) {
3347
2930
  while (1) {
3348
2931
  switch (_context7.prev = _context7.next) {
3349
2932
  case 0:
@@ -3390,8 +2973,8 @@ var VaultService = /*#__PURE__*/function () {
3390
2973
  }();
3391
2974
 
3392
2975
  _proto.lockboxManifestGet = /*#__PURE__*/function () {
3393
- var _lockboxManifestGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee8(lockboxUuid, filter, lockboxOwnerUuid) {
3394
- return runtime_1.wrap(function _callee8$(_context8) {
2976
+ var _lockboxManifestGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8(lockboxUuid, filter, lockboxOwnerUuid) {
2977
+ return _regeneratorRuntime().wrap(function _callee8$(_context8) {
3395
2978
  while (1) {
3396
2979
  switch (_context8.prev = _context8.next) {
3397
2980
  case 0:
@@ -3418,8 +3001,8 @@ var VaultService = /*#__PURE__*/function () {
3418
3001
  }();
3419
3002
 
3420
3003
  _proto.lockboxMetadataGet = /*#__PURE__*/function () {
3421
- var _lockboxMetadataGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee9(lockboxUuid, fields, groupby, filter, lockboxOwnerUuid) {
3422
- return runtime_1.wrap(function _callee9$(_context9) {
3004
+ var _lockboxMetadataGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9(lockboxUuid, fields, groupby, filter, lockboxOwnerUuid) {
3005
+ return _regeneratorRuntime().wrap(function _callee9$(_context9) {
3423
3006
  while (1) {
3424
3007
  switch (_context9.prev = _context9.next) {
3425
3008
  case 0:
@@ -3458,8 +3041,8 @@ var VaultService = /*#__PURE__*/function () {
3458
3041
  _proto.vaultIndexPut =
3459
3042
  /*#__PURE__*/
3460
3043
  function () {
3461
- var _vaultIndexPut = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee10(entries, indexOwnerUuid) {
3462
- return runtime_1.wrap(function _callee10$(_context10) {
3044
+ var _vaultIndexPut = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10(entries, indexOwnerUuid) {
3045
+ return _regeneratorRuntime().wrap(function _callee10$(_context10) {
3463
3046
  while (1) {
3464
3047
  switch (_context10.prev = _context10.next) {
3465
3048
  case 0:
@@ -3493,8 +3076,8 @@ var VaultService = /*#__PURE__*/function () {
3493
3076
  _proto.vaultIndexSnapshotPut =
3494
3077
  /*#__PURE__*/
3495
3078
  function () {
3496
- var _vaultIndexSnapshotPut = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee11(entry) {
3497
- return runtime_1.wrap(function _callee11$(_context11) {
3079
+ var _vaultIndexSnapshotPut = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee11(entry) {
3080
+ return _regeneratorRuntime().wrap(function _callee11$(_context11) {
3498
3081
  while (1) {
3499
3082
  switch (_context11.prev = _context11.next) {
3500
3083
  case 0:
@@ -3527,8 +3110,8 @@ var VaultService = /*#__PURE__*/function () {
3527
3110
  _proto.vaultIndexGet =
3528
3111
  /*#__PURE__*/
3529
3112
  function () {
3530
- var _vaultIndexGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee12(indexKeys, identifiers, timestamp) {
3531
- return runtime_1.wrap(function _callee12$(_context12) {
3113
+ var _vaultIndexGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee12(indexKeys, identifiers, timestamp) {
3114
+ return _regeneratorRuntime().wrap(function _callee12$(_context12) {
3532
3115
  while (1) {
3533
3116
  switch (_context12.prev = _context12.next) {
3534
3117
  case 0: