text: "use strict";
  (self["webpackChunkhome"] = self["webpackChunkhome"] || []).push([["polyfills"],{
  
  /***/ 7435:
  /*!**************************!*\
    !*** ./src/polyfills.ts ***!
    \**************************/
  /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
  
  __webpack_require__.r(__webpack_exports__);
  /* harmony import */ var zone_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! zone.js */ 4946);
  /* harmony import */ var zone_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(zone_js__WEBPACK_IMPORTED_MODULE_0__);
  /**
   * This file includes polyfills needed by Angular and is loaded before the app.
   * You can add your own extra polyfills to this file.
   *
   * This file is divided into 2 sections:
   *   1. Browser polyfills. These are applied before loading ZoneJS and are sorted by browsers.
   *   2. Application imports. Files imported after ZoneJS that should be loaded before your main
   *      file.
   *
   * The current setup is for so-called "evergreen" browsers; the last versions of browsers that
   * automatically update themselves. This includes recent versions of Safari, Chrome (including
   * Opera), Edge on the desktop, and iOS and Chrome on mobile.
   *
   * Learn more in https://angular.io/guide/browser-support
   */
  /***************************************************************************************************
   * BROWSER POLYFILLS
   */
  /**
   * By default, zone.js will patch all possible macroTask and DomEvents
   * user can disable parts of macroTask/DomEvents patch by setting following flags
   * because those flags need to be set before `zone.js` being loaded, and webpack
   * will put import in the top of bundle, so user need to create a separate file
   * in this directory (for example: zone-flags.ts), and put the following flags
   * into that file, and then add the following code before importing zone.js.
   * import './zone-flags';
   *
   * The flags allowed in zone-flags.ts are listed here.
   *
   * The following flags will work for all browsers.
   *
   * (window as any).__Zone_disable_requestAnimationFrame = true; // disable patch requestAnimationFrame
   * (window as any).__Zone_disable_on_property = true; // disable patch onProperty such as onclick
   * (window as any).__zone_symbol__UNPATCHED_EVENTS = ['scroll', 'mousemove']; // disable patch specified eventNames
   *
   *  in IE/Edge developer tools, the addEventListener will also be wrapped by zone.js
   *  with the following flag, it will bypass `zone.js` patch for IE/Edge
   *
   *  (window as any).__Zone_enable_cross_context_check = true;
   *
   */
  /***************************************************************************************************
   * Zone JS is required by default for Angular itself.
   */
   // Included with Angular CLI.
  /***************************************************************************************************
   * APPLICATION IMPORTS
   */
  
  
  /***/ }),
  
  /***/ 4946:
  /*!***********************************************!*\
    !*** ./node_modules/zone.js/fesm2015/zone.js ***!
    \***********************************************/
  /***/ (() => {
  
  
  /**
   * @license Angular v12.0.0-next.0
   * (c) 2010-2020 Google LLC. https://angular.io/
   * License: MIT
   */
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  const Zone$1 = (function (global) {
      const performance = global['performance'];
      function mark(name) {
          performance && performance['mark'] && performance['mark'](name);
      }
      function performanceMeasure(name, label) {
          performance && performance['measure'] && performance['measure'](name, label);
      }
      mark('Zone');
      // Initialize before it's accessed below.
      // __Zone_symbol_prefix global can be used to override the default zone
      // symbol prefix with a custom one if needed.
      const symbolPrefix = global['__Zone_symbol_prefix'] || '__zone_symbol__';
      function __symbol__(name) {
          return symbolPrefix + name;
      }
      const checkDuplicate = global[__symbol__('forceDuplicateZoneCheck')] === true;
      if (global['Zone']) {
          // if global['Zone'] already exists (maybe zone.js was already loaded or
          // some other lib also registered a global object named Zone), we may need
          // to throw an error, but sometimes user may not want this error.
          // For example,
          // we have two web pages, page1 includes zone.js, page2 doesn't.
          // and the 1st time user load page1 and page2, everything work fine,
          // but when user load page2 again, error occurs because global['Zone'] already exists.
          // so we add a flag to let user choose whether to throw this error or not.
          // By default, if existing Zone is from zone.js, we will not throw the error.
          if (checkDuplicate || typeof global['Zone'].__symbol__ !== 'function') {
              throw new Error('Zone already loaded.');
          }
          else {
              return global['Zone'];
          }
      }
      class Zone {
          constructor(parent, zoneSpec) {
              this._parent = parent;
              this._name = zoneSpec ? zoneSpec.name || 'unnamed' : '<root>';
              this._properties = zoneSpec && zoneSpec.properties || {};
              this._zoneDelegate =
                  new ZoneDelegate(this, this._parent && this._parent._zoneDelegate, zoneSpec);
          }
          static assertZonePatched() {
              if (global['Promise'] !== patches['ZoneAwarePromise']) {
                  throw new Error('Zone.js has detected that ZoneAwarePromise `(window|global).Promise` ' +
                      'has been overwritten.\n' +
                      'Most likely cause is that a Promise polyfill has been loaded ' +
                      'after Zone.js (Polyfilling Promise api is not necessary when zone.js is loaded. ' +
                      'If you must load one, do so before loading zone.js.)');
              }
          }
          static get root() {
              let zone = Zone.current;
              while (zone.parent) {
                  zone = zone.parent;
              }
              return zone;
          }
          static get current() {
              return _currentZoneFrame.zone;
          }
          static get currentTask() {
              return _currentTask;
          }
          // tslint:disable-next-line:require-internal-with-underscore
          static __load_patch(name, fn, ignoreDuplicate = false) {
              if (patches.hasOwnProperty(name)) {
                  // `checkDuplicate` option is defined from global variable
                  // so it works for all modules.
                  // `ignoreDuplicate` can work for the specified module
                  if (!ignoreDuplicate && checkDuplicate) {
                      throw Error('Already loaded patch: ' + name);
                  }
              }
              else if (!global['__Zone_disable_' + name]) {
                  const perfName = 'Zone:' + name;
                  mark(perfName);
                  patches[name] = fn(global, Zone, _api);
                  performanceMeasure(perfName, perfName);
              }
          }
          get parent() {
              return this._parent;
          }
          get name() {
              return this._name;
          }
          get(key) {
              const zone = this.getZoneWith(key);
              if (zone)
                  return zone._properties[key];
          }
          getZoneWith(key) {
              let current = this;
              while (current) {
                  if (current._properties.hasOwnProperty(key)) {
                      return current;
                  }
                  current = current._parent;
              }
              return null;
          }
          fork(zoneSpec) {
              if (!zoneSpec)
                  throw new Error('ZoneSpec required!');
              return this._zoneDelegate.fork(this, zoneSpec);
          }
          wrap(callback, source) {
              if (typeof callback !== 'function') {
                  throw new Error('Expecting function got: ' + callback);
              }
              const _callback = this._zoneDelegate.intercept(this, callback, source);
              const zone = this;
              return function () {
                  return zone.runGuarded(_callback, this, arguments, source);
              };
          }
          run(callback, applyThis, applyArgs, source) {
              _currentZoneFrame = { parent: _currentZoneFrame, zone: this };
              try {
                  return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source);
              }
              finally {
                  _currentZoneFrame = _currentZoneFrame.parent;
              }
          }
          runGuarded(callback, applyThis = null, applyArgs, source) {
              _currentZoneFrame = { parent: _currentZoneFrame, zone: this };
              try {
                  try {
                      return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source);
                  }
                  catch (error) {
                      if (this._zoneDelegate.handleError(this, error)) {
                          throw error;
                      }
                  }
              }
              finally {
                  _currentZoneFrame = _currentZoneFrame.parent;
              }
          }
          runTask(task, applyThis, applyArgs) {
              if (task.zone != this) {
                  throw new Error('A task can only be run in the zone of creation! (Creation: ' +
                      (task.zone || NO_ZONE).name + '; Execution: ' + this.name + ')');
              }
              // https://github.com/angular/zone.js/issues/778, sometimes eventTask
              // will run in notScheduled(canceled) state, we should not try to
              // run such kind of task but just return
              if (task.state === notScheduled && (task.type === eventTask || task.type === macroTask)) {
                  return;
              }
              const reEntryGuard = task.state != running;
              reEntryGuard && task._transitionTo(running, scheduled);
              task.runCount++;
              const previousTask = _currentTask;
              _currentTask = task;
              _currentZoneFrame = { parent: _currentZoneFrame, zone: this };
              try {
                  if (task.type == macroTask && task.data && !task.data.isPeriodic) {
                      task.cancelFn = undefined;
                  }
                  try {
                      return this._zoneDelegate.invokeTask(this, task, applyThis, applyArgs);
                  }
                  catch (error) {
                      if (this._zoneDelegate.handleError(this, error)) {
                          throw error;
                      }
                  }
              }
              finally {
                  // if the task's state is notScheduled or unknown, then it has already been cancelled
                  // we should not reset the state to scheduled
                  if (task.state !== notScheduled && task.state !== unknown) {
                      if (task.type == eventTask || (task.data && task.data.isPeriodic)) {
                          reEntryGuard && task._transitionTo(scheduled, running);
                      }
                      else {
                          task.runCount = 0;
                          this._updateTaskCount(task, -1);
                          reEntryGuard &&
                              task._transitionTo(notScheduled, running, notScheduled);
                      }
                  }
                  _currentZoneFrame = _currentZoneFrame.parent;
                  _currentTask = previousTask;
              }
          }
          scheduleTask(task) {
              if (task.zone && task.zone !== this) {
                  // check if the task was rescheduled, the newZone
                  // should not be the children of the original zone
                  let newZone = this;
                  while (newZone) {
                      if (newZone === task.zone) {
                          throw Error(`can not reschedule task to ${this.name} which is descendants of the original zone ${task.zone.name}`);
                      }
                      newZone = newZone.parent;
                  }
              }
              task._transitionTo(scheduling, notScheduled);
              const zoneDelegates = [];
              task._zoneDelegates = zoneDelegates;
              task._zone = this;
              try {
                  task = this._zoneDelegate.scheduleTask(this, task);
              }
              catch (err) {
                  // should set task's state to unknown when scheduleTask throw error
                  // because the err may from reschedule, so the fromState maybe notScheduled
                  task._transitionTo(unknown, scheduling, notScheduled);
                  // TODO: @JiaLiPassion, should we check the result from handleError?
                  this._zoneDelegate.handleError(this, err);
                  throw err;
              }
              if (task._zoneDelegates === zoneDelegates) {
                  // we have to check because internally the delegate can reschedule the task.
                  this._updateTaskCount(task, 1);
              }
              if (task.state == scheduling) {
                  task._transitionTo(scheduled, scheduling);
              }
              return task;
          }
          scheduleMicroTask(source, callback, data, customSchedule) {
              return this.scheduleTask(new ZoneTask(microTask, source, callback, data, customSchedule, undefined));
          }
          scheduleMacroTask(source, callback, data, customSchedule, customCancel) {
              return this.scheduleTask(new ZoneTask(macroTask, source, callback, data, customSchedule, customCancel));
          }
          scheduleEventTask(source, callback, data, customSchedule, customCancel) {
              return this.scheduleTask(new ZoneTask(eventTask, source, callback, data, customSchedule, customCancel));
          }
          cancelTask(task) {
              if (task.zone != this)
                  throw new Error('A task can only be cancelled in the zone of creation! (Creation: ' +
                      (task.zone || NO_ZONE).name + '; Execution: ' + this.name + ')');
              task._transitionTo(canceling, scheduled, running);
              try {
                  this._zoneDelegate.cancelTask(this, task);
              }
              catch (err) {
                  // if error occurs when cancelTask, transit the state to unknown
                  task._transitionTo(unknown, canceling);
                  this._zoneDelegate.handleError(this, err);
                  throw err;
              }
              this._updateTaskCount(task, -1);
              task._transitionTo(notScheduled, canceling);
              task.runCount = 0;
              return task;
          }
          _updateTaskCount(task, count) {
              const zoneDelegates = task._zoneDelegates;
              if (count == -1) {
                  task._zoneDelegates = null;
              }
              for (let i = 0; i < zoneDelegates.length; i++) {
                  zoneDelegates[i]._updateTaskCount(task.type, count);
              }
          }
      }
      // tslint:disable-next-line:require-internal-with-underscore
      Zone.__symbol__ = __symbol__;
      const DELEGATE_ZS = {
          name: '',
          onHasTask: (delegate, _, target, hasTaskState) => delegate.hasTask(target, hasTaskState),
          onScheduleTask: (delegate, _, target, task) => delegate.scheduleTask(target, task),
          onInvokeTask: (delegate, _, target, task, applyThis, applyArgs) => delegate.invokeTask(target, task, applyThis, applyArgs),
          onCancelTask: (delegate, _, target, task) => delegate.cancelTask(target, task)
      };
      class ZoneDelegate {
          constructor(zone, parentDelegate, zoneSpec) {
              this._taskCounts = { 'microTask': 0, 'macroTask': 0, 'eventTask': 0 };
              this.zone = zone;
              this._parentDelegate = parentDelegate;
              this._forkZS = zoneSpec && (zoneSpec && zoneSpec.onFork ? zoneSpec : parentDelegate._forkZS);
              this._forkDlgt = zoneSpec && (zoneSpec.onFork ? parentDelegate : parentDelegate._forkDlgt);
              this._forkCurrZone =
                  zoneSpec && (zoneSpec.onFork ? this.zone : parentDelegate._forkCurrZone);
              this._interceptZS =
                  zoneSpec && (zoneSpec.onIntercept ? zoneSpec : parentDelegate._interceptZS);
              this._interceptDlgt =
                  zoneSpec && (zoneSpec.onIntercept ? parentDelegate : parentDelegate._interceptDlgt);
              this._interceptCurrZone =
                  zoneSpec && (zoneSpec.onIntercept ? this.zone : parentDelegate._interceptCurrZone);
              this._invokeZS = zoneSpec && (zoneSpec.onInvoke ? zoneSpec : parentDelegate._invokeZS);
              this._invokeDlgt =
                  zoneSpec && (zoneSpec.onInvoke ? parentDelegate : parentDelegate._invokeDlgt);
              this._invokeCurrZone =
                  zoneSpec && (zoneSpec.onInvoke ? this.zone : parentDelegate._invokeCurrZone);
              this._handleErrorZS =
                  zoneSpec && (zoneSpec.onHandleError ? zoneSpec : parentDelegate._handleErrorZS);
              this._handleErrorDlgt =
                  zoneSpec && (zoneSpec.onHandleError ? parentDelegate : parentDelegate._handleErrorDlgt);
              this._handleErrorCurrZone =
                  zoneSpec && (zoneSpec.onHandleError ? this.zone : parentDelegate._handleErrorCurrZone);
              this._scheduleTaskZS =
                  zoneSpec && (zoneSpec.onScheduleTask ? zoneSpec : parentDelegate._scheduleTaskZS);
              this._scheduleTaskDlgt = zoneSpec &&
                  (zoneSpec.onScheduleTask ? parentDelegate : parentDelegate._scheduleTaskDlgt);
              this._scheduleTaskCurrZone =
                  zoneSpec && (zoneSpec.onScheduleTask ? this.zone : parentDelegate._scheduleTaskCurrZone);
              this._invokeTaskZS =
                  zoneSpec && (zoneSpec.onInvokeTask ? zoneSpec : parentDelegate._invokeTaskZS);
              this._invokeTaskDlgt =
                  zoneSpec && (zoneSpec.onInvokeTask ? parentDelegate : parentDelegate._invokeTaskDlgt);
              this._invokeTaskCurrZone =
                  zoneSpec && (zoneSpec.onInvokeTask ? this.zone : parentDelegate._invokeTaskCurrZone);
              this._cancelTaskZS =
                  zoneSpec && (zoneSpec.onCancelTask ? zoneSpec : parentDelegate._cancelTaskZS);
              this._cancelTaskDlgt =
                  zoneSpec && (zoneSpec.onCancelTask ? parentDelegate : parentDelegate._cancelTaskDlgt);
              this._cancelTaskCurrZone =
                  zoneSpec && (zoneSpec.onCancelTask ? this.zone : parentDelegate._cancelTaskCurrZone);
              this._hasTaskZS = null;
              this._hasTaskDlgt = null;
              this._hasTaskDlgtOwner = null;
              this._hasTaskCurrZone = null;
              const zoneSpecHasTask = zoneSpec && zoneSpec.onHasTask;
              const parentHasTask = parentDelegate && parentDelegate._hasTaskZS;
              if (zoneSpecHasTask || parentHasTask) {
                  // If we need to report hasTask, than this ZS needs to do ref counting on tasks. In such
                  // a case all task related interceptors must go through this ZD. We can't short circuit it.
                  this._hasTaskZS = zoneSpecHasTask ? zoneSpec : DELEGATE_ZS;
                  this._hasTaskDlgt = parentDelegate;
                  this._hasTaskDlgtOwner = this;
                  this._hasTaskCurrZone = zone;
                  if (!zoneSpec.onScheduleTask) {
                      this._scheduleTaskZS = DELEGATE_ZS;
                      this._scheduleTaskDlgt = parentDelegate;
                      this._scheduleTaskCurrZone = this.zone;
                  }
                  if (!zoneSpec.onInvokeTask) {
                      this._invokeTaskZS = DELEGATE_ZS;
                      this._invokeTaskDlgt = parentDelegate;
                      this._invokeTaskCurrZone = this.zone;
                  }
                  if (!zoneSpec.onCancelTask) {
                      this._cancelTaskZS = DELEGATE_ZS;
                      this._cancelTaskDlgt = parentDelegate;
                      this._cancelTaskCurrZone = this.zone;
                  }
              }
          }
          fork(targetZone, zoneSpec) {
              return this._forkZS ? this._forkZS.onFork(this._forkDlgt, this.zone, targetZone, zoneSpec) :
                  new Zone(targetZone, zoneSpec);
          }
          intercept(targetZone, callback, source) {
              return this._interceptZS ?
                  this._interceptZS.onIntercept(this._interceptDlgt, this._interceptCurrZone, targetZone, callback, source) :
                  callback;
          }
          invoke(targetZone, callback, applyThis, applyArgs, source) {
              return this._invokeZS ? this._invokeZS.onInvoke(this._invokeDlgt, this._invokeCurrZone, targetZone, callback, applyThis, applyArgs, source) :
                  callback.apply(applyThis, applyArgs);
          }
          handleError(targetZone, error) {
              return this._handleErrorZS ?
                  this._handleErrorZS.onHandleError(this._handleErrorDlgt, this._handleErrorCurrZone, targetZone, error) :
                  true;
          }
          scheduleTask(targetZone, task) {
              let returnTask = task;
              if (this._scheduleTaskZS) {
                  if (this._hasTaskZS) {
                      returnTask._zoneDelegates.push(this._hasTaskDlgtOwner);
                  }
                  // clang-format off
                  returnTask = this._scheduleTaskZS.onScheduleTask(this._scheduleTaskDlgt, this._scheduleTaskCurrZone, targetZone, task);
                  // clang-format on
                  if (!returnTask)
                      returnTask = task;
              }
              else {
                  if (task.scheduleFn) {
                      task.scheduleFn(task);
                  }
                  else if (task.type == microTask) {
                      scheduleMicroTask(task);
                  }
                  else {
                      throw new Error('Task is missing scheduleFn.');
                  }
              }
              return returnTask;
          }
          invokeTask(targetZone, task, applyThis, applyArgs) {
              return this._invokeTaskZS ? this._invokeTaskZS.onInvokeTask(this._invokeTaskDlgt, this._invokeTaskCurrZone, targetZone, task, applyThis, applyArgs) :
                  task.callback.apply(applyThis, applyArgs);
          }
          cancelTask(targetZone, task) {
              let value;
              if (this._cancelTaskZS) {
                  value = this._cancelTaskZS.onCancelTask(this._cancelTaskDlgt, this._cancelTaskCurrZone, targetZone, task);
              }
              else {
                  if (!task.cancelFn) {
                      throw Error('Task is not cancelable');
                  }
                  value = task.cancelFn(task);
              }
              return value;
          }
          hasTask(targetZone, isEmpty) {
              // hasTask should not throw error so other ZoneDelegate
              // can still trigger hasTask callback
              try {
                  this._hasTaskZS &&
                      this._hasTaskZS.onHasTask(this._hasTaskDlgt, this._hasTaskCurrZone, targetZone, isEmpty);
              }
              catch (err) {
                  this.handleError(targetZone, err);
              }
          }
          // tslint:disable-next-line:require-internal-with-underscore
          _updateTaskCount(type, count) {
              const counts = this._taskCounts;
              const prev = counts[type];
              const next = counts[type] = prev + count;
              if (next < 0) {
                  throw new Error('More tasks executed then were scheduled.');
              }
              if (prev == 0 || next == 0) {
                  const isEmpty = {
                      microTask: counts['microTask'] > 0,
                      macroTask: counts['macroTask'] > 0,
                      eventTask: counts['eventTask'] > 0,
                      change: type
                  };
                  this.hasTask(this.zone, isEmpty);
              }
          }
      }
      class ZoneTask {
          constructor(type, source, callback, options, scheduleFn, cancelFn) {
              // tslint:disable-next-line:require-internal-with-underscore
              this._zone = null;
              this.runCount = 0;
              // tslint:disable-next-line:require-internal-with-underscore
              this._zoneDelegates = null;
              // tslint:disable-next-line:require-internal-with-underscore
              this._state = 'notScheduled';
              this.type = type;
              this.source = source;
              this.data = options;
              this.scheduleFn = scheduleFn;
              this.cancelFn = cancelFn;
              if (!callback) {
                  throw new Error('callback is not defined');
              }
              this.callback = callback;
              const self = this;
              // TODO: @JiaLiPassion options should have interface
              if (type === eventTask && options && options.useG) {
                  this.invoke = ZoneTask.invokeTask;
              }
              else {
                  this.invoke = function () {
                      return ZoneTask.invokeTask.call(global, self, this, arguments);
                  };
              }
          }
          static invokeTask(task, target, args) {
              if (!task) {
                  task = this;
              }
              _numberOfNestedTaskFrames++;
              try {
                  task.runCount++;
                  return task.zone.runTask(task, target, args);
              }
              finally {
                  if (_numberOfNestedTaskFrames == 1) {
                      drainMicroTaskQueue();
                  }
                  _numberOfNestedTaskFrames--;
              }
          }
          get zone() {
              return this._zone;
          }
          get state() {
              return this._state;
          }
          cancelScheduleRequest() {
              this._transitionTo(notScheduled, scheduling);
          }
          // tslint:disable-next-line:require-internal-with-underscore
          _transitionTo(toState, fromState1, fromState2) {
              if (this._state === fromState1 || this._state === fromState2) {
                  this._state = toState;
                  if (toState == notScheduled) {
                      this._zoneDelegates = null;
                  }
              }
              else {
                  throw new Error(`${this.type} '${this.source}': can not transition to '${toState}', expecting state '${fromState1}'${fromState2 ? ' or \'' + fromState2 + '\'' : ''}, was '${this._state}'.`);
              }
          }
          toString() {
              if (this.data && typeof this.data.handleId !== 'undefined') {
                  return this.data.handleId.toString();
              }
              else {
                  return Object.prototype.toString.call(this);
              }
          }
          // add toJSON method to prevent cyclic error when
          // call JSON.stringify(zoneTask)
          toJSON() {
              return {
                  type: this.type,
                  state: this.state,
                  source: this.source,
                  zone: this.zone.name,
                  runCount: this.runCount
              };
          }
      }
      //////////////////////////////////////////////////////
      //////////////////////////////////////////////////////
      ///  MICROTASK QUEUE
      //////////////////////////////////////////////////////
      //////////////////////////////////////////////////////
      const symbolSetTimeout = __symbol__('setTimeout');
      const symbolPromise = __symbol__('Promise');
      const symbolThen = __symbol__('then');
      let _microTaskQueue = [];
      let _isDrainingMicrotaskQueue = false;
      let nativeMicroTaskQueuePromise;
      function scheduleMicroTask(task) {
          // if we are not running in any task, and there has not been anything scheduled
          // we must bootstrap the initial task creation by manually scheduling the drain
          if (_numberOfNestedTaskFrames === 0 && _microTaskQueue.length === 0) {
              // We are not running in Task, so we need to kickstart the microtask queue.
              if (!nativeMicroTaskQueuePromise) {
                  if (global[symbolPromise]) {
                      nativeMicroTaskQueuePromise = global[symbolPromise].resolve(0);
                  }
              }
              if (nativeMicroTaskQueuePromise) {
                  let nativeThen = nativeMicroTaskQueuePromise[symbolThen];
                  if (!nativeThen) {
                      // native Promise is not patchable, we need to use `then` directly
                      // issue 1078
                      nativeThen = nativeMicroTaskQueuePromise['then'];
                  }
                  nativeThen.call(nativeMicroTaskQueuePromise, drainMicroTaskQueue);
              }
              else {
                  global[symbolSetTimeout](drainMicroTaskQueue, 0);
              }
          }
          task && _microTaskQueue.push(task);
      }
      function drainMicroTaskQueue() {
          if (!_isDrainingMicrotaskQueue) {
              _isDrainingMicrotaskQueue = true;
              while (_microTaskQueue.length) {
                  const queue = _microTaskQueue;
                  _microTaskQueue = [];
                  for (let i = 0; i < queue.length; i++) {
                      const task = queue[i];
                      try {
                          task.zone.runTask(task, null, null);
                      }
                      catch (error) {
                          _api.onUnhandledError(error);
                      }
                  }
              }
              _api.microtaskDrainDone();
              _isDrainingMicrotaskQueue = false;
          }
      }
      //////////////////////////////////////////////////////
      //////////////////////////////////////////////////////
      ///  BOOTSTRAP
      //////////////////////////////////////////////////////
      //////////////////////////////////////////////////////
      const NO_ZONE = { name: 'NO ZONE' };
      const notScheduled = 'notScheduled', scheduling = 'scheduling', scheduled = 'scheduled', running = 'running', canceling = 'canceling', unknown = 'unknown';
      const microTask = 'microTask', macroTask = 'macroTask', eventTask = 'eventTask';
      const patches = {};
      const _api = {
          symbol: __symbol__,
          currentZoneFrame: () => _currentZoneFrame,
          onUnhandledError: noop,
          microtaskDrainDone: noop,
          scheduleMicroTask: scheduleMicroTask,
          showUncaughtError: () => !Zone[__symbol__('ignoreConsoleErrorUncaughtError')],
          patchEventTarget: () => [],
          patchOnProperties: noop,
          patchMethod: () => noop,
          bindArguments: () => [],
          patchThen: () => noop,
          patchMacroTask: () => noop,
          patchEventPrototype: () => noop,
          isIEOrEdge: () => false,
          getGlobalObjects: () => undefined,
          ObjectDefineProperty: () => noop,
          ObjectGetOwnPropertyDescriptor: () => undefined,
          ObjectCreate: () => undefined,
          ArraySlice: () => [],
          patchClass: () => noop,
          wrapWithCurrentZone: () => noop,
          filterProperties: () => [],
          attachOriginToPatched: () => noop,
          _redefineProperty: () => noop,
          patchCallbacks: () => noop
      };
      let _currentZoneFrame = { parent: null, zone: new Zone(null, null) };
      let _currentTask = null;
      let _numberOfNestedTaskFrames = 0;
      function noop() { }
      performanceMeasure('Zone', 'Zone');
      return global['Zone'] = Zone;
  })(typeof window !== 'undefined' && window || typeof self !== 'undefined' && self || global);
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  /**
   * Suppress closure compiler errors about unknown 'Zone' variable
   * @fileoverview
   * @suppress {undefinedVars,globalThis,missingRequire}
   */
  /// <reference types="node"/>
  // issue #989, to reduce bundle size, use short name
  /** Object.getOwnPropertyDescriptor */
  const ObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
  /** Object.defineProperty */
  const ObjectDefineProperty = Object.defineProperty;
  /** Object.getPrototypeOf */
  const ObjectGetPrototypeOf = Object.getPrototypeOf;
  /** Object.create */
  const ObjectCreate = Object.create;
  /** Array.prototype.slice */
  const ArraySlice = Array.prototype.slice;
  /** addEventListener string const */
  const ADD_EVENT_LISTENER_STR = 'addEventListener';
  /** removeEventListener string const */
  const REMOVE_EVENT_LISTENER_STR = 'removeEventListener';
  /** zoneSymbol addEventListener */
  const ZONE_SYMBOL_ADD_EVENT_LISTENER = Zone.__symbol__(ADD_EVENT_LISTENER_STR);
  /** zoneSymbol removeEventListener */
  const ZONE_SYMBOL_REMOVE_EVENT_LISTENER = Zone.__symbol__(REMOVE_EVENT_LISTENER_STR);
  /** true string const */
  const TRUE_STR = 'true';
  /** false string const */
  const FALSE_STR = 'false';
  /** Zone symbol prefix string const. */
  const ZONE_SYMBOL_PREFIX = Zone.__symbol__('');
  function wrapWithCurrentZone(callback, source) {
      return Zone.current.wrap(callback, source);
  }
  function scheduleMacroTaskWithCurrentZone(source, callback, data, customSchedule, customCancel) {
      return Zone.current.scheduleMacroTask(source, callback, data, customSchedule, customCancel);
  }
  const zoneSymbol = Zone.__symbol__;
  const isWindowExists = typeof window !== 'undefined';
  const internalWindow = isWindowExists ? window : undefined;
  const _global = isWindowExists && internalWindow || typeof self === 'object' && self || global;
  const REMOVE_ATTRIBUTE = 'removeAttribute';
  const NULL_ON_PROP_VALUE = [null];
  function bindArguments(args, source) {
      for (let i = args.length - 1; i >= 0; i--) {
          if (typeof args[i] === 'function') {
              args[i] = wrapWithCurrentZone(args[i], source + '_' + i);
          }
      }
      return args;
  }
  function patchPrototype(prototype, fnNames) {
      const source = prototype.constructor['name'];
      for (let i = 0; i < fnNames.length; i++) {
          const name = fnNames[i];
          const delegate = prototype[name];
          if (delegate) {
              const prototypeDesc = ObjectGetOwnPropertyDescriptor(prototype, name);
              if (!isPropertyWritable(prototypeDesc)) {
                  continue;
              }
              prototype[name] = ((delegate) => {
                  const patched = function () {
                      return delegate.apply(this, bindArguments(arguments, source + '.' + name));
                  };
                  attachOriginToPatched(patched, delegate);
                  return patched;
              })(delegate);
          }
      }
  }
  function isPropertyWritable(propertyDesc) {
      if (!propertyDesc) {
          return true;
      }
      if (propertyDesc.writable === false) {
          return false;
      }
      return !(typeof propertyDesc.get === 'function' && typeof propertyDesc.set === 'undefined');
  }
  const isWebWorker = (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope);
  // Make sure to access `process` through `_global` so that WebPack does not accidentally browserify
  // this code.
  const isNode = (!('nw' in _global) && typeof _global.process !== 'undefined' &&
      {}.toString.call(_global.process) === '[object process]');
  const isBrowser = !isNode && !isWebWorker && !!(isWindowExists && internalWindow['HTMLElement']);
  // we are in electron of nw, so we are both browser and nodejs
  // Make sure to access `process` through `_global` so that WebPack does not accidentally browserify
  // this code.
  const isMix = typeof _global.process !== 'undefined' &&
      {}.toString.call(_global.process) === '[object process]' && !isWebWorker &&
      !!(isWindowExists && internalWindow['HTMLElement']);
  const zoneSymbolEventNames = {};
  const wrapFn = function (event) {
      // https://github.com/angular/zone.js/issues/911, in IE, sometimes
      // event will be undefined, so we need to use window.event
      event = event || _global.event;
      if (!event) {
          return;
      }
      let eventNameSymbol = zoneSymbolEventNames[event.type];
      if (!eventNameSymbol) {
          eventNameSymbol = zoneSymbolEventNames[event.type] = zoneSymbol('ON_PROPERTY' + event.type);
      }
      const target = this || event.target || _global;
      const listener = target[eventNameSymbol];
      let result;
      if (isBrowser && target === internalWindow && event.type === 'error') {
          // window.onerror have different signiture
          // https://developer.mozilla.org/en-US/docs/Web/API/GlobalEventHandlers/onerror#window.onerror
          // and onerror callback will prevent default when callback return true
          const errorEvent = event;
          result = listener &&
              listener.call(this, errorEvent.message, errorEvent.filename, errorEvent.lineno, errorEvent.colno, errorEvent.error);
          if (result === true) {
              event.preventDefault();
          }
      }
      else {
          result = listener && listener.apply(this, arguments);
          if (result != undefined && !result) {
              event.preventDefault();
          }
      }
      return result;
  };
  function patchProperty(obj, prop, prototype) {
      let desc = ObjectGetOwnPropertyDescriptor(obj, prop);
      if (!desc && prototype) {
          // when patch window object, use prototype to check prop exist or not
          const prototypeDesc = ObjectGetOwnPropertyDescriptor(prototype, prop);
          if (prototypeDesc) {
              desc = { enumerable: true, configurable: true };
          }
      }
      // if the descriptor not exists or is not configurable
      // just return
      if (!desc || !desc.configurable) {
          return;
      }
      const onPropPatchedSymbol = zoneSymbol('on' + prop + 'patched');
      if (obj.hasOwnProperty(onPropPatchedSymbol) && obj[onPropPatchedSymbol]) {
          return;
      }
      // A property descriptor cannot have getter/setter and be writable
      // deleting the writable and value properties avoids this error:
      //
      // TypeError: property descriptors must not specify a value or be writable when a
      // getter or setter has been specified
      delete desc.writable;
      delete desc.value;
      const originalDescGet = desc.get;
      const originalDescSet = desc.set;
      // substr(2) cuz 'onclick' -> 'click', etc
      const eventName = prop.substr(2);
      let eventNameSymbol = zoneSymbolEventNames[eventName];
      if (!eventNameSymbol) {
          eventNameSymbol = zoneSymbolEventNames[eventName] = zoneSymbol('ON_PROPERTY' + eventName);
      }
      desc.set = function (newValue) {
          // in some of windows's onproperty callback, this is undefined
          // so we need to check it
          let target = this;
          if (!target && obj === _global) {
              target = _global;
          }
          if (!target) {
              return;
          }
          let previousValue = target[eventNameSymbol];
          if (previousValue) {
              target.removeEventListener(eventName, wrapFn);
          }
          // issue #978, when onload handler was added before loading zone.js
          // we should remove it with originalDescSet
          if (originalDescSet) {
              originalDescSet.apply(target, NULL_ON_PROP_VALUE);
          }
          if (typeof newValue === 'function') {
              target[eventNameSymbol] = newValue;
              target.addEventListener(eventName, wrapFn, false);
          }
          else {
              target[eventNameSymbol] = null;
          }
      };
      // The getter would return undefined for unassigned properties but the default value of an
      // unassigned property is null
      desc.get = function () {
          // in some of windows's onproperty callback, this is undefined
          // so we need to check it
          let target = this;
          if (!target && obj === _global) {
              target = _global;
          }
          if (!target) {
              return null;
          }
          const listener = target[eventNameSymbol];
          if (listener) {
              return listener;
          }
          else if (originalDescGet) {
              // result will be null when use inline event attribute,
              // such as <button onclick="func();">OK</button>
              // because the onclick function is internal raw uncompiled handler
              // the onclick will be evaluated when first time event was triggered or
              // the property is accessed, https://github.com/angular/zone.js/issues/525
              // so we should use original native get to retrieve the handler
              let value = originalDescGet && originalDescGet.call(this);
              if (value) {
                  desc.set.call(this, value);
                  if (typeof target[REMOVE_ATTRIBUTE] === 'function') {
                      target.removeAttribute(prop);
                  }
                  return value;
              }
          }
          return null;
      };
      ObjectDefineProperty(obj, prop, desc);
      obj[onPropPatchedSymbol] = true;
  }
  function patchOnProperties(obj, properties, prototype) {
      if (properties) {
          for (let i = 0; i < properties.length; i++) {
              patchProperty(obj, 'on' + properties[i], prototype);
          }
      }
      else {
          const onProperties = [];
          for (const prop in obj) {
              if (prop.substr(0, 2) == 'on') {
                  onProperties.push(prop);
              }
          }
          for (let j = 0; j < onProperties.length; j++) {
              patchProperty(obj, onProperties[j], prototype);
          }
      }
  }
  const originalInstanceKey = zoneSymbol('originalInstance');
  // wrap some native API on `window`
  function patchClass(className) {
      const OriginalClass = _global[className];
      if (!OriginalClass)
          return;
      // keep original class in global
      _global[zoneSymbol(className)] = OriginalClass;
      _global[className] = function () {
          const a = bindArguments(arguments, className);
          switch (a.length) {
              case 0:
                  this[originalInstanceKey] = new OriginalClass();
                  break;
              case 1:
                  this[originalInstanceKey] = new OriginalClass(a[0]);
                  break;
              case 2:
                  this[originalInstanceKey] = new OriginalClass(a[0], a[1]);
                  break;
              case 3:
                  this[originalInstanceKey] = new OriginalClass(a[0], a[1], a[2]);
                  break;
              case 4:
                  this[originalInstanceKey] = new OriginalClass(a[0], a[1], a[2], a[3]);
                  break;
              default:
                  throw new Error('Arg list too long.');
          }
      };
      // attach original delegate to patched function
      attachOriginToPatched(_global[className], OriginalClass);
      const instance = new OriginalClass(function () { });
      let prop;
      for (prop in instance) {
          // https://bugs.webkit.org/show_bug.cgi?id=44721
          if (className === 'XMLHttpRequest' && prop === 'responseBlob')
              continue;
          (function (prop) {
              if (typeof instance[prop] === 'function') {
                  _global[className].prototype[prop] = function () {
                      return this[originalInstanceKey][prop].apply(this[originalInstanceKey], arguments);
                  };
              }
              else {
                  ObjectDefineProperty(_global[className].prototype, prop, {
                      set: function (fn) {
                          if (typeof fn === 'function') {
                              this[originalInstanceKey][prop] = wrapWithCurrentZone(fn, className + '.' + prop);
                              // keep callback in wrapped function so we can
                              // use it in Function.prototype.toString to return
                              // the native one.
                              attachOriginToPatched(this[originalInstanceKey][prop], fn);
                          }
                          else {
                              this[originalInstanceKey][prop] = fn;
                          }
                      },
                      get: function () {
                          return this[originalInstanceKey][prop];
                      }
                  });
              }
          }(prop));
      }
      for (prop in OriginalClass) {
          if (prop !== 'prototype' && OriginalClass.hasOwnProperty(prop)) {
              _global[className][prop] = OriginalClass[prop];
          }
      }
  }
  function patchMethod(target, name, patchFn) {
      let proto = target;
      while (proto && !proto.hasOwnProperty(name)) {
          proto = ObjectGetPrototypeOf(proto);
      }
      if (!proto && target[name]) {
          // somehow we did not find it, but we can see it. This happens on IE for Window properties.
          proto = target;
      }
      const delegateName = zoneSymbol(name);
      let delegate = null;
      if (proto && (!(delegate = proto[delegateName]) || !proto.hasOwnProperty(delegateName))) {
          delegate = proto[delegateName] = proto[name];
          // check whether proto[name] is writable
          // some property is readonly in safari, such as HtmlCanvasElement.prototype.toBlob
          const desc = proto && ObjectGetOwnPropertyDescriptor(proto, name);
          if (isPropertyWritable(desc)) {
              const patchDelegate = patchFn(delegate, delegateName, name);
              proto[name] = function () {
                  return patchDelegate(this, arguments);
              };
              attachOriginToPatched(proto[name], delegate);
          }
      }
      return delegate;
  }
  // TODO: @JiaLiPassion, support cancel task later if necessary
  function patchMacroTask(obj, funcName, metaCreator) {
      let setNative = null;
      function scheduleTask(task) {
          const data = task.data;
          data.args[data.cbIdx] = function () {
              task.invoke.apply(this, arguments);
          };
          setNative.apply(data.target, data.args);
          return task;
      }
      setNative = patchMethod(obj, funcName, (delegate) => function (self, args) {
          const meta = metaCreator(self, args);
          if (meta.cbIdx >= 0 && typeof args[meta.cbIdx] === 'function') {
              return scheduleMacroTaskWithCurrentZone(meta.name, args[meta.cbIdx], meta, scheduleTask);
          }
          else {
              // cause an error by calling it directly.
              return delegate.apply(self, args);
          }
      });
  }
  function attachOriginToPatched(patched, original) {
      patched[zoneSymbol('OriginalDelegate')] = original;
  }
  let isDetectedIEOrEdge = false;
  let ieOrEdge = false;
  function isIE() {
      try {
          const ua = internalWindow.navigator.userAgent;
          if (ua.indexOf('MSIE ') !== -1 || ua.indexOf('Trident/') !== -1) {
              return true;
          }
      }
      catch (error) {
      }
      return false;
  }
  function isIEOrEdge() {
      if (isDetectedIEOrEdge) {
          return ieOrEdge;
      }
      isDetectedIEOrEdge = true;
      try {
          const ua = internalWindow.navigator.userAgent;
          if (ua.indexOf('MSIE ') !== -1 || ua.indexOf('Trident/') !== -1 || ua.indexOf('Edge/') !== -1) {
              ieOrEdge = true;
          }
      }
      catch (error) {
      }
      return ieOrEdge;
  }
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  Zone.__load_patch('ZoneAwarePromise', (global, Zone, api) => {
      const ObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
      const ObjectDefineProperty = Object.defineProperty;
      function readableObjectToString(obj) {
          if (obj && obj.toString === Object.prototype.toString) {
              const className = obj.constructor && obj.constructor.name;
              return (className ? className : '') + ': ' + JSON.stringify(obj);
          }
          return obj ? obj.toString() : Object.prototype.toString.call(obj);
      }
      const __symbol__ = api.symbol;
      const _uncaughtPromiseErrors = [];
      const isDisableWrappingUncaughtPromiseRejection = global[__symbol__('DISABLE_WRAPPING_UNCAUGHT_PROMISE_REJECTION')] === true;
      const symbolPromise = __symbol__('Promise');
      const symbolThen = __symbol__('then');
      const creationTrace = '__creationTrace__';
      api.onUnhandledError = (e) => {
          if (api.showUncaughtError()) {
              const rejection = e && e.rejection;
              if (rejection) {
                  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);
              }
              else {
                  console.error(e);
              }
          }
      };
      api.microtaskDrainDone = () => {
          while (_uncaughtPromiseErrors.length) {
              const uncaughtPromiseError = _uncaughtPromiseErrors.shift();
              try {
                  uncaughtPromiseError.zone.runGuarded(() => {
                      if (uncaughtPromiseError.throwOriginal) {
                          throw uncaughtPromiseError.rejection;
                      }
                      throw uncaughtPromiseError;
                  });
              }
              catch (error) {
                  handleUnhandledRejection(error);
              }
          }
      };
      const UNHANDLED_PROMISE_REJECTION_HANDLER_SYMBOL = __symbol__('unhandledPromiseRejectionHandler');
      function handleUnhandledRejection(e) {
          api.onUnhandledError(e);
          try {
              const handler = Zone[UNHANDLED_PROMISE_REJECTION_HANDLER_SYMBOL];
              if (typeof handler === 'function') {
                  handler.call(this, e);
              }
          }
          catch (err) {
          }
      }
      function isThenable(value) {
          return value && value.then;
      }
      function forwardResolution(value) {
          return value;
      }
      function forwardRejection(rejection) {
          return ZoneAwarePromise.reject(rejection);
      }
      const symbolState = __symbol__('state');
      const symbolValue = __symbol__('value');
      const symbolFinally = __symbol__('finally');
      const symbolParentPromiseValue = __symbol__('parentPromiseValue');
      const symbolParentPromiseState = __symbol__('parentPromiseState');
      const source = 'Promise.then';
      const UNRESOLVED = null;
      const RESOLVED = true;
      const REJECTED = false;
      const REJECTED_NO_CATCH = 0;
      function makeResolver(promise, state) {
          return (v) => {
              try {
                  resolvePromise(promise, state, v);
              }
              catch (err) {
                  resolvePromise(promise, false, err);
              }
              // Do not return value or you will break the Promise spec.
          };
      }
      const once = function () {
          let wasCalled = false;
          return function wrapper(wrappedFunction) {
              return function () {
                  if (wasCalled) {
                      return;
                  }
                  wasCalled = true;
                  wrappedFunction.apply(null, arguments);
              };
          };
      };
      const TYPE_ERROR = 'Promise resolved with itself';
      const CURRENT_TASK_TRACE_SYMBOL = __symbol__('currentTaskTrace');
      // Promise Resolution
      function resolvePromise(promise, state, value) {
          const onceWrapper = once();
          if (promise === value) {
              throw new TypeError(TYPE_ERROR);
          }
          if (promise[symbolState] === UNRESOLVED) {
              // should only get value.then once based on promise spec.
              let then = null;
              try {
                  if (typeof value === 'object' || typeof value === 'function') {
                      then = value && value.then;
                  }
              }
              catch (err) {
                  onceWrapper(() => {
                      resolvePromise(promise, false, err);
                  })();
                  return promise;
              }
              // if (value instanceof ZoneAwarePromise) {
              if (state !== REJECTED && value instanceof ZoneAwarePromise &&
                  value.hasOwnProperty(symbolState) && value.hasOwnProperty(symbolValue) &&
                  value[symbolState] !== UNRESOLVED) {
                  clearRejectedNoCatch(value);
                  resolvePromise(promise, value[symbolState], value[symbolValue]);
              }
              else if (state !== REJECTED && typeof then === 'function') {
                  try {
                      then.call(value, onceWrapper(makeResolver(promise, state)), onceWrapper(makeResolver(promise, false)));
                  }
                  catch (err) {
                      onceWrapper(() => {
                          resolvePromise(promise, false, err);
                      })();
                  }
              }
              else {
                  promise[symbolState] = state;
                  const queue = promise[symbolValue];
                  promise[symbolValue] = value;
                  if (promise[symbolFinally] === symbolFinally) {
                      // the promise is generated by Promise.prototype.finally
                      if (state === RESOLVED) {
                          // the state is resolved, should ignore the value
                          // and use parent promise value
                          promise[symbolState] = promise[symbolParentPromiseState];
                          promise[symbolValue] = promise[symbolParentPromiseValue];
                      }
                  }
                  // record task information in value when error occurs, so we can
                  // do some additional work such as render longStackTrace
                  if (state === REJECTED && value instanceof Error) {
                      // check if longStackTraceZone is here
                      const trace = Zone.currentTask && Zone.currentTask.data &&
                          Zone.currentTask.data[creationTrace];
                      if (trace) {
                          // only keep the long stack trace into error when in longStackTraceZone
                          ObjectDefineProperty(value, CURRENT_TASK_TRACE_SYMBOL, { configurable: true, enumerable: false, writable: true, value: trace });
                      }
                  }
                  for (let i = 0; i < queue.length;) {
                      scheduleResolveOrReject(promise, queue[i++], queue[i++], queue[i++], queue[i++]);
                  }
                  if (queue.length == 0 && state == REJECTED) {
                      promise[symbolState] = REJECTED_NO_CATCH;
                      let uncaughtPromiseError = value;
                      try {
                          // Here we throws a new Error to print more readable error log
                          // and if the value is not an error, zone.js builds an `Error`
                          // Object here to attach the stack information.
                          throw new Error('Uncaught (in promise): ' + readableObjectToString(value) +
                              (value && value.stack ? '\n' + value.stack : ''));
                      }
                      catch (err) {
                          uncaughtPromiseError = err;
                      }
                      if (isDisableWrappingUncaughtPromiseRejection) {
                          // If disable wrapping uncaught promise reject
                          // use the value instead of wrapping it.
                          uncaughtPromiseError.throwOriginal = true;
                      }
                      uncaughtPromiseError.rejection = value;
                      uncaughtPromiseError.promise = promise;
                      uncaughtPromiseError.zone = Zone.current;
                      uncaughtPromiseError.task = Zone.currentTask;
                      _uncaughtPromiseErrors.push(uncaughtPromiseError);
                      api.scheduleMicroTask(); // to make sure that it is running
                  }
              }
          }
          // Resolving an already resolved promise is a noop.
          return promise;
      }
      const REJECTION_HANDLED_HANDLER = __symbol__('rejectionHandledHandler');
      function clearRejectedNoCatch(promise) {
          if (promise[symbolState] === REJECTED_NO_CATCH) {
              // if the promise is rejected no catch status
              // and queue.length > 0, means there is a error handler
              // here to handle the rejected promise, we should trigger
              // windows.rejectionhandled eventHandler or nodejs rejectionHandled
              // eventHandler
              try {
                  const handler = Zone[REJECTION_HANDLED_HANDLER];
                  if (handler && typeof handler === 'function') {
                      handler.call(this, { rejection: promise[symbolValue], promise: promise });
                  }
              }
              catch (err) {
              }
              promise[symbolState] = REJECTED;
              for (let i = 0; i < _uncaughtPromiseErrors.length; i++) {
                  if (promise === _uncaughtPromiseErrors[i].promise) {
                      _uncaughtPromiseErrors.splice(i, 1);
                  }
              }
          }
      }
      function scheduleResolveOrReject(promise, zone, chainPromise, onFulfilled, onRejected) {
          clearRejectedNoCatch(promise);
          const promiseState = promise[symbolState];
          const delegate = promiseState ?
              (typeof onFulfilled === 'function') ? onFulfilled : forwardResolution :
              (typeof onRejected === 'function') ? onRejected : forwardRejection;
          zone.scheduleMicroTask(source, () => {
              try {
                  const parentPromiseValue = promise[symbolValue];
                  const isFinallyPromise = !!chainPromise && symbolFinally === chainPromise[symbolFinally];
                  if (isFinallyPromise) {
                      // if the promise is generated from finally call, keep parent promise's state and value
                      chainPromise[symbolParentPromiseValue] = parentPromiseValue;
                      chainPromise[symbolParentPromiseState] = promiseState;
                  }
                  // should not pass value to finally callback
                  const value = zone.run(delegate, undefined, isFinallyPromise && delegate !== forwardRejection && delegate !== forwardResolution ?
                      [] :
                      [parentPromiseValue]);
                  resolvePromise(chainPromise, true, value);
              }
              catch (error) {
                  // if error occurs, should always return this error
                  resolvePromise(chainPromise, false, error);
              }
          }, chainPromise);
      }
      const ZONE_AWARE_PROMISE_TO_STRING = 'function ZoneAwarePromise() { [native code] }';
      const noop = function () { };
      class ZoneAwarePromise {
          static toString() {
              return ZONE_AWARE_PROMISE_TO_STRING;
          }
          static resolve(value) {
              return resolvePromise(new this(null), RESOLVED, value);
          }
          static reject(error) {
              return resolvePromise(new this(null), REJECTED, error);
          }
          static race(values) {
              let resolve;
              let reject;
              let promise = new this((res, rej) => {
                  resolve = res;
                  reject = rej;
              });
              function onResolve(value) {
                  resolve(value);
              }
              function onReject(error) {
                  reject(error);
              }
              for (let value of values) {
                  if (!isThenable(value)) {
                      value = this.resolve(value);
                  }
                  value.then(onResolve, onReject);
              }
              return promise;
          }
          static all(values) {
              return ZoneAwarePromise.allWithCallback(values);
          }
          static allSettled(values) {
              const P = this && this.prototype instanceof ZoneAwarePromise ? this : ZoneAwarePromise;
              return P.allWithCallback(values, {
                  thenCallback: (value) => ({ status: 'fulfilled', value }),
                  errorCallback: (err) => ({ status: 'rejected', reason: err })
              });
          }
          static allWithCallback(values, callback) {
              let resolve;
              let reject;
              let promise = new this((res, rej) => {
                  resolve = res;
                  reject = rej;
              });
              // Start at 2 to prevent prematurely resolving if .then is called immediately.
              let unresolvedCount = 2;
              let valueIndex = 0;
              const resolvedValues = [];
              for (let value of values) {
                  if (!isThenable(value)) {
                      value = this.resolve(value);
                  }
                  const curValueIndex = valueIndex;
                  try {
                      value.then((value) => {
                          resolvedValues[curValueIndex] = callback ? callback.thenCallback(value) : value;
                          unresolvedCount--;
                          if (unresolvedCount === 0) {
                              resolve(resolvedValues);
                          }
                      }, (err) => {
                          if (!callback) {
                              reject(err);
                          }
                          else {
                              resolvedValues[curValueIndex] = callback.errorCallback(err);
                              unresolvedCount--;
                              if (unresolvedCount === 0) {
                                  resolve(resolvedValues);
                              }
                          }
                      });
                  }
                  catch (thenErr) {
                      reject(thenErr);
                  }
                  unresolvedCount++;
                  valueIndex++;
              }
              // Make the unresolvedCount zero-based again.
              unresolvedCount -= 2;
              if (unresolvedCount === 0) {
                  resolve(resolvedValues);
              }
              return promise;
          }
          constructor(executor) {
              const promise = this;
              if (!(promise instanceof ZoneAwarePromise)) {
                  throw new Error('Must be an instanceof Promise.');
              }
              promise[symbolState] = UNRESOLVED;
              promise[symbolValue] = []; // queue;
              try {
                  executor && executor(makeResolver(promise, RESOLVED), makeResolver(promise, REJECTED));
              }
              catch (error) {
                  resolvePromise(promise, false, error);
              }
          }
          get [Symbol.toStringTag]() {
              return 'Promise';
          }
          get [Symbol.species]() {
              return ZoneAwarePromise;
          }
          then(onFulfilled, onRejected) {
              let C = this.constructor[Symbol.species];
              if (!C || typeof C !== 'function') {
                  C = this.constructor || ZoneAwarePromise;
              }
              const chainPromise = new C(noop);
              const zone = Zone.current;
              if (this[symbolState] == UNRESOLVED) {
                  this[symbolValue].push(zone, chainPromise, onFulfilled, onRejected);
              }
              else {
                  scheduleResolveOrReject(this, zone, chainPromise, onFulfilled, onRejected);
              }
              return chainPromise;
          }
          catch(onRejected) {
              return this.then(null, onRejected);
          }
          finally(onFinally) {
              let C = this.constructor[Symbol.species];
              if (!C || typeof C !== 'function') {
                  C = ZoneAwarePromise;
              }
              const chainPromise = new C(noop);
              chainPromise[symbolFinally] = symbolFinally;
              const zone = Zone.current;
              if (this[symbolState] == UNRESOLVED) {
                  this[symbolValue].push(zone, chainPromise, onFinally, onFinally);
              }
              else {
                  scheduleResolveOrReject(this, zone, chainPromise, onFinally, onFinally);
              }
              return chainPromise;
          }
      }
      // Protect against aggressive optimizers dropping seemingly unused properties.
      // E.g. Closure Compiler in advanced mode.
      ZoneAwarePromise['resolve'] = ZoneAwarePromise.resolve;
      ZoneAwarePromise['reject'] = ZoneAwarePromise.reject;
      ZoneAwarePromise['race'] = ZoneAwarePromise.race;
      ZoneAwarePromise['all'] = ZoneAwarePromise.all;
      const NativePromise = global[symbolPromise] = global['Promise'];
      global['Promise'] = ZoneAwarePromise;
      const symbolThenPatched = __symbol__('thenPatched');
      function patchThen(Ctor) {
          const proto = Ctor.prototype;
          const prop = ObjectGetOwnPropertyDescriptor(proto, 'then');
          if (prop && (prop.writable === false || !prop.configurable)) {
              // check Ctor.prototype.then propertyDescriptor is writable or not
              // in meteor env, writable is false, we should ignore such case
              return;
          }
          const originalThen = proto.then;
          // Keep a reference to the original method.
          proto[symbolThen] = originalThen;
          Ctor.prototype.then = function (onResolve, onReject) {
              const wrapped = new ZoneAwarePromise((resolve, reject) => {
                  originalThen.call(this, resolve, reject);
              });
              return wrapped.then(onResolve, onReject);
          };
          Ctor[symbolThenPatched] = true;
      }
      api.patchThen = patchThen;
      function zoneify(fn) {
          return function (self, args) {
              let resultPromise = fn.apply(self, args);
              if (resultPromise instanceof ZoneAwarePromise) {
                  return resultPromise;
              }
              let ctor = resultPromise.constructor;
              if (!ctor[symbolThenPatched]) {
                  patchThen(ctor);
              }
              return resultPromise;
          };
      }
      if (NativePromise) {
          patchThen(NativePromise);
          patchMethod(global, 'fetch', delegate => zoneify(delegate));
      }
      // This is not part of public API, but it is useful for tests, so we expose it.
      Promise[Zone.__symbol__('uncaughtPromiseErrors')] = _uncaughtPromiseErrors;
      return ZoneAwarePromise;
  });
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  // override Function.prototype.toString to make zone.js patched function
  // look like native function
  Zone.__load_patch('toString', (global) => {
      // patch Func.prototype.toString to let them look like native
      const originalFunctionToString = Function.prototype.toString;
      const ORIGINAL_DELEGATE_SYMBOL = zoneSymbol('OriginalDelegate');
      const PROMISE_SYMBOL = zoneSymbol('Promise');
      const ERROR_SYMBOL = zoneSymbol('Error');
      const newFunctionToString = function toString() {
          if (typeof this === 'function') {
              const originalDelegate = this[ORIGINAL_DELEGATE_SYMBOL];
              if (originalDelegate) {
                  if (typeof originalDelegate === 'function') {
                      return originalFunctionToString.call(originalDelegate);
                  }
                  else {
                      return Object.prototype.toString.call(originalDelegate);
                  }
              }
              if (this === Promise) {
                  const nativePromise = global[PROMISE_SYMBOL];
                  if (nativePromise) {
                      return originalFunctionToString.call(nativePromise);
                  }
              }
              if (this === Error) {
                  const nativeError = global[ERROR_SYMBOL];
                  if (nativeError) {
                      return originalFunctionToString.call(nativeError);
                  }
              }
          }
          return originalFunctionToString.call(this);
      };
      newFunctionToString[ORIGINAL_DELEGATE_SYMBOL] = originalFunctionToString;
      Function.prototype.toString = newFunctionToString;
      // patch Object.prototype.toString to let them look like native
      const originalObjectToString = Object.prototype.toString;
      const PROMISE_OBJECT_TO_STRING = '[object Promise]';
      Object.prototype.toString = function () {
          if (typeof Promise === 'function' && this instanceof Promise) {
              return PROMISE_OBJECT_TO_STRING;
          }
          return originalObjectToString.call(this);
      };
  });
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  let passiveSupported = false;
  if (typeof window !== 'undefined') {
      try {
          const options = Object.defineProperty({}, 'passive', {
              get: function () {
                  passiveSupported = true;
              }
          });
          window.addEventListener('test', options, options);
          window.removeEventListener('test', options, options);
      }
      catch (err) {
          passiveSupported = false;
      }
  }
  // an identifier to tell ZoneTask do not create a new invoke closure
  const OPTIMIZED_ZONE_EVENT_TASK_DATA = {
      useG: true
  };
  const zoneSymbolEventNames$1 = {};
  const globalSources = {};
  const EVENT_NAME_SYMBOL_REGX = new RegExp('^' + ZONE_SYMBOL_PREFIX + '(\\w+)(true|false)$');
  const IMMEDIATE_PROPAGATION_SYMBOL = zoneSymbol('propagationStopped');
  function prepareEventNames(eventName, eventNameToString) {
      const falseEventName = (eventNameToString ? eventNameToString(eventName) : eventName) + FALSE_STR;
      const trueEventName = (eventNameToString ? eventNameToString(eventName) : eventName) + TRUE_STR;
      const symbol = ZONE_SYMBOL_PREFIX + falseEventName;
      const symbolCapture = ZONE_SYMBOL_PREFIX + trueEventName;
      zoneSymbolEventNames$1[eventName] = {};
      zoneSymbolEventNames$1[eventName][FALSE_STR] = symbol;
      zoneSymbolEventNames$1[eventName][TRUE_STR] = symbolCapture;
  }
  function patchEventTarget(_global, apis, patchOptions) {
      const ADD_EVENT_LISTENER = (patchOptions && patchOptions.add) || ADD_EVENT_LISTENER_STR;
      const REMOVE_EVENT_LISTENER = (patchOptions && patchOptions.rm) || REMOVE_EVENT_LISTENER_STR;
      const LISTENERS_EVENT_LISTENER = (patchOptions && patchOptions.listeners) || 'eventListeners';
      const REMOVE_ALL_LISTENERS_EVENT_LISTENER = (patchOptions && patchOptions.rmAll) || 'removeAllListeners';
      const zoneSymbolAddEventListener = zoneSymbol(ADD_EVENT_LISTENER);
      const ADD_EVENT_LISTENER_SOURCE = '.' + ADD_EVENT_LISTENER + ':';
      const PREPEND_EVENT_LISTENER = 'prependListener';
      const PREPEND_EVENT_LISTENER_SOURCE = '.' + PREPEND_EVENT_LISTENER + ':';
      const invokeTask = function (task, target, event) {
          // for better performance, check isRemoved which is set
          // by removeEventListener
          if (task.isRemoved) {
              return;
          }
          const delegate = task.callback;
          if (typeof delegate === 'object' && delegate.handleEvent) {
              // create the bind version of handleEvent when invoke
              task.callback = (event) => delegate.handleEvent(event);
              task.originalDelegate = delegate;
          }
          // invoke static task.invoke
          task.invoke(task, target, [event]);
          const options = task.options;
          if (options && typeof options === 'object' && options.once) {
              // if options.once is true, after invoke once remove listener here
              // only browser need to do this, nodejs eventEmitter will cal removeListener
              // inside EventEmitter.once
              const delegate = task.originalDelegate ? task.originalDelegate : task.callback;
              target[REMOVE_EVENT_LISTENER].call(target, event.type, delegate, options);
          }
      };
      // global shared zoneAwareCallback to handle all event callback with capture = false
      const globalZoneAwareCallback = function (event) {
          // https://github.com/angular/zone.js/issues/911, in IE, sometimes
          // event will be undefined, so we need to use window.event
          event = event || _global.event;
          if (!event) {
              return;
          }
          // event.target is needed for Samsung TV and SourceBuffer
          // || global is needed https://github.com/angular/zone.js/issues/190
          const target = this || event.target || _global;
          const tasks = target[zoneSymbolEventNames$1[event.type][FALSE_STR]];
          if (tasks) {
              // invoke all tasks which attached to current target with given event.type and capture = false
              // for performance concern, if task.length === 1, just invoke
              if (tasks.length === 1) {
                  invokeTask(tasks[0], target, event);
              }
              else {
                  // https://github.com/angular/zone.js/issues/836
                  // copy the tasks array before invoke, to avoid
                  // the callback will remove itself or other listener
                  const copyTasks = tasks.slice();
                  for (let i = 0; i < copyTasks.length; i++) {
                      if (event && event[IMMEDIATE_PROPAGATION_SYMBOL] === true) {
                          break;
                      }
                      invokeTask(copyTasks[i], target, event);
                  }
              }
          }
      };
      // global shared zoneAwareCallback to handle all event callback with capture = true
      const globalZoneAwareCaptureCallback = function (event) {
          // https://github.com/angular/zone.js/issues/911, in IE, sometimes
          // event will be undefined, so we need to use window.event
          event = event || _global.event;
          if (!event) {
              return;
          }
          // event.target is needed for Samsung TV and SourceBuffer
          // || global is needed https://github.com/angular/zone.js/issues/190
          const target = this || event.target || _global;
          const tasks = target[zoneSymbolEventNames$1[event.type][TRUE_STR]];
          if (tasks) {
              // invoke all tasks which attached to current target with given event.type and capture = false
              // for performance concern, if task.length === 1, just invoke
              if (tasks.length === 1) {
                  invokeTask(tasks[0], target, event);
              }
              else {
                  // https://github.com/angular/zone.js/issues/836
                  // copy the tasks array before invoke, to avoid
                  // the callback will remove itself or other listener
                  const copyTasks = tasks.slice();
                  for (let i = 0; i < copyTasks.length; i++) {
                      if (event && event[IMMEDIATE_PROPAGATION_SYMBOL] === true) {
                          break;
                      }
                      invokeTask(copyTasks[i], target, event);
                  }
              }
          }
      };
      function patchEventTargetMethods(obj, patchOptions) {
          if (!obj) {
              return false;
          }
          let useGlobalCallback = true;
          if (patchOptions && patchOptions.useG !== undefined) {
              useGlobalCallback = patchOptions.useG;
          }
          const validateHandler = patchOptions && patchOptions.vh;
          let checkDuplicate = true;
          if (patchOptions && patchOptions.chkDup !== undefined) {
              checkDuplicate = patchOptions.chkDup;
          }
          let returnTarget = false;
          if (patchOptions && patchOptions.rt !== undefined) {
              returnTarget = patchOptions.rt;
          }
          let proto = obj;
          while (proto && !proto.hasOwnProperty(ADD_EVENT_LISTENER)) {
              proto = ObjectGetPrototypeOf(proto);
          }
          if (!proto && obj[ADD_EVENT_LISTENER]) {
              // somehow we did not find it, but we can see it. This happens on IE for Window properties.
              proto = obj;
          }
          if (!proto) {
              return false;
          }
          if (proto[zoneSymbolAddEventListener]) {
              return false;
          }
          const eventNameToString = patchOptions && patchOptions.eventNameToString;
          // a shared global taskData to pass data for scheduleEventTask
          // so we do not need to create a new object just for pass some data
          const taskData = {};
          const nativeAddEventListener = proto[zoneSymbolAddEventListener] = proto[ADD_EVENT_LISTENER];
          const nativeRemoveEventListener = proto[zoneSymbol(REMOVE_EVENT_LISTENER)] =
              proto[REMOVE_EVENT_LISTENER];
          const nativeListeners = proto[zoneSymbol(LISTENERS_EVENT_LISTENER)] =
              proto[LISTENERS_EVENT_LISTENER];
          const nativeRemoveAllListeners = proto[zoneSymbol(REMOVE_ALL_LISTENERS_EVENT_LISTENER)] =
              proto[REMOVE_ALL_LISTENERS_EVENT_LISTENER];
          let nativePrependEventListener;
          if (patchOptions && patchOptions.prepend) {
              nativePrependEventListener = proto[zoneSymbol(patchOptions.prepend)] =
                  proto[patchOptions.prepend];
          }
          /**
           * This util function will build an option object with passive option
           * to handle all possible input from the user.
           */
          function buildEventListenerOptions(options, passive) {
              if (!passiveSupported && typeof options === 'object' && options) {
                  // doesn't support passive but user want to pass an object as options.
                  // this will not work on some old browser, so we just pass a boolean
                  // as useCapture parameter
                  return !!options.capture;
              }
              if (!passiveSupported || !passive) {
                  return options;
              }
              if (typeof options === 'boolean') {
                  return { capture: options, passive: true };
              }
              if (!options) {
                  return { passive: true };
              }
              if (typeof options === 'object' && options.passive !== false) {
                  return Object.assign(Object.assign({}, options), { passive: true });
              }
              return options;
          }
          const customScheduleGlobal = function (task) {
              // if there is already a task for the eventName + capture,
              // just return, because we use the shared globalZoneAwareCallback here.
              if (taskData.isExisting) {
                  return;
              }
              return nativeAddEventListener.call(taskData.target, taskData.eventName, taskData.capture ? globalZoneAwareCaptureCallback : globalZoneAwareCallback, taskData.options);
          };
          const customCancelGlobal = function (task) {
              // if task is not marked as isRemoved, this call is directly
              // from Zone.prototype.cancelTask, we should remove the task
              // from tasksList of target first
              if (!task.isRemoved) {
                  const symbolEventNames = zoneSymbolEventNames$1[task.eventName];
                  let symbolEventName;
                  if (symbolEventNames) {
                      symbolEventName = symbolEventNames[task.capture ? TRUE_STR : FALSE_STR];
                  }
                  const existingTasks = symbolEventName && task.target[symbolEventName];
                  if (existingTasks) {
                      for (let i = 0; i < existingTasks.length; i++) {
                          const existingTask = existingTasks[i];
                          if (existingTask === task) {
                              existingTasks.splice(i, 1);
                              // set isRemoved to data for faster invokeTask check
                              task.isRemoved = true;
                              if (existingTasks.length === 0) {
                                  // all tasks for the eventName + capture have gone,
                                  // remove globalZoneAwareCallback and remove the task cache from target
                                  task.allRemoved = true;
                                  task.target[symbolEventName] = null;
                              }
                              break;
                          }
                      }
                  }
              }
              // if all tasks for the eventName + capture have gone,
              // we will really remove the global event callback,
              // if not, return
              if (!task.allRemoved) {
                  return;
              }
              return nativeRemoveEventListener.call(task.target, task.eventName, task.capture ? globalZoneAwareCaptureCallback : globalZoneAwareCallback, task.options);
          };
          const customScheduleNonGlobal = function (task) {
              return nativeAddEventListener.call(taskData.target, taskData.eventName, task.invoke, taskData.options);
          };
          const customSchedulePrepend = function (task) {
              return nativePrependEventListener.call(taskData.target, taskData.eventName, task.invoke, taskData.options);
          };
          const customCancelNonGlobal = function (task) {
              return nativeRemoveEventListener.call(task.target, task.eventName, task.invoke, task.options);
          };
          const customSchedule = useGlobalCallback ? customScheduleGlobal : customScheduleNonGlobal;
          const customCancel = useGlobalCallback ? customCancelGlobal : customCancelNonGlobal;
          const compareTaskCallbackVsDelegate = function (task, delegate) {
              const typeOfDelegate = typeof delegate;
              return (typeOfDelegate === 'function' && task.callback === delegate) ||
                  (typeOfDelegate === 'object' && task.originalDelegate === delegate);
          };
          const compare = (patchOptions && patchOptions.diff) ? patchOptions.diff : compareTaskCallbackVsDelegate;
          const unpatchedEvents = Zone[zoneSymbol('UNPATCHED_EVENTS')];
          const passiveEvents = _global[zoneSymbol('PASSIVE_EVENTS')];
          const makeAddListener = function (nativeListener, addSource, customScheduleFn, customCancelFn, returnTarget = false, prepend = false) {
              return function () {
                  const target = this || _global;
                  let eventName = arguments[0];
                  if (patchOptions && patchOptions.transferEventName) {
                      eventName = patchOptions.transferEventName(eventName);
                  }
                  let delegate = arguments[1];
                  if (!delegate) {
                      return nativeListener.apply(this, arguments);
                  }
                  if (isNode && eventName === 'uncaughtException') {
                      // don't patch uncaughtException of nodejs to prevent endless loop
                      return nativeListener.apply(this, arguments);
                  }
                  // don't create the bind delegate function for handleEvent
                  // case here to improve addEventListener performance
                  // we will create the bind delegate when invoke
                  let isHandleEvent = false;
                  if (typeof delegate !== 'function') {
                      if (!delegate.handleEvent) {
                          return nativeListener.apply(this, arguments);
                      }
                      isHandleEvent = true;
                  }
                  if (validateHandler && !validateHandler(nativeListener, delegate, target, arguments)) {
                      return;
                  }
                  const passive = passiveSupported && !!passiveEvents && passiveEvents.indexOf(eventName) !== -1;
                  const options = buildEventListenerOptions(arguments[2], passive);
                  if (unpatchedEvents) {
                      // check upatched list
                      for (let i = 0; i < unpatchedEvents.length; i++) {
                          if (eventName === unpatchedEvents[i]) {
                              if (passive) {
                                  return nativeListener.call(target, eventName, delegate, options);
                              }
                              else {
                                  return nativeListener.apply(this, arguments);
                              }
                          }
                      }
                  }
                  const capture = !options ? false : typeof options === 'boolean' ? true : options.capture;
                  const once = options && typeof options === 'object' ? options.once : false;
                  const zone = Zone.current;
                  let symbolEventNames = zoneSymbolEventNames$1[eventName];
                  if (!symbolEventNames) {
                      prepareEventNames(eventName, eventNameToString);
                      symbolEventNames = zoneSymbolEventNames$1[eventName];
                  }
                  const symbolEventName = symbolEventNames[capture ? TRUE_STR : FALSE_STR];
                  let existingTasks = target[symbolEventName];
                  let isExisting = false;
                  if (existingTasks) {
                      // already have task registered
                      isExisting = true;
                      if (checkDuplicate) {
                          for (let i = 0; i < existingTasks.length; i++) {
                              if (compare(existingTasks[i], delegate)) {
                                  // same callback, same capture, same event name, just return
                                  return;
                              }
                          }
                      }
                  }
                  else {
                      existingTasks = target[symbolEventName] = [];
                  }
                  let source;
                  const constructorName = target.constructor['name'];
                  const targetSource = globalSources[constructorName];
                  if (targetSource) {
                      source = targetSource[eventName];
                  }
                  if (!source) {
                      source = constructorName + addSource +
                          (eventNameToString ? eventNameToString(eventName) : eventName);
                  }
                  // do not create a new object as task.data to pass those things
                  // just use the global shared one
                  taskData.options = options;
                  if (once) {
                      // if addEventListener with once options, we don't pass it to
                      // native addEventListener, instead we keep the once setting
                      // and handle ourselves.
                      taskData.options.once = false;
                  }
                  taskData.target = target;
                  taskData.capture = capture;
                  taskData.eventName = eventName;
                  taskData.isExisting = isExisting;
                  const data = useGlobalCallback ? OPTIMIZED_ZONE_EVENT_TASK_DATA : undefined;
                  // keep taskData into data to allow onScheduleEventTask to access the task information
                  if (data) {
                      data.taskData = taskData;
                  }
                  const task = zone.scheduleEventTask(source, delegate, data, customScheduleFn, customCancelFn);
                  // should clear taskData.target to avoid memory leak
                  // issue, https://github.com/angular/angular/issues/20442
                  taskData.target = null;
                  // need to clear up taskData because it is a global object
                  if (data) {
                      data.taskData = null;
                  }
                  // have to save those information to task in case
                  // application may call task.zone.cancelTask() directly
                  if (once) {
                      options.once = true;
                  }
                  if (!(!passiveSupported && typeof task.options === 'boolean')) {
                      // if not support passive, and we pass an option object
                      // to addEventListener, we should save the options to task
                      task.options = options;
                  }
                  task.target = target;
                  task.capture = capture;
                  task.eventName = eventName;
                  if (isHandleEvent) {
                      // save original delegate for compare to check duplicate
                      task.originalDelegate = delegate;
                  }
                  if (!prepend) {
                      existingTasks.push(task);
                  }
                  else {
                      existingTasks.unshift(task);
                  }
                  if (returnTarget) {
                      return target;
                  }
              };
          };
          proto[ADD_EVENT_LISTENER] = makeAddListener(nativeAddEventListener, ADD_EVENT_LISTENER_SOURCE, customSchedule, customCancel, returnTarget);
          if (nativePrependEventListener) {
              proto[PREPEND_EVENT_LISTENER] = makeAddListener(nativePrependEventListener, PREPEND_EVENT_LISTENER_SOURCE, customSchedulePrepend, customCancel, returnTarget, true);
          }
          proto[REMOVE_EVENT_LISTENER] = function () {
              const target = this || _global;
              let eventName = arguments[0];
              if (patchOptions && patchOptions.transferEventName) {
                  eventName = patchOptions.transferEventName(eventName);
              }
              const options = arguments[2];
              const capture = !options ? false : typeof options === 'boolean' ? true : options.capture;
              const delegate = arguments[1];
              if (!delegate) {
                  return nativeRemoveEventListener.apply(this, arguments);
              }
              if (validateHandler &&
                  !validateHandler(nativeRemoveEventListener, delegate, target, arguments)) {
                  return;
              }
              const symbolEventNames = zoneSymbolEventNames$1[eventName];
              let symbolEventName;
              if (symbolEventNames) {
                  symbolEventName = symbolEventNames[capture ? TRUE_STR : FALSE_STR];
              }
              const existingTasks = symbolEventName && target[symbolEventName];
              if (existingTasks) {
                  for (let i = 0; i < existingTasks.length; i++) {
                      const existingTask = existingTasks[i];
                      if (compare(existingTask, delegate)) {
                          existingTasks.splice(i, 1);
                          // set isRemoved to data for faster invokeTask check
                          existingTask.isRemoved = true;
                          if (existingTasks.length === 0) {
                              // all tasks for the eventName + capture have gone,
                              // remove globalZoneAwareCallback and remove the task cache from target
                              existingTask.allRemoved = true;
                              target[symbolEventName] = null;
                              // in the target, we have an event listener which is added by on_property
                              // such as target.onclick = function() {}, so we need to clear this internal
                              // property too if all delegates all removed
                              if (typeof eventName === 'string') {
                                  const onPropertySymbol = ZONE_SYMBOL_PREFIX + 'ON_PROPERTY' + eventName;
                                  target[onPropertySymbol] = null;
                              }
                          }
                          existingTask.zone.cancelTask(existingTask);
                          if (returnTarget) {
                              return target;
                          }
                          return;
                      }
                  }
              }
              // issue 930, didn't find the event name or callback
              // from zone kept existingTasks, the callback maybe
              // added outside of zone, we need to call native removeEventListener
              // to try to remove it.
              return nativeRemoveEventListener.apply(this, arguments);
          };
          proto[LISTENERS_EVENT_LISTENER] = function () {
              const target = this || _global;
              let eventName = arguments[0];
              if (patchOptions && patchOptions.transferEventName) {
                  eventName = patchOptions.transferEventName(eventName);
              }
              const listeners = [];
              const tasks = findEventTasks(target, eventNameToString ? eventNameToString(eventName) : eventName);
              for (let i = 0; i < tasks.length; i++) {
                  const task = tasks[i];
                  let delegate = task.originalDelegate ? task.originalDelegate : task.callback;
                  listeners.push(delegate);
              }
              return listeners;
          };
          proto[REMOVE_ALL_LISTENERS_EVENT_LISTENER] = function () {
              const target = this || _global;
              let eventName = arguments[0];
              if (!eventName) {
                  const keys = Object.keys(target);
                  for (let i = 0; i < keys.length; i++) {
                      const prop = keys[i];
                      const match = EVENT_NAME_SYMBOL_REGX.exec(prop);
                      let evtName = match && match[1];
                      // in nodejs EventEmitter, removeListener event is
                      // used for monitoring the removeListener call,
                      // so just keep removeListener eventListener until
                      // all other eventListeners are removed
                      if (evtName && evtName !== 'removeListener') {
                          this[REMOVE_ALL_LISTENERS_EVENT_LISTENER].call(this, evtName);
                      }
                  }
                  // remove removeListener listener finally
                  this[REMOVE_ALL_LISTENERS_EVENT_LISTENER].call(this, 'removeListener');
              }
              else {
                  if (patchOptions && patchOptions.transferEventName) {
                      eventName = patchOptions.transferEventName(eventName);
                  }
                  const symbolEventNames = zoneSymbolEventNames$1[eventName];
                  if (symbolEventNames) {
                      const symbolEventName = symbolEventNames[FALSE_STR];
                      const symbolCaptureEventName = symbolEventNames[TRUE_STR];
                      const tasks = target[symbolEventName];
                      const captureTasks = target[symbolCaptureEventName];
                      if (tasks) {
                          const removeTasks = tasks.slice();
                          for (let i = 0; i < removeTasks.length; i++) {
                              const task = removeTasks[i];
                              let delegate = task.originalDelegate ? task.originalDelegate : task.callback;
                              this[REMOVE_EVENT_LISTENER].call(this, eventName, delegate, task.options);
                          }
                      }
                      if (captureTasks) {
                          const removeTasks = captureTasks.slice();
                          for (let i = 0; i < removeTasks.length; i++) {
                              const task = removeTasks[i];
                              let delegate = task.originalDelegate ? task.originalDelegate : task.callback;
                              this[REMOVE_EVENT_LISTENER].call(this, eventName, delegate, task.options);
                          }
                      }
                  }
              }
              if (returnTarget) {
                  return this;
              }
          };
          // for native toString patch
          attachOriginToPatched(proto[ADD_EVENT_LISTENER], nativeAddEventListener);
          attachOriginToPatched(proto[REMOVE_EVENT_LISTENER], nativeRemoveEventListener);
          if (nativeRemoveAllListeners) {
              attachOriginToPatched(proto[REMOVE_ALL_LISTENERS_EVENT_LISTENER], nativeRemoveAllListeners);
          }
          if (nativeListeners) {
              attachOriginToPatched(proto[LISTENERS_EVENT_LISTENER], nativeListeners);
          }
          return true;
      }
      let results = [];
      for (let i = 0; i < apis.length; i++) {
          results[i] = patchEventTargetMethods(apis[i], patchOptions);
      }
      return results;
  }
  function findEventTasks(target, eventName) {
      if (!eventName) {
          const foundTasks = [];
          for (let prop in target) {
              const match = EVENT_NAME_SYMBOL_REGX.exec(prop);
              let evtName = match && match[1];
              if (evtName && (!eventName || evtName === eventName)) {
                  const tasks = target[prop];
                  if (tasks) {
                      for (let i = 0; i < tasks.length; i++) {
                          foundTasks.push(tasks[i]);
                      }
                  }
              }
          }
          return foundTasks;
      }
      let symbolEventName = zoneSymbolEventNames$1[eventName];
      if (!symbolEventName) {
          prepareEventNames(eventName);
          symbolEventName = zoneSymbolEventNames$1[eventName];
      }
      const captureFalseTasks = target[symbolEventName[FALSE_STR]];
      const captureTrueTasks = target[symbolEventName[TRUE_STR]];
      if (!captureFalseTasks) {
          return captureTrueTasks ? captureTrueTasks.slice() : [];
      }
      else {
          return captureTrueTasks ? captureFalseTasks.concat(captureTrueTasks) :
              captureFalseTasks.slice();
      }
  }
  function patchEventPrototype(global, api) {
      const Event = global['Event'];
      if (Event && Event.prototype) {
          api.patchMethod(Event.prototype, 'stopImmediatePropagation', (delegate) => function (self, args) {
              self[IMMEDIATE_PROPAGATION_SYMBOL] = true;
              // we need to call the native stopImmediatePropagation
              // in case in some hybrid application, some part of
              // application will be controlled by zone, some are not
              delegate && delegate.apply(self, args);
          });
      }
  }
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  function patchCallbacks(api, target, targetName, method, callbacks) {
      const symbol = Zone.__symbol__(method);
      if (target[symbol]) {
          return;
      }
      const nativeDelegate = target[symbol] = target[method];
      target[method] = function (name, opts, options) {
          if (opts && opts.prototype) {
              callbacks.forEach(function (callback) {
                  const source = `${targetName}.${method}::` + callback;
                  const prototype = opts.prototype;
                  if (prototype.hasOwnProperty(callback)) {
                      const descriptor = api.ObjectGetOwnPropertyDescriptor(prototype, callback);
                      if (descriptor && descriptor.value) {
                          descriptor.value = api.wrapWithCurrentZone(descriptor.value, source);
                          api._redefineProperty(opts.prototype, callback, descriptor);
                      }
                      else if (prototype[callback]) {
                          prototype[callback] = api.wrapWithCurrentZone(prototype[callback], source);
                      }
                  }
                  else if (prototype[callback]) {
                      prototype[callback] = api.wrapWithCurrentZone(prototype[callback], source);
                  }
              });
          }
          return nativeDelegate.call(target, name, opts, options);
      };
      api.attachOriginToPatched(target[method], nativeDelegate);
  }
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  const globalEventHandlersEventNames = [
      'abort',
      'animationcancel',
      'animationend',
      'animationiteration',
      'auxclick',
      'beforeinput',
      'blur',
      'cancel',
      'canplay',
      'canplaythrough',
      'change',
      'compositionstart',
      'compositionupdate',
      'compositionend',
      'cuechange',
      'click',
      'close',
      'contextmenu',
      'curechange',
      'dblclick',
      'drag',
      'dragend',
      'dragenter',
      'dragexit',
      'dragleave',
      'dragover',
      'drop',
      'durationchange',
      'emptied',
      'ended',
      'error',
      'focus',
      'focusin',
      'focusout',
      'gotpointercapture',
      'input',
      'invalid',
      'keydown',
      'keypress',
      'keyup',
      'load',
      'loadstart',
      'loadeddata',
      'loadedmetadata',
      'lostpointercapture',
      'mousedown',
      'mouseenter',
      'mouseleave',
      'mousemove',
      'mouseout',
      'mouseover',
      'mouseup',
      'mousewheel',
      'orientationchange',
      'pause',
      'play',
      'playing',
      'pointercancel',
      'pointerdown',
      'pointerenter',
      'pointerleave',
      'pointerlockchange',
      'mozpointerlockchange',
      'webkitpointerlockerchange',
      'pointerlockerror',
      'mozpointerlockerror',
      'webkitpointerlockerror',
      'pointermove',
      'pointout',
      'pointerover',
      'pointerup',
      'progress',
      'ratechange',
      'reset',
      'resize',
      'scroll',
      'seeked',
      'seeking',
      'select',
      'selectionchange',
      'selectstart',
      'show',
      'sort',
      'stalled',
      'submit',
      'suspend',
      'timeupdate',
      'volumechange',
      'touchcancel',
      'touchmove',
      'touchstart',
      'touchend',
      'transitioncancel',
      'transitionend',
      'waiting',
      'wheel'
  ];
  const documentEventNames = [
      'afterscriptexecute', 'beforescriptexecute', 'DOMContentLoaded', 'freeze', 'fullscreenchange',
      'mozfullscreenchange', 'webkitfullscreenchange', 'msfullscreenchange', 'fullscreenerror',
      'mozfullscreenerror', 'webkitfullscreenerror', 'msfullscreenerror', 'readystatechange',
      'visibilitychange', 'resume'
  ];
  const windowEventNames = [
      'absolutedeviceorientation',
      'afterinput',
      'afterprint',
      'appinstalled',
      'beforeinstallprompt',
      'beforeprint',
      'beforeunload',
      'devicelight',
      'devicemotion',
      'deviceorientation',
      'deviceorientationabsolute',
      'deviceproximity',
      'hashchange',
      'languagechange',
      'message',
      'mozbeforepaint',
      'offline',
      'online',
      'paint',
      'pageshow',
      'pagehide',
      'popstate',
      'rejectionhandled',
      'storage',
      'unhandledrejection',
      'unload',
      'userproximity',
      'vrdisplayconnected',
      'vrdisplaydisconnected',
      'vrdisplaypresentchange'
  ];
  const htmlElementEventNames = [
      'beforecopy', 'beforecut', 'beforepaste', 'copy', 'cut', 'paste', 'dragstart', 'loadend',
      'animationstart', 'search', 'transitionrun', 'transitionstart', 'webkitanimationend',
      'webkitanimationiteration', 'webkitanimationstart', 'webkittransitionend'
  ];
  const mediaElementEventNames = ['encrypted', 'waitingforkey', 'msneedkey', 'mozinterruptbegin', 'mozinterruptend'];
  const ieElementEventNames = [
      'activate',
      'afterupdate',
      'ariarequest',
      'beforeactivate',
      'beforedeactivate',
      'beforeeditfocus',
      'beforeupdate',
      'cellchange',
      'controlselect',
      'dataavailable',
      'datasetchanged',
      'datasetcomplete',
      'errorupdate',
      'filterchange',
      'layoutcomplete',
      'losecapture',
      'move',
      'moveend',
      'movestart',
      'propertychange',
      'resizeend',
      'resizestart',
      'rowenter',
      'rowexit',
      'rowsdelete',
      'rowsinserted',
      'command',
      'compassneedscalibration',
      'deactivate',
      'help',
      'mscontentzoom',
      'msmanipulationstatechanged',
      'msgesturechange',
      'msgesturedoubletap',
      'msgestureend',
      'msgesturehold',
      'msgesturestart',
      'msgesturetap',
      'msgotpointercapture',
      'msinertiastart',
      'mslostpointercapture',
      'mspointercancel',
      'mspointerdown',
      'mspointerenter',
      'mspointerhover',
      'mspointerleave',
      'mspointermove',
      'mspointerout',
      'mspointerover',
      'mspointerup',
      'pointerout',
      'mssitemodejumplistitemremoved',
      'msthumbnailclick',
      'stop',
      'storagecommit'
  ];
  const webglEventNames = ['webglcontextrestored', 'webglcontextlost', 'webglcontextcreationerror'];
  const formEventNames = ['autocomplete', 'autocompleteerror'];
  const detailEventNames = ['toggle'];
  const frameEventNames = ['load'];
  const frameSetEventNames = ['blur', 'error', 'focus', 'load', 'resize', 'scroll', 'messageerror'];
  const marqueeEventNames = ['bounce', 'finish', 'start'];
  const XMLHttpRequestEventNames = [
      'loadstart', 'progress', 'abort', 'error', 'load', 'progress', 'timeout', 'loadend',
      'readystatechange'
  ];
  const IDBIndexEventNames = ['upgradeneeded', 'complete', 'abort', 'success', 'error', 'blocked', 'versionchange', 'close'];
  const websocketEventNames = ['close', 'error', 'open', 'message'];
  const workerEventNames = ['error', 'message'];
  const eventNames = globalEventHandlersEventNames.concat(webglEventNames, formEventNames, detailEventNames, documentEventNames, windowEventNames, htmlElementEventNames, ieElementEventNames);
  function filterProperties(target, onProperties, ignoreProperties) {
      if (!ignoreProperties || ignoreProperties.length === 0) {
          return onProperties;
      }
      const tip = ignoreProperties.filter(ip => ip.target === target);
      if (!tip || tip.length === 0) {
          return onProperties;
      }
      const targetIgnoreProperties = tip[0].ignoreProperties;
      return onProperties.filter(op => targetIgnoreProperties.indexOf(op) === -1);
  }
  function patchFilteredProperties(target, onProperties, ignoreProperties, prototype) {
      // check whether target is available, sometimes target will be undefined
      // because different browser or some 3rd party plugin.
      if (!target) {
          return;
      }
      const filteredProperties = filterProperties(target, onProperties, ignoreProperties);
      patchOnProperties(target, filteredProperties, prototype);
  }
  function propertyDescriptorPatch(api, _global) {
      if (isNode && !isMix) {
          return;
      }
      if (Zone[api.symbol('patchEvents')]) {
          // events are already been patched by legacy patch.
          return;
      }
      const supportsWebSocket = typeof WebSocket !== 'undefined';
      const ignoreProperties = _global['__Zone_ignore_on_properties'];
      // for browsers that we can patch the descriptor:  Chrome & Firefox
      if (isBrowser) {
          const internalWindow = window;
          const ignoreErrorProperties = isIE() ? [{ target: internalWindow, ignoreProperties: ['error'] }] : [];
          // in IE/Edge, onProp not exist in window object, but in WindowPrototype
          // so we need to pass WindowPrototype to check onProp exist or not
          patchFilteredProperties(internalWindow, eventNames.concat(['messageerror']), ignoreProperties ? ignoreProperties.concat(ignoreErrorProperties) : ignoreProperties, ObjectGetPrototypeOf(internalWindow));
          patchFilteredProperties(Document.prototype, eventNames, ignoreProperties);
          if (typeof internalWindow['SVGElement'] !== 'undefined') {
              patchFilteredProperties(internalWindow['SVGElement'].prototype, eventNames, ignoreProperties);
          }
          patchFilteredProperties(Element.prototype, eventNames, ignoreProperties);
          patchFilteredProperties(HTMLElement.prototype, eventNames, ignoreProperties);
          patchFilteredProperties(HTMLMediaElement.prototype, mediaElementEventNames, ignoreProperties);
          patchFilteredProperties(HTMLFrameSetElement.prototype, windowEventNames.concat(frameSetEventNames), ignoreProperties);
          patchFilteredProperties(HTMLBodyElement.prototype, windowEventNames.concat(frameSetEventNames), ignoreProperties);
          patchFilteredProperties(HTMLFrameElement.prototype, frameEventNames, ignoreProperties);
          patchFilteredProperties(HTMLIFrameElement.prototype, frameEventNames, ignoreProperties);
          const HTMLMarqueeElement = internalWindow['HTMLMarqueeElement'];
          if (HTMLMarqueeElement) {
              patchFilteredProperties(HTMLMarqueeElement.prototype, marqueeEventNames, ignoreProperties);
          }
          const Worker = internalWindow['Worker'];
          if (Worker) {
              patchFilteredProperties(Worker.prototype, workerEventNames, ignoreProperties);
          }
      }
      const XMLHttpRequest = _global['XMLHttpRequest'];
      if (XMLHttpRequest) {
          // XMLHttpRequest is not available in ServiceWorker, so we need to check here
          patchFilteredProperties(XMLHttpRequest.prototype, XMLHttpRequestEventNames, ignoreProperties);
      }
      const XMLHttpRequestEventTarget = _global['XMLHttpRequestEventTarget'];
      if (XMLHttpRequestEventTarget) {
          patchFilteredProperties(XMLHttpRequestEventTarget && XMLHttpRequestEventTarget.prototype, XMLHttpRequestEventNames, ignoreProperties);
      }
      if (typeof IDBIndex !== 'undefined') {
          patchFilteredProperties(IDBIndex.prototype, IDBIndexEventNames, ignoreProperties);
          patchFilteredProperties(IDBRequest.prototype, IDBIndexEventNames, ignoreProperties);
          patchFilteredProperties(IDBOpenDBRequest.prototype, IDBIndexEventNames, ignoreProperties);
          patchFilteredProperties(IDBDatabase.prototype, IDBIndexEventNames, ignoreProperties);
          patchFilteredProperties(IDBTransaction.prototype, IDBIndexEventNames, ignoreProperties);
          patchFilteredProperties(IDBCursor.prototype, IDBIndexEventNames, ignoreProperties);
      }
      if (supportsWebSocket) {
          patchFilteredProperties(WebSocket.prototype, websocketEventNames, ignoreProperties);
      }
  }
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  Zone.__load_patch('util', (global, Zone, api) => {
      api.patchOnProperties = patchOnProperties;
      api.patchMethod = patchMethod;
      api.bindArguments = bindArguments;
      api.patchMacroTask = patchMacroTask;
      // In earlier version of zone.js (<0.9.0), we use env name `__zone_symbol__BLACK_LISTED_EVENTS` to
      // define which events will not be patched by `Zone.js`.
      // In newer version (>=0.9.0), we change the env name to `__zone_symbol__UNPATCHED_EVENTS` to keep
      // the name consistent with angular repo.
      // The  `__zone_symbol__BLACK_LISTED_EVENTS` is deprecated, but it is still be supported for
      // backwards compatibility.
      const SYMBOL_BLACK_LISTED_EVENTS = Zone.__symbol__('BLACK_LISTED_EVENTS');
      const SYMBOL_UNPATCHED_EVENTS = Zone.__symbol__('UNPATCHED_EVENTS');
      if (global[SYMBOL_UNPATCHED_EVENTS]) {
          global[SYMBOL_BLACK_LISTED_EVENTS] = global[SYMBOL_UNPATCHED_EVENTS];
      }
      if (global[SYMBOL_BLACK_LISTED_EVENTS]) {
          Zone[SYMBOL_BLACK_LISTED_EVENTS] = Zone[SYMBOL_UNPATCHED_EVENTS] =
              global[SYMBOL_BLACK_LISTED_EVENTS];
      }
      api.patchEventPrototype = patchEventPrototype;
      api.patchEventTarget = patchEventTarget;
      api.isIEOrEdge = isIEOrEdge;
      api.ObjectDefineProperty = ObjectDefineProperty;
      api.ObjectGetOwnPropertyDescriptor = ObjectGetOwnPropertyDescriptor;
      api.ObjectCreate = ObjectCreate;
      api.ArraySlice = ArraySlice;
      api.patchClass = patchClass;
      api.wrapWithCurrentZone = wrapWithCurrentZone;
      api.filterProperties = filterProperties;
      api.attachOriginToPatched = attachOriginToPatched;
      api._redefineProperty = Object.defineProperty;
      api.patchCallbacks = patchCallbacks;
      api.getGlobalObjects = () => ({
          globalSources,
          zoneSymbolEventNames: zoneSymbolEventNames$1,
          eventNames,
          isBrowser,
          isMix,
          isNode,
          TRUE_STR,
          FALSE_STR,
          ZONE_SYMBOL_PREFIX,
          ADD_EVENT_LISTENER_STR,
          REMOVE_EVENT_LISTENER_STR
      });
  });
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  const taskSymbol = zoneSymbol('zoneTask');
  function patchTimer(window, setName, cancelName, nameSuffix) {
      let setNative = null;
      let clearNative = null;
      setName += nameSuffix;
      cancelName += nameSuffix;
      const tasksByHandleId = {};
      function scheduleTask(task) {
          const data = task.data;
          data.args[0] = function () {
              return task.invoke.apply(this, arguments);
          };
          data.handleId = setNative.apply(window, data.args);
          return task;
      }
      function clearTask(task) {
          return clearNative.call(window, task.data.handleId);
      }
      setNative =
          patchMethod(window, setName, (delegate) => function (self, args) {
              if (typeof args[0] === 'function') {
                  const options = {
                      isPeriodic: nameSuffix === 'Interval',
                      delay: (nameSuffix === 'Timeout' || nameSuffix === 'Interval') ? args[1] || 0 :
                          undefined,
                      args: args
                  };
                  const callback = args[0];
                  args[0] = function timer() {
                      try {
                          return callback.apply(this, arguments);
                      }
                      finally {
                          // issue-934, task will be cancelled
                          // even it is a periodic task such as
                          // setInterval
                          // https://github.com/angular/angular/issues/40387
                          // Cleanup tasksByHandleId should be handled before scheduleTask
                          // Since some zoneSpec may intercept and doesn't trigger
                          // scheduleFn(scheduleTask) provided here.
                          if (!(options.isPeriodic)) {
                              if (typeof options.handleId === 'number') {
                                  // in non-nodejs env, we remove timerId
                                  // from local cache
                                  delete tasksByHandleId[options.handleId];
                              }
                              else if (options.handleId) {
                                  // Node returns complex objects as handleIds
                                  // we remove task reference from timer object
                                  options.handleId[taskSymbol] = null;
                              }
                          }
                      }
                  };
                  const task = scheduleMacroTaskWithCurrentZone(setName, args[0], options, scheduleTask, clearTask);
                  if (!task) {
                      return task;
                  }
                  // Node.js must additionally support the ref and unref functions.
                  const handle = task.data.handleId;
                  if (typeof handle === 'number') {
                      // for non nodejs env, we save handleId: task
                      // mapping in local cache for clearTimeout
                      tasksByHandleId[handle] = task;
                  }
                  else if (handle) {
                      // for nodejs env, we save task
                      // reference in timerId Object for clearTimeout
                      handle[taskSymbol] = task;
                  }
                  // check whether handle is null, because some polyfill or browser
                  // may return undefined from setTimeout/setInterval/setImmediate/requestAnimationFrame
                  if (handle && handle.ref && handle.unref && typeof handle.ref === 'function' &&
                      typeof handle.unref === 'function') {
                      task.ref = handle.ref.bind(handle);
                      task.unref = handle.unref.bind(handle);
                  }
                  if (typeof handle === 'number' || handle) {
                      return handle;
                  }
                  return task;
              }
              else {
                  // cause an error by calling it directly.
                  return delegate.apply(window, args);
              }
          });
      clearNative =
          patchMethod(window, cancelName, (delegate) => function (self, args) {
              const id = args[0];
              let task;
              if (typeof id === 'number') {
                  // non nodejs env.
                  task = tasksByHandleId[id];
              }
              else {
                  // nodejs env.
                  task = id && id[taskSymbol];
                  // other environments.
                  if (!task) {
                      task = id;
                  }
              }
              if (task && typeof task.type === 'string') {
                  if (task.state !== 'notScheduled' &&
                      (task.cancelFn && task.data.isPeriodic || task.runCount === 0)) {
                      if (typeof id === 'number') {
                          delete tasksByHandleId[id];
                      }
                      else if (id) {
                          id[taskSymbol] = null;
                      }
                      // Do not cancel already canceled functions
                      task.zone.cancelTask(task);
                  }
              }
              else {
                  // cause an error by calling it directly.
                  delegate.apply(window, args);
              }
          });
  }
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  function patchCustomElements(_global, api) {
      const { isBrowser, isMix } = api.getGlobalObjects();
      if ((!isBrowser && !isMix) || !_global['customElements'] || !('customElements' in _global)) {
          return;
      }
      const callbacks = ['connectedCallback', 'disconnectedCallback', 'adoptedCallback', 'attributeChangedCallback'];
      api.patchCallbacks(api, _global.customElements, 'customElements', 'define', callbacks);
  }
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  function eventTargetPatch(_global, api) {
      if (Zone[api.symbol('patchEventTarget')]) {
          // EventTarget is already patched.
          return;
      }
      const { eventNames, zoneSymbolEventNames, TRUE_STR, FALSE_STR, ZONE_SYMBOL_PREFIX } = api.getGlobalObjects();
      //  predefine all __zone_symbol__ + eventName + true/false string
      for (let i = 0; i < eventNames.length; i++) {
          const eventName = eventNames[i];
          const falseEventName = eventName + FALSE_STR;
          const trueEventName = eventName + TRUE_STR;
          const symbol = ZONE_SYMBOL_PREFIX + falseEventName;
          const symbolCapture = ZONE_SYMBOL_PREFIX + trueEventName;
          zoneSymbolEventNames[eventName] = {};
          zoneSymbolEventNames[eventName][FALSE_STR] = symbol;
          zoneSymbolEventNames[eventName][TRUE_STR] = symbolCapture;
      }
      const EVENT_TARGET = _global['EventTarget'];
      if (!EVENT_TARGET || !EVENT_TARGET.prototype) {
          return;
      }
      api.patchEventTarget(_global, [EVENT_TARGET && EVENT_TARGET.prototype]);
      return true;
  }
  function patchEvent(global, api) {
      api.patchEventPrototype(global, api);
  }
  
  /**
   * @license
   * Copyright Google LLC All Rights Reserved.
   *
   * Use of this source code is governed by an MIT-style license that can be
   * found in the LICENSE file at https://angular.io/license
   */
  Zone.__load_patch('legacy', (global) => {
      const legacyPatch = global[Zone.__symbol__('legacyPatch')];
      if (legacyPatch) {
          legacyPatch();
      }
  });
  Zone.__load_patch('queueMicrotask', (global, Zone, api) => {
      api.patchMethod(global, 'queueMicrotask', delegate => {
          return function (self, args) {
              Zone.current.scheduleMicroTask('queueMicrotask', args[0]);
          };
      });
  });
  Zone.__load_patch('timers', (global) => {
      const set = 'set';
      const clear = 'clear';
      patchTimer(global, set, clear, 'Timeout');
      patchTimer(global, set, clear, 'Interval');
      patchTimer(global, set, clear, 'Immediate');
  });
  Zone.__load_patch('requestAnimationFrame', (global) => {
      patchTimer(global, 'request', 'cancel', 'AnimationFrame');
      patchTimer(global, 'mozRequest', 'mozCancel', 'AnimationFrame');
      patchTimer(global, 'webkitRequest', 'webkitCancel', 'AnimationFrame');
  });
  Zone.__load_patch('blocking', (global, Zone) => {
      const blockingMethods = ['alert', 'prompt', 'confirm'];
      for (let i = 0; i < blockingMethods.length; i++) {
          const name = blockingMethods[i];
          patchMethod(global, name, (delegate, symbol, name) => {
              return function (s, args) {
                  return Zone.current.run(delegate, global, args, name);
              };
          });
      }
  });
  Zone.__load_patch('EventTarget', (global, Zone, api) => {
      patchEvent(global, api);
      eventTargetPatch(global, api);
      // patch XMLHttpRequestEventTarget's addEventListener/removeEventListener
      const XMLHttpRequestEventTarget = global['XMLHttpRequestEventTarget'];
      if (XMLHttpRequestEventTarget && XMLHttpRequestEventTarget.prototype) {
          api.patchEventTarget(global, [XMLHttpRequestEventTarget.prototype]);
      }
  });
  Zone.__load_patch('MutationObserver', (global, Zone, api) => {
      patchClass('MutationObserver');
      patchClass('WebKitMutationObserver');
  });
  Zone.__load_patch('IntersectionObserver', (global, Zone, api) => {
      patchClass('IntersectionObserver');
  });
  Zone.__load_patch('FileReader', (global, Zone, api) => {
      patchClass('FileReader');
  });
  Zone.__load_patch('on_property', (global, Zone, api) => {
      propertyDescriptorPatch(api, global);
  });
  Zone.__load_patch('customElements', (global, Zone, api) => {
      patchCustomElements(global, api);
  });
  Zone.__load_patch('XHR', (global, Zone) => {
      // Treat XMLHttpRequest as a macrotask.
      patchXHR(global);
      const XHR_TASK = zoneSymbol('xhrTask');
      const XHR_SYNC = zoneSymbol('xhrSync');
      const XHR_LISTENER = zoneSymbol('xhrListener');
      const XHR_SCHEDULED = zoneSymbol('xhrScheduled');
      const XHR_URL = zoneSymbol('xhrURL');
      const XHR_ERROR_BEFORE_SCHEDULED = zoneSymbol('xhrErrorBeforeScheduled');
      function patchXHR(window) {
          const XMLHttpRequest = window['XMLHttpRequest'];
          if (!XMLHttpRequest) {
              // XMLHttpRequest is not available in service worker
              return;
          }
          const XMLHttpRequestPrototype = XMLHttpRequest.prototype;
          function findPendingTask(target) {
              return target[XHR_TASK];
          }
          let oriAddListener = XMLHttpRequestPrototype[ZONE_SYMBOL_ADD_EVENT_LISTENER];
          let oriRemoveListener = XMLHttpRequestPrototype[ZONE_SYMBOL_REMOVE_EVENT_LISTENER];
          if (!oriAddListener) {
              const XMLHttpRequestEventTarget = window['XMLHttpRequestEventTarget'];
              if (XMLHttpRequestEventTarget) {
                  const XMLHttpRequestEventTargetPrototype = XMLHttpRequestEventTarget.prototype;
                  oriAddListener = XMLHttpRequestEventTargetPrototype[ZONE_SYMBOL_ADD_EVENT_LISTENER];
                  oriRemoveListener = XMLHttpRequestEventTargetPrototype[ZONE_SYMBOL_REMOVE_EVENT_LISTENER];
              }
          }
          const READY_STATE_CHANGE = 'readystatechange';
          const SCHEDULED = 'scheduled';
          function scheduleTask(task) {
              const data = task.data;
              const target = data.target;
              target[XHR_SCHEDULED] = false;
              target[XHR_ERROR_BEFORE_SCHEDULED] = false;
              // remove existing event listener
              const listener = target[XHR_LISTENER];
              if (!oriAddListener) {
                  oriAddListener = target[ZONE_SYMBOL_ADD_EVENT_LISTENER];
                  oriRemoveListener = target[ZONE_SYMBOL_REMOVE_EVENT_LISTENER];
              }
              if (listener) {
                  oriRemoveListener.call(target, READY_STATE_CHANGE, listener);
              }
              const newListener = target[XHR_LISTENER] = () => {
                  if (target.readyState === target.DONE) {
                      // sometimes on some browsers XMLHttpRequest will fire onreadystatechange with
                      // readyState=4 multiple times, so we need to check task state here
                      if (!data.aborted && target[XHR_SCHEDULED] && task.state === SCHEDULED) {
                          // check whether the xhr has registered onload listener
                          // if that is the case, the task should invoke after all
                          // onload listeners finish.
                          // Also if the request failed without response (status = 0), the load event handler
                          // will not be triggered, in that case, we should also invoke the placeholder callback
                          // to close the XMLHttpRequest::send macroTask.
                          // https://github.com/angular/angular/issues/38795
                          const loadTasks = target[Zone.__symbol__('loadfalse')];
                          if (target.status !== 0 && loadTasks && loadTasks.length > 0) {
                              const oriInvoke = task.invoke;
                              task.invoke = function () {
                                  // need to load the tasks again, because in other
                                  // load listener, they may remove themselves
                                  const loadTasks = target[Zone.__symbol__('loadfalse')];
                                  for (let i = 0; i < loadTasks.length; i++) {
                                      if (loadTasks[i] === task) {
                                          loadTasks.splice(i, 1);
                                      }
                                  }
                                  if (!data.aborted && task.state === SCHEDULED) {
                                      oriInvoke.call(task);
                                  }
                              };
                              loadTasks.push(task);
                          }
                          else {
                              task.invoke();
                          }
                      }
                      else if (!data.aborted && target[XHR_SCHEDULED] === false) {
                          // error occurs when xhr.send()
                          target[XHR_ERROR_BEFORE_SCHEDULED] = true;
                      }
                  }
              };
              oriAddListener.call(target, READY_STATE_CHANGE, newListener);
              const storedTask = target[XHR_TASK];
              if (!storedTask) {
                  target[XHR_TASK] = task;
              }
              sendNative.apply(target, data.args);
              target[XHR_SCHEDULED] = true;
              return task;
          }
          function placeholderCallback() { }
          function clearTask(task) {
              const data = task.data;
              // Note - ideally, we would call data.target.removeEventListener here, but it's too late
              // to prevent it from firing. So instead, we store info for the event listener.
              data.aborted = true;
              return abortNative.apply(data.target, data.args);
          }
          const openNative = patchMethod(XMLHttpRequestPrototype, 'open', () => function (self, args) {
              self[XHR_SYNC] = args[2] == false;
              self[XHR_URL] = args[1];
              return openNative.apply(self, args);
          });
          const XMLHTTPREQUEST_SOURCE = 'XMLHttpRequest.send';
          const fetchTaskAborting = zoneSymbol('fetchTaskAborting');
          const fetchTaskScheduling = zoneSymbol('fetchTaskScheduling');
          const sendNative = patchMethod(XMLHttpRequestPrototype, 'send', () => function (self, args) {
              if (Zone.current[fetchTaskScheduling] === true) {
                  // a fetch is scheduling, so we are using xhr to polyfill fetch
                  // and because we already schedule macroTask for fetch, we should
                  // not schedule a macroTask for xhr again
                  return sendNative.apply(self, args);
              }
              if (self[XHR_SYNC]) {
                  // if the XHR is sync there is no task to schedule, just execute the code.
                  return sendNative.apply(self, args);
              }
              else {
                  const options = { target: self, url: self[XHR_URL], isPeriodic: false, args: args, aborted: false };
                  const task = scheduleMacroTaskWithCurrentZone(XMLHTTPREQUEST_SOURCE, placeholderCallback, options, scheduleTask, clearTask);
                  if (self && self[XHR_ERROR_BEFORE_SCHEDULED] === true && !options.aborted &&
                      task.state === SCHEDULED) {
                      // xhr request throw error when send
                      // we should invoke task instead of leaving a scheduled
                      // pending macroTask
                      task.invoke();
                  }
              }
          });
          const abortNative = patchMethod(XMLHttpRequestPrototype, 'abort', () => function (self, args) {
              const task = findPendingTask(self);
              if (task && typeof task.type == 'string') {
                  // If the XHR has already completed, do nothing.
                  // If the XHR has already been aborted, do nothing.
                  // Fix #569, call abort multiple times before done will cause
                  // macroTask task count be negative number
                  if (task.cancelFn == null || (task.data && task.data.aborted)) {
                      return;
                  }
                  task.zone.cancelTask(task);
              }
              else if (Zone.current[fetchTaskAborting] === true) {
                  // the abort is called from fetch polyfill, we need to call native abort of XHR.
                  return abortNative.apply(self, args);
              }
              // Otherwise, we are trying to abort an XHR which has not yet been sent, so there is no
              // task
              // to cancel. Do nothing.
          });
      }
  });
  Zone.__load_patch('geolocation', (global) => {
      /// GEO_LOCATION
      if (global['navigator'] && global['navigator'].geolocation) {
          patchPrototype(global['navigator'].geolocation, ['getCurrentPosition', 'watchPosition']);
      }
  });
  Zone.__load_patch('PromiseRejectionEvent', (global, Zone) => {
      // handle unhandled promise rejection
      function findPromiseRejectionHandler(evtName) {
          return function (e) {
              const eventTasks = findEventTasks(global, evtName);
              eventTasks.forEach(eventTask => {
                  // windows has added unhandledrejection event listener
                  // trigger the event listener
                  const PromiseRejectionEvent = global['PromiseRejectionEvent'];
                  if (PromiseRejectionEvent) {
                      const evt = new PromiseRejectionEvent(evtName, { promise: e.promise, reason: e.rejection });
                      eventTask.invoke(evt);
                  }
              });
          };
      }
      if (global['PromiseRejectionEvent']) {
          Zone[zoneSymbol('unhandledPromiseRejectionHandler')] =
              findPromiseRejectionHandler('unhandledrejection');
          Zone[zoneSymbol('rejectionHandledHandler')] =
              findPromiseRejectionHandler('rejectionhandled');
      }
  });
  
  
  /***/ })
  
  },
  /******/ __webpack_require__ => { // webpackRuntimeModules
  /******/ var __webpack_exec__ = (moduleId) => (__webpack_require__(__webpack_require__.s = moduleId))
  /******/ var __webpack_exports__ = (__webpack_exec__(7435));
  /******/ }
  ]);
  //# sourceMappingURL=polyfills.js.map