https://patient.exactsciences.com/main.a9e4df955e9625bafcad.js

1/******/ (() => { // webpackBootstrap
2/******/ 	var __webpack_modules__ = ({
3
4/***/ "./src/index.js"
5/*!**********************!*\
6  !*** ./src/index.js ***!
7  \**********************/
8(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
9
10"use strict";
11__webpack_require__.r(__webpack_exports__);
12/* harmony import */ var _babel_runtime_helpers_asyncToGenerator__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/asyncToGenerator */ "./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js");
13
14function _regenerator() { /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */ var e, t, r = "function" == typeof Symbol ? Symbol : {}, n = r.iterator || "@@iterator", o = r.toStringTag || "@@toStringTag"; function i(r, n, o, i) { var c = n && n.prototype instanceof Generator ? n : Generator, u = Object.create(c.prototype); return _regeneratorDefine2(u, "_invoke", function (r, n, o) { var i, c, u, f = 0, p = o || [], y = !1, G = { p: 0, n: 0, v: e, a: d, f: d.bind(e, 4), d: function d(t, r) { return i = t, c = 0, u = e, G.n = r, a; } }; function d(r, n) { for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) { var o, i = p[t], d = G.p, l = i[2]; r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0)); } if (o || r > 1) return a; throw y = !0, n; } return function (o, p, l) { if (f > 1) throw TypeError("Generator is already running"); for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) { i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u); try { if (f = 2, i) { if (c || (o = "next"), t = i[o]) { if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object"); if (!t.done) return t; u = t.value, c < 2 && (c = 0); } else 1 === c && (t = i["return"]) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1); i = e; } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break; } catch (t) { i = e, c = 1, u = t; } finally { f = 1; } } return { value: t, done: y }; }; }(r, o, i), !0), u; } var a = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} t = Object.getPrototypeOf; var c = [][n] ? t(t([][n]())) : (_regeneratorDefine2(t = {}, n, function () { return this; }), t), u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c); function f(e) { return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, _regeneratorDefine2(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e; } return GeneratorFunction.prototype = GeneratorFunctionPrototype, _regeneratorDefine2(u, "constructor", GeneratorFunctionPrototype), _regeneratorDefine2(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", _regeneratorDefine2(GeneratorFunctionPrototype, o, "GeneratorFunction"), _regeneratorDefine2(u), _regeneratorDefine2(u, o, "Generator"), _regeneratorDefine2(u, n, function () { return this; }), _regeneratorDefine2(u, "toString", function () { return "[object Generator]"; }), (_regenerator = function _regenerator() { return { w: i, m: f }; })(); }
15function _regeneratorDefine2(e, r, n, t) { var i = Object.defineProperty; try { i({}, "", {}); } catch (e) { i = 0; } _regeneratorDefine2 = function _regeneratorDefine(e, r, n, t) { function o(r, n) { _regeneratorDefine2(e, r, function (e) { return this._invoke(r, n, e); }); } r ? i ? i(e, r, { value: n, enumerable: !t, configurable: !t, writable: !t }) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2)); }, _regeneratorDefine2(e, r, n, t); }
16// import '@exactsciences/ph-web-components/dist/index';
17// import { initConfig, localizationConfig } from '@helix-design-system/components/dist/components/localization-provider/localization-provider.js';
18// initConfig(new Map([
19//     ['es', Promise.all([

214 :
215                typeof self === "object" ? self :
216                    typeof this === "object" ? this :
217                        sloppyModeThis();
218        var exporter = makeExporter(Reflect);
219        if (typeof root.Reflect !== "undefined") {
220            exporter = makeExporter(root.Reflect, exporter);
221        }
222        factory(exporter, root);
223        if (typeof root.Reflect === "undefined") {
224            root.Reflect = Reflect;
225        }
226        function makeExporter(target, previous) {
227            return function (key, value) {
228                Object.defineProperty(target, key, { configurable: true, writable: true, value: value });
229                if (previous)
230                    previous(key, value);
231            };
232        }
233        function functionThis() {
234            try {
235                return Function("return this;")();
236            }
237            catch (_) { }
238        }
239        function indirectEvalThis() {
240            try {
241                return (void 0, eval)("(function() { return this; })()");
242            }
243            catch (_) { }
244        }
245        function sloppyModeThis() {
246            return functionThis() || indirectEvalThis();
247        }
248    })(function (exporter, root) {
249        var hasOwn = Object.prototype.hasOwnProperty;
250        // feature test for Symbol support
251        var supportsSymbol = typeof Symbol === "function";
252        var toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== "undefined" ? Symbol.toPrimitive : "@@toPrimitive";
253        var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== "undefined" ? Symbol.iterator : "@@iterator";
254        var supportsCreate = typeof Object.create === "function"; // feature test for Object.create support
255        var supportsProto = { __proto__: [] } instanceof Array; // feature test for __proto__ support
256        var downLevel = !supportsCreate && !supportsProto;
257        var HashMap = {
258            // create an object in dictionary mode (a.k.a. "slow" mode in v8)
259            create: supportsCreate
260                ? function () { return MakeDictionary(Object.create(null)); }
261                : supportsProto
262                    ? function () { return MakeDictionary({ __proto__: null }); }
263                    : function () { return MakeDictionary({}); },
264            has: downLevel
265                ? function (map, key) { return hasOwn.call(map, key); }
266                : function (map, key) { return key in map; },
267            get: downLevel
268                ? function (map, key) { return hasOwn.call(map, key) ? map[key] : undefined; }
269                : function (map, key) { return map[key]; },
270        };
271        // Load global or shim versions of Map, Set, and WeakMap
272        var functionPrototype = Object.getPrototypeOf(Function);
273        var _Map = typeof Map === "function" && typeof Map.prototype.entries === "function" ? Map : CreateMapPolyfill();
274        var _Set = typeof Set === "function" && typeof Set.prototype.entries === "function" ? Set : CreateSetPolyfill();
275        var _WeakMap = typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill();
276        var registrySymbol = supportsSymbol ? Symbol.for("@reflect-metadata:registry") : undefined;
277        var metadataRegistry = GetOrCreateMetadataRegistry();
278        var metadataProvider = CreateMetadataProvider(metadataRegistry);
279        /**
280         * Applies a set of decorators to a property of a target object.
281         * @param decorators An array of decorators.
282         * @param target The target object.
283         * @param propertyKey (Optional) The property key to decorate.
284         * @param attributes (Optional) The property descriptor for the target key.
285         * @remarks Decorators are applied in reverse order.
286         * @example
287         *
288         *     class Example {
289         *         // property declarations are not part of ES6, though they are valid in TypeScript:
290         *         // static staticProperty;
291         *         // property;
292         *
293         *         constructor(p) { }
294         *         static staticMethod(p) { }
295         *         method(p) { }
296         *     }
297         *
298         *     // constructor
299         *     Example = Reflect.decorate(decoratorsArray, Example);
300         *
301         *     // property (on constructor)
302         *     Reflect.decorate(decoratorsArray, Example, "staticProperty");
303         *
304         *     // property (on prototype)
305         *     Reflect.decorate(decoratorsArray, Example.prototype, "property");
306         *
307         *     // method (on constructor)
308         *     Object.defineProperty(Example, "staticMethod",
309         *         Reflect.decorate(decoratorsArray, Example, "staticMethod",
310         *             Object.getOwnPropertyDescriptor(Example, "staticMethod")));
311         *
312         *     // method (on prototype)
313         *     Object.defineProperty(Example.prototype, "method",
314         *         Reflect.decorate(decoratorsArray, Example.prototype, "method",
315         *             Object.getOwnPropertyDescriptor(Example.prototype, "method")));
316         *
317         */
318        function decorate(decorators, target, propertyKey, attributes) {
319            if (!IsUndefined(propertyKey)) {
320                if (!IsArray(decorators))
321                    throw new TypeError();
322                if (!IsObject(target))
323                    throw new TypeError();
324                if (!IsObject(attributes) && !IsUndefined(attributes) && !IsNull(attributes))
325                    throw new TypeError();
326                if (IsNull(attributes))
327                    attributes = undefined;
328                propertyKey = ToPropertyKey(propertyKey);
329                return DecorateProperty(decorators, target, propertyKey, attributes);
330            }
331            else {
332                if (!IsArray(decorators))
333                    throw new TypeError();
334                if (!IsConstructor(target))
335                    throw new TypeError();
336                return DecorateConstructor(decorators, target);
337            }
338        }
339        exporter("decorate", decorate);
340        // 4.1.2 Reflect.metadata(metadataKey, metadataValue)
341        // https://rbuckton.github.io/reflect-metadata/#reflect.metadata
342        /**
343         * A default metadata decorator factory that can be used on a class, class member, or parameter.
344         * @param metadataKey The key for the metadata entry.
345         * @param metadataValue The value for the metadata entry.
346         * @returns A decorator function.
347         * @remarks
348         * If `metadataKey` is already defined for the target and target key, the
349         * metadataValue for that key will be overwritten.
350         * @example
351         *
352         *     // constructor
353         *     @Reflect.metadata(key, value)
354         *     class Example {
355         *     }
356         *
357         *     // property (on constructor, TypeScript only)
358         *     class Example {
359         *         @Reflect.metadata(key, value)
360         *         static staticProperty;
361         *     }
362         *
363         *     // property (on prototype, TypeScript only)
364         *     class Example {
365         *         @Reflect.metadata(key, value)
366         *         property;
367         *     }
368         *
369         *     // method (on constructor)
370         *     class Example {
371         *         @Reflect.metadata(key, value)
372         *         static staticMethod() { }
373         *     }
374         *
375         *     // method (on prototype)
376         *     class Example {
377         *         @Reflect.metadata(key, value)
378         *         method() { }
379         *     }
380         *
381         */
382        function metadata(metadataKey, metadataValue) {
383            function decorator(target, propertyKey) {
384                if (!IsObject(target))
385                    throw new TypeError();
386                if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey))
387                    throw new TypeError();
388                OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
389            }
390            return decorator;
391        }
392        exporter("metadata", metadata);
393        /**
394         * Define a unique metadata entry on the target.
395         * @param metadataKey A key used to store and retrieve metadata.
396         * @param metadataValue A value that contains attached metadata.
397         * @param target The target object on which to define metadata.
398         * @param propertyKey (Optional) The property key for the target.
399         * @example
400         *
401         *     class Example {
402         *         // property declarations are not part of ES6, though they are valid in TypeScript:
403         *         // static staticProperty;
404         *         // property;
405         *
406         *         constructor(p) { }
407         *         static staticMethod(p) { }
408         *         method(p) { }
409         *     }
410         *
411         *     // constructor
412         *     Reflect.defineMetadata("custom:annotation", options, Example);
413         *
414         *     // property (on constructor)
415         *     Reflect.defineMetadata("custom:annotation", options, Example, "staticProperty");
416         *
417         *     // property (on prototype)
418         *     Reflect.defineMetadata("custom:annotation", options, Example.prototype, "property");
419         *
420         *     // method (on constructor)
421         *     Reflect.defineMetadata("custom:annotation", options, Example, "staticMethod");
422         *
423         *     // method (on prototype)
424         *     Reflect.defineMetadata("custom:annotation", options, Example.prototype, "method");
425         *
426         *     // decorator factory as metadata-producing annotation.
427         *     function MyAnnotation(options): Decorator {
428         *         return (target, key?) => Reflect.defineMetadata("custom:annotation", options, target, key);
429         *     }
430         *
431         */
432        function defineMetadata(metadataKey, metadataValue, target, propertyKey) {
433            if (!IsObject(target))
434                throw new TypeError();
435            if (!IsUndefined(propertyKey))
436                propertyKey = ToPropertyKey(propertyKey);
437            return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
438        }
439        exporter("defineMetadata", defineMetadata);
440        /**
441         * Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
442         * @param metadataKey A key used to store and retrieve metadata.
443         * @param target The target object on which the metadata is defined.
444         * @param propertyKey (Optional) The property key for the target.
445         * @returns `true` if the metadata key was defined on the target object or its prototype chain; otherwise, `false`.
446         * @example
447         *
448         *     class Example {
449         *         // property declarations are not part of ES6, though they are valid in TypeScript:
450         *         // static staticProperty;
451         *         // property;
452         *
453         *         constructor(p) { }
454         *         static staticMethod(p) { }
455         *         method(p) { }
456         *     }
457         *
458         *     // constructor
459         *     result = Reflect.hasMetadata("custom:annotation", Example);
460         *
461         *     // property (on constructor)
462         *     result = Reflect.hasMetadata("custom:annotation", Example, "staticProperty");
463         *
464         *     // property (on prototype)
465         *     result = Reflect.hasMetadata("custom:annotation", Example.prototype, "property");
466         *
467         *     // method (on constructor)
468         *     result = Reflect.hasMetadata("custom:annotation", Example, "staticMethod");
469         *
470         *     // method (on prototype)
471         *     result = Reflect.hasMetadata("custom:annotation", Example.prototype, "method");
472         *
473         */
474        function hasMetadata(metadataKey, target, propertyKey) {
475            if (!IsObject(target))
476                throw new TypeError();
477            if (!IsUndefined(propertyKey))
478                propertyKey = ToPropertyKey(propertyKey);
479            return OrdinaryHasMetadata(metadataKey, target, propertyKey);
480        }
481        exporter("hasMetadata", hasMetadata);
482        /**
483         * Gets a value indicating whether the target object has the provided metadata key defined.
484         * @param metadataKey A key used to store and retrieve metadata.
485         * @param target The target object on which the metadata is defined.
486         * @param propertyKey (Optional) The property key for the target.
487         * @returns `true` if the metadata key was defined on the target object; otherwise, `false`.
488         * @example
489         *
490         *     class Example {
491         *         // property declarations are not part of ES6, though they are valid in TypeScript:
492         *         // static staticProperty;
493         *         // property;
494         *
495         *         constructor(p) { }
496         *         static staticMethod(p) { }
497         *         method(p) { }
498         *     }
499         *
500         *     // constructor
501         *     result = Reflect.hasOwnMetadata("custom:annotation", Example);
502         *
503         *     // property (on constructor)
504         *     result = Reflect.hasOwnMetadata("custom:annotation", Example, "staticProperty");
505         *
506         *     // property (on prototype)
507         *     result = Reflect.hasOwnMetadata("custom:annotation", Example.prototype, "property");
508         *
509         *     // method (on constructor)
510         *     result = Reflect.hasOwnMetadata("custom:annotation", Example, "staticMethod");
511         *
512         *     // method (on prototype)
513         *     result = Reflect.hasOwnMetadata("custom:annotation", Example.prototype, "method");
514         *
515         */
516        function hasOwnMetadata(metadataKey, target, propertyKey) {
517            if (!IsObject(target))
518                throw new TypeError();
519            if (!IsUndefined(propertyKey))
520                propertyKey = ToPropertyKey(propertyKey);
521            return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);
522        }
523        exporter("hasOwnMetadata", hasOwnMetadata);
524        /**
525         * Gets the metadata value for the provided metadata key on the target object or its prototype chain.
526         * @param metadataKey A key used to store and retrieve metadata.
527         * @param target The target object on which the metadata is defined.
528         * @param propertyKey (Optional) The property key for the target.
529         * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
530         * @example
531         *
532         *     class Example {
533         *         // property declarations are not part of ES6, though they are valid in TypeScript:
534         *         // static staticProperty;
535         *         // property;
536         *
537         *         constructor(p) { }
538         *         static staticMethod(p) { }
539         *         method(p) { }
540         *     }
541         *
542         *     // constructor
543         *     result = Reflect.getMetadata("custom:annotation", Example);
544         *
545         *     // property (on constructor)
546         *     result = Reflect.getMetadata("custom:annotation", Example, "staticProperty");
547         *
548         *     // property (on prototype)
549         *     result = Reflect.getMetadata("custom:annotation", Example.prototype, "property");
550         *
551         *     // method (on constructor)
552         *     result = Reflect.getMetadata("custom:annotation", Example, "staticMethod");
553         *
554         *     // method (on prototype)
555         *     result = Reflect.getMetadata("custom:annotation", Example.prototype, "method");
556         *
557         */
558        function getMetadata(metadataKey, target, propertyKey) {
559            if (!IsObject(target))
560                throw new TypeError();
561            if (!IsUndefined(propertyKey))
562                propertyKey = ToPropertyKey(propertyKey);
563            return OrdinaryGetMetadata(metadataKey, target, propertyKey);
564        }
565        exporter("getMetadata", getMetadata);
566        /**
567         * Gets the metadata value for the provided metadata key on the target object.
568         * @param metadataKey A key used to store and retrieve metadata.
569         * @param target The target object on which the metadata is defined.
570         * @param propertyKey (Optional) The property key for the target.
571         * @returns The metadata value for the metadata key if found; otherwise, `undefined`.
572         * @example
573         *
574         *     class Example {
575         *         // property declarations are not part of ES6, though they are valid in TypeScript:
576         *         // static staticProperty;
577         *         // property;
578         *
579         *         constructor(p) { }
580         *         static staticMethod(p) { }
581         *         method(p) { }
582         *     }
583         *
584         *     // constructor
585         *     result = Reflect.getOwnMetadata("custom:annotation", Example);
586         *
587         *     // property (on constructor)
588         *     result = Reflect.getOwnMetadata("custom:annotation", Example, "staticProperty");
589         *
590         *     // property (on prototype)
591         *     result = Reflect.getOwnMetadata("custom:annotation", Example.prototype, "property");
592         *
593         *     // method (on constructor)
594         *     result = Reflect.getOwnMetadata("custom:annotation", Example, "staticMethod");
595         *
596         *     // method (on prototype)
597         *     result = Reflect.getOwnMetadata("custom:annotation", Example.prototype, "method");
598         *
599         */
600        function getOwnMetadata(metadataKey, target, propertyKey) {
601            if (!IsObject(target))
602                throw new TypeError();
603            if (!IsUndefined(propertyKey))
604                propertyKey = ToPropertyKey(propertyKey);
605            return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey);
606        }
607        exporter("getOwnMetadata", getOwnMetadata);
608        /**
609         * Gets the metadata keys defined on the target object or its prototype chain.
610         * @param target The target object on which the metadata is defined.
611         * @param propertyKey (Optional) The property key for the target.
612         * @returns An array of unique metadata keys.
613         * @example
614         *
615         *     class Example {
616         *         // property declarations are not part of ES6, though they are valid in TypeScript:
617         *         // static staticProperty;
618         *         // property;
619         *
620         *         constructor(p) { }
621         *         static staticMethod(p) { }
622         *         method(p) { }
623         *     }
624         *
625         *     // constructor
626         *     result = Reflect.getMetadataKeys(Example);
627         *
628         *     // property (on constructor)
629         *     result = Reflect.getMetadataKeys(Example, "staticProperty");
630         *
631         *     // property (on prototype)
632         *     result = Reflect.getMetadataKeys(Example.prototype, "property");
633         *
634         *     // method (on constructor)
635         *     result = Reflect.getMetadataKeys(Example, "staticMethod");
636         *
637         *     // method (on prototype)
638         *     result = Reflect.getMetadataKeys(Example.prototype, "method");
639         *
640         */
641        function getMetadataKeys(target, propertyKey) {
642            if (!IsObject(target))
643                throw new TypeError();
644            if (!IsUndefined(propertyKey))
645                propertyKey = ToPropertyKey(propertyKey);
646            return OrdinaryMetadataKeys(target, propertyKey);
647        }
648        exporter("getMetadataKeys", getMetadataKeys);
649        /**
650         * Gets the unique metadata keys defined on the target object.
651         * @param target The target object on which the metadata is defined.
652         * @param propertyKey (Optional) The property key for the target.
653         * @returns An array of unique metadata keys.
654         * @example
655         *
656         *     class Example {
657         *         // property declarations are not part of ES6, though they are valid in TypeScript:
658         *         // static staticProperty;
659         *         // property;
660         *
661         *         constructor(p) { }
662         *         static staticMethod(p) { }
663         *         method(p) { }
664         *     }
665         *
666         *     // constructor
667         *     result = Reflect.getOwnMetadataKeys(Example);
668         *
669         *     // property (on constructor)
670         *     result = Reflect.getOwnMetadataKeys(Example, "staticProperty");
671         *
672         *     // property (on prototype)
673         *     result = Reflect.getOwnMetadataKeys(Example.prototype, "property");
674         *
675         *     // method (on constructor)
676         *     result = Reflect.getOwnMetadataKeys(Example, "staticMethod");
677         *
678         *     // method (on prototype)
679         *     result = Reflect.getOwnMetadataKeys(Example.prototype, "method");
680         *
681         */
682        function getOwnMetadataKeys(target, propertyKey) {
683            if (!IsObject(target))
684                throw new TypeError();
685            if (!IsUndefined(propertyKey))
686                propertyKey = ToPropertyKey(propertyKey);
687            return OrdinaryOwnMetadataKeys(target, propertyKey);
688        }
689        exporter("getOwnMetadataKeys", getOwnMetadataKeys);
690        /**
691         * Deletes the metadata entry from the target object with the provided key.
692         * @param metadataKey A key used to store and retrieve metadata.
693         * @param target The target object on which the metadata is defined.
694         * @param propertyKey (Optional) The property key for the target.
695         * @returns `true` if the metadata entry was found and deleted; otherwise, false.
696         * @example
697         *
698         *     class Example {
699         *         // property declarations are not part of ES6, though they are valid in TypeScript:
700         *         // static staticProperty;
701         *         // property;
702         *
703         *         constructor(p) { }
704         *         static staticMethod(p) { }
705         *         method(p) { }
706         *     }
707         *
708         *     // constructor
709         *     result = Reflect.deleteMetadata("custom:annotation", Example);
710         *
711         *     // property (on constructor)
712         *     result = Reflect.deleteMetadata("custom:annotation", Example, "staticProperty");
713         *
714         *     // property (on prototype)
715         *     result = Reflect.deleteMetadata("custom:annotation", Example.prototype, "property");
716         *
717         *     // method (on constructor)
718         *     result = Reflect.deleteMetadata("custom:annotation", Example, "staticMethod");
719         *
720         *     // method (on prototype)
721         *     result = Reflect.deleteMetadata("custom:annotation", Example.prototype, "method");
722         *
723         */
724        function deleteMetadata(metadataKey, target, propertyKey) {
725            if (!IsObject(target))
726                throw new TypeError();
727            if (!IsUndefined(propertyKey))
728                propertyKey = ToPropertyKey(propertyKey);
729            if (!IsObject(target))
730                throw new TypeError();
731            if (!IsUndefined(propertyKey))
732                propertyKey = ToPropertyKey(propertyKey);
733            var provider = GetMetadataProvider(target, propertyKey, /*Create*/ false);
734            if (IsUndefined(provider))
735                return false;

736            return provider.OrdinaryDeleteMetadata(metadataKey, target, propertyKey);
737        }
738        exporter("deleteMetadata", deleteMetadata);
739        function DecorateConstructor(decorators, target) {
740            for (var i = decorators.length - 1; i >= 0; --i) {
741                var decorator = decorators[i];
742                var decorated = decorator(target);
743                if (!IsUndefined(decorated) && !IsNull(decorated)) {
744                    if (!IsConstructor(decorated))
745                        throw new TypeError();
746                    target = decorated;
747                }
748            }
749            return target;
750        }
751        function DecorateProperty(decorators, target, propertyKey, descriptor) {
752            for (var i = decorators.length - 1; i >= 0; --i) {
753                var decorator = decorators[i];
754                var decorated = decorator(target, propertyKey, descriptor);
755                if (!IsUndefined(decorated) && !IsNull(decorated)) {
756                    if (!IsObject(decorated))
757                        throw new TypeError();
758                    descriptor = decorated;
759                }
760            }
761            return descriptor;
762        }
763        // 3.1.1.1 OrdinaryHasMetadata(MetadataKey, O, P)
764        // https://rbuckton.github.io/reflect-metadata/#ordinaryhasmetadata
765        function OrdinaryHasMetadata(MetadataKey, O, P) {
766            var hasOwn = OrdinaryHasOwnMetadata(MetadataKey, O, P);
767            if (hasOwn)
768                return true;
769            var parent = OrdinaryGetPrototypeOf(O);
770            if (!IsNull(parent))
771                return OrdinaryHasMetadata(MetadataKey, parent, P);
772            return false;
773        }
774        // 3.1.2.1 OrdinaryHasOwnMetadata(MetadataKey, O, P)
775        // https://rbuckton.github.io/reflect-metadata/#ordinaryhasownmetadata
776        function OrdinaryHasOwnMetadata(MetadataKey, O, P) {
777            var provider = GetMetadataProvider(O, P, /*Create*/ false);
778            if (IsUndefined(provider))
779                return false;
780            return ToBoolean(provider.OrdinaryHasOwnMetadata(MetadataKey, O, P));
781        }
782        // 3.1.3.1 OrdinaryGetMetadata(MetadataKey, O, P)
783        // https://rbuckton.github.io/reflect-metadata/#ordinarygetmetadata
784        function OrdinaryGetMetadata(MetadataKey, O, P) {
785            var hasOwn = OrdinaryHasOwnMetadata(MetadataKey, O, P);
786            if (hasOwn)
787                return OrdinaryGetOwnMetadata(MetadataKey, O, P);
788            var parent = OrdinaryGetPrototypeOf(O);
789            if (!IsNull(parent))
790                return OrdinaryGetMetadata(MetadataKey, parent, P);
791            return undefined;
792        }
793        // 3.1.4.1 OrdinaryGetOwnMetadata(MetadataKey, O, P)
794        // https://rbuckton.github.io/reflect-metadata/#ordinarygetownmetadata
795        function OrdinaryGetOwnMetadata(MetadataKey, O, P) {
796            var provider = GetMetadataProvider(O, P, /*Create*/ false);
797            if (IsUndefined(provider))
798                return;
799            return provider.OrdinaryGetOwnMetadata(MetadataKey, O, P);
800        }
801        // 3.1.5.1 OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P)
802        // https://rbuckton.github.io/reflect-metadata/#ordinarydefineownmetadata
803        function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {
804            var provider = GetMetadataProvider(O, P, /*Create*/ true);
805            provider.OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P);
806        }
807        // 3.1.6.1 OrdinaryMetadataKeys(O, P)
808        // https://rbuckton.github.io/reflect-metadata/#ordinarymetadatakeys
809        function OrdinaryMetadataKeys(O, P) {
810            var ownKeys = OrdinaryOwnMetadataKeys(O, P);
811            var parent = OrdinaryGetPrototypeOf(O);
812            if (parent === null)
813                return ownKeys;
814            var parentKeys = OrdinaryMetadataKeys(parent, P);
815            if (parentKeys.length <= 0)
816                return ownKeys;
817            if (ownKeys.length <= 0)
818                return parentKeys;
819            var set = new _Set();
820            var keys = [];
821            for (var _i = 0, ownKeys_1 = ownKeys; _i < ownKeys_1.length; _i++) {
822                var key = ownKeys_1[_i];
823                var hasKey = set.has(key);
824                if (!hasKey) {
825                    set.add(key);
826                    keys.push(key);
827                }
828            }
829            for (var _a = 0, parentKeys_1 = parentKeys; _a < parentKeys_1.length; _a++) {
830                var key = parentKeys_1[_a];
831                var hasKey = set.has(key);
832                if (!hasKey) {
833                    set.add(key);
834                    keys.push(key);
835                }
836            }
837            return keys;
838        }
839        // 3.1.7.1 OrdinaryOwnMetadataKeys(O, P)
840        // https://rbuckton.github.io/reflect-metadata/#ordinaryownmetadatakeys
841        function OrdinaryOwnMetadataKeys(O, P) {
842            var provider = GetMetadataProvider(O, P, /*create*/ false);
843            if (!provider) {
844                return [];
845            }
846            return provider.OrdinaryOwnMetadataKeys(O, P);
847        }
848        // 6 ECMAScript Data Types and Values
849        // https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values
850        function Type(x) {
851            if (x === null)
852                return 1 /* Null */;
853            switch (typeof x) {
854                case "undefined": return 0 /* Undefined */;
855                case "boolean": return 2 /* Boolean */;
856                case "string": return 3 /* String */;
857                case "symbol": return 4 /* Symbol */;
858                case "number": return 5 /* Number */;
859                case "object": return x === null ? 1 /* Null */ : 6 /* Object */;
860                default: return 6 /* Object */;
861            }
862        }
863        // 6.1.1 The Undefined Type
864        // https://tc39.github.io/ecma262/#sec-ecmascript-language-types-undefined-type
865        function IsUndefined(x) {
866            return x === undefined;
867        }
868        // 6.1.2 The Null Type
869        // https://tc39.github.io/ecma262/#sec-ecmascript-language-types-null-type
870        function IsNull(x) {
871            return x === null;
872        }
873        // 6.1.5 The Symbol Type
874        // https://tc39.github.io/ecma262/#sec-ecmascript-language-types-symbol-type
875        function IsSymbol(x) {
876            return typeof x === "symbol";
877        }
878        // 6.1.7 The Object Type
879        // https://tc39.github.io/ecma262/#sec-object-type
880        function IsObject(x) {
881            return typeof x === "object" ? x !== null : typeof x === "function";
882        }
883        // 7.1 Type Conversion
884        // https://tc39.github.io/ecma262/#sec-type-conversion
885        // 7.1.1 ToPrimitive(input [, PreferredType])
886        // https://tc39.github.io/ecma262/#sec-toprimitive
887        function ToPrimitive(input, PreferredType) {
888            switch (Type(input)) {
889                case 0 /* Undefined */: return input;
890                case 1 /* Null */: return input;
891                case 2 /* Boolean */: return input;
892                case 3 /* String */: return input;

893                case 4 /* Symbol */: return input;
894                case 5 /* Number */: return input;
895            }
896            var hint = PreferredType === 3 /* String */ ? "string" : PreferredType === 5 /* Number */ ? "number" : "default";
897            var exoticToPrim = GetMethod(input, toPrimitiveSymbol);
898            if (exoticToPrim !== undefined) {
899                var result = exoticToPrim.call(input, hint);
900                if (IsObject(result))
901                    throw new TypeError();
902                return result;
903            }
904            return OrdinaryToPrimitive(input, hint === "default" ? "number" : hint);
905        }
906        // 7.1.1.1 OrdinaryToPrimitive(O, hint)
907        // https://tc39.github.io/ecma262/#sec-ordinarytoprimitive
908        function OrdinaryToPrimitive(O, hint) {
909            if (hint === "string") {
910                var toString_1 = O.toString;
911                if (IsCallable(toString_1)) {
912                    var result = toString_1.call(O);
913                    if (!IsObject(result))
914                        return result;
915                }
916                var valueOf = O.valueOf;
917                if (IsCallable(valueOf)) {
918                    var result = valueOf.call(O);
919                    if (!IsObject(result))
920                        return result;
921                }
922            }
923            else {
924                var valueOf = O.valueOf;
925                if (IsCallable(valueOf)) {
926                    var result = valueOf.call(O);
927                    if (!IsObject(result))
928                        return result;
929                }
930                var toString_2 = O.toString;
931                if (IsCallable(toString_2)) {
932                    var result = toString_2.call(O);
933                    if (!IsObject(result))
934                        return result;
935                }
936            }
937            throw new TypeError();
938        }
939        // 7.1.2 ToBoolean(argument)
940        // https://tc39.github.io/ecma262/2016/#sec-toboolean
941        function ToBoolean(argument) {
942            return !!argument;
943        }
944        // 7.1.12 ToString(argument)
945        // https://tc39.github.io/ecma262/#sec-tostring
946        function ToString(argument) {
947            return "" + argument;
948        }
949        // 7.1.14 ToPropertyKey(argument)
950        // https://tc39.github.io/ecma262/#sec-topropertykey
951        function ToPropertyKey(argument) {
952            var key = ToPrimitive(argument, 3 /* String */);
953            if (IsSymbol(key))
954                return key;
955            return ToString(key);
956        }
957        // 7.2 Testing and Comparison Operations
958        // https://tc39.github.io/ecma262/#sec-testing-and-comparison-operations
959        // 7.2.2 IsArray(argument)
960        // https://tc39.github.io/ecma262/#sec-isarray
961        function IsArray(argument) {
962            return Array.isArray
963                ? Array.isArray(argument)
964                : argument instanceof Object
965                    ? argument instanceof Array
966                    : Object.prototype.toString.call(argument) === "[object Array]";
967        }
968        // 7.2.3 IsCallable(argument)
969        // https://tc39.github.io/ecma262/#sec-iscallable
970        function IsCallable(argument) {
971            // NOTE: This is an approximation as we cannot check for [[Call]] internal method.
972            return typeof argument === "function";
973        }
974        // 7.2.4 IsConstructor(argument)
975        // https://tc39.github.io/ecma262/#sec-isconstructor
976        function IsConstructor(argument) {
977            // NOTE: This is an approximation as we cannot check for [[Construct]] internal method.
978            return typeof argument === "function";
979        }
980        // 7.2.7 IsPropertyKey(argument)
981        // https://tc39.github.io/ecma262/#sec-ispropertykey
982        function IsPropertyKey(argument) {
983            switch (Type(argument)) {
984                case 3 /* String */: return true;
985                case 4 /* Symbol */: return true;
986                default: return false;
987            }
988        }
989        function SameValueZero(x, y) {
990            return x === y || x !== x && y !== y;
991        }
992        // 7.3 Operations on Objects
993        // https://tc39.github.io/ecma262/#sec-operations-on-objects
994        // 7.3.9 GetMethod(V, P)
995        // https://tc39.github.io/ecma262/#sec-getmethod
996        function GetMethod(V, P) {
997            var func = V[P];
998            if (func === undefined || func === null)
999                return undefined;
1000            if (!IsCallable(func))
1001                throw new TypeError();
1002            return func;
1003        }
1004        // 7.4 Operations on Iterator Objects
1005        // https://tc39.github.io/ecma262/#sec-operations-on-iterator-objects
1006        function GetIterator(obj) {
1007            var method = GetMethod(obj, iteratorSymbol);
1008            if (!IsCallable(method))
1009                throw new TypeError(); // from Call
1010            var iterator = method.call(obj);
1011            if (!IsObject(iterator))
1012                throw new TypeError();
1013            return iterator;
1014        }
1015        // 7.4.4 IteratorValue(iterResult)
1016        // https://tc39.github.io/ecma262/2016/#sec-iteratorvalue
1017        function IteratorValue(iterResult) {
1018            return iterResult.value;
1019        }
1020        // 7.4.5 IteratorStep(iterator)
1021        // https://tc39.github.io/ecma262/#sec-iteratorstep
1022        function IteratorStep(iterator) {
1023            var result = iterator.next();
1024            return result.done ? false : result;
1025        }
1026        // 7.4.6 IteratorClose(iterator, completion)
1027        // https://tc39.github.io/ecma262/#sec-iteratorclose
1028        function IteratorClose(iterator) {
1029            var f = iterator["return"];
1030            if (f)
1031                f.call(iterator);
1032        }
1033        // 9.1 Ordinary Object Internal Methods and Internal Slots
1034        // https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots
1035        // 9.1.1.1 OrdinaryGetPrototypeOf(O)
1036        // https://tc39.github.io/ecma262/#sec-ordinarygetprototypeof
1037        function OrdinaryGetPrototypeOf(O) {
1038            var proto = Object.getPrototypeOf(O);
1039            if (typeof O !== "function" || O === functionPrototype)
1040                return proto;
1041            // TypeScript doesn't set __proto__ in ES5, as it's non-standard.
1042            // Try to determine the superclass constructor. Compatible implementations
1043            // must either set __proto__ on a subclass constructor to the superclass constructor,
1044            // or ensure each class has a valid `constructor` property on its prototype that
1045            // points back to the constructor.
1046            // If this is not the same as Function.[[Prototype]], then this is definately inherited.
1047            // This is the case when in ES6 or when using __proto__ in a compatible browser.
1048            if (proto !== functionPrototype)
1049                return proto;
1050            // If the super prototype is Object.prototype, null, or undefined, then we cannot determine the heritage.
1051            var prototype = O.prototype;
1052            var prototypeProto = prototype && Object.getPrototypeOf(prototype);
1053            if (prototypeProto == null || prototypeProto === Object.prototype)
1054                return proto;
1055            // If the constructor was not a function, then we cannot determine the heritage.
1056            var constructor = prototypeProto.constructor;
1057            if (typeof constructor !== "function")
1058                return proto;
1059            // If we have some kind of self-reference, then we cannot determine the heritage.
1060            if (constructor === O)
1061                return proto;
1062            // we have a pretty good guess at the heritage.
1063            return constructor;
1064        }
1065        // Global metadata registry
1066        // - Allows `import "reflect-metadata"` and `import "reflect-metadata/no-conflict"` to interoperate.
1067        // - Uses isolated metadata if `Reflect` is frozen before the registry can be installed.
1068        /**
1069         * Creates a registry used to allow multiple `reflect-metadata` providers.
1070         */
1071        function CreateMetadataRegistry() {
1072            var fallback;
1073            if (!IsUndefined(registrySymbol) &&
1074                typeof root.Reflect !== "undefined" &&
1075                !(registrySymbol in root.Reflect) &&
1076                typeof root.Reflect.defineMetadata === "function") {
1077                // interoperate with older version of `reflect-metadata` that did not support a registry.
1078                fallback = CreateFallbackProvider(root.Reflect);
1079            }
1080            var first;
1081            var second;
1082            var rest;
1083            var targetProviderMap = new _WeakMap();
1084            var registry = {
1085                registerProvider: registerProvider,
1086                getProvider: getProvider,
1087                setProvider: setProvider,
1088            };
1089            return registry;
1090            function registerProvider(provider) {
1091                if (!Object.isExtensible(registry)) {
1092                    throw new Error("Cannot add provider to a frozen registry.");
1093                }
1094                switch (true) {
1095                    case fallback === provider: break;
1096                    case IsUndefined(first):
1097                        first = provider;
1098                        break;
1099                    case first === provider: break;
1100                    case IsUndefined(second):
1101                        second = provider;
1102                        break;
1103                    case second === provider: break;
1104                    default:
1105                        if (rest === undefined)
1106                            rest = new _Set();
1107                        rest.add(provider);
1108                        break;
1109                }
1110            }
1111            function getProviderNoCache(O, P) {
1112                if (!IsUndefined(first)) {
1113                    if (first.isProviderFor(O, P))
1114                        return first;
1115                    if (!IsUndefined(second)) {
1116                        if (second.isProviderFor(O, P))
1117                            return first;
1118                        if (!IsUndefined(rest)) {
1119                            var iterator = GetIterator(rest);
1120                            while (true) {
1121                                var next = IteratorStep(iterator);
1122                                if (!next) {
1123                                    return undefined;
1124                                }
1125                                var provider = IteratorValue(next);
1126                                if (provider.isProviderFor(O, P)) {
1127                                    IteratorClose(iterator);
1128                                    return provider;
1129                                }
1130                            }
1131                        }
1132                    }
1133                }
1134                if (!IsUndefined(fallback) && fallback.isProviderFor(O, P)) {
1135                    return fallback;
1136                }
1137                return undefined;
1138            }
1139            function getProvider(O, P) {
1140                var providerMap = targetProviderMap.get(O);
1141                var provider;
1142                if (!IsUndefined(providerMap)) {
1143                    provider = providerMap.get(P);
1144                }
1145                if (!IsUndefined(provider)) {
1146                    return provider;
1147                }
1148                provider = getProviderNoCache(O, P);
1149                if (!IsUndefined(provider)) {
1150                    if (IsUndefined(providerMap)) {
1151                        providerMap = new _Map();
1152                        targetProviderMap.set(O, providerMap);
1153                    }
1154                    providerMap.set(P, provider);
1155                }
1156                return provider;
1157            }
1158            function hasProvider(provider) {
1159                if (IsUndefined(provider))
1160                    throw new TypeError();
1161                return first === provider || second === provider || !IsUndefined(rest) && rest.has(provider);
1162            }
1163            function setProvider(O, P, provider) {
1164                if (!hasProvider(provider)) {
1165                    throw new Error("Metadata provider not registered.");
1166                }
1167                var existingProvider = getProvider(O, P);
1168                if (existingProvider !== provider) {
1169                    if (!IsUndefined(existingProvider)) {
1170                        return false;

1171                    }
1172                    var providerMap = targetProviderMap.get(O);
1173                    if (IsUndefined(providerMap)) {
1174                        providerMap = new _Map();
1175                        targetProviderMap.set(O, providerMap);
1176                    }
1177                    providerMap.set(P, provider);
1178                }
1179                return true;
1180            }
1181        }
1182        /**
1183         * Gets or creates the shared registry of metadata providers.
1184         */
1185        function GetOrCreateMetadataRegistry() {
1186            var metadataRegistry;
1187            if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
1188                metadataRegistry = root.Reflect[registrySymbol];
1189            }
1190            if (IsUndefined(metadataRegistry)) {
1191                metadataRegistry = CreateMetadataRegistry();
1192            }
1193            if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
1194                Object.defineProperty(root.Reflect, registrySymbol, {
1195                    enumerable: false,
1196                    configurable: false,
1197                    writable: false,
1198                    value: metadataRegistry
1199                });
1200            }
1201            return metadataRegistry;
1202        }
1203        function CreateMetadataProvider(registry) {
1204            // [[Metadata]] internal slot
1205            // https://rbuckton.github.io/reflect-metadata/#ordinary-object-internal-methods-and-internal-slots
1206            var metadata = new _WeakMap();
1207            var provider = {
1208                isProviderFor: function (O, P) {
1209                    var targetMetadata = metadata.get(O);
1210                    if (IsUndefined(targetMetadata))
1211                        return false;
1212                    return targetMetadata.has(P);
1213                },
1214                OrdinaryDefineOwnMetadata: OrdinaryDefineOwnMetadata,
1215                OrdinaryHasOwnMetadata: OrdinaryHasOwnMetadata,
1216                OrdinaryGetOwnMetadata: OrdinaryGetOwnMetadata,
1217                OrdinaryOwnMetadataKeys: OrdinaryOwnMetadataKeys,
1218                OrdinaryDeleteMetadata: OrdinaryDeleteMetadata,
1219            };
1220            metadataRegistry.registerProvider(provider);
1221            return provider;
1222            function GetOrCreateMetadataMap(O, P, Create) {
1223                var targetMetadata = metadata.get(O);
1224                var createdTargetMetadata = false;
1225                if (IsUndefined(targetMetadata)) {
1226                    if (!Create)
1227                        return undefined;
1228                    targetMetadata = new _Map();
1229                    metadata.set(O, targetMetadata);
1230                    createdTargetMetadata = true;
1231                }
1232                var metadataMap = targetMetadata.get(P);
1233                if (IsUndefined(metadataMap)) {
1234                    if (!Create)
1235                        return undefined;
1236                    metadataMap = new _Map();
1237                    targetMetadata.set(P, metadataMap);
1238                    if (!registry.setProvider(O, P, provider)) {
1239                        targetMetadata.delete(P);
1240                        if (createdTargetMetadata) {
1241                            metadata.delete(O);
1242                        }
1243                        throw new Error("Wrong provider for target.");
1244                    }
1245                }
1246                return metadataMap;
1247            }
1248            // 3.1.2.1 OrdinaryHasOwnMetadata(MetadataKey, O, P)
1249            // https://rbuckton.github.io/reflect-metadata/#ordinaryhasownmetadata
1250            function OrdinaryHasOwnMetadata(MetadataKey, O, P) {
1251                var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);
1252                if (IsUndefined(metadataMap))
1253                    return false;
1254                return ToBoolean(metadataMap.has(MetadataKey));
1255            }
1256            // 3.1.4.1 OrdinaryGetOwnMetadata(MetadataKey, O, P)
1257            // https://rbuckton.github.io/reflect-metadata/#ordinarygetownmetadata
1258            function OrdinaryGetOwnMetadata(MetadataKey, O, P) {
1259                var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);
1260                if (IsUndefined(metadataMap))
1261                    return undefined;
1262                return metadataMap.get(MetadataKey);
1263            }

