oro-sdk 2.27.0-dev3 → 2.29.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.
@@ -5,351 +5,6 @@ import * as oroToolbox from 'oro-toolbox';
5
5
  export { oroToolbox as OroToolboxNamespace };
6
6
  import { getMany } from 'idb-keyval';
7
7
 
8
- function _regeneratorRuntime() {
9
- /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
10
-
11
- _regeneratorRuntime = function () {
12
- return exports;
13
- };
14
-
15
- var exports = {},
16
- Op = Object.prototype,
17
- hasOwn = Op.hasOwnProperty,
18
- $Symbol = "function" == typeof Symbol ? Symbol : {},
19
- iteratorSymbol = $Symbol.iterator || "@@iterator",
20
- asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
21
- toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
22
-
23
- function define(obj, key, value) {
24
- return Object.defineProperty(obj, key, {
25
- value: value,
26
- enumerable: !0,
27
- configurable: !0,
28
- writable: !0
29
- }), obj[key];
30
- }
31
-
32
- try {
33
- define({}, "");
34
- } catch (err) {
35
- define = function (obj, key, value) {
36
- return obj[key] = value;
37
- };
38
- }
39
-
40
- function wrap(innerFn, outerFn, self, tryLocsList) {
41
- var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
42
- generator = Object.create(protoGenerator.prototype),
43
- context = new Context(tryLocsList || []);
44
- return generator._invoke = function (innerFn, self, context) {
45
- var state = "suspendedStart";
46
- return function (method, arg) {
47
- if ("executing" === state) throw new Error("Generator is already running");
48
-
49
- if ("completed" === state) {
50
- if ("throw" === method) throw arg;
51
- return doneResult();
52
- }
53
-
54
- for (context.method = method, context.arg = arg;;) {
55
- var delegate = context.delegate;
56
-
57
- if (delegate) {
58
- var delegateResult = maybeInvokeDelegate(delegate, context);
59
-
60
- if (delegateResult) {
61
- if (delegateResult === ContinueSentinel) continue;
62
- return delegateResult;
63
- }
64
- }
65
-
66
- if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
67
- if ("suspendedStart" === state) throw state = "completed", context.arg;
68
- context.dispatchException(context.arg);
69
- } else "return" === context.method && context.abrupt("return", context.arg);
70
- state = "executing";
71
- var record = tryCatch(innerFn, self, context);
72
-
73
- if ("normal" === record.type) {
74
- if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
75
- return {
76
- value: record.arg,
77
- done: context.done
78
- };
79
- }
80
-
81
- "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
82
- }
83
- };
84
- }(innerFn, self, context), generator;
85
- }
86
-
87
- function tryCatch(fn, obj, arg) {
88
- try {
89
- return {
90
- type: "normal",
91
- arg: fn.call(obj, arg)
92
- };
93
- } catch (err) {
94
- return {
95
- type: "throw",
96
- arg: err
97
- };
98
- }
99
- }
100
-
101
- exports.wrap = wrap;
102
- var ContinueSentinel = {};
103
-
104
- function Generator() {}
105
-
106
- function GeneratorFunction() {}
107
-
108
- function GeneratorFunctionPrototype() {}
109
-
110
- var IteratorPrototype = {};
111
- define(IteratorPrototype, iteratorSymbol, function () {
112
- return this;
113
- });
114
- var getProto = Object.getPrototypeOf,
115
- NativeIteratorPrototype = getProto && getProto(getProto(values([])));
116
- NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
117
- var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
118
-
119
- function defineIteratorMethods(prototype) {
120
- ["next", "throw", "return"].forEach(function (method) {
121
- define(prototype, method, function (arg) {
122
- return this._invoke(method, arg);
123
- });
124
- });
125
- }
126
-
127
- function AsyncIterator(generator, PromiseImpl) {
128
- function invoke(method, arg, resolve, reject) {
129
- var record = tryCatch(generator[method], generator, arg);
130
-
131
- if ("throw" !== record.type) {
132
- var result = record.arg,
133
- value = result.value;
134
- return value && "object" == typeof value && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
135
- invoke("next", value, resolve, reject);
136
- }, function (err) {
137
- invoke("throw", err, resolve, reject);
138
- }) : PromiseImpl.resolve(value).then(function (unwrapped) {
139
- result.value = unwrapped, resolve(result);
140
- }, function (error) {
141
- return invoke("throw", error, resolve, reject);
142
- });
143
- }
144
-
145
- reject(record.arg);
146
- }
147
-
148
- var previousPromise;
149
-
150
- this._invoke = function (method, arg) {
151
- function callInvokeWithMethodAndArg() {
152
- return new PromiseImpl(function (resolve, reject) {
153
- invoke(method, arg, resolve, reject);
154
- });
155
- }
156
-
157
- return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
158
- };
159
- }
160
-
161
- function maybeInvokeDelegate(delegate, context) {
162
- var method = delegate.iterator[context.method];
163
-
164
- if (undefined === method) {
165
- if (context.delegate = null, "throw" === context.method) {
166
- if (delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method)) return ContinueSentinel;
167
- context.method = "throw", context.arg = new TypeError("The iterator does not provide a 'throw' method");
168
- }
169
-
170
- return ContinueSentinel;
171
- }
172
-
173
- var record = tryCatch(method, delegate.iterator, context.arg);
174
- if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
175
- var info = record.arg;
176
- 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);
177
- }
178
-
179
- function pushTryEntry(locs) {
180
- var entry = {
181
- tryLoc: locs[0]
182
- };
183
- 1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
184
- }
185
-
186
- function resetTryEntry(entry) {
187
- var record = entry.completion || {};
188
- record.type = "normal", delete record.arg, entry.completion = record;
189
- }
190
-
191
- function Context(tryLocsList) {
192
- this.tryEntries = [{
193
- tryLoc: "root"
194
- }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
195
- }
196
-
197
- function values(iterable) {
198
- if (iterable) {
199
- var iteratorMethod = iterable[iteratorSymbol];
200
- if (iteratorMethod) return iteratorMethod.call(iterable);
201
- if ("function" == typeof iterable.next) return iterable;
202
-
203
- if (!isNaN(iterable.length)) {
204
- var i = -1,
205
- next = function next() {
206
- for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
207
-
208
- return next.value = undefined, next.done = !0, next;
209
- };
210
-
211
- return next.next = next;
212
- }
213
- }
214
-
215
- return {
216
- next: doneResult
217
- };
218
- }
219
-
220
- function doneResult() {
221
- return {
222
- value: undefined,
223
- done: !0
224
- };
225
- }
226
-
227
- return GeneratorFunction.prototype = GeneratorFunctionPrototype, define(Gp, "constructor", GeneratorFunctionPrototype), define(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
228
- var ctor = "function" == typeof genFun && genFun.constructor;
229
- return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
230
- }, exports.mark = function (genFun) {
231
- return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
232
- }, exports.awrap = function (arg) {
233
- return {
234
- __await: arg
235
- };
236
- }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
237
- return this;
238
- }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
239
- void 0 === PromiseImpl && (PromiseImpl = Promise);
240
- var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
241
- return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
242
- return result.done ? result.value : iter.next();
243
- });
244
- }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
245
- return this;
246
- }), define(Gp, "toString", function () {
247
- return "[object Generator]";
248
- }), exports.keys = function (object) {
249
- var keys = [];
250
-
251
- for (var key in object) keys.push(key);
252
-
253
- return keys.reverse(), function next() {
254
- for (; keys.length;) {
255
- var key = keys.pop();
256
- if (key in object) return next.value = key, next.done = !1, next;
257
- }
258
-
259
- return next.done = !0, next;
260
- };
261
- }, exports.values = values, Context.prototype = {
262
- constructor: Context,
263
- reset: function (skipTempReset) {
264
- 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);
265
- },
266
- stop: function () {
267
- this.done = !0;
268
- var rootRecord = this.tryEntries[0].completion;
269
- if ("throw" === rootRecord.type) throw rootRecord.arg;
270
- return this.rval;
271
- },
272
- dispatchException: function (exception) {
273
- if (this.done) throw exception;
274
- var context = this;
275
-
276
- function handle(loc, caught) {
277
- return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
278
- }
279
-
280
- for (var i = this.tryEntries.length - 1; i >= 0; --i) {
281
- var entry = this.tryEntries[i],
282
- record = entry.completion;
283
- if ("root" === entry.tryLoc) return handle("end");
284
-
285
- if (entry.tryLoc <= this.prev) {
286
- var hasCatch = hasOwn.call(entry, "catchLoc"),
287
- hasFinally = hasOwn.call(entry, "finallyLoc");
288
-
289
- if (hasCatch && hasFinally) {
290
- if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
291
- if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
292
- } else if (hasCatch) {
293
- if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
294
- } else {
295
- if (!hasFinally) throw new Error("try statement without catch or finally");
296
- if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
297
- }
298
- }
299
- }
300
- },
301
- abrupt: function (type, arg) {
302
- for (var i = this.tryEntries.length - 1; i >= 0; --i) {
303
- var entry = this.tryEntries[i];
304
-
305
- if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
306
- var finallyEntry = entry;
307
- break;
308
- }
309
- }
310
-
311
- finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
312
- var record = finallyEntry ? finallyEntry.completion : {};
313
- return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
314
- },
315
- complete: function (record, afterLoc) {
316
- if ("throw" === record.type) throw record.arg;
317
- 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;
318
- },
319
- finish: function (finallyLoc) {
320
- for (var i = this.tryEntries.length - 1; i >= 0; --i) {
321
- var entry = this.tryEntries[i];
322
- if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
323
- }
324
- },
325
- catch: function (tryLoc) {
326
- for (var i = this.tryEntries.length - 1; i >= 0; --i) {
327
- var entry = this.tryEntries[i];
328
-
329
- if (entry.tryLoc === tryLoc) {
330
- var record = entry.completion;
331
-
332
- if ("throw" === record.type) {
333
- var thrown = record.arg;
334
- resetTryEntry(entry);
335
- }
336
-
337
- return thrown;
338
- }
339
- }
340
-
341
- throw new Error("illegal catch attempt");
342
- },
343
- delegateYield: function (iterable, resultName, nextLoc) {
344
- return this.delegate = {
345
- iterator: values(iterable),
346
- resultName: resultName,
347
- nextLoc: nextLoc
348
- }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
349
- }
350
- }, exports;
351
- }
352
-
353
8
  function _wrapRegExp() {
354
9
  _wrapRegExp = function (re, groups) {
355
10
  return new BabelRegExp(re, void 0, groups);
@@ -435,7 +90,7 @@ function _asyncToGenerator(fn) {
435
90
  }
436
91
 
437
92
  function _extends() {
438
- _extends = Object.assign ? Object.assign.bind() : function (target) {
93
+ _extends = Object.assign || function (target) {
439
94
  for (var i = 1; i < arguments.length; i++) {
440
95
  var source = arguments[i];
441
96
 
@@ -448,6 +103,7 @@ function _extends() {
448
103
 
449
104
  return target;
450
105
  };
106
+
451
107
  return _extends.apply(this, arguments);
452
108
  }
453
109
 
@@ -477,17 +133,18 @@ function _inheritsLoose(subClass, superClass) {
477
133
  }
478
134
 
479
135
  function _getPrototypeOf(o) {
480
- _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
136
+ _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
481
137
  return o.__proto__ || Object.getPrototypeOf(o);
482
138
  };
483
139
  return _getPrototypeOf(o);
484
140
  }
485
141
 
486
142
  function _setPrototypeOf(o, p) {
487
- _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
143
+ _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
488
144
  o.__proto__ = p;
489
145
  return o;
490
146
  };
147
+
491
148
  return _setPrototypeOf(o, p);
492
149
  }
493
150
 
@@ -506,7 +163,7 @@ function _isNativeReflectConstruct() {
506
163
 
507
164
  function _construct(Parent, args, Class) {
508
165
  if (_isNativeReflectConstruct()) {
509
- _construct = Reflect.construct.bind();
166
+ _construct = Reflect.construct;
510
167
  } else {
511
168
  _construct = function _construct(Parent, args, Class) {
512
169
  var a = [null];
@@ -612,6 +269,766 @@ function _createForOfIteratorHelperLoose(o, allowArrayLike) {
612
269
  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
613
270
  }
614
271
 
272
+ function createCommonjsModule(fn, module) {
273
+ return module = { exports: {} }, fn(module, module.exports), module.exports;
274
+ }
275
+
276
+ var runtime_1 = createCommonjsModule(function (module) {
277
+ /**
278
+ * Copyright (c) 2014-present, Facebook, Inc.
279
+ *
280
+ * This source code is licensed under the MIT license found in the
281
+ * LICENSE file in the root directory of this source tree.
282
+ */
283
+
284
+ var runtime = (function (exports) {
285
+
286
+ var Op = Object.prototype;
287
+ var hasOwn = Op.hasOwnProperty;
288
+ var undefined$1; // More compressible than void 0.
289
+ var $Symbol = typeof Symbol === "function" ? Symbol : {};
290
+ var iteratorSymbol = $Symbol.iterator || "@@iterator";
291
+ var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
292
+ var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
293
+
294
+ function define(obj, key, value) {
295
+ Object.defineProperty(obj, key, {
296
+ value: value,
297
+ enumerable: true,
298
+ configurable: true,
299
+ writable: true
300
+ });
301
+ return obj[key];
302
+ }
303
+ try {
304
+ // IE 8 has a broken Object.defineProperty that only works on DOM objects.
305
+ define({}, "");
306
+ } catch (err) {
307
+ define = function(obj, key, value) {
308
+ return obj[key] = value;
309
+ };
310
+ }
311
+
312
+ function wrap(innerFn, outerFn, self, tryLocsList) {
313
+ // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
314
+ var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
315
+ var generator = Object.create(protoGenerator.prototype);
316
+ var context = new Context(tryLocsList || []);
317
+
318
+ // The ._invoke method unifies the implementations of the .next,
319
+ // .throw, and .return methods.
320
+ generator._invoke = makeInvokeMethod(innerFn, self, context);
321
+
322
+ return generator;
323
+ }
324
+ exports.wrap = wrap;
325
+
326
+ // Try/catch helper to minimize deoptimizations. Returns a completion
327
+ // record like context.tryEntries[i].completion. This interface could
328
+ // have been (and was previously) designed to take a closure to be
329
+ // invoked without arguments, but in all the cases we care about we
330
+ // already have an existing method we want to call, so there's no need
331
+ // to create a new function object. We can even get away with assuming
332
+ // the method takes exactly one argument, since that happens to be true
333
+ // in every case, so we don't have to touch the arguments object. The
334
+ // only additional allocation required is the completion record, which
335
+ // has a stable shape and so hopefully should be cheap to allocate.
336
+ function tryCatch(fn, obj, arg) {
337
+ try {
338
+ return { type: "normal", arg: fn.call(obj, arg) };
339
+ } catch (err) {
340
+ return { type: "throw", arg: err };
341
+ }
342
+ }
343
+
344
+ var GenStateSuspendedStart = "suspendedStart";
345
+ var GenStateSuspendedYield = "suspendedYield";
346
+ var GenStateExecuting = "executing";
347
+ var GenStateCompleted = "completed";
348
+
349
+ // Returning this object from the innerFn has the same effect as
350
+ // breaking out of the dispatch switch statement.
351
+ var ContinueSentinel = {};
352
+
353
+ // Dummy constructor functions that we use as the .constructor and
354
+ // .constructor.prototype properties for functions that return Generator
355
+ // objects. For full spec compliance, you may wish to configure your
356
+ // minifier not to mangle the names of these two functions.
357
+ function Generator() {}
358
+ function GeneratorFunction() {}
359
+ function GeneratorFunctionPrototype() {}
360
+
361
+ // This is a polyfill for %IteratorPrototype% for environments that
362
+ // don't natively support it.
363
+ var IteratorPrototype = {};
364
+ define(IteratorPrototype, iteratorSymbol, function () {
365
+ return this;
366
+ });
367
+
368
+ var getProto = Object.getPrototypeOf;
369
+ var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
370
+ if (NativeIteratorPrototype &&
371
+ NativeIteratorPrototype !== Op &&
372
+ hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
373
+ // This environment has a native %IteratorPrototype%; use it instead
374
+ // of the polyfill.
375
+ IteratorPrototype = NativeIteratorPrototype;
376
+ }
377
+
378
+ var Gp = GeneratorFunctionPrototype.prototype =
379
+ Generator.prototype = Object.create(IteratorPrototype);
380
+ GeneratorFunction.prototype = GeneratorFunctionPrototype;
381
+ define(Gp, "constructor", GeneratorFunctionPrototype);
382
+ define(GeneratorFunctionPrototype, "constructor", GeneratorFunction);
383
+ GeneratorFunction.displayName = define(
384
+ GeneratorFunctionPrototype,
385
+ toStringTagSymbol,
386
+ "GeneratorFunction"
387
+ );
388
+
389
+ // Helper for defining the .next, .throw, and .return methods of the
390
+ // Iterator interface in terms of a single ._invoke method.
391
+ function defineIteratorMethods(prototype) {
392
+ ["next", "throw", "return"].forEach(function(method) {
393
+ define(prototype, method, function(arg) {
394
+ return this._invoke(method, arg);
395
+ });
396
+ });
397
+ }
398
+
399
+ exports.isGeneratorFunction = function(genFun) {
400
+ var ctor = typeof genFun === "function" && genFun.constructor;
401
+ return ctor
402
+ ? ctor === GeneratorFunction ||
403
+ // For the native GeneratorFunction constructor, the best we can
404
+ // do is to check its .name property.
405
+ (ctor.displayName || ctor.name) === "GeneratorFunction"
406
+ : false;
407
+ };
408
+
409
+ exports.mark = function(genFun) {
410
+ if (Object.setPrototypeOf) {
411
+ Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
412
+ } else {
413
+ genFun.__proto__ = GeneratorFunctionPrototype;
414
+ define(genFun, toStringTagSymbol, "GeneratorFunction");
415
+ }
416
+ genFun.prototype = Object.create(Gp);
417
+ return genFun;
418
+ };
419
+
420
+ // Within the body of any async function, `await x` is transformed to
421
+ // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
422
+ // `hasOwn.call(value, "__await")` to determine if the yielded value is
423
+ // meant to be awaited.
424
+ exports.awrap = function(arg) {
425
+ return { __await: arg };
426
+ };
427
+
428
+ function AsyncIterator(generator, PromiseImpl) {
429
+ function invoke(method, arg, resolve, reject) {
430
+ var record = tryCatch(generator[method], generator, arg);
431
+ if (record.type === "throw") {
432
+ reject(record.arg);
433
+ } else {
434
+ var result = record.arg;
435
+ var value = result.value;
436
+ if (value &&
437
+ typeof value === "object" &&
438
+ hasOwn.call(value, "__await")) {
439
+ return PromiseImpl.resolve(value.__await).then(function(value) {
440
+ invoke("next", value, resolve, reject);
441
+ }, function(err) {
442
+ invoke("throw", err, resolve, reject);
443
+ });
444
+ }
445
+
446
+ return PromiseImpl.resolve(value).then(function(unwrapped) {
447
+ // When a yielded Promise is resolved, its final value becomes
448
+ // the .value of the Promise<{value,done}> result for the
449
+ // current iteration.
450
+ result.value = unwrapped;
451
+ resolve(result);
452
+ }, function(error) {
453
+ // If a rejected Promise was yielded, throw the rejection back
454
+ // into the async generator function so it can be handled there.
455
+ return invoke("throw", error, resolve, reject);
456
+ });
457
+ }
458
+ }
459
+
460
+ var previousPromise;
461
+
462
+ function enqueue(method, arg) {
463
+ function callInvokeWithMethodAndArg() {
464
+ return new PromiseImpl(function(resolve, reject) {
465
+ invoke(method, arg, resolve, reject);
466
+ });
467
+ }
468
+
469
+ return previousPromise =
470
+ // If enqueue has been called before, then we want to wait until
471
+ // all previous Promises have been resolved before calling invoke,
472
+ // so that results are always delivered in the correct order. If
473
+ // enqueue has not been called before, then it is important to
474
+ // call invoke immediately, without waiting on a callback to fire,
475
+ // so that the async generator function has the opportunity to do
476
+ // any necessary setup in a predictable way. This predictability
477
+ // is why the Promise constructor synchronously invokes its
478
+ // executor callback, and why async functions synchronously
479
+ // execute code before the first await. Since we implement simple
480
+ // async functions in terms of async generators, it is especially
481
+ // important to get this right, even though it requires care.
482
+ previousPromise ? previousPromise.then(
483
+ callInvokeWithMethodAndArg,
484
+ // Avoid propagating failures to Promises returned by later
485
+ // invocations of the iterator.
486
+ callInvokeWithMethodAndArg
487
+ ) : callInvokeWithMethodAndArg();
488
+ }
489
+
490
+ // Define the unified helper method that is used to implement .next,
491
+ // .throw, and .return (see defineIteratorMethods).
492
+ this._invoke = enqueue;
493
+ }
494
+
495
+ defineIteratorMethods(AsyncIterator.prototype);
496
+ define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
497
+ return this;
498
+ });
499
+ exports.AsyncIterator = AsyncIterator;
500
+
501
+ // Note that simple async functions are implemented on top of
502
+ // AsyncIterator objects; they just return a Promise for the value of
503
+ // the final result produced by the iterator.
504
+ exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {
505
+ if (PromiseImpl === void 0) PromiseImpl = Promise;
506
+
507
+ var iter = new AsyncIterator(
508
+ wrap(innerFn, outerFn, self, tryLocsList),
509
+ PromiseImpl
510
+ );
511
+
512
+ return exports.isGeneratorFunction(outerFn)
513
+ ? iter // If outerFn is a generator, return the full iterator.
514
+ : iter.next().then(function(result) {
515
+ return result.done ? result.value : iter.next();
516
+ });
517
+ };
518
+
519
+ function makeInvokeMethod(innerFn, self, context) {
520
+ var state = GenStateSuspendedStart;
521
+
522
+ return function invoke(method, arg) {
523
+ if (state === GenStateExecuting) {
524
+ throw new Error("Generator is already running");
525
+ }
526
+
527
+ if (state === GenStateCompleted) {
528
+ if (method === "throw") {
529
+ throw arg;
530
+ }
531
+
532
+ // Be forgiving, per 25.3.3.3.3 of the spec:
533
+ // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
534
+ return doneResult();
535
+ }
536
+
537
+ context.method = method;
538
+ context.arg = arg;
539
+
540
+ while (true) {
541
+ var delegate = context.delegate;
542
+ if (delegate) {
543
+ var delegateResult = maybeInvokeDelegate(delegate, context);
544
+ if (delegateResult) {
545
+ if (delegateResult === ContinueSentinel) continue;
546
+ return delegateResult;
547
+ }
548
+ }
549
+
550
+ if (context.method === "next") {
551
+ // Setting context._sent for legacy support of Babel's
552
+ // function.sent implementation.
553
+ context.sent = context._sent = context.arg;
554
+
555
+ } else if (context.method === "throw") {
556
+ if (state === GenStateSuspendedStart) {
557
+ state = GenStateCompleted;
558
+ throw context.arg;
559
+ }
560
+
561
+ context.dispatchException(context.arg);
562
+
563
+ } else if (context.method === "return") {
564
+ context.abrupt("return", context.arg);
565
+ }
566
+
567
+ state = GenStateExecuting;
568
+
569
+ var record = tryCatch(innerFn, self, context);
570
+ if (record.type === "normal") {
571
+ // If an exception is thrown from innerFn, we leave state ===
572
+ // GenStateExecuting and loop back for another invocation.
573
+ state = context.done
574
+ ? GenStateCompleted
575
+ : GenStateSuspendedYield;
576
+
577
+ if (record.arg === ContinueSentinel) {
578
+ continue;
579
+ }
580
+
581
+ return {
582
+ value: record.arg,
583
+ done: context.done
584
+ };
585
+
586
+ } else if (record.type === "throw") {
587
+ state = GenStateCompleted;
588
+ // Dispatch the exception by looping back around to the
589
+ // context.dispatchException(context.arg) call above.
590
+ context.method = "throw";
591
+ context.arg = record.arg;
592
+ }
593
+ }
594
+ };
595
+ }
596
+
597
+ // Call delegate.iterator[context.method](context.arg) and handle the
598
+ // result, either by returning a { value, done } result from the
599
+ // delegate iterator, or by modifying context.method and context.arg,
600
+ // setting context.delegate to null, and returning the ContinueSentinel.
601
+ function maybeInvokeDelegate(delegate, context) {
602
+ var method = delegate.iterator[context.method];
603
+ if (method === undefined$1) {
604
+ // A .throw or .return when the delegate iterator has no .throw
605
+ // method always terminates the yield* loop.
606
+ context.delegate = null;
607
+
608
+ if (context.method === "throw") {
609
+ // Note: ["return"] must be used for ES3 parsing compatibility.
610
+ if (delegate.iterator["return"]) {
611
+ // If the delegate iterator has a return method, give it a
612
+ // chance to clean up.
613
+ context.method = "return";
614
+ context.arg = undefined$1;
615
+ maybeInvokeDelegate(delegate, context);
616
+
617
+ if (context.method === "throw") {
618
+ // If maybeInvokeDelegate(context) changed context.method from
619
+ // "return" to "throw", let that override the TypeError below.
620
+ return ContinueSentinel;
621
+ }
622
+ }
623
+
624
+ context.method = "throw";
625
+ context.arg = new TypeError(
626
+ "The iterator does not provide a 'throw' method");
627
+ }
628
+
629
+ return ContinueSentinel;
630
+ }
631
+
632
+ var record = tryCatch(method, delegate.iterator, context.arg);
633
+
634
+ if (record.type === "throw") {
635
+ context.method = "throw";
636
+ context.arg = record.arg;
637
+ context.delegate = null;
638
+ return ContinueSentinel;
639
+ }
640
+
641
+ var info = record.arg;
642
+
643
+ if (! info) {
644
+ context.method = "throw";
645
+ context.arg = new TypeError("iterator result is not an object");
646
+ context.delegate = null;
647
+ return ContinueSentinel;
648
+ }
649
+
650
+ if (info.done) {
651
+ // Assign the result of the finished delegate to the temporary
652
+ // variable specified by delegate.resultName (see delegateYield).
653
+ context[delegate.resultName] = info.value;
654
+
655
+ // Resume execution at the desired location (see delegateYield).
656
+ context.next = delegate.nextLoc;
657
+
658
+ // If context.method was "throw" but the delegate handled the
659
+ // exception, let the outer generator proceed normally. If
660
+ // context.method was "next", forget context.arg since it has been
661
+ // "consumed" by the delegate iterator. If context.method was
662
+ // "return", allow the original .return call to continue in the
663
+ // outer generator.
664
+ if (context.method !== "return") {
665
+ context.method = "next";
666
+ context.arg = undefined$1;
667
+ }
668
+
669
+ } else {
670
+ // Re-yield the result returned by the delegate method.
671
+ return info;
672
+ }
673
+
674
+ // The delegate iterator is finished, so forget it and continue with
675
+ // the outer generator.
676
+ context.delegate = null;
677
+ return ContinueSentinel;
678
+ }
679
+
680
+ // Define Generator.prototype.{next,throw,return} in terms of the
681
+ // unified ._invoke helper method.
682
+ defineIteratorMethods(Gp);
683
+
684
+ define(Gp, toStringTagSymbol, "Generator");
685
+
686
+ // A Generator should always return itself as the iterator object when the
687
+ // @@iterator function is called on it. Some browsers' implementations of the
688
+ // iterator prototype chain incorrectly implement this, causing the Generator
689
+ // object to not be returned from this call. This ensures that doesn't happen.
690
+ // See https://github.com/facebook/regenerator/issues/274 for more details.
691
+ define(Gp, iteratorSymbol, function() {
692
+ return this;
693
+ });
694
+
695
+ define(Gp, "toString", function() {
696
+ return "[object Generator]";
697
+ });
698
+
699
+ function pushTryEntry(locs) {
700
+ var entry = { tryLoc: locs[0] };
701
+
702
+ if (1 in locs) {
703
+ entry.catchLoc = locs[1];
704
+ }
705
+
706
+ if (2 in locs) {
707
+ entry.finallyLoc = locs[2];
708
+ entry.afterLoc = locs[3];
709
+ }
710
+
711
+ this.tryEntries.push(entry);
712
+ }
713
+
714
+ function resetTryEntry(entry) {
715
+ var record = entry.completion || {};
716
+ record.type = "normal";
717
+ delete record.arg;
718
+ entry.completion = record;
719
+ }
720
+
721
+ function Context(tryLocsList) {
722
+ // The root entry object (effectively a try statement without a catch
723
+ // or a finally block) gives us a place to store values thrown from
724
+ // locations where there is no enclosing try statement.
725
+ this.tryEntries = [{ tryLoc: "root" }];
726
+ tryLocsList.forEach(pushTryEntry, this);
727
+ this.reset(true);
728
+ }
729
+
730
+ exports.keys = function(object) {
731
+ var keys = [];
732
+ for (var key in object) {
733
+ keys.push(key);
734
+ }
735
+ keys.reverse();
736
+
737
+ // Rather than returning an object with a next method, we keep
738
+ // things simple and return the next function itself.
739
+ return function next() {
740
+ while (keys.length) {
741
+ var key = keys.pop();
742
+ if (key in object) {
743
+ next.value = key;
744
+ next.done = false;
745
+ return next;
746
+ }
747
+ }
748
+
749
+ // To avoid creating an additional object, we just hang the .value
750
+ // and .done properties off the next function object itself. This
751
+ // also ensures that the minifier will not anonymize the function.
752
+ next.done = true;
753
+ return next;
754
+ };
755
+ };
756
+
757
+ function values(iterable) {
758
+ if (iterable) {
759
+ var iteratorMethod = iterable[iteratorSymbol];
760
+ if (iteratorMethod) {
761
+ return iteratorMethod.call(iterable);
762
+ }
763
+
764
+ if (typeof iterable.next === "function") {
765
+ return iterable;
766
+ }
767
+
768
+ if (!isNaN(iterable.length)) {
769
+ var i = -1, next = function next() {
770
+ while (++i < iterable.length) {
771
+ if (hasOwn.call(iterable, i)) {
772
+ next.value = iterable[i];
773
+ next.done = false;
774
+ return next;
775
+ }
776
+ }
777
+
778
+ next.value = undefined$1;
779
+ next.done = true;
780
+
781
+ return next;
782
+ };
783
+
784
+ return next.next = next;
785
+ }
786
+ }
787
+
788
+ // Return an iterator with no values.
789
+ return { next: doneResult };
790
+ }
791
+ exports.values = values;
792
+
793
+ function doneResult() {
794
+ return { value: undefined$1, done: true };
795
+ }
796
+
797
+ Context.prototype = {
798
+ constructor: Context,
799
+
800
+ reset: function(skipTempReset) {
801
+ this.prev = 0;
802
+ this.next = 0;
803
+ // Resetting context._sent for legacy support of Babel's
804
+ // function.sent implementation.
805
+ this.sent = this._sent = undefined$1;
806
+ this.done = false;
807
+ this.delegate = null;
808
+
809
+ this.method = "next";
810
+ this.arg = undefined$1;
811
+
812
+ this.tryEntries.forEach(resetTryEntry);
813
+
814
+ if (!skipTempReset) {
815
+ for (var name in this) {
816
+ // Not sure about the optimal order of these conditions:
817
+ if (name.charAt(0) === "t" &&
818
+ hasOwn.call(this, name) &&
819
+ !isNaN(+name.slice(1))) {
820
+ this[name] = undefined$1;
821
+ }
822
+ }
823
+ }
824
+ },
825
+
826
+ stop: function() {
827
+ this.done = true;
828
+
829
+ var rootEntry = this.tryEntries[0];
830
+ var rootRecord = rootEntry.completion;
831
+ if (rootRecord.type === "throw") {
832
+ throw rootRecord.arg;
833
+ }
834
+
835
+ return this.rval;
836
+ },
837
+
838
+ dispatchException: function(exception) {
839
+ if (this.done) {
840
+ throw exception;
841
+ }
842
+
843
+ var context = this;
844
+ function handle(loc, caught) {
845
+ record.type = "throw";
846
+ record.arg = exception;
847
+ context.next = loc;
848
+
849
+ if (caught) {
850
+ // If the dispatched exception was caught by a catch block,
851
+ // then let that catch block handle the exception normally.
852
+ context.method = "next";
853
+ context.arg = undefined$1;
854
+ }
855
+
856
+ return !! caught;
857
+ }
858
+
859
+ for (var i = this.tryEntries.length - 1; i >= 0; --i) {
860
+ var entry = this.tryEntries[i];
861
+ var record = entry.completion;
862
+
863
+ if (entry.tryLoc === "root") {
864
+ // Exception thrown outside of any try block that could handle
865
+ // it, so set the completion value of the entire function to
866
+ // throw the exception.
867
+ return handle("end");
868
+ }
869
+
870
+ if (entry.tryLoc <= this.prev) {
871
+ var hasCatch = hasOwn.call(entry, "catchLoc");
872
+ var hasFinally = hasOwn.call(entry, "finallyLoc");
873
+
874
+ if (hasCatch && hasFinally) {
875
+ if (this.prev < entry.catchLoc) {
876
+ return handle(entry.catchLoc, true);
877
+ } else if (this.prev < entry.finallyLoc) {
878
+ return handle(entry.finallyLoc);
879
+ }
880
+
881
+ } else if (hasCatch) {
882
+ if (this.prev < entry.catchLoc) {
883
+ return handle(entry.catchLoc, true);
884
+ }
885
+
886
+ } else if (hasFinally) {
887
+ if (this.prev < entry.finallyLoc) {
888
+ return handle(entry.finallyLoc);
889
+ }
890
+
891
+ } else {
892
+ throw new Error("try statement without catch or finally");
893
+ }
894
+ }
895
+ }
896
+ },
897
+
898
+ abrupt: function(type, arg) {
899
+ for (var i = this.tryEntries.length - 1; i >= 0; --i) {
900
+ var entry = this.tryEntries[i];
901
+ if (entry.tryLoc <= this.prev &&
902
+ hasOwn.call(entry, "finallyLoc") &&
903
+ this.prev < entry.finallyLoc) {
904
+ var finallyEntry = entry;
905
+ break;
906
+ }
907
+ }
908
+
909
+ if (finallyEntry &&
910
+ (type === "break" ||
911
+ type === "continue") &&
912
+ finallyEntry.tryLoc <= arg &&
913
+ arg <= finallyEntry.finallyLoc) {
914
+ // Ignore the finally entry if control is not jumping to a
915
+ // location outside the try/catch block.
916
+ finallyEntry = null;
917
+ }
918
+
919
+ var record = finallyEntry ? finallyEntry.completion : {};
920
+ record.type = type;
921
+ record.arg = arg;
922
+
923
+ if (finallyEntry) {
924
+ this.method = "next";
925
+ this.next = finallyEntry.finallyLoc;
926
+ return ContinueSentinel;
927
+ }
928
+
929
+ return this.complete(record);
930
+ },
931
+
932
+ complete: function(record, afterLoc) {
933
+ if (record.type === "throw") {
934
+ throw record.arg;
935
+ }
936
+
937
+ if (record.type === "break" ||
938
+ record.type === "continue") {
939
+ this.next = record.arg;
940
+ } else if (record.type === "return") {
941
+ this.rval = this.arg = record.arg;
942
+ this.method = "return";
943
+ this.next = "end";
944
+ } else if (record.type === "normal" && afterLoc) {
945
+ this.next = afterLoc;
946
+ }
947
+
948
+ return ContinueSentinel;
949
+ },
950
+
951
+ finish: function(finallyLoc) {
952
+ for (var i = this.tryEntries.length - 1; i >= 0; --i) {
953
+ var entry = this.tryEntries[i];
954
+ if (entry.finallyLoc === finallyLoc) {
955
+ this.complete(entry.completion, entry.afterLoc);
956
+ resetTryEntry(entry);
957
+ return ContinueSentinel;
958
+ }
959
+ }
960
+ },
961
+
962
+ "catch": function(tryLoc) {
963
+ for (var i = this.tryEntries.length - 1; i >= 0; --i) {
964
+ var entry = this.tryEntries[i];
965
+ if (entry.tryLoc === tryLoc) {
966
+ var record = entry.completion;
967
+ if (record.type === "throw") {
968
+ var thrown = record.arg;
969
+ resetTryEntry(entry);
970
+ }
971
+ return thrown;
972
+ }
973
+ }
974
+
975
+ // The context.catch method must only be called with a location
976
+ // argument that corresponds to a known catch block.
977
+ throw new Error("illegal catch attempt");
978
+ },
979
+
980
+ delegateYield: function(iterable, resultName, nextLoc) {
981
+ this.delegate = {
982
+ iterator: values(iterable),
983
+ resultName: resultName,
984
+ nextLoc: nextLoc
985
+ };
986
+
987
+ if (this.method === "next") {
988
+ // Deliberately forget the last sent value so that we don't
989
+ // accidentally pass it on to the delegate.
990
+ this.arg = undefined$1;
991
+ }
992
+
993
+ return ContinueSentinel;
994
+ }
995
+ };
996
+
997
+ // Regardless of whether this script is executing as a CommonJS module
998
+ // or not, return the runtime object so that we can declare the variable
999
+ // regeneratorRuntime in the outer scope, which allows this module to be
1000
+ // injected easily by `bin/regenerator --include-runtime script.js`.
1001
+ return exports;
1002
+
1003
+ }(
1004
+ // If this script is executing as a CommonJS module, use module.exports
1005
+ // as the regeneratorRuntime namespace. Otherwise create a new empty
1006
+ // object. Either way, the resulting object will be used to initialize
1007
+ // the regeneratorRuntime variable at the top of this file.
1008
+ module.exports
1009
+ ));
1010
+
1011
+ try {
1012
+ regeneratorRuntime = runtime;
1013
+ } catch (accidentalStrictMode) {
1014
+ // This module should not be running in strict mode, so the above
1015
+ // assignment should always work unless something is misconfigured. Just
1016
+ // in case runtime.js accidentally runs in strict mode, in modern engines
1017
+ // we can explicitly access globalThis. In older engines we can escape
1018
+ // strict mode using a global Function call. This could conceivably fail
1019
+ // if a Content Security Policy forbids using Function, but in that case
1020
+ // the proper solution is to fix the accidental strict mode problem. If
1021
+ // you've misconfigured your bundler to force strict mode and applied a
1022
+ // CSP to forbid Function, and you're not willing to fix either of those
1023
+ // problems, please detail your unique predicament in a GitHub issue.
1024
+ if (typeof globalThis === "object") {
1025
+ globalThis.regeneratorRuntime = runtime;
1026
+ } else {
1027
+ Function("r", "regeneratorRuntime = r")(runtime);
1028
+ }
1029
+ }
1030
+ });
1031
+
615
1032
  var _personalMetaToPrefix;
616
1033
  var personalMetaToPrefix = (_personalMetaToPrefix = {}, _personalMetaToPrefix[MetadataCategory.Personal] = 'you', _personalMetaToPrefix[MetadataCategory.ChildPersonal] = 'child', _personalMetaToPrefix[MetadataCategory.OtherPersonal] = 'other', _personalMetaToPrefix);
617
1034
  /**
@@ -831,9 +1248,9 @@ function filterTriggeredAnsweredWithKind(_x, _x2) {
831
1248
  */
832
1249
 
833
1250
  function _filterTriggeredAnsweredWithKind() {
834
- _filterTriggeredAnsweredWithKind = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(workflowData, kind) {
1251
+ _filterTriggeredAnsweredWithKind = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(workflowData, kind) {
835
1252
  var flattenedAnswers, triggeredQuestionsWithKind, samePageAnswers, res;
836
- return _regeneratorRuntime().wrap(function _callee$(_context) {
1253
+ return runtime_1.wrap(function _callee$(_context) {
837
1254
  while (1) {
838
1255
  switch (_context.prev = _context.next) {
839
1256
  case 0:
@@ -877,9 +1294,9 @@ function getWorkflowDataByCategory(_x3, _x4) {
877
1294
  }
878
1295
 
879
1296
  function _getWorkflowDataByCategory() {
880
- _getWorkflowDataByCategory = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(workflowData, category) {
1297
+ _getWorkflowDataByCategory = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(workflowData, category) {
881
1298
  var flattenedAnswers, triggeredQuestions, fields;
882
- return _regeneratorRuntime().wrap(function _callee2$(_context2) {
1299
+ return runtime_1.wrap(function _callee2$(_context2) {
883
1300
  while (1) {
884
1301
  switch (_context2.prev = _context2.next) {
885
1302
  case 0:
@@ -950,8 +1367,8 @@ function getImagesFromIndexDb(_x5) {
950
1367
  */
951
1368
 
952
1369
  function _getImagesFromIndexDb() {
953
- _getImagesFromIndexDb = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(answer) {
954
- return _regeneratorRuntime().wrap(function _callee3$(_context3) {
1370
+ _getImagesFromIndexDb = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(answer) {
1371
+ return runtime_1.wrap(function _callee3$(_context3) {
955
1372
  while (1) {
956
1373
  switch (_context3.prev = _context3.next) {
957
1374
  case 0:
@@ -980,9 +1397,9 @@ function populateWorkflowField(_x6, _x7) {
980
1397
  }
981
1398
 
982
1399
  function _populateWorkflowField() {
983
- _populateWorkflowField = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(question, answerValue) {
1400
+ _populateWorkflowField = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(question, answerValue) {
984
1401
  var answer, displayedAnswer;
985
- return _regeneratorRuntime().wrap(function _callee4$(_context4) {
1402
+ return runtime_1.wrap(function _callee4$(_context4) {
986
1403
  while (1) {
987
1404
  switch (_context4.prev = _context4.next) {
988
1405
  case 0:
@@ -1160,10 +1577,10 @@ function registerPatient(_x, _x2, _x3, _x4, _x5, _x6) {
1160
1577
  */
1161
1578
 
1162
1579
  function _registerPatient() {
1163
- _registerPatient = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(patientUuid, consultRequest, workflow, oroClient, masterKey, recoveryQA) {
1580
+ _registerPatient = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(patientUuid, consultRequest, workflow, oroClient, masterKey, recoveryQA) {
1164
1581
  var consult, lockboxUuid, practitionerAdmin, retry, identity, errorsThrown, _ret;
1165
1582
 
1166
- return _regeneratorRuntime().wrap(function _callee4$(_context4) {
1583
+ return runtime_1.wrap(function _callee4$(_context4) {
1167
1584
  while (1) {
1168
1585
  switch (_context4.prev = _context4.next) {
1169
1586
  case 0:
@@ -1181,11 +1598,11 @@ function _registerPatient() {
1181
1598
  }
1182
1599
 
1183
1600
  _context4.prev = 7;
1184
- return _context4.delegateYield( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
1601
+ return _context4.delegateYield( /*#__PURE__*/runtime_1.mark(function _callee3() {
1185
1602
  var _consultIndex, _identity, _identity2;
1186
1603
 
1187
1604
  var practitioners, grantPromises, consultIndex, consultIndexPromises;
1188
- return _regeneratorRuntime().wrap(function _callee3$(_context3) {
1605
+ return runtime_1.wrap(function _callee3$(_context3) {
1189
1606
  while (1) {
1190
1607
  switch (_context3.prev = _context3.next) {
1191
1608
  case 0:
@@ -1256,6 +1673,7 @@ function _registerPatient() {
1256
1673
  return oroClient.grantLockbox(practitionerAdmin, lockboxUuid)["catch"](function (err) {
1257
1674
  console.error("Error while granting lockbox to practitioner admin " + practitionerAdmin, err); // if we cannot grant to the admin, then the registration will fail
1258
1675
 
1676
+ // if we cannot grant to the admin, then the registration will fail
1259
1677
  errorsThrown.push(err);
1260
1678
  });
1261
1679
 
@@ -1264,14 +1682,15 @@ function _registerPatient() {
1264
1682
  grantPromises = practitioners.filter(function (practitioner) {
1265
1683
  return practitioner.uuid !== practitionerAdmin;
1266
1684
  }).map( /*#__PURE__*/function () {
1267
- var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(practitioner) {
1268
- return _regeneratorRuntime().wrap(function _callee$(_context) {
1685
+ var _ref = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(practitioner) {
1686
+ return runtime_1.wrap(function _callee$(_context) {
1269
1687
  while (1) {
1270
1688
  switch (_context.prev = _context.next) {
1271
1689
  case 0:
1272
1690
  return _context.abrupt("return", oroClient.grantLockbox(practitioner.uuid, lockboxUuid)["catch"](function (err) {
1273
1691
  console.error("Error while granting lockbox to practitioner", err); // Acceptable to continue as admin has already been granted, but we should still retry until the last retry remains
1274
1692
 
1693
+ // Acceptable to continue as admin has already been granted, but we should still retry until the last retry remains
1275
1694
  if (retry <= 1) return;
1276
1695
  errorsThrown.push(err);
1277
1696
  }));
@@ -1297,14 +1716,15 @@ function _registerPatient() {
1297
1716
  }], _consultIndex); // the index will identify in which lockbox a consultation resides
1298
1717
 
1299
1718
  consultIndexPromises = practitioners.map( /*#__PURE__*/function () {
1300
- var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(practitioner) {
1301
- return _regeneratorRuntime().wrap(function _callee2$(_context2) {
1719
+ var _ref2 = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(practitioner) {
1720
+ return runtime_1.wrap(function _callee2$(_context2) {
1302
1721
  while (1) {
1303
1722
  switch (_context2.prev = _context2.next) {
1304
1723
  case 0:
1305
1724
  return _context2.abrupt("return", oroClient.vaultIndexAdd(consultIndex, practitioner.uuid)["catch"](function (err) {
1306
1725
  console.error("[SDK: registration] Error while adding to the practitioner's index " + practitioner.uuid, err); // Acceptable to continue as the index can be rebuilt, but we should still retry until the last retry remains
1307
1726
 
1727
+ // Acceptable to continue as the index can be rebuilt, but we should still retry until the last retry remains
1308
1728
  if (retry <= 1) return;else errorsThrown.push(err);
1309
1729
  }));
1310
1730
 
@@ -1324,6 +1744,7 @@ function _registerPatient() {
1324
1744
  return storeImageAliases(consult.uuid, lockboxUuid, workflow, oroClient)["catch"](function (err) {
1325
1745
  console.error('[SDK: registration] Some errors happened during image upload', err); // Acceptable to continue as images can be requested during the consultation, but we should still retry until the last retry remains
1326
1746
 
1747
+ // Acceptable to continue as images can be requested during the consultation, but we should still retry until the last retry remains
1327
1748
  if (retry <= 1) return;else errorsThrown.push(err);
1328
1749
  });
1329
1750
 
@@ -1344,6 +1765,7 @@ function _registerPatient() {
1344
1765
  return oroClient.updateMasterKey(patientUuid, masterKey, lockboxUuid)["catch"](function (err) {
1345
1766
  console.error("[SDK: registration] Error while updating master key", err); /// it's acceptable to continue registration (return old identity)
1346
1767
 
1768
+ /// it's acceptable to continue registration (return old identity)
1347
1769
  if (retry <= 1) return;
1348
1770
  errorsThrown.push(err);
1349
1771
  return identity;
@@ -1368,6 +1790,7 @@ function _registerPatient() {
1368
1790
  return oroClient.updateSecurityQuestions(patientUuid, recoveryQA.recoverySecurityQuestions, recoveryQA.recoverySecurityAnswers, 2)["catch"](function (err) {
1369
1791
  console.error("[SDK: registration] Error while updating security questions", err); /// it's acceptable to continue registration (return old identity)
1370
1792
 
1793
+ /// it's acceptable to continue registration (return old identity)
1371
1794
  if (retry <= 1) return;
1372
1795
  errorsThrown.push(err);
1373
1796
  return identity;
@@ -1473,9 +1896,9 @@ function getOrCreatePatientConsultationUuid(_x7, _x8) {
1473
1896
 
1474
1897
 
1475
1898
  function _getOrCreatePatientConsultationUuid() {
1476
- _getOrCreatePatientConsultationUuid = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(consult, oroClient) {
1899
+ _getOrCreatePatientConsultationUuid = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(consult, oroClient) {
1477
1900
  var payment;
1478
- return _regeneratorRuntime().wrap(function _callee5$(_context5) {
1901
+ return runtime_1.wrap(function _callee5$(_context5) {
1479
1902
  while (1) {
1480
1903
  switch (_context5.prev = _context5.next) {
1481
1904
  case 0:
@@ -1530,9 +1953,9 @@ function getOrCreatePatientLockbox(_x9) {
1530
1953
 
1531
1954
 
1532
1955
  function _getOrCreatePatientLockbox() {
1533
- _getOrCreatePatientLockbox = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(oroClient) {
1956
+ _getOrCreatePatientLockbox = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee6(oroClient) {
1534
1957
  var grants;
1535
- return _regeneratorRuntime().wrap(function _callee6$(_context6) {
1958
+ return runtime_1.wrap(function _callee6$(_context6) {
1536
1959
  while (1) {
1537
1960
  switch (_context6.prev = _context6.next) {
1538
1961
  case 0:
@@ -1575,8 +1998,8 @@ function storePatientData(_x10, _x11, _x12, _x13, _x14) {
1575
1998
  }
1576
1999
 
1577
2000
  function _storePatientData() {
1578
- _storePatientData = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(consultationId, isoLanguage, lockboxUuid, workflow, oroClient) {
1579
- return _regeneratorRuntime().wrap(function _callee7$(_context7) {
2001
+ _storePatientData = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee7(consultationId, isoLanguage, lockboxUuid, workflow, oroClient) {
2002
+ return runtime_1.wrap(function _callee7$(_context7) {
1580
2003
  while (1) {
1581
2004
  switch (_context7.prev = _context7.next) {
1582
2005
  case 0:
@@ -1633,9 +2056,9 @@ function storeImageAliases(_x15, _x16, _x17, _x18) {
1633
2056
 
1634
2057
 
1635
2058
  function _storeImageAliases() {
1636
- _storeImageAliases = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8(consultationId, lockboxUuid, workflow, oroClient) {
2059
+ _storeImageAliases = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee8(consultationId, lockboxUuid, workflow, oroClient) {
1637
2060
  var images, nonNullImages, promises;
1638
- return _regeneratorRuntime().wrap(function _callee8$(_context8) {
2061
+ return runtime_1.wrap(function _callee8$(_context8) {
1639
2062
  while (1) {
1640
2063
  switch (_context8.prev = _context8.next) {
1641
2064
  case 0:
@@ -1683,8 +2106,8 @@ function extractAndStorePersonalWorkflowData(_x19, _x20, _x21, _x22, _x23) {
1683
2106
  }
1684
2107
 
1685
2108
  function _extractAndStorePersonalWorkflowData() {
1686
- _extractAndStorePersonalWorkflowData = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9(workflow, lockboxUuid, consultationId, category, oroClient) {
1687
- return _regeneratorRuntime().wrap(function _callee9$(_context9) {
2109
+ _extractAndStorePersonalWorkflowData = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee9(workflow, lockboxUuid, consultationId, category, oroClient) {
2110
+ return runtime_1.wrap(function _callee9$(_context9) {
1688
2111
  while (1) {
1689
2112
  switch (_context9.prev = _context9.next) {
1690
2113
  case 0:
@@ -1776,10 +2199,10 @@ function filterGrantsWithLockboxMetadata(_x, _x2, _x3, _x4) {
1776
2199
  */
1777
2200
 
1778
2201
  function _filterGrantsWithLockboxMetadata() {
1779
- _filterGrantsWithLockboxMetadata = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(oroClient, filter, vaultIndex, forceRefresh) {
2202
+ _filterGrantsWithLockboxMetadata = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(oroClient, filter, vaultIndex, forceRefresh) {
1780
2203
  var _vaultIndex$IndexKey$, indexConsults;
1781
2204
 
1782
- return _regeneratorRuntime().wrap(function _callee$(_context) {
2205
+ return runtime_1.wrap(function _callee$(_context) {
1783
2206
  while (1) {
1784
2207
  switch (_context.prev = _context.next) {
1785
2208
  case 0:
@@ -1829,12 +2252,12 @@ function buildLegacyVaultIndex(_x5) {
1829
2252
  }
1830
2253
 
1831
2254
  function _buildLegacyVaultIndex() {
1832
- _buildLegacyVaultIndex = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(oroClient) {
2255
+ _buildLegacyVaultIndex = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(oroClient) {
1833
2256
  var _vaultIndex;
1834
2257
 
1835
2258
  var grants, consultGrants, _loop, _iterator, _step, vaultIndex;
1836
2259
 
1837
- return _regeneratorRuntime().wrap(function _callee2$(_context3) {
2260
+ return runtime_1.wrap(function _callee2$(_context3) {
1838
2261
  while (1) {
1839
2262
  switch (_context3.prev = _context3.next) {
1840
2263
  case 0:
@@ -1844,9 +2267,9 @@ function _buildLegacyVaultIndex() {
1844
2267
  case 2:
1845
2268
  grants = _context3.sent;
1846
2269
  consultGrants = [];
1847
- _loop = /*#__PURE__*/_regeneratorRuntime().mark(function _loop() {
2270
+ _loop = /*#__PURE__*/runtime_1.mark(function _loop() {
1848
2271
  var grant, consults;
1849
- return _regeneratorRuntime().wrap(function _loop$(_context2) {
2272
+ return runtime_1.wrap(function _loop$(_context2) {
1850
2273
  while (1) {
1851
2274
  switch (_context2.prev = _context2.next) {
1852
2275
  case 0:
@@ -1929,8 +2352,8 @@ var OroClient = /*#__PURE__*/function () {
1929
2352
  _proto.cleanIndex =
1930
2353
  /*#__PURE__*/
1931
2354
  function () {
1932
- var _cleanIndex = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
1933
- return _regeneratorRuntime().wrap(function _callee$(_context) {
2355
+ var _cleanIndex = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee() {
2356
+ return runtime_1.wrap(function _callee$(_context) {
1934
2357
  while (1) {
1935
2358
  switch (_context.prev = _context.next) {
1936
2359
  case 0:
@@ -1968,9 +2391,9 @@ var OroClient = /*#__PURE__*/function () {
1968
2391
  _proto.signUp =
1969
2392
  /*#__PURE__*/
1970
2393
  function () {
1971
- var _signUp = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(email, password, practice, tosAndCpAcceptance, tokenData, subscription, skipEmailValidation) {
2394
+ var _signUp = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(email, password, practice, tosAndCpAcceptance, tokenData, subscription, skipEmailValidation) {
1972
2395
  var privateKey, symmetricEncryptor, recoveryPassword, hashedPassword, emailConfirmed, signupRequest, identity, symetricEncryptor;
1973
- return _regeneratorRuntime().wrap(function _callee2$(_context2) {
2396
+ return runtime_1.wrap(function _callee2$(_context2) {
1974
2397
  while (1) {
1975
2398
  switch (_context2.prev = _context2.next) {
1976
2399
  case 0:
@@ -2029,9 +2452,9 @@ var OroClient = /*#__PURE__*/function () {
2029
2452
  _proto.confirmEmail =
2030
2453
  /*#__PURE__*/
2031
2454
  function () {
2032
- var _confirmEmail = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(accessToken) {
2455
+ var _confirmEmail = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(accessToken) {
2033
2456
  var claims;
2034
- return _regeneratorRuntime().wrap(function _callee3$(_context3) {
2457
+ return runtime_1.wrap(function _callee3$(_context3) {
2035
2458
  while (1) {
2036
2459
  switch (_context3.prev = _context3.next) {
2037
2460
  case 0:
@@ -2076,9 +2499,9 @@ var OroClient = /*#__PURE__*/function () {
2076
2499
  _proto.signIn =
2077
2500
  /*#__PURE__*/
2078
2501
  function () {
2079
- var _signIn = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(practiceUuid, email, password, otp) {
2502
+ var _signIn = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(practiceUuid, email, password, otp) {
2080
2503
  var hashedPassword, tokenRequest, userUuid;
2081
- return _regeneratorRuntime().wrap(function _callee4$(_context4) {
2504
+ return runtime_1.wrap(function _callee4$(_context4) {
2082
2505
  while (1) {
2083
2506
  switch (_context4.prev = _context4.next) {
2084
2507
  case 0:
@@ -2131,9 +2554,9 @@ var OroClient = /*#__PURE__*/function () {
2131
2554
  _proto.resumeSession =
2132
2555
  /*#__PURE__*/
2133
2556
  function () {
2134
- var _resumeSession = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5() {
2557
+ var _resumeSession = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5() {
2135
2558
  var id, recoveryPayload, recoveryKey, symmetricDecryptor, privateKey;
2136
- return _regeneratorRuntime().wrap(function _callee5$(_context5) {
2559
+ return runtime_1.wrap(function _callee5$(_context5) {
2137
2560
  while (1) {
2138
2561
  switch (_context5.prev = _context5.next) {
2139
2562
  case 0:
@@ -2234,8 +2657,8 @@ var OroClient = /*#__PURE__*/function () {
2234
2657
  _proto.signOut =
2235
2658
  /*#__PURE__*/
2236
2659
  function () {
2237
- var _signOut = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6() {
2238
- return _regeneratorRuntime().wrap(function _callee6$(_context6) {
2660
+ var _signOut = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee6() {
2661
+ return runtime_1.wrap(function _callee6$(_context6) {
2239
2662
  while (1) {
2240
2663
  switch (_context6.prev = _context6.next) {
2241
2664
  case 0:
@@ -2284,8 +2707,8 @@ var OroClient = /*#__PURE__*/function () {
2284
2707
  _proto.registerPatient =
2285
2708
  /*#__PURE__*/
2286
2709
  function () {
2287
- var _registerPatient2 = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(patientUuid, consult, workflow, recoveryQA) {
2288
- return _regeneratorRuntime().wrap(function _callee7$(_context7) {
2710
+ var _registerPatient2 = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee7(patientUuid, consult, workflow, recoveryQA) {
2711
+ return runtime_1.wrap(function _callee7$(_context7) {
2289
2712
  while (1) {
2290
2713
  switch (_context7.prev = _context7.next) {
2291
2714
  case 0:
@@ -2328,8 +2751,8 @@ var OroClient = /*#__PURE__*/function () {
2328
2751
  _proto.buildVaultIndex =
2329
2752
  /*#__PURE__*/
2330
2753
  function () {
2331
- var _buildVaultIndex = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8(forceRefresh) {
2332
- return _regeneratorRuntime().wrap(function _callee8$(_context8) {
2754
+ var _buildVaultIndex = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee8(forceRefresh) {
2755
+ return runtime_1.wrap(function _callee8$(_context8) {
2333
2756
  while (1) {
2334
2757
  switch (_context8.prev = _context8.next) {
2335
2758
  case 0:
@@ -2377,12 +2800,12 @@ var OroClient = /*#__PURE__*/function () {
2377
2800
  _proto.forceUpdateIndexEntries =
2378
2801
  /*#__PURE__*/
2379
2802
  function () {
2380
- var _forceUpdateIndexEntries = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10() {
2803
+ var _forceUpdateIndexEntries = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee10() {
2381
2804
  var _this = this,
2382
2805
  _this$vaultIndexAdd;
2383
2806
 
2384
2807
  var grants, indexConsultLockbox;
2385
- return _regeneratorRuntime().wrap(function _callee10$(_context10) {
2808
+ return runtime_1.wrap(function _callee10$(_context10) {
2386
2809
  while (1) {
2387
2810
  switch (_context10.prev = _context10.next) {
2388
2811
  case 0:
@@ -2393,8 +2816,8 @@ var OroClient = /*#__PURE__*/function () {
2393
2816
  grants = _context10.sent;
2394
2817
  _context10.next = 5;
2395
2818
  return Promise.all(grants.map( /*#__PURE__*/function () {
2396
- var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9(grant) {
2397
- return _regeneratorRuntime().wrap(function _callee9$(_context9) {
2819
+ var _ref2 = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee9(grant) {
2820
+ return runtime_1.wrap(function _callee9$(_context9) {
2398
2821
  while (1) {
2399
2822
  switch (_context9.prev = _context9.next) {
2400
2823
  case 0:
@@ -2470,12 +2893,12 @@ var OroClient = /*#__PURE__*/function () {
2470
2893
  _proto.vaultIndexAdd =
2471
2894
  /*#__PURE__*/
2472
2895
  function () {
2473
- var _vaultIndexAdd = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee11(entries, indexOwnerUuid) {
2896
+ var _vaultIndexAdd = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee11(entries, indexOwnerUuid) {
2474
2897
  var _this2 = this;
2475
2898
 
2476
2899
  var rsaPub, base64IndexOwnerPubKey, encryptedIndex, _i, _Object$keys, keyString, key;
2477
2900
 
2478
- return _regeneratorRuntime().wrap(function _callee11$(_context11) {
2901
+ return runtime_1.wrap(function _callee11$(_context11) {
2479
2902
  while (1) {
2480
2903
  switch (_context11.prev = _context11.next) {
2481
2904
  case 0:
@@ -2597,11 +3020,11 @@ var OroClient = /*#__PURE__*/function () {
2597
3020
  _proto.indexSnapshotAdd =
2598
3021
  /*#__PURE__*/
2599
3022
  function () {
2600
- var _indexSnapshotAdd = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee12(index) {
3023
+ var _indexSnapshotAdd = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee12(index) {
2601
3024
  var _index$IndexKey$Consu, _cleanedIndex;
2602
3025
 
2603
3026
  var rsaPub, cleanedIndex, encryptedIndexEntry, encryptedIndex;
2604
- return _regeneratorRuntime().wrap(function _callee12$(_context12) {
3027
+ return runtime_1.wrap(function _callee12$(_context12) {
2605
3028
  while (1) {
2606
3029
  switch (_context12.prev = _context12.next) {
2607
3030
  case 0:
@@ -2659,9 +3082,9 @@ var OroClient = /*#__PURE__*/function () {
2659
3082
  _proto.grantLockbox =
2660
3083
  /*#__PURE__*/
2661
3084
  function () {
2662
- var _grantLockbox = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee13(granteeUuid, lockboxUuid, lockboxOwnerUuid) {
3085
+ var _grantLockbox = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee13(granteeUuid, lockboxUuid, lockboxOwnerUuid) {
2663
3086
  var secret, base64GranteePublicKey, granteePublicKey, granteeEncryptedSecret, request;
2664
- return _regeneratorRuntime().wrap(function _callee13$(_context13) {
3087
+ return runtime_1.wrap(function _callee13$(_context13) {
2665
3088
  while (1) {
2666
3089
  switch (_context13.prev = _context13.next) {
2667
3090
  case 0:
@@ -2721,9 +3144,9 @@ var OroClient = /*#__PURE__*/function () {
2721
3144
  _proto.createMessageData =
2722
3145
  /*#__PURE__*/
2723
3146
  function () {
2724
- var _createMessageData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee14(lockboxUuid, message, consultationId, lockboxOwnerUuid, previousDataUuid) {
3147
+ var _createMessageData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee14(lockboxUuid, message, consultationId, lockboxOwnerUuid, previousDataUuid) {
2725
3148
  var symmetricEncryptor, encryptedData, encryptedPrivateMeta, meta, request;
2726
- return _regeneratorRuntime().wrap(function _callee14$(_context14) {
3149
+ return runtime_1.wrap(function _callee14$(_context14) {
2727
3150
  while (1) {
2728
3151
  switch (_context14.prev = _context14.next) {
2729
3152
  case 0:
@@ -2793,9 +3216,9 @@ var OroClient = /*#__PURE__*/function () {
2793
3216
  _proto.createMessageAttachmentData =
2794
3217
  /*#__PURE__*/
2795
3218
  function () {
2796
- var _createMessageAttachmentData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee15(lockboxUuid, data, consultationId, lockboxOwnerUuid, previousDataUuid) {
3219
+ var _createMessageAttachmentData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee15(lockboxUuid, data, consultationId, lockboxOwnerUuid, previousDataUuid) {
2797
3220
  var symmetricEncryptor, encryptedData, encryptedPrivateMeta, meta, request;
2798
- return _regeneratorRuntime().wrap(function _callee15$(_context15) {
3221
+ return runtime_1.wrap(function _callee15$(_context15) {
2799
3222
  while (1) {
2800
3223
  switch (_context15.prev = _context15.next) {
2801
3224
  case 0:
@@ -2880,8 +3303,8 @@ var OroClient = /*#__PURE__*/function () {
2880
3303
  _proto.createConsultationAttachmentData =
2881
3304
  /*#__PURE__*/
2882
3305
  function () {
2883
- var _createConsultationAttachmentData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee16(lockboxUuid, data, consultationId, documentType, lockboxOwnerUuid, previousDataUuid) {
2884
- return _regeneratorRuntime().wrap(function _callee16$(_context16) {
3306
+ var _createConsultationAttachmentData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee16(lockboxUuid, data, consultationId, documentType, lockboxOwnerUuid, previousDataUuid) {
3307
+ return runtime_1.wrap(function _callee16$(_context16) {
2885
3308
  while (1) {
2886
3309
  switch (_context16.prev = _context16.next) {
2887
3310
  case 0:
@@ -2952,9 +3375,9 @@ var OroClient = /*#__PURE__*/function () {
2952
3375
  _proto.createJsonData =
2953
3376
  /*#__PURE__*/
2954
3377
  function () {
2955
- var _createJsonData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee17(lockboxUuid, data, meta, privateMeta, lockboxOwnerUuid, previousDataUuid) {
3378
+ var _createJsonData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee17(lockboxUuid, data, meta, privateMeta, lockboxOwnerUuid, previousDataUuid) {
2956
3379
  var symmetricEncryptor, encryptedData, encryptedPrivateMeta, request;
2957
- return _regeneratorRuntime().wrap(function _callee17$(_context17) {
3380
+ return runtime_1.wrap(function _callee17$(_context17) {
2958
3381
  while (1) {
2959
3382
  switch (_context17.prev = _context17.next) {
2960
3383
  case 0:
@@ -3008,9 +3431,9 @@ var OroClient = /*#__PURE__*/function () {
3008
3431
  _proto.getOrInsertJsonData =
3009
3432
  /*#__PURE__*/
3010
3433
  function () {
3011
- var _getOrInsertJsonData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee18(lockboxUuid, data, publicMetadata, privateMetadata, forceReplace) {
3434
+ var _getOrInsertJsonData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee18(lockboxUuid, data, publicMetadata, privateMetadata, forceReplace) {
3012
3435
  var manifest;
3013
- return _regeneratorRuntime().wrap(function _callee18$(_context18) {
3436
+ return runtime_1.wrap(function _callee18$(_context18) {
3014
3437
  while (1) {
3015
3438
  switch (_context18.prev = _context18.next) {
3016
3439
  case 0:
@@ -3073,9 +3496,9 @@ var OroClient = /*#__PURE__*/function () {
3073
3496
  _proto.createBytesData =
3074
3497
  /*#__PURE__*/
3075
3498
  function () {
3076
- var _createBytesData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee19(lockboxUuid, data, meta, privateMeta, lockboxOwnerUuid, previousDataUuid) {
3499
+ var _createBytesData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee19(lockboxUuid, data, meta, privateMeta, lockboxOwnerUuid, previousDataUuid) {
3077
3500
  var symmetricEncryptor, encryptedData, encryptedPrivateMeta, request;
3078
- return _regeneratorRuntime().wrap(function _callee19$(_context19) {
3501
+ return runtime_1.wrap(function _callee19$(_context19) {
3079
3502
  while (1) {
3080
3503
  switch (_context19.prev = _context19.next) {
3081
3504
  case 0:
@@ -3131,10 +3554,10 @@ var OroClient = /*#__PURE__*/function () {
3131
3554
  _proto.getJsonData =
3132
3555
  /*#__PURE__*/
3133
3556
  function () {
3134
- var _getJsonData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee20(lockboxUuid, dataUuid, lockboxOwnerUuid) {
3557
+ var _getJsonData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee20(lockboxUuid, dataUuid, lockboxOwnerUuid) {
3135
3558
  var _yield$Promise$all, encryptedPayload, symmetricDecryptor;
3136
3559
 
3137
- return _regeneratorRuntime().wrap(function _callee20$(_context20) {
3560
+ return runtime_1.wrap(function _callee20$(_context20) {
3138
3561
  while (1) {
3139
3562
  switch (_context20.prev = _context20.next) {
3140
3563
  case 0:
@@ -3181,10 +3604,10 @@ var OroClient = /*#__PURE__*/function () {
3181
3604
  _proto.getBytesData =
3182
3605
  /*#__PURE__*/
3183
3606
  function () {
3184
- var _getBytesData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee21(lockboxUuid, dataUuid, lockboxOwnerUuid) {
3607
+ var _getBytesData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee21(lockboxUuid, dataUuid, lockboxOwnerUuid) {
3185
3608
  var _yield$Promise$all2, encryptedPayload, symmetricDecryptor;
3186
3609
 
3187
- return _regeneratorRuntime().wrap(function _callee21$(_context21) {
3610
+ return runtime_1.wrap(function _callee21$(_context21) {
3188
3611
  while (1) {
3189
3612
  switch (_context21.prev = _context21.next) {
3190
3613
  case 0:
@@ -3234,9 +3657,9 @@ var OroClient = /*#__PURE__*/function () {
3234
3657
  _proto.getGrants =
3235
3658
  /*#__PURE__*/
3236
3659
  function () {
3237
- var _getGrants = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee22(filter, forceRefresh) {
3660
+ var _getGrants = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee22(filter, forceRefresh) {
3238
3661
  var filterString, grantsByConsultLockbox, decryptedConsults, encryptedGrants, decryptedGrants;
3239
- return _regeneratorRuntime().wrap(function _callee22$(_context22) {
3662
+ return runtime_1.wrap(function _callee22$(_context22) {
3240
3663
  while (1) {
3241
3664
  switch (_context22.prev = _context22.next) {
3242
3665
  case 0:
@@ -3354,9 +3777,9 @@ var OroClient = /*#__PURE__*/function () {
3354
3777
  _proto.getCachedSecretCryptor =
3355
3778
  /*#__PURE__*/
3356
3779
  function () {
3357
- var _getCachedSecretCryptor = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee23(lockboxUuid, lockboxOwnerUuid) {
3780
+ var _getCachedSecretCryptor = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee23(lockboxUuid, lockboxOwnerUuid) {
3358
3781
  var index, encryptedSecret, secret, cryptor;
3359
- return _regeneratorRuntime().wrap(function _callee23$(_context23) {
3782
+ return runtime_1.wrap(function _callee23$(_context23) {
3360
3783
  while (1) {
3361
3784
  switch (_context23.prev = _context23.next) {
3362
3785
  case 0:
@@ -3421,8 +3844,8 @@ var OroClient = /*#__PURE__*/function () {
3421
3844
  _proto.getPersonalInformationsFromConsultId =
3422
3845
  /*#__PURE__*/
3423
3846
  function () {
3424
- var _getPersonalInformationsFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee24(consultationId, category, forceRefresh) {
3425
- return _regeneratorRuntime().wrap(function _callee24$(_context24) {
3847
+ var _getPersonalInformationsFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee24(consultationId, category, forceRefresh) {
3848
+ return runtime_1.wrap(function _callee24$(_context24) {
3426
3849
  while (1) {
3427
3850
  switch (_context24.prev = _context24.next) {
3428
3851
  case 0:
@@ -3459,8 +3882,8 @@ var OroClient = /*#__PURE__*/function () {
3459
3882
  _proto.getMedicalDataFromConsultId =
3460
3883
  /*#__PURE__*/
3461
3884
  function () {
3462
- var _getMedicalDataFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee25(consultationId, forceRefresh) {
3463
- return _regeneratorRuntime().wrap(function _callee25$(_context25) {
3885
+ var _getMedicalDataFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee25(consultationId, forceRefresh) {
3886
+ return runtime_1.wrap(function _callee25$(_context25) {
3464
3887
  while (1) {
3465
3888
  switch (_context25.prev = _context25.next) {
3466
3889
  case 0:
@@ -3486,12 +3909,12 @@ var OroClient = /*#__PURE__*/function () {
3486
3909
  }();
3487
3910
 
3488
3911
  _proto.getMetaCategoryFromConsultId = /*#__PURE__*/function () {
3489
- var _getMetaCategoryFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee27(consultationId, category, forceRefresh) {
3912
+ var _getMetaCategoryFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee27(consultationId, category, forceRefresh) {
3490
3913
  var _this3 = this;
3491
3914
 
3492
3915
  var grants, workflowData, _loop, _iterator, _step;
3493
3916
 
3494
- return _regeneratorRuntime().wrap(function _callee27$(_context28) {
3917
+ return runtime_1.wrap(function _callee27$(_context28) {
3495
3918
  while (1) {
3496
3919
  switch (_context28.prev = _context28.next) {
3497
3920
  case 0:
@@ -3507,9 +3930,9 @@ var OroClient = /*#__PURE__*/function () {
3507
3930
  case 3:
3508
3931
  grants = _context28.sent;
3509
3932
  workflowData = [];
3510
- _loop = /*#__PURE__*/_regeneratorRuntime().mark(function _loop() {
3933
+ _loop = /*#__PURE__*/runtime_1.mark(function _loop() {
3511
3934
  var grant, manifest, data;
3512
- return _regeneratorRuntime().wrap(function _loop$(_context27) {
3935
+ return runtime_1.wrap(function _loop$(_context27) {
3513
3936
  while (1) {
3514
3937
  switch (_context27.prev = _context27.next) {
3515
3938
  case 0:
@@ -3543,8 +3966,8 @@ var OroClient = /*#__PURE__*/function () {
3543
3966
  case 8:
3544
3967
  _context27.next = 10;
3545
3968
  return Promise.all(manifest.map( /*#__PURE__*/function () {
3546
- var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee26(entry) {
3547
- return _regeneratorRuntime().wrap(function _callee26$(_context26) {
3969
+ var _ref3 = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee26(entry) {
3970
+ return runtime_1.wrap(function _callee26$(_context26) {
3548
3971
  while (1) {
3549
3972
  switch (_context26.prev = _context26.next) {
3550
3973
  case 0:
@@ -3628,9 +4051,9 @@ var OroClient = /*#__PURE__*/function () {
3628
4051
  _proto.getPersonalInformations =
3629
4052
  /*#__PURE__*/
3630
4053
  function () {
3631
- var _getPersonalInformations = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee28(userId) {
4054
+ var _getPersonalInformations = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee28(userId) {
3632
4055
  var grant, lockboxUuid, lockboxOwnerUuid, identificationDataUuid;
3633
- return _regeneratorRuntime().wrap(function _callee28$(_context29) {
4056
+ return runtime_1.wrap(function _callee28$(_context29) {
3634
4057
  while (1) {
3635
4058
  switch (_context29.prev = _context29.next) {
3636
4059
  case 0:
@@ -3716,9 +4139,9 @@ var OroClient = /*#__PURE__*/function () {
3716
4139
  _proto.getGrantFromConsultId =
3717
4140
  /*#__PURE__*/
3718
4141
  function () {
3719
- var _getGrantFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee29(consultationId) {
4142
+ var _getGrantFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee29(consultationId) {
3720
4143
  var grants;
3721
- return _regeneratorRuntime().wrap(function _callee29$(_context30) {
4144
+ return runtime_1.wrap(function _callee29$(_context30) {
3722
4145
  while (1) {
3723
4146
  switch (_context30.prev = _context30.next) {
3724
4147
  case 0:
@@ -3764,9 +4187,9 @@ var OroClient = /*#__PURE__*/function () {
3764
4187
  _proto.getIdentityFromConsultId =
3765
4188
  /*#__PURE__*/
3766
4189
  function () {
3767
- var _getIdentityFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee30(consultationId) {
4190
+ var _getIdentityFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee30(consultationId) {
3768
4191
  var grant;
3769
- return _regeneratorRuntime().wrap(function _callee30$(_context31) {
4192
+ return runtime_1.wrap(function _callee30$(_context31) {
3770
4193
  while (1) {
3771
4194
  switch (_context31.prev = _context31.next) {
3772
4195
  case 0:
@@ -3819,11 +4242,11 @@ var OroClient = /*#__PURE__*/function () {
3819
4242
  _proto.getLockboxManifest =
3820
4243
  /*#__PURE__*/
3821
4244
  function () {
3822
- var _getLockboxManifest = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee32(lockboxUuid, filter, expandPrivateMetadata, lockboxOwnerUuid, forceRefresh) {
4245
+ var _getLockboxManifest = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee32(lockboxUuid, filter, expandPrivateMetadata, lockboxOwnerUuid, forceRefresh) {
3823
4246
  var _this4 = this;
3824
4247
 
3825
4248
  var manifestKey;
3826
- return _regeneratorRuntime().wrap(function _callee32$(_context33) {
4249
+ return runtime_1.wrap(function _callee32$(_context33) {
3827
4250
  while (1) {
3828
4251
  switch (_context33.prev = _context33.next) {
3829
4252
  case 0:
@@ -3848,9 +4271,9 @@ var OroClient = /*#__PURE__*/function () {
3848
4271
  case 4:
3849
4272
  return _context33.abrupt("return", this.vaultClient.lockboxManifestGet(lockboxUuid, filter, lockboxOwnerUuid).then(function (manifest) {
3850
4273
  return Promise.all(manifest.map( /*#__PURE__*/function () {
3851
- var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee31(entry) {
4274
+ var _ref4 = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee31(entry) {
3852
4275
  var privateMeta;
3853
- return _regeneratorRuntime().wrap(function _callee31$(_context32) {
4276
+ return runtime_1.wrap(function _callee31$(_context32) {
3854
4277
  while (1) {
3855
4278
  switch (_context32.prev = _context32.next) {
3856
4279
  case 0:
@@ -3911,11 +4334,11 @@ var OroClient = /*#__PURE__*/function () {
3911
4334
  _proto.createPersonalInformations =
3912
4335
  /*#__PURE__*/
3913
4336
  function () {
3914
- var _createPersonalInformations = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee33(identity, data, dataUuid) {
4337
+ var _createPersonalInformations = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee33(identity, data, dataUuid) {
3915
4338
  var _yield$this$getGrants;
3916
4339
 
3917
4340
  var lockboxUuid;
3918
- return _regeneratorRuntime().wrap(function _callee33$(_context34) {
4341
+ return runtime_1.wrap(function _callee33$(_context34) {
3919
4342
  while (1) {
3920
4343
  switch (_context34.prev = _context34.next) {
3921
4344
  case 0:
@@ -3981,11 +4404,11 @@ var OroClient = /*#__PURE__*/function () {
3981
4404
  _proto.createUserPreference =
3982
4405
  /*#__PURE__*/
3983
4406
  function () {
3984
- var _createUserPreference = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee34(identity, preference, dataUuid) {
4407
+ var _createUserPreference = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee34(identity, preference, dataUuid) {
3985
4408
  var _yield$this$getGrants2;
3986
4409
 
3987
4410
  var lockboxUuid;
3988
- return _regeneratorRuntime().wrap(function _callee34$(_context35) {
4411
+ return runtime_1.wrap(function _callee34$(_context35) {
3989
4412
  while (1) {
3990
4413
  switch (_context35.prev = _context35.next) {
3991
4414
  case 0:
@@ -4049,9 +4472,9 @@ var OroClient = /*#__PURE__*/function () {
4049
4472
  _proto.getDataFromGrant =
4050
4473
  /*#__PURE__*/
4051
4474
  function () {
4052
- var _getDataFromGrant = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee35(grant, filter) {
4475
+ var _getDataFromGrant = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee35(grant, filter) {
4053
4476
  var lockboxUuid, lockboxOwnerUuid, identificationDataUuid;
4054
- return _regeneratorRuntime().wrap(function _callee35$(_context36) {
4477
+ return runtime_1.wrap(function _callee35$(_context36) {
4055
4478
  while (1) {
4056
4479
  switch (_context36.prev = _context36.next) {
4057
4480
  case 0:
@@ -4117,9 +4540,9 @@ var OroClient = /*#__PURE__*/function () {
4117
4540
  _proto.getUserPreferenceFromConsultId =
4118
4541
  /*#__PURE__*/
4119
4542
  function () {
4120
- var _getUserPreferenceFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee36(consultationId) {
4543
+ var _getUserPreferenceFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee36(consultationId) {
4121
4544
  var grant;
4122
- return _regeneratorRuntime().wrap(function _callee36$(_context37) {
4545
+ return runtime_1.wrap(function _callee36$(_context37) {
4123
4546
  while (1) {
4124
4547
  switch (_context37.prev = _context37.next) {
4125
4548
  case 0:
@@ -4166,9 +4589,9 @@ var OroClient = /*#__PURE__*/function () {
4166
4589
  _proto.getUserPreference =
4167
4590
  /*#__PURE__*/
4168
4591
  function () {
4169
- var _getUserPreference = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee37(identity) {
4592
+ var _getUserPreference = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee37(identity) {
4170
4593
  var grant;
4171
- return _regeneratorRuntime().wrap(function _callee37$(_context38) {
4594
+ return runtime_1.wrap(function _callee37$(_context38) {
4172
4595
  while (1) {
4173
4596
  switch (_context38.prev = _context38.next) {
4174
4597
  case 0:
@@ -4217,9 +4640,9 @@ var OroClient = /*#__PURE__*/function () {
4217
4640
  _proto.getRecoveryDataFromConsultId =
4218
4641
  /*#__PURE__*/
4219
4642
  function () {
4220
- var _getRecoveryDataFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee38(consultationId) {
4643
+ var _getRecoveryDataFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee38(consultationId) {
4221
4644
  var grant;
4222
- return _regeneratorRuntime().wrap(function _callee38$(_context39) {
4645
+ return runtime_1.wrap(function _callee38$(_context39) {
4223
4646
  while (1) {
4224
4647
  switch (_context39.prev = _context39.next) {
4225
4648
  case 0:
@@ -4266,9 +4689,9 @@ var OroClient = /*#__PURE__*/function () {
4266
4689
  _proto.getRecoveryData =
4267
4690
  /*#__PURE__*/
4268
4691
  function () {
4269
- var _getRecoveryData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee39(identity) {
4692
+ var _getRecoveryData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee39(identity) {
4270
4693
  var grant;
4271
- return _regeneratorRuntime().wrap(function _callee39$(_context40) {
4694
+ return runtime_1.wrap(function _callee39$(_context40) {
4272
4695
  while (1) {
4273
4696
  switch (_context40.prev = _context40.next) {
4274
4697
  case 0:
@@ -4322,10 +4745,10 @@ var OroClient = /*#__PURE__*/function () {
4322
4745
  _proto.getAssignedConsultations =
4323
4746
  /*#__PURE__*/
4324
4747
  function () {
4325
- var _getAssignedConsultations = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee41(practiceUuid, forceRefresh) {
4748
+ var _getAssignedConsultations = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee41(practiceUuid, forceRefresh) {
4326
4749
  var _this5 = this;
4327
4750
 
4328
- return _regeneratorRuntime().wrap(function _callee41$(_context42) {
4751
+ return runtime_1.wrap(function _callee41$(_context42) {
4329
4752
  while (1) {
4330
4753
  switch (_context42.prev = _context42.next) {
4331
4754
  case 0:
@@ -4344,8 +4767,8 @@ var OroClient = /*#__PURE__*/function () {
4344
4767
  documentType: DocumentType.PopulatedWorkflowData
4345
4768
  }, true, undefined, forceRefresh).then(function (manifest) {
4346
4769
  return Promise.all(manifest.map( /*#__PURE__*/function () {
4347
- var _ref5 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee40(entry) {
4348
- return _regeneratorRuntime().wrap(function _callee40$(_context41) {
4770
+ var _ref5 = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee40(entry) {
4771
+ return runtime_1.wrap(function _callee40$(_context41) {
4349
4772
  while (1) {
4350
4773
  switch (_context41.prev = _context41.next) {
4351
4774
  case 0:
@@ -4399,11 +4822,11 @@ var OroClient = /*#__PURE__*/function () {
4399
4822
  _proto.getPastConsultationsFromConsultId =
4400
4823
  /*#__PURE__*/
4401
4824
  function () {
4402
- var _getPastConsultationsFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee43(consultationId, practiceUuid) {
4825
+ var _getPastConsultationsFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee43(consultationId, practiceUuid) {
4403
4826
  var _this6 = this;
4404
4827
 
4405
4828
  var grant, consultationsInLockbox;
4406
- return _regeneratorRuntime().wrap(function _callee43$(_context44) {
4829
+ return runtime_1.wrap(function _callee43$(_context44) {
4407
4830
  while (1) {
4408
4831
  switch (_context44.prev = _context44.next) {
4409
4832
  case 0:
@@ -4442,8 +4865,8 @@ var OroClient = /*#__PURE__*/function () {
4442
4865
  case 10:
4443
4866
  _context44.next = 12;
4444
4867
  return Promise.all(consultationsInLockbox.map( /*#__PURE__*/function () {
4445
- var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee42(consultId) {
4446
- return _regeneratorRuntime().wrap(function _callee42$(_context43) {
4868
+ var _ref6 = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee42(consultId) {
4869
+ return runtime_1.wrap(function _callee42$(_context43) {
4447
4870
  while (1) {
4448
4871
  switch (_context43.prev = _context43.next) {
4449
4872
  case 0:
@@ -4494,10 +4917,10 @@ var OroClient = /*#__PURE__*/function () {
4494
4917
  _proto.getPatientConsultationData =
4495
4918
  /*#__PURE__*/
4496
4919
  function () {
4497
- var _getPatientConsultationData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee44(consultationId, forceRefresh) {
4920
+ var _getPatientConsultationData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee44(consultationId, forceRefresh) {
4498
4921
  var _this7 = this;
4499
4922
 
4500
- return _regeneratorRuntime().wrap(function _callee44$(_context45) {
4923
+ return runtime_1.wrap(function _callee44$(_context45) {
4501
4924
  while (1) {
4502
4925
  switch (_context45.prev = _context45.next) {
4503
4926
  case 0:
@@ -4551,8 +4974,8 @@ var OroClient = /*#__PURE__*/function () {
4551
4974
  _proto.getPatientPrescriptionsList =
4552
4975
  /*#__PURE__*/
4553
4976
  function () {
4554
- var _getPatientPrescriptionsList = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee45(consultationId) {
4555
- return _regeneratorRuntime().wrap(function _callee45$(_context46) {
4977
+ var _getPatientPrescriptionsList = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee45(consultationId) {
4978
+ return runtime_1.wrap(function _callee45$(_context46) {
4556
4979
  while (1) {
4557
4980
  switch (_context46.prev = _context46.next) {
4558
4981
  case 0:
@@ -4585,8 +5008,8 @@ var OroClient = /*#__PURE__*/function () {
4585
5008
  _proto.getPatientResultsList =
4586
5009
  /*#__PURE__*/
4587
5010
  function () {
4588
- var _getPatientResultsList = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee46(consultationId) {
4589
- return _regeneratorRuntime().wrap(function _callee46$(_context47) {
5011
+ var _getPatientResultsList = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee46(consultationId) {
5012
+ return runtime_1.wrap(function _callee46$(_context47) {
4590
5013
  while (1) {
4591
5014
  switch (_context47.prev = _context47.next) {
4592
5015
  case 0:
@@ -4619,8 +5042,8 @@ var OroClient = /*#__PURE__*/function () {
4619
5042
  _proto.getPatientTreatmentPlans =
4620
5043
  /*#__PURE__*/
4621
5044
  function () {
4622
- var _getPatientTreatmentPlans = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee47(consultationId) {
4623
- return _regeneratorRuntime().wrap(function _callee47$(_context48) {
5045
+ var _getPatientTreatmentPlans = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee47(consultationId) {
5046
+ return runtime_1.wrap(function _callee47$(_context48) {
4624
5047
  while (1) {
4625
5048
  switch (_context48.prev = _context48.next) {
4626
5049
  case 0:
@@ -4654,8 +5077,8 @@ var OroClient = /*#__PURE__*/function () {
4654
5077
  _proto.getPatientTreatmentPlanByUuid =
4655
5078
  /*#__PURE__*/
4656
5079
  function () {
4657
- var _getPatientTreatmentPlanByUuid = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee48(consultationId, treatmentPlanId) {
4658
- return _regeneratorRuntime().wrap(function _callee48$(_context49) {
5080
+ var _getPatientTreatmentPlanByUuid = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee48(consultationId, treatmentPlanId) {
5081
+ return runtime_1.wrap(function _callee48$(_context49) {
4659
5082
  while (1) {
4660
5083
  switch (_context49.prev = _context49.next) {
4661
5084
  case 0:
@@ -4693,10 +5116,10 @@ var OroClient = /*#__PURE__*/function () {
4693
5116
  _proto.getPatientDocumentsList =
4694
5117
  /*#__PURE__*/
4695
5118
  function () {
4696
- var _getPatientDocumentsList = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee50(filters, expandPrivateMetadata, consultationId) {
5119
+ var _getPatientDocumentsList = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee50(filters, expandPrivateMetadata, consultationId) {
4697
5120
  var _this8 = this;
4698
5121
 
4699
- return _regeneratorRuntime().wrap(function _callee50$(_context51) {
5122
+ return runtime_1.wrap(function _callee50$(_context51) {
4700
5123
  while (1) {
4701
5124
  switch (_context51.prev = _context51.next) {
4702
5125
  case 0:
@@ -4712,8 +5135,8 @@ var OroClient = /*#__PURE__*/function () {
4712
5135
  consultationId: consultationId
4713
5136
  }), expandPrivateMetadata, grant.lockboxOwnerUuid, true).then(function (manifest) {
4714
5137
  return Promise.all(manifest.map( /*#__PURE__*/function () {
4715
- var _ref7 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee49(entry) {
4716
- return _regeneratorRuntime().wrap(function _callee49$(_context50) {
5138
+ var _ref7 = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee49(entry) {
5139
+ return runtime_1.wrap(function _callee49$(_context50) {
4717
5140
  while (1) {
4718
5141
  switch (_context50.prev = _context50.next) {
4719
5142
  case 0:
@@ -4771,9 +5194,9 @@ var OroClient = /*#__PURE__*/function () {
4771
5194
  _proto.recoverPrivateKeyFromSecurityQuestions =
4772
5195
  /*#__PURE__*/
4773
5196
  function () {
4774
- var _recoverPrivateKeyFromSecurityQuestions = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee51(id, recoverySecurityQuestions, recoverySecurityAnswers, threshold) {
5197
+ var _recoverPrivateKeyFromSecurityQuestions = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee51(id, recoverySecurityQuestions, recoverySecurityAnswers, threshold) {
4775
5198
  var shards, answeredShards, privateKey;
4776
- return _regeneratorRuntime().wrap(function _callee51$(_context52) {
5199
+ return runtime_1.wrap(function _callee51$(_context52) {
4777
5200
  while (1) {
4778
5201
  switch (_context52.prev = _context52.next) {
4779
5202
  case 0:
@@ -4827,9 +5250,9 @@ var OroClient = /*#__PURE__*/function () {
4827
5250
  _proto.recoverPrivateKeyFromPassword =
4828
5251
  /*#__PURE__*/
4829
5252
  function () {
4830
- var _recoverPrivateKeyFromPassword = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee52(id, password) {
5253
+ var _recoverPrivateKeyFromPassword = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee52(id, password) {
4831
5254
  var identity, recoveryPayload, symmetricDecryptor, privateKey, symetricEncryptor;
4832
- return _regeneratorRuntime().wrap(function _callee52$(_context53) {
5255
+ return runtime_1.wrap(function _callee52$(_context53) {
4833
5256
  while (1) {
4834
5257
  switch (_context53.prev = _context53.next) {
4835
5258
  case 0:
@@ -4875,9 +5298,9 @@ var OroClient = /*#__PURE__*/function () {
4875
5298
  _proto.recoverPrivateKeyFromMasterKey =
4876
5299
  /*#__PURE__*/
4877
5300
  function () {
4878
- var _recoverPrivateKeyFromMasterKey = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee53(id, masterKey) {
5301
+ var _recoverPrivateKeyFromMasterKey = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee53(id, masterKey) {
4879
5302
  var recoveryPayload, symmetricDecryptor, privateKey;
4880
- return _regeneratorRuntime().wrap(function _callee53$(_context54) {
5303
+ return runtime_1.wrap(function _callee53$(_context54) {
4881
5304
  while (1) {
4882
5305
  switch (_context54.prev = _context54.next) {
4883
5306
  case 0:
@@ -4917,9 +5340,9 @@ var OroClient = /*#__PURE__*/function () {
4917
5340
  _proto.updateSecurityQuestions =
4918
5341
  /*#__PURE__*/
4919
5342
  function () {
4920
- var _updateSecurityQuestions = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee54(id, recoverySecurityQuestions, recoverySecurityAnswers, threshold) {
5343
+ var _updateSecurityQuestions = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee54(id, recoverySecurityQuestions, recoverySecurityAnswers, threshold) {
4921
5344
  var securityQuestionPayload, updateRequest;
4922
- return _regeneratorRuntime().wrap(function _callee54$(_context55) {
5345
+ return runtime_1.wrap(function _callee54$(_context55) {
4923
5346
  while (1) {
4924
5347
  switch (_context55.prev = _context55.next) {
4925
5348
  case 0:
@@ -4971,9 +5394,9 @@ var OroClient = /*#__PURE__*/function () {
4971
5394
  _proto.updatePassword =
4972
5395
  /*#__PURE__*/
4973
5396
  function () {
4974
- var _updatePassword = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee55(id, newPassword, oldPassword) {
5397
+ var _updatePassword = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee55(id, newPassword, oldPassword) {
4975
5398
  var symmetricEncryptor, passwordPayload, updateRequest;
4976
- return _regeneratorRuntime().wrap(function _callee55$(_context56) {
5399
+ return runtime_1.wrap(function _callee55$(_context56) {
4977
5400
  while (1) {
4978
5401
  switch (_context56.prev = _context56.next) {
4979
5402
  case 0:
@@ -5033,9 +5456,9 @@ var OroClient = /*#__PURE__*/function () {
5033
5456
  _proto.updateMasterKey =
5034
5457
  /*#__PURE__*/
5035
5458
  function () {
5036
- var _updateMasterKey = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee56(id, masterKey, lockboxUuid) {
5459
+ var _updateMasterKey = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee56(id, masterKey, lockboxUuid) {
5037
5460
  var symmetricEncryptor, masterKeyPayload, updateRequest, updatedIdentity;
5038
- return _regeneratorRuntime().wrap(function _callee56$(_context57) {
5461
+ return runtime_1.wrap(function _callee56$(_context57) {
5039
5462
  while (1) {
5040
5463
  switch (_context57.prev = _context57.next) {
5041
5464
  case 0: