{"version":3,"sources":["./node_modules/core-js/modules/es.reflect.to-string-tag.js","./node_modules/core-js/internals/to-indexed-object.js","./node_modules/core-js/internals/use-symbol-as-uid.js","./node_modules/core-js/internals/hidden-keys.js","./node_modules/core-js/internals/fails.js","./node_modules/core-js/internals/get-built-in.js","./node_modules/zone.js/dist/zone.js","./node_modules/core-js/internals/object-property-is-enumerable.js","./node_modules/core-js/internals/object-set-prototype-of.js","./node_modules/core-js/internals/set-to-string-tag.js","./node_modules/core-js/modules/es.reflect.prevent-extensions.js","./node_modules/core-js/modules/es.reflect.is-extensible.js","./node_modules/core-js/internals/global.js","./node_modules/core-js/internals/object-keys.js","./node_modules/core-js/internals/object-get-prototype-of.js","./node_modules/core-js/internals/correct-prototype-getter.js","./node_modules/core-js/internals/copy-constructor-properties.js","./node_modules/core-js/internals/shared-key.js","./node_modules/core-js/internals/function-bind.js","./node_modules/core-js/internals/object-get-own-property-descriptor.js","./node_modules/core-js/internals/ie8-dom-define.js","./node_modules/core-js/internals/html.js","./node_modules/core-js/modules/es.reflect.own-keys.js","./node_modules/core-js/internals/a-function.js","./node_modules/core-js/internals/require-object-coercible.js","./node_modules/core-js/internals/export.js","./node_modules/core-js/internals/to-absolute-index.js","./node_modules/core-js/internals/object-get-own-property-names.js","./node_modules/core-js/internals/engine-v8-version.js","./node_modules/core-js/internals/object-define-properties.js","./node_modules/core-js/internals/engine-user-agent.js","./node_modules/core-js/internals/a-possible-prototype.js","./node_modules/core-js/modules/es.reflect.define-property.js","./node_modules/core-js/internals/path.js","./node_modules/core-js/internals/indexed-object.js","./node_modules/core-js/internals/native-symbol.js","./node_modules/core-js/es/reflect/index.js","./node_modules/core-js/modules/es.reflect.construct.js","./node_modules/core-js/internals/array-includes.js","./node_modules/core-js/internals/to-length.js","./node_modules/core-js/internals/has.js","./node_modules/core-js/internals/shared.js","./node_modules/core-js/internals/own-keys.js","./node_modules/core-js/internals/create-property-descriptor.js","./node_modules/core-js/modules/es.reflect.get.js","./node_modules/core-js/internals/engine-is-node.js","./node_modules/core-js/internals/internal-state.js","./node_modules/core-js/internals/redefine.js","./node_modules/core-js/internals/object-get-own-property-symbols.js","./node_modules/core-js/internals/enum-bug-keys.js","./node_modules/core-js/internals/to-object.js","./node_modules/core-js/modules/es.reflect.get-prototype-of.js","./node_modules/core-js/internals/native-weak-map.js","./node_modules/core-js/internals/object-create.js","./node_modules/core-js/modules/es.reflect.set.js","./node_modules/core-js/internals/descriptors.js","./node_modules/core-js/internals/an-object.js","./src/polyfills.ts","./node_modules/core-js/internals/is-object.js","./node_modules/core-js/modules/es.reflect.set-prototype-of.js","./node_modules/core-js/internals/inspect-source.js","./node_modules/@sentry/webpack-plugin/src/sentry-webpack.module.js","./node_modules/core-js/internals/uid.js","./node_modules/core-js/internals/create-non-enumerable-property.js","./node_modules/core-js/internals/is-forced.js","./node_modules/core-js/internals/object-define-property.js","./node_modules/core-js/modules/es.reflect.get-own-property-descriptor.js","./node_modules/core-js/internals/to-integer.js","./node_modules/core-js/modules/es.reflect.apply.js","./node_modules/core-js/modules/es.reflect.delete-property.js","./node_modules/core-js/internals/well-known-symbol.js","./node_modules/core-js/internals/freezing.js","./node_modules/core-js/internals/to-primitive.js","./node_modules/core-js/modules/es.reflect.has.js","./node_modules/core-js/internals/is-pure.js","./node_modules/core-js/internals/classof-raw.js","./node_modules/core-js/internals/shared-store.js","./node_modules/core-js/internals/object-keys-internal.js","./node_modules/core-js/internals/document-create-element.js","./node_modules/core-js/internals/set-global.js"],"names":["$","global","setToStringTag","Reflect","IndexedObject","requireObjectCoercible","module","exports","it","NATIVE_SYMBOL","Symbol","sham","iterator","exec","error","path","aFunction","variable","undefined","namespace","method","arguments","length","performance","mark","name","performanceMeasure","label","symbolPrefix","__symbol__","checkDuplicate","Error","Zone","parent","zoneSpec","this","_parent","_name","_properties","properties","_zoneDelegate","ZoneDelegate","assertZonePatched","patches","Object","defineProperty","get","zone","current","enumerable","configurable","_currentZoneFrame","_currentTask","__load_patch","fn","ignoreDuplicate","hasOwnProperty","perfName","_api","prototype","key","getZoneWith","fork","wrap","callback","source","_callback","intercept","runGuarded","run","applyThis","applyArgs","invoke","handleError","runTask","task","NO_ZONE","state","notScheduled","type","eventTask","macroTask","reEntryGuard","running","_transitionTo","scheduled","runCount","previousTask","data","isPeriodic","cancelFn","invokeTask","unknown","_updateTaskCount","scheduleTask","newZone","scheduling","zoneDelegates","_zoneDelegates","_zone","err","scheduleMicroTask","customSchedule","ZoneTask","microTask","scheduleMacroTask","customCancel","scheduleEventTask","cancelTask","canceling","count","i","nativeMicroTaskQueuePromise","DELEGATE_ZS","onHasTask","delegate","_","target","hasTaskState","hasTask","onScheduleTask","onInvokeTask","onCancelTask","parentDelegate","_taskCounts","_parentDelegate","_forkZS","onFork","_forkDlgt","_forkCurrZone","_interceptZS","onIntercept","_interceptDlgt","_interceptCurrZone","_invokeZS","onInvoke","_invokeDlgt","_invokeCurrZone","_handleErrorZS","onHandleError","_handleErrorDlgt","_handleErrorCurrZone","_scheduleTaskZS","_scheduleTaskDlgt","_scheduleTaskCurrZone","_invokeTaskZS","_invokeTaskDlgt","_invokeTaskCurrZone","_cancelTaskZS","_cancelTaskDlgt","_cancelTaskCurrZone","_hasTaskZS","_hasTaskDlgt","_hasTaskDlgtOwner","_hasTaskCurrZone","zoneSpecHasTask","targetZone","apply","returnTask","push","scheduleFn","value","isEmpty","counts","prev","next","change","options","_state","self","useG","call","args","_numberOfNestedTaskFrames","drainMicroTaskQueue","cancelScheduleRequest","toState","fromState1","fromState2","toString","handleId","toJSON","symbolSetTimeout","symbolPromise","symbolThen","_microTaskQueue","_isDrainingMicrotaskQueue","resolve","nativeThen","queue","onUnhandledError","microtaskDrainDone","symbol","currentZoneFrame","noop","showUncaughtError","patchEventTarget","patchOnProperties","patchMethod","bindArguments","patchThen","patchMacroTask","patchEventPrototype","isIEOrEdge","getGlobalObjects","ObjectDefineProperty","ObjectGetOwnPropertyDescriptor","ObjectCreate","ArraySlice","patchClass","wrapWithCurrentZone","filterProperties","attachOriginToPatched","_redefineProperty","patchCallbacks","window","getOwnPropertyDescriptor","ObjectGetPrototypeOf","getPrototypeOf","create","Array","slice","ADD_EVENT_LISTENER_STR","REMOVE_EVENT_LISTENER_STR","ZONE_SYMBOL_ADD_EVENT_LISTENER","ZONE_SYMBOL_REMOVE_EVENT_LISTENER","TRUE_STR","FALSE_STR","ZONE_SYMBOL_PREFIX","scheduleMacroTaskWithCurrentZone","zoneSymbol","isWindowExists","internalWindow","_global","NULL_ON_PROP_VALUE","isPropertyWritable","propertyDesc","writable","set","isWebWorker","WorkerGlobalScope","isNode","process","isBrowser","isMix","zoneSymbolEventNames","wrapFn","event","eventNameSymbol","result","listener","message","filename","lineno","colno","preventDefault","patchProperty","obj","prop","desc","onPropPatchedSymbol","originalDescGet","originalDescSet","eventName","substr","newValue","removeEventListener","addEventListener","removeAttribute","onProperties","j","originalInstanceKey","className","OriginalClass","a","instance","patchFn","proto","delegateName","patchDelegate_1","funcName","metaCreator","setNative","cbIdx","meta","patched","original","isDetectedIEOrEdge","ieOrEdge","ua","navigator","userAgent","indexOf","api","_uncaughtPromiseErrors","isDisableWrappingUncaughtPromiseRejection","e","rejection","console","stack","_loop_2","uncaughtPromiseError","shift","throwOriginal","handler","UNHANDLED_PROMISE_REJECTION_HANDLER_SYMBOL","handleUnhandledRejection","isThenable","then","forwardResolution","forwardRejection","ZoneAwarePromise","reject","symbolState","symbolValue","symbolFinally","symbolParentPromiseValue","symbolParentPromiseState","UNRESOLVED","RESOLVED","REJECTED","makeResolver","promise","v","resolvePromise","CURRENT_TASK_TRACE_SYMBOL","wasCalled","onceWrapper","wrappedFunction","TypeError","clearRejectedNoCatch","trace","currentTask","scheduleResolveOrReject","constructor","JSON","stringify","REJECTION_HANDLED_HANDLER","splice","chainPromise","onFulfilled","onRejected","promiseState","parentPromiseValue","isFinallyPromise","executor","race","values","res","rej","onResolve","onReject","_i","values_1","all","allWithCallback","allSettled","thenCallback","status","errorCallback","reason","unresolvedCount","valueIndex","resolvedValues","_loop_3","this_1","curValueIndex","thenErr","values_2","toStringTag","species","C","catch","finally","onFinally","NativePromise","symbolThenPatched","Ctor","originalThen","_this","resultPromise","ctor","Promise","originalFunctionToString","Function","ORIGINAL_DELEGATE_SYMBOL","PROMISE_SYMBOL","ERROR_SYMBOL","newFunctionToString","originalDelegate","nativePromise","nativeError","originalObjectToString","passiveSupported","OPTIMIZED_ZONE_EVENT_TASK_DATA","zoneSymbolEventNames$1","globalSources","EVENT_NAME_SYMBOL_REGX","RegExp","IMMEDIATE_PROPAGATION_SYMBOL","prepareEventNames","eventNameToString","falseEventName","trueEventName","symbolCapture","apis","patchOptions","ADD_EVENT_LISTENER","add","REMOVE_EVENT_LISTENER","rm","LISTENERS_EVENT_LISTENER","listeners","REMOVE_ALL_LISTENERS_EVENT_LISTENER","rmAll","zoneSymbolAddEventListener","ADD_EVENT_LISTENER_SOURCE","isRemoved","handleEvent","once","globalZoneAwareCallback","tasks","copyTasks","globalZoneAwareCaptureCallback","patchEventTargetMethods","useGlobalCallback","validateHandler","vh","chkDup","returnTarget","rt","nativePrependEventListener","taskData","nativeAddEventListener","nativeRemoveEventListener","nativeListeners","nativeRemoveAllListeners","buildEventListenerOptions","passive","capture","assign","prepend","isExisting","symbolEventNames","symbolEventName","existingTasks","allRemoved","compare","diff","typeOfDelegate","unpatchedEvents","passiveEvents","makeAddListener","nativeListener","addSource","customScheduleFn","customCancelFn","transferEventName","isHandleEvent","constructorName","targetSource","unshift","existingTask","findEventTasks","captureTasks","removeTasks","keys","match","evtName","results","foundTasks","captureFalseTasks","captureTrueTasks","concat","Event","targetName","callbacks","nativeDelegate","opts","forEach","descriptor","zoneSymbol$1","_defineProperty","_getOwnPropertyDescriptor","_create","unconfigurablesKey","windowEventNames","mediaElementEventNames","frameEventNames","frameSetEventNames","marqueeEventNames","XMLHttpRequestEventNames","IDBIndexEventNames","websocketEventNames","workerEventNames","eventNames","ignoreProperties","tip","filter","ip","targetIgnoreProperties","op","patchFilteredProperties","propertyDescriptorPatch","supportsWebSocket","WebSocket","internalWindow_1","ignoreErrorProperties","isIE","Document","Element","HTMLElement","HTMLMediaElement","HTMLFrameSetElement","HTMLBodyElement","HTMLFrameElement","HTMLIFrameElement","HTMLMarqueeElement_1","Worker_1","XMLHttpRequest","XMLHttpRequestEventTarget","IDBIndex","IDBRequest","IDBOpenDBRequest","IDBDatabase","IDBTransaction","IDBCursor","propertyPatch","isUnconfigurable","originalConfigurableFlag","rewriteDescriptor","_tryDefineProperty","defineProperties","props","isFrozen","swallowError","descJson","log","eventTargetLegacyPatch","_a","NO_EVENT_TARGET","split","isWtf","WTF_ISSUE_555_ARRAY","map","isDisableIECheck","isEnableCrossContextCheck","FUNCTION_WRAPPER","BROWSER_TOOLS","pointerEventsMap","targets","apiTypes","testString","propertyDescriptorLegacyPatch","document","createElement","onclick","ON_READY_STATE_CHANGE","XMLHttpRequestPrototype","xhrDesc","req","onreadystatechange","SYMBOL_FAKE_ONREADYSTATECHANGE_1","detectFunc","canPatchViaPropertyDescriptor","unboundKey","_loop_4","property","onproperty","bound","elt","parentElement","patchViaCapturingAllTheEvents","WS","EventTarget","x","y","proxySocket","proxySocketProto","socket","onmessageDesc","propName","propertySymbol","globalWebSocket","SYMBOL_BLACK_LISTED_EVENTS","SYMBOL_UNPATCHED_EVENTS","registerElementPatch","taskSymbol","patchTimer","setName","cancelName","nameSuffix","clearNative","tasksByHandleId","clearTask","options_1","delay","callback_1","handle","ref","unref","bind","id","eventTargetPatch","EVENT_TARGET","legacyPatch","clear","blockingMethods","s","patchEvent","customElements","patchCustomElements","oriAddListener","oriRemoveListener","XMLHttpRequestEventTarget_1","XMLHttpRequestEventTargetPrototype","READY_STATE_CHANGE","SCHEDULED","openNative","XHR_SYNC","XHR_URL","fetchTaskAborting","fetchTaskScheduling","sendNative","url","aborted","placeholderCallback","XHR_ERROR_BEFORE_SCHEDULED","abortNative","XHR_TASK","XHR_SCHEDULED","XHR_LISTENER","newListener","readyState","DONE","loadTasks","oriInvoke_1","patchXHR","geolocation","fnNames","_loop_1","name_1","patchPrototype","findPromiseRejectionHandler","PromiseRejectionEvent","evt","nativePropertyIsEnumerable","propertyIsEnumerable","NASHORN_BUG","1","f","V","anObject","aPossiblePrototype","setPrototypeOf","setter","CORRECT_SETTER","test","O","__proto__","has","TO_STRING_TAG","wellKnownSymbol","TAG","STATIC","getBuiltIn","stat","preventExtensions","objectPreventExtensions","objectIsExtensible","isExtensible","check","Math","globalThis","internalObjectKeys","enumBugKeys","toObject","sharedKey","CORRECT_PROTOTYPE_GETTER","IE_PROTO","ObjectPrototype","fails","F","ownKeys","getOwnPropertyDescriptorModule","definePropertyModule","shared","uid","isObject","factories","construct","argsLength","list","join","that","partArgs","boundFunction","DESCRIPTORS","propertyIsEnumerableModule","createPropertyDescriptor","toIndexedObject","toPrimitive","IE8_DOM_DEFINE","nativeGetOwnPropertyDescriptor","P","String","createNonEnumerableProperty","redefine","setGlobal","copyConstructorProperties","isForced","targetProperty","sourceProperty","TARGET","GLOBAL","noTargetGet","forced","toInteger","max","min","index","integer","hiddenKeys","getOwnPropertyNames","version","versions","v8","objectKeys","Properties","propertyKey","attributes","classof","IS_NODE","V8_VERSION","getOwnPropertySymbols","nativeConstruct","NEW_TARGET_BUG","ARGS_BUG","FORCED","Target","newTarget","$args","toLength","toAbsoluteIndex","createMethod","IS_INCLUDES","$this","el","fromIndex","includes","argument","IS_PURE","store","mode","copyright","getOwnPropertyNamesModule","getOwnPropertySymbolsModule","bitmap","receiver","NATIVE_WEAK_MAP","objectHas","WeakMap","wmget","wmhas","wmset","metadata","facade","STATE","enforce","getterFor","TYPE","inspectSource","InternalStateModule","getInternalState","enforceInternalState","TEMPLATE","unsafe","simple","objectGetPrototypeOf","activeXDocument","html","documentCreateElement","EmptyConstructor","scriptTag","content","LT","NullProtoObject","domain","ActiveXObject","iframeDocument","iframe","write","close","temp","parentWindow","NullProtoObjectViaActiveX","style","display","appendChild","src","contentWindow","open","Constructor","object","existingDescriptor","ownDescriptor","objectSetPrototypeOf","functionToString","SENTRY_RELEASE","postfix","random","replacement","feature","detection","normalize","POLYFILL","NATIVE","string","replace","toLowerCase","nativeDefineProperty","Attributes","ceil","floor","isNaN","nativeApply","functionApply","thisArgument","argumentsList","deleteProperty","USE_SYMBOL_AS_UID","WellKnownSymbolsStore","createWellKnownSymbol","withoutSetter","input","PREFERRED_STRING","val","valueOf","SHARED","names","EXISTS"],"mappings":"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","file":"polyfills.8f4cc0bc5fc9687859b9.js","sourcesContent":["var $ = require('../internals/export');\nvar global = require('../internals/global');\nvar setToStringTag = require('../internals/set-to-string-tag');\n\n$({ global: true }, { Reflect: {} });\n\n// Reflect[@@toStringTag] property\n// https://tc39.es/ecma262/#sec-reflect-@@tostringtag\nsetToStringTag(global.Reflect, 'Reflect', true);\n","// toObject with fallback for non-array-like ES3 strings\nvar IndexedObject = require('../internals/indexed-object');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nmodule.exports = function (it) {\n  return IndexedObject(requireObjectCoercible(it));\n};\n","var NATIVE_SYMBOL = require('../internals/native-symbol');\n\nmodule.exports = NATIVE_SYMBOL\n  /* global Symbol -- safe */\n  && !Symbol.sham\n  && typeof Symbol.iterator == 'symbol';\n","module.exports = {};\n","module.exports = function (exec) {\n  try {\n    return !!exec();\n  } catch (error) {\n    return true;\n  }\n};\n","var path = require('../internals/path');\nvar global = require('../internals/global');\n\nvar aFunction = function (variable) {\n  return typeof variable == 'function' ? variable : undefined;\n};\n\nmodule.exports = function (namespace, method) {\n  return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global[namespace])\n    : path[namespace] && path[namespace][method] || global[namespace] && global[namespace][method];\n};\n","'use strict';\n/**\n * @license Angular v12.0.0-next.0\n * (c) 2010-2020 Google LLC. https://angular.io/\n * License: MIT\n */\n(function (factory) {\n    typeof define === 'function' && define.amd ? define(factory) :\n        factory();\n}((function () {\n    'use strict';\n    /**\n     * @license\n     * Copyright Google LLC All Rights Reserved.\n     *\n     * Use of this source code is governed by an MIT-style license that can be\n     * found in the LICENSE file at https://angular.io/license\n     */\n    var Zone$1 = (function (global) {\n        var performance = global['performance'];\n        function mark(name) {\n            performance && performance['mark'] && performance['mark'](name);\n        }\n        function performanceMeasure(name, label) {\n            performance && performance['measure'] && performance['measure'](name, label);\n        }\n        mark('Zone');\n        // Initialize before it's accessed below.\n        // __Zone_symbol_prefix global can be used to override the default zone\n        // symbol prefix with a custom one if needed.\n        var symbolPrefix = global['__Zone_symbol_prefix'] || '__zone_symbol__';\n        function __symbol__(name) {\n            return symbolPrefix + name;\n        }\n        var checkDuplicate = global[__symbol__('forceDuplicateZoneCheck')] === true;\n        if (global['Zone']) {\n            // if global['Zone'] already exists (maybe zone.js was already loaded or\n            // some other lib also registered a global object named Zone), we may need\n            // to throw an error, but sometimes user may not want this error.\n            // For example,\n            // we have two web pages, page1 includes zone.js, page2 doesn't.\n            // and the 1st time user load page1 and page2, everything work fine,\n            // but when user load page2 again, error occurs because global['Zone'] already exists.\n            // so we add a flag to let user choose whether to throw this error or not.\n            // By default, if existing Zone is from zone.js, we will not throw the error.\n            if (checkDuplicate || typeof global['Zone'].__symbol__ !== 'function') {\n                throw new Error('Zone already loaded.');\n            }\n            else {\n                return global['Zone'];\n            }\n        }\n        var Zone = /** @class */ (function () {\n            function Zone(parent, zoneSpec) {\n                this._parent = parent;\n                this._name = zoneSpec ? zoneSpec.name || 'unnamed' : '<root>';\n                this._properties = zoneSpec && zoneSpec.properties || {};\n                this._zoneDelegate =\n                    new ZoneDelegate(this, this._parent && this._parent._zoneDelegate, zoneSpec);\n            }\n            Zone.assertZonePatched = function () {\n                if (global['Promise'] !== patches['ZoneAwarePromise']) {\n                    throw new Error('Zone.js has detected that ZoneAwarePromise `(window|global).Promise` ' +\n                        'has been overwritten.\\n' +\n                        'Most likely cause is that a Promise polyfill has been loaded ' +\n                        'after Zone.js (Polyfilling Promise api is not necessary when zone.js is loaded. ' +\n                        'If you must load one, do so before loading zone.js.)');\n                }\n            };\n            Object.defineProperty(Zone, \"root\", {\n                get: function () {\n                    var zone = Zone.current;\n                    while (zone.parent) {\n                        zone = zone.parent;\n                    }\n                    return zone;\n                },\n                enumerable: false,\n                configurable: true\n            });\n            Object.defineProperty(Zone, \"current\", {\n                get: function () {\n                    return _currentZoneFrame.zone;\n                },\n                enumerable: false,\n                configurable: true\n            });\n            Object.defineProperty(Zone, \"currentTask\", {\n                get: function () {\n                    return _currentTask;\n                },\n                enumerable: false,\n                configurable: true\n            });\n            // tslint:disable-next-line:require-internal-with-underscore\n            Zone.__load_patch = function (name, fn, ignoreDuplicate) {\n                if (ignoreDuplicate === void 0) { ignoreDuplicate = false; }\n                if (patches.hasOwnProperty(name)) {\n                    // `checkDuplicate` option is defined from global variable\n                    // so it works for all modules.\n                    // `ignoreDuplicate` can work for the specified module\n                    if (!ignoreDuplicate && checkDuplicate) {\n                        throw Error('Already loaded patch: ' + name);\n                    }\n                }\n                else if (!global['__Zone_disable_' + name]) {\n                    var perfName = 'Zone:' + name;\n                    mark(perfName);\n                    patches[name] = fn(global, Zone, _api);\n                    performanceMeasure(perfName, perfName);\n                }\n            };\n            Object.defineProperty(Zone.prototype, \"parent\", {\n                get: function () {\n                    return this._parent;\n                },\n                enumerable: false,\n                configurable: true\n            });\n            Object.defineProperty(Zone.prototype, \"name\", {\n                get: function () {\n                    return this._name;\n                },\n                enumerable: false,\n                configurable: true\n            });\n            Zone.prototype.get = function (key) {\n                var zone = this.getZoneWith(key);\n                if (zone)\n                    return zone._properties[key];\n            };\n            Zone.prototype.getZoneWith = function (key) {\n                var current = this;\n                while (current) {\n                    if (current._properties.hasOwnProperty(key)) {\n                        return current;\n                    }\n                    current = current._parent;\n                }\n                return null;\n            };\n            Zone.prototype.fork = function (zoneSpec) {\n                if (!zoneSpec)\n                    throw new Error('ZoneSpec required!');\n                return this._zoneDelegate.fork(this, zoneSpec);\n            };\n            Zone.prototype.wrap = function (callback, source) {\n                if (typeof callback !== 'function') {\n                    throw new Error('Expecting function got: ' + callback);\n                }\n                var _callback = this._zoneDelegate.intercept(this, callback, source);\n                var zone = this;\n                return function () {\n                    return zone.runGuarded(_callback, this, arguments, source);\n                };\n            };\n            Zone.prototype.run = function (callback, applyThis, applyArgs, source) {\n                _currentZoneFrame = { parent: _currentZoneFrame, zone: this };\n                try {\n                    return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source);\n                }\n                finally {\n                    _currentZoneFrame = _currentZoneFrame.parent;\n                }\n            };\n            Zone.prototype.runGuarded = function (callback, applyThis, applyArgs, source) {\n                if (applyThis === void 0) { applyThis = null; }\n                _currentZoneFrame = { parent: _currentZoneFrame, zone: this };\n                try {\n                    try {\n                        return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source);\n                    }\n                    catch (error) {\n                        if (this._zoneDelegate.handleError(this, error)) {\n                            throw error;\n                        }\n                    }\n                }\n                finally {\n                    _currentZoneFrame = _currentZoneFrame.parent;\n                }\n            };\n            Zone.prototype.runTask = function (task, applyThis, applyArgs) {\n                if (task.zone != this) {\n                    throw new Error('A task can only be run in the zone of creation! (Creation: ' +\n                        (task.zone || NO_ZONE).name + '; Execution: ' + this.name + ')');\n                }\n                // https://github.com/angular/zone.js/issues/778, sometimes eventTask\n                // will run in notScheduled(canceled) state, we should not try to\n                // run such kind of task but just return\n                if (task.state === notScheduled && (task.type === eventTask || task.type === macroTask)) {\n                    return;\n                }\n                var reEntryGuard = task.state != running;\n                reEntryGuard && task._transitionTo(running, scheduled);\n                task.runCount++;\n                var previousTask = _currentTask;\n                _currentTask = task;\n                _currentZoneFrame = { parent: _currentZoneFrame, zone: this };\n                try {\n                    if (task.type == macroTask && task.data && !task.data.isPeriodic) {\n                        task.cancelFn = undefined;\n                    }\n                    try {\n                        return this._zoneDelegate.invokeTask(this, task, applyThis, applyArgs);\n                    }\n                    catch (error) {\n                        if (this._zoneDelegate.handleError(this, error)) {\n                            throw error;\n                        }\n                    }\n                }\n                finally {\n                    // if the task's state is notScheduled or unknown, then it has already been cancelled\n                    // we should not reset the state to scheduled\n                    if (task.state !== notScheduled && task.state !== unknown) {\n                        if (task.type == eventTask || (task.data && task.data.isPeriodic)) {\n                            reEntryGuard && task._transitionTo(scheduled, running);\n                        }\n                        else {\n                            task.runCount = 0;\n                            this._updateTaskCount(task, -1);\n                            reEntryGuard &&\n                                task._transitionTo(notScheduled, running, notScheduled);\n                        }\n                    }\n                    _currentZoneFrame = _currentZoneFrame.parent;\n                    _currentTask = previousTask;\n                }\n            };\n            Zone.prototype.scheduleTask = function (task) {\n                if (task.zone && task.zone !== this) {\n                    // check if the task was rescheduled, the newZone\n                    // should not be the children of the original zone\n                    var newZone = this;\n                    while (newZone) {\n                        if (newZone === task.zone) {\n                            throw Error(\"can not reschedule task to \" + this.name + \" which is descendants of the original zone \" + task.zone.name);\n                        }\n                        newZone = newZone.parent;\n                    }\n                }\n                task._transitionTo(scheduling, notScheduled);\n                var zoneDelegates = [];\n                task._zoneDelegates = zoneDelegates;\n                task._zone = this;\n                try {\n                    task = this._zoneDelegate.scheduleTask(this, task);\n                }\n                catch (err) {\n                    // should set task's state to unknown when scheduleTask throw error\n                    // because the err may from reschedule, so the fromState maybe notScheduled\n                    task._transitionTo(unknown, scheduling, notScheduled);\n                    // TODO: @JiaLiPassion, should we check the result from handleError?\n                    this._zoneDelegate.handleError(this, err);\n                    throw err;\n                }\n                if (task._zoneDelegates === zoneDelegates) {\n                    // we have to check because internally the delegate can reschedule the task.\n                    this._updateTaskCount(task, 1);\n                }\n                if (task.state == scheduling) {\n                    task._transitionTo(scheduled, scheduling);\n                }\n                return task;\n            };\n            Zone.prototype.scheduleMicroTask = function (source, callback, data, customSchedule) {\n                return this.scheduleTask(new ZoneTask(microTask, source, callback, data, customSchedule, undefined));\n            };\n            Zone.prototype.scheduleMacroTask = function (source, callback, data, customSchedule, customCancel) {\n                return this.scheduleTask(new ZoneTask(macroTask, source, callback, data, customSchedule, customCancel));\n            };\n            Zone.prototype.scheduleEventTask = function (source, callback, data, customSchedule, customCancel) {\n                return this.scheduleTask(new ZoneTask(eventTask, source, callback, data, customSchedule, customCancel));\n            };\n            Zone.prototype.cancelTask = function (task) {\n                if (task.zone != this)\n                    throw new Error('A task can only be cancelled in the zone of creation! (Creation: ' +\n                        (task.zone || NO_ZONE).name + '; Execution: ' + this.name + ')');\n                task._transitionTo(canceling, scheduled, running);\n                try {\n                    this._zoneDelegate.cancelTask(this, task);\n                }\n                catch (err) {\n                    // if error occurs when cancelTask, transit the state to unknown\n                    task._transitionTo(unknown, canceling);\n                    this._zoneDelegate.handleError(this, err);\n                    throw err;\n                }\n                this._updateTaskCount(task, -1);\n                task._transitionTo(notScheduled, canceling);\n                task.runCount = 0;\n                return task;\n            };\n            Zone.prototype._updateTaskCount = function (task, count) {\n                var zoneDelegates = task._zoneDelegates;\n                if (count == -1) {\n                    task._zoneDelegates = null;\n                }\n                for (var i = 0; i < zoneDelegates.length; i++) {\n                    zoneDelegates[i]._updateTaskCount(task.type, count);\n                }\n            };\n            return Zone;\n        }());\n        // tslint:disable-next-line:require-internal-with-underscore\n        Zone.__symbol__ = __symbol__;\n        var DELEGATE_ZS = {\n            name: '',\n            onHasTask: function (delegate, _, target, hasTaskState) { return delegate.hasTask(target, hasTaskState); },\n            onScheduleTask: function (delegate, _, target, task) { return delegate.scheduleTask(target, task); },\n            onInvokeTask: function (delegate, _, target, task, applyThis, applyArgs) { return delegate.invokeTask(target, task, applyThis, applyArgs); },\n            onCancelTask: function (delegate, _, target, task) { return delegate.cancelTask(target, task); }\n        };\n        var ZoneDelegate = /** @class */ (function () {\n            function ZoneDelegate(zone, parentDelegate, zoneSpec) {\n                this._taskCounts = { 'microTask': 0, 'macroTask': 0, 'eventTask': 0 };\n                this.zone = zone;\n                this._parentDelegate = parentDelegate;\n                this._forkZS = zoneSpec && (zoneSpec && zoneSpec.onFork ? zoneSpec : parentDelegate._forkZS);\n                this._forkDlgt = zoneSpec && (zoneSpec.onFork ? parentDelegate : parentDelegate._forkDlgt);\n                this._forkCurrZone =\n                    zoneSpec && (zoneSpec.onFork ? this.zone : parentDelegate._forkCurrZone);\n                this._interceptZS =\n                    zoneSpec && (zoneSpec.onIntercept ? zoneSpec : parentDelegate._interceptZS);\n                this._interceptDlgt =\n                    zoneSpec && (zoneSpec.onIntercept ? parentDelegate : parentDelegate._interceptDlgt);\n                this._interceptCurrZone =\n                    zoneSpec && (zoneSpec.onIntercept ? this.zone : parentDelegate._interceptCurrZone);\n                this._invokeZS = zoneSpec && (zoneSpec.onInvoke ? zoneSpec : parentDelegate._invokeZS);\n                this._invokeDlgt =\n                    zoneSpec && (zoneSpec.onInvoke ? parentDelegate : parentDelegate._invokeDlgt);\n                this._invokeCurrZone =\n                    zoneSpec && (zoneSpec.onInvoke ? this.zone : parentDelegate._invokeCurrZone);\n                this._handleErrorZS =\n                    zoneSpec && (zoneSpec.onHandleError ? zoneSpec : parentDelegate._handleErrorZS);\n                this._handleErrorDlgt =\n                    zoneSpec && (zoneSpec.onHandleError ? parentDelegate : parentDelegate._handleErrorDlgt);\n                this._handleErrorCurrZone =\n                    zoneSpec && (zoneSpec.onHandleError ? this.zone : parentDelegate._handleErrorCurrZone);\n                this._scheduleTaskZS =\n                    zoneSpec && (zoneSpec.onScheduleTask ? zoneSpec : parentDelegate._scheduleTaskZS);\n                this._scheduleTaskDlgt = zoneSpec &&\n                    (zoneSpec.onScheduleTask ? parentDelegate : parentDelegate._scheduleTaskDlgt);\n                this._scheduleTaskCurrZone =\n                    zoneSpec && (zoneSpec.onScheduleTask ? this.zone : parentDelegate._scheduleTaskCurrZone);\n                this._invokeTaskZS =\n                    zoneSpec && (zoneSpec.onInvokeTask ? zoneSpec : parentDelegate._invokeTaskZS);\n                this._invokeTaskDlgt =\n                    zoneSpec && (zoneSpec.onInvokeTask ? parentDelegate : parentDelegate._invokeTaskDlgt);\n                this._invokeTaskCurrZone =\n                    zoneSpec && (zoneSpec.onInvokeTask ? this.zone : parentDelegate._invokeTaskCurrZone);\n                this._cancelTaskZS =\n                    zoneSpec && (zoneSpec.onCancelTask ? zoneSpec : parentDelegate._cancelTaskZS);\n                this._cancelTaskDlgt =\n                    zoneSpec && (zoneSpec.onCancelTask ? parentDelegate : parentDelegate._cancelTaskDlgt);\n                this._cancelTaskCurrZone =\n                    zoneSpec && (zoneSpec.onCancelTask ? this.zone : parentDelegate._cancelTaskCurrZone);\n                this._hasTaskZS = null;\n                this._hasTaskDlgt = null;\n                this._hasTaskDlgtOwner = null;\n                this._hasTaskCurrZone = null;\n                var zoneSpecHasTask = zoneSpec && zoneSpec.onHasTask;\n                var parentHasTask = parentDelegate && parentDelegate._hasTaskZS;\n                if (zoneSpecHasTask || parentHasTask) {\n                    // If we need to report hasTask, than this ZS needs to do ref counting on tasks. In such\n                    // a case all task related interceptors must go through this ZD. We can't short circuit it.\n                    this._hasTaskZS = zoneSpecHasTask ? zoneSpec : DELEGATE_ZS;\n                    this._hasTaskDlgt = parentDelegate;\n                    this._hasTaskDlgtOwner = this;\n                    this._hasTaskCurrZone = zone;\n                    if (!zoneSpec.onScheduleTask) {\n                        this._scheduleTaskZS = DELEGATE_ZS;\n                        this._scheduleTaskDlgt = parentDelegate;\n                        this._scheduleTaskCurrZone = this.zone;\n                    }\n                    if (!zoneSpec.onInvokeTask) {\n                        this._invokeTaskZS = DELEGATE_ZS;\n                        this._invokeTaskDlgt = parentDelegate;\n                        this._invokeTaskCurrZone = this.zone;\n                    }\n                    if (!zoneSpec.onCancelTask) {\n                        this._cancelTaskZS = DELEGATE_ZS;\n                        this._cancelTaskDlgt = parentDelegate;\n                        this._cancelTaskCurrZone = this.zone;\n                    }\n                }\n            }\n            ZoneDelegate.prototype.fork = function (targetZone, zoneSpec) {\n                return this._forkZS ? this._forkZS.onFork(this._forkDlgt, this.zone, targetZone, zoneSpec) :\n                    new Zone(targetZone, zoneSpec);\n            };\n            ZoneDelegate.prototype.intercept = function (targetZone, callback, source) {\n                return this._interceptZS ?\n                    this._interceptZS.onIntercept(this._interceptDlgt, this._interceptCurrZone, targetZone, callback, source) :\n                    callback;\n            };\n            ZoneDelegate.prototype.invoke = function (targetZone, callback, applyThis, applyArgs, source) {\n                return this._invokeZS ? this._invokeZS.onInvoke(this._invokeDlgt, this._invokeCurrZone, targetZone, callback, applyThis, applyArgs, source) :\n                    callback.apply(applyThis, applyArgs);\n            };\n            ZoneDelegate.prototype.handleError = function (targetZone, error) {\n                return this._handleErrorZS ?\n                    this._handleErrorZS.onHandleError(this._handleErrorDlgt, this._handleErrorCurrZone, targetZone, error) :\n                    true;\n            };\n            ZoneDelegate.prototype.scheduleTask = function (targetZone, task) {\n                var returnTask = task;\n                if (this._scheduleTaskZS) {\n                    if (this._hasTaskZS) {\n                        returnTask._zoneDelegates.push(this._hasTaskDlgtOwner);\n                    }\n                    // clang-format off\n                    returnTask = this._scheduleTaskZS.onScheduleTask(this._scheduleTaskDlgt, this._scheduleTaskCurrZone, targetZone, task);\n                    // clang-format on\n                    if (!returnTask)\n                        returnTask = task;\n                }\n                else {\n                    if (task.scheduleFn) {\n                        task.scheduleFn(task);\n                    }\n                    else if (task.type == microTask) {\n                        scheduleMicroTask(task);\n                    }\n                    else {\n                        throw new Error('Task is missing scheduleFn.');\n                    }\n                }\n                return returnTask;\n            };\n            ZoneDelegate.prototype.invokeTask = function (targetZone, task, applyThis, applyArgs) {\n                return this._invokeTaskZS ? this._invokeTaskZS.onInvokeTask(this._invokeTaskDlgt, this._invokeTaskCurrZone, targetZone, task, applyThis, applyArgs) :\n                    task.callback.apply(applyThis, applyArgs);\n            };\n            ZoneDelegate.prototype.cancelTask = function (targetZone, task) {\n                var value;\n                if (this._cancelTaskZS) {\n                    value = this._cancelTaskZS.onCancelTask(this._cancelTaskDlgt, this._cancelTaskCurrZone, targetZone, task);\n                }\n                else {\n                    if (!task.cancelFn) {\n                        throw Error('Task is not cancelable');\n                    }\n                    value = task.cancelFn(task);\n                }\n                return value;\n            };\n            ZoneDelegate.prototype.hasTask = function (targetZone, isEmpty) {\n                // hasTask should not throw error so other ZoneDelegate\n                // can still trigger hasTask callback\n                try {\n                    this._hasTaskZS &&\n                        this._hasTaskZS.onHasTask(this._hasTaskDlgt, this._hasTaskCurrZone, targetZone, isEmpty);\n                }\n                catch (err) {\n                    this.handleError(targetZone, err);\n                }\n            };\n            // tslint:disable-next-line:require-internal-with-underscore\n            ZoneDelegate.prototype._updateTaskCount = function (type, count) {\n                var counts = this._taskCounts;\n                var prev = counts[type];\n                var next = counts[type] = prev + count;\n                if (next < 0) {\n                    throw new Error('More tasks executed then were scheduled.');\n                }\n                if (prev == 0 || next == 0) {\n                    var isEmpty = {\n                        microTask: counts['microTask'] > 0,\n                        macroTask: counts['macroTask'] > 0,\n                        eventTask: counts['eventTask'] > 0,\n                        change: type\n                    };\n                    this.hasTask(this.zone, isEmpty);\n                }\n            };\n            return ZoneDelegate;\n        }());\n        var ZoneTask = /** @class */ (function () {\n            function ZoneTask(type, source, callback, options, scheduleFn, cancelFn) {\n                // tslint:disable-next-line:require-internal-with-underscore\n                this._zone = null;\n                this.runCount = 0;\n                // tslint:disable-next-line:require-internal-with-underscore\n                this._zoneDelegates = null;\n                // tslint:disable-next-line:require-internal-with-underscore\n                this._state = 'notScheduled';\n                this.type = type;\n                this.source = source;\n                this.data = options;\n                this.scheduleFn = scheduleFn;\n                this.cancelFn = cancelFn;\n                if (!callback) {\n                    throw new Error('callback is not defined');\n                }\n                this.callback = callback;\n                var self = this;\n                // TODO: @JiaLiPassion options should have interface\n                if (type === eventTask && options && options.useG) {\n                    this.invoke = ZoneTask.invokeTask;\n                }\n                else {\n                    this.invoke = function () {\n                        return ZoneTask.invokeTask.call(global, self, this, arguments);\n                    };\n                }\n            }\n            ZoneTask.invokeTask = function (task, target, args) {\n                if (!task) {\n                    task = this;\n                }\n                _numberOfNestedTaskFrames++;\n                try {\n                    task.runCount++;\n                    return task.zone.runTask(task, target, args);\n                }\n                finally {\n                    if (_numberOfNestedTaskFrames == 1) {\n                        drainMicroTaskQueue();\n                    }\n                    _numberOfNestedTaskFrames--;\n                }\n            };\n            Object.defineProperty(ZoneTask.prototype, \"zone\", {\n                get: function () {\n                    return this._zone;\n                },\n                enumerable: false,\n                configurable: true\n            });\n            Object.defineProperty(ZoneTask.prototype, \"state\", {\n                get: function () {\n                    return this._state;\n                },\n                enumerable: false,\n                configurable: true\n            });\n            ZoneTask.prototype.cancelScheduleRequest = function () {\n                this._transitionTo(notScheduled, scheduling);\n            };\n            // tslint:disable-next-line:require-internal-with-underscore\n            ZoneTask.prototype._transitionTo = function (toState, fromState1, fromState2) {\n                if (this._state === fromState1 || this._state === fromState2) {\n                    this._state = toState;\n                    if (toState == notScheduled) {\n                        this._zoneDelegates = null;\n                    }\n                }\n                else {\n                    throw new Error(this.type + \" '\" + this.source + \"': can not transition to '\" + toState + \"', expecting state '\" + fromState1 + \"'\" + (fromState2 ? ' or \\'' + fromState2 + '\\'' : '') + \", was '\" + this._state + \"'.\");\n                }\n            };\n            ZoneTask.prototype.toString = function () {\n                if (this.data && typeof this.data.handleId !== 'undefined') {\n                    return this.data.handleId.toString();\n                }\n                else {\n                    return Object.prototype.toString.call(this);\n                }\n            };\n            // add toJSON method to prevent cyclic error when\n            // call JSON.stringify(zoneTask)\n            ZoneTask.prototype.toJSON = function () {\n                return {\n                    type: this.type,\n                    state: this.state,\n                    source: this.source,\n                    zone: this.zone.name,\n                    runCount: this.runCount\n                };\n            };\n            return ZoneTask;\n        }());\n        //////////////////////////////////////////////////////\n        //////////////////////////////////////////////////////\n        ///  MICROTASK QUEUE\n        //////////////////////////////////////////////////////\n        //////////////////////////////////////////////////////\n        var symbolSetTimeout = __symbol__('setTimeout');\n        var symbolPromise = __symbol__('Promise');\n        var symbolThen = __symbol__('then');\n        var _microTaskQueue = [];\n        var _isDrainingMicrotaskQueue = false;\n        var nativeMicroTaskQueuePromise;\n        function scheduleMicroTask(task) {\n            // if we are not running in any task, and there has not been anything scheduled\n            // we must bootstrap the initial task creation by manually scheduling the drain\n            if (_numberOfNestedTaskFrames === 0 && _microTaskQueue.length === 0) {\n                // We are not running in Task, so we need to kickstart the microtask queue.\n                if (!nativeMicroTaskQueuePromise) {\n                    if (global[symbolPromise]) {\n                        nativeMicroTaskQueuePromise = global[symbolPromise].resolve(0);\n                    }\n                }\n                if (nativeMicroTaskQueuePromise) {\n                    var nativeThen = nativeMicroTaskQueuePromise[symbolThen];\n                    if (!nativeThen) {\n                        // native Promise is not patchable, we need to use `then` directly\n                        // issue 1078\n                        nativeThen = nativeMicroTaskQueuePromise['then'];\n                    }\n                    nativeThen.call(nativeMicroTaskQueuePromise, drainMicroTaskQueue);\n                }\n                else {\n                    global[symbolSetTimeout](drainMicroTaskQueue, 0);\n                }\n            }\n            task && _microTaskQueue.push(task);\n        }\n        function drainMicroTaskQueue() {\n            if (!_isDrainingMicrotaskQueue) {\n                _isDrainingMicrotaskQueue = true;\n                while (_microTaskQueue.length) {\n                    var queue = _microTaskQueue;\n                    _microTaskQueue = [];\n                    for (var i = 0; i < queue.length; i++) {\n                        var task = queue[i];\n                        try {\n                            task.zone.runTask(task, null, null);\n                        }\n                        catch (error) {\n                            _api.onUnhandledError(error);\n                        }\n                    }\n                }\n                _api.microtaskDrainDone();\n                _isDrainingMicrotaskQueue = false;\n            }\n        }\n        //////////////////////////////////////////////////////\n        //////////////////////////////////////////////////////\n        ///  BOOTSTRAP\n        //////////////////////////////////////////////////////\n        //////////////////////////////////////////////////////\n        var NO_ZONE = { name: 'NO ZONE' };\n        var notScheduled = 'notScheduled', scheduling = 'scheduling', scheduled = 'scheduled', running = 'running', canceling = 'canceling', unknown = 'unknown';\n        var microTask = 'microTask', macroTask = 'macroTask', eventTask = 'eventTask';\n        var patches = {};\n        var _api = {\n            symbol: __symbol__,\n            currentZoneFrame: function () { return _currentZoneFrame; },\n            onUnhandledError: noop,\n            microtaskDrainDone: noop,\n            scheduleMicroTask: scheduleMicroTask,\n            showUncaughtError: function () { return !Zone[__symbol__('ignoreConsoleErrorUncaughtError')]; },\n            patchEventTarget: function () { return []; },\n            patchOnProperties: noop,\n            patchMethod: function () { return noop; },\n            bindArguments: function () { return []; },\n            patchThen: function () { return noop; },\n            patchMacroTask: function () { return noop; },\n            patchEventPrototype: function () { return noop; },\n            isIEOrEdge: function () { return false; },\n            getGlobalObjects: function () { return undefined; },\n            ObjectDefineProperty: function () { return noop; },\n            ObjectGetOwnPropertyDescriptor: function () { return undefined; },\n            ObjectCreate: function () { return undefined; },\n            ArraySlice: function () { return []; },\n            patchClass: function () { return noop; },\n            wrapWithCurrentZone: function () { return noop; },\n            filterProperties: function () { return []; },\n            attachOriginToPatched: function () { return noop; },\n            _redefineProperty: function () { return noop; },\n            patchCallbacks: function () { return noop; }\n        };\n        var _currentZoneFrame = { parent: null, zone: new Zone(null, null) };\n        var _currentTask = null;\n        var _numberOfNestedTaskFrames = 0;\n        function noop() { }\n        performanceMeasure('Zone', 'Zone');\n        return global['Zone'] = Zone;\n    })(typeof window !== 'undefined' && window || typeof self !== 'undefined' && self || global);\n    /**\n     * @license\n     * Copyright Google LLC All Rights Reserved.\n     *\n     * Use of this source code is governed by an MIT-style license that can be\n     * found in the LICENSE file at https://angular.io/license\n     */\n    /**\n     * Suppress closure compiler errors about unknown 'Zone' variable\n     * @fileoverview\n     * @suppress {undefinedVars,globalThis,missingRequire}\n     */\n    /// <reference types=\"node\"/>\n    // issue #989, to reduce bundle size, use short name\n    /** Object.getOwnPropertyDescriptor */\n    var ObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n    /** Object.defineProperty */\n    var ObjectDefineProperty = Object.defineProperty;\n    /** Object.getPrototypeOf */\n    var ObjectGetPrototypeOf = Object.getPrototypeOf;\n    /** Object.create */\n    var ObjectCreate = Object.create;\n    /** Array.prototype.slice */\n    var ArraySlice = Array.prototype.slice;\n    /** addEventListener string const */\n    var ADD_EVENT_LISTENER_STR = 'addEventListener';\n    /** removeEventListener string const */\n    var REMOVE_EVENT_LISTENER_STR = 'removeEventListener';\n    /** zoneSymbol addEventListener */\n    var ZONE_SYMBOL_ADD_EVENT_LISTENER = Zone.__symbol__(ADD_EVENT_LISTENER_STR);\n    /** zoneSymbol removeEventListener */\n    var ZONE_SYMBOL_REMOVE_EVENT_LISTENER = Zone.__symbol__(REMOVE_EVENT_LISTENER_STR);\n    /** true string const */\n    var TRUE_STR = 'true';\n    /** false string const */\n    var FALSE_STR = 'false';\n    /** Zone symbol prefix string const. */\n    var ZONE_SYMBOL_PREFIX = Zone.__symbol__('');\n    function wrapWithCurrentZone(callback, source) {\n        return Zone.current.wrap(callback, source);\n    }\n    function scheduleMacroTaskWithCurrentZone(source, callback, data, customSchedule, customCancel) {\n        return Zone.current.scheduleMacroTask(source, callback, data, customSchedule, customCancel);\n    }\n    var zoneSymbol = Zone.__symbol__;\n    var isWindowExists = typeof window !== 'undefined';\n    var internalWindow = isWindowExists ? window : undefined;\n    var _global = isWindowExists && internalWindow || typeof self === 'object' && self || global;\n    var REMOVE_ATTRIBUTE = 'removeAttribute';\n    var NULL_ON_PROP_VALUE = [null];\n    function bindArguments(args, source) {\n        for (var i = args.length - 1; i >= 0; i--) {\n            if (typeof args[i] === 'function') {\n                args[i] = wrapWithCurrentZone(args[i], source + '_' + i);\n            }\n        }\n        return args;\n    }\n    function patchPrototype(prototype, fnNames) {\n        var source = prototype.constructor['name'];\n        var _loop_1 = function (i) {\n            var name_1 = fnNames[i];\n            var delegate = prototype[name_1];\n            if (delegate) {\n                var prototypeDesc = ObjectGetOwnPropertyDescriptor(prototype, name_1);\n                if (!isPropertyWritable(prototypeDesc)) {\n                    return \"continue\";\n                }\n                prototype[name_1] = (function (delegate) {\n                    var patched = function () {\n                        return delegate.apply(this, bindArguments(arguments, source + '.' + name_1));\n                    };\n                    attachOriginToPatched(patched, delegate);\n                    return patched;\n                })(delegate);\n            }\n        };\n        for (var i = 0; i < fnNames.length; i++) {\n            _loop_1(i);\n        }\n    }\n    function isPropertyWritable(propertyDesc) {\n        if (!propertyDesc) {\n            return true;\n        }\n        if (propertyDesc.writable === false) {\n            return false;\n        }\n        return !(typeof propertyDesc.get === 'function' && typeof propertyDesc.set === 'undefined');\n    }\n    var isWebWorker = (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope);\n    // Make sure to access `process` through `_global` so that WebPack does not accidentally browserify\n    // this code.\n    var isNode = (!('nw' in _global) && typeof _global.process !== 'undefined' &&\n        {}.toString.call(_global.process) === '[object process]');\n    var isBrowser = !isNode && !isWebWorker && !!(isWindowExists && internalWindow['HTMLElement']);\n    // we are in electron of nw, so we are both browser and nodejs\n    // Make sure to access `process` through `_global` so that WebPack does not accidentally browserify\n    // this code.\n    var isMix = typeof _global.process !== 'undefined' &&\n        {}.toString.call(_global.process) === '[object process]' && !isWebWorker &&\n        !!(isWindowExists && internalWindow['HTMLElement']);\n    var zoneSymbolEventNames = {};\n    var wrapFn = function (event) {\n        // https://github.com/angular/zone.js/issues/911, in IE, sometimes\n        // event will be undefined, so we need to use window.event\n        event = event || _global.event;\n        if (!event) {\n            return;\n        }\n        var eventNameSymbol = zoneSymbolEventNames[event.type];\n        if (!eventNameSymbol) {\n            eventNameSymbol = zoneSymbolEventNames[event.type] = zoneSymbol('ON_PROPERTY' + event.type);\n        }\n        var target = this || event.target || _global;\n        var listener = target[eventNameSymbol];\n        var result;\n        if (isBrowser && target === internalWindow && event.type === 'error') {\n            // window.onerror have different signiture\n            // https://developer.mozilla.org/en-US/docs/Web/API/GlobalEventHandlers/onerror#window.onerror\n            // and onerror callback will prevent default when callback return true\n            var errorEvent = event;\n            result = listener &&\n                listener.call(this, errorEvent.message, errorEvent.filename, errorEvent.lineno, errorEvent.colno, errorEvent.error);\n            if (result === true) {\n                event.preventDefault();\n            }\n        }\n        else {\n            result = listener && listener.apply(this, arguments);\n            if (result != undefined && !result) {\n                event.preventDefault();\n            }\n        }\n        return result;\n    };\n    function patchProperty(obj, prop, prototype) {\n        var desc = ObjectGetOwnPropertyDescriptor(obj, prop);\n        if (!desc && prototype) {\n            // when patch window object, use prototype to check prop exist or not\n            var prototypeDesc = ObjectGetOwnPropertyDescriptor(prototype, prop);\n            if (prototypeDesc) {\n                desc = { enumerable: true, configurable: true };\n            }\n        }\n        // if the descriptor not exists or is not configurable\n        // just return\n        if (!desc || !desc.configurable) {\n            return;\n        }\n        var onPropPatchedSymbol = zoneSymbol('on' + prop + 'patched');\n        if (obj.hasOwnProperty(onPropPatchedSymbol) && obj[onPropPatchedSymbol]) {\n            return;\n        }\n        // A property descriptor cannot have getter/setter and be writable\n        // deleting the writable and value properties avoids this error:\n        //\n        // TypeError: property descriptors must not specify a value or be writable when a\n        // getter or setter has been specified\n        delete desc.writable;\n        delete desc.value;\n        var originalDescGet = desc.get;\n        var originalDescSet = desc.set;\n        // substr(2) cuz 'onclick' -> 'click', etc\n        var eventName = prop.substr(2);\n        var eventNameSymbol = zoneSymbolEventNames[eventName];\n        if (!eventNameSymbol) {\n            eventNameSymbol = zoneSymbolEventNames[eventName] = zoneSymbol('ON_PROPERTY' + eventName);\n        }\n        desc.set = function (newValue) {\n            // in some of windows's onproperty callback, this is undefined\n            // so we need to check it\n            var target = this;\n            if (!target && obj === _global) {\n                target = _global;\n            }\n            if (!target) {\n                return;\n            }\n            var previousValue = target[eventNameSymbol];\n            if (previousValue) {\n                target.removeEventListener(eventName, wrapFn);\n            }\n            // issue #978, when onload handler was added before loading zone.js\n            // we should remove it with originalDescSet\n            if (originalDescSet) {\n                originalDescSet.apply(target, NULL_ON_PROP_VALUE);\n            }\n            if (typeof newValue === 'function') {\n                target[eventNameSymbol] = newValue;\n                target.addEventListener(eventName, wrapFn, false);\n            }\n            else {\n                target[eventNameSymbol] = null;\n            }\n        };\n        // The getter would return undefined for unassigned properties but the default value of an\n        // unassigned property is null\n        desc.get = function () {\n            // in some of windows's onproperty callback, this is undefined\n            // so we need to check it\n            var target = this;\n            if (!target && obj === _global) {\n                target = _global;\n            }\n            if (!target) {\n                return null;\n            }\n            var listener = target[eventNameSymbol];\n            if (listener) {\n                return listener;\n            }\n            else if (originalDescGet) {\n                // result will be null when use inline event attribute,\n                // such as <button onclick=\"func();\">OK</button>\n                // because the onclick function is internal raw uncompiled handler\n                // the onclick will be evaluated when first time event was triggered or\n                // the property is accessed, https://github.com/angular/zone.js/issues/525\n                // so we should use original native get to retrieve the handler\n                var value = originalDescGet && originalDescGet.call(this);\n                if (value) {\n                    desc.set.call(this, value);\n                    if (typeof target[REMOVE_ATTRIBUTE] === 'function') {\n                        target.removeAttribute(prop);\n                    }\n                    return value;\n                }\n            }\n            return null;\n        };\n        ObjectDefineProperty(obj, prop, desc);\n        obj[onPropPatchedSymbol] = true;\n    }\n    function patchOnProperties(obj, properties, prototype) {\n        if (properties) {\n            for (var i = 0; i < properties.length; i++) {\n                patchProperty(obj, 'on' + properties[i], prototype);\n            }\n        }\n        else {\n            var onProperties = [];\n            for (var prop in obj) {\n                if (prop.substr(0, 2) == 'on') {\n                    onProperties.push(prop);\n                }\n            }\n            for (var j = 0; j < onProperties.length; j++) {\n                patchProperty(obj, onProperties[j], prototype);\n            }\n        }\n    }\n    var originalInstanceKey = zoneSymbol('originalInstance');\n    // wrap some native API on `window`\n    function patchClass(className) {\n        var OriginalClass = _global[className];\n        if (!OriginalClass)\n            return;\n        // keep original class in global\n        _global[zoneSymbol(className)] = OriginalClass;\n        _global[className] = function () {\n            var a = bindArguments(arguments, className);\n            switch (a.length) {\n                case 0:\n                    this[originalInstanceKey] = new OriginalClass();\n                    break;\n                case 1:\n                    this[originalInstanceKey] = new OriginalClass(a[0]);\n                    break;\n                case 2:\n                    this[originalInstanceKey] = new OriginalClass(a[0], a[1]);\n                    break;\n                case 3:\n                    this[originalInstanceKey] = new OriginalClass(a[0], a[1], a[2]);\n                    break;\n                case 4:\n                    this[originalInstanceKey] = new OriginalClass(a[0], a[1], a[2], a[3]);\n                    break;\n                default:\n                    throw new Error('Arg list too long.');\n            }\n        };\n        // attach original delegate to patched function\n        attachOriginToPatched(_global[className], OriginalClass);\n        var instance = new OriginalClass(function () { });\n        var prop;\n        for (prop in instance) {\n            // https://bugs.webkit.org/show_bug.cgi?id=44721\n            if (className === 'XMLHttpRequest' && prop === 'responseBlob')\n                continue;\n            (function (prop) {\n                if (typeof instance[prop] === 'function') {\n                    _global[className].prototype[prop] = function () {\n                        return this[originalInstanceKey][prop].apply(this[originalInstanceKey], arguments);\n                    };\n                }\n                else {\n                    ObjectDefineProperty(_global[className].prototype, prop, {\n                        set: function (fn) {\n                            if (typeof fn === 'function') {\n                                this[originalInstanceKey][prop] = wrapWithCurrentZone(fn, className + '.' + prop);\n                                // keep callback in wrapped function so we can\n                                // use it in Function.prototype.toString to return\n                                // the native one.\n                                attachOriginToPatched(this[originalInstanceKey][prop], fn);\n                            }\n                            else {\n                                this[originalInstanceKey][prop] = fn;\n                            }\n                        },\n                        get: function () {\n                            return this[originalInstanceKey][prop];\n                        }\n                    });\n                }\n            }(prop));\n        }\n        for (prop in OriginalClass) {\n            if (prop !== 'prototype' && OriginalClass.hasOwnProperty(prop)) {\n                _global[className][prop] = OriginalClass[prop];\n            }\n        }\n    }\n    function patchMethod(target, name, patchFn) {\n        var proto = target;\n        while (proto && !proto.hasOwnProperty(name)) {\n            proto = ObjectGetPrototypeOf(proto);\n        }\n        if (!proto && target[name]) {\n            // somehow we did not find it, but we can see it. This happens on IE for Window properties.\n            proto = target;\n        }\n        var delegateName = zoneSymbol(name);\n        var delegate = null;\n        if (proto && (!(delegate = proto[delegateName]) || !proto.hasOwnProperty(delegateName))) {\n            delegate = proto[delegateName] = proto[name];\n            // check whether proto[name] is writable\n            // some property is readonly in safari, such as HtmlCanvasElement.prototype.toBlob\n            var desc = proto && ObjectGetOwnPropertyDescriptor(proto, name);\n            if (isPropertyWritable(desc)) {\n                var patchDelegate_1 = patchFn(delegate, delegateName, name);\n                proto[name] = function () {\n                    return patchDelegate_1(this, arguments);\n                };\n                attachOriginToPatched(proto[name], delegate);\n            }\n        }\n        return delegate;\n    }\n    // TODO: @JiaLiPassion, support cancel task later if necessary\n    function patchMacroTask(obj, funcName, metaCreator) {\n        var setNative = null;\n        function scheduleTask(task) {\n            var data = task.data;\n            data.args[data.cbIdx] = function () {\n                task.invoke.apply(this, arguments);\n            };\n            setNative.apply(data.target, data.args);\n            return task;\n        }\n        setNative = patchMethod(obj, funcName, function (delegate) { return function (self, args) {\n            var meta = metaCreator(self, args);\n            if (meta.cbIdx >= 0 && typeof args[meta.cbIdx] === 'function') {\n                return scheduleMacroTaskWithCurrentZone(meta.name, args[meta.cbIdx], meta, scheduleTask);\n            }\n            else {\n                // cause an error by calling it directly.\n                return delegate.apply(self, args);\n            }\n        }; });\n    }\n    function attachOriginToPatched(patched, original) {\n        patched[zoneSymbol('OriginalDelegate')] = original;\n    }\n    var isDetectedIEOrEdge = false;\n    var ieOrEdge = false;\n    function isIE() {\n        try {\n            var ua = internalWindow.navigator.userAgent;\n            if (ua.indexOf('MSIE ') !== -1 || ua.indexOf('Trident/') !== -1) {\n                return true;\n            }\n        }\n        catch (error) {\n        }\n        return false;\n    }\n    function isIEOrEdge() {\n        if (isDetectedIEOrEdge) {\n            return ieOrEdge;\n        }\n        isDetectedIEOrEdge = true;\n        try {\n            var ua = internalWindow.navigator.userAgent;\n            if (ua.indexOf('MSIE ') !== -1 || ua.indexOf('Trident/') !== -1 || ua.indexOf('Edge/') !== -1) {\n                ieOrEdge = true;\n            }\n        }\n        catch (error) {\n        }\n        return ieOrEdge;\n    }\n    /**\n     * @license\n     * Copyright Google LLC All Rights Reserved.\n     *\n     * Use of this source code is governed by an MIT-style license that can be\n     * found in the LICENSE file at https://angular.io/license\n     */\n    Zone.__load_patch('ZoneAwarePromise', function (global, Zone, api) {\n        var ObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n        var ObjectDefineProperty = Object.defineProperty;\n        function readableObjectToString(obj) {\n            if (obj && obj.toString === Object.prototype.toString) {\n                var className = obj.constructor && obj.constructor.name;\n                return (className ? className : '') + ': ' + JSON.stringify(obj);\n            }\n            return obj ? obj.toString() : Object.prototype.toString.call(obj);\n        }\n        var __symbol__ = api.symbol;\n        var _uncaughtPromiseErrors = [];\n        var isDisableWrappingUncaughtPromiseRejection = global[__symbol__('DISABLE_WRAPPING_UNCAUGHT_PROMISE_REJECTION')] === true;\n        var symbolPromise = __symbol__('Promise');\n        var symbolThen = __symbol__('then');\n        var creationTrace = '__creationTrace__';\n        api.onUnhandledError = function (e) {\n            if (api.showUncaughtError()) {\n                var rejection = e && e.rejection;\n                if (rejection) {\n                    console.error('Unhandled Promise rejection:', rejection instanceof Error ? rejection.message : rejection, '; Zone:', e.zone.name, '; Task:', e.task && e.task.source, '; Value:', rejection, rejection instanceof Error ? rejection.stack : undefined);\n                }\n                else {\n                    console.error(e);\n                }\n            }\n        };\n        api.microtaskDrainDone = function () {\n            var _loop_2 = function () {\n                var uncaughtPromiseError = _uncaughtPromiseErrors.shift();\n                try {\n                    uncaughtPromiseError.zone.runGuarded(function () {\n                        if (uncaughtPromiseError.throwOriginal) {\n                            throw uncaughtPromiseError.rejection;\n                        }\n                        throw uncaughtPromiseError;\n                    });\n                }\n                catch (error) {\n                    handleUnhandledRejection(error);\n                }\n            };\n            while (_uncaughtPromiseErrors.length) {\n                _loop_2();\n            }\n        };\n        var UNHANDLED_PROMISE_REJECTION_HANDLER_SYMBOL = __symbol__('unhandledPromiseRejectionHandler');\n        function handleUnhandledRejection(e) {\n            api.onUnhandledError(e);\n            try {\n                var handler = Zone[UNHANDLED_PROMISE_REJECTION_HANDLER_SYMBOL];\n                if (typeof handler === 'function') {\n                    handler.call(this, e);\n                }\n            }\n            catch (err) {\n            }\n        }\n        function isThenable(value) {\n            return value && value.then;\n        }\n        function forwardResolution(value) {\n            return value;\n        }\n        function forwardRejection(rejection) {\n            return ZoneAwarePromise.reject(rejection);\n        }\n        var symbolState = __symbol__('state');\n        var symbolValue = __symbol__('value');\n        var symbolFinally = __symbol__('finally');\n        var symbolParentPromiseValue = __symbol__('parentPromiseValue');\n        var symbolParentPromiseState = __symbol__('parentPromiseState');\n        var source = 'Promise.then';\n        var UNRESOLVED = null;\n        var RESOLVED = true;\n        var REJECTED = false;\n        var REJECTED_NO_CATCH = 0;\n        function makeResolver(promise, state) {\n            return function (v) {\n                try {\n                    resolvePromise(promise, state, v);\n                }\n                catch (err) {\n                    resolvePromise(promise, false, err);\n                }\n                // Do not return value or you will break the Promise spec.\n            };\n        }\n        var once = function () {\n            var wasCalled = false;\n            return function wrapper(wrappedFunction) {\n                return function () {\n                    if (wasCalled) {\n                        return;\n                    }\n                    wasCalled = true;\n                    wrappedFunction.apply(null, arguments);\n                };\n            };\n        };\n        var TYPE_ERROR = 'Promise resolved with itself';\n        var CURRENT_TASK_TRACE_SYMBOL = __symbol__('currentTaskTrace');\n        // Promise Resolution\n        function resolvePromise(promise, state, value) {\n            var onceWrapper = once();\n            if (promise === value) {\n                throw new TypeError(TYPE_ERROR);\n            }\n            if (promise[symbolState] === UNRESOLVED) {\n                // should only get value.then once based on promise spec.\n                var then = null;\n                try {\n                    if (typeof value === 'object' || typeof value === 'function') {\n                        then = value && value.then;\n                    }\n                }\n                catch (err) {\n                    onceWrapper(function () {\n                        resolvePromise(promise, false, err);\n                    })();\n                    return promise;\n                }\n                // if (value instanceof ZoneAwarePromise) {\n                if (state !== REJECTED && value instanceof ZoneAwarePromise &&\n                    value.hasOwnProperty(symbolState) && value.hasOwnProperty(symbolValue) &&\n                    value[symbolState] !== UNRESOLVED) {\n                    clearRejectedNoCatch(value);\n                    resolvePromise(promise, value[symbolState], value[symbolValue]);\n                }\n                else if (state !== REJECTED && typeof then === 'function') {\n                    try {\n                        then.call(value, onceWrapper(makeResolver(promise, state)), onceWrapper(makeResolver(promise, false)));\n                    }\n                    catch (err) {\n                        onceWrapper(function () {\n                            resolvePromise(promise, false, err);\n                        })();\n                    }\n                }\n                else {\n                    promise[symbolState] = state;\n                    var queue = promise[symbolValue];\n                    promise[symbolValue] = value;\n                    if (promise[symbolFinally] === symbolFinally) {\n                        // the promise is generated by Promise.prototype.finally\n                        if (state === RESOLVED) {\n                            // the state is resolved, should ignore the value\n                            // and use parent promise value\n                            promise[symbolState] = promise[symbolParentPromiseState];\n                            promise[symbolValue] = promise[symbolParentPromiseValue];\n                        }\n                    }\n                    // record task information in value when error occurs, so we can\n                    // do some additional work such as render longStackTrace\n                    if (state === REJECTED && value instanceof Error) {\n                        // check if longStackTraceZone is here\n                        var trace = Zone.currentTask && Zone.currentTask.data &&\n                            Zone.currentTask.data[creationTrace];\n                        if (trace) {\n                            // only keep the long stack trace into error when in longStackTraceZone\n                            ObjectDefineProperty(value, CURRENT_TASK_TRACE_SYMBOL, { configurable: true, enumerable: false, writable: true, value: trace });\n                        }\n                    }\n                    for (var i = 0; i < queue.length;) {\n                        scheduleResolveOrReject(promise, queue[i++], queue[i++], queue[i++], queue[i++]);\n                    }\n                    if (queue.length == 0 && state == REJECTED) {\n                        promise[symbolState] = REJECTED_NO_CATCH;\n                        var uncaughtPromiseError = value;\n                        try {\n                            // Here we throws a new Error to print more readable error log\n                            // and if the value is not an error, zone.js builds an `Error`\n                            // Object here to attach the stack information.\n                            throw new Error('Uncaught (in promise): ' + readableObjectToString(value) +\n                                (value && value.stack ? '\\n' + value.stack : ''));\n                        }\n                        catch (err) {\n                            uncaughtPromiseError = err;\n                        }\n                        if (isDisableWrappingUncaughtPromiseRejection) {\n                            // If disable wrapping uncaught promise reject\n                            // use the value instead of wrapping it.\n                            uncaughtPromiseError.throwOriginal = true;\n                        }\n                        uncaughtPromiseError.rejection = value;\n                        uncaughtPromiseError.promise = promise;\n                        uncaughtPromiseError.zone = Zone.current;\n                        uncaughtPromiseError.task = Zone.currentTask;\n                        _uncaughtPromiseErrors.push(uncaughtPromiseError);\n                        api.scheduleMicroTask(); // to make sure that it is running\n                    }\n                }\n            }\n            // Resolving an already resolved promise is a noop.\n            return promise;\n        }\n        var REJECTION_HANDLED_HANDLER = __symbol__('rejectionHandledHandler');\n        function clearRejectedNoCatch(promise) {\n            if (promise[symbolState] === REJECTED_NO_CATCH) {\n                // if the promise is rejected no catch status\n                // and queue.length > 0, means there is a error handler\n                // here to handle the rejected promise, we should trigger\n                // windows.rejectionhandled eventHandler or nodejs rejectionHandled\n                // eventHandler\n                try {\n                    var handler = Zone[REJECTION_HANDLED_HANDLER];\n                    if (handler && typeof handler === 'function') {\n                        handler.call(this, { rejection: promise[symbolValue], promise: promise });\n                    }\n                }\n                catch (err) {\n                }\n                promise[symbolState] = REJECTED;\n                for (var i = 0; i < _uncaughtPromiseErrors.length; i++) {\n                    if (promise === _uncaughtPromiseErrors[i].promise) {\n                        _uncaughtPromiseErrors.splice(i, 1);\n                    }\n                }\n            }\n        }\n        function scheduleResolveOrReject(promise, zone, chainPromise, onFulfilled, onRejected) {\n            clearRejectedNoCatch(promise);\n            var promiseState = promise[symbolState];\n            var delegate = promiseState ?\n                (typeof onFulfilled === 'function') ? onFulfilled : forwardResolution :\n                (typeof onRejected === 'function') ? onRejected : forwardRejection;\n            zone.scheduleMicroTask(source, function () {\n                try {\n                    var parentPromiseValue = promise[symbolValue];\n                    var isFinallyPromise = !!chainPromise && symbolFinally === chainPromise[symbolFinally];\n                    if (isFinallyPromise) {\n                        // if the promise is generated from finally call, keep parent promise's state and value\n                        chainPromise[symbolParentPromiseValue] = parentPromiseValue;\n                        chainPromise[symbolParentPromiseState] = promiseState;\n                    }\n                    // should not pass value to finally callback\n                    var value = zone.run(delegate, undefined, isFinallyPromise && delegate !== forwardRejection && delegate !== forwardResolution ?\n                        [] :\n                        [parentPromiseValue]);\n                    resolvePromise(chainPromise, true, value);\n                }\n                catch (error) {\n                    // if error occurs, should always return this error\n                    resolvePromise(chainPromise, false, error);\n                }\n            }, chainPromise);\n        }\n        var ZONE_AWARE_PROMISE_TO_STRING = 'function ZoneAwarePromise() { [native code] }';\n        var noop = function () { };\n        var ZoneAwarePromise = /** @class */ (function () {\n            function ZoneAwarePromise(executor) {\n                var promise = this;\n                if (!(promise instanceof ZoneAwarePromise)) {\n                    throw new Error('Must be an instanceof Promise.');\n                }\n                promise[symbolState] = UNRESOLVED;\n                promise[symbolValue] = []; // queue;\n                try {\n                    executor && executor(makeResolver(promise, RESOLVED), makeResolver(promise, REJECTED));\n                }\n                catch (error) {\n                    resolvePromise(promise, false, error);\n                }\n            }\n            ZoneAwarePromise.toString = function () {\n                return ZONE_AWARE_PROMISE_TO_STRING;\n            };\n            ZoneAwarePromise.resolve = function (value) {\n                return resolvePromise(new this(null), RESOLVED, value);\n            };\n            ZoneAwarePromise.reject = function (error) {\n                return resolvePromise(new this(null), REJECTED, error);\n            };\n            ZoneAwarePromise.race = function (values) {\n                var resolve;\n                var reject;\n                var promise = new this(function (res, rej) {\n                    resolve = res;\n                    reject = rej;\n                });\n                function onResolve(value) {\n                    resolve(value);\n                }\n                function onReject(error) {\n                    reject(error);\n                }\n                for (var _i = 0, values_1 = values; _i < values_1.length; _i++) {\n                    var value = values_1[_i];\n                    if (!isThenable(value)) {\n                        value = this.resolve(value);\n                    }\n                    value.then(onResolve, onReject);\n                }\n                return promise;\n            };\n            ZoneAwarePromise.all = function (values) {\n                return ZoneAwarePromise.allWithCallback(values);\n            };\n            ZoneAwarePromise.allSettled = function (values) {\n                var P = this && this.prototype instanceof ZoneAwarePromise ? this : ZoneAwarePromise;\n                return P.allWithCallback(values, {\n                    thenCallback: function (value) { return ({ status: 'fulfilled', value: value }); },\n                    errorCallback: function (err) { return ({ status: 'rejected', reason: err }); }\n                });\n            };\n            ZoneAwarePromise.allWithCallback = function (values, callback) {\n                var resolve;\n                var reject;\n                var promise = new this(function (res, rej) {\n                    resolve = res;\n                    reject = rej;\n                });\n                // Start at 2 to prevent prematurely resolving if .then is called immediately.\n                var unresolvedCount = 2;\n                var valueIndex = 0;\n                var resolvedValues = [];\n                var _loop_3 = function (value) {\n                    if (!isThenable(value)) {\n                        value = this_1.resolve(value);\n                    }\n                    var curValueIndex = valueIndex;\n                    try {\n                        value.then(function (value) {\n                            resolvedValues[curValueIndex] = callback ? callback.thenCallback(value) : value;\n                            unresolvedCount--;\n                            if (unresolvedCount === 0) {\n                                resolve(resolvedValues);\n                            }\n                        }, function (err) {\n                            if (!callback) {\n                                reject(err);\n                            }\n                            else {\n                                resolvedValues[curValueIndex] = callback.errorCallback(err);\n                                unresolvedCount--;\n                                if (unresolvedCount === 0) {\n                                    resolve(resolvedValues);\n                                }\n                            }\n                        });\n                    }\n                    catch (thenErr) {\n                        reject(thenErr);\n                    }\n                    unresolvedCount++;\n                    valueIndex++;\n                };\n                var this_1 = this;\n                for (var _i = 0, values_2 = values; _i < values_2.length; _i++) {\n                    var value = values_2[_i];\n                    _loop_3(value);\n                }\n                // Make the unresolvedCount zero-based again.\n                unresolvedCount -= 2;\n                if (unresolvedCount === 0) {\n                    resolve(resolvedValues);\n                }\n                return promise;\n            };\n            Object.defineProperty(ZoneAwarePromise.prototype, Symbol.toStringTag, {\n                get: function () {\n                    return 'Promise';\n                },\n                enumerable: false,\n                configurable: true\n            });\n            Object.defineProperty(ZoneAwarePromise.prototype, Symbol.species, {\n                get: function () {\n                    return ZoneAwarePromise;\n                },\n                enumerable: false,\n                configurable: true\n            });\n            ZoneAwarePromise.prototype.then = function (onFulfilled, onRejected) {\n                var C = this.constructor[Symbol.species];\n                if (!C || typeof C !== 'function') {\n                    C = this.constructor || ZoneAwarePromise;\n                }\n                var chainPromise = new C(noop);\n                var zone = Zone.current;\n                if (this[symbolState] == UNRESOLVED) {\n                    this[symbolValue].push(zone, chainPromise, onFulfilled, onRejected);\n                }\n                else {\n                    scheduleResolveOrReject(this, zone, chainPromise, onFulfilled, onRejected);\n                }\n                return chainPromise;\n            };\n            ZoneAwarePromise.prototype.catch = function (onRejected) {\n                return this.then(null, onRejected);\n            };\n            ZoneAwarePromise.prototype.finally = function (onFinally) {\n                var C = this.constructor[Symbol.species];\n                if (!C || typeof C !== 'function') {\n                    C = ZoneAwarePromise;\n                }\n                var chainPromise = new C(noop);\n                chainPromise[symbolFinally] = symbolFinally;\n                var zone = Zone.current;\n                if (this[symbolState] == UNRESOLVED) {\n                    this[symbolValue].push(zone, chainPromise, onFinally, onFinally);\n                }\n                else {\n                    scheduleResolveOrReject(this, zone, chainPromise, onFinally, onFinally);\n                }\n                return chainPromise;\n            };\n            return ZoneAwarePromise;\n        }());\n        // Protect against aggressive optimizers dropping seemingly unused properties.\n        // E.g. Closure Compiler in advanced mode.\n        ZoneAwarePromise['resolve'] = ZoneAwarePromise.resolve;\n        ZoneAwarePromise['reject'] = ZoneAwarePromise.reject;\n        ZoneAwarePromise['race'] = ZoneAwarePromise.race;\n        ZoneAwarePromise['all'] = ZoneAwarePromise.all;\n        var NativePromise = global[symbolPromise] = global['Promise'];\n        global['Promise'] = ZoneAwarePromise;\n        var symbolThenPatched = __symbol__('thenPatched');\n        function patchThen(Ctor) {\n            var proto = Ctor.prototype;\n            var prop = ObjectGetOwnPropertyDescriptor(proto, 'then');\n            if (prop && (prop.writable === false || !prop.configurable)) {\n                // check Ctor.prototype.then propertyDescriptor is writable or not\n                // in meteor env, writable is false, we should ignore such case\n                return;\n            }\n            var originalThen = proto.then;\n            // Keep a reference to the original method.\n            proto[symbolThen] = originalThen;\n            Ctor.prototype.then = function (onResolve, onReject) {\n                var _this = this;\n                var wrapped = new ZoneAwarePromise(function (resolve, reject) {\n                    originalThen.call(_this, resolve, reject);\n                });\n                return wrapped.then(onResolve, onReject);\n            };\n            Ctor[symbolThenPatched] = true;\n        }\n        api.patchThen = patchThen;\n        function zoneify(fn) {\n            return function (self, args) {\n                var resultPromise = fn.apply(self, args);\n                if (resultPromise instanceof ZoneAwarePromise) {\n                    return resultPromise;\n                }\n                var ctor = resultPromise.constructor;\n                if (!ctor[symbolThenPatched]) {\n                    patchThen(ctor);\n                }\n                return resultPromise;\n            };\n        }\n        if (NativePromise) {\n            patchThen(NativePromise);\n            patchMethod(global, 'fetch', function (delegate) { return zoneify(delegate); });\n        }\n        // This is not part of public API, but it is useful for tests, so we expose it.\n        Promise[Zone.__symbol__('uncaughtPromiseErrors')] = _uncaughtPromiseErrors;\n        return ZoneAwarePromise;\n    });\n    /**\n     * @license\n     * Copyright Google LLC All Rights Reserved.\n     *\n     * Use of this source code is governed by an MIT-style license that can be\n     * found in the LICENSE file at https://angular.io/license\n     */\n    // override Function.prototype.toString to make zone.js patched function\n    // look like native function\n    Zone.__load_patch('toString', function (global) {\n        // patch Func.prototype.toString to let them look like native\n        var originalFunctionToString = Function.prototype.toString;\n        var ORIGINAL_DELEGATE_SYMBOL = zoneSymbol('OriginalDelegate');\n        var PROMISE_SYMBOL = zoneSymbol('Promise');\n        var ERROR_SYMBOL = zoneSymbol('Error');\n        var newFunctionToString = function toString() {\n            if (typeof this === 'function') {\n                var originalDelegate = this[ORIGINAL_DELEGATE_SYMBOL];\n                if (originalDelegate) {\n                    if (typeof originalDelegate === 'function') {\n                        return originalFunctionToString.call(originalDelegate);\n                    }\n                    else {\n                        return Object.prototype.toString.call(originalDelegate);\n                    }\n                }\n                if (this === Promise) {\n                    var nativePromise = global[PROMISE_SYMBOL];\n                    if (nativePromise) {\n                        return originalFunctionToString.call(nativePromise);\n                    }\n                }\n                if (this === Error) {\n                    var nativeError = global[ERROR_SYMBOL];\n                    if (nativeError) {\n                        return originalFunctionToString.call(nativeError);\n                    }\n                }\n            }\n            return originalFunctionToString.call(this);\n        };\n        newFunctionToString[ORIGINAL_DELEGATE_SYMBOL] = originalFunctionToString;\n        Function.prototype.toString = newFunctionToString;\n        // patch Object.prototype.toString to let them look like native\n        var originalObjectToString = Object.prototype.toString;\n        var PROMISE_OBJECT_TO_STRING = '[object Promise]';\n        Object.prototype.toString = function () {\n            if (typeof Promise === 'function' && this instanceof Promise) {\n                return PROMISE_OBJECT_TO_STRING;\n            }\n            return originalObjectToString.call(this);\n        };\n    });\n    /**\n     * @license\n     * Copyright Google LLC All Rights Reserved.\n     *\n     * Use of this source code is governed by an MIT-style license that can be\n     * found in the LICENSE file at https://angular.io/license\n     */\n    var passiveSupported = false;\n    if (typeof window !== 'undefined') {\n        try {\n            var options = Object.defineProperty({}, 'passive', {\n                get: function () {\n                    passiveSupported = true;\n                }\n            });\n            window.addEventListener('test', options, options);\n            window.removeEventListener('test', options, options);\n        }\n        catch (err) {\n            passiveSupported = false;\n        }\n    }\n    // an identifier to tell ZoneTask do not create a new invoke closure\n    var OPTIMIZED_ZONE_EVENT_TASK_DATA = {\n        useG: true\n    };\n    var zoneSymbolEventNames$1 = {};\n    var globalSources = {};\n    var EVENT_NAME_SYMBOL_REGX = new RegExp('^' + ZONE_SYMBOL_PREFIX + '(\\\\w+)(true|false)$');\n    var IMMEDIATE_PROPAGATION_SYMBOL = zoneSymbol('propagationStopped');\n    function prepareEventNames(eventName, eventNameToString) {\n        var falseEventName = (eventNameToString ? eventNameToString(eventName) : eventName) + FALSE_STR;\n        var trueEventName = (eventNameToString ? eventNameToString(eventName) : eventName) + TRUE_STR;\n        var symbol = ZONE_SYMBOL_PREFIX + falseEventName;\n        var symbolCapture = ZONE_SYMBOL_PREFIX + trueEventName;\n        zoneSymbolEventNames$1[eventName] = {};\n        zoneSymbolEventNames$1[eventName][FALSE_STR] = symbol;\n        zoneSymbolEventNames$1[eventName][TRUE_STR] = symbolCapture;\n    }\n    function patchEventTarget(_global, apis, patchOptions) {\n        var ADD_EVENT_LISTENER = (patchOptions && patchOptions.add) || ADD_EVENT_LISTENER_STR;\n        var REMOVE_EVENT_LISTENER = (patchOptions && patchOptions.rm) || REMOVE_EVENT_LISTENER_STR;\n        var LISTENERS_EVENT_LISTENER = (patchOptions && patchOptions.listeners) || 'eventListeners';\n        var REMOVE_ALL_LISTENERS_EVENT_LISTENER = (patchOptions && patchOptions.rmAll) || 'removeAllListeners';\n        var zoneSymbolAddEventListener = zoneSymbol(ADD_EVENT_LISTENER);\n        var ADD_EVENT_LISTENER_SOURCE = '.' + ADD_EVENT_LISTENER + ':';\n        var PREPEND_EVENT_LISTENER = 'prependListener';\n        var PREPEND_EVENT_LISTENER_SOURCE = '.' + PREPEND_EVENT_LISTENER + ':';\n        var invokeTask = function (task, target, event) {\n            // for better performance, check isRemoved which is set\n            // by removeEventListener\n            if (task.isRemoved) {\n                return;\n            }\n            var delegate = task.callback;\n            if (typeof delegate === 'object' && delegate.handleEvent) {\n                // create the bind version of handleEvent when invoke\n                task.callback = function (event) { return delegate.handleEvent(event); };\n                task.originalDelegate = delegate;\n            }\n            // invoke static task.invoke\n            task.invoke(task, target, [event]);\n            var options = task.options;\n            if (options && typeof options === 'object' && options.once) {\n                // if options.once is true, after invoke once remove listener here\n                // only browser need to do this, nodejs eventEmitter will cal removeListener\n                // inside EventEmitter.once\n                var delegate_1 = task.originalDelegate ? task.originalDelegate : task.callback;\n                target[REMOVE_EVENT_LISTENER].call(target, event.type, delegate_1, options);\n            }\n        };\n        // global shared zoneAwareCallback to handle all event callback with capture = false\n        var globalZoneAwareCallback = function (event) {\n            // https://github.com/angular/zone.js/issues/911, in IE, sometimes\n            // event will be undefined, so we need to use window.event\n            event = event || _global.event;\n            if (!event) {\n                return;\n            }\n            // event.target is needed for Samsung TV and SourceBuffer\n            // || global is needed https://github.com/angular/zone.js/issues/190\n            var target = this || event.target || _global;\n            var tasks = target[zoneSymbolEventNames$1[event.type][FALSE_STR]];\n            if (tasks) {\n                // invoke all tasks which attached to current target with given event.type and capture = false\n                // for performance concern, if task.length === 1, just invoke\n                if (tasks.length === 1) {\n                    invokeTask(tasks[0], target, event);\n                }\n                else {\n                    // https://github.com/angular/zone.js/issues/836\n                    // copy the tasks array before invoke, to avoid\n                    // the callback will remove itself or other listener\n                    var copyTasks = tasks.slice();\n                    for (var i = 0; i < copyTasks.length; i++) {\n                        if (event && event[IMMEDIATE_PROPAGATION_SYMBOL] === true) {\n                            break;\n                        }\n                        invokeTask(copyTasks[i], target, event);\n                    }\n                }\n            }\n        };\n        // global shared zoneAwareCallback to handle all event callback with capture = true\n        var globalZoneAwareCaptureCallback = function (event) {\n            // https://github.com/angular/zone.js/issues/911, in IE, sometimes\n            // event will be undefined, so we need to use window.event\n            event = event || _global.event;\n            if (!event) {\n                return;\n            }\n            // event.target is needed for Samsung TV and SourceBuffer\n            // || global is needed https://github.com/angular/zone.js/issues/190\n            var target = this || event.target || _global;\n            var tasks = target[zoneSymbolEventNames$1[event.type][TRUE_STR]];\n            if (tasks) {\n                // invoke all tasks which attached to current target with given event.type and capture = false\n                // for performance concern, if task.length === 1, just invoke\n                if (tasks.length === 1) {\n                    invokeTask(tasks[0], target, event);\n                }\n                else {\n                    // https://github.com/angular/zone.js/issues/836\n                    // copy the tasks array before invoke, to avoid\n                    // the callback will remove itself or other listener\n                    var copyTasks = tasks.slice();\n                    for (var i = 0; i < copyTasks.length; i++) {\n                        if (event && event[IMMEDIATE_PROPAGATION_SYMBOL] === true) {\n                            break;\n                        }\n                        invokeTask(copyTasks[i], target, event);\n                    }\n                }\n            }\n        };\n        function patchEventTargetMethods(obj, patchOptions) {\n            if (!obj) {\n                return false;\n            }\n            var useGlobalCallback = true;\n            if (patchOptions && patchOptions.useG !== undefined) {\n                useGlobalCallback = patchOptions.useG;\n            }\n            var validateHandler = patchOptions && patchOptions.vh;\n            var checkDuplicate = true;\n            if (patchOptions && patchOptions.chkDup !== undefined) {\n                checkDuplicate = patchOptions.chkDup;\n            }\n            var returnTarget = false;\n            if (patchOptions && patchOptions.rt !== undefined) {\n                returnTarget = patchOptions.rt;\n            }\n            var proto = obj;\n            while (proto && !proto.hasOwnProperty(ADD_EVENT_LISTENER)) {\n                proto = ObjectGetPrototypeOf(proto);\n            }\n            if (!proto && obj[ADD_EVENT_LISTENER]) {\n                // somehow we did not find it, but we can see it. This happens on IE for Window properties.\n                proto = obj;\n            }\n            if (!proto) {\n                return false;\n            }\n            if (proto[zoneSymbolAddEventListener]) {\n                return false;\n            }\n            var eventNameToString = patchOptions && patchOptions.eventNameToString;\n            // a shared global taskData to pass data for scheduleEventTask\n            // so we do not need to create a new object just for pass some data\n            var taskData = {};\n            var nativeAddEventListener = proto[zoneSymbolAddEventListener] = proto[ADD_EVENT_LISTENER];\n            var nativeRemoveEventListener = proto[zoneSymbol(REMOVE_EVENT_LISTENER)] =\n                proto[REMOVE_EVENT_LISTENER];\n            var nativeListeners = proto[zoneSymbol(LISTENERS_EVENT_LISTENER)] =\n                proto[LISTENERS_EVENT_LISTENER];\n            var nativeRemoveAllListeners = proto[zoneSymbol(REMOVE_ALL_LISTENERS_EVENT_LISTENER)] =\n                proto[REMOVE_ALL_LISTENERS_EVENT_LISTENER];\n            var nativePrependEventListener;\n            if (patchOptions && patchOptions.prepend) {\n                nativePrependEventListener = proto[zoneSymbol(patchOptions.prepend)] =\n                    proto[patchOptions.prepend];\n            }\n            /**\n             * This util function will build an option object with passive option\n             * to handle all possible input from the user.\n             */\n            function buildEventListenerOptions(options, passive) {\n                if (!passiveSupported && typeof options === 'object' && options) {\n                    // doesn't support passive but user want to pass an object as options.\n                    // this will not work on some old browser, so we just pass a boolean\n                    // as useCapture parameter\n                    return !!options.capture;\n                }\n                if (!passiveSupported || !passive) {\n                    return options;\n                }\n                if (typeof options === 'boolean') {\n                    return { capture: options, passive: true };\n                }\n                if (!options) {\n                    return { passive: true };\n                }\n                if (typeof options === 'object' && options.passive !== false) {\n                    return Object.assign(Object.assign({}, options), { passive: true });\n                }\n                return options;\n            }\n            var customScheduleGlobal = function (task) {\n                // if there is already a task for the eventName + capture,\n                // just return, because we use the shared globalZoneAwareCallback here.\n                if (taskData.isExisting) {\n                    return;\n                }\n                return nativeAddEventListener.call(taskData.target, taskData.eventName, taskData.capture ? globalZoneAwareCaptureCallback : globalZoneAwareCallback, taskData.options);\n            };\n            var customCancelGlobal = function (task) {\n                // if task is not marked as isRemoved, this call is directly\n                // from Zone.prototype.cancelTask, we should remove the task\n                // from tasksList of target first\n                if (!task.isRemoved) {\n                    var symbolEventNames = zoneSymbolEventNames$1[task.eventName];\n                    var symbolEventName = void 0;\n                    if (symbolEventNames) {\n                        symbolEventName = symbolEventNames[task.capture ? TRUE_STR : FALSE_STR];\n                    }\n                    var existingTasks = symbolEventName && task.target[symbolEventName];\n                    if (existingTasks) {\n                        for (var i = 0; i < existingTasks.length; i++) {\n                            var existingTask = existingTasks[i];\n                            if (existingTask === task) {\n                                existingTasks.splice(i, 1);\n                                // set isRemoved to data for faster invokeTask check\n                                task.isRemoved = true;\n                                if (existingTasks.length === 0) {\n                                    // all tasks for the eventName + capture have gone,\n                                    // remove globalZoneAwareCallback and remove the task cache from target\n                                    task.allRemoved = true;\n                                    task.target[symbolEventName] = null;\n                                }\n                                break;\n                            }\n                        }\n                    }\n                }\n                // if all tasks for the eventName + capture have gone,\n                // we will really remove the global event callback,\n                // if not, return\n                if (!task.allRemoved) {\n                    return;\n                }\n                return nativeRemoveEventListener.call(task.target, task.eventName, task.capture ? globalZoneAwareCaptureCallback : globalZoneAwareCallback, task.options);\n            };\n            var customScheduleNonGlobal = function (task) {\n                return nativeAddEventListener.call(taskData.target, taskData.eventName, task.invoke, taskData.options);\n            };\n            var customSchedulePrepend = function (task) {\n                return nativePrependEventListener.call(taskData.target, taskData.eventName, task.invoke, taskData.options);\n            };\n            var customCancelNonGlobal = function (task) {\n                return nativeRemoveEventListener.call(task.target, task.eventName, task.invoke, task.options);\n            };\n            var customSchedule = useGlobalCallback ? customScheduleGlobal : customScheduleNonGlobal;\n            var customCancel = useGlobalCallback ? customCancelGlobal : customCancelNonGlobal;\n            var compareTaskCallbackVsDelegate = function (task, delegate) {\n                var typeOfDelegate = typeof delegate;\n                return (typeOfDelegate === 'function' && task.callback === delegate) ||\n                    (typeOfDelegate === 'object' && task.originalDelegate === delegate);\n            };\n            var compare = (patchOptions && patchOptions.diff) ? patchOptions.diff : compareTaskCallbackVsDelegate;\n            var unpatchedEvents = Zone[zoneSymbol('UNPATCHED_EVENTS')];\n            var passiveEvents = _global[zoneSymbol('PASSIVE_EVENTS')];\n            var makeAddListener = function (nativeListener, addSource, customScheduleFn, customCancelFn, returnTarget, prepend) {\n                if (returnTarget === void 0) { returnTarget = false; }\n                if (prepend === void 0) { prepend = false; }\n                return function () {\n                    var target = this || _global;\n                    var eventName = arguments[0];\n                    if (patchOptions && patchOptions.transferEventName) {\n                        eventName = patchOptions.transferEventName(eventName);\n                    }\n                    var delegate = arguments[1];\n                    if (!delegate) {\n                        return nativeListener.apply(this, arguments);\n                    }\n                    if (isNode && eventName === 'uncaughtException') {\n                        // don't patch uncaughtException of nodejs to prevent endless loop\n                        return nativeListener.apply(this, arguments);\n                    }\n                    // don't create the bind delegate function for handleEvent\n                    // case here to improve addEventListener performance\n                    // we will create the bind delegate when invoke\n                    var isHandleEvent = false;\n                    if (typeof delegate !== 'function') {\n                        if (!delegate.handleEvent) {\n                            return nativeListener.apply(this, arguments);\n                        }\n                        isHandleEvent = true;\n                    }\n                    if (validateHandler && !validateHandler(nativeListener, delegate, target, arguments)) {\n                        return;\n                    }\n                    var passive = passiveSupported && !!passiveEvents && passiveEvents.indexOf(eventName) !== -1;\n                    var options = buildEventListenerOptions(arguments[2], passive);\n                    if (unpatchedEvents) {\n                        // check upatched list\n                        for (var i = 0; i < unpatchedEvents.length; i++) {\n                            if (eventName === unpatchedEvents[i]) {\n                                if (passive) {\n                                    return nativeListener.call(target, eventName, delegate, options);\n                                }\n                                else {\n                                    return nativeListener.apply(this, arguments);\n                                }\n                            }\n                        }\n                    }\n                    var capture = !options ? false : typeof options === 'boolean' ? true : options.capture;\n                    var once = options && typeof options === 'object' ? options.once : false;\n                    var zone = Zone.current;\n                    var symbolEventNames = zoneSymbolEventNames$1[eventName];\n                    if (!symbolEventNames) {\n                        prepareEventNames(eventName, eventNameToString);\n                        symbolEventNames = zoneSymbolEventNames$1[eventName];\n                    }\n                    var symbolEventName = symbolEventNames[capture ? TRUE_STR : FALSE_STR];\n                    var existingTasks = target[symbolEventName];\n                    var isExisting = false;\n                    if (existingTasks) {\n                        // already have task registered\n                        isExisting = true;\n                        if (checkDuplicate) {\n                            for (var i = 0; i < existingTasks.length; i++) {\n                                if (compare(existingTasks[i], delegate)) {\n                                    // same callback, same capture, same event name, just return\n                                    return;\n                                }\n                            }\n                        }\n                    }\n                    else {\n                        existingTasks = target[symbolEventName] = [];\n                    }\n                    var source;\n                    var constructorName = target.constructor['name'];\n                    var targetSource = globalSources[constructorName];\n                    if (targetSource) {\n                        source = targetSource[eventName];\n                    }\n                    if (!source) {\n                        source = constructorName + addSource +\n                            (eventNameToString ? eventNameToString(eventName) : eventName);\n                    }\n                    // do not create a new object as task.data to pass those things\n                    // just use the global shared one\n                    taskData.options = options;\n                    if (once) {\n                        // if addEventListener with once options, we don't pass it to\n                        // native addEventListener, instead we keep the once setting\n                        // and handle ourselves.\n                        taskData.options.once = false;\n                    }\n                    taskData.target = target;\n                    taskData.capture = capture;\n                    taskData.eventName = eventName;\n                    taskData.isExisting = isExisting;\n                    var data = useGlobalCallback ? OPTIMIZED_ZONE_EVENT_TASK_DATA : undefined;\n                    // keep taskData into data to allow onScheduleEventTask to access the task information\n                    if (data) {\n                        data.taskData = taskData;\n                    }\n                    var task = zone.scheduleEventTask(source, delegate, data, customScheduleFn, customCancelFn);\n                    // should clear taskData.target to avoid memory leak\n                    // issue, https://github.com/angular/angular/issues/20442\n                    taskData.target = null;\n                    // need to clear up taskData because it is a global object\n                    if (data) {\n                        data.taskData = null;\n                    }\n                    // have to save those information to task in case\n                    // application may call task.zone.cancelTask() directly\n                    if (once) {\n                        options.once = true;\n                    }\n                    if (!(!passiveSupported && typeof task.options === 'boolean')) {\n                        // if not support passive, and we pass an option object\n                        // to addEventListener, we should save the options to task\n                        task.options = options;\n                    }\n                    task.target = target;\n                    task.capture = capture;\n                    task.eventName = eventName;\n                    if (isHandleEvent) {\n                        // save original delegate for compare to check duplicate\n                        task.originalDelegate = delegate;\n                    }\n                    if (!prepend) {\n                        existingTasks.push(task);\n                    }\n                    else {\n                        existingTasks.unshift(task);\n                    }\n                    if (returnTarget) {\n                        return target;\n                    }\n                };\n            };\n            proto[ADD_EVENT_LISTENER] = makeAddListener(nativeAddEventListener, ADD_EVENT_LISTENER_SOURCE, customSchedule, customCancel, returnTarget);\n            if (nativePrependEventListener) {\n                proto[PREPEND_EVENT_LISTENER] = makeAddListener(nativePrependEventListener, PREPEND_EVENT_LISTENER_SOURCE, customSchedulePrepend, customCancel, returnTarget, true);\n            }\n            proto[REMOVE_EVENT_LISTENER] = function () {\n                var target = this || _global;\n                var eventName = arguments[0];\n                if (patchOptions && patchOptions.transferEventName) {\n                    eventName = patchOptions.transferEventName(eventName);\n                }\n                var options = arguments[2];\n                var capture = !options ? false : typeof options === 'boolean' ? true : options.capture;\n                var delegate = arguments[1];\n                if (!delegate) {\n                    return nativeRemoveEventListener.apply(this, arguments);\n                }\n                if (validateHandler &&\n                    !validateHandler(nativeRemoveEventListener, delegate, target, arguments)) {\n                    return;\n                }\n                var symbolEventNames = zoneSymbolEventNames$1[eventName];\n                var symbolEventName;\n                if (symbolEventNames) {\n                    symbolEventName = symbolEventNames[capture ? TRUE_STR : FALSE_STR];\n                }\n                var existingTasks = symbolEventName && target[symbolEventName];\n                if (existingTasks) {\n                    for (var i = 0; i < existingTasks.length; i++) {\n                        var existingTask = existingTasks[i];\n                        if (compare(existingTask, delegate)) {\n                            existingTasks.splice(i, 1);\n                            // set isRemoved to data for faster invokeTask check\n                            existingTask.isRemoved = true;\n                            if (existingTasks.length === 0) {\n                                // all tasks for the eventName + capture have gone,\n                                // remove globalZoneAwareCallback and remove the task cache from target\n                                existingTask.allRemoved = true;\n                                target[symbolEventName] = null;\n                                // in the target, we have an event listener which is added by on_property\n                                // such as target.onclick = function() {}, so we need to clear this internal\n                                // property too if all delegates all removed\n                                if (typeof eventName === 'string') {\n                                    var onPropertySymbol = ZONE_SYMBOL_PREFIX + 'ON_PROPERTY' + eventName;\n                                    target[onPropertySymbol] = null;\n                                }\n                            }\n                            existingTask.zone.cancelTask(existingTask);\n                            if (returnTarget) {\n                                return target;\n                            }\n                            return;\n                        }\n                    }\n                }\n                // issue 930, didn't find the event name or callback\n                // from zone kept existingTasks, the callback maybe\n                // added outside of zone, we need to call native removeEventListener\n                // to try to remove it.\n                return nativeRemoveEventListener.apply(this, arguments);\n            };\n            proto[LISTENERS_EVENT_LISTENER] = function () {\n                var target = this || _global;\n                var eventName = arguments[0];\n                if (patchOptions && patchOptions.transferEventName) {\n                    eventName = patchOptions.transferEventName(eventName);\n                }\n                var listeners = [];\n                var tasks = findEventTasks(target, eventNameToString ? eventNameToString(eventName) : eventName);\n                for (var i = 0; i < tasks.length; i++) {\n                    var task = tasks[i];\n                    var delegate = task.originalDelegate ? task.originalDelegate : task.callback;\n                    listeners.push(delegate);\n                }\n                return listeners;\n            };\n            proto[REMOVE_ALL_LISTENERS_EVENT_LISTENER] = function () {\n                var target = this || _global;\n                var eventName = arguments[0];\n                if (!eventName) {\n                    var keys = Object.keys(target);\n                    for (var i = 0; i < keys.length; i++) {\n                        var prop = keys[i];\n                        var match = EVENT_NAME_SYMBOL_REGX.exec(prop);\n                        var evtName = match && match[1];\n                        // in nodejs EventEmitter, removeListener event is\n                        // used for monitoring the removeListener call,\n                        // so just keep removeListener eventListener until\n                        // all other eventListeners are removed\n                        if (evtName && evtName !== 'removeListener') {\n                            this[REMOVE_ALL_LISTENERS_EVENT_LISTENER].call(this, evtName);\n                        }\n                    }\n                    // remove removeListener listener finally\n                    this[REMOVE_ALL_LISTENERS_EVENT_LISTENER].call(this, 'removeListener');\n                }\n                else {\n                    if (patchOptions && patchOptions.transferEventName) {\n                        eventName = patchOptions.transferEventName(eventName);\n                    }\n                    var symbolEventNames = zoneSymbolEventNames$1[eventName];\n                    if (symbolEventNames) {\n                        var symbolEventName = symbolEventNames[FALSE_STR];\n                        var symbolCaptureEventName = symbolEventNames[TRUE_STR];\n                        var tasks = target[symbolEventName];\n                        var captureTasks = target[symbolCaptureEventName];\n                        if (tasks) {\n                            var removeTasks = tasks.slice();\n                            for (var i = 0; i < removeTasks.length; i++) {\n                                var task = removeTasks[i];\n                                var delegate = task.originalDelegate ? task.originalDelegate : task.callback;\n                                this[REMOVE_EVENT_LISTENER].call(this, eventName, delegate, task.options);\n                            }\n                        }\n                        if (captureTasks) {\n                            var removeTasks = captureTasks.slice();\n                            for (var i = 0; i < removeTasks.length; i++) {\n                                var task = removeTasks[i];\n                                var delegate = task.originalDelegate ? task.originalDelegate : task.callback;\n                                this[REMOVE_EVENT_LISTENER].call(this, eventName, delegate, task.options);\n                            }\n                        }\n                    }\n                }\n                if (returnTarget) {\n                    return this;\n                }\n            };\n            // for native toString patch\n            attachOriginToPatched(proto[ADD_EVENT_LISTENER], nativeAddEventListener);\n            attachOriginToPatched(proto[REMOVE_EVENT_LISTENER], nativeRemoveEventListener);\n            if (nativeRemoveAllListeners) {\n                attachOriginToPatched(proto[REMOVE_ALL_LISTENERS_EVENT_LISTENER], nativeRemoveAllListeners);\n            }\n            if (nativeListeners) {\n                attachOriginToPatched(proto[LISTENERS_EVENT_LISTENER], nativeListeners);\n            }\n            return true;\n        }\n        var results = [];\n        for (var i = 0; i < apis.length; i++) {\n            results[i] = patchEventTargetMethods(apis[i], patchOptions);\n        }\n        return results;\n    }\n    function findEventTasks(target, eventName) {\n        if (!eventName) {\n            var foundTasks = [];\n            for (var prop in target) {\n                var match = EVENT_NAME_SYMBOL_REGX.exec(prop);\n                var evtName = match && match[1];\n                if (evtName && (!eventName || evtName === eventName)) {\n                    var tasks = target[prop];\n                    if (tasks) {\n                        for (var i = 0; i < tasks.length; i++) {\n                            foundTasks.push(tasks[i]);\n                        }\n                    }\n                }\n            }\n            return foundTasks;\n        }\n        var symbolEventName = zoneSymbolEventNames$1[eventName];\n        if (!symbolEventName) {\n            prepareEventNames(eventName);\n            symbolEventName = zoneSymbolEventNames$1[eventName];\n        }\n        var captureFalseTasks = target[symbolEventName[FALSE_STR]];\n        var captureTrueTasks = target[symbolEventName[TRUE_STR]];\n        if (!captureFalseTasks) {\n            return captureTrueTasks ? captureTrueTasks.slice() : [];\n        }\n        else {\n            return captureTrueTasks ? captureFalseTasks.concat(captureTrueTasks) :\n                captureFalseTasks.slice();\n        }\n    }\n    function patchEventPrototype(global, api) {\n        var Event = global['Event'];\n        if (Event && Event.prototype) {\n            api.patchMethod(Event.prototype, 'stopImmediatePropagation', function (delegate) { return function (self, args) {\n                self[IMMEDIATE_PROPAGATION_SYMBOL] = true;\n                // we need to call the native stopImmediatePropagation\n                // in case in some hybrid application, some part of\n                // application will be controlled by zone, some are not\n                delegate && delegate.apply(self, args);\n            }; });\n        }\n    }\n    /**\n     * @license\n     * Copyright Google LLC All Rights Reserved.\n     *\n     * Use of this source code is governed by an MIT-style license that can be\n     * found in the LICENSE file at https://angular.io/license\n     */\n    function patchCallbacks(api, target, targetName, method, callbacks) {\n        var symbol = Zone.__symbol__(method);\n        if (target[symbol]) {\n            return;\n        }\n        var nativeDelegate = target[symbol] = target[method];\n        target[method] = function (name, opts, options) {\n            if (opts && opts.prototype) {\n                callbacks.forEach(function (callback) {\n                    var source = targetName + \".\" + method + \"::\" + callback;\n                    var prototype = opts.prototype;\n                    if (prototype.hasOwnProperty(callback)) {\n                        var descriptor = api.ObjectGetOwnPropertyDescriptor(prototype, callback);\n                        if (descriptor && descriptor.value) {\n                            descriptor.value = api.wrapWithCurrentZone(descriptor.value, source);\n                            api._redefineProperty(opts.prototype, callback, descriptor);\n                        }\n                        else if (prototype[callback]) {\n                            prototype[callback] = api.wrapWithCurrentZone(prototype[callback], source);\n                        }\n                    }\n                    else if (prototype[callback]) {\n                        prototype[callback] = api.wrapWithCurrentZone(prototype[callback], source);\n                    }\n                });\n            }\n            return nativeDelegate.call(target, name, opts, options);\n        };\n        api.attachOriginToPatched(target[method], nativeDelegate);\n    }\n    /**\n     * @license\n     * Copyright Google LLC All Rights Reserved.\n     *\n     * Use of this source code is governed by an MIT-style license that can be\n     * found in the LICENSE file at https://angular.io/license\n     */\n    var globalEventHandlersEventNames = [\n        'abort',\n        'animationcancel',\n        'animationend',\n        'animationiteration',\n        'auxclick',\n        'beforeinput',\n        'blur',\n        'cancel',\n        'canplay',\n        'canplaythrough',\n        'change',\n        'compositionstart',\n        'compositionupdate',\n        'compositionend',\n        'cuechange',\n        'click',\n        'close',\n        'contextmenu',\n        'curechange',\n        'dblclick',\n        'drag',\n        'dragend',\n        'dragenter',\n        'dragexit',\n        'dragleave',\n        'dragover',\n        'drop',\n        'durationchange',\n        'emptied',\n        'ended',\n        'error',\n        'focus',\n        'focusin',\n        'focusout',\n        'gotpointercapture',\n        'input',\n        'invalid',\n        'keydown',\n        'keypress',\n        'keyup',\n        'load',\n        'loadstart',\n        'loadeddata',\n        'loadedmetadata',\n        'lostpointercapture',\n        'mousedown',\n        'mouseenter',\n        'mouseleave',\n        'mousemove',\n        'mouseout',\n        'mouseover',\n        'mouseup',\n        'mousewheel',\n        'orientationchange',\n        'pause',\n        'play',\n        'playing',\n        'pointercancel',\n        'pointerdown',\n        'pointerenter',\n        'pointerleave',\n        'pointerlockchange',\n        'mozpointerlockchange',\n        'webkitpointerlockerchange',\n        'pointerlockerror',\n        'mozpointerlockerror',\n        'webkitpointerlockerror',\n        'pointermove',\n        'pointout',\n        'pointerover',\n        'pointerup',\n        'progress',\n        'ratechange',\n        'reset',\n        'resize',\n        'scroll',\n        'seeked',\n        'seeking',\n        'select',\n        'selectionchange',\n        'selectstart',\n        'show',\n        'sort',\n        'stalled',\n        'submit',\n        'suspend',\n        'timeupdate',\n        'volumechange',\n        'touchcancel',\n        'touchmove',\n        'touchstart',\n        'touchend',\n        'transitioncancel',\n        'transitionend',\n        'waiting',\n        'wheel'\n    ];\n    var documentEventNames = [\n        'afterscriptexecute', 'beforescriptexecute', 'DOMContentLoaded', 'freeze', 'fullscreenchange',\n        'mozfullscreenchange', 'webkitfullscreenchange', 'msfullscreenchange', 'fullscreenerror',\n        'mozfullscreenerror', 'webkitfullscreenerror', 'msfullscreenerror', 'readystatechange',\n        'visibilitychange', 'resume'\n    ];\n    var windowEventNames = [\n        'absolutedeviceorientation',\n        'afterinput',\n        'afterprint',\n        'appinstalled',\n        'beforeinstallprompt',\n        'beforeprint',\n        'beforeunload',\n        'devicelight',\n        'devicemotion',\n        'deviceorientation',\n        'deviceorientationabsolute',\n        'deviceproximity',\n        'hashchange',\n        'languagechange',\n        'message',\n        'mozbeforepaint',\n        'offline',\n        'online',\n        'paint',\n        'pageshow',\n        'pagehide',\n        'popstate',\n        'rejectionhandled',\n        'storage',\n        'unhandledrejection',\n        'unload',\n        'userproximity',\n        'vrdisplayconnected',\n        'vrdisplaydisconnected',\n        'vrdisplaypresentchange'\n    ];\n    var htmlElementEventNames = [\n        'beforecopy', 'beforecut', 'beforepaste', 'copy', 'cut', 'paste', 'dragstart', 'loadend',\n        'animationstart', 'search', 'transitionrun', 'transitionstart', 'webkitanimationend',\n        'webkitanimationiteration', 'webkitanimationstart', 'webkittransitionend'\n    ];\n    var mediaElementEventNames = ['encrypted', 'waitingforkey', 'msneedkey', 'mozinterruptbegin', 'mozinterruptend'];\n    var ieElementEventNames = [\n        'activate',\n        'afterupdate',\n        'ariarequest',\n        'beforeactivate',\n        'beforedeactivate',\n        'beforeeditfocus',\n        'beforeupdate',\n        'cellchange',\n        'controlselect',\n        'dataavailable',\n        'datasetchanged',\n        'datasetcomplete',\n        'errorupdate',\n        'filterchange',\n        'layoutcomplete',\n        'losecapture',\n        'move',\n        'moveend',\n        'movestart',\n        'propertychange',\n        'resizeend',\n        'resizestart',\n        'rowenter',\n        'rowexit',\n        'rowsdelete',\n        'rowsinserted',\n        'command',\n        'compassneedscalibration',\n        'deactivate',\n        'help',\n        'mscontentzoom',\n        'msmanipulationstatechanged',\n        'msgesturechange',\n        'msgesturedoubletap',\n        'msgestureend',\n        'msgesturehold',\n        'msgesturestart',\n        'msgesturetap',\n        'msgotpointercapture',\n        'msinertiastart',\n        'mslostpointercapture',\n        'mspointercancel',\n        'mspointerdown',\n        'mspointerenter',\n        'mspointerhover',\n        'mspointerleave',\n        'mspointermove',\n        'mspointerout',\n        'mspointerover',\n        'mspointerup',\n        'pointerout',\n        'mssitemodejumplistitemremoved',\n        'msthumbnailclick',\n        'stop',\n        'storagecommit'\n    ];\n    var webglEventNames = ['webglcontextrestored', 'webglcontextlost', 'webglcontextcreationerror'];\n    var formEventNames = ['autocomplete', 'autocompleteerror'];\n    var detailEventNames = ['toggle'];\n    var frameEventNames = ['load'];\n    var frameSetEventNames = ['blur', 'error', 'focus', 'load', 'resize', 'scroll', 'messageerror'];\n    var marqueeEventNames = ['bounce', 'finish', 'start'];\n    var XMLHttpRequestEventNames = [\n        'loadstart', 'progress', 'abort', 'error', 'load', 'progress', 'timeout', 'loadend',\n        'readystatechange'\n    ];\n    var IDBIndexEventNames = ['upgradeneeded', 'complete', 'abort', 'success', 'error', 'blocked', 'versionchange', 'close'];\n    var websocketEventNames = ['close', 'error', 'open', 'message'];\n    var workerEventNames = ['error', 'message'];\n    var eventNames = globalEventHandlersEventNames.concat(webglEventNames, formEventNames, detailEventNames, documentEventNames, windowEventNames, htmlElementEventNames, ieElementEventNames);\n    function filterProperties(target, onProperties, ignoreProperties) {\n        if (!ignoreProperties || ignoreProperties.length === 0) {\n            return onProperties;\n        }\n        var tip = ignoreProperties.filter(function (ip) { return ip.target === target; });\n        if (!tip || tip.length === 0) {\n            return onProperties;\n        }\n        var targetIgnoreProperties = tip[0].ignoreProperties;\n        return onProperties.filter(function (op) { return targetIgnoreProperties.indexOf(op) === -1; });\n    }\n    function patchFilteredProperties(target, onProperties, ignoreProperties, prototype) {\n        // check whether target is available, sometimes target will be undefined\n        // because different browser or some 3rd party plugin.\n        if (!target) {\n            return;\n        }\n        var filteredProperties = filterProperties(target, onProperties, ignoreProperties);\n        patchOnProperties(target, filteredProperties, prototype);\n    }\n    function propertyDescriptorPatch(api, _global) {\n        if (isNode && !isMix) {\n            return;\n        }\n        if (Zone[api.symbol('patchEvents')]) {\n            // events are already been patched by legacy patch.\n            return;\n        }\n        var supportsWebSocket = typeof WebSocket !== 'undefined';\n        var ignoreProperties = _global['__Zone_ignore_on_properties'];\n        // for browsers that we can patch the descriptor:  Chrome & Firefox\n        if (isBrowser) {\n            var internalWindow_1 = window;\n            var ignoreErrorProperties = isIE() ? [{ target: internalWindow_1, ignoreProperties: ['error'] }] : [];\n            // in IE/Edge, onProp not exist in window object, but in WindowPrototype\n            // so we need to pass WindowPrototype to check onProp exist or not\n            patchFilteredProperties(internalWindow_1, eventNames.concat(['messageerror']), ignoreProperties ? ignoreProperties.concat(ignoreErrorProperties) : ignoreProperties, ObjectGetPrototypeOf(internalWindow_1));\n            patchFilteredProperties(Document.prototype, eventNames, ignoreProperties);\n            if (typeof internalWindow_1['SVGElement'] !== 'undefined') {\n                patchFilteredProperties(internalWindow_1['SVGElement'].prototype, eventNames, ignoreProperties);\n            }\n            patchFilteredProperties(Element.prototype, eventNames, ignoreProperties);\n            patchFilteredProperties(HTMLElement.prototype, eventNames, ignoreProperties);\n            patchFilteredProperties(HTMLMediaElement.prototype, mediaElementEventNames, ignoreProperties);\n            patchFilteredProperties(HTMLFrameSetElement.prototype, windowEventNames.concat(frameSetEventNames), ignoreProperties);\n            patchFilteredProperties(HTMLBodyElement.prototype, windowEventNames.concat(frameSetEventNames), ignoreProperties);\n            patchFilteredProperties(HTMLFrameElement.prototype, frameEventNames, ignoreProperties);\n            patchFilteredProperties(HTMLIFrameElement.prototype, frameEventNames, ignoreProperties);\n            var HTMLMarqueeElement_1 = internalWindow_1['HTMLMarqueeElement'];\n            if (HTMLMarqueeElement_1) {\n                patchFilteredProperties(HTMLMarqueeElement_1.prototype, marqueeEventNames, ignoreProperties);\n            }\n            var Worker_1 = internalWindow_1['Worker'];\n            if (Worker_1) {\n                patchFilteredProperties(Worker_1.prototype, workerEventNames, ignoreProperties);\n            }\n        }\n        var XMLHttpRequest = _global['XMLHttpRequest'];\n        if (XMLHttpRequest) {\n            // XMLHttpRequest is not available in ServiceWorker, so we need to check here\n            patchFilteredProperties(XMLHttpRequest.prototype, XMLHttpRequestEventNames, ignoreProperties);\n        }\n        var XMLHttpRequestEventTarget = _global['XMLHttpRequestEventTarget'];\n        if (XMLHttpRequestEventTarget) {\n            patchFilteredProperties(XMLHttpRequestEventTarget && XMLHttpRequestEventTarget.prototype, XMLHttpRequestEventNames, ignoreProperties);\n        }\n        if (typeof IDBIndex !== 'undefined') {\n            patchFilteredProperties(IDBIndex.prototype, IDBIndexEventNames, ignoreProperties);\n            patchFilteredProperties(IDBRequest.prototype, IDBIndexEventNames, ignoreProperties);\n            patchFilteredProperties(IDBOpenDBRequest.prototype, IDBIndexEventNames, ignoreProperties);\n            patchFilteredProperties(IDBDatabase.prototype, IDBIndexEventNames, ignoreProperties);\n            patchFilteredProperties(IDBTransaction.prototype, IDBIndexEventNames, ignoreProperties);\n            patchFilteredProperties(IDBCursor.prototype, IDBIndexEventNames, ignoreProperties);\n        }\n        if (supportsWebSocket) {\n            patchFilteredProperties(WebSocket.prototype, websocketEventNames, ignoreProperties);\n        }\n    }\n    /**\n     * @license\n     * Copyright Google LLC All Rights Reserved.\n     *\n     * Use of this source code is governed by an MIT-style license that can be\n     * found in the LICENSE file at https://angular.io/license\n     */\n    Zone.__load_patch('util', function (global, Zone, api) {\n        api.patchOnProperties = patchOnProperties;\n        api.patchMethod = patchMethod;\n        api.bindArguments = bindArguments;\n        api.patchMacroTask = patchMacroTask;\n        // In earlier version of zone.js (<0.9.0), we use env name `__zone_symbol__BLACK_LISTED_EVENTS` to\n        // define which events will not be patched by `Zone.js`.\n        // In newer version (>=0.9.0), we change the env name to `__zone_symbol__UNPATCHED_EVENTS` to keep\n        // the name consistent with angular repo.\n        // The  `__zone_symbol__BLACK_LISTED_EVENTS` is deprecated, but it is still be supported for\n        // backwards compatibility.\n        var SYMBOL_BLACK_LISTED_EVENTS = Zone.__symbol__('BLACK_LISTED_EVENTS');\n        var SYMBOL_UNPATCHED_EVENTS = Zone.__symbol__('UNPATCHED_EVENTS');\n        if (global[SYMBOL_UNPATCHED_EVENTS]) {\n            global[SYMBOL_BLACK_LISTED_EVENTS] = global[SYMBOL_UNPATCHED_EVENTS];\n        }\n        if (global[SYMBOL_BLACK_LISTED_EVENTS]) {\n            Zone[SYMBOL_BLACK_LISTED_EVENTS] = Zone[SYMBOL_UNPATCHED_EVENTS] =\n                global[SYMBOL_BLACK_LISTED_EVENTS];\n        }\n        api.patchEventPrototype = patchEventPrototype;\n        api.patchEventTarget = patchEventTarget;\n        api.isIEOrEdge = isIEOrEdge;\n        api.ObjectDefineProperty = ObjectDefineProperty;\n        api.ObjectGetOwnPropertyDescriptor = ObjectGetOwnPropertyDescriptor;\n        api.ObjectCreate = ObjectCreate;\n        api.ArraySlice = ArraySlice;\n        api.patchClass = patchClass;\n        api.wrapWithCurrentZone = wrapWithCurrentZone;\n        api.filterProperties = filterProperties;\n        api.attachOriginToPatched = attachOriginToPatched;\n        api._redefineProperty = Object.defineProperty;\n        api.patchCallbacks = patchCallbacks;\n        api.getGlobalObjects = function () { return ({\n            globalSources: globalSources,\n            zoneSymbolEventNames: zoneSymbolEventNames$1,\n            eventNames: eventNames,\n            isBrowser: isBrowser,\n            isMix: isMix,\n            isNode: isNode,\n            TRUE_STR: TRUE_STR,\n            FALSE_STR: FALSE_STR,\n            ZONE_SYMBOL_PREFIX: ZONE_SYMBOL_PREFIX,\n            ADD_EVENT_LISTENER_STR: ADD_EVENT_LISTENER_STR,\n            REMOVE_EVENT_LISTENER_STR: REMOVE_EVENT_LISTENER_STR\n        }); };\n    });\n    /**\n     * @license\n     * Copyright Google LLC All Rights Reserved.\n     *\n     * Use of this source code is governed by an MIT-style license that can be\n     * found in the LICENSE file at https://angular.io/license\n     */\n    /*\n     * This is necessary for Chrome and Chrome mobile, to enable\n     * things like redefining `createdCallback` on an element.\n     */\n    var zoneSymbol$1;\n    var _defineProperty;\n    var _getOwnPropertyDescriptor;\n    var _create;\n    var unconfigurablesKey;\n    function propertyPatch() {\n        zoneSymbol$1 = Zone.__symbol__;\n        _defineProperty = Object[zoneSymbol$1('defineProperty')] = Object.defineProperty;\n        _getOwnPropertyDescriptor = Object[zoneSymbol$1('getOwnPropertyDescriptor')] =\n            Object.getOwnPropertyDescriptor;\n        _create = Object.create;\n        unconfigurablesKey = zoneSymbol$1('unconfigurables');\n        Object.defineProperty = function (obj, prop, desc) {\n            if (isUnconfigurable(obj, prop)) {\n                throw new TypeError('Cannot assign to read only property \\'' + prop + '\\' of ' + obj);\n            }\n            var originalConfigurableFlag = desc.configurable;\n            if (prop !== 'prototype') {\n                desc = rewriteDescriptor(obj, prop, desc);\n            }\n            return _tryDefineProperty(obj, prop, desc, originalConfigurableFlag);\n        };\n        Object.defineProperties = function (obj, props) {\n            Object.keys(props).forEach(function (prop) {\n                Object.defineProperty(obj, prop, props[prop]);\n            });\n            return obj;\n        };\n        Object.create = function (obj, proto) {\n            if (typeof proto === 'object' && !Object.isFrozen(proto)) {\n                Object.keys(proto).forEach(function (prop) {\n                    proto[prop] = rewriteDescriptor(obj, prop, proto[prop]);\n                });\n            }\n            return _create(obj, proto);\n        };\n        Object.getOwnPropertyDescriptor = function (obj, prop) {\n            var desc = _getOwnPropertyDescriptor(obj, prop);\n            if (desc && isUnconfigurable(obj, prop)) {\n                desc.configurable = false;\n            }\n            return desc;\n        };\n    }\n    function _redefineProperty(obj, prop, desc) {\n        var originalConfigurableFlag = desc.configurable;\n        desc = rewriteDescriptor(obj, prop, desc);\n        return _tryDefineProperty(obj, prop, desc, originalConfigurableFlag);\n    }\n    function isUnconfigurable(obj, prop) {\n        return obj && obj[unconfigurablesKey] && obj[unconfigurablesKey][prop];\n    }\n    function rewriteDescriptor(obj, prop, desc) {\n        // issue-927, if the desc is frozen, don't try to change the desc\n        if (!Object.isFrozen(desc)) {\n            desc.configurable = true;\n        }\n        if (!desc.configurable) {\n            // issue-927, if the obj is frozen, don't try to set the desc to obj\n            if (!obj[unconfigurablesKey] && !Object.isFrozen(obj)) {\n                _defineProperty(obj, unconfigurablesKey, { writable: true, value: {} });\n            }\n            if (obj[unconfigurablesKey]) {\n                obj[unconfigurablesKey][prop] = true;\n            }\n        }\n        return desc;\n    }\n    function _tryDefineProperty(obj, prop, desc, originalConfigurableFlag) {\n        try {\n            return _defineProperty(obj, prop, desc);\n        }\n        catch (error) {\n            if (desc.configurable) {\n                // In case of errors, when the configurable flag was likely set by rewriteDescriptor(), let's\n                // retry with the original flag value\n                if (typeof originalConfigurableFlag == 'undefined') {\n                    delete desc.configurable;\n                }\n                else {\n                    desc.configurable = originalConfigurableFlag;\n                }\n                try {\n                    return _defineProperty(obj, prop, desc);\n                }\n                catch (error) {\n                    var swallowError = false;\n                    if (prop === 'createdCallback' || prop === 'attachedCallback' ||\n                        prop === 'detachedCallback' || prop === 'attributeChangedCallback') {\n                        // We only swallow the error in registerElement patch\n                        // this is the work around since some applications\n                        // fail if we throw the error\n                        swallowError = true;\n                    }\n                    if (!swallowError) {\n                        throw error;\n                    }\n                    // TODO: @JiaLiPassion, Some application such as `registerElement` patch\n                    // still need to swallow the error, in the future after these applications\n                    // are updated, the following logic can be removed.\n                    var descJson = null;\n                    try {\n                        descJson = JSON.stringify(desc);\n                    }\n                    catch (error) {\n                        descJson = desc.toString();\n                    }\n                    console.log(\"Attempting to configure '\" + prop + \"' with descriptor '\" + descJson + \"' on object '\" + obj + \"' and got error, giving up: \" + error);\n                }\n            }\n            else {\n                throw error;\n            }\n        }\n    }\n    /**\n     * @license\n     * Copyright Google LLC All Rights Reserved.\n     *\n     * Use of this source code is governed by an MIT-style license that can be\n     * found in the LICENSE file at https://angular.io/license\n     */\n    function eventTargetLegacyPatch(_global, api) {\n        var _a = api.getGlobalObjects(), eventNames = _a.eventNames, globalSources = _a.globalSources, zoneSymbolEventNames = _a.zoneSymbolEventNames, TRUE_STR = _a.TRUE_STR, FALSE_STR = _a.FALSE_STR, ZONE_SYMBOL_PREFIX = _a.ZONE_SYMBOL_PREFIX;\n        var WTF_ISSUE_555 = 'Anchor,Area,Audio,BR,Base,BaseFont,Body,Button,Canvas,Content,DList,Directory,Div,Embed,FieldSet,Font,Form,Frame,FrameSet,HR,Head,Heading,Html,IFrame,Image,Input,Keygen,LI,Label,Legend,Link,Map,Marquee,Media,Menu,Meta,Meter,Mod,OList,Object,OptGroup,Option,Output,Paragraph,Pre,Progress,Quote,Script,Select,Source,Span,Style,TableCaption,TableCell,TableCol,Table,TableRow,TableSection,TextArea,Title,Track,UList,Unknown,Video';\n        var NO_EVENT_TARGET = 'ApplicationCache,EventSource,FileReader,InputMethodContext,MediaController,MessagePort,Node,Performance,SVGElementInstance,SharedWorker,TextTrack,TextTrackCue,TextTrackList,WebKitNamedFlow,Window,Worker,WorkerGlobalScope,XMLHttpRequest,XMLHttpRequestEventTarget,XMLHttpRequestUpload,IDBRequest,IDBOpenDBRequest,IDBDatabase,IDBTransaction,IDBCursor,DBIndex,WebSocket'\n            .split(',');\n        var EVENT_TARGET = 'EventTarget';\n        var apis = [];\n        var isWtf = _global['wtf'];\n        var WTF_ISSUE_555_ARRAY = WTF_ISSUE_555.split(',');\n        if (isWtf) {\n            // Workaround for: https://github.com/google/tracing-framework/issues/555\n            apis = WTF_ISSUE_555_ARRAY.map(function (v) { return 'HTML' + v + 'Element'; }).concat(NO_EVENT_TARGET);\n        }\n        else if (_global[EVENT_TARGET]) {\n            apis.push(EVENT_TARGET);\n        }\n        else {\n            // Note: EventTarget is not available in all browsers,\n            // if it's not available, we instead patch the APIs in the IDL that inherit from EventTarget\n            apis = NO_EVENT_TARGET;\n        }\n        var isDisableIECheck = _global['__Zone_disable_IE_check'] || false;\n        var isEnableCrossContextCheck = _global['__Zone_enable_cross_context_check'] || false;\n        var ieOrEdge = api.isIEOrEdge();\n        var ADD_EVENT_LISTENER_SOURCE = '.addEventListener:';\n        var FUNCTION_WRAPPER = '[object FunctionWrapper]';\n        var BROWSER_TOOLS = 'function __BROWSERTOOLS_CONSOLE_SAFEFUNC() { [native code] }';\n        var pointerEventsMap = {\n            'MSPointerCancel': 'pointercancel',\n            'MSPointerDown': 'pointerdown',\n            'MSPointerEnter': 'pointerenter',\n            'MSPointerHover': 'pointerhover',\n            'MSPointerLeave': 'pointerleave',\n            'MSPointerMove': 'pointermove',\n            'MSPointerOut': 'pointerout',\n            'MSPointerOver': 'pointerover',\n            'MSPointerUp': 'pointerup'\n        };\n        //  predefine all __zone_symbol__ + eventName + true/false string\n        for (var i = 0; i < eventNames.length; i++) {\n            var eventName = eventNames[i];\n            var falseEventName = eventName + FALSE_STR;\n            var trueEventName = eventName + TRUE_STR;\n            var symbol = ZONE_SYMBOL_PREFIX + falseEventName;\n            var symbolCapture = ZONE_SYMBOL_PREFIX + trueEventName;\n            zoneSymbolEventNames[eventName] = {};\n            zoneSymbolEventNames[eventName][FALSE_STR] = symbol;\n            zoneSymbolEventNames[eventName][TRUE_STR] = symbolCapture;\n        }\n        //  predefine all task.source string\n        for (var i = 0; i < WTF_ISSUE_555_ARRAY.length; i++) {\n            var target = WTF_ISSUE_555_ARRAY[i];\n            var targets = globalSources[target] = {};\n            for (var j = 0; j < eventNames.length; j++) {\n                var eventName = eventNames[j];\n                targets[eventName] = target + ADD_EVENT_LISTENER_SOURCE + eventName;\n            }\n        }\n        var checkIEAndCrossContext = function (nativeDelegate, delegate, target, args) {\n            if (!isDisableIECheck && ieOrEdge) {\n                if (isEnableCrossContextCheck) {\n                    try {\n                        var testString = delegate.toString();\n                        if ((testString === FUNCTION_WRAPPER || testString == BROWSER_TOOLS)) {\n                            nativeDelegate.apply(target, args);\n                            return false;\n                        }\n                    }\n                    catch (error) {\n                        nativeDelegate.apply(target, args);\n                        return false;\n                    }\n                }\n                else {\n                    var testString = delegate.toString();\n                    if ((testString === FUNCTION_WRAPPER || testString == BROWSER_TOOLS)) {\n                        nativeDelegate.apply(target, args);\n                        return false;\n                    }\n                }\n            }\n            else if (isEnableCrossContextCheck) {\n                try {\n                    delegate.toString();\n                }\n                catch (error) {\n                    nativeDelegate.apply(target, args);\n                    return false;\n                }\n            }\n            return true;\n        };\n        var apiTypes = [];\n        for (var i = 0; i < apis.length; i++) {\n            var type = _global[apis[i]];\n            apiTypes.push(type && type.prototype);\n        }\n        // vh is validateHandler to check event handler\n        // is valid or not(for security check)\n        api.patchEventTarget(_global, apiTypes, {\n            vh: checkIEAndCrossContext,\n            transferEventName: function (eventName) {\n                var pointerEventName = pointerEventsMap[eventName];\n                return pointerEventName || eventName;\n            }\n        });\n        Zone[api.symbol('patchEventTarget')] = !!_global[EVENT_TARGET];\n        return true;\n    }\n    /**\n     * @license\n     * Copyright Google LLC All Rights Reserved.\n     *\n     * Use of this source code is governed by an MIT-style license that can be\n     * found in the LICENSE file at https://angular.io/license\n     */\n    // we have to patch the instance since the proto is non-configurable\n    function apply(api, _global) {\n        var _a = api.getGlobalObjects(), ADD_EVENT_LISTENER_STR = _a.ADD_EVENT_LISTENER_STR, REMOVE_EVENT_LISTENER_STR = _a.REMOVE_EVENT_LISTENER_STR;\n        var WS = _global.WebSocket;\n        // On Safari window.EventTarget doesn't exist so need to patch WS add/removeEventListener\n        // On older Chrome, no need since EventTarget was already patched\n        if (!_global.EventTarget) {\n            api.patchEventTarget(_global, [WS.prototype]);\n        }\n        _global.WebSocket = function (x, y) {\n            var socket = arguments.length > 1 ? new WS(x, y) : new WS(x);\n            var proxySocket;\n            var proxySocketProto;\n            // Safari 7.0 has non-configurable own 'onmessage' and friends properties on the socket instance\n            var onmessageDesc = api.ObjectGetOwnPropertyDescriptor(socket, 'onmessage');\n            if (onmessageDesc && onmessageDesc.configurable === false) {\n                proxySocket = api.ObjectCreate(socket);\n                // socket have own property descriptor 'onopen', 'onmessage', 'onclose', 'onerror'\n                // but proxySocket not, so we will keep socket as prototype and pass it to\n                // patchOnProperties method\n                proxySocketProto = socket;\n                [ADD_EVENT_LISTENER_STR, REMOVE_EVENT_LISTENER_STR, 'send', 'close'].forEach(function (propName) {\n                    proxySocket[propName] = function () {\n                        var args = api.ArraySlice.call(arguments);\n                        if (propName === ADD_EVENT_LISTENER_STR || propName === REMOVE_EVENT_LISTENER_STR) {\n                            var eventName = args.length > 0 ? args[0] : undefined;\n                            if (eventName) {\n                                var propertySymbol = Zone.__symbol__('ON_PROPERTY' + eventName);\n                                socket[propertySymbol] = proxySocket[propertySymbol];\n                            }\n                        }\n                        return socket[propName].apply(socket, args);\n                    };\n                });\n            }\n            else {\n                // we can patch the real socket\n                proxySocket = socket;\n            }\n            api.patchOnProperties(proxySocket, ['close', 'error', 'message', 'open'], proxySocketProto);\n            return proxySocket;\n        };\n        var globalWebSocket = _global['WebSocket'];\n        for (var prop in WS) {\n            globalWebSocket[prop] = WS[prop];\n        }\n    }\n    /**\n     * @license\n     * Copyright Google LLC All Rights Reserved.\n     *\n     * Use of this source code is governed by an MIT-style license that can be\n     * found in the LICENSE file at https://angular.io/license\n     */\n    function propertyDescriptorLegacyPatch(api, _global) {\n        var _a = api.getGlobalObjects(), isNode = _a.isNode, isMix = _a.isMix;\n        if (isNode && !isMix) {\n            return;\n        }\n        if (!canPatchViaPropertyDescriptor(api, _global)) {\n            var supportsWebSocket = typeof WebSocket !== 'undefined';\n            // Safari, Android browsers (Jelly Bean)\n            patchViaCapturingAllTheEvents(api);\n            api.patchClass('XMLHttpRequest');\n            if (supportsWebSocket) {\n                apply(api, _global);\n            }\n            Zone[api.symbol('patchEvents')] = true;\n        }\n    }\n    function canPatchViaPropertyDescriptor(api, _global) {\n        var _a = api.getGlobalObjects(), isBrowser = _a.isBrowser, isMix = _a.isMix;\n        if ((isBrowser || isMix) &&\n            !api.ObjectGetOwnPropertyDescriptor(HTMLElement.prototype, 'onclick') &&\n            typeof Element !== 'undefined') {\n            // WebKit https://bugs.webkit.org/show_bug.cgi?id=134364\n            // IDL interface attributes are not configurable\n            var desc = api.ObjectGetOwnPropertyDescriptor(Element.prototype, 'onclick');\n            if (desc && !desc.configurable)\n                return false;\n            // try to use onclick to detect whether we can patch via propertyDescriptor\n            // because XMLHttpRequest is not available in service worker\n            if (desc) {\n                api.ObjectDefineProperty(Element.prototype, 'onclick', {\n                    enumerable: true,\n                    configurable: true,\n                    get: function () {\n                        return true;\n                    }\n                });\n                var div = document.createElement('div');\n                var result = !!div.onclick;\n                api.ObjectDefineProperty(Element.prototype, 'onclick', desc);\n                return result;\n            }\n        }\n        var XMLHttpRequest = _global['XMLHttpRequest'];\n        if (!XMLHttpRequest) {\n            // XMLHttpRequest is not available in service worker\n            return false;\n        }\n        var ON_READY_STATE_CHANGE = 'onreadystatechange';\n        var XMLHttpRequestPrototype = XMLHttpRequest.prototype;\n        var xhrDesc = api.ObjectGetOwnPropertyDescriptor(XMLHttpRequestPrototype, ON_READY_STATE_CHANGE);\n        // add enumerable and configurable here because in opera\n        // by default XMLHttpRequest.prototype.onreadystatechange is undefined\n        // without adding enumerable and configurable will cause onreadystatechange\n        // non-configurable\n        // and if XMLHttpRequest.prototype.onreadystatechange is undefined,\n        // we should set a real desc instead a fake one\n        if (xhrDesc) {\n            api.ObjectDefineProperty(XMLHttpRequestPrototype, ON_READY_STATE_CHANGE, {\n                enumerable: true,\n                configurable: true,\n                get: function () {\n                    return true;\n                }\n            });\n            var req = new XMLHttpRequest();\n            var result = !!req.onreadystatechange;\n            // restore original desc\n            api.ObjectDefineProperty(XMLHttpRequestPrototype, ON_READY_STATE_CHANGE, xhrDesc || {});\n            return result;\n        }\n        else {\n            var SYMBOL_FAKE_ONREADYSTATECHANGE_1 = api.symbol('fake');\n            api.ObjectDefineProperty(XMLHttpRequestPrototype, ON_READY_STATE_CHANGE, {\n                enumerable: true,\n                configurable: true,\n                get: function () {\n                    return this[SYMBOL_FAKE_ONREADYSTATECHANGE_1];\n                },\n                set: function (value) {\n                    this[SYMBOL_FAKE_ONREADYSTATECHANGE_1] = value;\n                }\n            });\n            var req = new XMLHttpRequest();\n            var detectFunc = function () { };\n            req.onreadystatechange = detectFunc;\n            var result = req[SYMBOL_FAKE_ONREADYSTATECHANGE_1] === detectFunc;\n            req.onreadystatechange = null;\n            return result;\n        }\n    }\n    // Whenever any eventListener fires, we check the eventListener target and all parents\n    // for `onwhatever` properties and replace them with zone-bound functions\n    // - Chrome (for now)\n    function patchViaCapturingAllTheEvents(api) {\n        var eventNames = api.getGlobalObjects().eventNames;\n        var unboundKey = api.symbol('unbound');\n        var _loop_4 = function (i) {\n            var property = eventNames[i];\n            var onproperty = 'on' + property;\n            self.addEventListener(property, function (event) {\n                var elt = event.target, bound, source;\n                if (elt) {\n                    source = elt.constructor['name'] + '.' + onproperty;\n                }\n                else {\n                    source = 'unknown.' + onproperty;\n                }\n                while (elt) {\n                    if (elt[onproperty] && !elt[onproperty][unboundKey]) {\n                        bound = api.wrapWithCurrentZone(elt[onproperty], source);\n                        bound[unboundKey] = elt[onproperty];\n                        elt[onproperty] = bound;\n                    }\n                    elt = elt.parentElement;\n                }\n            }, true);\n        };\n        for (var i = 0; i < eventNames.length; i++) {\n            _loop_4(i);\n        }\n    }\n    /**\n     * @license\n     * Copyright Google LLC All Rights Reserved.\n     *\n     * Use of this source code is governed by an MIT-style license that can be\n     * found in the LICENSE file at https://angular.io/license\n     */\n    function registerElementPatch(_global, api) {\n        var _a = api.getGlobalObjects(), isBrowser = _a.isBrowser, isMix = _a.isMix;\n        if ((!isBrowser && !isMix) || !('registerElement' in _global.document)) {\n            return;\n        }\n        var callbacks = ['createdCallback', 'attachedCallback', 'detachedCallback', 'attributeChangedCallback'];\n        api.patchCallbacks(api, document, 'Document', 'registerElement', callbacks);\n    }\n    /**\n     * @license\n     * Copyright Google LLC All Rights Reserved.\n     *\n     * Use of this source code is governed by an MIT-style license that can be\n     * found in the LICENSE file at https://angular.io/license\n     */\n    (function (_global) {\n        var symbolPrefix = _global['__Zone_symbol_prefix'] || '__zone_symbol__';\n        function __symbol__(name) {\n            return symbolPrefix + name;\n        }\n        _global[__symbol__('legacyPatch')] = function () {\n            var Zone = _global['Zone'];\n            Zone.__load_patch('defineProperty', function (global, Zone, api) {\n                api._redefineProperty = _redefineProperty;\n                propertyPatch();\n            });\n            Zone.__load_patch('registerElement', function (global, Zone, api) {\n                registerElementPatch(global, api);\n            });\n            Zone.__load_patch('EventTargetLegacy', function (global, Zone, api) {\n                eventTargetLegacyPatch(global, api);\n                propertyDescriptorLegacyPatch(api, global);\n            });\n        };\n    })(typeof window !== 'undefined' ?\n        window :\n        typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {});\n    /**\n     * @license\n     * Copyright Google LLC All Rights Reserved.\n     *\n     * Use of this source code is governed by an MIT-style license that can be\n     * found in the LICENSE file at https://angular.io/license\n     */\n    var taskSymbol = zoneSymbol('zoneTask');\n    function patchTimer(window, setName, cancelName, nameSuffix) {\n        var setNative = null;\n        var clearNative = null;\n        setName += nameSuffix;\n        cancelName += nameSuffix;\n        var tasksByHandleId = {};\n        function scheduleTask(task) {\n            var data = task.data;\n            data.args[0] = function () {\n                return task.invoke.apply(this, arguments);\n            };\n            data.handleId = setNative.apply(window, data.args);\n            return task;\n        }\n        function clearTask(task) {\n            return clearNative.call(window, task.data.handleId);\n        }\n        setNative =\n            patchMethod(window, setName, function (delegate) { return function (self, args) {\n                if (typeof args[0] === 'function') {\n                    var options_1 = {\n                        isPeriodic: nameSuffix === 'Interval',\n                        delay: (nameSuffix === 'Timeout' || nameSuffix === 'Interval') ? args[1] || 0 :\n                            undefined,\n                        args: args\n                    };\n                    var callback_1 = args[0];\n                    args[0] = function timer() {\n                        try {\n                            return callback_1.apply(this, arguments);\n                        }\n                        finally {\n                            // issue-934, task will be cancelled\n                            // even it is a periodic task such as\n                            // setInterval\n                            // https://github.com/angular/angular/issues/40387\n                            // Cleanup tasksByHandleId should be handled before scheduleTask\n                            // Since some zoneSpec may intercept and doesn't trigger\n                            // scheduleFn(scheduleTask) provided here.\n                            if (!(options_1.isPeriodic)) {\n                                if (typeof options_1.handleId === 'number') {\n                                    // in non-nodejs env, we remove timerId\n                                    // from local cache\n                                    delete tasksByHandleId[options_1.handleId];\n                                }\n                                else if (options_1.handleId) {\n                                    // Node returns complex objects as handleIds\n                                    // we remove task reference from timer object\n                                    options_1.handleId[taskSymbol] = null;\n                                }\n                            }\n                        }\n                    };\n                    var task = scheduleMacroTaskWithCurrentZone(setName, args[0], options_1, scheduleTask, clearTask);\n                    if (!task) {\n                        return task;\n                    }\n                    // Node.js must additionally support the ref and unref functions.\n                    var handle = task.data.handleId;\n                    if (typeof handle === 'number') {\n                        // for non nodejs env, we save handleId: task\n                        // mapping in local cache for clearTimeout\n                        tasksByHandleId[handle] = task;\n                    }\n                    else if (handle) {\n                        // for nodejs env, we save task\n                        // reference in timerId Object for clearTimeout\n                        handle[taskSymbol] = task;\n                    }\n                    // check whether handle is null, because some polyfill or browser\n                    // may return undefined from setTimeout/setInterval/setImmediate/requestAnimationFrame\n                    if (handle && handle.ref && handle.unref && typeof handle.ref === 'function' &&\n                        typeof handle.unref === 'function') {\n                        task.ref = handle.ref.bind(handle);\n                        task.unref = handle.unref.bind(handle);\n                    }\n                    if (typeof handle === 'number' || handle) {\n                        return handle;\n                    }\n                    return task;\n                }\n                else {\n                    // cause an error by calling it directly.\n                    return delegate.apply(window, args);\n                }\n            }; });\n        clearNative =\n            patchMethod(window, cancelName, function (delegate) { return function (self, args) {\n                var id = args[0];\n                var task;\n                if (typeof id === 'number') {\n                    // non nodejs env.\n                    task = tasksByHandleId[id];\n                }\n                else {\n                    // nodejs env.\n                    task = id && id[taskSymbol];\n                    // other environments.\n                    if (!task) {\n                        task = id;\n                    }\n                }\n                if (task && typeof task.type === 'string') {\n                    if (task.state !== 'notScheduled' &&\n                        (task.cancelFn && task.data.isPeriodic || task.runCount === 0)) {\n                        if (typeof id === 'number') {\n                            delete tasksByHandleId[id];\n                        }\n                        else if (id) {\n                            id[taskSymbol] = null;\n                        }\n                        // Do not cancel already canceled functions\n                        task.zone.cancelTask(task);\n                    }\n                }\n                else {\n                    // cause an error by calling it directly.\n                    delegate.apply(window, args);\n                }\n            }; });\n    }\n    /**\n     * @license\n     * Copyright Google LLC All Rights Reserved.\n     *\n     * Use of this source code is governed by an MIT-style license that can be\n     * found in the LICENSE file at https://angular.io/license\n     */\n    function patchCustomElements(_global, api) {\n        var _a = api.getGlobalObjects(), isBrowser = _a.isBrowser, isMix = _a.isMix;\n        if ((!isBrowser && !isMix) || !_global['customElements'] || !('customElements' in _global)) {\n            return;\n        }\n        var callbacks = ['connectedCallback', 'disconnectedCallback', 'adoptedCallback', 'attributeChangedCallback'];\n        api.patchCallbacks(api, _global.customElements, 'customElements', 'define', callbacks);\n    }\n    /**\n     * @license\n     * Copyright Google LLC All Rights Reserved.\n     *\n     * Use of this source code is governed by an MIT-style license that can be\n     * found in the LICENSE file at https://angular.io/license\n     */\n    function eventTargetPatch(_global, api) {\n        if (Zone[api.symbol('patchEventTarget')]) {\n            // EventTarget is already patched.\n            return;\n        }\n        var _a = api.getGlobalObjects(), eventNames = _a.eventNames, zoneSymbolEventNames = _a.zoneSymbolEventNames, TRUE_STR = _a.TRUE_STR, FALSE_STR = _a.FALSE_STR, ZONE_SYMBOL_PREFIX = _a.ZONE_SYMBOL_PREFIX;\n        //  predefine all __zone_symbol__ + eventName + true/false string\n        for (var i = 0; i < eventNames.length; i++) {\n            var eventName = eventNames[i];\n            var falseEventName = eventName + FALSE_STR;\n            var trueEventName = eventName + TRUE_STR;\n            var symbol = ZONE_SYMBOL_PREFIX + falseEventName;\n            var symbolCapture = ZONE_SYMBOL_PREFIX + trueEventName;\n            zoneSymbolEventNames[eventName] = {};\n            zoneSymbolEventNames[eventName][FALSE_STR] = symbol;\n            zoneSymbolEventNames[eventName][TRUE_STR] = symbolCapture;\n        }\n        var EVENT_TARGET = _global['EventTarget'];\n        if (!EVENT_TARGET || !EVENT_TARGET.prototype) {\n            return;\n        }\n        api.patchEventTarget(_global, [EVENT_TARGET && EVENT_TARGET.prototype]);\n        return true;\n    }\n    function patchEvent(global, api) {\n        api.patchEventPrototype(global, api);\n    }\n    /**\n     * @license\n     * Copyright Google LLC All Rights Reserved.\n     *\n     * Use of this source code is governed by an MIT-style license that can be\n     * found in the LICENSE file at https://angular.io/license\n     */\n    Zone.__load_patch('legacy', function (global) {\n        var legacyPatch = global[Zone.__symbol__('legacyPatch')];\n        if (legacyPatch) {\n            legacyPatch();\n        }\n    });\n    Zone.__load_patch('queueMicrotask', function (global, Zone, api) {\n        api.patchMethod(global, 'queueMicrotask', function (delegate) {\n            return function (self, args) {\n                Zone.current.scheduleMicroTask('queueMicrotask', args[0]);\n            };\n        });\n    });\n    Zone.__load_patch('timers', function (global) {\n        var set = 'set';\n        var clear = 'clear';\n        patchTimer(global, set, clear, 'Timeout');\n        patchTimer(global, set, clear, 'Interval');\n        patchTimer(global, set, clear, 'Immediate');\n    });\n    Zone.__load_patch('requestAnimationFrame', function (global) {\n        patchTimer(global, 'request', 'cancel', 'AnimationFrame');\n        patchTimer(global, 'mozRequest', 'mozCancel', 'AnimationFrame');\n        patchTimer(global, 'webkitRequest', 'webkitCancel', 'AnimationFrame');\n    });\n    Zone.__load_patch('blocking', function (global, Zone) {\n        var blockingMethods = ['alert', 'prompt', 'confirm'];\n        for (var i = 0; i < blockingMethods.length; i++) {\n            var name_2 = blockingMethods[i];\n            patchMethod(global, name_2, function (delegate, symbol, name) {\n                return function (s, args) {\n                    return Zone.current.run(delegate, global, args, name);\n                };\n            });\n        }\n    });\n    Zone.__load_patch('EventTarget', function (global, Zone, api) {\n        patchEvent(global, api);\n        eventTargetPatch(global, api);\n        // patch XMLHttpRequestEventTarget's addEventListener/removeEventListener\n        var XMLHttpRequestEventTarget = global['XMLHttpRequestEventTarget'];\n        if (XMLHttpRequestEventTarget && XMLHttpRequestEventTarget.prototype) {\n            api.patchEventTarget(global, [XMLHttpRequestEventTarget.prototype]);\n        }\n    });\n    Zone.__load_patch('MutationObserver', function (global, Zone, api) {\n        patchClass('MutationObserver');\n        patchClass('WebKitMutationObserver');\n    });\n    Zone.__load_patch('IntersectionObserver', function (global, Zone, api) {\n        patchClass('IntersectionObserver');\n    });\n    Zone.__load_patch('FileReader', function (global, Zone, api) {\n        patchClass('FileReader');\n    });\n    Zone.__load_patch('on_property', function (global, Zone, api) {\n        propertyDescriptorPatch(api, global);\n    });\n    Zone.__load_patch('customElements', function (global, Zone, api) {\n        patchCustomElements(global, api);\n    });\n    Zone.__load_patch('XHR', function (global, Zone) {\n        // Treat XMLHttpRequest as a macrotask.\n        patchXHR(global);\n        var XHR_TASK = zoneSymbol('xhrTask');\n        var XHR_SYNC = zoneSymbol('xhrSync');\n        var XHR_LISTENER = zoneSymbol('xhrListener');\n        var XHR_SCHEDULED = zoneSymbol('xhrScheduled');\n        var XHR_URL = zoneSymbol('xhrURL');\n        var XHR_ERROR_BEFORE_SCHEDULED = zoneSymbol('xhrErrorBeforeScheduled');\n        function patchXHR(window) {\n            var XMLHttpRequest = window['XMLHttpRequest'];\n            if (!XMLHttpRequest) {\n                // XMLHttpRequest is not available in service worker\n                return;\n            }\n            var XMLHttpRequestPrototype = XMLHttpRequest.prototype;\n            function findPendingTask(target) {\n                return target[XHR_TASK];\n            }\n            var oriAddListener = XMLHttpRequestPrototype[ZONE_SYMBOL_ADD_EVENT_LISTENER];\n            var oriRemoveListener = XMLHttpRequestPrototype[ZONE_SYMBOL_REMOVE_EVENT_LISTENER];\n            if (!oriAddListener) {\n                var XMLHttpRequestEventTarget_1 = window['XMLHttpRequestEventTarget'];\n                if (XMLHttpRequestEventTarget_1) {\n                    var XMLHttpRequestEventTargetPrototype = XMLHttpRequestEventTarget_1.prototype;\n                    oriAddListener = XMLHttpRequestEventTargetPrototype[ZONE_SYMBOL_ADD_EVENT_LISTENER];\n                    oriRemoveListener = XMLHttpRequestEventTargetPrototype[ZONE_SYMBOL_REMOVE_EVENT_LISTENER];\n                }\n            }\n            var READY_STATE_CHANGE = 'readystatechange';\n            var SCHEDULED = 'scheduled';\n            function scheduleTask(task) {\n                var data = task.data;\n                var target = data.target;\n                target[XHR_SCHEDULED] = false;\n                target[XHR_ERROR_BEFORE_SCHEDULED] = false;\n                // remove existing event listener\n                var listener = target[XHR_LISTENER];\n                if (!oriAddListener) {\n                    oriAddListener = target[ZONE_SYMBOL_ADD_EVENT_LISTENER];\n                    oriRemoveListener = target[ZONE_SYMBOL_REMOVE_EVENT_LISTENER];\n                }\n                if (listener) {\n                    oriRemoveListener.call(target, READY_STATE_CHANGE, listener);\n                }\n                var newListener = target[XHR_LISTENER] = function () {\n                    if (target.readyState === target.DONE) {\n                        // sometimes on some browsers XMLHttpRequest will fire onreadystatechange with\n                        // readyState=4 multiple times, so we need to check task state here\n                        if (!data.aborted && target[XHR_SCHEDULED] && task.state === SCHEDULED) {\n                            // check whether the xhr has registered onload listener\n                            // if that is the case, the task should invoke after all\n                            // onload listeners finish.\n                            // Also if the request failed without response (status = 0), the load event handler\n                            // will not be triggered, in that case, we should also invoke the placeholder callback\n                            // to close the XMLHttpRequest::send macroTask.\n                            // https://github.com/angular/angular/issues/38795\n                            var loadTasks = target[Zone.__symbol__('loadfalse')];\n                            if (target.status !== 0 && loadTasks && loadTasks.length > 0) {\n                                var oriInvoke_1 = task.invoke;\n                                task.invoke = function () {\n                                    // need to load the tasks again, because in other\n                                    // load listener, they may remove themselves\n                                    var loadTasks = target[Zone.__symbol__('loadfalse')];\n                                    for (var i = 0; i < loadTasks.length; i++) {\n                                        if (loadTasks[i] === task) {\n                                            loadTasks.splice(i, 1);\n                                        }\n                                    }\n                                    if (!data.aborted && task.state === SCHEDULED) {\n                                        oriInvoke_1.call(task);\n                                    }\n                                };\n                                loadTasks.push(task);\n                            }\n                            else {\n                                task.invoke();\n                            }\n                        }\n                        else if (!data.aborted && target[XHR_SCHEDULED] === false) {\n                            // error occurs when xhr.send()\n                            target[XHR_ERROR_BEFORE_SCHEDULED] = true;\n                        }\n                    }\n                };\n                oriAddListener.call(target, READY_STATE_CHANGE, newListener);\n                var storedTask = target[XHR_TASK];\n                if (!storedTask) {\n                    target[XHR_TASK] = task;\n                }\n                sendNative.apply(target, data.args);\n                target[XHR_SCHEDULED] = true;\n                return task;\n            }\n            function placeholderCallback() { }\n            function clearTask(task) {\n                var data = task.data;\n                // Note - ideally, we would call data.target.removeEventListener here, but it's too late\n                // to prevent it from firing. So instead, we store info for the event listener.\n                data.aborted = true;\n                return abortNative.apply(data.target, data.args);\n            }\n            var openNative = patchMethod(XMLHttpRequestPrototype, 'open', function () { return function (self, args) {\n                self[XHR_SYNC] = args[2] == false;\n                self[XHR_URL] = args[1];\n                return openNative.apply(self, args);\n            }; });\n            var XMLHTTPREQUEST_SOURCE = 'XMLHttpRequest.send';\n            var fetchTaskAborting = zoneSymbol('fetchTaskAborting');\n            var fetchTaskScheduling = zoneSymbol('fetchTaskScheduling');\n            var sendNative = patchMethod(XMLHttpRequestPrototype, 'send', function () { return function (self, args) {\n                if (Zone.current[fetchTaskScheduling] === true) {\n                    // a fetch is scheduling, so we are using xhr to polyfill fetch\n                    // and because we already schedule macroTask for fetch, we should\n                    // not schedule a macroTask for xhr again\n                    return sendNative.apply(self, args);\n                }\n                if (self[XHR_SYNC]) {\n                    // if the XHR is sync there is no task to schedule, just execute the code.\n                    return sendNative.apply(self, args);\n                }\n                else {\n                    var options = { target: self, url: self[XHR_URL], isPeriodic: false, args: args, aborted: false };\n                    var task = scheduleMacroTaskWithCurrentZone(XMLHTTPREQUEST_SOURCE, placeholderCallback, options, scheduleTask, clearTask);\n                    if (self && self[XHR_ERROR_BEFORE_SCHEDULED] === true && !options.aborted &&\n                        task.state === SCHEDULED) {\n                        // xhr request throw error when send\n                        // we should invoke task instead of leaving a scheduled\n                        // pending macroTask\n                        task.invoke();\n                    }\n                }\n            }; });\n            var abortNative = patchMethod(XMLHttpRequestPrototype, 'abort', function () { return function (self, args) {\n                var task = findPendingTask(self);\n                if (task && typeof task.type == 'string') {\n                    // If the XHR has already completed, do nothing.\n                    // If the XHR has already been aborted, do nothing.\n                    // Fix #569, call abort multiple times before done will cause\n                    // macroTask task count be negative number\n                    if (task.cancelFn == null || (task.data && task.data.aborted)) {\n                        return;\n                    }\n                    task.zone.cancelTask(task);\n                }\n                else if (Zone.current[fetchTaskAborting] === true) {\n                    // the abort is called from fetch polyfill, we need to call native abort of XHR.\n                    return abortNative.apply(self, args);\n                }\n                // Otherwise, we are trying to abort an XHR which has not yet been sent, so there is no\n                // task\n                // to cancel. Do nothing.\n            }; });\n        }\n    });\n    Zone.__load_patch('geolocation', function (global) {\n        /// GEO_LOCATION\n        if (global['navigator'] && global['navigator'].geolocation) {\n            patchPrototype(global['navigator'].geolocation, ['getCurrentPosition', 'watchPosition']);\n        }\n    });\n    Zone.__load_patch('PromiseRejectionEvent', function (global, Zone) {\n        // handle unhandled promise rejection\n        function findPromiseRejectionHandler(evtName) {\n            return function (e) {\n                var eventTasks = findEventTasks(global, evtName);\n                eventTasks.forEach(function (eventTask) {\n                    // windows has added unhandledrejection event listener\n                    // trigger the event listener\n                    var PromiseRejectionEvent = global['PromiseRejectionEvent'];\n                    if (PromiseRejectionEvent) {\n                        var evt = new PromiseRejectionEvent(evtName, { promise: e.promise, reason: e.rejection });\n                        eventTask.invoke(evt);\n                    }\n                });\n            };\n        }\n        if (global['PromiseRejectionEvent']) {\n            Zone[zoneSymbol('unhandledPromiseRejectionHandler')] =\n                findPromiseRejectionHandler('unhandledrejection');\n            Zone[zoneSymbol('rejectionHandledHandler')] =\n                findPromiseRejectionHandler('rejectionhandled');\n        }\n    });\n})));\n","'use strict';\nvar nativePropertyIsEnumerable = {}.propertyIsEnumerable;\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// Nashorn ~ JDK8 bug\nvar NASHORN_BUG = getOwnPropertyDescriptor && !nativePropertyIsEnumerable.call({ 1: 2 }, 1);\n\n// `Object.prototype.propertyIsEnumerable` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable\nexports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {\n  var descriptor = getOwnPropertyDescriptor(this, V);\n  return !!descriptor && descriptor.enumerable;\n} : nativePropertyIsEnumerable;\n","/* eslint-disable no-proto -- safe */\nvar anObject = require('../internals/an-object');\nvar aPossiblePrototype = require('../internals/a-possible-prototype');\n\n// `Object.setPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.setprototypeof\n// Works with __proto__ only. Old v8 can't work with null proto objects.\nmodule.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {\n  var CORRECT_SETTER = false;\n  var test = {};\n  var setter;\n  try {\n    setter = Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set;\n    setter.call(test, []);\n    CORRECT_SETTER = test instanceof Array;\n  } catch (error) { /* empty */ }\n  return function setPrototypeOf(O, proto) {\n    anObject(O);\n    aPossiblePrototype(proto);\n    if (CORRECT_SETTER) setter.call(O, proto);\n    else O.__proto__ = proto;\n    return O;\n  };\n}() : undefined);\n","var defineProperty = require('../internals/object-define-property').f;\nvar has = require('../internals/has');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\n\nmodule.exports = function (it, TAG, STATIC) {\n  if (it && !has(it = STATIC ? it : it.prototype, TO_STRING_TAG)) {\n    defineProperty(it, TO_STRING_TAG, { configurable: true, value: TAG });\n  }\n};\n","var $ = require('../internals/export');\nvar getBuiltIn = require('../internals/get-built-in');\nvar anObject = require('../internals/an-object');\nvar FREEZING = require('../internals/freezing');\n\n// `Reflect.preventExtensions` method\n// https://tc39.es/ecma262/#sec-reflect.preventextensions\n$({ target: 'Reflect', stat: true, sham: !FREEZING }, {\n  preventExtensions: function preventExtensions(target) {\n    anObject(target);\n    try {\n      var objectPreventExtensions = getBuiltIn('Object', 'preventExtensions');\n      if (objectPreventExtensions) objectPreventExtensions(target);\n      return true;\n    } catch (error) {\n      return false;\n    }\n  }\n});\n","var $ = require('../internals/export');\nvar anObject = require('../internals/an-object');\n\nvar objectIsExtensible = Object.isExtensible;\n\n// `Reflect.isExtensible` method\n// https://tc39.es/ecma262/#sec-reflect.isextensible\n$({ target: 'Reflect', stat: true }, {\n  isExtensible: function isExtensible(target) {\n    anObject(target);\n    return objectIsExtensible ? objectIsExtensible(target) : true;\n  }\n});\n","var check = function (it) {\n  return it && it.Math == Math && it;\n};\n\n// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nmodule.exports =\n  /* global globalThis -- safe */\n  check(typeof globalThis == 'object' && globalThis) ||\n  check(typeof window == 'object' && window) ||\n  check(typeof self == 'object' && self) ||\n  check(typeof global == 'object' && global) ||\n  // eslint-disable-next-line no-new-func -- fallback\n  (function () { return this; })() || Function('return this')();\n","var internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\n// `Object.keys` method\n// https://tc39.es/ecma262/#sec-object.keys\nmodule.exports = Object.keys || function keys(O) {\n  return internalObjectKeys(O, enumBugKeys);\n};\n","var has = require('../internals/has');\nvar toObject = require('../internals/to-object');\nvar sharedKey = require('../internals/shared-key');\nvar CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter');\n\nvar IE_PROTO = sharedKey('IE_PROTO');\nvar ObjectPrototype = Object.prototype;\n\n// `Object.getPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.getprototypeof\nmodule.exports = CORRECT_PROTOTYPE_GETTER ? Object.getPrototypeOf : function (O) {\n  O = toObject(O);\n  if (has(O, IE_PROTO)) return O[IE_PROTO];\n  if (typeof O.constructor == 'function' && O instanceof O.constructor) {\n    return O.constructor.prototype;\n  } return O instanceof Object ? ObjectPrototype : null;\n};\n","var fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n  function F() { /* empty */ }\n  F.prototype.constructor = null;\n  return Object.getPrototypeOf(new F()) !== F.prototype;\n});\n","var has = require('../internals/has');\nvar ownKeys = require('../internals/own-keys');\nvar getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');\nvar definePropertyModule = require('../internals/object-define-property');\n\nmodule.exports = function (target, source) {\n  var keys = ownKeys(source);\n  var defineProperty = definePropertyModule.f;\n  var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;\n  for (var i = 0; i < keys.length; i++) {\n    var key = keys[i];\n    if (!has(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key));\n  }\n};\n","var shared = require('../internals/shared');\nvar uid = require('../internals/uid');\n\nvar keys = shared('keys');\n\nmodule.exports = function (key) {\n  return keys[key] || (keys[key] = uid(key));\n};\n","'use strict';\nvar aFunction = require('../internals/a-function');\nvar isObject = require('../internals/is-object');\n\nvar slice = [].slice;\nvar factories = {};\n\nvar construct = function (C, argsLength, args) {\n  if (!(argsLength in factories)) {\n    for (var list = [], i = 0; i < argsLength; i++) list[i] = 'a[' + i + ']';\n    // eslint-disable-next-line no-new-func -- we have no proper alternatives, IE8- only\n    factories[argsLength] = Function('C,a', 'return new C(' + list.join(',') + ')');\n  } return factories[argsLength](C, args);\n};\n\n// `Function.prototype.bind` method implementation\n// https://tc39.es/ecma262/#sec-function.prototype.bind\nmodule.exports = Function.bind || function bind(that /* , ...args */) {\n  var fn = aFunction(this);\n  var partArgs = slice.call(arguments, 1);\n  var boundFunction = function bound(/* args... */) {\n    var args = partArgs.concat(slice.call(arguments));\n    return this instanceof boundFunction ? construct(fn, args.length, args) : fn.apply(that, args);\n  };\n  if (isObject(fn.prototype)) boundFunction.prototype = fn.prototype;\n  return boundFunction;\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toPrimitive = require('../internals/to-primitive');\nvar has = require('../internals/has');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\n\nvar nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// `Object.getOwnPropertyDescriptor` method\n// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor\nexports.f = DESCRIPTORS ? nativeGetOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {\n  O = toIndexedObject(O);\n  P = toPrimitive(P, true);\n  if (IE8_DOM_DEFINE) try {\n    return nativeGetOwnPropertyDescriptor(O, P);\n  } catch (error) { /* empty */ }\n  if (has(O, P)) return createPropertyDescriptor(!propertyIsEnumerableModule.f.call(O, P), O[P]);\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar createElement = require('../internals/document-create-element');\n\n// Thank's IE8 for his funny defineProperty\nmodule.exports = !DESCRIPTORS && !fails(function () {\n  return Object.defineProperty(createElement('div'), 'a', {\n    get: function () { return 7; }\n  }).a != 7;\n});\n","var getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('document', 'documentElement');\n","var $ = require('../internals/export');\nvar ownKeys = require('../internals/own-keys');\n\n// `Reflect.ownKeys` method\n// https://tc39.es/ecma262/#sec-reflect.ownkeys\n$({ target: 'Reflect', stat: true }, {\n  ownKeys: ownKeys\n});\n","module.exports = function (it) {\n  if (typeof it != 'function') {\n    throw TypeError(String(it) + ' is not a function');\n  } return it;\n};\n","// `RequireObjectCoercible` abstract operation\n// https://tc39.es/ecma262/#sec-requireobjectcoercible\nmodule.exports = function (it) {\n  if (it == undefined) throw TypeError(\"Can't call method on \" + it);\n  return it;\n};\n","var global = require('../internals/global');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar redefine = require('../internals/redefine');\nvar setGlobal = require('../internals/set-global');\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\nvar isForced = require('../internals/is-forced');\n\n/*\n  options.target      - name of the target object\n  options.global      - target is the global object\n  options.stat        - export as static methods of target\n  options.proto       - export as prototype methods of target\n  options.real        - real prototype method for the `pure` version\n  options.forced      - export even if the native feature is available\n  options.bind        - bind methods to the target, required for the `pure` version\n  options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version\n  options.unsafe      - use the simple assignment of property instead of delete + defineProperty\n  options.sham        - add a flag to not completely full polyfills\n  options.enumerable  - export as enumerable property\n  options.noTargetGet - prevent calling a getter on target\n*/\nmodule.exports = function (options, source) {\n  var TARGET = options.target;\n  var GLOBAL = options.global;\n  var STATIC = options.stat;\n  var FORCED, target, key, targetProperty, sourceProperty, descriptor;\n  if (GLOBAL) {\n    target = global;\n  } else if (STATIC) {\n    target = global[TARGET] || setGlobal(TARGET, {});\n  } else {\n    target = (global[TARGET] || {}).prototype;\n  }\n  if (target) for (key in source) {\n    sourceProperty = source[key];\n    if (options.noTargetGet) {\n      descriptor = getOwnPropertyDescriptor(target, key);\n      targetProperty = descriptor && descriptor.value;\n    } else targetProperty = target[key];\n    FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);\n    // contained in target\n    if (!FORCED && targetProperty !== undefined) {\n      if (typeof sourceProperty === typeof targetProperty) continue;\n      copyConstructorProperties(sourceProperty, targetProperty);\n    }\n    // add a flag to not completely full polyfills\n    if (options.sham || (targetProperty && targetProperty.sham)) {\n      createNonEnumerableProperty(sourceProperty, 'sham', true);\n    }\n    // extend global\n    redefine(target, key, sourceProperty, options);\n  }\n};\n","var toInteger = require('../internals/to-integer');\n\nvar max = Math.max;\nvar min = Math.min;\n\n// Helper for a popular repeating case of the spec:\n// Let integer be ? ToInteger(index).\n// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).\nmodule.exports = function (index, length) {\n  var integer = toInteger(index);\n  return integer < 0 ? max(integer + length, 0) : min(integer, length);\n};\n","var internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\nvar hiddenKeys = enumBugKeys.concat('length', 'prototype');\n\n// `Object.getOwnPropertyNames` method\n// https://tc39.es/ecma262/#sec-object.getownpropertynames\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {\n  return internalObjectKeys(O, hiddenKeys);\n};\n","var global = require('../internals/global');\nvar userAgent = require('../internals/engine-user-agent');\n\nvar process = global.process;\nvar versions = process && process.versions;\nvar v8 = versions && versions.v8;\nvar match, version;\n\nif (v8) {\n  match = v8.split('.');\n  version = match[0] + match[1];\n} else if (userAgent) {\n  match = userAgent.match(/Edge\\/(\\d+)/);\n  if (!match || match[1] >= 74) {\n    match = userAgent.match(/Chrome\\/(\\d+)/);\n    if (match) version = match[1];\n  }\n}\n\nmodule.exports = version && +version;\n","var DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar anObject = require('../internals/an-object');\nvar objectKeys = require('../internals/object-keys');\n\n// `Object.defineProperties` method\n// https://tc39.es/ecma262/#sec-object.defineproperties\nmodule.exports = DESCRIPTORS ? Object.defineProperties : function defineProperties(O, Properties) {\n  anObject(O);\n  var keys = objectKeys(Properties);\n  var length = keys.length;\n  var index = 0;\n  var key;\n  while (length > index) definePropertyModule.f(O, key = keys[index++], Properties[key]);\n  return O;\n};\n","var getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('navigator', 'userAgent') || '';\n","var isObject = require('../internals/is-object');\n\nmodule.exports = function (it) {\n  if (!isObject(it) && it !== null) {\n    throw TypeError(\"Can't set \" + String(it) + ' as a prototype');\n  } return it;\n};\n","var $ = require('../internals/export');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar anObject = require('../internals/an-object');\nvar toPrimitive = require('../internals/to-primitive');\nvar definePropertyModule = require('../internals/object-define-property');\nvar fails = require('../internals/fails');\n\n// MS Edge has broken Reflect.defineProperty - throwing instead of returning false\nvar ERROR_INSTEAD_OF_FALSE = fails(function () {\n  /* global Reflect -- required for testing */\n  Reflect.defineProperty(definePropertyModule.f({}, 1, { value: 1 }), 1, { value: 2 });\n});\n\n// `Reflect.defineProperty` method\n// https://tc39.es/ecma262/#sec-reflect.defineproperty\n$({ target: 'Reflect', stat: true, forced: ERROR_INSTEAD_OF_FALSE, sham: !DESCRIPTORS }, {\n  defineProperty: function defineProperty(target, propertyKey, attributes) {\n    anObject(target);\n    var key = toPrimitive(propertyKey, true);\n    anObject(attributes);\n    try {\n      definePropertyModule.f(target, key, attributes);\n      return true;\n    } catch (error) {\n      return false;\n    }\n  }\n});\n","var global = require('../internals/global');\n\nmodule.exports = global;\n","var fails = require('../internals/fails');\nvar classof = require('../internals/classof-raw');\n\nvar split = ''.split;\n\n// fallback for non-array-like ES3 and non-enumerable old V8 strings\nmodule.exports = fails(function () {\n  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346\n  // eslint-disable-next-line no-prototype-builtins -- safe\n  return !Object('z').propertyIsEnumerable(0);\n}) ? function (it) {\n  return classof(it) == 'String' ? split.call(it, '') : Object(it);\n} : Object;\n","var IS_NODE = require('../internals/engine-is-node');\nvar V8_VERSION = require('../internals/engine-v8-version');\nvar fails = require('../internals/fails');\n\nmodule.exports = !!Object.getOwnPropertySymbols && !fails(function () {\n  /* global Symbol -- required for testing */\n  return !Symbol.sham &&\n    // Chrome 38 Symbol has incorrect toString conversion\n    // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances\n    (IS_NODE ? V8_VERSION === 38 : V8_VERSION > 37 && V8_VERSION < 41);\n});\n","require('../../modules/es.reflect.apply');\nrequire('../../modules/es.reflect.construct');\nrequire('../../modules/es.reflect.define-property');\nrequire('../../modules/es.reflect.delete-property');\nrequire('../../modules/es.reflect.get');\nrequire('../../modules/es.reflect.get-own-property-descriptor');\nrequire('../../modules/es.reflect.get-prototype-of');\nrequire('../../modules/es.reflect.has');\nrequire('../../modules/es.reflect.is-extensible');\nrequire('../../modules/es.reflect.own-keys');\nrequire('../../modules/es.reflect.prevent-extensions');\nrequire('../../modules/es.reflect.set');\nrequire('../../modules/es.reflect.set-prototype-of');\nrequire('../../modules/es.reflect.to-string-tag');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Reflect;\n","var $ = require('../internals/export');\nvar getBuiltIn = require('../internals/get-built-in');\nvar aFunction = require('../internals/a-function');\nvar anObject = require('../internals/an-object');\nvar isObject = require('../internals/is-object');\nvar create = require('../internals/object-create');\nvar bind = require('../internals/function-bind');\nvar fails = require('../internals/fails');\n\nvar nativeConstruct = getBuiltIn('Reflect', 'construct');\n\n// `Reflect.construct` method\n// https://tc39.es/ecma262/#sec-reflect.construct\n// MS Edge supports only 2 arguments and argumentsList argument is optional\n// FF Nightly sets third argument as `new.target`, but does not create `this` from it\nvar NEW_TARGET_BUG = fails(function () {\n  function F() { /* empty */ }\n  return !(nativeConstruct(function () { /* empty */ }, [], F) instanceof F);\n});\nvar ARGS_BUG = !fails(function () {\n  nativeConstruct(function () { /* empty */ });\n});\nvar FORCED = NEW_TARGET_BUG || ARGS_BUG;\n\n$({ target: 'Reflect', stat: true, forced: FORCED, sham: FORCED }, {\n  construct: function construct(Target, args /* , newTarget */) {\n    aFunction(Target);\n    anObject(args);\n    var newTarget = arguments.length < 3 ? Target : aFunction(arguments[2]);\n    if (ARGS_BUG && !NEW_TARGET_BUG) return nativeConstruct(Target, args, newTarget);\n    if (Target == newTarget) {\n      // w/o altered newTarget, optimization for 0-4 arguments\n      switch (args.length) {\n        case 0: return new Target();\n        case 1: return new Target(args[0]);\n        case 2: return new Target(args[0], args[1]);\n        case 3: return new Target(args[0], args[1], args[2]);\n        case 4: return new Target(args[0], args[1], args[2], args[3]);\n      }\n      // w/o altered newTarget, lot of arguments case\n      var $args = [null];\n      $args.push.apply($args, args);\n      return new (bind.apply(Target, $args))();\n    }\n    // with altered newTarget, not support built-in constructors\n    var proto = newTarget.prototype;\n    var instance = create(isObject(proto) ? proto : Object.prototype);\n    var result = Function.apply.call(Target, instance, args);\n    return isObject(result) ? result : instance;\n  }\n});\n","var toIndexedObject = require('../internals/to-indexed-object');\nvar toLength = require('../internals/to-length');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\n\n// `Array.prototype.{ indexOf, includes }` methods implementation\nvar createMethod = function (IS_INCLUDES) {\n  return function ($this, el, fromIndex) {\n    var O = toIndexedObject($this);\n    var length = toLength(O.length);\n    var index = toAbsoluteIndex(fromIndex, length);\n    var value;\n    // Array#includes uses SameValueZero equality algorithm\n    // eslint-disable-next-line no-self-compare -- NaN check\n    if (IS_INCLUDES && el != el) while (length > index) {\n      value = O[index++];\n      // eslint-disable-next-line no-self-compare -- NaN check\n      if (value != value) return true;\n    // Array#indexOf ignores holes, Array#includes - not\n    } else for (;length > index; index++) {\n      if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;\n    } return !IS_INCLUDES && -1;\n  };\n};\n\nmodule.exports = {\n  // `Array.prototype.includes` method\n  // https://tc39.es/ecma262/#sec-array.prototype.includes\n  includes: createMethod(true),\n  // `Array.prototype.indexOf` method\n  // https://tc39.es/ecma262/#sec-array.prototype.indexof\n  indexOf: createMethod(false)\n};\n","var toInteger = require('../internals/to-integer');\n\nvar min = Math.min;\n\n// `ToLength` abstract operation\n// https://tc39.es/ecma262/#sec-tolength\nmodule.exports = function (argument) {\n  return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991\n};\n","var hasOwnProperty = {}.hasOwnProperty;\n\nmodule.exports = function (it, key) {\n  return hasOwnProperty.call(it, key);\n};\n","var IS_PURE = require('../internals/is-pure');\nvar store = require('../internals/shared-store');\n\n(module.exports = function (key, value) {\n  return store[key] || (store[key] = value !== undefined ? value : {});\n})('versions', []).push({\n  version: '3.9.1',\n  mode: IS_PURE ? 'pure' : 'global',\n  copyright: '© 2021 Denis Pushkarev (zloirock.ru)'\n});\n","var getBuiltIn = require('../internals/get-built-in');\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar anObject = require('../internals/an-object');\n\n// all object keys, includes non-enumerable and symbols\nmodule.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {\n  var keys = getOwnPropertyNamesModule.f(anObject(it));\n  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n  return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys;\n};\n","module.exports = function (bitmap, value) {\n  return {\n    enumerable: !(bitmap & 1),\n    configurable: !(bitmap & 2),\n    writable: !(bitmap & 4),\n    value: value\n  };\n};\n","var $ = require('../internals/export');\nvar isObject = require('../internals/is-object');\nvar anObject = require('../internals/an-object');\nvar has = require('../internals/has');\nvar getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\n\n// `Reflect.get` method\n// https://tc39.es/ecma262/#sec-reflect.get\nfunction get(target, propertyKey /* , receiver */) {\n  var receiver = arguments.length < 3 ? target : arguments[2];\n  var descriptor, prototype;\n  if (anObject(target) === receiver) return target[propertyKey];\n  if (descriptor = getOwnPropertyDescriptorModule.f(target, propertyKey)) return has(descriptor, 'value')\n    ? descriptor.value\n    : descriptor.get === undefined\n      ? undefined\n      : descriptor.get.call(receiver);\n  if (isObject(prototype = getPrototypeOf(target))) return get(prototype, propertyKey, receiver);\n}\n\n$({ target: 'Reflect', stat: true }, {\n  get: get\n});\n","var classof = require('../internals/classof-raw');\nvar global = require('../internals/global');\n\nmodule.exports = classof(global.process) == 'process';\n","var NATIVE_WEAK_MAP = require('../internals/native-weak-map');\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar objectHas = require('../internals/has');\nvar shared = require('../internals/shared-store');\nvar sharedKey = require('../internals/shared-key');\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar WeakMap = global.WeakMap;\nvar set, get, has;\n\nvar enforce = function (it) {\n  return has(it) ? get(it) : set(it, {});\n};\n\nvar getterFor = function (TYPE) {\n  return function (it) {\n    var state;\n    if (!isObject(it) || (state = get(it)).type !== TYPE) {\n      throw TypeError('Incompatible receiver, ' + TYPE + ' required');\n    } return state;\n  };\n};\n\nif (NATIVE_WEAK_MAP) {\n  var store = shared.state || (shared.state = new WeakMap());\n  var wmget = store.get;\n  var wmhas = store.has;\n  var wmset = store.set;\n  set = function (it, metadata) {\n    metadata.facade = it;\n    wmset.call(store, it, metadata);\n    return metadata;\n  };\n  get = function (it) {\n    return wmget.call(store, it) || {};\n  };\n  has = function (it) {\n    return wmhas.call(store, it);\n  };\n} else {\n  var STATE = sharedKey('state');\n  hiddenKeys[STATE] = true;\n  set = function (it, metadata) {\n    metadata.facade = it;\n    createNonEnumerableProperty(it, STATE, metadata);\n    return metadata;\n  };\n  get = function (it) {\n    return objectHas(it, STATE) ? it[STATE] : {};\n  };\n  has = function (it) {\n    return objectHas(it, STATE);\n  };\n}\n\nmodule.exports = {\n  set: set,\n  get: get,\n  has: has,\n  enforce: enforce,\n  getterFor: getterFor\n};\n","var global = require('../internals/global');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar has = require('../internals/has');\nvar setGlobal = require('../internals/set-global');\nvar inspectSource = require('../internals/inspect-source');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar getInternalState = InternalStateModule.get;\nvar enforceInternalState = InternalStateModule.enforce;\nvar TEMPLATE = String(String).split('String');\n\n(module.exports = function (O, key, value, options) {\n  var unsafe = options ? !!options.unsafe : false;\n  var simple = options ? !!options.enumerable : false;\n  var noTargetGet = options ? !!options.noTargetGet : false;\n  var state;\n  if (typeof value == 'function') {\n    if (typeof key == 'string' && !has(value, 'name')) {\n      createNonEnumerableProperty(value, 'name', key);\n    }\n    state = enforceInternalState(value);\n    if (!state.source) {\n      state.source = TEMPLATE.join(typeof key == 'string' ? key : '');\n    }\n  }\n  if (O === global) {\n    if (simple) O[key] = value;\n    else setGlobal(key, value);\n    return;\n  } else if (!unsafe) {\n    delete O[key];\n  } else if (!noTargetGet && O[key]) {\n    simple = true;\n  }\n  if (simple) O[key] = value;\n  else createNonEnumerableProperty(O, key, value);\n// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative\n})(Function.prototype, 'toString', function toString() {\n  return typeof this == 'function' && getInternalState(this).source || inspectSource(this);\n});\n","exports.f = Object.getOwnPropertySymbols;\n","// IE8- don't enum bug keys\nmodule.exports = [\n  'constructor',\n  'hasOwnProperty',\n  'isPrototypeOf',\n  'propertyIsEnumerable',\n  'toLocaleString',\n  'toString',\n  'valueOf'\n];\n","var requireObjectCoercible = require('../internals/require-object-coercible');\n\n// `ToObject` abstract operation\n// https://tc39.es/ecma262/#sec-toobject\nmodule.exports = function (argument) {\n  return Object(requireObjectCoercible(argument));\n};\n","var $ = require('../internals/export');\nvar anObject = require('../internals/an-object');\nvar objectGetPrototypeOf = require('../internals/object-get-prototype-of');\nvar CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter');\n\n// `Reflect.getPrototypeOf` method\n// https://tc39.es/ecma262/#sec-reflect.getprototypeof\n$({ target: 'Reflect', stat: true, sham: !CORRECT_PROTOTYPE_GETTER }, {\n  getPrototypeOf: function getPrototypeOf(target) {\n    return objectGetPrototypeOf(anObject(target));\n  }\n});\n","var global = require('../internals/global');\nvar inspectSource = require('../internals/inspect-source');\n\nvar WeakMap = global.WeakMap;\n\nmodule.exports = typeof WeakMap === 'function' && /native code/.test(inspectSource(WeakMap));\n","var anObject = require('../internals/an-object');\nvar defineProperties = require('../internals/object-define-properties');\nvar enumBugKeys = require('../internals/enum-bug-keys');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar html = require('../internals/html');\nvar documentCreateElement = require('../internals/document-create-element');\nvar sharedKey = require('../internals/shared-key');\n\nvar GT = '>';\nvar LT = '<';\nvar PROTOTYPE = 'prototype';\nvar SCRIPT = 'script';\nvar IE_PROTO = sharedKey('IE_PROTO');\n\nvar EmptyConstructor = function () { /* empty */ };\n\nvar scriptTag = function (content) {\n  return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;\n};\n\n// Create object with fake `null` prototype: use ActiveX Object with cleared prototype\nvar NullProtoObjectViaActiveX = function (activeXDocument) {\n  activeXDocument.write(scriptTag(''));\n  activeXDocument.close();\n  var temp = activeXDocument.parentWindow.Object;\n  activeXDocument = null; // avoid memory leak\n  return temp;\n};\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar NullProtoObjectViaIFrame = function () {\n  // Thrash, waste and sodomy: IE GC bug\n  var iframe = documentCreateElement('iframe');\n  var JS = 'java' + SCRIPT + ':';\n  var iframeDocument;\n  iframe.style.display = 'none';\n  html.appendChild(iframe);\n  // https://github.com/zloirock/core-js/issues/475\n  iframe.src = String(JS);\n  iframeDocument = iframe.contentWindow.document;\n  iframeDocument.open();\n  iframeDocument.write(scriptTag('document.F=Object'));\n  iframeDocument.close();\n  return iframeDocument.F;\n};\n\n// Check for document.domain and active x support\n// No need to use active x approach when document.domain is not set\n// see https://github.com/es-shims/es5-shim/issues/150\n// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346\n// avoid IE GC bug\nvar activeXDocument;\nvar NullProtoObject = function () {\n  try {\n    /* global ActiveXObject -- old IE */\n    activeXDocument = document.domain && new ActiveXObject('htmlfile');\n  } catch (error) { /* ignore */ }\n  NullProtoObject = activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame();\n  var length = enumBugKeys.length;\n  while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];\n  return NullProtoObject();\n};\n\nhiddenKeys[IE_PROTO] = true;\n\n// `Object.create` method\n// https://tc39.es/ecma262/#sec-object.create\nmodule.exports = Object.create || function create(O, Properties) {\n  var result;\n  if (O !== null) {\n    EmptyConstructor[PROTOTYPE] = anObject(O);\n    result = new EmptyConstructor();\n    EmptyConstructor[PROTOTYPE] = null;\n    // add \"__proto__\" for Object.getPrototypeOf polyfill\n    result[IE_PROTO] = O;\n  } else result = NullProtoObject();\n  return Properties === undefined ? result : defineProperties(result, Properties);\n};\n","var $ = require('../internals/export');\nvar anObject = require('../internals/an-object');\nvar isObject = require('../internals/is-object');\nvar has = require('../internals/has');\nvar fails = require('../internals/fails');\nvar definePropertyModule = require('../internals/object-define-property');\nvar getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\n// `Reflect.set` method\n// https://tc39.es/ecma262/#sec-reflect.set\nfunction set(target, propertyKey, V /* , receiver */) {\n  var receiver = arguments.length < 4 ? target : arguments[3];\n  var ownDescriptor = getOwnPropertyDescriptorModule.f(anObject(target), propertyKey);\n  var existingDescriptor, prototype;\n  if (!ownDescriptor) {\n    if (isObject(prototype = getPrototypeOf(target))) {\n      return set(prototype, propertyKey, V, receiver);\n    }\n    ownDescriptor = createPropertyDescriptor(0);\n  }\n  if (has(ownDescriptor, 'value')) {\n    if (ownDescriptor.writable === false || !isObject(receiver)) return false;\n    if (existingDescriptor = getOwnPropertyDescriptorModule.f(receiver, propertyKey)) {\n      if (existingDescriptor.get || existingDescriptor.set || existingDescriptor.writable === false) return false;\n      existingDescriptor.value = V;\n      definePropertyModule.f(receiver, propertyKey, existingDescriptor);\n    } else definePropertyModule.f(receiver, propertyKey, createPropertyDescriptor(0, V));\n    return true;\n  }\n  return ownDescriptor.set === undefined ? false : (ownDescriptor.set.call(receiver, V), true);\n}\n\n// MS Edge 17-18 Reflect.set allows setting the property to object\n// with non-writable property on the prototype\nvar MS_EDGE_BUG = fails(function () {\n  var Constructor = function () { /* empty */ };\n  var object = definePropertyModule.f(new Constructor(), 'a', { configurable: true });\n  /* global Reflect -- required for testing */\n  return Reflect.set(Constructor.prototype, 'a', 1, object) !== false;\n});\n\n$({ target: 'Reflect', stat: true, forced: MS_EDGE_BUG }, {\n  set: set\n});\n","var fails = require('../internals/fails');\n\n// Detect IE8's incomplete defineProperty implementation\nmodule.exports = !fails(function () {\n  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;\n});\n","var isObject = require('../internals/is-object');\n\nmodule.exports = function (it) {\n  if (!isObject(it)) {\n    throw TypeError(String(it) + ' is not an object');\n  } return it;\n};\n","/**\n * This file includes polyfills needed by Angular and is loaded before the app.\n * You can add your own extra polyfills to this file.\n *\n * This file is divided into 2 sections:\n *   1. Browser polyfills. These are applied before loading ZoneJS and are sorted by browsers.\n *   2. Application imports. Files imported after ZoneJS that should be loaded before your main\n *      file.\n *\n * The current setup is for so-called \"evergreen\" browsers; the last versions of browsers that\n * automatically update themselves. This includes Safari >= 10, Chrome >= 55 (including Opera),\n * Edge >= 13 on the desktop, and iOS 10 and Chrome on mobile.\n *\n * Learn more in https://angular.io/docs/ts/latest/guide/browser-support.html\n */\n\n/***************************************************************************************************\n * BROWSER POLYFILLS\n */\n\n/** IE9, IE10 and IE11 requires all of the following polyfills. **/\n// import 'core-js/es6/symbol';\n// import 'core-js/es6/object';\n// import 'core-js/es6/function';\n// import 'core-js/es6/parse-int';\n// import 'core-js/es6/parse-float';\n// import 'core-js/es6/number';\n// import 'core-js/es6/math';\n// import 'core-js/es6/string';\n// import 'core-js/es6/date';\n// import 'core-js/es6/array';\n// import 'core-js/es6/regexp';\n// import 'core-js/es6/map';\n// import 'core-js/es6/weak-map';\n// import 'core-js/es6/set';\n\n/** IE10 and IE11 requires the following for NgClass support on SVG elements */\n// import 'classlist.js';  // Run `npm install --save classlist.js`.\n\n/** IE10 and IE11 requires the following for the Reflect API. */\n// import 'core-js/es6/reflect';\n\n\n/** Evergreen browsers require these. **/\n// Used for reflect-metadata in JIT. If you use AOT (and only Angular decorators), you can remove.\nimport 'core-js/es/reflect';\n\n\n/**\n * Web Animations `@angular/platform-browser/animations`\n * Only required if AnimationBuilder is used within the application and using IE/Edge or Safari.\n * Standard animation support in Angular DOES NOT require any polyfills (as of Angular 6.0).\n **/\n// import 'web-animations-js';  // Run `npm install --save web-animations-js`.\n\n/**\n * By default, zone.js will patch all possible macroTask and DomEvents\n * user can disable parts of macroTask/DomEvents patch by setting following flags\n */\n\n // (window as any).__Zone_disable_requestAnimationFrame = true; // disable patch requestAnimationFrame\n // (window as any).__Zone_disable_on_property = true; // disable patch onProperty such as onclick\n // (window as any).__zone_symbol__BLACK_LISTED_EVENTS = ['scroll', 'mousemove']; // disable patch specified eventNames\n\n /*\n * in IE/Edge developer tools, the addEventListener will also be wrapped by zone.js\n * with the following flag, it will bypass `zone.js` patch for IE/Edge\n */\n// (window as any).__Zone_enable_cross_context_check = true;\n\n/***************************************************************************************************\n * Zone JS is required by default for Angular itself.\n */\nimport 'zone.js/dist/zone';  // Included with Angular CLI.\n\n\n\n/***************************************************************************************************\n * APPLICATION IMPORTS\n */\n","module.exports = function (it) {\n  return typeof it === 'object' ? it !== null : typeof it === 'function';\n};\n","var $ = require('../internals/export');\nvar anObject = require('../internals/an-object');\nvar aPossiblePrototype = require('../internals/a-possible-prototype');\nvar objectSetPrototypeOf = require('../internals/object-set-prototype-of');\n\n// `Reflect.setPrototypeOf` method\n// https://tc39.es/ecma262/#sec-reflect.setprototypeof\nif (objectSetPrototypeOf) $({ target: 'Reflect', stat: true }, {\n  setPrototypeOf: function setPrototypeOf(target, proto) {\n    anObject(target);\n    aPossiblePrototype(proto);\n    try {\n      objectSetPrototypeOf(target, proto);\n      return true;\n    } catch (error) {\n      return false;\n    }\n  }\n});\n","var store = require('../internals/shared-store');\n\nvar functionToString = Function.toString;\n\n// this helper broken in `3.4.1-3.4.4`, so we can't use `shared` helper\nif (typeof store.inspectSource != 'function') {\n  store.inspectSource = function (it) {\n    return functionToString.call(it);\n  };\n}\n\nmodule.exports = store.inspectSource;\n","(typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}).SENTRY_RELEASE={id:\"18b05d6\"};","var id = 0;\nvar postfix = Math.random();\n\nmodule.exports = function (key) {\n  return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id + postfix).toString(36);\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = DESCRIPTORS ? function (object, key, value) {\n  return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));\n} : function (object, key, value) {\n  object[key] = value;\n  return object;\n};\n","var fails = require('../internals/fails');\n\nvar replacement = /#|\\.prototype\\./;\n\nvar isForced = function (feature, detection) {\n  var value = data[normalize(feature)];\n  return value == POLYFILL ? true\n    : value == NATIVE ? false\n    : typeof detection == 'function' ? fails(detection)\n    : !!detection;\n};\n\nvar normalize = isForced.normalize = function (string) {\n  return String(string).replace(replacement, '.').toLowerCase();\n};\n\nvar data = isForced.data = {};\nvar NATIVE = isForced.NATIVE = 'N';\nvar POLYFILL = isForced.POLYFILL = 'P';\n\nmodule.exports = isForced;\n","var DESCRIPTORS = require('../internals/descriptors');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\nvar anObject = require('../internals/an-object');\nvar toPrimitive = require('../internals/to-primitive');\n\nvar nativeDefineProperty = Object.defineProperty;\n\n// `Object.defineProperty` method\n// https://tc39.es/ecma262/#sec-object.defineproperty\nexports.f = DESCRIPTORS ? nativeDefineProperty : function defineProperty(O, P, Attributes) {\n  anObject(O);\n  P = toPrimitive(P, true);\n  anObject(Attributes);\n  if (IE8_DOM_DEFINE) try {\n    return nativeDefineProperty(O, P, Attributes);\n  } catch (error) { /* empty */ }\n  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');\n  if ('value' in Attributes) O[P] = Attributes.value;\n  return O;\n};\n","var $ = require('../internals/export');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar anObject = require('../internals/an-object');\nvar getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');\n\n// `Reflect.getOwnPropertyDescriptor` method\n// https://tc39.es/ecma262/#sec-reflect.getownpropertydescriptor\n$({ target: 'Reflect', stat: true, sham: !DESCRIPTORS }, {\n  getOwnPropertyDescriptor: function getOwnPropertyDescriptor(target, propertyKey) {\n    return getOwnPropertyDescriptorModule.f(anObject(target), propertyKey);\n  }\n});\n","var ceil = Math.ceil;\nvar floor = Math.floor;\n\n// `ToInteger` abstract operation\n// https://tc39.es/ecma262/#sec-tointeger\nmodule.exports = function (argument) {\n  return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument);\n};\n","var $ = require('../internals/export');\nvar getBuiltIn = require('../internals/get-built-in');\nvar aFunction = require('../internals/a-function');\nvar anObject = require('../internals/an-object');\nvar fails = require('../internals/fails');\n\nvar nativeApply = getBuiltIn('Reflect', 'apply');\nvar functionApply = Function.apply;\n\n// MS Edge argumentsList argument is optional\nvar OPTIONAL_ARGUMENTS_LIST = !fails(function () {\n  nativeApply(function () { /* empty */ });\n});\n\n// `Reflect.apply` method\n// https://tc39.es/ecma262/#sec-reflect.apply\n$({ target: 'Reflect', stat: true, forced: OPTIONAL_ARGUMENTS_LIST }, {\n  apply: function apply(target, thisArgument, argumentsList) {\n    aFunction(target);\n    anObject(argumentsList);\n    return nativeApply\n      ? nativeApply(target, thisArgument, argumentsList)\n      : functionApply.call(target, thisArgument, argumentsList);\n  }\n});\n","var $ = require('../internals/export');\nvar anObject = require('../internals/an-object');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\n\n// `Reflect.deleteProperty` method\n// https://tc39.es/ecma262/#sec-reflect.deleteproperty\n$({ target: 'Reflect', stat: true }, {\n  deleteProperty: function deleteProperty(target, propertyKey) {\n    var descriptor = getOwnPropertyDescriptor(anObject(target), propertyKey);\n    return descriptor && !descriptor.configurable ? false : delete target[propertyKey];\n  }\n});\n","var global = require('../internals/global');\nvar shared = require('../internals/shared');\nvar has = require('../internals/has');\nvar uid = require('../internals/uid');\nvar NATIVE_SYMBOL = require('../internals/native-symbol');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar WellKnownSymbolsStore = shared('wks');\nvar Symbol = global.Symbol;\nvar createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol : Symbol && Symbol.withoutSetter || uid;\n\nmodule.exports = function (name) {\n  if (!has(WellKnownSymbolsStore, name) || !(NATIVE_SYMBOL || typeof WellKnownSymbolsStore[name] == 'string')) {\n    if (NATIVE_SYMBOL && has(Symbol, name)) {\n      WellKnownSymbolsStore[name] = Symbol[name];\n    } else {\n      WellKnownSymbolsStore[name] = createWellKnownSymbol('Symbol.' + name);\n    }\n  } return WellKnownSymbolsStore[name];\n};\n","var fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n  return Object.isExtensible(Object.preventExtensions({}));\n});\n","var isObject = require('../internals/is-object');\n\n// `ToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-toprimitive\n// instead of the ES6 spec version, we didn't implement @@toPrimitive case\n// and the second argument - flag - preferred type is a string\nmodule.exports = function (input, PREFERRED_STRING) {\n  if (!isObject(input)) return input;\n  var fn, val;\n  if (PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;\n  if (typeof (fn = input.valueOf) == 'function' && !isObject(val = fn.call(input))) return val;\n  if (!PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;\n  throw TypeError(\"Can't convert object to primitive value\");\n};\n","var $ = require('../internals/export');\n\n// `Reflect.has` method\n// https://tc39.es/ecma262/#sec-reflect.has\n$({ target: 'Reflect', stat: true }, {\n  has: function has(target, propertyKey) {\n    return propertyKey in target;\n  }\n});\n","module.exports = false;\n","var toString = {}.toString;\n\nmodule.exports = function (it) {\n  return toString.call(it).slice(8, -1);\n};\n","var global = require('../internals/global');\nvar setGlobal = require('../internals/set-global');\n\nvar SHARED = '__core-js_shared__';\nvar store = global[SHARED] || setGlobal(SHARED, {});\n\nmodule.exports = store;\n","var has = require('../internals/has');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar indexOf = require('../internals/array-includes').indexOf;\nvar hiddenKeys = require('../internals/hidden-keys');\n\nmodule.exports = function (object, names) {\n  var O = toIndexedObject(object);\n  var i = 0;\n  var result = [];\n  var key;\n  for (key in O) !has(hiddenKeys, key) && has(O, key) && result.push(key);\n  // Don't enum bug & hidden keys\n  while (names.length > i) if (has(O, key = names[i++])) {\n    ~indexOf(result, key) || result.push(key);\n  }\n  return result;\n};\n","var global = require('../internals/global');\nvar isObject = require('../internals/is-object');\n\nvar document = global.document;\n// typeof document.createElement is 'object' in old IE\nvar EXISTS = isObject(document) && isObject(document.createElement);\n\nmodule.exports = function (it) {\n  return EXISTS ? document.createElement(it) : {};\n};\n","var global = require('../internals/global');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\n\nmodule.exports = function (key, value) {\n  try {\n    createNonEnumerableProperty(global, key, value);\n  } catch (error) {\n    global[key] = value;\n  } return value;\n};\n"],"sourceRoot":"webpack:///"}