1264            // 3.1.5.1 OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P)
1265            // https://rbuckton.github.io/reflect-metadata/#ordinarydefineownmetadata
1266            function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {
1267                var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ true);
1268                metadataMap.set(MetadataKey, MetadataValue);
1269            }
1270            // 3.1.7.1 OrdinaryOwnMetadataKeys(O, P)
1271            // https://rbuckton.github.io/reflect-metadata/#ordinaryownmetadatakeys
1272            function OrdinaryOwnMetadataKeys(O, P) {
1273                var keys = [];
1274                var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);
1275                if (IsUndefined(metadataMap))
1276                    return keys;
1277                var keysObj = metadataMap.keys();
1278                var iterator = GetIterator(keysObj);
1279                var k = 0;
1280                while (true) {
1281                    var next = IteratorStep(iterator);
1282                    if (!next) {
1283                        keys.length = k;
1284                        return keys;
1285                    }
1286                    var nextValue = IteratorValue(next);
1287                    try {
1288                        keys[k] = nextValue;
1289                    }
1290                    catch (e) {
1291                        try {
1292                            IteratorClose(iterator);
1293                        }
1294                        finally {
1295                            throw e;
1296                        }
1297                    }
1298                    k++;
1299                }
1300            }
1301            function OrdinaryDeleteMetadata(MetadataKey, O, P) {
1302                var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);
1303                if (IsUndefined(metadataMap))
1304                    return false;
1305                if (!metadataMap.delete(MetadataKey))
1306                    return false;
1307                if (metadataMap.size === 0) {
1308                    var targetMetadata = metadata.get(O);
1309                    if (!IsUndefined(targetMetadata)) {
1310                        targetMetadata.delete(P);
1311                        if (targetMetadata.size === 0) {
1312                            metadata.delete(targetMetadata);
1313                        }
1314                    }
1315                }
1316                return true;
1317            }
1318        }
1319        function CreateFallbackProvider(reflect) {
1320            var defineMetadata = reflect.defineMetadata, hasOwnMetadata = reflect.hasOwnMetadata, getOwnMetadata = reflect.getOwnMetadata, getOwnMetadataKeys = reflect.getOwnMetadataKeys, deleteMetadata = reflect.deleteMetadata;
1321            var metadataOwner = new _WeakMap();
1322            var provider = {
1323                isProviderFor: function (O, P) {
1324                    var metadataPropertySet = metadataOwner.get(O);
1325                    if (!IsUndefined(metadataPropertySet) && metadataPropertySet.has(P)) {
1326                        return true;
1327                    }
1328                    if (getOwnMetadataKeys(O, P).length) {
1329                        if (IsUndefined(metadataPropertySet)) {
1330                            metadataPropertySet = new _Set();
1331                            metadataOwner.set(O, metadataPropertySet);
1332                        }
1333                        metadataPropertySet.add(P);
1334                        return true;
1335                    }
1336                    return false;
1337                },
1338                OrdinaryDefineOwnMetadata: defineMetadata,
1339                OrdinaryHasOwnMetadata: hasOwnMetadata,
1340                OrdinaryGetOwnMetadata: getOwnMetadata,
1341                OrdinaryOwnMetadataKeys: getOwnMetadataKeys,
1342                OrdinaryDeleteMetadata: deleteMetadata,
1343            };
1344            return provider;
1345        }
1346        /**
1347         * Gets the metadata provider for an object. If the object has no metadata provider and this is for a create operation,
1348         * then this module's metadata provider is assigned to the object.
1349         */
1350        function GetMetadataProvider(O, P, Create) {
1351            var registeredProvider = metadataRegistry.getProvider(O, P);
1352            if (!IsUndefined(registeredProvider)) {
1353                return registeredProvider;
1354            }
1355            if (Create) {
1356                if (metadataRegistry.setProvider(O, P, metadataProvider)) {
1357                    return metadataProvider;
1358                }
1359                throw new Error("Illegal state.");
1360            }
1361            return undefined;
1362        }
1363        // naive Map shim
1364        function CreateMapPolyfill() {
1365            var cacheSentinel = {};
1366            var arraySentinel = [];
1367            var MapIterator = /** @class */ (function () {
1368                function MapIterator(keys, values, selector) {
1369                    this._index = 0;
1370                    this._keys = keys;
1371                    this._values = values;
1372                    this._selector = selector;
1373                }
1374                MapIterator.prototype["@@iterator"] = function () { return this; };
1375                MapIterator.prototype[iteratorSymbol] = function () { return this; };
1376                MapIterator.prototype.next = function () {
1377                    var index = this._index;
1378                    if (index >= 0 && index < this._keys.length) {
1379                        var result = this._selector(this._keys[index], this._values[index]);
1380                        if (index + 1 >= this._keys.length) {
1381                            this._index = -1;
1382                            this._keys = arraySentinel;
1383                            this._values = arraySentinel;
1384                        }
1385                        else {
1386                            this._index++;
1387                        }
1388                        return { value: result, done: false };
1389                    }
1390                    return { value: undefined, done: true };
1391                };
1392                MapIterator.prototype.throw = function (error) {
1393                    if (this._index >= 0) {
1394                        this._index = -1;
1395                        this._keys = arraySentinel;
1396                        this._values = arraySentinel;
1397                    }
1398                    throw error;
1399                };
1400                MapIterator.prototype.return = function (value) {
1401                    if (this._index >= 0) {
1402                        this._index = -1;
1403                        this._keys = arraySentinel;
1404                        this._values = arraySentinel;
1405                    }
1406                    return { value: value, done: true };
1407                };
1408                return MapIterator;
1409            }());
1410            var Map = /** @class */ (function () {
1411                function Map() {
1412                    this._keys = [];
1413                    this._values = [];
1414                    this._cacheKey = cacheSentinel;
1415                    this._cacheIndex = -2;
1416                }
1417                Object.defineProperty(Map.prototype, "size", {
1418                    get: function () { return this._keys.length; },
1419                    enumerable: true,
1420                    configurable: true
1421                });
1422                Map.prototype.has = function (key) { return this._find(key, /*insert*/ false) >= 0; };
1423                Map.prototype.get = function (key) {
1424                    var index = this._find(key, /*insert*/ false);
1425                    return index >= 0 ? this._values[index] : undefined;
1426                };
1427                Map.prototype.set = function (key, value) {
1428                    var index = this._find(key, /*insert*/ true);
1429                    this._values[index] = value;
1430                    return this;
1431                };
1432                Map.prototype.delete = function (key) {
1433                    var index = this._find(key, /*insert*/ false);
1434                    if (index >= 0) {
1435                        var size = this._keys.length;
1436                        for (var i = index + 1; i < size; i++) {
1437                            this._keys[i - 1] = this._keys[i];
1438                            this._values[i - 1] = this._values[i];
1439                        }
1440                        this._keys.length--;
1441                        this._values.length--;
1442                        if (SameValueZero(key, this._cacheKey)) {
1443                            this._cacheKey = cacheSentinel;
1444                            this._cacheIndex = -2;
1445                        }
1446                        return true;
1447                    }
1448                    return false;
1449                };
1450                Map.prototype.clear = function () {
1451                    this._keys.length = 0;
1452                    this._values.length = 0;
1453                    this._cacheKey = cacheSentinel;
1454                    this._cacheIndex = -2;
1455                };
1456                Map.prototype.keys = function () { return new MapIterator(this._keys, this._values, getKey); };
1457                Map.prototype.values = function () { return new MapIterator(this._keys, this._values, getValue); };
1458                Map.prototype.entries = function () { return new MapIterator(this._keys, this._values, getEntry); };
1459                Map.prototype["@@iterator"] = function () { return this.entries(); };
1460                Map.prototype[iteratorSymbol] = function () { return this.entries(); };
1461                Map.prototype._find = function (key, insert) {
1462                    if (!SameValueZero(this._cacheKey, key)) {
1463                        this._cacheIndex = -1;
1464                        for (var i = 0; i < this._keys.length; i++) {
1465                            if (SameValueZero(this._keys[i], key)) {
1466                                this._cacheIndex = i;
1467                                break;
1468                            }
1469                        }
1470                    }
1471                    if (this._cacheIndex < 0 && insert) {
1472                        this._cacheIndex = this._keys.length;
1473                        this._keys.push(key);
1474                        this._values.push(undefined);
1475                    }
1476                    return this._cacheIndex;
1477                };
1478                return Map;
1479            }());
1480            return Map;
1481            function getKey(key, _) {
1482                return key;
1483            }
1484            function getValue(_, value) {
1485                return value;
1486            }
1487            function getEntry(key, value) {
1488                return [key, value];
1489            }
1490        }
1491        // naive Set shim
1492        function CreateSetPolyfill() {
1493            var Set = /** @class */ (function () {
1494                function Set() {
1495                    this._map = new _Map();
1496                }
1497                Object.defineProperty(Set.prototype, "size", {
1498                    get: function () { return this._map.size; },
1499                    enumerable: true,
1500                    configurable: true
1501                });
1502                Set.prototype.has = function (value) { return this._map.has(value); };
1503                Set.prototype.add = function (value) { return this._map.set(value, value), this; };
1504                Set.prototype.delete = function (value) { return this._map.delete(value); };
1505                Set.prototype.clear = function () { this._map.clear(); };
1506                Set.prototype.keys = function () { return this._map.keys(); };
1507                Set.prototype.values = function () { return this._map.keys(); };
1508                Set.prototype.entries = function () { return this._map.entries(); };
1509                Set.prototype["@@iterator"] = function () { return this.keys(); };
1510                Set.prototype[iteratorSymbol] = function () { return this.keys(); };
1511                return Set;
1512            }());
1513            return Set;
1514        }
1515        // naive WeakMap shim
1516        function CreateWeakMapPolyfill() {
1517            var UUID_SIZE = 16;
1518            var keys = HashMap.create();
1519            var rootKey = CreateUniqueKey();
1520            return /** @class */ (function () {
1521                function WeakMap() {
1522                    this._key = CreateUniqueKey();
1523                }
1524                WeakMap.prototype.has = function (target) {
1525                    var table = GetOrCreateWeakMapTable(target, /*create*/ false);
1526                    return table !== undefined ? HashMap.has(table, this._key) : false;
1527                };
1528                WeakMap.prototype.get = function (target) {
1529                    var table = GetOrCreateWeakMapTable(target, /*create*/ false);
1530                    return table !== undefined ? HashMap.get(table, this._key) : undefined;
1531                };
1532                WeakMap.prototype.set = function (target, value) {
1533                    var table = GetOrCreateWeakMapTable(target, /*create*/ true);
1534                    table[this._key] = value;
1535                    return this;
1536                };
1537                WeakMap.prototype.delete = function (target) {
1538                    var table = GetOrCreateWeakMapTable(target, /*create*/ false);
1539                    return table !== undefined ? delete table[this._key] : false;
1540                };
1541                WeakMap.prototype.clear = function () {
1542                    // NOTE: not a real clear, just makes the previous data unreachable
1543                    this._key = CreateUniqueKey();
1544                };
1545                return WeakMap;
1546            }());
1547            function CreateUniqueKey() {
1548                var key;
1549                do
1550                    key = "@@WeakMap@@" + CreateUUID();
1551                while (HashMap.has(keys, key));
1552                keys[key] = true;
1553                return key;
1554            }
1555            function GetOrCreateWeakMapTable(target, create) {
1556                if (!hasOwn.call(target, rootKey)) {
1557                    if (!create)
1558                        return undefined;
1559                    Object.defineProperty(target, rootKey, { value: HashMap.create() });
1560                }
1561                return target[rootKey];
1562            }
1563            function FillRandomBytes(buffer, size) {
1564                for (var i = 0; i < size; ++i)
1565                    buffer[i] = Math.random() * 0xff | 0;
1566                return buffer;
1567            }
1568            function GenRandomBytes(size) {
1569                if (typeof Uint8Array === "function") {
1570                    var array = new Uint8Array(size);
1571                    if (typeof crypto !== "undefined") {
1572                        crypto.getRandomValues(array);
1573                    }
1574                    else if (typeof msCrypto !== "undefined") {
1575                        msCrypto.getRandomValues(array);
1576                    }
1577                    else {
1578                        FillRandomBytes(array, size);
1579                    }
1580                    return array;
1581                }
1582                return FillRandomBytes(new Array(size), size);
1583            }
1584            function CreateUUID() {
1585                var data = GenRandomBytes(UUID_SIZE);
1586                // mark as random - RFC 4122 § 4.4
1587                data[6] = data[6] & 0x4f | 0x40;
1588                data[8] = data[8] & 0xbf | 0x80;
1589                var result = "";
1590                for (var offset = 0; offset < UUID_SIZE; ++offset) {
1591                    var byte = data[offset];
1592                    if (offset === 4 || offset === 6 || offset === 8)
1593                        result += "-";
1594                    if (byte < 16)
1595                        result += "0";
1596                    result += byte.toString(16).toLowerCase();
1597                }
1598                return result;
1599            }
1600        }
1601        // uses a heuristic used by v8 and chakra to force an object into dictionary mode.
1602        function MakeDictionary(obj) {
1603            obj.__ = undefined;
1604            delete obj.__;
1605            return obj;
1606        }
1607    });
1608})(Reflect || (Reflect = {}));

