oro-sdk 3.1.1 → 3.1.2-dev2.1

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.
@@ -9,612 +9,1029 @@ var initApis__default = _interopDefault(initApis);
9
9
  var oroToolbox = require('oro-toolbox');
10
10
  var idbKeyval = require('idb-keyval');
11
11
 
12
- function _regeneratorRuntime() {
13
- /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
12
+ function _wrapRegExp() {
13
+ _wrapRegExp = function (re, groups) {
14
+ return new BabelRegExp(re, void 0, groups);
15
+ };
16
+
17
+ var _super = RegExp.prototype,
18
+ _groups = new WeakMap();
19
+
20
+ function BabelRegExp(re, flags, groups) {
21
+ var _this = new RegExp(re, flags);
22
+
23
+ return _groups.set(_this, groups || _groups.get(re)), _setPrototypeOf(_this, BabelRegExp.prototype);
24
+ }
25
+
26
+ function buildGroups(result, re) {
27
+ var g = _groups.get(re);
28
+
29
+ return Object.keys(g).reduce(function (groups, name) {
30
+ return groups[name] = result[g[name]], groups;
31
+ }, Object.create(null));
32
+ }
33
+
34
+ return _inherits(BabelRegExp, RegExp), BabelRegExp.prototype.exec = function (str) {
35
+ var result = _super.exec.call(this, str);
36
+
37
+ return result && (result.groups = buildGroups(result, this)), result;
38
+ }, BabelRegExp.prototype[Symbol.replace] = function (str, substitution) {
39
+ if ("string" == typeof substitution) {
40
+ var groups = _groups.get(this);
41
+
42
+ return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) {
43
+ return "$" + groups[name];
44
+ }));
45
+ }
46
+
47
+ if ("function" == typeof substitution) {
48
+ var _this = this;
49
+
50
+ return _super[Symbol.replace].call(this, str, function () {
51
+ var args = arguments;
52
+ return "object" != typeof args[args.length - 1] && (args = [].slice.call(args)).push(buildGroups(args, _this)), substitution.apply(this, args);
53
+ });
54
+ }
55
+
56
+ return _super[Symbol.replace].call(this, str, substitution);
57
+ }, _wrapRegExp.apply(this, arguments);
58
+ }
59
+
60
+ function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
61
+ try {
62
+ var info = gen[key](arg);
63
+ var value = info.value;
64
+ } catch (error) {
65
+ reject(error);
66
+ return;
67
+ }
68
+
69
+ if (info.done) {
70
+ resolve(value);
71
+ } else {
72
+ Promise.resolve(value).then(_next, _throw);
73
+ }
74
+ }
75
+
76
+ function _asyncToGenerator(fn) {
77
+ return function () {
78
+ var self = this,
79
+ args = arguments;
80
+ return new Promise(function (resolve, reject) {
81
+ var gen = fn.apply(self, args);
82
+
83
+ function _next(value) {
84
+ asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
85
+ }
86
+
87
+ function _throw(err) {
88
+ asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
89
+ }
90
+
91
+ _next(undefined);
92
+ });
93
+ };
94
+ }
95
+
96
+ function _extends() {
97
+ _extends = Object.assign || function (target) {
98
+ for (var i = 1; i < arguments.length; i++) {
99
+ var source = arguments[i];
100
+
101
+ for (var key in source) {
102
+ if (Object.prototype.hasOwnProperty.call(source, key)) {
103
+ target[key] = source[key];
104
+ }
105
+ }
106
+ }
107
+
108
+ return target;
109
+ };
110
+
111
+ return _extends.apply(this, arguments);
112
+ }
113
+
114
+ function _inherits(subClass, superClass) {
115
+ if (typeof superClass !== "function" && superClass !== null) {
116
+ throw new TypeError("Super expression must either be null or a function");
117
+ }
118
+
119
+ subClass.prototype = Object.create(superClass && superClass.prototype, {
120
+ constructor: {
121
+ value: subClass,
122
+ writable: true,
123
+ configurable: true
124
+ }
125
+ });
126
+ Object.defineProperty(subClass, "prototype", {
127
+ writable: false
128
+ });
129
+ if (superClass) _setPrototypeOf(subClass, superClass);
130
+ }
131
+
132
+ function _inheritsLoose(subClass, superClass) {
133
+ subClass.prototype = Object.create(superClass.prototype);
134
+ subClass.prototype.constructor = subClass;
135
+
136
+ _setPrototypeOf(subClass, superClass);
137
+ }
14
138
 
15
- _regeneratorRuntime = function () {
16
- return exports;
139
+ function _getPrototypeOf(o) {
140
+ _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
141
+ return o.__proto__ || Object.getPrototypeOf(o);
142
+ };
143
+ return _getPrototypeOf(o);
144
+ }
145
+
146
+ function _setPrototypeOf(o, p) {
147
+ _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
148
+ o.__proto__ = p;
149
+ return o;
17
150
  };
18
151
 
