{"version":3,"sources":["webpack:///node_modules/url-polyfill/url-polyfill.js","webpack:///node_modules/zone.js/fesm2015/zone.js","webpack:///node_modules/core-js/es/array/includes.js","webpack:///node_modules/core-js/es/object/entries.js","webpack:///node_modules/core-js/es/object/values.js","webpack:///node_modules/core-js/es/string/includes.js","webpack:///node_modules/core-js/internals/a-function.js","webpack:///node_modules/core-js/internals/add-to-unscopables.js","webpack:///node_modules/core-js/internals/an-object.js","webpack:///node_modules/core-js/internals/array-includes.js","webpack:///node_modules/core-js/internals/classof-raw.js","webpack:///node_modules/core-js/internals/copy-constructor-properties.js","webpack:///node_modules/core-js/internals/correct-is-regexp-logic.js","webpack:///node_modules/core-js/internals/create-non-enumerable-property.js","webpack:///node_modules/core-js/internals/create-property-descriptor.js","webpack:///node_modules/core-js/internals/descriptors.js","webpack:///node_modules/core-js/internals/document-create-element.js","webpack:///node_modules/core-js/internals/engine-user-agent.js","webpack:///node_modules/core-js/internals/engine-v8-version.js","webpack:///node_modules/core-js/internals/entry-unbind.js","webpack:///node_modules/core-js/internals/enum-bug-keys.js","webpack:///node_modules/core-js/internals/export.js","webpack:///node_modules/core-js/internals/fails.js","webpack:///node_modules/core-js/internals/function-bind-context.js","webpack:///node_modules/core-js/internals/get-built-in.js","webpack:///node_modules/core-js/internals/global.js","webpack:///node_modules/core-js/internals/has.js","webpack:///node_modules/core-js/internals/hidden-keys.js","webpack:///node_modules/core-js/internals/html.js","webpack:///node_modules/core-js/internals/ie8-dom-define.js","webpack:///node_modules/core-js/internals/indexed-object.js","webpack:///node_modules/core-js/internals/inspect-source.js","webpack:///node_modules/core-js/internals/internal-state.js","webpack:///node_modules/core-js/internals/is-forced.js","webpack:///node_modules/core-js/internals/is-object.js","webpack:///node_modules/core-js/internals/is-pure.js","webpack:///node_modules/core-js/internals/is-regexp.js","webpack:///node_modules/core-js/internals/native-symbol.js","webpack:///node_modules/core-js/internals/native-weak-map.js","webpack:///node_modules/core-js/internals/not-a-regexp.js","webpack:///node_modules/core-js/internals/object-create.js","webpack:///node_modules/core-js/internals/object-define-properties.js","webpack:///node_modules/core-js/internals/object-define-property.js","webpack:///node_modules/core-js/internals/object-get-own-property-descriptor.js","webpack:///node_modules/core-js/internals/object-get-own-property-names.js","webpack:///node_modules/core-js/internals/object-get-own-property-symbols.js","webpack:///node_modules/core-js/internals/object-keys-internal.js","webpack:///node_modules/core-js/internals/object-keys.js","webpack:///node_modules/core-js/internals/object-property-is-enumerable.js","webpack:///node_modules/core-js/internals/object-to-array.js","webpack:///node_modules/core-js/internals/own-keys.js","webpack:///node_modules/core-js/internals/path.js","webpack:///node_modules/core-js/internals/redefine.js","webpack:///node_modules/core-js/internals/require-object-coercible.js","webpack:///node_modules/core-js/internals/set-global.js","webpack:///node_modules/core-js/internals/shared-key.js","webpack:///node_modules/core-js/internals/shared-store.js","webpack:///node_modules/core-js/internals/shared.js","webpack:///node_modules/core-js/internals/to-absolute-index.js","webpack:///node_modules/core-js/internals/to-indexed-object.js","webpack:///node_modules/core-js/internals/to-integer.js","webpack:///node_modules/core-js/internals/to-length.js","webpack:///node_modules/core-js/internals/to-object.js","webpack:///node_modules/core-js/internals/to-primitive.js","webpack:///node_modules/core-js/internals/uid.js","webpack:///node_modules/core-js/internals/use-symbol-as-uid.js","webpack:///node_modules/core-js/internals/well-known-symbol.js","webpack:///node_modules/core-js/modules/es.array.includes.js","webpack:///node_modules/core-js/modules/es.object.entries.js","webpack:///node_modules/core-js/modules/es.object.values.js","webpack:///node_modules/core-js/modules/es.string.includes.js"],"names":["global","iteratorSupported","Symbol","iterator","error","createIterator","items","next","value","shift","done","serializeParam","encodeURIComponent","replace","deserializeParam","decodeURIComponent","String","URLSearchParams","toString","prototype","set","entries","e","searchString","Object","defineProperty","this","writable","typeofSearchString","_fromString","_this","forEach","name","append","TypeError","call","i","length","entry","key","hasOwnProperty","proto","_entries","push","delete","get","getAll","slice","has","callback","thisArg","keys","values","searchArray","join","sort","a","b","enumerable","configurable","attribute","attributes","split","window","self","_URL","URL","u","pathname","href","searchParams","url","base","baseElement","doc","document","location","toLowerCase","implementation","createHTMLDocument","createElement","head","appendChild","indexOf","Error","err","anchorElement","body","inputElement","type","protocol","test","checkValidity","search","enableSearchUpdate","enableSearchParamsUpdate","methodName","method","apply","arguments","attributeName","_anchorElement","_updateSearchParams","defineProperties","hostname","port","createObjectURL","blob","revokeObjectURL","getOrigin","setInterval","origin","performance","mark","performanceMeasure","label","symbolPrefix","__symbol__","checkDuplicate","Zone","constructor","parent","zoneSpec","_parent","_name","_properties","properties","_zoneDelegate","ZoneDelegate","patches","zone","current","_currentZoneFrame","_currentTask","fn","ignoreDuplicate","perfName","_api","getZoneWith","fork","wrap","source","_callback","intercept","runGuarded","run","applyThis","applyArgs","invoke","handleError","runTask","task","NO_ZONE","state","notScheduled","eventTask","macroTask","reEntryGuard","running","_transitionTo","scheduled","runCount","previousTask","data","isPeriodic","cancelFn","undefined","invokeTask","unknown","_updateTaskCount","scheduleTask","newZone","scheduling","zoneDelegates","_zoneDelegates","_zone","scheduleMicroTask","customSchedule","ZoneTask","microTask","scheduleMacroTask","customCancel","scheduleEventTask","cancelTask","canceling","count","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","returnTask","scheduleFn","isEmpty","counts","prev","change","options","_state","useG","args","_numberOfNestedTaskFrames","drainMicroTaskQueue","cancelScheduleRequest","toState","fromState1","fromState2","handleId","toJSON","symbolSetTimeout","symbolPromise","symbolThen","nativeMicroTaskQueuePromise","_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","getOwnPropertyDescriptor","ObjectGetPrototypeOf","getPrototypeOf","create","Array","ZONE_SYMBOL_ADD_EVENT_LISTENER","ZONE_SYMBOL_REMOVE_EVENT_LISTENER","ZONE_SYMBOL_PREFIX","scheduleMacroTaskWithCurrentZone","zoneSymbol","isWindowExists","internalWindow","_global","NULL_ON_PROP_VALUE","isPropertyWritable","propertyDesc","isWebWorker","WorkerGlobalScope","isNode","process","isBrowser","isMix","zoneSymbolEventNames","wrapFn","event","eventNameSymbol","listener","result","errorEvent","message","filename","lineno","colno","preventDefault","patchProperty","obj","prop","desc","onPropPatchedSymbol","originalDescGet","originalDescSet","eventName","substr","newValue","removeEventListener","addEventListener","removeAttribute","onProperties","j","originalInstanceKey","className","OriginalClass","instance","patchFn","delegateName","patchDelegate","funcName","metaCreator","setNative","cbIdx","meta","patched","original","isDetectedIEOrEdge","ieOrEdge","isIE","ua","navigator","userAgent","__load_patch","api","_uncaughtPromiseErrors","isDisableWrappingUncaughtPromiseRejection","rejection","console","stack","uncaughtPromiseError","throwOriginal","handleUnhandledRejection","UNHANDLED_PROMISE_REJECTION_HANDLER_SYMBOL","handler","isThenable","then","forwardResolution","forwardRejection","ZoneAwarePromise","reject","symbolState","symbolValue","symbolFinally","symbolParentPromiseValue","symbolParentPromiseState","makeResolver","promise","v","resolvePromise","CURRENT_TASK_TRACE_SYMBOL","onceWrapper","wasCalled","wrappedFunction","clearRejectedNoCatch","trace","currentTask","scheduleResolveOrReject","JSON","stringify","REJECTION_HANDLED_HANDLER","splice","chainPromise","onFulfilled","onRejected","promiseState","parentPromiseValue","isFinallyPromise","res","rej","onResolve","onReject","allWithCallback","thenCallback","status","errorCallback","reason","unresolvedCount","valueIndex","resolvedValues","curValueIndex","thenErr","executor","toStringTag","species","C","catch","finally","onFinally","race","all","NativePromise","symbolThenPatched","Ctor","originalThen","zoneify","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","taskData","nativeAddEventListener","nativeRemoveEventListener","nativeListeners","nativeRemoveAllListeners","nativePrependEventListener","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","match","exec","evtName","results","foundTasks","captureFalseTasks","captureTrueTasks","concat","Event","targetName","callbacks","nativeDelegate","opts","descriptor","windowEventNames","mediaElementEventNames","frameEventNames","frameSetEventNames","marqueeEventNames","XMLHttpRequestEventNames","IDBIndexEventNames","websocketEventNames","workerEventNames","eventNames","ignoreProperties","tip","filter","ip","targetIgnoreProperties","op","patchFilteredProperties","propertyDescriptorPatch","supportsWebSocket","WebSocket","ignoreErrorProperties","Document","Element","HTMLElement","HTMLMediaElement","HTMLFrameSetElement","HTMLBodyElement","HTMLFrameElement","HTMLIFrameElement","HTMLMarqueeElement","Worker","XMLHttpRequest","XMLHttpRequestEventTarget","IDBIndex","IDBRequest","IDBOpenDBRequest","IDBDatabase","IDBTransaction","IDBCursor","SYMBOL_BLACK_LISTED_EVENTS","SYMBOL_UNPATCHED_EVENTS","TRUE_STR","FALSE_STR","ADD_EVENT_LISTENER_STR","REMOVE_EVENT_LISTENER_STR","taskSymbol","patchTimer","setName","cancelName","nameSuffix","clearNative","tasksByHandleId","clearTask","delay","handle","ref","unref","bind","id","eventTargetPatch","EVENT_TARGET","legacyPatch","blockingMethods","s","customElements","XMLHttpRequestPrototype","oriAddListener","oriRemoveListener","XMLHttpRequestEventTargetPrototype","XHR_SCHEDULED","XHR_ERROR_BEFORE_SCHEDULED","XHR_LISTENER","newListener","readyState","DONE","aborted","loadTasks","oriInvoke","XHR_TASK","sendNative","placeholderCallback","abortNative","openNative","XHR_SYNC","XHR_URL","fetchTaskAborting","fetchTaskScheduling","geolocation","fnNames","findPromiseRejectionHandler","PromiseRejectionEvent","evt","entryUnbind","module","exports","path","it","wellKnownSymbol","definePropertyModule","UNSCOPABLES","ArrayPrototype","f","isObject","toIndexedObject","toLength","toAbsoluteIndex","createMethod","IS_INCLUDES","$this","el","fromIndex","O","index","includes","ownKeys","getOwnPropertyDescriptorModule","MATCH","METHOD_NAME","regexp","error1","error2","DESCRIPTORS","createPropertyDescriptor","object","bitmap","fails","EXISTS","getBuiltIn","version","versions","v8","CONSTRUCTOR","METHOD","createNonEnumerableProperty","redefine","setGlobal","copyConstructorProperties","isForced","targetProperty","sourceProperty","TARGET","GLOBAL","STATIC","stat","noTargetGet","forced","sham","aFunction","that","c","variable","namespace","check","Math","globalThis","toObject","hasOwn","classof","propertyIsEnumerable","store","functionToString","inspectSource","NATIVE_WEAK_MAP","objectHas","shared","sharedKey","hiddenKeys","WeakMap","wmget","wmhas","wmset","metadata","facade","STATE","enforce","getterFor","TYPE","replacement","feature","detection","normalize","POLYFILL","NATIVE","string","isRegExp","V8_VERSION","getOwnPropertySymbols","activeXDocument","anObject","enumBugKeys","html","documentCreateElement","IE_PROTO","EmptyConstructor","scriptTag","content","LT","NullProtoObject","domain","ActiveXObject","iframeDocument","iframe","write","close","temp","parentWindow","style","display","src","contentWindow","open","F","Properties","objectKeys","IE8_DOM_DEFINE","toPrimitive","$defineProperty","P","Attributes","propertyIsEnumerableModule","$getOwnPropertyDescriptor","internalObjectKeys","getOwnPropertyNames","names","$propertyIsEnumerable","NASHORN_BUG","1","V","TO_ENTRIES","getOwnPropertyNamesModule","getOwnPropertySymbolsModule","InternalStateModule","getInternalState","enforceInternalState","TEMPLATE","unsafe","simple","uid","IS_PURE","mode","copyright","toInteger","max","min","integer","IndexedObject","requireObjectCoercible","ceil","floor","argument","isNaN","input","PREFERRED_STRING","val","valueOf","postfix","random","NATIVE_SYMBOL","USE_SYMBOL_AS_UID","WellKnownSymbolsStore","createWellKnownSymbol","withoutSetter","$","$includes","addToUnscopables","$entries","$values","notARegExp"],"mappings":"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H,EAAIzE,sBAAsBzF,EAAO7F,GAASwa,GAU9C,MAwGMG,EAAmB,CACrB,4BACA,aACA,aACA,eACA,sBACA,cACA,eACA,cACA,eACA,oBACA,4BACA,kBACA,aACA,iBACA,UACA,iBACA,UACA,SACA,QACA,WACA,WACA,WACA,mBACA,UACA,qBACA,SACA,gBACA,qBACA,wBACA,0BAOEC,EAAyB,CAAC,YAAa,gBAAiB,YAAa,oBAAqB,mBA6D1FC,EAAkB,CAAC,QACnBC,EAAqB,CAAC,OAAQ,QAAS,QAAS,OAAQ,SAAU,SAAU,gBAC5EC,EAAoB,CAAC,SAAU,SAAU,SACzCC,EAA2B,CAC7B,YAAa,WAAY,QAAS,QAAS,OAAQ,WAAY,UAAW,UAC1E,oBAEEC,EAAqB,CAAC,gBAAiB,WAAY,QAAS,UAAW,QAAS,UAAW,gBAAiB,SAC5GC,EAAsB,CAAC,QAAS,QAAS,OAAQ,WACjDC,EAAmB,CAAC,QAAS,WAC7BC,GApNgC,CAClC,QACA,kBACA,eACA,qBACA,WACA,cACA,OACA,SACA,UACA,iBACA,SACA,mBACA,oBACA,iBACA,YACA,QACA,QACA,cACA,aACA,WACA,OACA,UACA,YACA,WACA,YACA,WACA,OACA,iBACA,UACA,QACA,QACA,QACA,UACA,WACA,oBACA,QACA,UACA,UACA,WACA,QACA,OACA,YACA,aACA,iBACA,qBACA,YACA,aACA,aACA,YACA,WACA,YACA,UACA,aACA,oBACA,QACA,OACA,UACA,gBACA,cACA,eACA,eACA,oBACA,uBACA,4BACA,mBACA,sBACA,yBACA,cACA,WACA,cACA,YACA,WACA,aACA,QACA,SACA,SACA,SACA,UACA,SACA,kBACA,cACA,OACA,OACA,UACA,SACA,UACA,aACA,eACA,cACA,YACA,aACA,WACA,mBACA,gBACA,UACA,SAoH6ChB,OAbzB,CAAC,uBAAwB,mBAAoB,6BAC9C,CAAC,eAAgB,qBACf,CAAC,UAvGC,CACvB,qBAAsB,sBAAuB,mBAAoB,SAAU,mBAC3E,sBAAuB,yBAA0B,qBAAsB,kBACvE,qBAAsB,wBAAyB,oBAAqB,m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","file":"x","sourcesContent":["(function(global) {\r\n  /**\r\n   * Polyfill URLSearchParams\r\n   *\r\n   * Inspired from : https://github.com/WebReflection/url-search-params/blob/master/src/url-search-params.js\r\n   */\r\n\r\n  var checkIfIteratorIsSupported = function() {\r\n    try {\r\n      return !!Symbol.iterator;\r\n    } catch (error) {\r\n      return false;\r\n    }\r\n  };\r\n\r\n\r\n  var iteratorSupported = checkIfIteratorIsSupported();\r\n\r\n  var createIterator = function(items) {\r\n    var iterator = {\r\n      next: function() {\r\n        var value = items.shift();\r\n        return { done: value === void 0, value: value };\r\n      }\r\n    };\r\n\r\n    if (iteratorSupported) {\r\n      iterator[Symbol.iterator] = function() {\r\n        return iterator;\r\n      };\r\n    }\r\n\r\n    return iterator;\r\n  };\r\n\r\n  /**\r\n   * Search param name and values should be encoded according to https://url.spec.whatwg.org/#urlencoded-serializing\r\n   * encodeURIComponent() produces the same result except encoding spaces as `%20` instead of `+`.\r\n   */\r\n  var serializeParam = function(value) {\r\n    return encodeURIComponent(value).replace(/%20/g, '+');\r\n  };\r\n\r\n  var deserializeParam = function(value) {\r\n    return decodeURIComponent(String(value).replace(/\\+/g, ' '));\r\n  };\r\n\r\n  var polyfillURLSearchParams = function() {\r\n\r\n    var URLSearchParams = function(searchString) {\r\n      Object.defineProperty(this, '_entries', { writable: true, value: {} });\r\n      var typeofSearchString = typeof searchString;\r\n\r\n      if (typeofSearchString === 'undefined') {\r\n        // do nothing\r\n      } else if (typeofSearchString === 'string') {\r\n        if (searchString !== '') {\r\n          this._fromString(searchString);\r\n        }\r\n      } else if (searchString instanceof URLSearchParams) {\r\n        var _this = this;\r\n        searchString.forEach(function(value, name) {\r\n          _this.append(name, value);\r\n        });\r\n      } else if ((searchString !== null) && (typeofSearchString === 'object')) {\r\n        if (Object.prototype.toString.call(searchString) === '[object Array]') {\r\n          for (var i = 0; i < searchString.length; i++) {\r\n            var entry = searchString[i];\r\n            if ((Object.prototype.toString.call(entry) === '[object Array]') || (entry.length !== 2)) {\r\n              this.append(entry[0], entry[1]);\r\n            } else {\r\n              throw new TypeError('Expected [string, any] as entry at index ' + i + ' of URLSearchParams\\'s input');\r\n            }\r\n          }\r\n        } else {\r\n          for (var key in searchString) {\r\n            if (searchString.hasOwnProperty(key)) {\r\n              this.append(key, searchString[key]);\r\n            }\r\n          }\r\n        }\r\n      } else {\r\n        throw new TypeError('Unsupported input\\'s type for URLSearchParams');\r\n      }\r\n    };\r\n\r\n    var proto = URLSearchParams.prototype;\r\n\r\n    proto.append = function(name, value) {\r\n      if (name in this._entries) {\r\n        this._entries[name].push(String(value));\r\n      } else {\r\n        this._entries[name] = [String(value)];\r\n      }\r\n    };\r\n\r\n    proto.delete = function(name) {\r\n      delete this._entries[name];\r\n    };\r\n\r\n    proto.get = function(name) {\r\n      return (name in this._entries) ? this._entries[name][0] : null;\r\n    };\r\n\r\n    proto.getAll = function(name) {\r\n      return (name in this._entries) ? this._entries[name].slice(0) : [];\r\n    };\r\n\r\n    proto.has = function(name) {\r\n      return (name in this._entries);\r\n    };\r\n\r\n    proto.set = function(name, value) {\r\n      this._entries[name] = [String(value)];\r\n    };\r\n\r\n    proto.forEach = function(callback, thisArg) {\r\n      var entries;\r\n      for (var name in this._entries) {\r\n        if (this._entries.hasOwnProperty(name)) {\r\n          entries = this._entries[name];\r\n          for (var i = 0; i < entries.length; i++) {\r\n            callback.call(thisArg, entries[i], name, this);\r\n          }\r\n        }\r\n      }\r\n    };\r\n\r\n    proto.keys = function() {\r\n      var items = [];\r\n      this.forEach(function(value, name) {\r\n        items.push(name);\r\n      });\r\n      return createIterator(items);\r\n    };\r\n\r\n    proto.values = function() {\r\n      var items = [];\r\n      this.forEach(function(value) {\r\n        items.push(value);\r\n      });\r\n      return createIterator(items);\r\n    };\r\n\r\n    proto.entries = function() {\r\n      var items = [];\r\n      this.forEach(function(value, name) {\r\n        items.push([name, value]);\r\n      });\r\n      return createIterator(items);\r\n    };\r\n\r\n    if (iteratorSupported) {\r\n      proto[Symbol.iterator] = proto.entries;\r\n    }\r\n\r\n    proto.toString = function() {\r\n      var searchArray = [];\r\n      this.forEach(function(value, name) {\r\n        searchArray.push(serializeParam(name) + '=' + serializeParam(value));\r\n      });\r\n      return searchArray.join('&');\r\n    };\r\n\r\n\r\n    global.URLSearchParams = URLSearchParams;\r\n  };\r\n\r\n  var checkIfURLSearchParamsSupported = function() {\r\n    try {\r\n      var URLSearchParams = global.URLSearchParams;\r\n\r\n      return (\r\n        (new URLSearchParams('?a=1').toString() === 'a=1') &&\r\n        (typeof URLSearchParams.prototype.set === 'function') &&\r\n        (typeof URLSearchParams.prototype.entries === 'function')\r\n      );\r\n    } catch (e) {\r\n      return false;\r\n    }\r\n  };\r\n\r\n  if (!checkIfURLSearchParamsSupported()) {\r\n    polyfillURLSearchParams();\r\n  }\r\n\r\n  var proto = global.URLSearchParams.prototype;\r\n\r\n  if (typeof proto.sort !== 'function') {\r\n    proto.sort = function() {\r\n      var _this = this;\r\n      var items = [];\r\n      this.forEach(function(value, name) {\r\n        items.push([name, value]);\r\n        if (!_this._entries) {\r\n          _this.delete(name);\r\n        }\r\n      });\r\n      items.sort(function(a, b) {\r\n        if (a[0] < b[0]) {\r\n          return -1;\r\n        } else if (a[0] > b[0]) {\r\n          return +1;\r\n        } else {\r\n          return 0;\r\n        }\r\n      });\r\n      if (_this._entries) { // force reset because IE keeps keys index\r\n        _this._entries = {};\r\n      }\r\n      for (var i = 0; i < items.length; i++) {\r\n        this.append(items[i][0], items[i][1]);\r\n      }\r\n    };\r\n  }\r\n\r\n  if (typeof proto._fromString !== 'function') {\r\n    Object.defineProperty(proto, '_fromString', {\r\n      enumerable: false,\r\n      configurable: false,\r\n      writable: false,\r\n      value: function(searchString) {\r\n        if (this._entries) {\r\n          this._entries = {};\r\n        } else {\r\n          var keys = [];\r\n          this.forEach(function(value, name) {\r\n            keys.push(name);\r\n          });\r\n          for (var i = 0; i < keys.length; i++) {\r\n            this.delete(keys[i]);\r\n          }\r\n        }\r\n\r\n        searchString = searchString.replace(/^\\?/, '');\r\n        var attributes = searchString.split('&');\r\n        var attribute;\r\n        for (var i = 0; i < attributes.length; i++) {\r\n          attribute = attributes[i].split('=');\r\n          this.append(\r\n            deserializeParam(attribute[0]),\r\n            (attribute.length > 1) ? deserializeParam(attribute[1]) : ''\r\n          );\r\n        }\r\n      }\r\n    });\r\n  }\r\n\r\n  // HTMLAnchorElement\r\n\r\n})(\r\n  (typeof global !== 'undefined') ? global\r\n    : ((typeof window !== 'undefined') ? window\r\n    : ((typeof self !== 'undefined') ? self : this))\r\n);\r\n\r\n(function(global) {\r\n  /**\r\n   * Polyfill URL\r\n   *\r\n   * Inspired from : https://github.com/arv/DOM-URL-Polyfill/blob/master/src/url.js\r\n   */\r\n\r\n  var checkIfURLIsSupported = function() {\r\n    try {\r\n      var u = new global.URL('b', 'http://a');\r\n      u.pathname = 'c d';\r\n      return (u.href === 'http://a/c%20d') && u.searchParams;\r\n    } catch (e) {\r\n      return false;\r\n    }\r\n  };\r\n\r\n\r\n  var polyfillURL = function() {\r\n    var _URL = global.URL;\r\n\r\n    var URL = function(url, base) {\r\n      if (typeof url !== 'string') url = String(url);\r\n      if (base && typeof base !== 'string') base = String(base);\r\n\r\n      // Only create another document if the base is different from current location.\r\n      var doc = document, baseElement;\r\n      if (base && (global.location === void 0 || base !== global.location.href)) {\r\n        base = base.toLowerCase();\r\n        doc = document.implementation.createHTMLDocument('');\r\n        baseElement = doc.createElement('base');\r\n        baseElement.href = base;\r\n        doc.head.appendChild(baseElement);\r\n        try {\r\n          if (baseElement.href.indexOf(base) !== 0) throw new Error(baseElement.href);\r\n        } catch (err) {\r\n          throw new Error('URL unable to set base ' + base + ' due to ' + err);\r\n        }\r\n      }\r\n\r\n      var anchorElement = doc.createElement('a');\r\n      anchorElement.href = url;\r\n      if (baseElement) {\r\n        doc.body.appendChild(anchorElement);\r\n        anchorElement.href = anchorElement.href; // force href to refresh\r\n      }\r\n\r\n      var inputElement = doc.createElement('input');\r\n      inputElement.type = 'url';\r\n      inputElement.value = url;\r\n\r\n      if (anchorElement.protocol === ':' || !/:/.test(anchorElement.href) || (!inputElement.checkValidity() && !base)) {\r\n        throw new TypeError('Invalid URL');\r\n      }\r\n\r\n      Object.defineProperty(this, '_anchorElement', {\r\n        value: anchorElement\r\n      });\r\n\r\n\r\n      // create a linked searchParams which reflect its changes on URL\r\n      var searchParams = new global.URLSearchParams(this.search);\r\n      var enableSearchUpdate = true;\r\n      var enableSearchParamsUpdate = true;\r\n      var _this = this;\r\n      ['append', 'delete', 'set'].forEach(function(methodName) {\r\n        var method = searchParams[methodName];\r\n        searchParams[methodName] = function() {\r\n          method.apply(searchParams, arguments);\r\n          if (enableSearchUpdate) {\r\n            enableSearchParamsUpdate = false;\r\n            _this.search = searchParams.toString();\r\n            enableSearchParamsUpdate = true;\r\n          }\r\n        };\r\n      });\r\n\r\n      Object.defineProperty(this, 'searchParams', {\r\n        value: searchParams,\r\n        enumerable: true\r\n      });\r\n\r\n      var search = void 0;\r\n      Object.defineProperty(this, '_updateSearchParams', {\r\n        enumerable: false,\r\n        configurable: false,\r\n        writable: false,\r\n        value: function() {\r\n          if (this.search !== search) {\r\n            search = this.search;\r\n            if (enableSearchParamsUpdate) {\r\n              enableSearchUpdate = false;\r\n              this.searchParams._fromString(this.search);\r\n              enableSearchUpdate = true;\r\n            }\r\n          }\r\n        }\r\n      });\r\n    };\r\n\r\n    var proto = URL.prototype;\r\n\r\n    var linkURLWithAnchorAttribute = function(attributeName) {\r\n      Object.defineProperty(proto, attributeName, {\r\n        get: function() {\r\n          return this._anchorElement[attributeName];\r\n        },\r\n        set: function(value) {\r\n          this._anchorElement[attributeName] = value;\r\n        },\r\n        enumerable: true\r\n      });\r\n    };\r\n\r\n    ['hash', 'host', 'hostname', 'port', 'protocol']\r\n      .forEach(function(attributeName) {\r\n        linkURLWithAnchorAttribute(attributeName);\r\n      });\r\n\r\n    Object.defineProperty(proto, 'search', {\r\n      get: function() {\r\n        return this._anchorElement['search'];\r\n      },\r\n      set: function(value) {\r\n        this._anchorElement['search'] = value;\r\n        this._updateSearchParams();\r\n      },\r\n      enumerable: true\r\n    });\r\n\r\n    Object.defineProperties(proto, {\r\n\r\n      'toString': {\r\n        get: function() {\r\n          var _this = this;\r\n          return function() {\r\n            return _this.href;\r\n          };\r\n        }\r\n      },\r\n\r\n      'href': {\r\n        get: function() {\r\n          return this._anchorElement.href.replace(/\\?$/, '');\r\n        },\r\n        set: function(value) {\r\n          this._anchorElement.href = value;\r\n          this._updateSearchParams();\r\n        },\r\n        enumerable: true\r\n      },\r\n\r\n      'pathname': {\r\n        get: function() {\r\n          return this._anchorElement.pathname.replace(/(^\\/?)/, '/');\r\n        },\r\n        set: function(value) {\r\n          this._anchorElement.pathname = value;\r\n        },\r\n        enumerable: true\r\n      },\r\n\r\n      'origin': {\r\n        get: function() {\r\n          // get expected port from protocol\r\n          var expectedPort = { 'http:': 80, 'https:': 443, 'ftp:': 21 }[this._anchorElement.protocol];\r\n          // add port to origin if, expected port is different than actual port\r\n          // and it is not empty f.e http://foo:8080\r\n          // 8080 != 80 && 8080 != ''\r\n          var addPortToOrigin = this._anchorElement.port != expectedPort &&\r\n            this._anchorElement.port !== '';\r\n\r\n          return this._anchorElement.protocol +\r\n            '//' +\r\n            this._anchorElement.hostname +\r\n            (addPortToOrigin ? (':' + this._anchorElement.port) : '');\r\n        },\r\n        enumerable: true\r\n      },\r\n\r\n      'password': { // TODO\r\n        get: function() {\r\n          return '';\r\n        },\r\n        set: function(value) {\r\n        },\r\n        enumerable: true\r\n      },\r\n\r\n      'username': { // TODO\r\n        get: function() {\r\n          return '';\r\n        },\r\n        set: function(value) {\r\n        },\r\n        enumerable: true\r\n      },\r\n    });\r\n\r\n    URL.createObjectURL = function(blob) {\r\n      return _URL.createObjectURL.apply(_URL, arguments);\r\n    };\r\n\r\n    URL.revokeObjectURL = function(url) {\r\n      return _URL.revokeObjectURL.apply(_URL, arguments);\r\n    };\r\n\r\n    global.URL = URL;\r\n\r\n  };\r\n\r\n  if (!checkIfURLIsSupported()) {\r\n    polyfillURL();\r\n  }\r\n\r\n  if ((global.location !== void 0) && !('origin' in global.location)) {\r\n    var getOrigin = function() {\r\n      return global.location.protocol + '//' + global.location.hostname + (global.location.port ? (':' + global.location.port) : '');\r\n    };\r\n\r\n    try {\r\n      Object.defineProperty(global.location, 'origin', {\r\n        get: getOrigin,\r\n        enumerable: true\r\n      });\r\n    } catch (e) {\r\n      setInterval(function() {\r\n        global.location.origin = getOrigin();\r\n      }, 100);\r\n    }\r\n  }\r\n\r\n})(\r\n  (typeof global !== 'undefined') ? global\r\n    : ((typeof window !== 'undefined') ? window\r\n    : ((typeof self !== 'undefined') ? self : this))\r\n);\r\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/**\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 */\nconst Zone$1 = (function (global) {\n    const 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    const symbolPrefix = global['__Zone_symbol_prefix'] || '__zone_symbol__';\n    function __symbol__(name) {\n        return symbolPrefix + name;\n    }\n    const 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    class Zone {\n        constructor(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        static assertZonePatched() {\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        static get root() {\n            let zone = Zone.current;\n            while (zone.parent) {\n                zone = zone.parent;\n            }\n            return zone;\n        }\n        static get current() {\n            return _currentZoneFrame.zone;\n        }\n        static get currentTask() {\n            return _currentTask;\n        }\n        // tslint:disable-next-line:require-internal-with-underscore\n        static __load_patch(name, fn, 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                const perfName = 'Zone:' + name;\n                mark(perfName);\n                patches[name] = fn(global, Zone, _api);\n                performanceMeasure(perfName, perfName);\n            }\n        }\n        get parent() {\n            return this._parent;\n        }\n        get name() {\n            return this._name;\n        }\n        get(key) {\n            const zone = this.getZoneWith(key);\n            if (zone)\n                return zone._properties[key];\n        }\n        getZoneWith(key) {\n            let 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        fork(zoneSpec) {\n            if (!zoneSpec)\n                throw new Error('ZoneSpec required!');\n            return this._zoneDelegate.fork(this, zoneSpec);\n        }\n        wrap(callback, source) {\n            if (typeof callback !== 'function') {\n                throw new Error('Expecting function got: ' + callback);\n            }\n            const _callback = this._zoneDelegate.intercept(this, callback, source);\n            const zone = this;\n            return function () {\n                return zone.runGuarded(_callback, this, arguments, source);\n            };\n        }\n        run(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        runGuarded(callback, applyThis = null, applyArgs, source) {\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        runTask(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            const reEntryGuard = task.state != running;\n            reEntryGuard && task._transitionTo(running, scheduled);\n            task.runCount++;\n            const 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        scheduleTask(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                let 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            const 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        scheduleMicroTask(source, callback, data, customSchedule) {\n            return this.scheduleTask(new ZoneTask(microTask, source, callback, data, customSchedule, undefined));\n        }\n        scheduleMacroTask(source, callback, data, customSchedule, customCancel) {\n            return this.scheduleTask(new ZoneTask(macroTask, source, callback, data, customSchedule, customCancel));\n        }\n        scheduleEventTask(source, callback, data, customSchedule, customCancel) {\n            return this.scheduleTask(new ZoneTask(eventTask, source, callback, data, customSchedule, customCancel));\n        }\n        cancelTask(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        _updateTaskCount(task, count) {\n            const zoneDelegates = task._zoneDelegates;\n            if (count == -1) {\n                task._zoneDelegates = null;\n            }\n            for (let i = 0; i < zoneDelegates.length; i++) {\n                zoneDelegates[i]._updateTaskCount(task.type, count);\n            }\n        }\n    }\n    // tslint:disable-next-line:require-internal-with-underscore\n    Zone.__symbol__ = __symbol__;\n    const DELEGATE_ZS = {\n        name: '',\n        onHasTask: (delegate, _, target, hasTaskState) => delegate.hasTask(target, hasTaskState),\n        onScheduleTask: (delegate, _, target, task) => delegate.scheduleTask(target, task),\n        onInvokeTask: (delegate, _, target, task, applyThis, applyArgs) => delegate.invokeTask(target, task, applyThis, applyArgs),\n        onCancelTask: (delegate, _, target, task) => delegate.cancelTask(target, task)\n    };\n    class ZoneDelegate {\n        constructor(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            const zoneSpecHasTask = zoneSpec && zoneSpec.onHasTask;\n            const 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        fork(targetZone, zoneSpec) {\n            return this._forkZS ? this._forkZS.onFork(this._forkDlgt, this.zone, targetZone, zoneSpec) :\n                new Zone(targetZone, zoneSpec);\n        }\n        intercept(targetZone, callback, source) {\n            return this._interceptZS ?\n                this._interceptZS.onIntercept(this._interceptDlgt, this._interceptCurrZone, targetZone, callback, source) :\n                callback;\n        }\n        invoke(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        handleError(targetZone, error) {\n            return this._handleErrorZS ?\n                this._handleErrorZS.onHandleError(this._handleErrorDlgt, this._handleErrorCurrZone, targetZone, error) :\n                true;\n        }\n        scheduleTask(targetZone, task) {\n            let 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        invokeTask(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        cancelTask(targetZone, task) {\n            let 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        hasTask(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        _updateTaskCount(type, count) {\n            const counts = this._taskCounts;\n            const prev = counts[type];\n            const 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                const 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    }\n    class ZoneTask {\n        constructor(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            const 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        static invokeTask(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        get zone() {\n            return this._zone;\n        }\n        get state() {\n            return this._state;\n        }\n        cancelScheduleRequest() {\n            this._transitionTo(notScheduled, scheduling);\n        }\n        // tslint:disable-next-line:require-internal-with-underscore\n        _transitionTo(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        toString() {\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        toJSON() {\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    }\n    //////////////////////////////////////////////////////\n    //////////////////////////////////////////////////////\n    ///  MICROTASK QUEUE\n    //////////////////////////////////////////////////////\n    //////////////////////////////////////////////////////\n    const symbolSetTimeout = __symbol__('setTimeout');\n    const symbolPromise = __symbol__('Promise');\n    const symbolThen = __symbol__('then');\n    let _microTaskQueue = [];\n    let _isDrainingMicrotaskQueue = false;\n    let 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                let 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                const queue = _microTaskQueue;\n                _microTaskQueue = [];\n                for (let i = 0; i < queue.length; i++) {\n                    const 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    const NO_ZONE = { name: 'NO ZONE' };\n    const notScheduled = 'notScheduled', scheduling = 'scheduling', scheduled = 'scheduled', running = 'running', canceling = 'canceling', unknown = 'unknown';\n    const microTask = 'microTask', macroTask = 'macroTask', eventTask = 'eventTask';\n    const patches = {};\n    const _api = {\n        symbol: __symbol__,\n        currentZoneFrame: () => _currentZoneFrame,\n        onUnhandledError: noop,\n        microtaskDrainDone: noop,\n        scheduleMicroTask: scheduleMicroTask,\n        showUncaughtError: () => !Zone[__symbol__('ignoreConsoleErrorUncaughtError')],\n        patchEventTarget: () => [],\n        patchOnProperties: noop,\n        patchMethod: () => noop,\n        bindArguments: () => [],\n        patchThen: () => noop,\n        patchMacroTask: () => noop,\n        patchEventPrototype: () => noop,\n        isIEOrEdge: () => false,\n        getGlobalObjects: () => undefined,\n        ObjectDefineProperty: () => noop,\n        ObjectGetOwnPropertyDescriptor: () => undefined,\n        ObjectCreate: () => undefined,\n        ArraySlice: () => [],\n        patchClass: () => noop,\n        wrapWithCurrentZone: () => noop,\n        filterProperties: () => [],\n        attachOriginToPatched: () => noop,\n        _redefineProperty: () => noop,\n        patchCallbacks: () => noop\n    };\n    let _currentZoneFrame = { parent: null, zone: new Zone(null, null) };\n    let _currentTask = null;\n    let _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/**\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 */\nconst ObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n/** Object.defineProperty */\nconst ObjectDefineProperty = Object.defineProperty;\n/** Object.getPrototypeOf */\nconst ObjectGetPrototypeOf = Object.getPrototypeOf;\n/** Object.create */\nconst ObjectCreate = Object.create;\n/** Array.prototype.slice */\nconst ArraySlice = Array.prototype.slice;\n/** addEventListener string const */\nconst ADD_EVENT_LISTENER_STR = 'addEventListener';\n/** removeEventListener string const */\nconst REMOVE_EVENT_LISTENER_STR = 'removeEventListener';\n/** zoneSymbol addEventListener */\nconst ZONE_SYMBOL_ADD_EVENT_LISTENER = Zone.__symbol__(ADD_EVENT_LISTENER_STR);\n/** zoneSymbol removeEventListener */\nconst ZONE_SYMBOL_REMOVE_EVENT_LISTENER = Zone.__symbol__(REMOVE_EVENT_LISTENER_STR);\n/** true string const */\nconst TRUE_STR = 'true';\n/** false string const */\nconst FALSE_STR = 'false';\n/** Zone symbol prefix string const. */\nconst ZONE_SYMBOL_PREFIX = Zone.__symbol__('');\nfunction wrapWithCurrentZone(callback, source) {\n    return Zone.current.wrap(callback, source);\n}\nfunction scheduleMacroTaskWithCurrentZone(source, callback, data, customSchedule, customCancel) {\n    return Zone.current.scheduleMacroTask(source, callback, data, customSchedule, customCancel);\n}\nconst zoneSymbol = Zone.__symbol__;\nconst isWindowExists = typeof window !== 'undefined';\nconst internalWindow = isWindowExists ? window : undefined;\nconst _global = isWindowExists && internalWindow || typeof self === 'object' && self || global;\nconst REMOVE_ATTRIBUTE = 'removeAttribute';\nconst NULL_ON_PROP_VALUE = [null];\nfunction bindArguments(args, source) {\n    for (let 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}\nfunction patchPrototype(prototype, fnNames) {\n    const source = prototype.constructor['name'];\n    for (let i = 0; i < fnNames.length; i++) {\n        const name = fnNames[i];\n        const delegate = prototype[name];\n        if (delegate) {\n            const prototypeDesc = ObjectGetOwnPropertyDescriptor(prototype, name);\n            if (!isPropertyWritable(prototypeDesc)) {\n                continue;\n            }\n            prototype[name] = ((delegate) => {\n                const patched = function () {\n                    return delegate.apply(this, bindArguments(arguments, source + '.' + name));\n                };\n                attachOriginToPatched(patched, delegate);\n                return patched;\n            })(delegate);\n        }\n    }\n}\nfunction 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}\nconst 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.\nconst isNode = (!('nw' in _global) && typeof _global.process !== 'undefined' &&\n    {}.toString.call(_global.process) === '[object process]');\nconst 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.\nconst isMix = typeof _global.process !== 'undefined' &&\n    {}.toString.call(_global.process) === '[object process]' && !isWebWorker &&\n    !!(isWindowExists && internalWindow['HTMLElement']);\nconst zoneSymbolEventNames = {};\nconst 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    let eventNameSymbol = zoneSymbolEventNames[event.type];\n    if (!eventNameSymbol) {\n        eventNameSymbol = zoneSymbolEventNames[event.type] = zoneSymbol('ON_PROPERTY' + event.type);\n    }\n    const target = this || event.target || _global;\n    const listener = target[eventNameSymbol];\n    let 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        const 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};\nfunction patchProperty(obj, prop, prototype) {\n    let desc = ObjectGetOwnPropertyDescriptor(obj, prop);\n    if (!desc && prototype) {\n        // when patch window object, use prototype to check prop exist or not\n        const 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    const 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    const originalDescGet = desc.get;\n    const originalDescSet = desc.set;\n    // substr(2) cuz 'onclick' -> 'click', etc\n    const eventName = prop.substr(2);\n    let 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        let target = this;\n        if (!target && obj === _global) {\n            target = _global;\n        }\n        if (!target) {\n            return;\n        }\n        let 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        let target = this;\n        if (!target && obj === _global) {\n            target = _global;\n        }\n        if (!target) {\n            return null;\n        }\n        const 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            let 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}\nfunction patchOnProperties(obj, properties, prototype) {\n    if (properties) {\n        for (let i = 0; i < properties.length; i++) {\n            patchProperty(obj, 'on' + properties[i], prototype);\n        }\n    }\n    else {\n        const onProperties = [];\n        for (const prop in obj) {\n            if (prop.substr(0, 2) == 'on') {\n                onProperties.push(prop);\n            }\n        }\n        for (let j = 0; j < onProperties.length; j++) {\n            patchProperty(obj, onProperties[j], prototype);\n        }\n    }\n}\nconst originalInstanceKey = zoneSymbol('originalInstance');\n// wrap some native API on `window`\nfunction patchClass(className) {\n    const OriginalClass = _global[className];\n    if (!OriginalClass)\n        return;\n    // keep original class in global\n    _global[zoneSymbol(className)] = OriginalClass;\n    _global[className] = function () {\n        const 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    const instance = new OriginalClass(function () { });\n    let 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}\nfunction patchMethod(target, name, patchFn) {\n    let 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    const delegateName = zoneSymbol(name);\n    let 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        const desc = proto && ObjectGetOwnPropertyDescriptor(proto, name);\n        if (isPropertyWritable(desc)) {\n            const patchDelegate = patchFn(delegate, delegateName, name);\n            proto[name] = function () {\n                return patchDelegate(this, arguments);\n            };\n            attachOriginToPatched(proto[name], delegate);\n        }\n    }\n    return delegate;\n}\n// TODO: @JiaLiPassion, support cancel task later if necessary\nfunction patchMacroTask(obj, funcName, metaCreator) {\n    let setNative = null;\n    function scheduleTask(task) {\n        const 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, (delegate) => function (self, args) {\n        const 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}\nfunction attachOriginToPatched(patched, original) {\n    patched[zoneSymbol('OriginalDelegate')] = original;\n}\nlet isDetectedIEOrEdge = false;\nlet ieOrEdge = false;\nfunction isIE() {\n    try {\n        const 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}\nfunction isIEOrEdge() {\n    if (isDetectedIEOrEdge) {\n        return ieOrEdge;\n    }\n    isDetectedIEOrEdge = true;\n    try {\n        const 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/**\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 */\nZone.__load_patch('ZoneAwarePromise', (global, Zone, api) => {\n    const ObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n    const ObjectDefineProperty = Object.defineProperty;\n    function readableObjectToString(obj) {\n        if (obj && obj.toString === Object.prototype.toString) {\n            const 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    const __symbol__ = api.symbol;\n    const _uncaughtPromiseErrors = [];\n    const isDisableWrappingUncaughtPromiseRejection = global[__symbol__('DISABLE_WRAPPING_UNCAUGHT_PROMISE_REJECTION')] === true;\n    const symbolPromise = __symbol__('Promise');\n    const symbolThen = __symbol__('then');\n    const creationTrace = '__creationTrace__';\n    api.onUnhandledError = (e) => {\n        if (api.showUncaughtError()) {\n            const 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 = () => {\n        while (_uncaughtPromiseErrors.length) {\n            const uncaughtPromiseError = _uncaughtPromiseErrors.shift();\n            try {\n                uncaughtPromiseError.zone.runGuarded(() => {\n                    if (uncaughtPromiseError.throwOriginal) {\n                        throw uncaughtPromiseError.rejection;\n                    }\n                    throw uncaughtPromiseError;\n                });\n            }\n            catch (error) {\n                handleUnhandledRejection(error);\n            }\n        }\n    };\n    const UNHANDLED_PROMISE_REJECTION_HANDLER_SYMBOL = __symbol__('unhandledPromiseRejectionHandler');\n    function handleUnhandledRejection(e) {\n        api.onUnhandledError(e);\n        try {\n            const 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    const symbolState = __symbol__('state');\n    const symbolValue = __symbol__('value');\n    const symbolFinally = __symbol__('finally');\n    const symbolParentPromiseValue = __symbol__('parentPromiseValue');\n    const symbolParentPromiseState = __symbol__('parentPromiseState');\n    const source = 'Promise.then';\n    const UNRESOLVED = null;\n    const RESOLVED = true;\n    const REJECTED = false;\n    const REJECTED_NO_CATCH = 0;\n    function makeResolver(promise, state) {\n        return (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    const once = function () {\n        let 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    const TYPE_ERROR = 'Promise resolved with itself';\n    const CURRENT_TASK_TRACE_SYMBOL = __symbol__('currentTaskTrace');\n    // Promise Resolution\n    function resolvePromise(promise, state, value) {\n        const 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            let then = null;\n            try {\n                if (typeof value === 'object' || typeof value === 'function') {\n                    then = value && value.then;\n                }\n            }\n            catch (err) {\n                onceWrapper(() => {\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(() => {\n                        resolvePromise(promise, false, err);\n                    })();\n                }\n            }\n            else {\n                promise[symbolState] = state;\n                const 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                    const 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 (let 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                    let 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    const 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                const 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 (let 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        const promiseState = promise[symbolState];\n        const delegate = promiseState ?\n            (typeof onFulfilled === 'function') ? onFulfilled : forwardResolution :\n            (typeof onRejected === 'function') ? onRejected : forwardRejection;\n        zone.scheduleMicroTask(source, () => {\n            try {\n                const parentPromiseValue = promise[symbolValue];\n                const 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                const 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    const ZONE_AWARE_PROMISE_TO_STRING = 'function ZoneAwarePromise() { [native code] }';\n    const noop = function () { };\n    class ZoneAwarePromise {\n        static toString() {\n            return ZONE_AWARE_PROMISE_TO_STRING;\n        }\n        static resolve(value) {\n            return resolvePromise(new this(null), RESOLVED, value);\n        }\n        static reject(error) {\n            return resolvePromise(new this(null), REJECTED, error);\n        }\n        static race(values) {\n            let resolve;\n            let reject;\n            let promise = new this((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 (let value of values) {\n                if (!isThenable(value)) {\n                    value = this.resolve(value);\n                }\n                value.then(onResolve, onReject);\n            }\n            return promise;\n        }\n        static all(values) {\n            return ZoneAwarePromise.allWithCallback(values);\n        }\n        static allSettled(values) {\n            const P = this && this.prototype instanceof ZoneAwarePromise ? this : ZoneAwarePromise;\n            return P.allWithCallback(values, {\n                thenCallback: (value) => ({ status: 'fulfilled', value }),\n                errorCallback: (err) => ({ status: 'rejected', reason: err })\n            });\n        }\n        static allWithCallback(values, callback) {\n            let resolve;\n            let reject;\n            let promise = new this((res, rej) => {\n                resolve = res;\n                reject = rej;\n            });\n            // Start at 2 to prevent prematurely resolving if .then is called immediately.\n            let unresolvedCount = 2;\n            let valueIndex = 0;\n            const resolvedValues = [];\n            for (let value of values) {\n                if (!isThenable(value)) {\n                    value = this.resolve(value);\n                }\n                const curValueIndex = valueIndex;\n                try {\n                    value.then((value) => {\n                        resolvedValues[curValueIndex] = callback ? callback.thenCallback(value) : value;\n                        unresolvedCount--;\n                        if (unresolvedCount === 0) {\n                            resolve(resolvedValues);\n                        }\n                    }, (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            // Make the unresolvedCount zero-based again.\n            unresolvedCount -= 2;\n            if (unresolvedCount === 0) {\n                resolve(resolvedValues);\n            }\n            return promise;\n        }\n        constructor(executor) {\n            const 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        get [Symbol.toStringTag]() {\n            return 'Promise';\n        }\n        get [Symbol.species]() {\n            return ZoneAwarePromise;\n        }\n        then(onFulfilled, onRejected) {\n            let C = this.constructor[Symbol.species];\n            if (!C || typeof C !== 'function') {\n                C = this.constructor || ZoneAwarePromise;\n            }\n            const chainPromise = new C(noop);\n            const 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        catch(onRejected) {\n            return this.then(null, onRejected);\n        }\n        finally(onFinally) {\n            let C = this.constructor[Symbol.species];\n            if (!C || typeof C !== 'function') {\n                C = ZoneAwarePromise;\n            }\n            const chainPromise = new C(noop);\n            chainPromise[symbolFinally] = symbolFinally;\n            const 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    }\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    const NativePromise = global[symbolPromise] = global['Promise'];\n    global['Promise'] = ZoneAwarePromise;\n    const symbolThenPatched = __symbol__('thenPatched');\n    function patchThen(Ctor) {\n        const proto = Ctor.prototype;\n        const 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        const originalThen = proto.then;\n        // Keep a reference to the original method.\n        proto[symbolThen] = originalThen;\n        Ctor.prototype.then = function (onResolve, onReject) {\n            const wrapped = new ZoneAwarePromise((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            let resultPromise = fn.apply(self, args);\n            if (resultPromise instanceof ZoneAwarePromise) {\n                return resultPromise;\n            }\n            let 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', delegate => 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/**\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\nZone.__load_patch('toString', (global) => {\n    // patch Func.prototype.toString to let them look like native\n    const originalFunctionToString = Function.prototype.toString;\n    const ORIGINAL_DELEGATE_SYMBOL = zoneSymbol('OriginalDelegate');\n    const PROMISE_SYMBOL = zoneSymbol('Promise');\n    const ERROR_SYMBOL = zoneSymbol('Error');\n    const newFunctionToString = function toString() {\n        if (typeof this === 'function') {\n            const 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                const nativePromise = global[PROMISE_SYMBOL];\n                if (nativePromise) {\n                    return originalFunctionToString.call(nativePromise);\n                }\n            }\n            if (this === Error) {\n                const 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    const originalObjectToString = Object.prototype.toString;\n    const 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/**\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 */\nlet passiveSupported = false;\nif (typeof window !== 'undefined') {\n    try {\n        const 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\nconst OPTIMIZED_ZONE_EVENT_TASK_DATA = {\n    useG: true\n};\nconst zoneSymbolEventNames$1 = {};\nconst globalSources = {};\nconst EVENT_NAME_SYMBOL_REGX = new RegExp('^' + ZONE_SYMBOL_PREFIX + '(\\\\w+)(true|false)$');\nconst IMMEDIATE_PROPAGATION_SYMBOL = zoneSymbol('propagationStopped');\nfunction prepareEventNames(eventName, eventNameToString) {\n    const falseEventName = (eventNameToString ? eventNameToString(eventName) : eventName) + FALSE_STR;\n    const trueEventName = (eventNameToString ? eventNameToString(eventName) : eventName) + TRUE_STR;\n    const symbol = ZONE_SYMBOL_PREFIX + falseEventName;\n    const symbolCapture = ZONE_SYMBOL_PREFIX + trueEventName;\n    zoneSymbolEventNames$1[eventName] = {};\n    zoneSymbolEventNames$1[eventName][FALSE_STR] = symbol;\n    zoneSymbolEventNames$1[eventName][TRUE_STR] = symbolCapture;\n}\nfunction patchEventTarget(_global, apis, patchOptions) {\n    const ADD_EVENT_LISTENER = (patchOptions && patchOptions.add) || ADD_EVENT_LISTENER_STR;\n    const REMOVE_EVENT_LISTENER = (patchOptions && patchOptions.rm) || REMOVE_EVENT_LISTENER_STR;\n    const LISTENERS_EVENT_LISTENER = (patchOptions && patchOptions.listeners) || 'eventListeners';\n    const REMOVE_ALL_LISTENERS_EVENT_LISTENER = (patchOptions && patchOptions.rmAll) || 'removeAllListeners';\n    const zoneSymbolAddEventListener = zoneSymbol(ADD_EVENT_LISTENER);\n    const ADD_EVENT_LISTENER_SOURCE = '.' + ADD_EVENT_LISTENER + ':';\n    const PREPEND_EVENT_LISTENER = 'prependListener';\n    const PREPEND_EVENT_LISTENER_SOURCE = '.' + PREPEND_EVENT_LISTENER + ':';\n    const 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        const delegate = task.callback;\n        if (typeof delegate === 'object' && delegate.handleEvent) {\n            // create the bind version of handleEvent when invoke\n            task.callback = (event) => delegate.handleEvent(event);\n            task.originalDelegate = delegate;\n        }\n        // invoke static task.invoke\n        task.invoke(task, target, [event]);\n        const 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            const delegate = task.originalDelegate ? task.originalDelegate : task.callback;\n            target[REMOVE_EVENT_LISTENER].call(target, event.type, delegate, options);\n        }\n    };\n    // global shared zoneAwareCallback to handle all event callback with capture = false\n    const 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        const target = this || event.target || _global;\n        const 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                const copyTasks = tasks.slice();\n                for (let 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    const 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        const target = this || event.target || _global;\n        const 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                const copyTasks = tasks.slice();\n                for (let 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        let useGlobalCallback = true;\n        if (patchOptions && patchOptions.useG !== undefined) {\n            useGlobalCallback = patchOptions.useG;\n        }\n        const validateHandler = patchOptions && patchOptions.vh;\n        let checkDuplicate = true;\n        if (patchOptions && patchOptions.chkDup !== undefined) {\n            checkDuplicate = patchOptions.chkDup;\n        }\n        let returnTarget = false;\n        if (patchOptions && patchOptions.rt !== undefined) {\n            returnTarget = patchOptions.rt;\n        }\n        let 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        const 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        const taskData = {};\n        const nativeAddEventListener = proto[zoneSymbolAddEventListener] = proto[ADD_EVENT_LISTENER];\n        const nativeRemoveEventListener = proto[zoneSymbol(REMOVE_EVENT_LISTENER)] =\n            proto[REMOVE_EVENT_LISTENER];\n        const nativeListeners = proto[zoneSymbol(LISTENERS_EVENT_LISTENER)] =\n            proto[LISTENERS_EVENT_LISTENER];\n        const nativeRemoveAllListeners = proto[zoneSymbol(REMOVE_ALL_LISTENERS_EVENT_LISTENER)] =\n            proto[REMOVE_ALL_LISTENERS_EVENT_LISTENER];\n        let 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        const 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        const 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                const symbolEventNames = zoneSymbolEventNames$1[task.eventName];\n                let symbolEventName;\n                if (symbolEventNames) {\n                    symbolEventName = symbolEventNames[task.capture ? TRUE_STR : FALSE_STR];\n                }\n                const existingTasks = symbolEventName && task.target[symbolEventName];\n                if (existingTasks) {\n                    for (let i = 0; i < existingTasks.length; i++) {\n                        const 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        const customScheduleNonGlobal = function (task) {\n            return nativeAddEventListener.call(taskData.target, taskData.eventName, task.invoke, taskData.options);\n        };\n        const customSchedulePrepend = function (task) {\n            return nativePrependEventListener.call(taskData.target, taskData.eventName, task.invoke, taskData.options);\n        };\n        const customCancelNonGlobal = function (task) {\n            return nativeRemoveEventListener.call(task.target, task.eventName, task.invoke, task.options);\n        };\n        const customSchedule = useGlobalCallback ? customScheduleGlobal : customScheduleNonGlobal;\n        const customCancel = useGlobalCallback ? customCancelGlobal : customCancelNonGlobal;\n        const compareTaskCallbackVsDelegate = function (task, delegate) {\n            const typeOfDelegate = typeof delegate;\n            return (typeOfDelegate === 'function' && task.callback === delegate) ||\n                (typeOfDelegate === 'object' && task.originalDelegate === delegate);\n        };\n        const compare = (patchOptions && patchOptions.diff) ? patchOptions.diff : compareTaskCallbackVsDelegate;\n        const unpatchedEvents = Zone[zoneSymbol('UNPATCHED_EVENTS')];\n        const passiveEvents = _global[zoneSymbol('PASSIVE_EVENTS')];\n        const makeAddListener = function (nativeListener, addSource, customScheduleFn, customCancelFn, returnTarget = false, prepend = false) {\n            return function () {\n                const target = this || _global;\n                let eventName = arguments[0];\n                if (patchOptions && patchOptions.transferEventName) {\n                    eventName = patchOptions.transferEventName(eventName);\n                }\n                let 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                let 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                const passive = passiveSupported && !!passiveEvents && passiveEvents.indexOf(eventName) !== -1;\n                const options = buildEventListenerOptions(arguments[2], passive);\n                if (unpatchedEvents) {\n                    // check upatched list\n                    for (let 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                const capture = !options ? false : typeof options === 'boolean' ? true : options.capture;\n                const once = options && typeof options === 'object' ? options.once : false;\n                const zone = Zone.current;\n                let symbolEventNames = zoneSymbolEventNames$1[eventName];\n                if (!symbolEventNames) {\n                    prepareEventNames(eventName, eventNameToString);\n                    symbolEventNames = zoneSymbolEventNames$1[eventName];\n                }\n                const symbolEventName = symbolEventNames[capture ? TRUE_STR : FALSE_STR];\n                let existingTasks = target[symbolEventName];\n                let isExisting = false;\n                if (existingTasks) {\n                    // already have task registered\n                    isExisting = true;\n                    if (checkDuplicate) {\n                        for (let 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                let source;\n                const constructorName = target.constructor['name'];\n                const 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                const 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                const 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            const target = this || _global;\n            let eventName = arguments[0];\n            if (patchOptions && patchOptions.transferEventName) {\n                eventName = patchOptions.transferEventName(eventName);\n            }\n            const options = arguments[2];\n            const capture = !options ? false : typeof options === 'boolean' ? true : options.capture;\n            const 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            const symbolEventNames = zoneSymbolEventNames$1[eventName];\n            let symbolEventName;\n            if (symbolEventNames) {\n                symbolEventName = symbolEventNames[capture ? TRUE_STR : FALSE_STR];\n            }\n            const existingTasks = symbolEventName && target[symbolEventName];\n            if (existingTasks) {\n                for (let i = 0; i < existingTasks.length; i++) {\n                    const 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                                const 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            const target = this || _global;\n            let eventName = arguments[0];\n            if (patchOptions && patchOptions.transferEventName) {\n                eventName = patchOptions.transferEventName(eventName);\n            }\n            const listeners = [];\n            const tasks = findEventTasks(target, eventNameToString ? eventNameToString(eventName) : eventName);\n            for (let i = 0; i < tasks.length; i++) {\n                const task = tasks[i];\n                let 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            const target = this || _global;\n            let eventName = arguments[0];\n            if (!eventName) {\n                const keys = Object.keys(target);\n                for (let i = 0; i < keys.length; i++) {\n                    const prop = keys[i];\n                    const match = EVENT_NAME_SYMBOL_REGX.exec(prop);\n                    let 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                const symbolEventNames = zoneSymbolEventNames$1[eventName];\n                if (symbolEventNames) {\n                    const symbolEventName = symbolEventNames[FALSE_STR];\n                    const symbolCaptureEventName = symbolEventNames[TRUE_STR];\n                    const tasks = target[symbolEventName];\n                    const captureTasks = target[symbolCaptureEventName];\n                    if (tasks) {\n                        const removeTasks = tasks.slice();\n                        for (let i = 0; i < removeTasks.length; i++) {\n                            const task = removeTasks[i];\n                            let delegate = task.originalDelegate ? task.originalDelegate : task.callback;\n                            this[REMOVE_EVENT_LISTENER].call(this, eventName, delegate, task.options);\n                        }\n                    }\n                    if (captureTasks) {\n                        const removeTasks = captureTasks.slice();\n                        for (let i = 0; i < removeTasks.length; i++) {\n                            const task = removeTasks[i];\n                            let 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    let results = [];\n    for (let i = 0; i < apis.length; i++) {\n        results[i] = patchEventTargetMethods(apis[i], patchOptions);\n    }\n    return results;\n}\nfunction findEventTasks(target, eventName) {\n    if (!eventName) {\n        const foundTasks = [];\n        for (let prop in target) {\n            const match = EVENT_NAME_SYMBOL_REGX.exec(prop);\n            let evtName = match && match[1];\n            if (evtName && (!eventName || evtName === eventName)) {\n                const tasks = target[prop];\n                if (tasks) {\n                    for (let i = 0; i < tasks.length; i++) {\n                        foundTasks.push(tasks[i]);\n                    }\n                }\n            }\n        }\n        return foundTasks;\n    }\n    let symbolEventName = zoneSymbolEventNames$1[eventName];\n    if (!symbolEventName) {\n        prepareEventNames(eventName);\n        symbolEventName = zoneSymbolEventNames$1[eventName];\n    }\n    const captureFalseTasks = target[symbolEventName[FALSE_STR]];\n    const 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}\nfunction patchEventPrototype(global, api) {\n    const Event = global['Event'];\n    if (Event && Event.prototype) {\n        api.patchMethod(Event.prototype, 'stopImmediatePropagation', (delegate) => 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/**\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 */\nfunction patchCallbacks(api, target, targetName, method, callbacks) {\n    const symbol = Zone.__symbol__(method);\n    if (target[symbol]) {\n        return;\n    }\n    const nativeDelegate = target[symbol] = target[method];\n    target[method] = function (name, opts, options) {\n        if (opts && opts.prototype) {\n            callbacks.forEach(function (callback) {\n                const source = `${targetName}.${method}::` + callback;\n                const prototype = opts.prototype;\n                if (prototype.hasOwnProperty(callback)) {\n                    const 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/**\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 */\nconst 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];\nconst documentEventNames = [\n    'afterscriptexecute', 'beforescriptexecute', 'DOMContentLoaded', 'freeze', 'fullscreenchange',\n    'mozfullscreenchange', 'webkitfullscreenchange', 'msfullscreenchange', 'fullscreenerror',\n    'mozfullscreenerror', 'webkitfullscreenerror', 'msfullscreenerror', 'readystatechange',\n    'visibilitychange', 'resume'\n];\nconst 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];\nconst htmlElementEventNames = [\n    'beforecopy', 'beforecut', 'beforepaste', 'copy', 'cut', 'paste', 'dragstart', 'loadend',\n    'animationstart', 'search', 'transitionrun', 'transitionstart', 'webkitanimationend',\n    'webkitanimationiteration', 'webkitanimationstart', 'webkittransitionend'\n];\nconst mediaElementEventNames = ['encrypted', 'waitingforkey', 'msneedkey', 'mozinterruptbegin', 'mozinterruptend'];\nconst 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];\nconst webglEventNames = ['webglcontextrestored', 'webglcontextlost', 'webglcontextcreationerror'];\nconst formEventNames = ['autocomplete', 'autocompleteerror'];\nconst detailEventNames = ['toggle'];\nconst frameEventNames = ['load'];\nconst frameSetEventNames = ['blur', 'error', 'focus', 'load', 'resize', 'scroll', 'messageerror'];\nconst marqueeEventNames = ['bounce', 'finish', 'start'];\nconst XMLHttpRequestEventNames = [\n    'loadstart', 'progress', 'abort', 'error', 'load', 'progress', 'timeout', 'loadend',\n    'readystatechange'\n];\nconst IDBIndexEventNames = ['upgradeneeded', 'complete', 'abort', 'success', 'error', 'blocked', 'versionchange', 'close'];\nconst websocketEventNames = ['close', 'error', 'open', 'message'];\nconst workerEventNames = ['error', 'message'];\nconst eventNames = globalEventHandlersEventNames.concat(webglEventNames, formEventNames, detailEventNames, documentEventNames, windowEventNames, htmlElementEventNames, ieElementEventNames);\nfunction filterProperties(target, onProperties, ignoreProperties) {\n    if (!ignoreProperties || ignoreProperties.length === 0) {\n        return onProperties;\n    }\n    const tip = ignoreProperties.filter(ip => ip.target === target);\n    if (!tip || tip.length === 0) {\n        return onProperties;\n    }\n    const targetIgnoreProperties = tip[0].ignoreProperties;\n    return onProperties.filter(op => targetIgnoreProperties.indexOf(op) === -1);\n}\nfunction 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    const filteredProperties = filterProperties(target, onProperties, ignoreProperties);\n    patchOnProperties(target, filteredProperties, prototype);\n}\nfunction 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    const supportsWebSocket = typeof WebSocket !== 'undefined';\n    const ignoreProperties = _global['__Zone_ignore_on_properties'];\n    // for browsers that we can patch the descriptor:  Chrome & Firefox\n    if (isBrowser) {\n        const internalWindow = window;\n        const ignoreErrorProperties = isIE() ? [{ target: internalWindow, 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, eventNames.concat(['messageerror']), ignoreProperties ? ignoreProperties.concat(ignoreErrorProperties) : ignoreProperties, ObjectGetPrototypeOf(internalWindow));\n        patchFilteredProperties(Document.prototype, eventNames, ignoreProperties);\n        if (typeof internalWindow['SVGElement'] !== 'undefined') {\n            patchFilteredProperties(internalWindow['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        const HTMLMarqueeElement = internalWindow['HTMLMarqueeElement'];\n        if (HTMLMarqueeElement) {\n            patchFilteredProperties(HTMLMarqueeElement.prototype, marqueeEventNames, ignoreProperties);\n        }\n        const Worker = internalWindow['Worker'];\n        if (Worker) {\n            patchFilteredProperties(Worker.prototype, workerEventNames, ignoreProperties);\n        }\n    }\n    const 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    const 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/**\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 */\nZone.__load_patch('util', (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    const SYMBOL_BLACK_LISTED_EVENTS = Zone.__symbol__('BLACK_LISTED_EVENTS');\n    const 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 = () => ({\n        globalSources,\n        zoneSymbolEventNames: zoneSymbolEventNames$1,\n        eventNames,\n        isBrowser,\n        isMix,\n        isNode,\n        TRUE_STR,\n        FALSE_STR,\n        ZONE_SYMBOL_PREFIX,\n        ADD_EVENT_LISTENER_STR,\n        REMOVE_EVENT_LISTENER_STR\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 */\nconst taskSymbol = zoneSymbol('zoneTask');\nfunction patchTimer(window, setName, cancelName, nameSuffix) {\n    let setNative = null;\n    let clearNative = null;\n    setName += nameSuffix;\n    cancelName += nameSuffix;\n    const tasksByHandleId = {};\n    function scheduleTask(task) {\n        const 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, (delegate) => function (self, args) {\n            if (typeof args[0] === 'function') {\n                const options = {\n                    isPeriodic: nameSuffix === 'Interval',\n                    delay: (nameSuffix === 'Timeout' || nameSuffix === 'Interval') ? args[1] || 0 :\n                        undefined,\n                    args: args\n                };\n                const callback = args[0];\n                args[0] = function timer() {\n                    try {\n                        return callback.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.isPeriodic)) {\n                            if (typeof options.handleId === 'number') {\n                                // in non-nodejs env, we remove timerId\n                                // from local cache\n                                delete tasksByHandleId[options.handleId];\n                            }\n                            else if (options.handleId) {\n                                // Node returns complex objects as handleIds\n                                // we remove task reference from timer object\n                                options.handleId[taskSymbol] = null;\n                            }\n                        }\n                    }\n                };\n                const task = scheduleMacroTaskWithCurrentZone(setName, args[0], options, scheduleTask, clearTask);\n                if (!task) {\n                    return task;\n                }\n                // Node.js must additionally support the ref and unref functions.\n                const 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, (delegate) => function (self, args) {\n            const id = args[0];\n            let 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/**\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 */\nfunction patchCustomElements(_global, api) {\n    const { isBrowser, isMix } = api.getGlobalObjects();\n    if ((!isBrowser && !isMix) || !_global['customElements'] || !('customElements' in _global)) {\n        return;\n    }\n    const callbacks = ['connectedCallback', 'disconnectedCallback', 'adoptedCallback', 'attributeChangedCallback'];\n    api.patchCallbacks(api, _global.customElements, 'customElements', 'define', callbacks);\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 */\nfunction eventTargetPatch(_global, api) {\n    if (Zone[api.symbol('patchEventTarget')]) {\n        // EventTarget is already patched.\n        return;\n    }\n    const { eventNames, zoneSymbolEventNames, TRUE_STR, FALSE_STR, ZONE_SYMBOL_PREFIX } = api.getGlobalObjects();\n    //  predefine all __zone_symbol__ + eventName + true/false string\n    for (let i = 0; i < eventNames.length; i++) {\n        const eventName = eventNames[i];\n        const falseEventName = eventName + FALSE_STR;\n        const trueEventName = eventName + TRUE_STR;\n        const symbol = ZONE_SYMBOL_PREFIX + falseEventName;\n        const symbolCapture = ZONE_SYMBOL_PREFIX + trueEventName;\n        zoneSymbolEventNames[eventName] = {};\n        zoneSymbolEventNames[eventName][FALSE_STR] = symbol;\n        zoneSymbolEventNames[eventName][TRUE_STR] = symbolCapture;\n    }\n    const 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}\nfunction patchEvent(global, api) {\n    api.patchEventPrototype(global, api);\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 */\nZone.__load_patch('legacy', (global) => {\n    const legacyPatch = global[Zone.__symbol__('legacyPatch')];\n    if (legacyPatch) {\n        legacyPatch();\n    }\n});\nZone.__load_patch('queueMicrotask', (global, Zone, api) => {\n    api.patchMethod(global, 'queueMicrotask', delegate => {\n        return function (self, args) {\n            Zone.current.scheduleMicroTask('queueMicrotask', args[0]);\n        };\n    });\n});\nZone.__load_patch('timers', (global) => {\n    const set = 'set';\n    const clear = 'clear';\n    patchTimer(global, set, clear, 'Timeout');\n    patchTimer(global, set, clear, 'Interval');\n    patchTimer(global, set, clear, 'Immediate');\n});\nZone.__load_patch('requestAnimationFrame', (global) => {\n    patchTimer(global, 'request', 'cancel', 'AnimationFrame');\n    patchTimer(global, 'mozRequest', 'mozCancel', 'AnimationFrame');\n    patchTimer(global, 'webkitRequest', 'webkitCancel', 'AnimationFrame');\n});\nZone.__load_patch('blocking', (global, Zone) => {\n    const blockingMethods = ['alert', 'prompt', 'confirm'];\n    for (let i = 0; i < blockingMethods.length; i++) {\n        const name = blockingMethods[i];\n        patchMethod(global, name, (delegate, symbol, name) => {\n            return function (s, args) {\n                return Zone.current.run(delegate, global, args, name);\n            };\n        });\n    }\n});\nZone.__load_patch('EventTarget', (global, Zone, api) => {\n    patchEvent(global, api);\n    eventTargetPatch(global, api);\n    // patch XMLHttpRequestEventTarget's addEventListener/removeEventListener\n    const XMLHttpRequestEventTarget = global['XMLHttpRequestEventTarget'];\n    if (XMLHttpRequestEventTarget && XMLHttpRequestEventTarget.prototype) {\n        api.patchEventTarget(global, [XMLHttpRequestEventTarget.prototype]);\n    }\n});\nZone.__load_patch('MutationObserver', (global, Zone, api) => {\n    patchClass('MutationObserver');\n    patchClass('WebKitMutationObserver');\n});\nZone.__load_patch('IntersectionObserver', (global, Zone, api) => {\n    patchClass('IntersectionObserver');\n});\nZone.__load_patch('FileReader', (global, Zone, api) => {\n    patchClass('FileReader');\n});\nZone.__load_patch('on_property', (global, Zone, api) => {\n    propertyDescriptorPatch(api, global);\n});\nZone.__load_patch('customElements', (global, Zone, api) => {\n    patchCustomElements(global, api);\n});\nZone.__load_patch('XHR', (global, Zone) => {\n    // Treat XMLHttpRequest as a macrotask.\n    patchXHR(global);\n    const XHR_TASK = zoneSymbol('xhrTask');\n    const XHR_SYNC = zoneSymbol('xhrSync');\n    const XHR_LISTENER = zoneSymbol('xhrListener');\n    const XHR_SCHEDULED = zoneSymbol('xhrScheduled');\n    const XHR_URL = zoneSymbol('xhrURL');\n    const XHR_ERROR_BEFORE_SCHEDULED = zoneSymbol('xhrErrorBeforeScheduled');\n    function patchXHR(window) {\n        const XMLHttpRequest = window['XMLHttpRequest'];\n        if (!XMLHttpRequest) {\n            // XMLHttpRequest is not available in service worker\n            return;\n        }\n        const XMLHttpRequestPrototype = XMLHttpRequest.prototype;\n        function findPendingTask(target) {\n            return target[XHR_TASK];\n        }\n        let oriAddListener = XMLHttpRequestPrototype[ZONE_SYMBOL_ADD_EVENT_LISTENER];\n        let oriRemoveListener = XMLHttpRequestPrototype[ZONE_SYMBOL_REMOVE_EVENT_LISTENER];\n        if (!oriAddListener) {\n            const XMLHttpRequestEventTarget = window['XMLHttpRequestEventTarget'];\n            if (XMLHttpRequestEventTarget) {\n                const XMLHttpRequestEventTargetPrototype = XMLHttpRequestEventTarget.prototype;\n                oriAddListener = XMLHttpRequestEventTargetPrototype[ZONE_SYMBOL_ADD_EVENT_LISTENER];\n                oriRemoveListener = XMLHttpRequestEventTargetPrototype[ZONE_SYMBOL_REMOVE_EVENT_LISTENER];\n            }\n        }\n        const READY_STATE_CHANGE = 'readystatechange';\n        const SCHEDULED = 'scheduled';\n        function scheduleTask(task) {\n            const data = task.data;\n            const target = data.target;\n            target[XHR_SCHEDULED] = false;\n            target[XHR_ERROR_BEFORE_SCHEDULED] = false;\n            // remove existing event listener\n            const 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            const newListener = target[XHR_LISTENER] = () => {\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                        const loadTasks = target[Zone.__symbol__('loadfalse')];\n                        if (target.status !== 0 && loadTasks && loadTasks.length > 0) {\n                            const oriInvoke = task.invoke;\n                            task.invoke = function () {\n                                // need to load the tasks again, because in other\n                                // load listener, they may remove themselves\n                                const loadTasks = target[Zone.__symbol__('loadfalse')];\n                                for (let 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.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            const 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            const 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        const openNative = patchMethod(XMLHttpRequestPrototype, 'open', () => function (self, args) {\n            self[XHR_SYNC] = args[2] == false;\n            self[XHR_URL] = args[1];\n            return openNative.apply(self, args);\n        });\n        const XMLHTTPREQUEST_SOURCE = 'XMLHttpRequest.send';\n        const fetchTaskAborting = zoneSymbol('fetchTaskAborting');\n        const fetchTaskScheduling = zoneSymbol('fetchTaskScheduling');\n        const sendNative = patchMethod(XMLHttpRequestPrototype, 'send', () => 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                const options = { target: self, url: self[XHR_URL], isPeriodic: false, args: args, aborted: false };\n                const 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        const abortNative = patchMethod(XMLHttpRequestPrototype, 'abort', () => function (self, args) {\n            const 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});\nZone.__load_patch('geolocation', (global) => {\n    /// GEO_LOCATION\n    if (global['navigator'] && global['navigator'].geolocation) {\n        patchPrototype(global['navigator'].geolocation, ['getCurrentPosition', 'watchPosition']);\n    }\n});\nZone.__load_patch('PromiseRejectionEvent', (global, Zone) => {\n    // handle unhandled promise rejection\n    function findPromiseRejectionHandler(evtName) {\n        return function (e) {\n            const eventTasks = findEventTasks(global, evtName);\n            eventTasks.forEach(eventTask => {\n                // windows has added unhandledrejection event listener\n                // trigger the event listener\n                const PromiseRejectionEvent = global['PromiseRejectionEvent'];\n                if (PromiseRejectionEvent) {\n                    const 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","require('../../modules/es.array.includes');\nvar entryUnbind = require('../../internals/entry-unbind');\n\nmodule.exports = entryUnbind('Array', 'includes');\n","require('../../modules/es.object.entries');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Object.entries;\n","require('../../modules/es.object.values');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Object.values;\n","require('../../modules/es.string.includes');\nvar entryUnbind = require('../../internals/entry-unbind');\n\nmodule.exports = entryUnbind('String', 'includes');\n","module.exports = function (it) {\n  if (typeof it != 'function') {\n    throw TypeError(String(it) + ' is not a function');\n  } return it;\n};\n","var wellKnownSymbol = require('../internals/well-known-symbol');\nvar create = require('../internals/object-create');\nvar definePropertyModule = require('../internals/object-define-property');\n\nvar UNSCOPABLES = wellKnownSymbol('unscopables');\nvar ArrayPrototype = Array.prototype;\n\n// Array.prototype[@@unscopables]\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\nif (ArrayPrototype[UNSCOPABLES] == undefined) {\n  definePropertyModule.f(ArrayPrototype, UNSCOPABLES, {\n    configurable: true,\n    value: create(null)\n  });\n}\n\n// add a key to Array.prototype[@@unscopables]\nmodule.exports = function (key) {\n  ArrayPrototype[UNSCOPABLES][key] = true;\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","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 toString = {}.toString;\n\nmodule.exports = function (it) {\n  return toString.call(it).slice(8, -1);\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 wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar MATCH = wellKnownSymbol('match');\n\nmodule.exports = function (METHOD_NAME) {\n  var regexp = /./;\n  try {\n    '/./'[METHOD_NAME](regexp);\n  } catch (error1) {\n    try {\n      regexp[MATCH] = false;\n      return '/./'[METHOD_NAME](regexp);\n    } catch (error2) { /* empty */ }\n  } return false;\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","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 fails = require('../internals/fails');\n\n// Detect IE8's incomplete defineProperty implementation\nmodule.exports = !fails(function () {\n  // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;\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 getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('navigator', 'userAgent') || '';\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] < 4 ? 1 : 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 global = require('../internals/global');\nvar bind = require('../internals/function-bind-context');\n\nvar call = Function.call;\n\nmodule.exports = function (CONSTRUCTOR, METHOD, length) {\n  return bind(call, global[CONSTRUCTOR].prototype[METHOD], length);\n};\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 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","module.exports = function (exec) {\n  try {\n    return !!exec();\n  } catch (error) {\n    return true;\n  }\n};\n","var aFunction = require('../internals/a-function');\n\n// optional / simple context binding\nmodule.exports = function (fn, that, length) {\n  aFunction(fn);\n  if (that === undefined) return fn;\n  switch (length) {\n    case 0: return function () {\n      return fn.call(that);\n    };\n    case 1: return function (a) {\n      return fn.call(that, a);\n    };\n    case 2: return function (a, b) {\n      return fn.call(that, a, b);\n    };\n    case 3: return function (a, b, c) {\n      return fn.call(that, a, b, c);\n    };\n  }\n  return function (/* ...args */) {\n    return fn.apply(that, arguments);\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","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  // eslint-disable-next-line es/no-global-this -- safe\n  check(typeof globalThis == 'object' && globalThis) ||\n  check(typeof window == 'object' && window) ||\n  // eslint-disable-next-line no-restricted-globals -- safe\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 toObject = require('../internals/to-object');\n\nvar hasOwnProperty = {}.hasOwnProperty;\n\nmodule.exports = Object.hasOwn || function hasOwn(it, key) {\n  return hasOwnProperty.call(toObject(it), key);\n};\n","module.exports = {};\n","var getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('document', 'documentElement');\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  // eslint-disable-next-line es/no-object-defineproperty -- requied for testing\n  return Object.defineProperty(createElement('div'), 'a', {\n    get: function () { return 7; }\n  }).a != 7;\n});\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 store = require('../internals/shared-store');\n\nvar functionToString = Function.toString;\n\n// this helper broken in `core-js@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","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 OBJECT_ALREADY_INITIALIZED = 'Object already initialized';\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 || shared.state) {\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    if (wmhas.call(store, it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\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    if (objectHas(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\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 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","module.exports = function (it) {\n  return typeof it === 'object' ? it !== null : typeof it === 'function';\n};\n","module.exports = false;\n","var isObject = require('../internals/is-object');\nvar classof = require('../internals/classof-raw');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar MATCH = wellKnownSymbol('match');\n\n// `IsRegExp` abstract operation\n// https://tc39.es/ecma262/#sec-isregexp\nmodule.exports = function (it) {\n  var isRegExp;\n  return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : classof(it) == 'RegExp');\n};\n","/* eslint-disable es/no-symbol -- required for testing */\nvar V8_VERSION = require('../internals/engine-v8-version');\nvar fails = require('../internals/fails');\n\n// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing\nmodule.exports = !!Object.getOwnPropertySymbols && !fails(function () {\n  var symbol = Symbol();\n  // Chrome 38 Symbol has incorrect toString conversion\n  // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances\n  return !String(symbol) || !(Object(symbol) instanceof Symbol) ||\n    // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances\n    !Symbol.sham && V8_VERSION && V8_VERSION < 41;\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 isRegExp = require('../internals/is-regexp');\n\nmodule.exports = function (it) {\n  if (isRegExp(it)) {\n    throw TypeError(\"The method doesn't accept regular expressions\");\n  } return it;\n};\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 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\n// eslint-disable-next-line es/no-object-defineproperties -- safe\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 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\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar $defineProperty = Object.defineProperty;\n\n// `Object.defineProperty` method\n// https://tc39.es/ecma262/#sec-object.defineproperty\nexports.f = DESCRIPTORS ? $defineProperty : function defineProperty(O, P, Attributes) {\n  anObject(O);\n  P = toPrimitive(P, true);\n  anObject(Attributes);\n  if (IE8_DOM_DEFINE) try {\n    return $defineProperty(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 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\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// `Object.getOwnPropertyDescriptor` method\n// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor\nexports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {\n  O = toIndexedObject(O);\n  P = toPrimitive(P, true);\n  if (IE8_DOM_DEFINE) try {\n    return $getOwnPropertyDescriptor(O, P);\n  } catch (error) { /* empty */ }\n  if (has(O, P)) return createPropertyDescriptor(!propertyIsEnumerableModule.f.call(O, P), O[P]);\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\n// eslint-disable-next-line es/no-object-getownpropertynames -- safe\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {\n  return internalObjectKeys(O, hiddenKeys);\n};\n","// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe\nexports.f = Object.getOwnPropertySymbols;\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 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\n// eslint-disable-next-line es/no-object-keys -- safe\nmodule.exports = Object.keys || function keys(O) {\n  return internalObjectKeys(O, enumBugKeys);\n};\n","'use strict';\nvar $propertyIsEnumerable = {}.propertyIsEnumerable;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// Nashorn ~ JDK8 bug\nvar NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.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} : $propertyIsEnumerable;\n","var DESCRIPTORS = require('../internals/descriptors');\nvar objectKeys = require('../internals/object-keys');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar propertyIsEnumerable = require('../internals/object-property-is-enumerable').f;\n\n// `Object.{ entries, values }` methods implementation\nvar createMethod = function (TO_ENTRIES) {\n  return function (it) {\n    var O = toIndexedObject(it);\n    var keys = objectKeys(O);\n    var length = keys.length;\n    var i = 0;\n    var result = [];\n    var key;\n    while (length > i) {\n      key = keys[i++];\n      if (!DESCRIPTORS || propertyIsEnumerable.call(O, key)) {\n        result.push(TO_ENTRIES ? [key, O[key]] : O[key]);\n      }\n    }\n    return result;\n  };\n};\n\nmodule.exports = {\n  // `Object.entries` method\n  // https://tc39.es/ecma262/#sec-object.entries\n  entries: createMethod(true),\n  // `Object.values` method\n  // https://tc39.es/ecma262/#sec-object.values\n  values: createMethod(false)\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","var global = require('../internals/global');\n\nmodule.exports = global;\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","// `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 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","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","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 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.15.2',\n  mode: IS_PURE ? 'pure' : 'global',\n  copyright: '© 2021 Denis Pushkarev (zloirock.ru)'\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","// 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 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 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 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 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 id = 0;\nvar postfix = Math.random();\n\nmodule.exports = function (key) {\n  return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id + postfix).toString(36);\n};\n","/* eslint-disable es/no-symbol -- required for testing */\nvar NATIVE_SYMBOL = require('../internals/native-symbol');\n\nmodule.exports = NATIVE_SYMBOL\n  && !Symbol.sham\n  && typeof Symbol.iterator == 'symbol';\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","'use strict';\nvar $ = require('../internals/export');\nvar $includes = require('../internals/array-includes').includes;\nvar addToUnscopables = require('../internals/add-to-unscopables');\n\n// `Array.prototype.includes` method\n// https://tc39.es/ecma262/#sec-array.prototype.includes\n$({ target: 'Array', proto: true }, {\n  includes: function includes(el /* , fromIndex = 0 */) {\n    return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);\n  }\n});\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('includes');\n","var $ = require('../internals/export');\nvar $entries = require('../internals/object-to-array').entries;\n\n// `Object.entries` method\n// https://tc39.es/ecma262/#sec-object.entries\n$({ target: 'Object', stat: true }, {\n  entries: function entries(O) {\n    return $entries(O);\n  }\n});\n","var $ = require('../internals/export');\nvar $values = require('../internals/object-to-array').values;\n\n// `Object.values` method\n// https://tc39.es/ecma262/#sec-object.values\n$({ target: 'Object', stat: true }, {\n  values: function values(O) {\n    return $values(O);\n  }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar notARegExp = require('../internals/not-a-regexp');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\nvar correctIsRegExpLogic = require('../internals/correct-is-regexp-logic');\n\n// `String.prototype.includes` method\n// https://tc39.es/ecma262/#sec-string.prototype.includes\n$({ target: 'String', proto: true, forced: !correctIsRegExpLogic('includes') }, {\n  includes: function includes(searchString /* , position = 0 */) {\n    return !!~String(requireObjectCoercible(this))\n      .indexOf(notARegExp(searchString), arguments.length > 1 ? arguments[1] : undefined);\n  }\n});\n"]}