1609
1610
1611/***/ },
1612
1613/***/ "./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js"
1614/*!*********************************************************************!*\
1615  !*** ./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js ***!
1616  \*********************************************************************/
1617(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
1618
1619"use strict";
1620__webpack_require__.r(__webpack_exports__);
1621/* harmony export */ __webpack_require__.d(__webpack_exports__, {
1622/* harmony export */   "default": () => (/* binding */ _asyncToGenerator)
1623/* harmony export */ });
1624function asyncGeneratorStep(n, t, e, r, o, a, c) {
1625  try {
1626    var i = n[a](c),
1627      u = i.value;
1628  } catch (n) {
1629    return void e(n);
1630  }
1631  i.done ? t(u) : Promise.resolve(u).then(r, o);
1632}
1633function _asyncToGenerator(n) {
1634  return function () {
1635    var t = this,
1636      e = arguments;
1637    return new Promise(function (r, o) {
1638      var a = n.apply(t, e);
1639      function _next(n) {
1640        asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
1641      }
1642      function _throw(n) {
1643        asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
1644      }
1645      _next(void 0);
1646    });
1647  };
1648}
1649
1650
1651/***/ }
1652
1653/******/ 	});
1654/************************************************************************/
1655/******/ 	// The module cache
1656/******/ 	var __webpack_module_cache__ = {};
1657/******/ 	
1658/******/ 	// The require function
1659/******/ 	function __webpack_require__(moduleId) {
1660/******/ 		// Check if module is in cache
1661/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
1662/******/ 		if (cachedModule !== undefined) {
1663/******/ 			return cachedModule.exports;
1664/******/ 		}
1665/******/ 		// Create a new module (and put it into the cache)
1666/******/ 		var module = __webpack_module_cache__[moduleId] = {
1667/******/ 			// no module.id needed
1668/******/ 			// no module.loaded needed
1669/******/ 			exports: {}
1670/******/ 		};
1671/******/ 	
1672/******/ 		// Execute the module function
1673/******/ 		if (!(moduleId in __webpack_modules__)) {
1674/******/ 			delete __webpack_module_cache__[moduleId];
1675/******/ 			var e = new Error("Cannot find module '" + moduleId + "'");
1676/******/ 			e.code = 'MODULE_NOT_FOUND';
1677/******/ 			throw e;
1678/******/ 		}
1679/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
1680/******/ 	
1681/******/ 		// Return the exports of the module
1682/******/ 		return module.exports;
1683/******/ 	}
1684/******/ 	
1685/******/ 	// expose the modules object (__webpack_modules__)
1686/******/ 	__webpack_require__.m = __webpack_modules__;
1687/******/ 	
1688/******/ 	// expose the module cache
1689/******/ 	__webpack_require__.c = __webpack_module_cache__;
1690/******/ 	
1691/************************************************************************/
1692/******/ 	/* webpack/runtime/compat get default export */
1693/******/ 	(() => {
1694/******/ 		// getDefaultExport function for compatibility with non-harmony modules
1695/******/ 		__webpack_require__.n = (module) => {

1696/******/ 			var getter = module && module.__esModule ?
1697/******/ 				() => (module['default']) :
1698/******/ 				() => (module);
1699/******/ 			__webpack_require__.d(getter, { a: getter });
1700/******/ 			return getter;
1701/******/ 		};
1702/******/ 	})();
1703/******/ 	
1704/******/ 	/* webpack/runtime/define property getters */
1705/******/ 	(() => {
1706/******/ 		// define getter functions for harmony exports
1707/******/ 		__webpack_require__.d = (exports, definition) => {
1708/******/ 			for(var key in definition) {
1709/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
1710/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
1711/******/ 				}
1712/******/ 			}
1713/******/ 		};
1714/******/ 	})();
1715/******/ 	
1716/******/ 	/* webpack/runtime/ensure chunk */
1717/******/ 	(() => {
1718/******/ 		__webpack_require__.f = {};
1719/******/ 		// This file contains only the entry chunk.
1720/******/ 		// The chunk loading function for additional chunks
1721/******/ 		__webpack_require__.e = (chunkId) => {
1722/******/ 			return Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key) => {
1723/******/ 				__webpack_require__.f[key](chunkId, promises);
1724/******/ 				return promises;
1725/******/ 			}, []));
1726/******/ 		};
1727/******/ 	})();
1728/******/ 	
1729/******/ 	/* webpack/runtime/get javascript chunk filename */
1730/******/ 	(() => {
1731/******/ 		// This function allow to reference async chunks
1732/******/ 		__webpack_require__.u = (chunkId) => {
1733/******/ 			// return url for filenames based on template
1734/******/ 			return "" + chunkId + "." + {"public_styles_css":"eaf651aa5e4387970fc3","vendors-node_modules_lit_decorators_js-node_modules_lit_index_js":"d36385bcd14748e4cc61","vendors-node_modules_lit_localize_lit-localize_js":"a61e75790f7a2f7bbf59","vendors-node_modules_exactsciences_ph-web-components_dist_components_header_ESHeader_js":"d0d0dbce63c5ff7b1c2c","node_modules_lit_directives_class-map_js-node_modules_lit_directives_if-defined_js":"8b1aa507682f067ba1e2","vendors-node_modules_tslib_tslib_es6_mjs":"48f5e0b55ba8417b0d96","vendors-node_modules_helix-design-system_components_dist_shared_types_helix-element_js":"939c30d0f54d8e6d63e3","vendors-node_modules_helix-design-system_components_dist_components_icon_icon_js":"62d353dcebb7fc6dbfcc","vendors-node_modules_helix-design-system_components_dist_shared_styles_component_styles_js-no-f2c113":"65092652e26acbc9475b","vendors-node_modules_floating-ui_dom_dist_floating-ui_dom_mjs-node_modules_helix-design-syste-7639e6":"d8eecf989eb8d097a922","vendors-node_modules_helix-design-system_components_dist_components_menu_index_js":"b70ba3e8fe6a8c9f23f1","vendors-node_modules_exactsciences_ph-web-components_dist_components_header-helix_HelixHeader_js":"47a20e8d27dd603dcc79","vendors-node_modules_lit_directives_repeat_js":"8ecd58f23d0cf722b40f","vendors-node_modules_exactsciences_ph-web-components_dist_components_footer-contact-link_Foot-1bce64":"2a9be6ad17b02a86e65d","vendors-node_modules_exactsciences_ph-web-components_dist_components_footer_ESFooter_js":"14c5c4c35ac5c32ddae0","vendors-node_modules_rxjs_dist_esm5_internal_firstValueFrom_js-node_modules_rxjs_dist_esm5_in-8499fe":"1069ffcaf9ba3f6f7410","vendors-node_modules_exactsciences_ph-web-components_dist_services_feature-flag_service_js":"90115884360097b8f86d","vendors-node_modules_exactsciences_ph-web-components_dist_components_footer_v2_ESFooter-v2_js":"91867893dccb3ff2d34e","vendors-node_modules_helix-design-system_components_dist_shared_controllers_slot_controller_j-2ac307":"48cdc8457705aa7b96db","vendors-node_modules_helix-design-system_components_dist_components_select_select_js":"0462a74982d1e65c10f3","vendors-node_modules_helix-design-system_components_dist_components_link_index_js":"846f933d64738487fced","vendors-node_modules_exactsciences_ph-web-components_dist_components_footer-helix_HelixFooter-40790a":"1e3a59b6420f58d8c744","vendors-node_modules_helix-design-system_components_dist_components_accordion_index_js":"aa70cdf0d1dd70aac6e1","vendors-node_modules_helix-design-system_components_dist_components_button_button_js":"39c3f2619acd177b3185","vendors-node_modules_helix-design-system_components_dist_components_alert_index_js-node_modul-cc7faf":"c496fc05b6a0da1e938f","vendors-node_modules_helix-design-system_components_dist_components_text-field_text-field_js":"e4aaf29ffc184b6dffdd","vendors-node_modules_helix-design-system_components_dist_components_autocomplete_index_js":"593eff00ab98a462dc27","

2182/******/ 										error.name = 'ChunkLoadError';
2183/******/ 										error.type = errorType;
2184/******/ 										error.request = realSrc;
2185/******/ 										installedChunkData[1](error);
2186/******/ 									}
2187/******/ 								}
2188/******/ 							};
2189/******/ 							__webpack_require__.l(url, loadingEnded, "chunk-" + chunkId, chunkId);
2190/******/ 						} else installedChunks[chunkId] = 0;
2191/******/ 					}
2192/******/ 				}
2193/******/ 		};
2194/******/ 		
2195/******/ 		// no prefetching
2196/******/ 		
2197/******/ 		// no preloaded
2198/******/ 		
2199/******/ 		// no HMR
2200/******/ 		
2201/******/ 		// no HMR manifest
2202/******/ 		
2203/******/ 		// no on chunks loaded
2204/******/ 		
2205/******/ 		// install a JSONP callback for chunk loading
2206/******/ 		var webpackJsonpCallback = (parentChunkLoadingFunction, data) => {
2207/******/ 			var [chunkIds, moreModules, runtime] = data;
2208/******/ 			// add "moreModules" to the modules object,
2209/******/ 			// then flag all "chunkIds" as loaded and fire callback
2210/******/ 			var moduleId, chunkId, i = 0;
2211/******/ 			if(chunkIds.some((id) => (installedChunks[id] !== 0))) {
2212/******/ 				for(moduleId in moreModules) {
2213/******/ 					if(__webpack_require__.o(moreModules, moduleId)) {
2214/******/ 						__webpack_require__.m[moduleId] = moreModules[moduleId];
2215/******/ 					}
2216/******/ 				}
2217/******/ 				if(runtime) var result = runtime(__webpack_require__);
2218/******/ 			}
2219/******/ 			if(parentChunkLoadingFunction) parentChunkLoadingFunction(data);
2220/******/ 			for(;i < chunkIds.length; i++) {
2221/******/ 				chunkId = chunkIds[i];
2222/******/ 				if(__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {
2223/******/ 					installedChunks[chunkId][0]();
2224/******/ 				}
2225/******/ 				installedChunks[chunkId] = 0;
2226/******/ 			}
2227/******/ 		
2228/******/ 		}
2229/******/ 		
2230/******/ 		var chunkLoadingGlobal = self["webpackChunkpatientHubRootMfe"] = self["webpackChunkpatientHubRootMfe"] || [];
2231/******/ 		chunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));
2232/******/ 		chunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));
2233/******/ 	})();
2234/******/ 	
2235/************************************************************************/
2236/******/ 	
2237/******/ 	// module cache are used so entry inlining is disabled
2238/******/ 	// startup
2239/******/ 	// Load entry module and return exports
2240/******/ 	__webpack_require__("./node_modules/reflect-metadata/Reflect.js");
2241/******/ 	var __webpack_exports__ = __webpack_require__("./src/index.js");
2242/******/ 	
2243/******/ })()
2244;
2245//# sourceMappingURL=main.a9e4df955e9625bafcad.js.map