19
- var exports = {},
20
- Op = Object.prototype,
21
- hasOwn = Op.hasOwnProperty,
22
- $Symbol = "function" == typeof Symbol ? Symbol : {},
23
- iteratorSymbol = $Symbol.iterator || "@@iterator",
24
- asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
25
- toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
152
+ return _setPrototypeOf(o, p);
153
+ }
154
+
155
+ function _isNativeReflectConstruct() {
156
+ if (typeof Reflect === "undefined" || !Reflect.construct) return false;
157
+ if (Reflect.construct.sham) return false;
158
+ if (typeof Proxy === "function") return true;
159
+
160
+ try {
161
+ Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
162
+ return true;
163
+ } catch (e) {
164
+ return false;
165
+ }
166
+ }
167
+
168
+ function _construct(Parent, args, Class) {
169
+ if (_isNativeReflectConstruct()) {
170
+ _construct = Reflect.construct;
171
+ } else {
172
+ _construct = function _construct(Parent, args, Class) {
173
+ var a = [null];
174
+ a.push.apply(a, args);
175
+ var Constructor = Function.bind.apply(Parent, a);
176
+ var instance = new Constructor();
177
+ if (Class) _setPrototypeOf(instance, Class.prototype);
178
+ return instance;
179
+ };
180
+ }
181
+
182
+ return _construct.apply(null, arguments);
183
+ }
184
+
185
+ function _isNativeFunction(fn) {
186
+ return Function.toString.call(fn).indexOf("[native code]") !== -1;
187
+ }
188
+
189
+ function _wrapNativeSuper(Class) {
190
+ var _cache = typeof Map === "function" ? new Map() : undefined;
191
+
192
+ _wrapNativeSuper = function _wrapNativeSuper(Class) {
193
+ if (Class === null || !_isNativeFunction(Class)) return Class;
194
+
195
+ if (typeof Class !== "function") {
196
+ throw new TypeError("Super expression must either be null or a function");
197
+ }
198
+
199
+ if (typeof _cache !== "undefined") {
200
+ if (_cache.has(Class)) return _cache.get(Class);
201
+
202
+ _cache.set(Class, Wrapper);
203
+ }
204
+
205
+ function Wrapper() {
206
+ return _construct(Class, arguments, _getPrototypeOf(this).constructor);
207
+ }
208
+
209
+ Wrapper.prototype = Object.create(Class.prototype, {
210
+ constructor: {
211
+ value: Wrapper,
212
+ enumerable: false,
213
+ writable: true,
214
+ configurable: true
215
+ }
216
+ });
217
+ return _setPrototypeOf(Wrapper, Class);
218
+ };
219
+
220
+ return _wrapNativeSuper(Class);
221
+ }
222
+
223
+ function _objectWithoutPropertiesLoose(source, excluded) {
224
+ if (source == null) return {};
225
+ var target = {};
226
+ var sourceKeys = Object.keys(source);
227
+ var key, i;
228
+
229
+ for (i = 0; i < sourceKeys.length; i++) {
230
+ key = sourceKeys[i];
231
+ if (excluded.indexOf(key) >= 0) continue;
232
+ target[key] = source[key];
233
+ }
234
+
235
+ return target;
236
+ }
237
+
238
+ function _unsupportedIterableToArray(o, minLen) {
239
+ if (!o) return;
240
+ if (typeof o === "string") return _arrayLikeToArray(o, minLen);
241
+ var n = Object.prototype.toString.call(o).slice(8, -1);
242
+ if (n === "Object" && o.constructor) n = o.constructor.name;
243
+ if (n === "Map" || n === "Set") return Array.from(o);
244
+ if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
245
+ }
246
+
247
+ function _arrayLikeToArray(arr, len) {
248
+ if (len == null || len > arr.length) len = arr.length;
249
+
250
+ for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
251
+
252
+ return arr2;
253
+ }
254
+
255
+ function _createForOfIteratorHelperLoose(o, allowArrayLike) {
256
+ var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
257
+ if (it) return (it = it.call(o)).next.bind(it);
258
+
259
+ if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
260
+ if (it) o = it;
261
+ var i = 0;
262
+ return function () {
263
+ if (i >= o.length) return {
264
+ done: true
265
+ };
266
+ return {
267
+ done: false,
268
+ value: o[i++]
269
+ };
270
+ };
271
+ }
272
+
273
+ throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
274
+ }
275
+
276
+ function createCommonjsModule(fn, module) {
277
+ return module = { exports: {} }, fn(module, module.exports), module.exports;
278
+ }
279
+
280
+ var runtime_1 = createCommonjsModule(function (module) {
281
+ /**
282
+ * Copyright (c) 2014-present, Facebook, Inc.
283
+ *
284
+ * This source code is licensed under the MIT license found in the
285
+ * LICENSE file in the root directory of this source tree.
286
+ */
287
+
288
+ var runtime = (function (exports) {
289
+
290
+ var Op = Object.prototype;
291
+ var hasOwn = Op.hasOwnProperty;
292
+ var undefined$1; // More compressible than void 0.
293
+ var $Symbol = typeof Symbol === "function" ? Symbol : {};
294
+ var iteratorSymbol = $Symbol.iterator || "@@iterator";
295
+ var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
296
+ var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
26
297
 
27
298
  function define(obj, key, value) {
28
- return Object.defineProperty(obj, key, {
299
+ Object.defineProperty(obj, key, {
29
300
  value: value,
30
- enumerable: !0,
31
- configurable: !0,
32
- writable: !0
33
- }), obj[key];
301
+ enumerable: true,
302
+ configurable: true,
303
+ writable: true
304
+ });
305
+ return obj[key];
34
306
  }
35
-
36
307
  try {
308
+ // IE 8 has a broken Object.defineProperty that only works on DOM objects.
37
309
  define({}, "");
38
310
  } catch (err) {
39
- define = function (obj, key, value) {
311
+ define = function(obj, key, value) {
40
312
  return obj[key] = value;
41
313
  };
42
314
  }
43
315
 
44
316
  function wrap(innerFn, outerFn, self, tryLocsList) {
45
- var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
46
- generator = Object.create(protoGenerator.prototype),
47
- context = new Context(tryLocsList || []);
48
- return generator._invoke = function (innerFn, self, context) {
49
- var state = "suspendedStart";
50
- return function (method, arg) {
51
- if ("executing" === state) throw new Error("Generator is already running");
52
-
53
- if ("completed" === state) {
54
- if ("throw" === method) throw arg;
55
- return doneResult();
56
- }
57
-
58
- for (context.method = method, context.arg = arg;;) {
59
- var delegate = context.delegate;
317
+ // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
318
+ var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
319
+ var generator = Object.create(protoGenerator.prototype);
320
+ var context = new Context(tryLocsList || []);
60
321
 
61
- if (delegate) {
62
- var delegateResult = maybeInvokeDelegate(delegate, context);
322
+ // The ._invoke method unifies the implementations of the .next,
323
+ // .throw, and .return methods.
324
+ generator._invoke = makeInvokeMethod(innerFn, self, context);
63
325
 
64
- if (delegateResult) {
65
- if (delegateResult === ContinueSentinel) continue;
66
- return delegateResult;
67
- }
68
- }
69
-
70
- if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
71
- if ("suspendedStart" === state) throw state = "completed", context.arg;
72
- context.dispatchException(context.arg);
73
- } else "return" === context.method && context.abrupt("return", context.arg);
74
- state = "executing";
75
- var record = tryCatch(innerFn, self, context);
76
-
77
- if ("normal" === record.type) {
78
- if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
79
- return {
80
- value: record.arg,
81
- done: context.done
82
- };
83
- }
84
-
85
- "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
86
- }
87
- };
88
- }(innerFn, self, context), generator;
326
+ return generator;
89
327
  }
328
+ exports.wrap = wrap;
90
329
 
330
+ // Try/catch helper to minimize deoptimizations. Returns a completion
331
+ // record like context.tryEntries[i].completion. This interface could
332
+ // have been (and was previously) designed to take a closure to be
333
+ // invoked without arguments, but in all the cases we care about we
334
+ // already have an existing method we want to call, so there's no need
335
+ // to create a new function object. We can even get away with assuming
336
+ // the method takes exactly one argument, since that happens to be true
337
+ // in every case, so we don't have to touch the arguments object. The
338
+ // only additional allocation required is the completion record, which
339
+ // has a stable shape and so hopefully should be cheap to allocate.
91
340
  function tryCatch(fn, obj, arg) {
92
341
  try {
93
- return {
94
- type: "normal",
95
- arg: fn.call(obj, arg)
96
- };
342
+ return { type: "normal", arg: fn.call(obj, arg) };
97
343
  } catch (err) {
98
- return {
99
- type: "throw",
100
- arg: err
101
- };
344
+ return { type: "throw", arg: err };
102
345
  }
103
346
  }
104
347
 
105
- exports.wrap = wrap;
348
+ var GenStateSuspendedStart = "suspendedStart";
349
+ var GenStateSuspendedYield = "suspendedYield";
350
+ var GenStateExecuting = "executing";
351
+ var GenStateCompleted = "completed";
352
+
353
+ // Returning this object from the innerFn has the same effect as
354
+ // breaking out of the dispatch switch statement.
106
355
  var ContinueSentinel = {};
107
356
 
357
+ // Dummy constructor functions that we use as the .constructor and
358
+ // .constructor.prototype properties for functions that return Generator
359
+ // objects. For full spec compliance, you may wish to configure your
360
+ // minifier not to mangle the names of these two functions.
108
361
  function Generator() {}
109
-
110
362
  function GeneratorFunction() {}
111
-
112
363
  function GeneratorFunctionPrototype() {}
113
364
 
365
+ // This is a polyfill for %IteratorPrototype% for environments that
366
+ // don't natively support it.
114
367
  var IteratorPrototype = {};
115
368
  define(IteratorPrototype, iteratorSymbol, function () {
116
369
  return this;
117
370
  });
118
- var getProto = Object.getPrototypeOf,
119
- NativeIteratorPrototype = getProto && getProto(getProto(values([])));
120
- NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
121
- var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
122
371
 
372
+ var getProto = Object.getPrototypeOf;
373
+ var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
374
+ if (NativeIteratorPrototype &&
375
+ NativeIteratorPrototype !== Op &&
376
+ hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
377
+ // This environment has a native %IteratorPrototype%; use it instead
378
+ // of the polyfill.
379
+ IteratorPrototype = NativeIteratorPrototype;
380
+ }
381
+
382
+ var Gp = GeneratorFunctionPrototype.prototype =
383
+ Generator.prototype = Object.create(IteratorPrototype);
384
+ GeneratorFunction.prototype = GeneratorFunctionPrototype;
385
+ define(Gp, "constructor", GeneratorFunctionPrototype);
386
+ define(GeneratorFunctionPrototype, "constructor", GeneratorFunction);
387
+ GeneratorFunction.displayName = define(
388
+ GeneratorFunctionPrototype,
389
+ toStringTagSymbol,
390
+ "GeneratorFunction"
391
+ );
392
+
393
+ // Helper for defining the .next, .throw, and .return methods of the
394
+ // Iterator interface in terms of a single ._invoke method.
123
395
  function defineIteratorMethods(prototype) {
124
- ["next", "throw", "return"].forEach(function (method) {
125
- define(prototype, method, function (arg) {
396
+ ["next", "throw", "return"].forEach(function(method) {
397
+ define(prototype, method, function(arg) {
126
398
  return this._invoke(method, arg);
127
399
  });
128
400
  });
129
401
  }
130
402
 
403
+ exports.isGeneratorFunction = function(genFun) {
404
+ var ctor = typeof genFun === "function" && genFun.constructor;
405
+ return ctor
406
+ ? ctor === GeneratorFunction ||
407
+ // For the native GeneratorFunction constructor, the best we can
408
+ // do is to check its .name property.
409
+ (ctor.displayName || ctor.name) === "GeneratorFunction"
410
+ : false;
411
+ };
412
+
413
+ exports.mark = function(genFun) {
414
+ if (Object.setPrototypeOf) {
415
+ Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
416
+ } else {
417
+ genFun.__proto__ = GeneratorFunctionPrototype;
418
+ define(genFun, toStringTagSymbol, "GeneratorFunction");
419
+ }
420
+ genFun.prototype = Object.create(Gp);
421
+ return genFun;
422
+ };
423
+
424
+ // Within the body of any async function, `await x` is transformed to
425
+ // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
426
+ // `hasOwn.call(value, "__await")` to determine if the yielded value is
427
+ // meant to be awaited.
428
+ exports.awrap = function(arg) {
429
+ return { __await: arg };
430
+ };
431
+
131
432
  function AsyncIterator(generator, PromiseImpl) {
132
433
  function invoke(method, arg, resolve, reject) {
133
434
  var record = tryCatch(generator[method], generator, arg);
435
+ if (record.type === "throw") {
436
+ reject(record.arg);
437
+ } else {
438
+ var result = record.arg;
439
+ var value = result.value;
440
+ if (value &&
441
+ typeof value === "object" &&
442
+ hasOwn.call(value, "__await")) {
443
+ return PromiseImpl.resolve(value.__await).then(function(value) {
444
+ invoke("next", value, resolve, reject);
445
+ }, function(err) {
446
+ invoke("throw", err, resolve, reject);
447
+ });
448
+ }
134
449
 
135
- if ("throw" !== record.type) {
136
- var result = record.arg,
137
- value = result.value;
138
- return value && "object" == typeof value && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
139
- invoke("next", value, resolve, reject);
140
- }, function (err) {
141
- invoke("throw", err, resolve, reject);
142
- }) : PromiseImpl.resolve(value).then(function (unwrapped) {
143
- result.value = unwrapped, resolve(result);
144
- }, function (error) {
450
+ return PromiseImpl.resolve(value).then(function(unwrapped) {
451
+ // When a yielded Promise is resolved, its final value becomes
452
+ // the .value of the Promise<{value,done}> result for the
453
+ // current iteration.
454
+ result.value = unwrapped;
455
+ resolve(result);
456
+ }, function(error) {
457
+ // If a rejected Promise was yielded, throw the rejection back
458
+ // into the async generator function so it can be handled there.
145
459
  return invoke("throw", error, resolve, reject);
146
460
  });
147
461
  }
148
-
149
- reject(record.arg);
150
462
  }
151
463
 
152
464
  var previousPromise;
153
465
 
154
- this._invoke = function (method, arg) {
466
+ function enqueue(method, arg) {
155
467
  function callInvokeWithMethodAndArg() {
156
- return new PromiseImpl(function (resolve, reject) {
468
+ return new PromiseImpl(function(resolve, reject) {
157
469
  invoke(method, arg, resolve, reject);
158
470
  });
159
471
  }
160
472
 
161
- return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
162
- };
163
- }
164
-
165
- function maybeInvokeDelegate(delegate, context) {
166
- var method = delegate.iterator[context.method];
167
-
168
- if (undefined === method) {
169
- if (context.delegate = null, "throw" === context.method) {
170
- if (delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method)) return ContinueSentinel;
171
- context.method = "throw", context.arg = new TypeError("The iterator does not provide a 'throw' method");
172
- }
173
-
174
- return ContinueSentinel;
473
+ return previousPromise =
474
+ // If enqueue has been called before, then we want to wait until
475
+ // all previous Promises have been resolved before calling invoke,
476
+ // so that results are always delivered in the correct order. If
477
+ // enqueue has not been called before, then it is important to
478
+ // call invoke immediately, without waiting on a callback to fire,
479
+ // so that the async generator function has the opportunity to do
480
+ // any necessary setup in a predictable way. This predictability
481
+ // is why the Promise constructor synchronously invokes its
482
+ // executor callback, and why async functions synchronously
483
+ // execute code before the first await. Since we implement simple
484
+ // async functions in terms of async generators, it is especially
485
+ // important to get this right, even though it requires care.
486
+ previousPromise ? previousPromise.then(
487
+ callInvokeWithMethodAndArg,
488
+ // Avoid propagating failures to Promises returned by later
489
+ // invocations of the iterator.
490
+ callInvokeWithMethodAndArg
491
+ ) : callInvokeWithMethodAndArg();
175
492
  }
176
493
 
177
- var record = tryCatch(method, delegate.iterator, context.arg);
178
- if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
179
- var info = record.arg;
180
- 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);
494
+ // Define the unified helper method that is used to implement .next,
495
+ // .throw, and .return (see defineIteratorMethods).
496
+ this._invoke = enqueue;
181
497
  }
182
498
 
183
- function pushTryEntry(locs) {
184
- var entry = {
185
- tryLoc: locs[0]
186
- };
187
- 1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
188
- }
189
-
190
- function resetTryEntry(entry) {
191
- var record = entry.completion || {};
192
- record.type = "normal", delete record.arg, entry.completion = record;
193
- }
194
-
195
- function Context(tryLocsList) {
196
- this.tryEntries = [{
197
- tryLoc: "root"
198
- }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
199
- }
499
+ defineIteratorMethods(AsyncIterator.prototype);
500
+ define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
501
+ return this;
502
+ });
503
+ exports.AsyncIterator = AsyncIterator;
504
+
505
+ // Note that simple async functions are implemented on top of
506
+ // AsyncIterator objects; they just return a Promise for the value of
507
+ // the final result produced by the iterator.
508
+ exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {
509
+ if (PromiseImpl === void 0) PromiseImpl = Promise;
510
+
511
+ var iter = new AsyncIterator(
512
+ wrap(innerFn, outerFn, self, tryLocsList),
513
+ PromiseImpl
514
+ );
515
+
516
+ return exports.isGeneratorFunction(outerFn)
517
+ ? iter // If outerFn is a generator, return the full iterator.
518
+ : iter.next().then(function(result) {
519
+ return result.done ? result.value : iter.next();
520
+ });
521
+ };
200
522
 
201
- function values(iterable) {
202
- if (iterable) {
203
- var iteratorMethod = iterable[iteratorSymbol];
204
- if (iteratorMethod) return iteratorMethod.call(iterable);
205
- if ("function" == typeof iterable.next) return iterable;
523
+ function makeInvokeMethod(innerFn, self, context) {
524
+ var state = GenStateSuspendedStart;
206
525
 
207
- if (!isNaN(iterable.length)) {
208
- var i = -1,
209
- next = function next() {
210
- for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
526
+ return function invoke(method, arg) {
527
+ if (state === GenStateExecuting) {
528
+ throw new Error("Generator is already running");
529
+ }
211
530
 
212
- return next.value = undefined, next.done = !0, next;
213
- };
531
+ if (state === GenStateCompleted) {
532
+ if (method === "throw") {
533
+ throw arg;
534
+ }
214
535
 
215
- return next.next = next;
536
+ // Be forgiving, per 25.3.3.3.3 of the spec:
537
+ // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
538
+ return doneResult();
216
539
  }
217
- }
218
540
 
219
- return {
220
- next: doneResult
221
- };
222
- }
223
-
224
- function doneResult() {
225
- return {
226
- value: undefined,
227
- done: !0
228
- };
229
- }
541
+ context.method = method;
542
+ context.arg = arg;
230
543
 
231
- return GeneratorFunction.prototype = GeneratorFunctionPrototype, define(Gp, "constructor", GeneratorFunctionPrototype), define(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
232
- var ctor = "function" == typeof genFun && genFun.constructor;
233
- return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
234
- }, exports.mark = function (genFun) {
235
- return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
236
- }, exports.awrap = function (arg) {
237
- return {
238
- __await: arg
239
- };
240
- }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
241
- return this;
242
- }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
243
- void 0 === PromiseImpl && (PromiseImpl = Promise);
244
- var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
245
- return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
246
- return result.done ? result.value : iter.next();
247
- });
248
- }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
249
- return this;
250
- }), define(Gp, "toString", function () {
251
- return "[object Generator]";
252
- }), exports.keys = function (object) {
253
- var keys = [];
544
+ while (true) {
545
+ var delegate = context.delegate;
546
+ if (delegate) {
547
+ var delegateResult = maybeInvokeDelegate(delegate, context);
548
+ if (delegateResult) {
549
+ if (delegateResult === ContinueSentinel) continue;
550
+ return delegateResult;
551
+ }
552
+ }
254
553
 
255
- for (var key in object) keys.push(key);
554
+ if (context.method === "next") {
555
+ // Setting context._sent for legacy support of Babel's
556
+ // function.sent implementation.
557
+ context.sent = context._sent = context.arg;
256
558
 
257
- return keys.reverse(), function next() {
258
- for (; keys.length;) {
259
- var key = keys.pop();
260
- if (key in object) return next.value = key, next.done = !1, next;
261
- }
559
+ } else if (context.method === "throw") {
560
+ if (state === GenStateSuspendedStart) {
561
+ state = GenStateCompleted;
562
+ throw context.arg;
563
+ }
262
564
 
263
- return next.done = !0, next;
264
- };
265
- }, exports.values = values, Context.prototype = {
266
- constructor: Context,
267
- reset: function (skipTempReset) {
268
- 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);
269
- },
270
- stop: function () {
271
- this.done = !0;
272
- var rootRecord = this.tryEntries[0].completion;
273
- if ("throw" === rootRecord.type) throw rootRecord.arg;
274
- return this.rval;
275
- },
276
- dispatchException: function (exception) {
277
- if (this.done) throw exception;
278
- var context = this;
565
+ context.dispatchException(context.arg);
279
566
 
280
- function handle(loc, caught) {
281
- return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
282
- }
567
+ } else if (context.method === "return") {
568
+ context.abrupt("return", context.arg);
569
+ }
283
570
 
284
- for (var i = this.tryEntries.length - 1; i >= 0; --i) {
285
- var entry = this.tryEntries[i],
286
- record = entry.completion;
287
- if ("root" === entry.tryLoc) return handle("end");
571
+ state = GenStateExecuting;
288
572
 
289
- if (entry.tryLoc <= this.prev) {
290
- var hasCatch = hasOwn.call(entry, "catchLoc"),
291
- hasFinally = hasOwn.call(entry, "finallyLoc");
573
+ var record = tryCatch(innerFn, self, context);
574
+ if (record.type === "normal") {
575
+ // If an exception is thrown from innerFn, we leave state ===
576
+ // GenStateExecuting and loop back for another invocation.
577
+ state = context.done
578
+ ? GenStateCompleted
579
+ : GenStateSuspendedYield;
292
580
 
293
- if (hasCatch && hasFinally) {
294
- if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
295
- if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
296
- } else if (hasCatch) {
297
- if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
298
- } else {
299
- if (!hasFinally) throw new Error("try statement without catch or finally");
300
- if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
581
+ if (record.arg === ContinueSentinel) {
582
+ continue;
301
583
  }
584
+
585
+ return {
586
+ value: record.arg,
587
+ done: context.done
588
+ };
589
+
590
+ } else if (record.type === "throw") {
591
+ state = GenStateCompleted;
592
+ // Dispatch the exception by looping back around to the
593
+ // context.dispatchException(context.arg) call above.
594
+ context.method = "throw";
595
+ context.arg = record.arg;
302
596
  }
303
597
  }
304
- },
305
- abrupt: function (type, arg) {
306
- for (var i = this.tryEntries.length - 1; i >= 0; --i) {
307
- var entry = this.tryEntries[i];
598
+ };
599
+ }
308
600
 
309
- if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
310
- var finallyEntry = entry;
311
- break;
601
+ // Call delegate.iterator[context.method](context.arg) and handle the
602
+ // result, either by returning a { value, done } result from the
603
+ // delegate iterator, or by modifying context.method and context.arg,
604
+ // setting context.delegate to null, and returning the ContinueSentinel.
605
+ function maybeInvokeDelegate(delegate, context) {
606
+ var method = delegate.iterator[context.method];
607
+ if (method === undefined$1) {
608
+ // A .throw or .return when the delegate iterator has no .throw
609
+ // method always terminates the yield* loop.
610
+ context.delegate = null;
611
+
612
+ if (context.method === "throw") {
613
+ // Note: ["return"] must be used for ES3 parsing compatibility.
614
+ if (delegate.iterator["return"]) {
615
+ // If the delegate iterator has a return method, give it a
616
+ // chance to clean up.
617
+ context.method = "return";
618
+ context.arg = undefined$1;
619
+ maybeInvokeDelegate(delegate, context);
620
+
621
+ if (context.method === "throw") {
622
+ // If maybeInvokeDelegate(context) changed context.method from
623
+ // "return" to "throw", let that override the TypeError below.
624
+ return ContinueSentinel;
625
+ }
312
626
  }
313
- }
314
627
 
315
- finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
316
- var record = finallyEntry ? finallyEntry.completion : {};
317
- return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
318
- },
319
- complete: function (record, afterLoc) {
320
- if ("throw" === record.type) throw record.arg;
321
- 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;
322
- },
323
- finish: function (finallyLoc) {
324
- for (var i = this.tryEntries.length - 1; i >= 0; --i) {
325
- var entry = this.tryEntries[i];
326
- if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
628
+ context.method = "throw";
629
+ context.arg = new TypeError(
630
+ "The iterator does not provide a 'throw' method");
327
631
  }
328
- },
329
- catch: function (tryLoc) {
330
- for (var i = this.tryEntries.length - 1; i >= 0; --i) {
331
- var entry = this.tryEntries[i];
332
632
 
333
- if (entry.tryLoc === tryLoc) {
334
- var record = entry.completion;
335
-
336
- if ("throw" === record.type) {
337
- var thrown = record.arg;
338
- resetTryEntry(entry);
339
- }
633
+ return ContinueSentinel;
634
+ }
340
635
 
341
- return thrown;
342
- }
343
- }
636
+ var record = tryCatch(method, delegate.iterator, context.arg);
344
637
 
345
- throw new Error("illegal catch attempt");
346
- },
347
- delegateYield: function (iterable, resultName, nextLoc) {
348
- return this.delegate = {
349
- iterator: values(iterable),
350
- resultName: resultName,
351
- nextLoc: nextLoc
352
- }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
638
+ if (record.type === "throw") {
639
+ context.method = "throw";
640
+ context.arg = record.arg;
641
+ context.delegate = null;
642
+ return ContinueSentinel;
353
643
  }
354
- }, exports;
355
- }
356
644
 
357
- function _wrapRegExp() {
358
- _wrapRegExp = function (re, groups) {
359
- return new BabelRegExp(re, void 0, groups);
360
- };
645
+ var info = record.arg;
361
646
 
362
- var _super = RegExp.prototype,
363
- _groups = new WeakMap();
647
+ if (! info) {
648
+ context.method = "throw";
649
+ context.arg = new TypeError("iterator result is not an object");
650
+ context.delegate = null;
651
+ return ContinueSentinel;
652
+ }
364
653
 
365
- function BabelRegExp(re, flags, groups) {
366
- var _this = new RegExp(re, flags);
654
+ if (info.done) {
655
+ // Assign the result of the finished delegate to the temporary
656
+ // variable specified by delegate.resultName (see delegateYield).
657
+ context[delegate.resultName] = info.value;
658
+
659
+ // Resume execution at the desired location (see delegateYield).
660
+ context.next = delegate.nextLoc;
661
+
662
+ // If context.method was "throw" but the delegate handled the
663
+ // exception, let the outer generator proceed normally. If
664
+ // context.method was "next", forget context.arg since it has been
665
+ // "consumed" by the delegate iterator. If context.method was
666
+ // "return", allow the original .return call to continue in the
667
+ // outer generator.
668
+ if (context.method !== "return") {
669
+ context.method = "next";
670
+ context.arg = undefined$1;
671
+ }
367
672
 
368
- return _groups.set(_this, groups || _groups.get(re)), _setPrototypeOf(_this, BabelRegExp.prototype);
673
+ } else {
674
+ // Re-yield the result returned by the delegate method.
675
+ return info;
676
+ }
677
+
678
+ // The delegate iterator is finished, so forget it and continue with
679
+ // the outer generator.
680
+ context.delegate = null;
681
+ return ContinueSentinel;
369
682
  }
370
683
 
371
- function buildGroups(result, re) {
372
- var g = _groups.get(re);
684
+ // Define Generator.prototype.{next,throw,return} in terms of the
685
+ // unified ._invoke helper method.
686
+ defineIteratorMethods(Gp);
373
687
 
374
- return Object.keys(g).reduce(function (groups, name) {
375
- return groups[name] = result[g[name]], groups;
376
- }, Object.create(null));
377
- }
688
+ define(Gp, toStringTagSymbol, "Generator");
378
689
 
379
- return _inherits(BabelRegExp, RegExp), BabelRegExp.prototype.exec = function (str) {
380
- var result = _super.exec.call(this, str);
690
+ // A Generator should always return itself as the iterator object when the
691
+ // @@iterator function is called on it. Some browsers' implementations of the
692
+ // iterator prototype chain incorrectly implement this, causing the Generator
693
+ // object to not be returned from this call. This ensures that doesn't happen.
694
+ // See https://github.com/facebook/regenerator/issues/274 for more details.
695
+ define(Gp, iteratorSymbol, function() {
696
+ return this;
697
+ });
381
698
 
382
- return result && (result.groups = buildGroups(result, this)), result;
383
- }, BabelRegExp.prototype[Symbol.replace] = function (str, substitution) {
384
- if ("string" == typeof substitution) {
385
- var groups = _groups.get(this);
699
+ define(Gp, "toString", function() {
700
+ return "[object Generator]";
701
+ });
386
702
 
387
- return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) {
388
- return "$" + groups[name];
389
- }));
390
- }
703
+ function pushTryEntry(locs) {
704
+ var entry = { tryLoc: locs[0] };
391
705
 
392
- if ("function" == typeof substitution) {
393
- var _this = this;
706
+ if (1 in locs) {
707
+ entry.catchLoc = locs[1];
708
+ }
394
709
 
395
- return _super[Symbol.replace].call(this, str, function () {
396
- var args = arguments;
397
- return "object" != typeof args[args.length - 1] && (args = [].slice.call(args)).push(buildGroups(args, _this)), substitution.apply(this, args);
398
- });
710
+ if (2 in locs) {
711
+ entry.finallyLoc = locs[2];
712
+ entry.afterLoc = locs[3];
399
713
  }
400
714
 
401
- return _super[Symbol.replace].call(this, str, substitution);
402
- }, _wrapRegExp.apply(this, arguments);
403
- }
715
+ this.tryEntries.push(entry);
716
+ }
404
717
 
405
- function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
406
- try {
407
- var info = gen[key](arg);
408
- var value = info.value;
409
- } catch (error) {
410
- reject(error);
411
- return;
718
+ function resetTryEntry(entry) {
719
+ var record = entry.completion || {};
720
+ record.type = "normal";
721
+ delete record.arg;
722
+ entry.completion = record;
412
723
  }
413
724
 
414
- if (info.done) {
415
- resolve(value);
416
- } else {
417
- Promise.resolve(value).then(_next, _throw);
725
+ function Context(tryLocsList) {
726
+ // The root entry object (effectively a try statement without a catch
727
+ // or a finally block) gives us a place to store values thrown from
728
+ // locations where there is no enclosing try statement.
729
+ this.tryEntries = [{ tryLoc: "root" }];
730
+ tryLocsList.forEach(pushTryEntry, this);
731
+ this.reset(true);
418
732
  }
419
- }
420
733
 
421
- function _asyncToGenerator(fn) {
422
- return function () {
423
- var self = this,
424
- args = arguments;
425
- return new Promise(function (resolve, reject) {
426
- var gen = fn.apply(self, args);
734
+ exports.keys = function(object) {
735
+ var keys = [];
736
+ for (var key in object) {
737
+ keys.push(key);
738
+ }
739
+ keys.reverse();
427
740
 
428
- function _next(value) {
429
- asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
741
+ // Rather than returning an object with a next method, we keep
742
+ // things simple and return the next function itself.
743
+ return function next() {
744
+ while (keys.length) {
745
+ var key = keys.pop();
746
+ if (key in object) {
747
+ next.value = key;
748
+ next.done = false;
749
+ return next;
750
+ }
430
751
  }
431
752
 
432
- function _throw(err) {
433
- asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
753
+ // To avoid creating an additional object, we just hang the .value
754
+ // and .done properties off the next function object itself. This
755
+ // also ensures that the minifier will not anonymize the function.
756
+ next.done = true;
757
+ return next;
758
+ };
759
+ };
760
+
761
+ function values(iterable) {
762
+ if (iterable) {
763
+ var iteratorMethod = iterable[iteratorSymbol];
764
+ if (iteratorMethod) {
765
+ return iteratorMethod.call(iterable);
434
766
  }
435
767
 
436
- _next(undefined);
437
- });
438
- };
439
- }
768
+ if (typeof iterable.next === "function") {
769
+ return iterable;
770
+ }
440
771
 
441
- function _extends() {
442
- _extends = Object.assign ? Object.assign.bind() : function (target) {
443
- for (var i = 1; i < arguments.length; i++) {
444
- var source = arguments[i];
772
+ if (!isNaN(iterable.length)) {
773
+ var i = -1, next = function next() {
774
+ while (++i < iterable.length) {
775
+ if (hasOwn.call(iterable, i)) {
776
+ next.value = iterable[i];
777
+ next.done = false;
778
+ return next;
779
+ }
780
+ }
445
781
 
446
- for (var key in source) {
447
- if (Object.prototype.hasOwnProperty.call(source, key)) {
448
- target[key] = source[key];
449
- }
782
+ next.value = undefined$1;
783
+ next.done = true;
784
+
785
+ return next;
786
+ };
787
+
788
+ return next.next = next;
450
789
  }
451
790
  }
452
791
 
453
- return target;
454
- };
455
- return _extends.apply(this, arguments);
456
- }
792
+ // Return an iterator with no values.
793
+ return { next: doneResult };
794
+ }
795
+ exports.values = values;
457
796
 
458
- function _inherits(subClass, superClass) {
459
- if (typeof superClass !== "function" && superClass !== null) {
460
- throw new TypeError("Super expression must either be null or a function");
797
+ function doneResult() {
798
+ return { value: undefined$1, done: true };
461
799
  }
462
800
 
463
- subClass.prototype = Object.create(superClass && superClass.prototype, {
464
- constructor: {
465
- value: subClass,
466
- writable: true,
467
- configurable: true
468
- }
469
- });
470
- Object.defineProperty(subClass, "prototype", {
471
- writable: false
472
- });
473
- if (superClass) _setPrototypeOf(subClass, superClass);
474
- }
801
+ Context.prototype = {
802
+ constructor: Context,
475
803
 
476
- function _inheritsLoose(subClass, superClass) {
477
- subClass.prototype = Object.create(superClass.prototype);
478
- subClass.prototype.constructor = subClass;
804
+ reset: function(skipTempReset) {
805
+ this.prev = 0;
806
+ this.next = 0;
807
+ // Resetting context._sent for legacy support of Babel's
808
+ // function.sent implementation.
809
+ this.sent = this._sent = undefined$1;
810
+ this.done = false;
811
+ this.delegate = null;
812
+
813
+ this.method = "next";
814
+ this.arg = undefined$1;
815
+
816
+ this.tryEntries.forEach(resetTryEntry);
817
+
818
+ if (!skipTempReset) {
819
+ for (var name in this) {
820
+ // Not sure about the optimal order of these conditions:
821
+ if (name.charAt(0) === "t" &&
822
+ hasOwn.call(this, name) &&
823
+ !isNaN(+name.slice(1))) {
824
+ this[name] = undefined$1;
825
+ }
826
+ }
827
+ }
828
+ },
479
829
 
480
- _setPrototypeOf(subClass, superClass);
481
- }
830
+ stop: function() {
831
+ this.done = true;
482
832
 
483
- function _getPrototypeOf(o) {
484
- _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
485
- return o.__proto__ || Object.getPrototypeOf(o);
486
- };
487
- return _getPrototypeOf(o);
488
- }
833
+ var rootEntry = this.tryEntries[0];
834
+ var rootRecord = rootEntry.completion;
835
+ if (rootRecord.type === "throw") {
836
+ throw rootRecord.arg;
837
+ }
489
838
 
490
- function _setPrototypeOf(o, p) {
491
- _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
492
- o.__proto__ = p;
493
- return o;
494
- };
495
- return _setPrototypeOf(o, p);
496
- }
839
+ return this.rval;
840
+ },
497
841
 
498
- function _isNativeReflectConstruct() {
499
- if (typeof Reflect === "undefined" || !Reflect.construct) return false;
500
- if (Reflect.construct.sham) return false;
501
- if (typeof Proxy === "function") return true;
842
+ dispatchException: function(exception) {
843
+ if (this.done) {
844
+ throw exception;
845
+ }
502
846
 
503
- try {
504
- Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
505
- return true;
506
- } catch (e) {
507
- return false;
508
- }
509
- }
847
+ var context = this;
848
+ function handle(loc, caught) {
849
+ record.type = "throw";
850
+ record.arg = exception;
851
+ context.next = loc;
852
+
853
+ if (caught) {
854
+ // If the dispatched exception was caught by a catch block,
855
+ // then let that catch block handle the exception normally.
856
+ context.method = "next";
857
+ context.arg = undefined$1;
858
+ }
510
859
 
511
- function _construct(Parent, args, Class) {
512
- if (_isNativeReflectConstruct()) {
513
- _construct = Reflect.construct.bind();
514
- } else {
515
- _construct = function _construct(Parent, args, Class) {
516
- var a = [null];
517
- a.push.apply(a, args);
518
- var Constructor = Function.bind.apply(Parent, a);
519
- var instance = new Constructor();
520
- if (Class) _setPrototypeOf(instance, Class.prototype);
521
- return instance;
522
- };
523
- }
860
+ return !! caught;
861
+ }
524
862
 
525
- return _construct.apply(null, arguments);
526
- }
863
+ for (var i = this.tryEntries.length - 1; i >= 0; --i) {
864
+ var entry = this.tryEntries[i];
865
+ var record = entry.completion;
527
866
 
528
- function _isNativeFunction(fn) {
529
- return Function.toString.call(fn).indexOf("[native code]") !== -1;
530
- }
867
+ if (entry.tryLoc === "root") {
868
+ // Exception thrown outside of any try block that could handle
869
+ // it, so set the completion value of the entire function to
870
+ // throw the exception.
871
+ return handle("end");
872
+ }
531
873
 
532
- function _wrapNativeSuper(Class) {
533
- var _cache = typeof Map === "function" ? new Map() : undefined;
874
+ if (entry.tryLoc <= this.prev) {
875
+ var hasCatch = hasOwn.call(entry, "catchLoc");
876
+ var hasFinally = hasOwn.call(entry, "finallyLoc");
534
877
 
535
- _wrapNativeSuper = function _wrapNativeSuper(Class) {
536
- if (Class === null || !_isNativeFunction(Class)) return Class;
878
+ if (hasCatch && hasFinally) {
879
+ if (this.prev < entry.catchLoc) {
880
+ return handle(entry.catchLoc, true);
881
+ } else if (this.prev < entry.finallyLoc) {
882
+ return handle(entry.finallyLoc);
883
+ }
537
884
 
538
- if (typeof Class !== "function") {
539
- throw new TypeError("Super expression must either be null or a function");
540
- }
885
+ } else if (hasCatch) {
886
+ if (this.prev < entry.catchLoc) {
887
+ return handle(entry.catchLoc, true);
888
+ }
541
889
 
542
- if (typeof _cache !== "undefined") {
543
- if (_cache.has(Class)) return _cache.get(Class);
890
+ } else if (hasFinally) {
891
+ if (this.prev < entry.finallyLoc) {
892
+ return handle(entry.finallyLoc);
893
+ }
544
894
 
545
- _cache.set(Class, Wrapper);
546
- }
895
+ } else {
896
+ throw new Error("try statement without catch or finally");
897
+ }
898
+ }
899
+ }
900
+ },
547
901
 
548
- function Wrapper() {
549
- return _construct(Class, arguments, _getPrototypeOf(this).constructor);
550
- }
902
+ abrupt: function(type, arg) {
903
+ for (var i = this.tryEntries.length - 1; i >= 0; --i) {
904
+ var entry = this.tryEntries[i];
905
+ if (entry.tryLoc <= this.prev &&
906
+ hasOwn.call(entry, "finallyLoc") &&
907
+ this.prev < entry.finallyLoc) {
908
+ var finallyEntry = entry;
909
+ break;
910
+ }
911
+ }
551
912
 
552
- Wrapper.prototype = Object.create(Class.prototype, {
553
- constructor: {
554
- value: Wrapper,
555
- enumerable: false,
556
- writable: true,
557
- configurable: true
913
+ if (finallyEntry &&
914
+ (type === "break" ||
915
+ type === "continue") &&
916
+ finallyEntry.tryLoc <= arg &&
917
+ arg <= finallyEntry.finallyLoc) {
918
+ // Ignore the finally entry if control is not jumping to a
919
+ // location outside the try/catch block.
920
+ finallyEntry = null;
558
921
  }
559
- });
560
- return _setPrototypeOf(Wrapper, Class);
561
- };
562
922
 
563
- return _wrapNativeSuper(Class);
564
- }
923
+ var record = finallyEntry ? finallyEntry.completion : {};
924
+ record.type = type;
925
+ record.arg = arg;
565
926
 
566
- function _objectWithoutPropertiesLoose(source, excluded) {
567
- if (source == null) return {};
568
- var target = {};
569
- var sourceKeys = Object.keys(source);
570
- var key, i;
927
+ if (finallyEntry) {
928
+ this.method = "next";
929
+ this.next = finallyEntry.finallyLoc;
930
+ return ContinueSentinel;
931
+ }
571
932
 
572
- for (i = 0; i < sourceKeys.length; i++) {
573
- key = sourceKeys[i];
574
- if (excluded.indexOf(key) >= 0) continue;
575
- target[key] = source[key];
576
- }
933
+ return this.complete(record);
934
+ },
577
935
 
578
- return target;
579
- }
936
+ complete: function(record, afterLoc) {
937
+ if (record.type === "throw") {
938
+ throw record.arg;
939
+ }
580
940
 
581
- function _unsupportedIterableToArray(o, minLen) {
582
- if (!o) return;
583
- if (typeof o === "string") return _arrayLikeToArray(o, minLen);
584
- var n = Object.prototype.toString.call(o).slice(8, -1);
585
- if (n === "Object" && o.constructor) n = o.constructor.name;
586
- if (n === "Map" || n === "Set") return Array.from(o);
587
- if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
588
- }
941
+ if (record.type === "break" ||
942
+ record.type === "continue") {
943
+ this.next = record.arg;
944
+ } else if (record.type === "return") {
945
+ this.rval = this.arg = record.arg;
946
+ this.method = "return";
947
+ this.next = "end";
948
+ } else if (record.type === "normal" && afterLoc) {
949
+ this.next = afterLoc;
950
+ }
589
951
 
590
- function _arrayLikeToArray(arr, len) {
591
- if (len == null || len > arr.length) len = arr.length;
952
+ return ContinueSentinel;
953
+ },
592
954
 
593
- for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
955
+ finish: function(finallyLoc) {
956
+ for (var i = this.tryEntries.length - 1; i >= 0; --i) {
957
+ var entry = this.tryEntries[i];
958
+ if (entry.finallyLoc === finallyLoc) {
959
+ this.complete(entry.completion, entry.afterLoc);
960
+ resetTryEntry(entry);
961
+ return ContinueSentinel;
962
+ }
963
+ }
964
+ },
594
965
 
595
- return arr2;
596
- }
966
+ "catch": function(tryLoc) {
967
+ for (var i = this.tryEntries.length - 1; i >= 0; --i) {
968
+ var entry = this.tryEntries[i];
969
+ if (entry.tryLoc === tryLoc) {
970
+ var record = entry.completion;
971
+ if (record.type === "throw") {
972
+ var thrown = record.arg;
973
+ resetTryEntry(entry);
974
+ }
975
+ return thrown;
976
+ }
977
+ }
597
978
 
598
- function _createForOfIteratorHelperLoose(o, allowArrayLike) {
599
- var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
600
- if (it) return (it = it.call(o)).next.bind(it);
979
+ // The context.catch method must only be called with a location
980
+ // argument that corresponds to a known catch block.
981
+ throw new Error("illegal catch attempt");
982
+ },
601
983
 
602
- if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
603
- if (it) o = it;
604
- var i = 0;
605
- return function () {
606
- if (i >= o.length) return {
607
- done: true
608
- };
609
- return {
610
- done: false,
611
- value: o[i++]
984
+ delegateYield: function(iterable, resultName, nextLoc) {
985
+ this.delegate = {
986
+ iterator: values(iterable),
987
+ resultName: resultName,
988
+ nextLoc: nextLoc
612
989
  };
613
- };
614
- }
615
990
 
616
- throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
991
+ if (this.method === "next") {
992
+ // Deliberately forget the last sent value so that we don't
993
+ // accidentally pass it on to the delegate.
994
+ this.arg = undefined$1;
995
+ }
996
+
997
+ return ContinueSentinel;
998
+ }
999
+ };
1000
+
1001
+ // Regardless of whether this script is executing as a CommonJS module
1002
+ // or not, return the runtime object so that we can declare the variable
1003
+ // regeneratorRuntime in the outer scope, which allows this module to be
1004
+ // injected easily by `bin/regenerator --include-runtime script.js`.
1005
+ return exports;
1006
+
1007
+ }(
1008
+ // If this script is executing as a CommonJS module, use module.exports
1009
+ // as the regeneratorRuntime namespace. Otherwise create a new empty
1010
+ // object. Either way, the resulting object will be used to initialize
1011
+ // the regeneratorRuntime variable at the top of this file.
1012
+ module.exports
1013
+ ));
1014
+
1015
+ try {
1016
+ regeneratorRuntime = runtime;
1017
+ } catch (accidentalStrictMode) {
1018
+ // This module should not be running in strict mode, so the above
1019
+ // assignment should always work unless something is misconfigured. Just
1020
+ // in case runtime.js accidentally runs in strict mode, in modern engines
1021
+ // we can explicitly access globalThis. In older engines we can escape
1022
+ // strict mode using a global Function call. This could conceivably fail
1023
+ // if a Content Security Policy forbids using Function, but in that case
1024
+ // the proper solution is to fix the accidental strict mode problem. If
1025
+ // you've misconfigured your bundler to force strict mode and applied a
1026
+ // CSP to forbid Function, and you're not willing to fix either of those
1027
+ // problems, please detail your unique predicament in a GitHub issue.
1028
+ if (typeof globalThis === "object") {
1029
+ globalThis.regeneratorRuntime = runtime;
1030
+ } else {
1031
+ Function("r", "regeneratorRuntime = r")(runtime);
1032
+ }
617
1033
  }
1034
+ });
618
1035
 
619
1036
  var _personalMetaToPrefix;
620
1037
  var personalMetaToPrefix = (_personalMetaToPrefix = {}, _personalMetaToPrefix[initApis.MetadataCategory.Personal] = 'you', _personalMetaToPrefix[initApis.MetadataCategory.ChildPersonal] = 'child', _personalMetaToPrefix[initApis.MetadataCategory.OtherPersonal] = 'other', _personalMetaToPrefix);
@@ -835,9 +1252,9 @@ function filterTriggeredAnsweredWithKind(_x, _x2) {
835
1252
  */
836
1253
 
837
1254
  function _filterTriggeredAnsweredWithKind() {
838
- _filterTriggeredAnsweredWithKind = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(workflowData, kind) {
1255
+ _filterTriggeredAnsweredWithKind = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(workflowData, kind) {
839
1256
  var flattenedAnswers, triggeredQuestionsWithKind, samePageAnswers, res;
840
- return _regeneratorRuntime().wrap(function _callee$(_context) {
1257
+ return runtime_1.wrap(function _callee$(_context) {
841
1258
  while (1) {
842
1259
  switch (_context.prev = _context.next) {
843
1260
  case 0:
@@ -881,9 +1298,9 @@ function getWorkflowDataByCategory(_x3, _x4) {
881
1298
  }
882
1299
 
883
1300
  function _getWorkflowDataByCategory() {
884
- _getWorkflowDataByCategory = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(workflowData, category) {
1301
+ _getWorkflowDataByCategory = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(workflowData, category) {
885
1302
  var flattenedAnswers, triggeredQuestions, fields;
886
- return _regeneratorRuntime().wrap(function _callee2$(_context2) {
1303
+ return runtime_1.wrap(function _callee2$(_context2) {
887
1304
  while (1) {
888
1305
  switch (_context2.prev = _context2.next) {
889
1306
  case 0:
@@ -954,8 +1371,8 @@ function getImagesFromIndexDb(_x5) {
954
1371
  */
955
1372
 
956
1373
  function _getImagesFromIndexDb() {
957
- _getImagesFromIndexDb = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(answer) {
958
- return _regeneratorRuntime().wrap(function _callee3$(_context3) {
1374
+ _getImagesFromIndexDb = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(answer) {
1375
+ return runtime_1.wrap(function _callee3$(_context3) {
959
1376
  while (1) {
960
1377
  switch (_context3.prev = _context3.next) {
961
1378
  case 0:
@@ -984,9 +1401,9 @@ function populateWorkflowField(_x6, _x7) {
984
1401
  }
985
1402
 
986
1403
  function _populateWorkflowField() {
987
- _populateWorkflowField = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(question, answerValue) {
1404
+ _populateWorkflowField = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(question, answerValue) {
988
1405
  var answer, displayedAnswer;
989
- return _regeneratorRuntime().wrap(function _callee4$(_context4) {
1406
+ return runtime_1.wrap(function _callee4$(_context4) {
990
1407
  while (1) {
991
1408
  switch (_context4.prev = _context4.next) {
992
1409
  case 0:
@@ -1164,10 +1581,10 @@ function registerPatient(_x, _x2, _x3, _x4, _x5, _x6) {
1164
1581
  */
1165
1582
 
1166
1583
  function _registerPatient() {
1167
- _registerPatient = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(patientUuid, consultRequest, workflow, oroClient, masterKey, recoveryQA) {
1584
+ _registerPatient = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(patientUuid, consultRequest, workflow, oroClient, masterKey, recoveryQA) {
1168
1585
  var consult, lockboxUuid, practitionerAdmin, retry, identity, errorsThrown, _ret;
1169
1586
 
1170
- return _regeneratorRuntime().wrap(function _callee4$(_context4) {
1587
+ return runtime_1.wrap(function _callee4$(_context4) {
1171
1588
  while (1) {
1172
1589
  switch (_context4.prev = _context4.next) {
1173
1590
  case 0:
@@ -1185,11 +1602,11 @@ function _registerPatient() {
1185
1602
  }
1186
1603
 
1187
1604
  _context4.prev = 7;
1188
- return _context4.delegateYield( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
1605
+ return _context4.delegateYield( /*#__PURE__*/runtime_1.mark(function _callee3() {
1189
1606
  var _consultIndex, _identity, _identity2;
1190
1607
 
1191
1608
  var practitioners, grantPromises, consultIndex, consultIndexPromises;
1192
- return _regeneratorRuntime().wrap(function _callee3$(_context3) {
1609
+ return runtime_1.wrap(function _callee3$(_context3) {
1193
1610
  while (1) {
1194
1611
  switch (_context3.prev = _context3.next) {
1195
1612
  case 0:
@@ -1260,6 +1677,7 @@ function _registerPatient() {
1260
1677
  return oroClient.grantLockbox(practitionerAdmin, lockboxUuid)["catch"](function (err) {
1261
1678
  console.error("Error while granting lockbox to practitioner admin " + practitionerAdmin, err); // if we cannot grant to the admin, then the registration will fail
1262
1679
 
1680
+ // if we cannot grant to the admin, then the registration will fail
1263
1681
  errorsThrown.push(err);
1264
1682
  });
1265
1683
 
@@ -1268,14 +1686,15 @@ function _registerPatient() {
1268
1686
  grantPromises = practitioners.filter(function (practitioner) {
1269
1687
  return practitioner.uuid !== practitionerAdmin;
1270
1688
  }).map( /*#__PURE__*/function () {
1271
- var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(practitioner) {
1272
- return _regeneratorRuntime().wrap(function _callee$(_context) {
1689
+ var _ref = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(practitioner) {
1690
+ return runtime_1.wrap(function _callee$(_context) {
1273
1691
  while (1) {
1274
1692
  switch (_context.prev = _context.next) {
1275
1693
  case 0:
1276
1694
  return _context.abrupt("return", oroClient.grantLockbox(practitioner.uuid, lockboxUuid)["catch"](function (err) {
1277
1695
  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
1278
1696
 
1697
+ // Acceptable to continue as admin has already been granted, but we should still retry until the last retry remains
1279
1698
  if (retry <= 1) return;
1280
1699
  errorsThrown.push(err);
1281
1700
  }));
@@ -1288,7 +1707,7 @@ function _registerPatient() {
1288
1707
  }, _callee);
1289
1708
  }));
1290
1709
 
1291
- return function (_x24) {
1710
+ return function (_x28) {
1292
1711
  return _ref.apply(this, arguments);
1293
1712
  };
1294
1713
  }());
@@ -1301,14 +1720,15 @@ function _registerPatient() {
1301
1720
  }], _consultIndex); // the index will identify in which lockbox a consultation resides
1302
1721
 
1303
1722
  consultIndexPromises = practitioners.map( /*#__PURE__*/function () {
1304
- var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(practitioner) {
1305
- return _regeneratorRuntime().wrap(function _callee2$(_context2) {
1723
+ var _ref2 = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(practitioner) {
1724
+ return runtime_1.wrap(function _callee2$(_context2) {
1306
1725
  while (1) {
1307
1726
  switch (_context2.prev = _context2.next) {
1308
1727
  case 0:
1309
1728
  return _context2.abrupt("return", oroClient.vaultIndexAdd(consultIndex, practitioner.uuid)["catch"](function (err) {
1310
1729
  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
1311
1730
 
1731
+ // Acceptable to continue as the index can be rebuilt, but we should still retry until the last retry remains
1312
1732
  if (retry <= 1) return;else errorsThrown.push(err);
1313
1733
  }));
1314
1734
 
@@ -1320,7 +1740,7 @@ function _registerPatient() {
1320
1740
  }, _callee2);
1321
1741
  }));
1322
1742
 
1323
- return function (_x25) {
1743
+ return function (_x29) {
1324
1744
  return _ref2.apply(this, arguments);
1325
1745
  };
1326
1746
  }());
@@ -1328,6 +1748,7 @@ function _registerPatient() {
1328
1748
  return storeImageAliases(consult.uuid, lockboxUuid, workflow, oroClient)["catch"](function (err) {
1329
1749
  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
1330
1750
 
1751
+ // Acceptable to continue as images can be requested during the consultation, but we should still retry until the last retry remains
1331
1752
  if (retry <= 1) return;else errorsThrown.push(err);
1332
1753
  });
1333
1754
 
@@ -1348,6 +1769,7 @@ function _registerPatient() {
1348
1769
  return oroClient.updateMasterKey(patientUuid, masterKey, lockboxUuid)["catch"](function (err) {
1349
1770
  console.error("[SDK: registration] Error while updating master key", err); /// it's acceptable to continue registration (return old identity)
1350
1771
 
1772
+ /// it's acceptable to continue registration (return old identity)
1351
1773
  if (retry <= 1) return;
1352
1774
  errorsThrown.push(err);
1353
1775
  return identity;
@@ -1372,6 +1794,7 @@ function _registerPatient() {
1372
1794
  return oroClient.updateSecurityQuestions(patientUuid, recoveryQA.recoverySecurityQuestions, recoveryQA.recoverySecurityAnswers, 2)["catch"](function (err) {
1373
1795
  console.error("[SDK: registration] Error while updating security questions", err); /// it's acceptable to continue registration (return old identity)
1374
1796
 
1797
+ /// it's acceptable to continue registration (return old identity)
1375
1798
  if (retry <= 1) return;
1376
1799
  errorsThrown.push(err);
1377
1800
  return identity;
@@ -1399,9 +1822,16 @@ function _registerPatient() {
1399
1822
  });
1400
1823
 
1401
1824
  case 47:
1825
+ _context3.next = 49;
1826
+ return searchIndexConsultation(consult.uuid, oroClient)["catch"](function (err) {
1827
+ console.error('[SDK: registration] personal information not found or another error occured during search indexing', err);
1828
+ errorsThrown.push(err);
1829
+ });
1830
+
1831
+ case 49:
1402
1832
  return _context3.abrupt("return", "break");
1403
1833
 
1404
- case 48:
1834
+ case 50:
1405
1835
  case "end":
1406
1836
  return _context3.stop();
1407
1837
  }
@@ -1477,9 +1907,9 @@ function getOrCreatePatientConsultationUuid(_x7, _x8) {
1477
1907
 
1478
1908
 
1479
1909
  function _getOrCreatePatientConsultationUuid() {
1480
- _getOrCreatePatientConsultationUuid = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(consult, oroClient) {
1910
+ _getOrCreatePatientConsultationUuid = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(consult, oroClient) {
1481
1911
  var payment;
1482
- return _regeneratorRuntime().wrap(function _callee5$(_context5) {
1912
+ return runtime_1.wrap(function _callee5$(_context5) {
1483
1913
  while (1) {
1484
1914
  switch (_context5.prev = _context5.next) {
1485
1915
  case 0:
@@ -1534,9 +1964,9 @@ function getOrCreatePatientLockbox(_x9) {
1534
1964
 
1535
1965
 
1536
1966
  function _getOrCreatePatientLockbox() {
1537
- _getOrCreatePatientLockbox = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(oroClient) {
1967
+ _getOrCreatePatientLockbox = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee6(oroClient) {
1538
1968
  var grants;
1539
- return _regeneratorRuntime().wrap(function _callee6$(_context6) {
1969
+ return runtime_1.wrap(function _callee6$(_context6) {
1540
1970
  while (1) {
1541
1971
  switch (_context6.prev = _context6.next) {
1542
1972
  case 0:
@@ -1579,8 +2009,8 @@ function storePatientData(_x10, _x11, _x12, _x13, _x14) {
1579
2009
  }
1580
2010
 
1581
2011
  function _storePatientData() {
1582
- _storePatientData = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(consultationId, isoLanguage, lockboxUuid, workflow, oroClient) {
1583
- return _regeneratorRuntime().wrap(function _callee7$(_context7) {
2012
+ _storePatientData = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee7(consultationId, isoLanguage, lockboxUuid, workflow, oroClient) {
2013
+ return runtime_1.wrap(function _callee7$(_context7) {
1584
2014
  while (1) {
1585
2015
  switch (_context7.prev = _context7.next) {
1586
2016
  case 0:
@@ -1637,9 +2067,9 @@ function storeImageAliases(_x15, _x16, _x17, _x18) {
1637
2067
 
1638
2068
 
1639
2069
  function _storeImageAliases() {
1640
- _storeImageAliases = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8(consultationId, lockboxUuid, workflow, oroClient) {
2070
+ _storeImageAliases = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee8(consultationId, lockboxUuid, workflow, oroClient) {
1641
2071
  var images, nonNullImages, promises;
1642
- return _regeneratorRuntime().wrap(function _callee8$(_context8) {
2072
+ return runtime_1.wrap(function _callee8$(_context8) {
1643
2073
  while (1) {
1644
2074
  switch (_context8.prev = _context8.next) {
1645
2075
  case 0:
@@ -1687,8 +2117,8 @@ function extractAndStorePersonalWorkflowData(_x19, _x20, _x21, _x22, _x23) {
1687
2117
  }
1688
2118
 
1689
2119
  function _extractAndStorePersonalWorkflowData() {
1690
- _extractAndStorePersonalWorkflowData = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9(workflow, lockboxUuid, consultationId, category, oroClient) {
1691
- return _regeneratorRuntime().wrap(function _callee9$(_context9) {
2120
+ _extractAndStorePersonalWorkflowData = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee9(workflow, lockboxUuid, consultationId, category, oroClient) {
2121
+ return runtime_1.wrap(function _callee9$(_context9) {
1692
2122
  while (1) {
1693
2123
  switch (_context9.prev = _context9.next) {
1694
2124
  case 0:
@@ -1711,6 +2141,135 @@ function _extractAndStorePersonalWorkflowData() {
1711
2141
  return _extractAndStorePersonalWorkflowData.apply(this, arguments);
1712
2142
  }
1713
2143
 
2144
+ function extractPersonalInfoFromConsultId(_x24, _x25) {
2145
+ return _extractPersonalInfoFromConsultId.apply(this, arguments);
2146
+ }
2147
+
2148
+ function _extractPersonalInfoFromConsultId() {
2149
+ _extractPersonalInfoFromConsultId = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee10(consultUuid, oroClient) {
2150
+ return runtime_1.wrap(function _callee10$(_context10) {
2151
+ while (1) {
2152
+ switch (_context10.prev = _context10.next) {
2153
+ case 0:
2154
+ return _context10.abrupt("return", Promise.all([// Retrieve MetadataCategory.Personal in any case
2155
+ oroClient.getPersonalInformationsFromConsultId(consultUuid, initApis.MetadataCategory.Personal, true).then(function (personalInformations) {
2156
+ if (!personalInformations[0]) {
2157
+ console.error(initApis.MetadataCategory.Personal + " informations not found for consult:", consultUuid);
2158
+ throw Error('No self personal information found');
2159
+ }
2160
+
2161
+ return personalInformations[0];
2162
+ }), // Retrieve MetadataCategory.ChildPersonal in any case in parallel
2163
+ oroClient.getPersonalInformationsFromConsultId(consultUuid, initApis.MetadataCategory.ChildPersonal, true).then(function (childInformations) {
2164
+ if (!childInformations[0]) {
2165
+ console.debug(initApis.MetadataCategory.ChildPersonal + " informations not found for consult:", consultUuid); // Retrieve MetadataCategory.OtherPersonal only if MetadataCategory.ChildPersonal does not exist
2166
+
2167
+ // Retrieve MetadataCategory.OtherPersonal only if MetadataCategory.ChildPersonal does not exist
2168
+ return oroClient.getPersonalInformationsFromConsultId(consultUuid, initApis.MetadataCategory.OtherPersonal, true).then(function (otherInformations) {
2169
+ if (!otherInformations[0]) {
2170
+ console.debug(initApis.MetadataCategory.OtherPersonal + " informations not found for consult:", consultUuid);
2171
+ return {};
2172
+ }
2173
+
2174
+ return {
2175
+ otherPersonalInformations: otherInformations[0]
2176
+ };
2177
+ });
2178
+ }
2179
+
2180
+ return {
2181
+ childPersonalInformations: childInformations[0]
2182
+ };
2183
+ })]).then(function (_ref3) {
2184
+ var personalInformations = _ref3[0],
2185
+ _ref3$ = _ref3[1],
2186
+ childPersonalInformations = _ref3$.childPersonalInformations,
2187
+ otherPersonalInformations = _ref3$.otherPersonalInformations;
2188
+ return {
2189
+ consultUuid: consultUuid,
2190
+ personalInformations: personalInformations,
2191
+ childPersonalInformations: childPersonalInformations,
2192
+ otherPersonalInformations: otherPersonalInformations
2193
+ };
2194
+ }));
2195
+
2196
+ case 1:
2197
+ case "end":
2198
+ return _context10.stop();
2199
+ }
2200
+ }
2201
+ }, _callee10);
2202
+ }));
2203
+ return _extractPersonalInfoFromConsultId.apply(this, arguments);
2204
+ }
2205
+
2206
+ function searchIndexConsultation(_x26, _x27) {
2207
+ return _searchIndexConsultation.apply(this, arguments);
2208
+ }
2209
+
2210
+ function _searchIndexConsultation() {
2211
+ _searchIndexConsultation = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee11(consultUuid, oroClient) {
2212
+ var terms, _yield$extractPersona, personalInformations, childPersonalInformations, otherPersonalInformations, personalInfo, childPersonalInfo, otherPersonalInfo;
2213
+
2214
+ return runtime_1.wrap(function _callee11$(_context11) {
2215
+ while (1) {
2216
+ switch (_context11.prev = _context11.next) {
2217
+ case 0:
2218
+ terms = [];
2219
+ console.log('here');
2220
+ _context11.next = 4;
2221
+ return extractPersonalInfoFromConsultId(consultUuid, oroClient);
2222
+
2223
+ case 4:
2224
+ _yield$extractPersona = _context11.sent;
2225
+ personalInformations = _yield$extractPersona.personalInformations;
2226
+ childPersonalInformations = _yield$extractPersona.childPersonalInformations;
2227
+ otherPersonalInformations = _yield$extractPersona.otherPersonalInformations;
2228
+ console.log('personal=', personalInformations, 'child=', childPersonalInformations, 'other=', otherPersonalInformations);
2229
+ personalInfo = identificationToPersonalInformations(toActualObject(personalInformations.data), initApis.MetadataCategory.Personal);
2230
+ terms.push({
2231
+ kind: 'first-name',
2232
+ value: personalInfo.firstname
2233
+ }, {
2234
+ kind: 'last-name',
2235
+ value: personalInfo.name
2236
+ });
2237
+
2238
+ if (childPersonalInformations) {
2239
+ childPersonalInfo = identificationToPersonalInformations(toActualObject(childPersonalInformations.data), initApis.MetadataCategory.ChildPersonal);
2240
+ terms.push({
2241
+ kind: 'first-name',
2242
+ value: childPersonalInfo.firstname
2243
+ }, {
2244
+ kind: 'last-name',
2245
+ value: childPersonalInfo.name
2246
+ });
2247
+ }
2248
+
2249
+ if (otherPersonalInformations) {
2250
+ otherPersonalInfo = identificationToPersonalInformations(toActualObject(otherPersonalInformations.data), initApis.MetadataCategory.OtherPersonal);
2251
+ terms.push({
2252
+ kind: 'first-name',
2253
+ value: otherPersonalInfo.firstname
2254
+ }, {
2255
+ kind: 'last-name',
2256
+ value: otherPersonalInfo.name
2257
+ });
2258
+ }
2259
+
2260
+ _context11.next = 15;
2261
+ return oroClient.searchClient.index(consultUuid, terms);
2262
+
2263
+ case 15:
2264
+ case "end":
2265
+ return _context11.stop();
2266
+ }
2267
+ }
2268
+ }, _callee11);
2269
+ }));
2270
+ return _searchIndexConsultation.apply(this, arguments);
2271
+ }
2272
+
1714
2273
  /**
1715
2274
  * Decrypts and returns the encrypted grants
1716
2275
  * If something went wrong during decryption, that grant will be removed from the list
@@ -1780,10 +2339,10 @@ function filterGrantsWithLockboxMetadata(_x, _x2, _x3, _x4) {
1780
2339
  */
1781
2340
 
1782
2341
  function _filterGrantsWithLockboxMetadata() {
1783
- _filterGrantsWithLockboxMetadata = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(oroClient, filter, vaultIndex, forceRefresh) {
2342
+ _filterGrantsWithLockboxMetadata = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(oroClient, filter, vaultIndex, forceRefresh) {
1784
2343
  var _vaultIndex$IndexKey$, indexConsults;
1785
2344
 
1786
- return _regeneratorRuntime().wrap(function _callee$(_context) {
2345
+ return runtime_1.wrap(function _callee$(_context) {
1787
2346
  while (1) {
1788
2347
  switch (_context.prev = _context.next) {
1789
2348
  case 0:
@@ -1833,12 +2392,12 @@ function buildLegacyVaultIndex(_x5) {
1833
2392
  }
1834
2393
 
1835
2394
  function _buildLegacyVaultIndex() {
1836
- _buildLegacyVaultIndex = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(oroClient) {
2395
+ _buildLegacyVaultIndex = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(oroClient) {
1837
2396
  var _vaultIndex;
1838
2397
 
1839
2398
  var grants, consultGrants, _loop, _iterator, _step, vaultIndex;
1840
2399
 
1841
- return _regeneratorRuntime().wrap(function _callee2$(_context3) {
2400
+ return runtime_1.wrap(function _callee2$(_context3) {
1842
2401
  while (1) {
1843
2402
  switch (_context3.prev = _context3.next) {
1844
2403
  case 0:
@@ -1848,9 +2407,9 @@ function _buildLegacyVaultIndex() {
1848
2407
  case 2:
1849
2408
  grants = _context3.sent;
1850
2409
  consultGrants = [];
1851
- _loop = /*#__PURE__*/_regeneratorRuntime().mark(function _loop() {
2410
+ _loop = /*#__PURE__*/runtime_1.mark(function _loop() {
1852
2411
  var grant, consults;
1853
- return _regeneratorRuntime().wrap(function _loop$(_context2) {
2412
+ return runtime_1.wrap(function _loop$(_context2) {
1854
2413
  while (1) {
1855
2414
  switch (_context2.prev = _context2.next) {
1856
2415
  case 0:
@@ -1934,8 +2493,8 @@ var OroClient = /*#__PURE__*/function () {
1934
2493
  _proto.cleanIndex =
1935
2494
  /*#__PURE__*/
1936
2495
  function () {
1937
- var _cleanIndex = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
1938
- return _regeneratorRuntime().wrap(function _callee$(_context) {
2496
+ var _cleanIndex = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee() {
2497
+ return runtime_1.wrap(function _callee$(_context) {
1939
2498
  while (1) {
1940
2499
  switch (_context.prev = _context.next) {
1941
2500
  case 0:
@@ -1973,9 +2532,9 @@ var OroClient = /*#__PURE__*/function () {
1973
2532
  _proto.signUp =
1974
2533
  /*#__PURE__*/
1975
2534
  function () {
1976
- var _signUp = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(email, password, practice, tosAndCpAcceptance, tokenData, subscription, skipEmailValidation) {
2535
+ var _signUp = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(email, password, practice, tosAndCpAcceptance, tokenData, subscription, skipEmailValidation) {
1977
2536
  var privateKey, symmetricEncryptor, recoveryPassword, hashedPassword, emailConfirmed, signupRequest, identity, symetricEncryptor;
1978
- return _regeneratorRuntime().wrap(function _callee2$(_context2) {
2537
+ return runtime_1.wrap(function _callee2$(_context2) {
1979
2538
  while (1) {
1980
2539
  switch (_context2.prev = _context2.next) {
1981
2540
  case 0:
@@ -2034,9 +2593,9 @@ var OroClient = /*#__PURE__*/function () {
2034
2593
  _proto.confirmEmail =
2035
2594
  /*#__PURE__*/
2036
2595
  function () {
2037
- var _confirmEmail = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(accessToken) {
2596
+ var _confirmEmail = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(accessToken) {
2038
2597
  var claims;
2039
- return _regeneratorRuntime().wrap(function _callee3$(_context3) {
2598
+ return runtime_1.wrap(function _callee3$(_context3) {
2040
2599
  while (1) {
2041
2600
  switch (_context3.prev = _context3.next) {
2042
2601
  case 0:
@@ -2081,9 +2640,9 @@ var OroClient = /*#__PURE__*/function () {
2081
2640
  _proto.signIn =
2082
2641
  /*#__PURE__*/
2083
2642
  function () {
2084
- var _signIn = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(practiceUuid, email, password, otp) {
2643
+ var _signIn = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(practiceUuid, email, password, otp) {
2085
2644
  var hashedPassword, tokenRequest, userUuid;
2086
- return _regeneratorRuntime().wrap(function _callee4$(_context4) {
2645
+ return runtime_1.wrap(function _callee4$(_context4) {
2087
2646
  while (1) {
2088
2647
  switch (_context4.prev = _context4.next) {
2089
2648
  case 0:
@@ -2136,9 +2695,9 @@ var OroClient = /*#__PURE__*/function () {
2136
2695
  _proto.resumeSession =
2137
2696
  /*#__PURE__*/
2138
2697
  function () {
2139
- var _resumeSession = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5() {
2698
+ var _resumeSession = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5() {
2140
2699
  var id, recoveryPayload, recoveryKey, symmetricDecryptor, privateKey;
2141
- return _regeneratorRuntime().wrap(function _callee5$(_context5) {
2700
+ return runtime_1.wrap(function _callee5$(_context5) {
2142
2701
  while (1) {
2143
2702
  switch (_context5.prev = _context5.next) {
2144
2703
  case 0:
@@ -2239,8 +2798,8 @@ var OroClient = /*#__PURE__*/function () {
2239
2798
  _proto.signOut =
2240
2799
  /*#__PURE__*/
2241
2800
  function () {
2242
- var _signOut = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6() {
2243
- return _regeneratorRuntime().wrap(function _callee6$(_context6) {
2801
+ var _signOut = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee6() {
2802
+ return runtime_1.wrap(function _callee6$(_context6) {
2244
2803
  while (1) {
2245
2804
  switch (_context6.prev = _context6.next) {
2246
2805
  case 0:
@@ -2289,8 +2848,8 @@ var OroClient = /*#__PURE__*/function () {
2289
2848
  _proto.registerPatient =
2290
2849
  /*#__PURE__*/
2291
2850
  function () {
2292
- var _registerPatient2 = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(patientUuid, consult, workflow, recoveryQA) {
2293
- return _regeneratorRuntime().wrap(function _callee7$(_context7) {
2851
+ var _registerPatient2 = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee7(patientUuid, consult, workflow, recoveryQA) {
2852
+ return runtime_1.wrap(function _callee7$(_context7) {
2294
2853
  while (1) {
2295
2854
  switch (_context7.prev = _context7.next) {
2296
2855
  case 0:
@@ -2333,8 +2892,8 @@ var OroClient = /*#__PURE__*/function () {
2333
2892
  _proto.buildVaultIndex =
2334
2893
  /*#__PURE__*/
2335
2894
  function () {
2336
- var _buildVaultIndex = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8(forceRefresh) {
2337
- return _regeneratorRuntime().wrap(function _callee8$(_context8) {
2895
+ var _buildVaultIndex = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee8(forceRefresh) {
2896
+ return runtime_1.wrap(function _callee8$(_context8) {
2338
2897
  while (1) {
2339
2898
  switch (_context8.prev = _context8.next) {
2340
2899
  case 0:
@@ -2382,12 +2941,12 @@ var OroClient = /*#__PURE__*/function () {
2382
2941
  _proto.forceUpdateIndexEntries =
2383
2942
  /*#__PURE__*/
2384
2943
  function () {
2385
- var _forceUpdateIndexEntries = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10() {
2944
+ var _forceUpdateIndexEntries = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee10() {
2386
2945
  var _this = this,
2387
2946
  _this$vaultIndexAdd;
2388
2947
 
2389
2948
  var grants, indexConsultLockbox;
2390
- return _regeneratorRuntime().wrap(function _callee10$(_context10) {
2949
+ return runtime_1.wrap(function _callee10$(_context10) {
2391
2950
  while (1) {
2392
2951
  switch (_context10.prev = _context10.next) {
2393
2952
  case 0:
@@ -2398,8 +2957,8 @@ var OroClient = /*#__PURE__*/function () {
2398
2957
  grants = _context10.sent;
2399
2958
  _context10.next = 5;
2400
2959
  return Promise.all(grants.map( /*#__PURE__*/function () {
2401
- var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9(grant) {
2402
- return _regeneratorRuntime().wrap(function _callee9$(_context9) {
2960
+ var _ref2 = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee9(grant) {
2961
+ return runtime_1.wrap(function _callee9$(_context9) {
2403
2962
  while (1) {
2404
2963
  switch (_context9.prev = _context9.next) {
2405
2964
  case 0:
@@ -2475,12 +3034,12 @@ var OroClient = /*#__PURE__*/function () {
2475
3034
  _proto.vaultIndexAdd =
2476
3035
  /*#__PURE__*/
2477
3036
  function () {
2478
- var _vaultIndexAdd = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee11(entries, indexOwnerUuid) {
3037
+ var _vaultIndexAdd = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee11(entries, indexOwnerUuid) {
2479
3038
  var _this2 = this;
2480
3039
 
2481
3040
  var rsaPub, base64IndexOwnerPubKey, encryptedIndex, _i, _Object$keys, keyString, key;
2482
3041
 
2483
- return _regeneratorRuntime().wrap(function _callee11$(_context11) {
3042
+ return runtime_1.wrap(function _callee11$(_context11) {
2484
3043
  while (1) {
2485
3044
  switch (_context11.prev = _context11.next) {
2486
3045
  case 0:
@@ -2602,11 +3161,11 @@ var OroClient = /*#__PURE__*/function () {
2602
3161
  _proto.indexSnapshotAdd =
2603
3162
  /*#__PURE__*/
2604
3163
  function () {
2605
- var _indexSnapshotAdd = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee12(index) {
3164
+ var _indexSnapshotAdd = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee12(index) {
2606
3165
  var _index$IndexKey$Consu, _cleanedIndex;
2607
3166
 
2608
3167
  var rsaPub, cleanedIndex, encryptedIndexEntry, encryptedIndex;
2609
- return _regeneratorRuntime().wrap(function _callee12$(_context12) {
3168
+ return runtime_1.wrap(function _callee12$(_context12) {
2610
3169
  while (1) {
2611
3170
  switch (_context12.prev = _context12.next) {
2612
3171
  case 0:
@@ -2664,9 +3223,9 @@ var OroClient = /*#__PURE__*/function () {
2664
3223
  _proto.grantLockbox =
2665
3224
  /*#__PURE__*/
2666
3225
  function () {
2667
- var _grantLockbox = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee13(granteeUuid, lockboxUuid, lockboxOwnerUuid) {
3226
+ var _grantLockbox = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee13(granteeUuid, lockboxUuid, lockboxOwnerUuid) {
2668
3227
  var secret, base64GranteePublicKey, granteePublicKey, granteeEncryptedSecret, request;
2669
- return _regeneratorRuntime().wrap(function _callee13$(_context13) {
3228
+ return runtime_1.wrap(function _callee13$(_context13) {
2670
3229
  while (1) {
2671
3230
  switch (_context13.prev = _context13.next) {
2672
3231
  case 0:
@@ -2726,9 +3285,9 @@ var OroClient = /*#__PURE__*/function () {
2726
3285
  _proto.createMessageData =
2727
3286
  /*#__PURE__*/
2728
3287
  function () {
2729
- var _createMessageData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee14(lockboxUuid, message, consultationId, lockboxOwnerUuid, previousDataUuid) {
3288
+ var _createMessageData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee14(lockboxUuid, message, consultationId, lockboxOwnerUuid, previousDataUuid) {
2730
3289
  var symmetricEncryptor, encryptedData, encryptedPrivateMeta, meta, request;
2731
- return _regeneratorRuntime().wrap(function _callee14$(_context14) {
3290
+ return runtime_1.wrap(function _callee14$(_context14) {
2732
3291
  while (1) {
2733
3292
  switch (_context14.prev = _context14.next) {
2734
3293
  case 0:
@@ -2798,9 +3357,9 @@ var OroClient = /*#__PURE__*/function () {
2798
3357
  _proto.createMessageAttachmentData =
2799
3358
  /*#__PURE__*/
2800
3359
  function () {
2801
- var _createMessageAttachmentData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee15(lockboxUuid, data, consultationId, lockboxOwnerUuid, previousDataUuid) {
3360
+ var _createMessageAttachmentData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee15(lockboxUuid, data, consultationId, lockboxOwnerUuid, previousDataUuid) {
2802
3361
  var symmetricEncryptor, encryptedData, encryptedPrivateMeta, meta, request;
2803
- return _regeneratorRuntime().wrap(function _callee15$(_context15) {
3362
+ return runtime_1.wrap(function _callee15$(_context15) {
2804
3363
  while (1) {
2805
3364
  switch (_context15.prev = _context15.next) {
2806
3365
  case 0:
@@ -2885,8 +3444,8 @@ var OroClient = /*#__PURE__*/function () {
2885
3444
  _proto.createConsultationAttachmentData =
2886
3445
  /*#__PURE__*/
2887
3446
  function () {
2888
- var _createConsultationAttachmentData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee16(lockboxUuid, data, consultationId, documentType, lockboxOwnerUuid, previousDataUuid) {
2889
- return _regeneratorRuntime().wrap(function _callee16$(_context16) {
3447
+ var _createConsultationAttachmentData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee16(lockboxUuid, data, consultationId, documentType, lockboxOwnerUuid, previousDataUuid) {
3448
+ return runtime_1.wrap(function _callee16$(_context16) {
2890
3449
  while (1) {
2891
3450
  switch (_context16.prev = _context16.next) {
2892
3451
  case 0:
@@ -2957,9 +3516,9 @@ var OroClient = /*#__PURE__*/function () {
2957
3516
  _proto.createJsonData =
2958
3517
  /*#__PURE__*/
2959
3518
  function () {
2960
- var _createJsonData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee17(lockboxUuid, data, meta, privateMeta, lockboxOwnerUuid, previousDataUuid) {
3519
+ var _createJsonData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee17(lockboxUuid, data, meta, privateMeta, lockboxOwnerUuid, previousDataUuid) {
2961
3520
  var symmetricEncryptor, encryptedData, encryptedPrivateMeta, request;
2962
- return _regeneratorRuntime().wrap(function _callee17$(_context17) {
3521
+ return runtime_1.wrap(function _callee17$(_context17) {
2963
3522
  while (1) {
2964
3523
  switch (_context17.prev = _context17.next) {
2965
3524
  case 0:
@@ -3013,9 +3572,9 @@ var OroClient = /*#__PURE__*/function () {
3013
3572
  _proto.getOrInsertJsonData =
3014
3573
  /*#__PURE__*/
3015
3574
  function () {
3016
- var _getOrInsertJsonData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee18(lockboxUuid, data, publicMetadata, privateMetadata, forceReplace) {
3575
+ var _getOrInsertJsonData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee18(lockboxUuid, data, publicMetadata, privateMetadata, forceReplace) {
3017
3576
  var manifest;
3018
- return _regeneratorRuntime().wrap(function _callee18$(_context18) {
3577
+ return runtime_1.wrap(function _callee18$(_context18) {
3019
3578
  while (1) {
3020
3579
  switch (_context18.prev = _context18.next) {
3021
3580
  case 0:
@@ -3078,9 +3637,9 @@ var OroClient = /*#__PURE__*/function () {
3078
3637
  _proto.createBytesData =
3079
3638
  /*#__PURE__*/
3080
3639
  function () {
3081
- var _createBytesData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee19(lockboxUuid, data, meta, privateMeta, lockboxOwnerUuid, previousDataUuid) {
3640
+ var _createBytesData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee19(lockboxUuid, data, meta, privateMeta, lockboxOwnerUuid, previousDataUuid) {
3082
3641
  var symmetricEncryptor, encryptedData, encryptedPrivateMeta, request;
3083
- return _regeneratorRuntime().wrap(function _callee19$(_context19) {
3642
+ return runtime_1.wrap(function _callee19$(_context19) {
3084
3643
  while (1) {
3085
3644
  switch (_context19.prev = _context19.next) {
3086
3645
  case 0:
@@ -3136,10 +3695,10 @@ var OroClient = /*#__PURE__*/function () {
3136
3695
  _proto.getJsonData =
3137
3696
  /*#__PURE__*/
3138
3697
  function () {
3139
- var _getJsonData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee20(lockboxUuid, dataUuid, lockboxOwnerUuid) {
3698
+ var _getJsonData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee20(lockboxUuid, dataUuid, lockboxOwnerUuid) {
3140
3699
  var _yield$Promise$all, encryptedPayload, symmetricDecryptor;
3141
3700
 
3142
- return _regeneratorRuntime().wrap(function _callee20$(_context20) {
3701
+ return runtime_1.wrap(function _callee20$(_context20) {
3143
3702
  while (1) {
3144
3703
  switch (_context20.prev = _context20.next) {
3145
3704
  case 0:
@@ -3186,10 +3745,10 @@ var OroClient = /*#__PURE__*/function () {
3186
3745
  _proto.getBytesData =
3187
3746
  /*#__PURE__*/
3188
3747
  function () {
3189
- var _getBytesData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee21(lockboxUuid, dataUuid, lockboxOwnerUuid) {
3748
+ var _getBytesData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee21(lockboxUuid, dataUuid, lockboxOwnerUuid) {
3190
3749
  var _yield$Promise$all2, encryptedPayload, symmetricDecryptor;
3191
3750
 
3192
- return _regeneratorRuntime().wrap(function _callee21$(_context21) {
3751
+ return runtime_1.wrap(function _callee21$(_context21) {
3193
3752
  while (1) {
3194
3753
  switch (_context21.prev = _context21.next) {
3195
3754
  case 0:
@@ -3239,9 +3798,9 @@ var OroClient = /*#__PURE__*/function () {
3239
3798
  _proto.getGrants =
3240
3799
  /*#__PURE__*/
3241
3800
  function () {
3242
- var _getGrants = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee22(filter, forceRefresh) {
3801
+ var _getGrants = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee22(filter, forceRefresh) {
3243
3802
  var filterString, grantsByConsultLockbox, decryptedConsults, encryptedGrants, decryptedGrants;
3244
- return _regeneratorRuntime().wrap(function _callee22$(_context22) {
3803
+ return runtime_1.wrap(function _callee22$(_context22) {
3245
3804
  while (1) {
3246
3805
  switch (_context22.prev = _context22.next) {
3247
3806
  case 0:
@@ -3359,9 +3918,9 @@ var OroClient = /*#__PURE__*/function () {
3359
3918
  _proto.getCachedSecretCryptor =
3360
3919
  /*#__PURE__*/
3361
3920
  function () {
3362
- var _getCachedSecretCryptor = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee23(lockboxUuid, lockboxOwnerUuid) {
3921
+ var _getCachedSecretCryptor = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee23(lockboxUuid, lockboxOwnerUuid) {
3363
3922
  var index, encryptedSecret, secret, cryptor;
3364
- return _regeneratorRuntime().wrap(function _callee23$(_context23) {
3923
+ return runtime_1.wrap(function _callee23$(_context23) {
3365
3924
  while (1) {
3366
3925
  switch (_context23.prev = _context23.next) {
3367
3926
  case 0:
@@ -3426,8 +3985,8 @@ var OroClient = /*#__PURE__*/function () {
3426
3985
  _proto.getPersonalInformationsFromConsultId =
3427
3986
  /*#__PURE__*/
3428
3987
  function () {
3429
- var _getPersonalInformationsFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee24(consultationId, category, forceRefresh) {
3430
- return _regeneratorRuntime().wrap(function _callee24$(_context24) {
3988
+ var _getPersonalInformationsFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee24(consultationId, category, forceRefresh) {
3989
+ return runtime_1.wrap(function _callee24$(_context24) {
3431
3990
  while (1) {
3432
3991
  switch (_context24.prev = _context24.next) {
3433
3992
  case 0:
@@ -3464,8 +4023,8 @@ var OroClient = /*#__PURE__*/function () {
3464
4023
  _proto.getMedicalDataFromConsultId =
3465
4024
  /*#__PURE__*/
3466
4025
  function () {
3467
- var _getMedicalDataFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee25(consultationId, forceRefresh) {
3468
- return _regeneratorRuntime().wrap(function _callee25$(_context25) {
4026
+ var _getMedicalDataFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee25(consultationId, forceRefresh) {
4027
+ return runtime_1.wrap(function _callee25$(_context25) {
3469
4028
  while (1) {
3470
4029
  switch (_context25.prev = _context25.next) {
3471
4030
  case 0:
@@ -3491,12 +4050,12 @@ var OroClient = /*#__PURE__*/function () {
3491
4050
  }();
3492
4051
 
3493
4052
  _proto.getMetaCategoryFromConsultId = /*#__PURE__*/function () {
3494
- var _getMetaCategoryFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee27(consultationId, category, forceRefresh) {
4053
+ var _getMetaCategoryFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee27(consultationId, category, forceRefresh) {
3495
4054
  var _this3 = this;
3496
4055
 
3497
4056
  var grants, workflowData, _loop, _iterator, _step;
3498
4057
 
3499
- return _regeneratorRuntime().wrap(function _callee27$(_context28) {
4058
+ return runtime_1.wrap(function _callee27$(_context28) {
3500
4059
  while (1) {
3501
4060
  switch (_context28.prev = _context28.next) {
3502
4061
  case 0:
@@ -3512,9 +4071,9 @@ var OroClient = /*#__PURE__*/function () {
3512
4071
  case 3:
3513
4072
  grants = _context28.sent;
3514
4073
  workflowData = [];
3515
- _loop = /*#__PURE__*/_regeneratorRuntime().mark(function _loop() {
4074
+ _loop = /*#__PURE__*/runtime_1.mark(function _loop() {
3516
4075
  var grant, manifest, data;
3517
- return _regeneratorRuntime().wrap(function _loop$(_context27) {
4076
+ return runtime_1.wrap(function _loop$(_context27) {
3518
4077
  while (1) {
3519
4078
  switch (_context27.prev = _context27.next) {
3520
4079
  case 0:
@@ -3548,8 +4107,8 @@ var OroClient = /*#__PURE__*/function () {
3548
4107
  case 8:
3549
4108
  _context27.next = 10;
3550
4109
  return Promise.all(manifest.map( /*#__PURE__*/function () {
3551
- var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee26(entry) {
3552
- return _regeneratorRuntime().wrap(function _callee26$(_context26) {
4110
+ var _ref3 = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee26(entry) {
4111
+ return runtime_1.wrap(function _callee26$(_context26) {
3553
4112
  while (1) {
3554
4113
  switch (_context26.prev = _context26.next) {
3555
4114
  case 0:
@@ -3633,9 +4192,9 @@ var OroClient = /*#__PURE__*/function () {
3633
4192
  _proto.getPersonalInformations =
3634
4193
  /*#__PURE__*/
3635
4194
  function () {
3636
- var _getPersonalInformations = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee28(userId) {
4195
+ var _getPersonalInformations = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee28(userId) {
3637
4196
  var grant, lockboxUuid, lockboxOwnerUuid, identificationDataUuid;
3638
- return _regeneratorRuntime().wrap(function _callee28$(_context29) {
4197
+ return runtime_1.wrap(function _callee28$(_context29) {
3639
4198
  while (1) {
3640
4199
  switch (_context29.prev = _context29.next) {
3641
4200
  case 0:
@@ -3721,9 +4280,9 @@ var OroClient = /*#__PURE__*/function () {
3721
4280
  _proto.getGrantFromConsultId =
3722
4281
  /*#__PURE__*/
3723
4282
  function () {
3724
- var _getGrantFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee29(consultationId) {
4283
+ var _getGrantFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee29(consultationId) {
3725
4284
  var grants;
3726
- return _regeneratorRuntime().wrap(function _callee29$(_context30) {
4285
+ return runtime_1.wrap(function _callee29$(_context30) {
3727
4286
  while (1) {
3728
4287
  switch (_context30.prev = _context30.next) {
3729
4288
  case 0:
@@ -3769,9 +4328,9 @@ var OroClient = /*#__PURE__*/function () {
3769
4328
  _proto.getIdentityFromConsultId =
3770
4329
  /*#__PURE__*/
3771
4330
  function () {
3772
- var _getIdentityFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee30(consultationId) {
4331
+ var _getIdentityFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee30(consultationId) {
3773
4332
  var grant;
3774
- return _regeneratorRuntime().wrap(function _callee30$(_context31) {
4333
+ return runtime_1.wrap(function _callee30$(_context31) {
3775
4334
  while (1) {
3776
4335
  switch (_context31.prev = _context31.next) {
3777
4336
  case 0:
@@ -3824,11 +4383,11 @@ var OroClient = /*#__PURE__*/function () {
3824
4383
  _proto.getLockboxManifest =
3825
4384
  /*#__PURE__*/
3826
4385
  function () {
3827
- var _getLockboxManifest = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee32(lockboxUuid, filter, expandPrivateMetadata, lockboxOwnerUuid, forceRefresh) {
4386
+ var _getLockboxManifest = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee32(lockboxUuid, filter, expandPrivateMetadata, lockboxOwnerUuid, forceRefresh) {
3828
4387
  var _this4 = this;
3829
4388
 
3830
4389
  var manifestKey;
3831
- return _regeneratorRuntime().wrap(function _callee32$(_context33) {
4390
+ return runtime_1.wrap(function _callee32$(_context33) {
3832
4391
  while (1) {
3833
4392
  switch (_context33.prev = _context33.next) {
3834
4393
  case 0:
@@ -3853,9 +4412,9 @@ var OroClient = /*#__PURE__*/function () {
3853
4412
  case 4:
3854
4413
  return _context33.abrupt("return", this.vaultClient.lockboxManifestGet(lockboxUuid, filter, lockboxOwnerUuid).then(function (manifest) {
3855
4414
  return Promise.all(manifest.map( /*#__PURE__*/function () {
3856
- var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee31(entry) {
4415
+ var _ref4 = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee31(entry) {
3857
4416
  var privateMeta;
3858
- return _regeneratorRuntime().wrap(function _callee31$(_context32) {
4417
+ return runtime_1.wrap(function _callee31$(_context32) {
3859
4418
  while (1) {
3860
4419
  switch (_context32.prev = _context32.next) {
3861
4420
  case 0:
@@ -3916,11 +4475,11 @@ var OroClient = /*#__PURE__*/function () {
3916
4475
  _proto.createPersonalInformations =
3917
4476
  /*#__PURE__*/
3918
4477
  function () {
3919
- var _createPersonalInformations = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee33(identity, data, dataUuid) {
4478
+ var _createPersonalInformations = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee33(identity, data, dataUuid) {
3920
4479
  var _yield$this$getGrants;
3921
4480
 
3922
4481
  var lockboxUuid;
3923
- return _regeneratorRuntime().wrap(function _callee33$(_context34) {
4482
+ return runtime_1.wrap(function _callee33$(_context34) {
3924
4483
  while (1) {
3925
4484
  switch (_context34.prev = _context34.next) {
3926
4485
  case 0:
@@ -3986,11 +4545,11 @@ var OroClient = /*#__PURE__*/function () {
3986
4545
  _proto.createUserPreference =
3987
4546
  /*#__PURE__*/
3988
4547
  function () {
3989
- var _createUserPreference = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee34(identity, preference, dataUuid) {
4548
+ var _createUserPreference = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee34(identity, preference, dataUuid) {
3990
4549
  var _yield$this$getGrants2;
3991
4550
 
3992
4551
  var lockboxUuid;
3993
- return _regeneratorRuntime().wrap(function _callee34$(_context35) {
4552
+ return runtime_1.wrap(function _callee34$(_context35) {
3994
4553
  while (1) {
3995
4554
  switch (_context35.prev = _context35.next) {
3996
4555
  case 0:
@@ -4054,9 +4613,9 @@ var OroClient = /*#__PURE__*/function () {
4054
4613
  _proto.getDataFromGrant =
4055
4614
  /*#__PURE__*/
4056
4615
  function () {
4057
- var _getDataFromGrant = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee35(grant, filter) {
4616
+ var _getDataFromGrant = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee35(grant, filter) {
4058
4617
  var lockboxUuid, lockboxOwnerUuid, identificationDataUuid;
4059
- return _regeneratorRuntime().wrap(function _callee35$(_context36) {
4618
+ return runtime_1.wrap(function _callee35$(_context36) {
4060
4619
  while (1) {
4061
4620
  switch (_context36.prev = _context36.next) {
4062
4621
  case 0:
@@ -4122,9 +4681,9 @@ var OroClient = /*#__PURE__*/function () {
4122
4681
  _proto.getUserPreferenceFromConsultId =
4123
4682
  /*#__PURE__*/
4124
4683
  function () {
4125
- var _getUserPreferenceFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee36(consultationId) {
4684
+ var _getUserPreferenceFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee36(consultationId) {
4126
4685
  var grant;
4127
- return _regeneratorRuntime().wrap(function _callee36$(_context37) {
4686
+ return runtime_1.wrap(function _callee36$(_context37) {
4128
4687
  while (1) {
4129
4688
  switch (_context37.prev = _context37.next) {
4130
4689
  case 0:
@@ -4171,9 +4730,9 @@ var OroClient = /*#__PURE__*/function () {
4171
4730
  _proto.getUserPreference =
4172
4731
  /*#__PURE__*/
4173
4732
  function () {
4174
- var _getUserPreference = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee37(identity) {
4733
+ var _getUserPreference = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee37(identity) {
4175
4734
  var grant;
4176
- return _regeneratorRuntime().wrap(function _callee37$(_context38) {
4735
+ return runtime_1.wrap(function _callee37$(_context38) {
4177
4736
  while (1) {
4178
4737
  switch (_context38.prev = _context38.next) {
4179
4738
  case 0:
@@ -4222,9 +4781,9 @@ var OroClient = /*#__PURE__*/function () {
4222
4781
  _proto.getRecoveryDataFromConsultId =
4223
4782
  /*#__PURE__*/
4224
4783
  function () {
4225
- var _getRecoveryDataFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee38(consultationId) {
4784
+ var _getRecoveryDataFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee38(consultationId) {
4226
4785
  var grant;
4227
- return _regeneratorRuntime().wrap(function _callee38$(_context39) {
4786
+ return runtime_1.wrap(function _callee38$(_context39) {
4228
4787
  while (1) {
4229
4788
  switch (_context39.prev = _context39.next) {
4230
4789
  case 0:
@@ -4271,9 +4830,9 @@ var OroClient = /*#__PURE__*/function () {
4271
4830
  _proto.getRecoveryData =
4272
4831
  /*#__PURE__*/
4273
4832
  function () {
4274
- var _getRecoveryData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee39(identity) {
4833
+ var _getRecoveryData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee39(identity) {
4275
4834
  var grant;
4276
- return _regeneratorRuntime().wrap(function _callee39$(_context40) {
4835
+ return runtime_1.wrap(function _callee39$(_context40) {
4277
4836
  while (1) {
4278
4837
  switch (_context40.prev = _context40.next) {
4279
4838
  case 0:
@@ -4327,10 +4886,10 @@ var OroClient = /*#__PURE__*/function () {
4327
4886
  _proto.getAssignedConsultations =
4328
4887
  /*#__PURE__*/
4329
4888
  function () {
4330
- var _getAssignedConsultations = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee41(practiceUuid, forceRefresh) {
4889
+ var _getAssignedConsultations = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee41(practiceUuid, forceRefresh) {
4331
4890
  var _this5 = this;
4332
4891
 
4333
- return _regeneratorRuntime().wrap(function _callee41$(_context42) {
4892
+ return runtime_1.wrap(function _callee41$(_context42) {
4334
4893
  while (1) {
4335
4894
  switch (_context42.prev = _context42.next) {
4336
4895
  case 0:
@@ -4349,8 +4908,8 @@ var OroClient = /*#__PURE__*/function () {
4349
4908
  documentType: initApis.DocumentType.PopulatedWorkflowData
4350
4909
  }, true, undefined, forceRefresh).then(function (manifest) {
4351
4910
  return Promise.all(manifest.map( /*#__PURE__*/function () {
4352
- var _ref5 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee40(entry) {
4353
- return _regeneratorRuntime().wrap(function _callee40$(_context41) {
4911
+ var _ref5 = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee40(entry) {
4912
+ return runtime_1.wrap(function _callee40$(_context41) {
4354
4913
  while (1) {
4355
4914
  switch (_context41.prev = _context41.next) {
4356
4915
  case 0:
@@ -4404,11 +4963,11 @@ var OroClient = /*#__PURE__*/function () {
4404
4963
  _proto.getPastConsultationsFromConsultId =
4405
4964
  /*#__PURE__*/
4406
4965
  function () {
4407
- var _getPastConsultationsFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee43(consultationId, practiceUuid) {
4966
+ var _getPastConsultationsFromConsultId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee43(consultationId, practiceUuid) {
4408
4967
  var _this6 = this;
4409
4968
 
4410
4969
  var grant, consultationsInLockbox;
4411
- return _regeneratorRuntime().wrap(function _callee43$(_context44) {
4970
+ return runtime_1.wrap(function _callee43$(_context44) {
4412
4971
  while (1) {
4413
4972
  switch (_context44.prev = _context44.next) {
4414
4973
  case 0:
@@ -4447,8 +5006,8 @@ var OroClient = /*#__PURE__*/function () {
4447
5006
  case 10:
4448
5007
  _context44.next = 12;
4449
5008
  return Promise.all(consultationsInLockbox.map( /*#__PURE__*/function () {
4450
- var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee42(consultId) {
4451
- return _regeneratorRuntime().wrap(function _callee42$(_context43) {
5009
+ var _ref6 = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee42(consultId) {
5010
+ return runtime_1.wrap(function _callee42$(_context43) {
4452
5011
  while (1) {
4453
5012
  switch (_context43.prev = _context43.next) {
4454
5013
  case 0:
@@ -4499,10 +5058,10 @@ var OroClient = /*#__PURE__*/function () {
4499
5058
  _proto.getPatientConsultationData =
4500
5059
  /*#__PURE__*/
4501
5060
  function () {
4502
- var _getPatientConsultationData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee44(consultationId, forceRefresh) {
5061
+ var _getPatientConsultationData = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee44(consultationId, forceRefresh) {
4503
5062
  var _this7 = this;
4504
5063
 
4505
- return _regeneratorRuntime().wrap(function _callee44$(_context45) {
5064
+ return runtime_1.wrap(function _callee44$(_context45) {
4506
5065
  while (1) {
4507
5066
  switch (_context45.prev = _context45.next) {
4508
5067
  case 0:
@@ -4556,8 +5115,8 @@ var OroClient = /*#__PURE__*/function () {
4556
5115
  _proto.getPatientPrescriptionsList =
4557
5116
  /*#__PURE__*/
4558
5117
  function () {
4559
- var _getPatientPrescriptionsList = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee45(consultationId) {
4560
- return _regeneratorRuntime().wrap(function _callee45$(_context46) {
5118
+ var _getPatientPrescriptionsList = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee45(consultationId) {
5119
+ return runtime_1.wrap(function _callee45$(_context46) {
4561
5120
  while (1) {
4562
5121
  switch (_context46.prev = _context46.next) {
4563
5122
  case 0:
@@ -4590,8 +5149,8 @@ var OroClient = /*#__PURE__*/function () {
4590
5149
  _proto.getPatientResultsList =
4591
5150
  /*#__PURE__*/
4592
5151
  function () {
4593
- var _getPatientResultsList = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee46(consultationId) {
4594
- return _regeneratorRuntime().wrap(function _callee46$(_context47) {
5152
+ var _getPatientResultsList = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee46(consultationId) {
5153
+ return runtime_1.wrap(function _callee46$(_context47) {
4595
5154
  while (1) {
4596
5155
  switch (_context47.prev = _context47.next) {
4597
5156
  case 0:
@@ -4624,8 +5183,8 @@ var OroClient = /*#__PURE__*/function () {
4624
5183
  _proto.getPatientTreatmentPlans =
4625
5184
  /*#__PURE__*/
4626
5185
  function () {
4627
- var _getPatientTreatmentPlans = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee47(consultationId) {
4628
- return _regeneratorRuntime().wrap(function _callee47$(_context48) {
5186
+ var _getPatientTreatmentPlans = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee47(consultationId) {
5187
+ return runtime_1.wrap(function _callee47$(_context48) {
4629
5188
  while (1) {
4630
5189
  switch (_context48.prev = _context48.next) {
4631
5190
  case 0:
@@ -4659,8 +5218,8 @@ var OroClient = /*#__PURE__*/function () {
4659
5218
  _proto.getPatientTreatmentPlanByUuid =
4660
5219
  /*#__PURE__*/
4661
5220
  function () {
4662
- var _getPatientTreatmentPlanByUuid = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee48(consultationId, treatmentPlanId) {
4663
- return _regeneratorRuntime().wrap(function _callee48$(_context49) {
5221
+ var _getPatientTreatmentPlanByUuid = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee48(consultationId, treatmentPlanId) {
5222
+ return runtime_1.wrap(function _callee48$(_context49) {
4664
5223
  while (1) {
4665
5224
  switch (_context49.prev = _context49.next) {
4666
5225
  case 0:
@@ -4698,10 +5257,10 @@ var OroClient = /*#__PURE__*/function () {
4698
5257
  _proto.getPatientDocumentsList =
4699
5258
  /*#__PURE__*/
4700
5259
  function () {
4701
- var _getPatientDocumentsList = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee50(filters, expandPrivateMetadata, consultationId) {
5260
+ var _getPatientDocumentsList = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee50(filters, expandPrivateMetadata, consultationId) {
4702
5261
  var _this8 = this;
4703
5262
 
4704
- return _regeneratorRuntime().wrap(function _callee50$(_context51) {
5263
+ return runtime_1.wrap(function _callee50$(_context51) {
4705
5264
  while (1) {
4706
5265
  switch (_context51.prev = _context51.next) {
4707
5266
  case 0:
@@ -4717,8 +5276,8 @@ var OroClient = /*#__PURE__*/function () {
4717
5276
  consultationId: consultationId
4718
5277
  }), expandPrivateMetadata, grant.lockboxOwnerUuid, true).then(function (manifest) {
4719
5278
  return Promise.all(manifest.map( /*#__PURE__*/function () {
4720
- var _ref7 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee49(entry) {
4721
- return _regeneratorRuntime().wrap(function _callee49$(_context50) {
5279
+ var _ref7 = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee49(entry) {
5280
+ return runtime_1.wrap(function _callee49$(_context50) {
4722
5281
  while (1) {
4723
5282
  switch (_context50.prev = _context50.next) {
4724
5283
  case 0:
@@ -4776,9 +5335,9 @@ var OroClient = /*#__PURE__*/function () {
4776
5335
  _proto.recoverPrivateKeyFromSecurityQuestions =
4777
5336
  /*#__PURE__*/
4778
5337
  function () {
4779
- var _recoverPrivateKeyFromSecurityQuestions = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee51(id, recoverySecurityQuestions, recoverySecurityAnswers, threshold) {
5338
+ var _recoverPrivateKeyFromSecurityQuestions = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee51(id, recoverySecurityQuestions, recoverySecurityAnswers, threshold) {
4780
5339
  var shards, answeredShards, privateKey;
4781
- return _regeneratorRuntime().wrap(function _callee51$(_context52) {
5340
+ return runtime_1.wrap(function _callee51$(_context52) {
4782
5341
  while (1) {
4783
5342
  switch (_context52.prev = _context52.next) {
4784
5343
  case 0:
@@ -4832,9 +5391,9 @@ var OroClient = /*#__PURE__*/function () {
4832
5391
  _proto.recoverPrivateKeyFromPassword =
4833
5392
  /*#__PURE__*/
4834
5393
  function () {
4835
- var _recoverPrivateKeyFromPassword = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee52(id, password) {
5394
+ var _recoverPrivateKeyFromPassword = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee52(id, password) {
4836
5395
  var identity, recoveryPayload, symmetricDecryptor, privateKey, symetricEncryptor;
4837
- return _regeneratorRuntime().wrap(function _callee52$(_context53) {
5396
+ return runtime_1.wrap(function _callee52$(_context53) {
4838
5397
  while (1) {
4839
5398
  switch (_context53.prev = _context53.next) {
4840
5399
  case 0:
@@ -4880,9 +5439,9 @@ var OroClient = /*#__PURE__*/function () {
4880
5439
  _proto.recoverPrivateKeyFromMasterKey =
4881
5440
  /*#__PURE__*/
4882
5441
  function () {
4883
- var _recoverPrivateKeyFromMasterKey = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee53(id, masterKey) {
5442
+ var _recoverPrivateKeyFromMasterKey = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee53(id, masterKey) {
4884
5443
  var recoveryPayload, symmetricDecryptor, privateKey;
4885
- return _regeneratorRuntime().wrap(function _callee53$(_context54) {
5444
+ return runtime_1.wrap(function _callee53$(_context54) {
4886
5445
  while (1) {
4887
5446
  switch (_context54.prev = _context54.next) {
4888
5447
  case 0:
@@ -4922,9 +5481,9 @@ var OroClient = /*#__PURE__*/function () {
4922
5481
  _proto.updateSecurityQuestions =
4923
5482
  /*#__PURE__*/
4924
5483
  function () {
4925
- var _updateSecurityQuestions = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee54(id, recoverySecurityQuestions, recoverySecurityAnswers, threshold) {
5484
+ var _updateSecurityQuestions = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee54(id, recoverySecurityQuestions, recoverySecurityAnswers, threshold) {
4926
5485
  var securityQuestionPayload, updateRequest;
4927
- return _regeneratorRuntime().wrap(function _callee54$(_context55) {
5486
+ return runtime_1.wrap(function _callee54$(_context55) {
4928
5487
  while (1) {
4929
5488
  switch (_context55.prev = _context55.next) {
4930
5489
  case 0:
@@ -4976,9 +5535,9 @@ var OroClient = /*#__PURE__*/function () {
4976
5535
  _proto.updatePassword =
4977
5536
  /*#__PURE__*/
4978
5537
  function () {
4979
- var _updatePassword = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee55(id, newPassword, oldPassword) {
5538
+ var _updatePassword = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee55(id, newPassword, oldPassword) {
4980
5539
  var symmetricEncryptor, passwordPayload, updateRequest;
4981
- return _regeneratorRuntime().wrap(function _callee55$(_context56) {
5540
+ return runtime_1.wrap(function _callee55$(_context56) {
4982
5541
  while (1) {
4983
5542
  switch (_context56.prev = _context56.next) {
4984
5543
  case 0:
@@ -5038,9 +5597,9 @@ var OroClient = /*#__PURE__*/function () {
5038
5597
  _proto.updateMasterKey =
5039
5598
  /*#__PURE__*/
5040
5599
  function () {
5041
- var _updateMasterKey = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee56(id, masterKey, lockboxUuid) {
5600
+ var _updateMasterKey = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee56(id, masterKey, lockboxUuid) {
5042
5601
  var symmetricEncryptor, masterKeyPayload, updateRequest, updatedIdentity;
5043
- return _regeneratorRuntime().wrap(function _callee56$(_context57) {
5602
+ return runtime_1.wrap(function _callee56$(_context57) {
5044
5603
  while (1) {
5045
5604
  switch (_context57.prev = _context57.next) {
5046
5605
  case 0:
@@ -5203,6 +5762,7 @@ exports.decryptGrants = decryptGrants;
5203
5762
  exports.default = init;
5204
5763
  exports.extractAndStorePersonalWorkflowData = extractAndStorePersonalWorkflowData;
5205
5764
  exports.extractISOLocalityForConsult = extractISOLocalityForConsult;
5765
+ exports.extractPersonalInfoFromConsultId = extractPersonalInfoFromConsultId;
5206
5766
  exports.fillWorkflowFromPopulatedWorkflow = fillWorkflowFromPopulatedWorkflow;
5207
5767
  exports.filterTriggeredAnsweredWithKind = filterTriggeredAnsweredWithKind;
5208
5768
  exports.flattenSelectedAnswers = flattenSelectedAnswers;
@@ -5212,6 +5772,7 @@ exports.getWorkflowDataByCategory = getWorkflowDataByCategory;
5212
5772
  exports.identificationToPersonalInformations = identificationToPersonalInformations;
5213
5773
  exports.isTriggered = isTriggered;
5214
5774
  exports.registerPatient = registerPatient;
5775
+ exports.searchIndexConsultation = searchIndexConsultation;
5215
5776
  exports.sessionStorePrivateKeyName = sessionStorePrivateKeyName;
5216
5777
  exports.toActualObject = toActualObject;
5217
5778
  exports.updatePersonalIntoPopulatedWorkflowData = updatePersonalIntoPopulatedWorkflowData;