https://topserve.ca/polyfills.js

264      try {
265        task = this._zoneDelegate.scheduleTask(this, task);
266      } catch (err) {
267        // should set task's state to unknown when scheduleTask throw error
268        // because the err may from reschedule, so the fromState maybe notScheduled
269        task._transitionTo(unknown, scheduling, notScheduled);
270        // TODO: @JiaLiPassion, should we check the result from handleError?
271        this._zoneDelegate.handleError(this, err);
272        throw err;
273      }
274      if (task._zoneDelegates === zoneDelegates) {
275        // we have to check because internally the delegate can reschedule the task.
276        this._updateTaskCount(task, 1);
277      }
278      if (task.state == scheduling) {
279        task._transitionTo(scheduled, scheduling);
280      }
281      return task;
282    }
283    scheduleMicroTask(source, callback, data, customSchedule) {
284      return this.scheduleTask(new ZoneTask(microTask, source, callback, data, customSchedule, undefined));
285    }
286    scheduleMacroTask(source, callback, data, customSchedule, customCancel) {
287      return this.scheduleTask(new ZoneTask(macroTask, source, callback, data, customSchedule, customCancel));
288    }
289    scheduleEventTask(source, callback, data, customSchedule, customCancel) {
290      return this.scheduleTask(new ZoneTask(eventTask, source, callback, data, customSchedule, customCancel));
291    }
292    cancelTask(task) {
293      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 + ')');
294      if (task.state !== scheduled && task.state !== running) {
295        return;
296      }
297      task._transitionTo(canceling, scheduled, running);
298      try {
299        this._zoneDelegate.cancelTask(this, task);
300      } catch (err) {
301        // if error occurs when cancelTask, transit the state to unknown
302        task._transitionTo(unknown, canceling);
303        this._zoneDelegate.handleError(this, err);
304        throw err;
305      }
306      this._updateTaskCount(task, -1);
307      task._transitionTo(notScheduled, canceling);
308      task.runCount = 0;
309      return task;
310    }
311    _updateTaskCount(task, count) {
312      const zoneDelegates = task._zoneDelegates;
313      if (count == -1) {
314        task._zoneDelegates = null;
315      }
316      for (let i = 0; i < zoneDelegates.length; i++) {
317        zoneDelegates[i]._updateTaskCount(task.type, count);
318      }
319    }
320  }
321  const DELEGATE_ZS = {
322    name: '',
323    onHasTask: (delegate, _, target, hasTaskState) => delegate.hasTask(target, hasTaskState),
324    onScheduleTask: (delegate, _, target, task) => delegate.scheduleTask(target, task),
325    onInvokeTask: (delegate, _, target, task, applyThis, applyArgs) => delegate.invokeTask(target, task, applyThis, applyArgs),
326    onCancelTask: (delegate, _, target, task) => delegate.cancelTask(target, task)
327  };
328  class _ZoneDelegate {
329    get zone() {
330      return this._zone;
331    }
332    constructor(zone, parentDelegate, zoneSpec) {
333      this._taskCounts = {
334        'microTask': 0,
335        'macroTask': 0,
336        'eventTask': 0
337      };
338      this._zone = zone;
339      this._parentDelegate = parentDelegate;
340      this._forkZS = zoneSpec && (zoneSpec && zoneSpec.onFork ? zoneSpec : parentDelegate._forkZS);
341      this._forkDlgt = zoneSpec && (zoneSpec.onFork ? parentDelegate : parentDelegate._forkDlgt);
342      this._forkCurrZone = zoneSpec && (zoneSpec.onFork ? this._zone : parentDelegate._forkCurrZone);
343      this._interceptZS = zoneSpec && (zoneSpec.onIntercept ? zoneSpec : parentDelegate._interceptZS);
344      this._interceptDlgt = zoneSpec && (zoneSpec.onIntercept ? parentDelegate : parentDelegate._interceptDlgt);
345      this._interceptCurrZone = zoneSpec && (zoneSpec.onIntercept ? this._zone : parentDelegate._interceptCurrZone);
346      this._invokeZS = zoneSpec && (zoneSpec.onInvoke ? zoneSpec : parentDelegate._invokeZS);
347      this._invokeDlgt = zoneSpec && (zoneSpec.onInvoke ? parentDelegate : parentDelegate._invokeDlgt);
348      this._invokeCurrZone = zoneSpec && (zoneSpec.onInvoke ? this._zone : parentDelegate._invokeCurrZone);
349      this._handleErrorZS = zoneSpec && (zoneSpec.onHandleError ? zoneSpec : parentDelegate._handleErrorZS);
350      this._handleErrorDlgt = zoneSpec && (zoneSpec.onHandleError ? parentDelegate : parentDelegate._handleErrorDlgt);
351      this._handleErrorCurrZone = zoneSpec && (zoneSpec.onHandleError ? this._zone : parentDelegate._handleErrorCurrZone);
352      this._scheduleTaskZS = zoneSpec && (zoneSpec.onScheduleTask ? zoneSpec : parentDelegate._scheduleTaskZS);
353      this._scheduleTaskDlgt = zoneSpec && (zoneSpec.onScheduleTask ? parentDelegate : parentDelegate._scheduleTaskDlgt);
354      this._scheduleTaskCurrZone = zoneSpec && (zoneSpec.onScheduleTask ? this._zone : parentDelegate._scheduleTaskCurrZone);
355      this._invokeTaskZS = zoneSpec && (zoneSpec.onInvokeTask ? zoneSpec : parentDelegate._invokeTaskZS);
356      this._invokeTaskDlgt = zoneSpec && (zoneSpec.onInvokeTask ? parentDelegate : parentDelegate._invokeTaskDlgt);
357      this._invokeTaskCurrZone = zoneSpec && (zoneSpec.onInvokeTask ? this._zone : parentDelegate._invokeTaskCurrZone);
358      this._cancelTaskZS = zoneSpec && (zoneSpec.onCancelTask ? zoneSpec : parentDelegate._cancelTaskZS);
359      this._cancelTaskDlgt = zoneSpec && (zoneSpec.onCancelTask ? parentDelegate : parentDelegate._cancelTaskDlgt);
360      this._cancelTaskCurrZone = zoneSpec && (zoneSpec.onCancelTask ? this._zone : parentDelegate._cancelTaskCurrZone);
361      this._hasTaskZS = null;
362      this._hasTaskDlgt = null;
363      this._hasTaskDlgtOwner = null;
364      this._hasTaskCurrZone = null;
365      const zoneSpecHasTask = zoneSpec && zoneSpec.onHasTask;
366      const parentHasTask = parentDelegate && parentDelegate._hasTaskZS;
367      if (zoneSpecHasTask || parentHasTask) {
368        // If we need to report hasTask, than this ZS needs to do ref counting on tasks. In such
369        // a case all task related interceptors must go through this ZD. We can't short circuit it.
370        this._hasTaskZS = zoneSpecHasTask ? zoneSpec : DELEGATE_ZS;
371        this._hasTaskDlgt = parentDelegate;
372        this._hasTaskDlgtOwner = this;
373        this._hasTaskCurrZone = this._zone;
374        if (!zoneSpec.onScheduleTask) {
375          this._scheduleTaskZS = DELEGATE_ZS;
376          this._scheduleTaskDlgt = parentDelegate;
377          this._scheduleTaskCurrZone = this._zone;
378        }
379        if (!zoneSpec.onInvokeTask) {
380          this._invokeTaskZS = DELEGATE_ZS;
381          this._invokeTaskDlgt = parentDelegate;
382          this._invokeTaskCurrZone = this._zone;
383        }
384        if (!zoneSpec.onCancelTask) {
385          this._cancelTaskZS = DELEGATE_ZS;
386          this._cancelTaskDlgt = parentDelegate;
387          this._cancelTaskCurrZone = this._zone;
388        }
389      }
390    }
391    fork(targetZone, zoneSpec) {
392      return this._forkZS ? this._forkZS.onFork(this._forkDlgt, this.zone, targetZone, zoneSpec) : new ZoneImpl(targetZone, zoneSpec);
393    }
394    intercept(targetZone, callback, source) {
395      return this._interceptZS ? this._interceptZS.onIntercept(this._interceptDlgt, this._interceptCurrZone, targetZone, callback, source) : callback;
396    }
397    invoke(targetZone, callback, applyThis, applyArgs, source) {
398      return this._invokeZS ? this._invokeZS.onInvoke(this._invokeDlgt, this._invokeCurrZone, targetZone, callback, applyThis, applyArgs, source) : callback.apply(applyThis, applyArgs);
399    }
400    handleError(targetZone, error) {
401      return this._handleErrorZS ? this._handleErrorZS.onHandleError(this._handleErrorDlgt, this._handleErrorCurrZone, targetZone, error) : true;
402    }
403    scheduleTask(targetZone, task) {
404      let returnTask = task;
405      if (this._scheduleTaskZS) {
406        if (this._hasTaskZS) {
407          returnTask._zoneDelegates.push(this._hasTaskDlgtOwner);
408        }
409        returnTask = this._scheduleTaskZS.onScheduleTask(this._scheduleTaskDlgt, this._scheduleTaskCurrZone, targetZone, task);
410        if (!returnTask) returnTask = task;
411      } else {
412        if (task.scheduleFn) {
413          task.scheduleFn(task);
414        } else if (task.type == microTask) {
415          scheduleMicroTask(task);
416        } else {
417          throw new Error('Task is missing scheduleFn.');
418        }
419      }
420      return returnTask;
421    }
422    invokeTask(targetZone, task, applyThis, applyArgs) {
423      return this._invokeTaskZS ? this._invokeTaskZS.onInvokeTask(this._invokeTaskDlgt, this._invokeTaskCurrZone, targetZone, task, applyThis, applyArgs) : task.callback.apply(applyThis, applyArgs);
424    }
425    cancelTask(targetZone, task) {
426      let value;
427      if (this._cancelTaskZS) {
428        value = this._cancelTaskZS.onCancelTask(this._cancelTaskDlgt, this._cancelTaskCurrZone, targetZone, task);
429      } else {
430        if (!task.cancelFn) {
431          throw Error('Task is not cancelable');
432        }
433        value = task.cancelFn(task);
434      }
435      return value;
436    }
437    hasTask(targetZone, isEmpty) {
438      // hasTask should not throw error so other ZoneDelegate
439      // can still trigger hasTask callback
440      try {
441        this._hasTaskZS && this._hasTaskZS.onHasTask(this._hasTaskDlgt, this._hasTaskCurrZone, targetZone, isEmpty);
442      } catch (err) {
443        this.handleError(targetZone, err);
444      }
445    }
446    // tslint:disable-next-line:require-internal-with-underscore
447    _updateTaskCount(type, count) {
448      const counts = this._taskCounts;
449      const prev = counts[type];
450      const next = counts[type] = prev + count;
451      if (next < 0) {
452        throw new Error('More tasks executed then were scheduled.');
453      }
454      if (prev == 0 || next == 0) {
455        const isEmpty = {
456          microTask: counts['microTask'] > 0,
457          macroTask: counts['macroTask'] > 0,
458          eventTask: counts['eventTask'] > 0,
459          change: type
460        };
461        this.hasTask(this._zone, isEmpty);
462      }
463    }
464  }
465  class ZoneTask {
466    constructor(type, source, callback, options, scheduleFn, cancelFn) {
467      // tslint:disable-next-line:require-internal-with-underscore
468      this._zone = null;
469      this.runCount = 0;
470      // tslint:disable-next-line:require-internal-with-underscore
471      this._zoneDelegates = null;
472      // tslint:disable-next-line:require-internal-with-underscore
473      this._state = 'notScheduled';
474      this.type = type;
475      this.source = source;
476      this.data = options;
477      this.scheduleFn = scheduleFn;
478      this.cancelFn = cancelFn;
479      if (!callback) {
480        throw new Error('callback is not defined');
481      }
482      this.callback = callback;
483      const self = this;
484      // TODO: @JiaLiPassion options should have interface
485      if (type === eventTask && options && options.useG) {
486        this.invoke = ZoneTask.invokeTask;
487      } else {
488        this.invoke = function () {
489          return ZoneTask.invokeTask.call(global, self, this, arguments);
490        };
491      }
492    }
493    static invokeTask(task, target, args) {
494      if (!task) {
495        task = this;
496      }
497      _numberOfNestedTaskFrames++;
498      try {
499        task.runCount++;
500        return task.zone.runTask(task, target, args);
501      } finally {
502        if (_numberOfNestedTaskFrames == 1) {
503          drainMicroTaskQueue();
504        }
505        _numberOfNestedTaskFrames--;
506      }
507    }
508    get zone() {
509      return this._zone;
510    }
511    get state() {
512      return this._state;
513    }
514    cancelScheduleRequest() {
515      this._transitionTo(notScheduled, scheduling);
516    }
517    // tslint:disable-next-line:require-internal-with-underscore
518    _transitionTo(toState, fromState1, fromState2) {
519      if (this._state === fromState1 || this._state === fromState2) {
520        this._state = toState;
521        if (toState == notScheduled) {
522          this._zoneDelegates = null;
523        }
524      } else {
525        throw new Error(`${this.type} '${this.source}': can not transition to '${toState}', expecting state '${fromState1}'${fromState2 ? " or '" + fromState2 + "'" : ''}, was '${this._state}'.`);
526      }
527    }
528    toString() {
529      if (this.data && typeof this.data.handleId !== 'undefined') {
530        return this.data.handleId.toString();
531      } else {
532        return Object.prototype.toString.call(this);
533      }
534    }
535    // add toJSON method to prevent cyclic error when
536    // call JSON.stringify(zoneTask)
537    toJSON() {
538      return {
539        type: this.type,
540        state: this.state,
541        source: this.source,
542        zone: this.zone.name,
543        runCount: this.runCount
544      };
545    }
546  }
547  //////////////////////////////////////////////////////
548  //////////////////////////////////////////////////////
549  ///  MICROTASK QUEUE
550  //////////////////////////////////////////////////////
551  //////////////////////////////////////////////////////
552  const symbolSetTimeout = __symbol__('setTimeout');
553  const symbolPromise = __symbol__('Promise');
554  const symbolThen = __symbol__('then');
555  let _microTaskQueue = [];
556  let _isDrainingMicrotaskQueue = false;
557  let nativeMicroTaskQueuePromise;
558  function nativeScheduleMicroTask(func) {
559    if (!nativeMicroTaskQueuePromise) {
560      if (global[symbolPromise]) {
561        nativeMicroTaskQueuePromise = global[symbolPromise].resolve(0);
562      }
563    }
564    if (nativeMicroTaskQueuePromise) {
565      let nativeThen = nativeMicroTaskQueuePromise[symbolThen];
566      if (!nativeThen) {
567        // native Promise is not patchable, we need to use `then` directly
568        // issue 1078
569        nativeThen = nativeMicroTaskQueuePromise['then'];
570      }
571      nativeThen.call(nativeMicroTaskQueuePromise, func);
572    } else {
573      global[symbolSetTimeout](func, 0);
574    }
575  }
576  function scheduleMicroTask(task) {
577    // if we are not running in any task, and there has not been anything scheduled
578    // we must bootstrap the initial task creation by manually scheduling the drain
579    if (_numberOfNestedTaskFrames === 0 && _microTaskQueue.length === 0) {
580      // We are not running in Task, so we need to kickstart the microtask queue.
581      nativeScheduleMicroTask(drainMicroTaskQueue);
582    }
583    task && _microTaskQueue.push(task);
584  }
585  function drainMicroTaskQueue() {
586    if (!_isDrainingMicrotaskQueue) {
587      _isDrainingMicrotaskQueue = true;
588      while (_microTaskQueue.length) {
589        const queue = _microTaskQueue;
590        _microTaskQueue = [];
591        for (let i = 0; i < queue.length; i++) {
592          const task = queue[i];
593          try {
594            task.zone.runTask(task, null, null);
595          } catch (error) {
596            _api.onUnhandledError(error);
597          }
598        }
599      }
600      _api.microtaskDrainDone();
601      _isDrainingMicrotaskQueue = false;
602    }
603  }
604  //////////////////////////////////////////////////////
605  //////////////////////////////////////////////////////
606  ///  BOOTSTRAP
607  //////////////////////////////////////////////////////
608  //////////////////////////////////////////////////////
609  const NO_ZONE = {
610    name: 'NO ZONE'
611  };
612  const notScheduled = 'notScheduled',
613    scheduling = 'scheduling',
614    scheduled = 'scheduled',
615    running = 'running',
616    canceling = 'canceling',
617    unknown = 'unknown';
618  const microTask = 'microTask',
619    macroTask = 'macroTask',
620    eventTask = 'eventTask';
621  const patches = {};
622  const _api = {
623    symbol: __symbol__,
624    currentZoneFrame: () => _currentZoneFrame,
625    onUnhandledError: noop,
626    microtaskDrainDone: noop,
627    scheduleMicroTask: scheduleMicroTask,
628    showUncaughtError: () => !ZoneImpl[__symbol__('ignoreConsoleErrorUncaughtError')],
629    patchEventTarget: () => [],
630    patchOnProperties: noop,
631    patchMethod: () => noop,
632    bindArguments: () => [],
633    patchThen: () => noop,
634    patchMacroTask: () => noop,
635    patchEventPrototype: () => noop,
636    isIEOrEdge: () => false,
637    getGlobalObjects: () => undefined,
638    ObjectDefineProperty: () => noop,
639    ObjectGetOwnPropertyDescriptor: () => undefined,
640    ObjectCreate: () => undefined,
641    ArraySlice: () => [],
642    patchClass: () => noop,
643    wrapWithCurrentZone: () => noop,
644    filterProperties: () => [],
645    attachOriginToPatched: () => noop,
646    _redefineProperty: () => noop,
647    patchCallbacks: () => noop,
648    nativeScheduleMicroTask: nativeScheduleMicroTask
649  };
650  let _currentZoneFrame = {
651    parent: null,
652    zone: new ZoneImpl(null, null)
653  };
654  let _currentTask = null;
655  let _numberOfNestedTaskFrames = 0;
656  function noop() {}
657  performanceMeasure('Zone', 'Zone');
658  return ZoneImpl;
659}
660function loadZone() {
661  // if global['Zone'] already exists (maybe zone.js was already loaded or
662  // some other lib also registered a global object named Zone), we may 

803    const prototypeDesc = ObjectGetOwnPropertyDescriptor(prototype, prop);
804    if (prototypeDesc) {
805      desc = {
806        enumerable: true,
807        configurable: true
808      };
809    }
810  }
811  // if the descriptor not exists or is not configurable
812  // just return
813  if (!desc || !desc.configurable) {
814    return;
815  }
816  const onPropPatchedSymbol = zoneSymbol('on' + prop + 'patched');
817  if (obj.hasOwnProperty(onPropPatchedSymbol) && obj[onPropPatchedSymbol]) {
818    return;
819  }
820  // A property descriptor cannot have getter/setter and be writable
821  // deleting the writable and value properties avoids this error:
822  //
823  // TypeError: property descriptors must not specify a value or be writable when a
824  // getter or setter has been specified
825  delete desc.writable;
826  delete desc.value;
827  const originalDescGet = desc.get;
828  const originalDescSet = desc.set;
829  // slice(2) cuz 'onclick' -> 'click', etc
830  const eventName = prop.slice(2);
831  let eventNameSymbol = zoneSymbolEventNames$1[eventName];
832  if (!eventNameSymbol) {
833    eventNameSymbol = zoneSymbolEventNames$1[eventName] = zoneSymbol('ON_PROPERTY' + eventName);
834  }
835  desc.set = function (newValue) {
836    // in some of windows's onproperty callback, this is undefined
837    // so we need to check it
838    let target = this;
839    if (!target && obj === _global) {
840      target = _global;
841    }
842    if (!target) {
843      return;
844    }
845    const previousValue = target[eventNameSymbol];
846    if (typeof previousValue === 'function') {
847      target.removeEventListener(eventName, wrapFn);
848    }
849    // issue #978, when onload handler was added before loading zone.js
850    // we should remove it with originalDescSet
851    originalDescSet && originalDescSet.call(target, null);
852    target[eventNameSymbol] = newValue;
853    if (typeof newValue === 'function') {
854      target.addEventListener(eventName, wrapFn, false);
855    }
856  };
857  // The getter would return undefined for unassigned properties but the default value of an
858  // unassigned property is null
859  desc.get = function () {
860    // in some of windows's onproperty callback, this is undefined
861    // so we need to check it
862    let target = this;
863    if (!target && obj === _global) {
864      target = _global;
865    }
866    if (!target) {
867      return null;
868    }
869    const listener = target[eventNameSymbol];
870    if (listener) {
871      return listener;
872    } else if (originalDescGet) {
873      // result will be null when use inline event attribute,
874      // such as <button onclick="func();">OK</button>
875      // because the onclick function is internal raw uncompiled handler
876      // the onclick will be evaluated when first time event was triggered or
877      // the property is accessed, https://github.com/angular/zone.js/issues/525
878      // so we should use original native get to retrieve the handler
879      let value = originalDescGet.call(this);
880      if (value) {
881        desc.set.call(this, value);
882        if (typeof target[REMOVE_ATTRIBUTE] === 'function') {
883          target.removeAttribute(prop);
884        }
885        return value;
886      }
887    }
888    return null;
889  };
890  ObjectDefineProperty(obj, prop, desc);
891  obj[onPropPatchedSymbol] = true;
892}
893function patchOnProperties(obj, properties, prototype) {
894  if (properties) {
895    for (let i = 0; i < properties.length; i++) {
896      patchProperty(obj, 'on' + properties[i], prototype);
897    }
898  } else {
899    const onProperties = [];
900    for (const prop in obj) {
901      if (prop.slice(0, 2) == 'on') {
902        onProperties.push(prop);
903      }
904    }
905    for (let j = 0; j < onProperties.length; j++) {
906      patchProperty(obj, onProperties[j], prototype);
907    }
908  }
909}
910const originalInstanceKey = zoneSymbol('originalInstance');
911// wrap some native API on `window`
912function patchClass(className) {
913  const OriginalClass = _global[className];
914  if (!OriginalClass) return;
915  // keep original class in global
916  _global[zoneSymbol(className)] = OriginalClass;
917  _global[className] = function () {
918    const a = bindArguments(arguments, className);
919    switch (a.length) {
920      case 0:
921        this[originalInstanceKey] = new OriginalClass();
922        break;
923      case 1:
924        this[originalInstanceKey] = new OriginalClass(a[0]);
925        break;
926      case 2:
927        this[originalInstanceKey] = new OriginalClass(a[0], a[1]);
928        break;
929      case 3:
930        this[originalInstanceKey] = new OriginalClass(a[0], a[1], a[2]);
931        break;
932      case 4:
933        this[originalInstanceKey] = new OriginalClass(a[0], a[1], a[2], a[3]);
934        break;
935      default:
936        throw new Error('Arg list too long.');
937    }
938  };
939  // attach original delegate to patched function
940  attachOriginToPatched(_global[className], OriginalClass);
941  const instance = new OriginalClass(function () {});
942  let prop;
943  for (prop in instance) {
944    // https://bugs.webkit.org/show_bug.cgi?id=44721
945    if (className === 'XMLHttpRequest' && prop === 'responseBlob') continue;
946    (function (prop) {
947      if (typeof instance[prop] === 'function') {
948        _global[className].prototype[prop] = function () {
949          return this[originalInstanceKey][prop].apply(this[originalInstanceKey], arguments);
950        };
951      } else {
952        ObjectDefineProperty(_global[className].prototype, prop, {
953          set: function (fn) {
954            if (typeof fn === 'function') {
955              this[originalInstanceKey][prop] = wrapWithCurrentZone(fn, className + '.' + prop);
956              // keep callback in wrapped function so we can
957              // use it in Function.prototype.toString to return
958              // the native one.
959              attachOriginToPatched(this[originalInstanceKey][prop], fn);
960            } else {
961              this[originalInstanceKey][prop] = fn;
962            }
963          },
964          get: function () {
965            return this[originalInstanceKey][prop];
966          }
967        });
968      }
969    })(prop);
970  }
971  for (prop in OriginalClass) {
972    if (prop !== 'prototype' && OriginalClass.hasOwnProperty(prop)) {
973      _global[className][prop] = OriginalClass[prop];
974    }
975  }
976}
977function patchMethod(target, name, patchFn) {
978  let proto = target;
979  while (proto && !proto.hasOwnProperty(name)) {
980    proto = ObjectGetPrototypeOf(proto);
981  }
982  if (!proto && target[name]) {
983    // somehow we did not find it, but we can see it. This happens on IE for Window properties.
984    proto = target;
985  }
986  const delegateName = zoneSymbol(name);
987  let delegate = null;
988  if (proto && (!(delegate = proto[delegateName]) || !proto.hasOwnProperty(delegateName))) {
989    delegate = proto[delegateName] = proto[name];
990    // check whether proto[name] is writable
991    // some property is readonly in safari, such as HtmlCanvasElement.prototype.toBlob
992    const desc = proto && ObjectGetOwnPropertyDescriptor(proto, name);
993    if (isPropertyWritable(desc)) {
994      const patchDelegate = patchFn(delegate, delegateName, name);
995      proto[name] = function () {
996        return patchDelegate(this, arguments);
997      };
998      attachOriginToPatched(proto[name], delegate);
999    }
1000  }
1001  return delegate;
1002}
1003// TODO: @JiaLiPassion, support cancel task later if necessary
1004function patchMacroTask(obj, funcName, metaCreator) {
1005  let setNative = null;
1006  function scheduleTask(task) {
1007    const data = task.data;
1008    data.args[data.cbIdx] = function () {
1009      task.invoke.apply(this, arguments);
1010    };
1011    setNative.apply(data.target, data.args);
1012    return task;
1013  }
1014  setNative = patchMethod(obj, funcName, delegate => function (self, args) {
1015    const meta = metaCreator(self, args);
1016    if (meta.cbIdx >= 0 && typeof args[meta.cbIdx] === 'function') {
1017      return scheduleMacroTaskWithCurrentZone(meta.name, args[meta.cbIdx], meta, scheduleTask);
1018    } else {
1019      // cause an error by calling it directly.
1020      return delegate.apply(self, args);
1021    }
1022  });
1023}
1024function attachOriginToPatched(patched, original) {
1025  patched[zoneSymbol('OriginalDelegate')] = original;
1026}
1027let isDetectedIEOrEdge = false;
1028let ieOrEdge = false;
1029function isIE() {
1030  try {
1031    const ua = internalWindow.navigator.userAgent;
1032    if (ua.indexOf('MSIE ') !== -1 || ua.indexOf('Trident/') !== -1) {
1033      return true;
1034    }
1035  } catch (error) {}
1036  return false;
1037}
1038function isIEOrEdge() {
1039  if (isDetectedIEOrEdge) {
1040    return ieOrEdge;
1041  }
1042  isDetectedIEOrEdge = true;
1043  try {
1044    const ua = internalWindow.navigator.userAgent;
1045    if (ua.indexOf('MSIE ') !== -1 || ua.indexOf('Trident/') !== -1 || ua.indexOf('Edge/') !== -1) {
1046      ieOrEdge = true;
1047    }
1048  } catch (error) {}
1049  return ieOrEdge;
1050}
1051
1052/**
1053 * @fileoverview
1054 * @suppress {missingRequire}
1055 */
1056let passiveSupported = false;
1057if (typeof window !== 'undefined') {
1058  try {
1059    const options = Object.defineProperty({}, 'passive', {
1060      get: function () {
1061        passiveSupported = true;
1062      }
1063    });
1064    // Note: We pass the `options` object as the event handler too. This is not compatible with the
1065    // signature of `addEventListener` or `removeEventListener` but enables us to remove the handler
1066    // without an actual handler.
1067    window.addEventListener('test', options, options);
1068    window.removeEventListener('test', options, options);
1069  } catch (err) {
1070    passiveSupported = false;
1071  }
1072}
1073// an identifier to tell ZoneTask do not create a new invoke closure
1074const OPTIMIZED_ZONE_EVENT_TASK_DATA = {
1075  useG: true
1076};
1077const zoneSymbolEventNames = {};
1078const globalSources = {};
1079const EVENT_NAME_SYMBOL_REGX = new RegExp('^' + ZONE_SYMBOL_PREFIX + '(\\w+)(true|false)$');
1080const IMMEDIATE_PROPAGATION_SYMBOL = zoneSymbol('propagationStopped');
1081function prepareEventNames(eventName, eventNameToString) {
1082  const falseEventName = (eventNameToString ? eventNameToString(eventName) : eventName) + FALSE_STR;
1083  const trueEventName = (eventNameToString ? eventNameToString(eventName) : eventName) + TRUE_STR;
1084  const symbol = ZONE_SYMBOL_PREFIX + falseEventName;
1085  const symbolCapture = ZONE_SYMBOL_PREFIX + trueEventName;
1086  zoneSymbolEventNames[eventName] = {};
1087  zoneSymbolEventNames[eventName][FALSE_STR] = symbol;
1088  zoneSymbolEventNames[eventName][TRUE_STR] = symbolCapture;
1089}
1090function patchEventTarget(_global, api, apis, patchOptions) {
1091  const ADD_EVENT_LISTENER = patchOptions && patchOptions.add || ADD_EVENT_LISTENER_STR;
1092  const REMOVE_EVENT_LISTENER = patchOptions && patchOptions.rm || REMOVE_EVENT_LISTENER_STR;
1093  const LISTENERS_EVENT_LISTENER = patchOptions && patchOptions.listeners || 'eventListeners';
1094  const REMOVE_ALL_LISTENERS_EVENT_LISTENER = patchOptions && patchOptions.rmAll || 'removeAllListeners';
1095  const zoneSymbolAddEventListener = zoneSymbol(ADD_EVENT_LISTENER);
1096  const ADD_EVENT_LISTENER_SOURCE = '.' + ADD_EVENT_LISTENER + ':';
1097  const PREPEND_EVENT_LISTENER = 'prependListener';
1098  const PREPEND_EVENT_LISTENER_SOURCE = '.' + PREPEND_EVENT_LISTENER + ':';
1099  const invokeTask = function (task, target, event) {
1100    // for better performance, check isRemoved which is set
1101    // by removeEventListener
1102    if (task.isRemoved) {
1103      return;
1104    }
1105    const delegate = task.callback;
1106    if (typeof delegate === 'object' && delegate.handleEvent) {
1107      // create the bind version of handleEvent when invoke
1108      task.callback = event => delegate.handleEvent(event);
1109      task.originalDelegate = delegate;
1110    }
1111    // invoke static task.invoke
1112    // need to try/catch error here, otherwise, the error in one event listener
1113    // will break the executions of the other event listeners. Also error will
1114    // not remove the event listener when `once` options is true.
1115    let error;
1116    try {
1117      task.invoke(task, target, [event]);
1118    } catch (err) {
1119      error = err;
1120    }
1121    const options = task.options;
1122    if (options && typeof options === 'object' && options.once) {
1123      // if options.once is true, after invoke once remove listener here
1124      // only browser need to do this, nodejs eventEmitter will cal removeListener
1125      // inside EventEmitter.once
1126      const delegate = task.originalDelegate ? task.originalDelegate : task.callback;
1127      target[REMOVE_EVENT_LISTENER].call(target, event.type, delegate, options);
1128    }
1129    return error;
1130  };
1131  function globalCallback(context, event, isCapture) {
1132    // https://github.com/angular/zone.js/issues/911, in IE, sometimes
1133    // event will be undefined, so we need to use window.event
1134    event = event || _global.event;
1135    if (!event) {
1136      return;
1137    }
1138    // event.target is needed for Samsung TV and SourceBuffer
1139    // || global is needed https://github.com/angular/zone.js/issues/190
1140    const target = context || event.target || _global;
1141    const tasks = target[zoneSymbolEventNames[event.type][isCapture ? TRUE_STR : FALSE_STR]];
1142    if (tasks) {
1143      const errors = [];
1144      // invoke all tasks which attached to current target with given event.type and capture = false
1145      // for performance concern, if task.length === 1, just invoke
1146      if (tasks.length === 1) {
1147        const err = invokeTask(tasks[0], target, event);
1148        err && errors.push(err);
1149      } else {
1150        // https://github.com/angular/zone.js/issues/836
1151        // copy the tasks array before invoke, to avoid
1152        // the callback will remove itself or other listener
1153        const copyTasks = tasks.slice();
1154        for (let i = 0; i < copyTasks.length; i++) {
1155          if (event && event[IMMEDIATE_PROPAGATION_SYMBOL] === true) {
1156            break;
1157          }
1158          const err = invokeTask(copyTasks[i], target, event);
1159          err && errors.push(err);
1160        }
1161      }
1162      // Since there is only one error, we don't need to schedule microTask
1163      // to throw the error.
1164      if (errors.length === 1) {
1165        throw errors[0];
1166      } else {
1167        for (let i = 0; i < errors.length; i++) {
1168          const err = errors[i];
1169          api.nativeScheduleMicroTask(() => {
1170            throw err;
1171          });
1172        }
1173      }
1174    }
1175  }
1176  // global shared zoneAwareCallback to handle all event callback with capture = false
1177  const globalZoneAwareCallback = function (event) {
1178    return globalCallback(this, event, false);
1179  };
1180  // global shared zoneAwareCallback to handle all event callback with capture = true
1181  const globalZoneAwareCaptureCallback = function (event) {
1182    return globalCallback(this, event, true);
1183  };
1184  function patchEventTargetMethods(obj, patchOptions) {
1185    if (!obj) {
1186      return false;
1187    }
1188    let useGlobalCallback = true;
1189    if (patchOptions && patchOptions.useG !== undefined) {
1190      useGlobalCallback = patchOptions.useG;
1191    }
1192    const validateHandler = patchOptions && patchOptions.vh;
1193    let checkDuplicate = true;
1194    if (patchOptions && patchOptions.chkDup !== undefined) {
1195      checkDuplicate = patchOptions.chkDup;
1196    }
1197    let returnTarget = false;
1198    if (patchOptions && patchOptions.rt !== undefined) {
1199      returnTarget = patchOptions.rt;
1200    }
1201    let proto = obj;
1202    while (proto && !proto.hasOwnProperty(ADD_EVENT_LISTENER)) {
1203      proto = ObjectGetPrototypeOf(proto);
1204    }
1205    if (!proto && obj[ADD_EVENT_LISTENER]) {
1206      // somehow we did not find it, but we can see it. This happens on IE for Window properties.
1207      proto = obj;
1208    }
1209    if (!proto) {
1210      return false;
1211    }
1212    if (proto[zoneSymbolAddEventListener]) {
1213      return false;
1214    }
1215    const eventNameToString = patchOptions && patchOptions.eventNameToString;
1216    // a shared global taskData to pass data for scheduleEventTask
1217    // so we do not need to create a new object just for pass some data
1218    const taskData = {};
1219    const nativeAddEventListener = proto[zoneSymbolAddEventListener] = proto[ADD_EVENT_LISTENER];
1220    const nativeRemoveEventListener = proto[zoneSymbol(REMOVE_EVENT_LISTENER)] = proto[REMOVE_EVENT_LISTENER];
1221    const nativeListeners = proto[zoneSymbol(LISTENERS_EVENT_LISTENER)] = proto[LISTENERS_EVENT_LISTENER];
1222    const nativeRemoveAllListeners = proto[zoneSymbol(REMOVE_ALL_LISTENERS_EVENT_LISTENER)] = proto[REMOVE_ALL_LISTENERS_EVENT_LISTENER];
1223    let nativePrependEventListener;
1224    if (patchOptions && patchOptions.prepend) {
1225      nativePrependEventListener = proto[zoneSymbol(patchOptions.prepend)] = proto[patchOptions.prepend];
1226    }
1227    /**
1228     * This util function will build an option object with passive option
1229     * to handle all possible input from the user.
1230     */
1231    function buildEventListenerOptions(options, passive) {
1232      if (!passiveSupported && typeof options === 'object' && options) {
1233        // doesn't support passive but user want to pass an object as options.
1234        // this will not work on some old browser, so we just pass a boolean
1235        // as useCapture parameter
1236        return !!options.capture;
1237      }
1238      if (!passiveSupported || !passive) {
1239        return options;
1240      }
1241      if (typeof options === 'boolean') {
1242        return {
1243          capture: options,
1244          passive: true
1245        };
1246      }
1247      if (!options) {
1248        return {
1249          passive: true
1250        };
1251      }
1252      if (typeof options === 'object' && options.passive !== false) {
1253        return {
1254          ...options,
1255          passive: true
1256        };
1257      }
1258      return options;
1259    }
1260    const customScheduleGlobal = function (task) {
1261      // if there is already a task for the eventName + capture,
1262      // just return, because we use the shared globalZoneAwareCallback here.
1263      if (taskData.isExisting) {
1264        return;
1265      }
1266      return nativeAddEventListener.call(taskData.target, taskData.eventName, taskData.capture ? globalZoneAwareCaptureCallback : globalZoneAwareCallback, taskData.options);
1267    };
1268    const customCancelGlobal = function (task) {
1269      // if task is not marked as isRemoved, this call is directly
1270      // from Zone.prototype.cancelTask, we should remove the task
1271      // from tasksList of target first
1272      if (!task.isRemoved) {
1273        const symbolEventNames = zoneSymbolEventNames[task.eventName];
1274        let symbolEventName;
1275        if (symbolEventNames) {
1276          symbolEventName = symbolEventNames[task.capture ? TRUE_STR : FALSE_STR];
1277        }
1278        const existingTasks = symbolEventName && task.target[symbolEventName];
1279        if (existingTasks) {
1280          for (let i = 0; i < existingTasks.length; i++) {
1281            const existingTask = existingTasks[i];
1282            if (existingTask === task) {
1283              existingTasks.splice(i, 1);
1284              // set isRemoved to data for faster invokeTask check
1285              task.isRemoved = true;
1286              if (existingTasks.length === 0) {
1287                // all tasks for the eventName + capture have gone,
1288                // remove globalZoneAwareCallback and remove the task cache from target
1289                task.allRemoved = true;
1290                task.target[symbolEventName] = null;
1291              }
1292              break;
1293            }
1294          }
1295        }
1296      }
1297      // if all tasks for the eventName + capture have gone,
1298      // we will really remove the global event callback,
1299      // if not, return
1300      if (!task.allRemoved) {
1301        return;
1302      }
1303      return nativeRemoveEventListener.call(task.target, task.eventName, task.capture ? globalZoneAwareCaptureCallback : globalZoneAwareCallback, task.options);
1304    };
1305    const customScheduleNonGlobal = function (task) {
1306      return nativeAddEventListener.call(taskData.target, taskData.eventName, task.invoke, taskData.options);
1307    };
1308    const customSchedulePrepend = function (task) {
1309      return nativePrependEventListener.call(taskData.target, taskData.eventName, task.invoke, taskData.options);
1310    };
1311    const customCancelNonGlobal = function (task) {
1312      return nativeRemoveEventListener.call(task.target, task.eventName, task.invoke, task.options);
1313    };
1314    const customSchedule = useGlobalCallback ? customScheduleGlobal : customScheduleNonGlobal;
1315    const customCancel = useGlobalCallback ? customCancelGlobal : customCancelNonGlobal;
1316    const compareTaskCallbackVsDelegate = function (task, delegate) {
1317      const typeOfDelegate = typeof delegate;
1318      return typeOfDelegate === 'function' && task.callback === delegate || typeOfDelegate === 'object' && task.originalDelegate === delegate;
1319    };
1320    const compare = patchOptions && patchOptions.diff ? patchOptions.diff : compareTaskCallbackVsDelegate;
1321    const unpatchedEvents = Zone[zoneSymbol('UNPATCHED_EVENTS')];
1322    const passiveEvents = _global[zoneSymbol('PASSIVE_EVENTS')];
1323    const makeAddListener = function (nativeListener, addSource, customScheduleFn, customCancelFn, returnTarget = false, prepend = false) {
1324      return function () {
1325        const target = this || _global;
1326        let eventName = arguments[0];
1327        if (patchOptions && patchOptions.transferEventName) {
1328          eventName = patchOptions.transferEventName(eventName);
1329        }
1330        let delegate = arguments[1];
1331        if (!delegate) {
1332          return nativeListener.apply(this, arguments);
1333        }
1334        if (isNode && eventName === 'uncaughtException') {
1335          // don't patch uncaughtException of nodejs to prevent endless loop
1336          return nativeListener.apply(this, arguments);
1337        }
1338        // don't create the bind delegate function for handleEvent
1339        // case here to improve addEventListener performance
1340        // we will create the bind delegate when invoke
1341        let isHandleEvent = false;
1342        if (typeof delegate !== 'function') {
1343          if (!delegate.handleEvent) {
1344            return nativeListener.apply(this, arguments);
1345          }
1346          isHandleEvent = true;
1347        }
1348        if (validateHandler && !validateHandler(nativeListener, delegate, target, arguments)) {
1349          return;
1350        }
1351        const passive = passiveSupported && !!passiveEvents && passiveEvents.indexOf(eventName) !== -1;
1352        const options = buildEventListenerOptions(arguments[2], passive);
1353        const signal = options?.signal;
1354        if (signal?.aborted) {
1355          // the signal is an aborted one, just return without attaching the event listener.
1356          return;
1357        }
1358        if (unpatchedEvents) {
1359          // check unpatched list
1360          for (let i = 0; i < unpatchedEvents.length; i++) {
1361            if (eventName === unpatchedEvents[i]) {
1362              if (passive) {
1363                return nativeListener.call(target, eventName, delegate, options);
1364              } else {
1365                return nativeListener.apply(this, arguments);
1366              }
1367            }
1368          }
1369        }
1370        const capture = !options ? false : typeof options === 'boolean' ? true : options.capture;
1371        const once = options && typeof options === 'object' ? options.once : false;
1372        const zone = Zone.current;
1373        let symbolEventNames = zoneSymbolEventNames[eventName];
1374        if (!symbolEventNames) {
1375          prepareEventNames(eventName, eventNameToString);
1376          symbolEventNames = zoneSymbolEventNames[eventName];
1377        }
1378        const symbolEventName = symbolEventNames[capture ? TRUE_STR : FALSE_STR];
1379        let existingTasks = target[symbolEventName];
1380        let isExisting = false;
1381        if (existingTasks) {
1382          // already have task registered
1383          isExisting = true;
1384          if (checkDuplicate) {
1385            for (let i = 0; i < existingTasks.length; i++) {
1386              if (compare(existingTasks[i], delegate)) {
1387                // same callback, same capture, same event name, just return
1388                return;
1389              }
1390            }
1391          }
1392        } else {
1393          existingTasks = target[symbolEventName] = [];
1394        }
1395        let source;
1396        const constructorName = target.constructor['name'];
1397        const targetSource = globalSources[constructorName];
1398        if (targetSource) {
1399          source = targetSource[eventName];
1400        }
1401        if (!source) {
1402          source = constructorName + addSource + (eventNameToString ? eventNameToString(eventName) : eventName);
1403        }
1404        // do not create a new object as task.data to pass those things
1405        // just use the global shared one
1406        taskData.options = options;
1407        if (once) {
1408          // if addEventListener with once options, we don't pass it to
1409          // native addEventListener, instead we keep the once setting
1410          // and handle ourselves.
1411          taskData.options.once = false;
1412        }
1413        taskData.target = target;
1414        taskData.capture = capture;
1415        taskData.eventName = eventName;
1416        taskData.isExisting = isExisting;
1417        const data = useGlobalCallback ? OPTIMIZED_ZONE_EVENT_TASK_DATA : undefined;
1418        // keep taskData into data to allow onScheduleEventTask to access the task information
1419        if (data) {
1420          data.taskData = taskData;
1421        }
1422        if (signal) {
1423          // if addEventListener with signal options, we don't pass it to
1424          // native addEventListener, instead we keep the signal setting
1425          // and handle ourselves.
1426          taskData.options.signal = undefined;
1427        }
1428        const task = zone.scheduleEventTask(source, delegate, data, customScheduleFn, customCancelFn);
1429        if (signal) {
1430          // after task is scheduled, we need to store the signal back to task.options
1431          taskData.options.signal = signal;
1432          // Wrapping `task` in a weak reference would not prevent memory leaks. Weak references are
1433          // primarily used for preventing strong references cycles. `onAbort` is always reachable
1434          // as it's an event listener, so its closure retains a strong reference to the `task`.
1435          const onAbort = () => task.zone.cancelTask(task);
1436          nativeListener.call(signal, 'abort', onAbort, {
1437            once: true
1438          });
1439          // We need to remove the `abort` listener when the event listener is going to be removed,
1440          // as it creates a closure that captures `task`. This closure retains a reference to the
1441          // `task` object even after it goes out of scope, preventing `task` from being garbage
1442          // collected.
1443          if (data) {
1444            data.removeAbortListener = () => signal.removeEventListener('abort', onAbort);
1445          }
1446        }
1447        // should clear taskData.target to avoid memory leak
1448        // issue, https://github.com/angular/angular/issues/20442
1449        taskData.target = null;
1450        // need to clear up taskData because it is a global object
1451        if (data) {
1452          data.taskData = null;
1453        }
1454        // have to save those information to task in case
1455        // application may call task.zone.cancelTask() directly
1456        if (once) {
1457          options.once = true;
1458        }
1459        if (!(!passiveSupported && typeof task.options === 'boolean')) {
1460          // if not support passive, and we pass an option object
1461          // to addEventListener, we should save the options to task
1462          task.options = options;
1463        }
1464        task.target = target;
1465        task.capture = capture;
1466        task.eventName = eventName;
1467        if (isHandleEvent) {
1468          // save original delegate for compare to check duplicate
1469          task.originalDelegate = delegate;
1470        }
1471        if (!prepend) {
1472          existingTasks.push(task);
1473        } else {
1474          existingTasks.unshift(task);
1475        }
1476        if (returnTarget) {
1477          return target;
1478        }
1479      };
1480    };
1481    proto[ADD_EVENT_LISTENER] = makeAddListener(nativeAddEventListener, ADD_EVENT_LISTENER_SOURCE, customSchedule, customCancel, returnTarget);
1482    if (nativePrependEventListener) {
1483      proto[PREPEND_EVENT_LISTENER] = makeAddListener(nativePrependEventListener, PREPEND_EVENT_LISTENER_SOURCE, customSchedulePrepend, customCancel, returnTarget, true);
1484    }
1485    proto[REMOVE_EVENT_LISTENER] = function () {
1486      const target = this || _global;
1487      let eventName = arguments[0];
1488      if (patchOptions && patchOptions.transferEventName) {
1489        eventName = patchOptions.transferEventName(eventName);
1490      }
1491      const options = arguments[2];
1492      const capture = !options ? false : typeof options === 'boolean' ? true : options.capture;
1493      const delegate = arguments[1];
1494      if (!delegate) {
1495        return nativeRemoveEventListener.apply(this, arguments);
1496      }
1497      if (validateHandler && !validateHandler(nativeRemoveEventListener, delegate, target, arguments)) {
1498        return;
1499      }
1500      const symbolEventNames = zoneSymbolEventNames[eventName];
1501      let symbolEventName;
1502      if (symbolEventNames) {
1503        symbolEventName = symbolEventNames[capture ? TRUE_STR : FALSE_STR];
1504      }
1505      const existingTasks = symbolEventName && target[symbolEventName];
1506      if (existingTasks) {
1507        for (let i = 0; i < existingTasks.length; i++) {
1508          const existingTask = existingTasks[i];
1509          if (compare(existingTask, delegate)) {
1510            existingTasks.splice(i, 1);
1511            // set isRemoved to data for faster invokeTask check
1512            existingTask.isRemoved = true;
1513            if (existingTasks.length === 0) {
1514              // all tasks for the eventName + capture have gone,
1515              // remove globalZoneAwareCallback and remove the task cache from target
1516              existingTask.allRemoved = true;
1517              target[symbolEventName] = null;
1518              // in the target, we have an event listener which is added by on_property
1519              // such as target.onclick = function() {}, so we need to clear this internal
1520              // property too if all delegates with capture=false were removed
1521              // https:// github.com/angular/angular/issues/31643
1522              // https://github.com/angular/angular/issues/54581
1523              if (!capture && typeof eventName === 'string') {
1524                const onPropertySymbol = ZONE_SYMBOL_PREFIX + 'ON_PROPERTY' + eventName;
1525                target[onPropertySymbol] = null;
1526              }
1527            }
1528            // Note that `removeAllListeners` would ultimately call `removeEventListener`,
1529            // so we're safe to remove the abort listener only once here.
1530            const taskData = existingTask.data;
1531            if (taskData?.removeAbortListener) {
1532              taskData.removeAbortListener();
1533              taskData.removeAbortListener = null;
1534            }
1535            existingTask.zone.cancelTask(existingTask);
1536            if (returnTarget) {
1537              return target;
1538            }
1539            return;
1540          }
1541        }
1542      }
1543      // issue 930, didn't find the event name or callback
1544      // from zone kept existingTasks, the callback maybe
1545      // added outside of zone, we need to call native removeEventListener
1546      // to try to remove it.
1547      return nativeRemoveEventListener.apply(this, arguments);
1548    };
1549    proto[LISTENERS_EVENT_LISTENER] = function () {
1550      const target = this || _global;
1551      let eventName = arguments[0];
1552      if (patchOptions && patchOptions.transferEventName) {
1553        eventName = patchOptions.transferEventName(eventName);
1554      }
1555      const listeners = [];
1556      const tasks = findEventTasks(target, eventNameToString ? eventNameToString(eventName) : eventName);
1557      for (let i = 0; i < tasks.length; i++) {
1558        const task = tasks[i];
1559        let delegate = task.originalDelegate ? task.originalDelegate : task.callback;
1560        listeners.push(delegate);
1561      }
1562      return listeners;
1563    };
1564    proto[REMOVE_ALL_LISTENERS_EVENT_LISTENER] = function () {
1565      const target = this || _global;
1566      let eventName = arguments[0];
1567      if (!eventName) {
1568        const keys = Object.keys(target);
1569        for (let i = 0; i < keys.length; i++) {
1570          const prop = keys[i];
1571          const match = EVENT_NAME_SYMBOL_REGX.exec(prop);
1572          let evtName = match && match[1];
1573          // in nodejs EventEmitter, removeListener event is
1574          // used for monitoring the removeListener call,
1575          // so just keep removeListener eventListener until
1576          // all other eventListeners are removed
1577          if (evtName && evtName !== 'removeListener') {
1578            this[REMOVE_ALL_LISTENERS_EVENT_LISTENER].call(this, evtName);
1579          }
1580        }
1581        // remove removeListener listener finally
1582        this[REMOVE_ALL_LISTENERS_EVENT_LISTENER].call(this, 'removeListener');
1583      } else {
1584        if (patchOptions && patchOptions.transferEventName) {
1585          eventName = patchOptions.transferEventName(eventName);
1586        }
1587        const symbolEventNames = zoneSymbolEventNames[eventName];
1588        if (symbolEventNames) {
1589          const symbolEventName = symbolEventNames[FALSE_STR];
1590          const symbolCaptureEventName = symbolEventNames[TRUE_STR];
1591          const tasks = target[symbolEventName];
1592          const captureTasks = target[symbolCaptureEventName];
1593          if (tasks) {
1594            const removeTasks = tasks.slice();
1595            for (let i = 0; i < removeTasks.length; i++) {
1596              const task = removeTasks[i];
1597              let delegate = task.originalDelegate ? task.originalDelegate : task.callback;
1598              this[REMOVE_EVENT_LISTENER].call(this, eventName, delegate, task.options);
1599            }
1600          }
1601          if (captureTasks) {
1602            const removeTasks = captureTasks.slice();
1603            for (let i = 0; i < removeTasks.length; i++) {
1604              const task = removeTasks[i];
1605              let delegate = task.originalDelegate ? task.originalDelegate : task.callback;
1606              this[REMOVE_EVENT_LISTENER].call(this, eventName, delegate, task.options);
1607            }
1608          }
1609        }
1610      }
1611      if (returnTarget) {
1612        return this;
1613      }
1614    };
1615    // for native toString patch
1616    attachOriginToPatched(proto[ADD_EVENT_LISTENER], nativeAddEventListener);
1617    attachOriginToPatched(proto[REMOVE_EVENT_LISTENER], nativeRemoveEventListener);
1618    if (nativeRemoveAllListeners) {
1619      attachOriginToPatched(proto[REMOVE_ALL_LISTENERS_EVENT_LISTENER], nativeRemoveAllListeners);
1620    }
1621    if (nativeListeners) {
1622      attachOriginToPatched(proto[LISTENERS_EVENT_LISTENER], nativeListeners);
1623    }
1624    return true;
1625  }
1626  let results = [];
1627  for (let i = 0; i < apis.length; i++) {
1628    results[i] = patchEventTargetMethods(apis[i], patchOptions);
1629  }
1630  return results;
1631}
1632function findEventTasks(target, eventName) {
1633  if (!eventName) {
1634    const foundTasks = [];
1635    for (let prop in target) {
1636      const match = EVENT_NAME_SYMBOL_REGX.exec(prop);
1637      let evtName = match && match[1];
1638      if (evtName && (!eventName || evtName === eventName)) {
1639        const tasks = target[prop];
1640        if (tasks) {
1641          for (let i = 0; i < tasks.length; i++) {
1642            foundTasks.push(tasks[i]);
1643          }
1644        }
1645      }
1646    }
1647    return foundTasks;
1648  }
1649  let symbolEventName = zoneSymbolEventNames[eventName];
1650  if (!symbolEventName) {
1651    prepareEventNames(eventName);
1652    symbolEventName = zoneSymbolEventNames[eventName];
1653  }
1654  const captureFalseTasks = target[symbolEventName[FALSE_STR]];
1655  const captureTrueTasks = target[symbolEventName[TRUE_STR]];
1656  if (!captureFalseTasks) {
1657    return captureTrueTasks ? captureTrueTasks.slice() : [];
1658  } else {
1659    return captureTrueTasks ? captureFalseTasks.concat(captureTrueTasks) : captureFalseTasks.slice();
1660  }
1661}
1662function patchEventPrototype(global, api) {
1663  const Event = global['Event'];
1664  if (Event && Event.prototype) {
1665    api.patchMethod(Event.prototype, 'stopImmediatePropagation', delegate => function (self, args) {
1666      self[IMMEDIATE_PROPAGATION_SYMBOL] = true;
1667      // we need to call the native stopImmediatePropagation
1668      // in case in some hybrid application, some part of
1669      // application will be controlled by zone, some are not
1670      delegate && delegate.apply(self, args);
1671    });
1672  }
1673}
1674
1675/**
1676 * @fileoverview
1677 * @suppress {missingRequire}
1678 */
1679function patchQueueMicrotask(global, api) {
1680  api.patchMethod(global, 'queueMicrotask', delegate => {
1681    return function (self, args) {
1682      Zone.current.scheduleMicroTask('queueMicrotask', args[0]);
1683    };
1684  });
1685}
1686
1687/**
1688 * @fileoverview
1689 * @suppress {missingRequire}
1690 */
1691const taskSymbol = zoneSymbol('zoneTask');
1692function patchTimer(window, setName, cancelName, nameSuffix) {
1693  let setNative = null;
1694  let clearNative = null;
1695  setName += nameSuffix;
1696  cancelName += nameSuffix;
1697  const tasksByHandleId = {};
1698  function scheduleTask(task) {
1699    const data = task.data;
1700    data.args[0] = function () {
1701      return task.invoke.apply(this, arguments);
1702    };

1814  if (Zone[api.symbol('patchEventTarget')]) {
1815    // EventTarget is already patched.
1816    return;
1817  }
1818  const {
1819    eventNames,
1820    zoneSymbolEventNames,
1821    TRUE_STR,
1822    FALSE_STR,
1823    ZONE_SYMBOL_PREFIX
1824  } = api.getGlobalObjects();
1825  //  predefine all __zone_symbol__ + eventName + true/false string
1826  for (let i = 0; i < eventNames.length; i++) {
1827    const eventName = eventNames[i];
1828    const falseEventName = eventName + FALSE_STR;
1829    const trueEventName = eventName + TRUE_STR;
1830    const symbol = ZONE_SYMBOL_PREFIX + falseEventName;
1831    const symbolCapture = ZONE_SYMBOL_PREFIX + trueEventName;
1832    zoneSymbolEventNames[eventName] = {};
1833    zoneSymbolEventNames[eventName][FALSE_STR] = symbol;
1834    zoneSymbolEventNames[eventName][TRUE_STR] = symbolCapture;
1835  }
1836  const EVENT_TARGET = _global['EventTarget'];
1837  if (!EVENT_TARGET || !EVENT_TARGET.prototype) {
1838    return;
1839  }
1840  api.patchEventTarget(_global, api, [EVENT_TARGET && EVENT_TARGET.prototype]);
1841  return true;
1842}
1843function patchEvent(global, api) {
1844  api.patchEventPrototype(global, api);
1845}
1846
1847/**
1848 * @fileoverview
1849 * @suppress {globalThis}
1850 */
1851function filterProperties(target, onProperties, ignoreProperties) {
1852  if (!ignoreProperties || ignoreProperties.length === 0) {
1853    return onProperties;
1854  }
1855  const tip = ignoreProperties.filter(ip => ip.target === target);
1856  if (!tip || tip.length === 0) {
1857    return onProperties;
1858  }
1859  const targetIgnoreProperties = tip[0].ignoreProperties;
1860  return onProperties.filter(op => targetIgnoreProperties.indexOf(op) === -1);
1861}
1862function patchFilteredProperties(target, onProperties, ignoreProperties, prototype) {
1863  // check whether target is available, sometimes target will be undefined
1864  // because different browser or some 3rd party plugin.
1865  if (!target) {
1866    return;
1867  }
1868  const filteredProperties = filterProperties(target, onProperties, ignoreProperties);
1869  patchOnProperties(target, filteredProperties, prototype);
1870}
1871/**
1872 * Get all event name properties which the event name startsWith `on`
1873 * from the target object itself, inherited properties are not considered.
1874 */
1875function getOnEventNames(target) {
1876  return Object.getOwnPropertyNames(target).filter(name => name.startsWith('on') && name.length > 2).map(name => name.substring(2));
1877}
1878function propertyDescriptorPatch(api, _global) {
1879  if (isNode && !isMix) {
1880    return;
1881  }
1882  if (Zone[api.symbol('patchEvents')]) {
1883    // events are already been patched by legacy patch.
1884    return;
1885  }
1886  const ignoreProperties = _global['__Zone_ignore_on_properties'];
1887  // for browsers that we can patch the descriptor:  Chrome & Firefox
1888  let patchTargets = [];
1889  if (isBrowser) {
1890    const internalWindow = window;
1891    patchTargets = patchTargets.concat(['Document', 'SVGElement', 'Element', 'HTMLElement', 'HTMLBodyElement', 'HTMLMediaElement', 'HTMLFrameSetElement', 'HTMLFrameElement', 'HTMLIFrameElement', 'HTMLMarqueeElement', 'Worker']);
1892    const ignoreErrorProperties = isIE() ? [{
1893      target: internalWindow,
1894      ignoreProperties: ['error']
1895    }] : [];
1896    // in IE/Edge, onProp not exist in window object, but in WindowPrototype
1897    // so we need to pass WindowPrototype to check onProp exist or not
1898    patchFilteredProperties(internalWindow, getOnEventNames(internalWindow), ignoreProperties ? ignoreProperties.concat(ignoreErrorProperties) : ignoreProperties, ObjectGetPrototypeOf(internalWindow));
1899  }
1900  patchTargets = patchTargets.concat(['XMLHttpRequest', 'XMLHttpRequestEventTarget', 'IDBIndex', 'IDBRequest', 'IDBOpenDBRequest', 'IDBDatabase', 'IDBTransaction', 'IDBCursor', 'WebSocket']);
1901  for (let i = 0; i < patchTargets.length; i++) {
1902    const target = _global[patchTargets[i]];
1903    target && target.prototype && patchFilteredProperties(target.prototype, getOnEventNames(target.prototype), ignoreProperties);
1904  }
1905}
1906
1907/**
1908 * @fileoverview
1909 * @suppress {missingRequire}
1910 */
1911function patchBrowser(Zone) {
1912  Zone.__load_patch('legacy', global => {
1913    const legacyPatch = global[Zone.__symbol__('legacyPatch')];
1914    if (legacyPatch) {
1915      legacyPatch();
1916    }
1917  });
1918  Zone.__load_patch('timers', global => {
1919    const set = 'set';
1920    const clear = 'clear';
1921    patchTimer(global, set, clear, 'Timeout');
1922    patchTimer(global, set, clear, 'Interval');
1923    patchTimer(global, set, clear, 'Immediate');
1924  });
1925  Zone.__load_patch('requestAnimationFrame', global => {
1926    patchTimer(global, 'request', 'cancel', 'AnimationFrame');
1927    patchTimer(global, 'mozRequest', 'mozCancel', 'AnimationFrame');
1928    patchTimer(global, 'webkitRequest', 'webkitCancel', 'AnimationFrame');
1929  });
1930  Zone.__load_patch('blocking', (global, Zone) => {
1931    const blockingMethods = ['alert', 'prompt', 'confirm'];
1932    for (let i = 0; i < blockingMethods.length; i++) {
1933      const name = blockingMethods[i];
1934      patchMethod(global, name, (delegate, symbol, name) => {
1935        return function (s, args) {
1936          return Zone.current.run(delegate, global, args, name);
1937        };
1938      });
1939    }
1940  });
1941  Zone.__load_patch('EventTarget', (global, Zone, api) => {
1942    patchEvent(global, api);
1943    eventTargetPatch(global, api);
1944    // patch XMLHttpRequestEventTarget's addEventListener/removeEventListener
1945    const XMLHttpRequestEventTarget = global['XMLHttpRequestEventTarget'];
1946    if (XMLHttpRequestEventTarget && XMLHttpRequestEventTarget.prototype) {
1947      api.patchEventTarget(global, api, [XMLHttpRequestEventTarget.prototype]);
1948    }
1949  });
1950  Zone.__load_patch('MutationObserver', (global, Zone, api) => {
1951    patchClass('MutationObserver');
1952    patchClass('WebKitMutationObserver');
1953  });
1954  Zone.__load_patch('IntersectionObserver', (global, Zone, api) => {
1955    patchClass('IntersectionObserver');
1956  });
1957  Zone.__load_patch('FileReader', (global, Zone, api) => {
1958    patchClass('FileReader');
1959  });
1960  Zone.__load_patch('on_property', (global, Zone, api) => {
1961    propertyDescriptorPatch(api, global);
1962  });
1963  Zone.__load_patch('customElements', (global, Zone, api) => {
1964    patchCustomElements(global, api);
1965  });
1966  Zone.__load_patch('XHR', (global, Zone) => {
1967    // Treat XMLHttpRequest as a macrotask.
1968    patchXHR(global);
1969    const XHR_TASK = zoneSymbol('xhrTask');
1970    const XHR_SYNC = zoneSymbol('xhrSync');
1971    const XHR_LISTENER = zoneSymbol('xhrListener');
1972    const XHR_SCHEDULED = zoneSymbol('xhrScheduled');
1973    const XHR_URL = zoneSymbol('xhrURL');
1974    const XHR_ERROR_BEFORE_SCHEDULED = zoneSymbol('xhrErrorBeforeScheduled');
1975    function patchXHR(window) {
1976      const XMLHttpRequest = window['XMLHttpRequest'];
1977      if (!XMLHttpRequest) {
1978        // XMLHttpRequest is not available in service worker
1979        return;
1980      }
1981      const XMLHttpRequestPrototype = XMLHttpRequest.prototype;
1982      function findPendingTask(target) {
1983        return target[XHR_TASK];
1984      }
1985      let oriAddListener = XMLHttpRequestPrototype[ZONE_SYMBOL_ADD_EVENT_LISTENER];
1986      let oriRemoveListener = XMLHttpRequestPrototype[ZONE_SYMBOL_REMOVE_EVENT_LISTENER];
1987      if (!oriAddListener) {
1988        const XMLHttpRequestEventTarget = window['XMLHttpRequestEventTarget'];
1989        if (XMLHttpRequestEventTarget) {
1990          const XMLHttpRequestEventTargetPrototype = XMLHttpRequestEventTarget.prototype;
1991          oriAddListener = XMLHttpRequestEventTargetPrototype[ZONE_SYMBOL_ADD_EVENT_LISTENER];
1992          oriRemoveListener = XMLHttpRequestEventTargetPrototype[ZONE_SYMBOL_REMOVE_EVENT_LISTENER];
1993        }
1994      }
1995      const READY_STATE_CHANGE = 'readystatechange';
1996      const SCHEDULED = 'scheduled';
1997      function scheduleTask(task) {
1998        const data = task.data;
1999        const target = data.target;
2000        target[XHR_SCHEDULED] = false;
2001        target[XHR_ERROR_BEFORE_SCHEDULED] = false;
2002        // remove existing event listener
2003        const listener = target[XHR_LISTENER];
2004        if (!oriAddListener) {
2005          oriAddListener = target[ZONE_SYMBOL_ADD_EVENT_LISTENER];
2006          oriRemoveListener = target[ZONE_SYMBOL_REMOVE_EVENT_LISTENER];
2007        }
2008        if (listener) {
2009          oriRemoveListener.call(target, READY_STATE_CHANGE, listener);
2010        }
2011        const newListener = target[XHR_LISTENER] = () => {
2012          if (target.readyState === target.DONE) {
2013            // sometimes on some browsers XMLHttpRequest will fire onreadystatechange with
2014            // readyState=4 multiple times, so we need to check task state here
2015            if (!data.aborted && target[XHR_SCHEDULED] && task.state === SCHEDULED) {
2016              // check whether the xhr has registered onload listener
2017              // if that is the case, the task should invoke after all
2018              // onload listeners finish.
2019              // Also if the request failed without response (status = 0), the load event handler
2020              // will not be triggered, in that case, we should also invoke the placeholder callback
2021              // to close the XMLHttpRequest::send macroTask.
2022              // https://github.com/angular/angular/issues/38795
2023              const loadTasks = target[Zone.__symbol__('loadfalse')];
2024              if (target.status !== 0 && loadTasks && loadTasks.length > 0) {
2025                const oriInvoke = task.invoke;
2026                task.invoke = function () {
2027                  // need to load the tasks again, because in other
2028                  // load listener, they may remove themselves
2029                  const loadTasks = target[Zone.__symbol__('loadfalse')];
2030                  for (let i = 0; i < loadTasks.length; i++) {
2031                    if (loadTasks[i] === task) {
2032                      loadTasks.splice(i, 1);
2033                    }
2034                  }
2035                  if (!data.aborted && task.state === SCHEDULED) {
2036                    oriInvoke.call(task);
2037                  }
2038                };
2039                loadTasks.push(task);
2040              } else {
2041                task.invoke();
2042              }
2043            } else if (!data.aborted && target[XHR_SCHEDULED] === false) {
2044              // error occurs when xhr.send()
2045              target[XHR_ERROR_BEFORE_SCHEDULED] = true;
2046            }
2047          }
2048        };
2049        oriAddListener.call(target, READY_STATE_CHANGE, newListener);
2050        const storedTask = target[XHR_TASK];
2051        if (!storedTask) {
2052          target[XHR_TASK] = task;
2053        }
2054        sendNative.apply(target, data.args);
2055        target[XHR_SCHEDULED] = true;
2056        return task;
2057      }
2058      function placeholderCallback() {}
2059      function clearTask(task) {
2060        const data = task.data;
2061        // Note - ideally, we would call data.target.removeEventListener here, but it's too late
2062        // to prevent it from firing. So instead, we store info for the event listener.
2063        data.aborted = true;
2064        return abortNative.apply(data.target, data.args);
2065      }
2066      const openNative = patchMethod(XMLHttpRequestPrototype, 'open', () => function (self, args) {
2067        self[XHR_SYNC] = args[2] == false;
2068        self[XHR_URL] = args[1];
2069        return openNative.apply(self, args);
2070      });
2071      const XMLHTTPREQUEST_SOURCE = 'XMLHttpRequest.send';
2072      const fetchTaskAborting = zoneSymbol('fetchTaskAborting');
2073      const fetchTaskScheduling = zoneSymbol('fetchTaskScheduling');
2074      const sendNative = patchMethod(XMLHttpRequestPrototype, 'send', () => function (self, args) {
2075        if (Zone.current[fetchTaskScheduling] === true) {
2076          // a fetch is scheduling, so we are using xhr to polyfill fetch
2077          // and because we already schedule macroTask for fetch, we should
2078          // not schedule a macroTask for xhr again
2079          return sendNative.apply(self, args);
2080        }
2081        if (self[XHR_SYNC]) {
2082          // if the XHR is sync there is no task to schedule, just execute the code.
2083          return sendNative.apply(self, args);
2084        } else {
2085          const options = {
2086            target: self,
2087            url: self[XHR_URL],
2088            isPeriodic: false,
2089            args: args,
2090            aborted: false
2091          };
2092          const task = scheduleMacroTaskWithCurrentZone(XMLHTTPREQUEST_SOURCE, placeholderCallback, options, scheduleTask, clearTask);
2093          if (self && self[XHR_ERROR_BEFORE_SCHEDULED] === true && !options.aborted && task.state === SCHEDULED) {
2094            // xhr request throw error when send
2095            // we should invoke task instead of leaving a scheduled
2096            // pending macroTask
2097            task.invoke();
2098          }
2099        }
2100      });
2101      const abortNative = patchMethod(XMLHttpRequestPrototype, 'abort', () => function (self, args) {
2102        const task = findPendingTask(self);
2103        if (task && typeof task.type == 'string') {
2104          // If the XHR has already completed, do nothing.
2105          // If the XHR has already been aborted, do nothing.
2106          // Fix #569, call abort multiple times before done will cause
2107          // macroTask task count be negative number
2108          if (task.cancelFn == null || task.data && task.data.aborted) {
2109            return;
2110          }
2111          task.zone.cancelTask(task);
2112        } else if (Zone.current[fetchTaskAborting] === true) {
2113          // the abort is called from fetch polyfill, we need to call native abort of XHR.
2114          return abortNative.apply(self, args);
2115        }
2116        // Otherwise, we are trying to abort an XHR which has not yet been sent, so there is no
2117        // task
2118        // to cancel. Do nothing.
2119      });
2120    }
2121  });
2122  Zone.__load_patch('geolocation', global => {
2123    /// GEO_LOCATION
2124    if (global['navigator'] && global['navigator'].geolocation) {
2125      patchPrototype(global['navigator'].geolocation, ['getCurrentPosition', 'watchPosition']);
2126    }
2127  });
2128  Zone.__load_patch('PromiseRejectionEvent', (global, Zone) => {
2129    // handle unhandled promise rejection
2130    function findPromiseRejectionHandler(evtName) {
2131      return function (e) {
2132        const eventTasks = findEventTasks(global, evtName);
2133        eventTasks.forEach(eventTask => {
2134          // windows has added unhandledrejection event listener
2135          // trigger the event listener
2136          const PromiseRejectionEvent = global['PromiseRejectionEvent'];
2137          if (PromiseRejectionEvent) {
2138            const evt = new PromiseRejectionEvent(evtName, {
2139              promise: e.promise,
2140              reason: e.rejection
2141            });
2142            eventTask.invoke(evt);
2143          }
2144        });
2145      };
2146    }
2147    if (global['PromiseRejectionEvent']) {
2148      Zone[zoneSymbol('unhandledPromiseRejectionHandler')] = findPromiseRejectionHandler('unhandledrejection');
2149      Zone[zoneSymbol('rejectionHandledHandler')] = findPromiseRejectionHandler('rejectionhandled');
2150    }
2151  });
2152  Zone.__load_patch('queueMicrotask', (global, Zone, api) => {
2153    patchQueueMicrotask(global, api);
2154  });
2155}
2156function patchPromise(Zone) {
2157  Zone.__load_patch('ZoneAwarePromise', (global, Zone, api) => {
2158    const ObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
2159    const ObjectDefineProperty = Object.defineProperty;
2160    function readableObjectToString(obj) {
2161      if (obj && obj.toString === Object.prototype.toString) {
2162        const className = obj.constructor && obj.constructor.name;
2163        return (className ? className : '') + ': ' + JSON.stringify(obj);
2164      }
2165      return obj ? obj.toString() : Object.prototype.toString.call(obj);
2166    }
2167    const __symbol__ = api.symbol;
2168    const _uncaughtPromiseErrors = [];
2169    const isDisableWrappingUncaughtPromiseRejection = global[__symbol__('DISABLE_WRAPPING_UNCAUGHT_PROMISE_REJECTION')] !== false;
2170    const symbolPromise = __symbol__('Promise');
2171    const symbolThen = __symbol__('then');
2172    const creationTrace = '__creationTrace__';
2173    api.onUnhandledError = e => {
2174      if (api.showUncaughtError()) {
2175        const rejection = e && e.rejection;
2176        if (rejection) {
2177          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);
2178        } else {
2179          console.error(e);
2180        }
2181      }
2182    };
2183    api.microtaskDrainDone = () => {
2184      while (_uncaughtPromiseErrors.length) {
2185        const uncaughtPromiseError = _uncaughtPromiseErrors.shift();
2186        try {
2187          uncaughtPromiseError.zone.runGuarded(() => {
2188            if (uncaughtPromiseError.throwOriginal) {
2189              throw uncaughtPromiseError.rejection;
2190            }
2191            throw uncaughtPromiseError;
2192          });
2193        } catch (error) {
2194          handleUnhandledRejection(error);
2195        }
2196      }
2197    };
2198    const UNHANDLED_PROMISE_REJECTION_HANDLER_SYMBOL = __symbol__('unhandledPromiseRejectionHandler');
2199    function handleUnhandledRejection(e) {
2200      api.onUnhandledError(e);
2201      try {
2202        const handler = Zone[UNHANDLED_PROMISE_REJECTION_HANDLER_SYMBOL];
2203        if (typeof handler === 'function') {
2204          handler.call(this, e);
2205        }
2206      } catch (err) {}
2207    }
2208    function isThenable(value) {
2209      return value && value.then;
2210    }
2211    function forwardResolution(value) {
2212      return value;
2213    }
2214    function forwardRejection(rejection) {
2215      return ZoneAwarePromise.reject(rejection);
2216    }
2217    const symbolState = __symbol__('state');
2218    const symbolValue = __symbol__('value');
2219    const symbolFinally = __symbol__('finally');
2220    const symbolParentPromiseValue = __symbol__('parentPromiseValue');
2221    const symbolParentPromiseState = __symbol__('parentPromiseState');
2222    const source = 'Promise.then';
2223    const UNRESOLVED = null;
2224    const RESOLVED = true;
2225    const REJECTED = false;
2226    const REJECTED_NO_CATCH = 0;
2227    function makeResolver(promise, state) {
2228      return v => {
2229        try {
2230          resolvePromise(promise, state, v);
2231        } catch (err) {
2232          resolvePromise(promise, false, err);
2233        }
2234        // Do not return value or you will break the Promise spec.
2235      };
2236    }
2237    const once = function () {
2238      let wasCalled = false;
2239      return function wrapper(wrappedFunction) {
2240        return function () {
2241          if (wasCalled) {
2242            return;
2243          }
2244          wasCalled = true;
2245          wrappedFunction.apply(null, arguments);
2246        };
2247      };
2248    };
2249    const TYPE_ERROR = 'Promise resolved with itself';
2250    const CURRENT_TASK_TRACE_SYMBOL = __symbol__('currentTaskTrace');
2251    // Promise Resolution
2252    function resolvePromise(promise, state, value) {
2253      const onceWrapper = once();
2254      if (promise === value) {
2255        throw new TypeError(TYPE_ERROR);
2256      }
2257      if (promise[symbolState] === UNRESOLVED) {
2258        // should only get value.then once based on promise spec.
2259        let then = null;
2260        try {
2261          if (typeof value === 'object' || typeof value === 'function') {
2262            then = value && value.then;
2263          }
2264        } catch (err) {
2265          onceWrapper(() => {
2266            resolvePromise(promise, false, err);
2267          })();
2268          return promise;
2269        }
2270        // if (value instanceof ZoneAwarePromise) {
2271        if (state !== REJECTED && value instanceof ZoneAwarePromise && value.hasOwnProperty(symbolState) && value.hasOwnProperty(symbolValue) && value[symbolState] !== UNRESOLVED) {
2272          clearRejectedNoCatch(value);
2273          resolvePromise(promise, value[symbolState], value[symbolValue]);
2274        } else if (state !== REJECTED && typeof then === 'function') {
2275          try {
2276            then.call(value, onceWrapper(makeResolver(promise, state)), onceWrapper(makeResolver(promise, false)));
2277          } catch (err) {
2278            onceWrapper(() => {
2279              resolvePromise(promise, false, err);
2280            })();
2281          }
2282        } else {
2283          promise[symbolState] = state;
2284          const queue = promise[symbolValue];
2285          promise[symbolValue] = value;
2286          if (promise[symbolFinally] === symbolFinally) {
2287            // the promise is generated by Promise.prototype.finally
2288            if (state === RESOLVED) {
2289              // the state is resolved, should ignore the value
2290              // and use parent promise value
2291              promise[symbolState] = promise[symbolParentPromiseState];
2292              promise[symbolValue] = promise[symbolParentPromiseValue];
2293            }
2294          }
2295          // record task information in value when error occurs, so we can
2296          // do some additional work such as render longStackTrace
2297          if (state === REJECTED && value instanceof Error) {
2298            // check if longStackTraceZone is here
2299            const trace = Zone.currentTask && Zone.currentTask.data && Zone.currentTask.data[creationTrace];
2300            if (trace) {
2301              // only keep the long stack trace into error when in longStackTraceZone
2302              ObjectDefineProperty(value, CURRENT_TASK_TRACE_SYMBOL, {
2303                configurable: true,
2304                enumerable: false,
2305                writable: true,
2306                value: trace
2307              });
2308            }
2309          }
2310          for (let i = 0; i < queue.length;) {
2311            scheduleResolveOrReject(promise, queue[i++], queue[i++], queue[i++], queue[i++]);
2312          }
2313          if (queue.length == 0 && state == REJECTED) {
2314            promise[symbolState] = REJECTED_NO_CATCH;
2315            let uncaughtPromiseError = value;
2316            try {
2317              // Here we throws a new Error to print more readable error log
2318              // and if the value is not an error, zone.js builds an `Error`
2319              // Object here to attach the stack information.
2320              throw new Error('Uncaught (in promise): ' + readableObjectToString(value) + (value && value.stack ? '\n' + value.stack : ''));
2321            } catch (err) {
2322              uncaughtPromiseError = err;
2323            }
2324            if (isDisableWrappingUncaughtPromiseRejection) {
2325              // If disable wrapping uncaught promise reject
2326              // use the value instead of wrapping it.
2327              uncaughtPromiseError.throwOriginal = true;
2328            }
2329            uncaughtPromiseError.rejection = value;
2330            uncaughtPromiseError.promise = promise;
2331            uncaughtPromiseError.zone = Zone.current;
2332            uncaughtPromiseError.task = Zone.currentTask;
2333            _uncaughtPromiseErrors.push(uncaughtPromiseError);
2334            api.scheduleMicroTask(); // to make sure that it is running
2335          }
2336        }
2337      }
2338      // Resolving an already resolved promise is a noop.
2339      return promise;
2340    }
2341    const REJECTION_HANDLED_HANDLER = __symbol__('rejectionHandledHandler');
2342    function clearRejectedNoCatch(promise) {
2343      if (promise[symbolState] === REJECTED_NO_CATCH) {
2344        // if the promise is rejected no catch status
2345        // and queue.length > 0, means there is a error handler
2346        // here to handle the rejected promise, we should trigger
2347        // windows.rejectionhandled eventHandler or nodejs rejectionHandled
2348        // eventHandler
2349        try {
2350          const handler = Zone[REJECTION_HANDLED_HANDLER];
2351          if (handler && typeof handler === 'function') {
2352            handler.call(this, {
2353              rejection: promise[symbolValue],
2354              promise: promise
2355            });
2356          }
2357        } catch (err) {}
2358        promise[symbolState] = REJECTED;
2359        for (let i = 0; i < _uncaughtPromiseErrors.length; i++) {
2360          if (promise === _uncaughtPromiseErrors[i].promise) {
2361            _uncaughtPromiseErrors.splice(i, 1);
2362          }
2363        }
2364      }
2365    }
2366    function scheduleResolveOrReject(promise, zone, chainPromise, onFulfilled, onRejected) {
2367      clearRejectedNoCatch(promise);
2368      const promiseState = promise[symbolState];
2369      const delegate = promiseState ? typeof onFulfilled === 'function' ? onFulfilled : forwardResolution : typeof onRejected === 'function' ? onRejected : forwardRejection;
2370      zone.scheduleMicroTask(source, () => {
2371        try {
2372          const parentPromiseValue = promise[symbolValue];
2373          const isFinallyPromise = !!chainPromise && symbolFinally === chainPromise[symbolFinally];
2374          if (isFinallyPromise) {
2375            // if the promise is generated from finally call, keep parent promise's state and value
2376            chainPromise[symbolParentPromiseValue] = parentPromiseValue;
2377            chainPromise[symbolParentPromiseState] = promiseState;
2378          }
2379          // should not pass value to finally callback
2380          const value = zone.run(delegate, undefined, isFinallyPromise && delegate !== forwardRejection && delegate !== forwardResolution ? [] : [parentPromiseValue]);
2381          resolvePromise(chainPromise, true, value);
2382        } catch (error) {
2383          // if error occurs, should always return this error
2384          resolvePromise(chainPromise, false, error);
2385        }
2386      }, chainPromise);
2387    }
2388    const ZONE_AWARE_PROMISE_TO_STRING = 'function ZoneAwarePromise() { [native code] }';
2389    const noop = function () {};
2390    const AggregateError = global.AggregateError;
2391    class ZoneAwarePromise {
2392      static toString() {
2393        return ZONE_AWARE_PROMISE_TO_STRING;
2394      }
2395      static resolve(value) {
2396        if (value instanceof ZoneAwarePromise) {
2397          return value;
2398        }
2399        return resolvePromise(new this(null), RESOLVED, value);
2400      }
2401      static reject(error) {
2402        return resolvePromise(new this(null), REJECTED, error);
2403      }
2404      static withResolvers() {
2405        const result = {};
2406        result.promise = new ZoneAwarePromise((res, rej) => {
2407          result.resolve = res;
2408          result.reject = rej;
2409        });
2410        return result;
2411      }
2412      static any(values) {
2413        if (!values || typeof values[Symbol.iterator] !== 'function') {
2414          return Promise.reject(new AggregateError([], 'All promises were rejected'));
2415        }
2416        const promises = [];
2417        let count = 0;
2418        try {
2419          for (let v of values) {
2420            count++;
2421            promises.push(ZoneAwarePromise.resolve(v));
2422          }
2423        } catch (err) {
2424          return Promise.reject(new AggregateError([], 'All promises were rejected'));
2425        }
2426        if (count === 0) {
2427          return Promise.reject(new AggregateError([], 'All promises were rejected'));
2428        }
2429        let finished = false;
2430        const errors = [];
2431        return new ZoneAwarePromise((resolve, reject) => {
2432          for (let i = 0; i < promises.length; i++) {
2433            promises[i].then(v => {
2434              if (finished) {
2435                return;
2436              }
2437              finished = true;
2438              resolve(v);
2439            }, err => {
2440              errors.push(err);
2441              count--;
2442              if (count === 0) {
2443                finished = true;
2444                reject(new AggregateError(errors, 'All promises were rejected'));
2445              }
2446            });
2447          }
2448        });
2449      }
2450      static race(values) {
2451        let resolve;
2452        let reject;
2453        let promise = new this((res, rej) => {
2454          resolve = res;
2455          reject = rej;
2456        });
2457        function onResolve(value) {
2458          resolve(value);
2459        }
2460        function onReject(error) {
2461          reject(error);
2462        }
2463        for (let value of values) {
2464          if (!isThenable(value)) {
2465            value = this.resolve(value);
2466          }
2467          value.then(onResolve, onReject);
2468        }
2469        return promise;
2470      }
2471      static all(values) {
2472        return ZoneAwarePromise.allWithCallback(values);
2473      }
2474      static allSettled(values) {
2475        const P = this && this.prototype instanceof ZoneAwarePromise ? this : ZoneAwarePromise;
2476        return P.allWithCallback(values, {
2477          thenCallback: value => ({
2478            status: 'fulfilled',
2479            value
2480          }),
2481          errorCallback: err => ({
2482            status: 'rejected',
2483            reason: err
2484          })
2485        });
2486      }
2487      static allWithCallback(values, callback) {
2488        let resolve;
2489        let reject;
2490        let promise = new this((res, rej) => {
2491          resolve = res;
2492          reject = rej;
2493        });
2494        // Start at 2 to prevent prematurely resolving if .then is called immediately.
2495        let unresolvedCount = 2;
2496        let valueIndex = 0;
2497        const resolvedValues = [];
2498        for (let value of values) {
2499          if (!isThenable(value)) {
2500            value = this.resolve(value);
2501          }
2502          const curValueIndex = valueIndex;
2503          try {
2504            value.then(value => {
2505              resolvedValues[curValueIndex] = callback ? callback.thenCallback(value) : value;
2506              unresolvedCount--;
2507              if (unresolvedCount === 0) {
2508                resolve(resolvedValues);
2509              }
2510            }, err => {
2511              if (!callback) {
2512                reject(err);
2513              } else {
2514                resolvedValues[curValueIndex] = callback.errorCallback(err);
2515                unresolvedCount--;
2516                if (unresolvedCount === 0) {
2517                  resolve(resolvedValues);
2518                }
2519              }
2520            });
2521          } catch (thenErr) {
2522            reject(thenErr);
2523          }
2524          unresolvedCount++;
2525          valueIndex++;
2526        }
2527        // Make the unresolvedCount zero-based again.
2528        unresolvedCount -= 2;
2529        if (unresolvedCount === 0) {
2530          resolve(resolvedValues);
2531        }
2532        return promise;
2533      }
2534      constructor(executor) {
2535        const promise = this;
2536        if (!(promise instanceof ZoneAwarePromise)) {
2537          throw new Error('Must be an instanceof Promise.');
2538        }
2539        promise[symbolState] = UNRESOLVED;
2540        promise[symbolValue] = []; // queue;
2541        try {
2542          const onceWrapper = once();
2543          executor && executor(onceWrapper(makeResolver(promise, RESOLVED)), onceWrapper(makeResolver(promise, REJECTED)));
2544        } catch (error) {
2545          resolvePromise(promise, false, error);
2546        }
2547      }
2548      get [Symbol.toStringTag]() {
2549        return 'Promise';
2550      }
2551      get [Symbol.species]() {
2552        return ZoneAwarePromise;
2553      }
2554      then(onFulfilled, onRejected) {
2555        // We must read `Symbol.species` safely because `this` may be anything. For instance, `this`
2556        // may be an object without a prototype (created through `Object.create(null)`); thus
2557        // `this.constructor` will be undefined. One of the use cases is SystemJS creating
2558        // prototype-less objects (modules) via `Object.create(null)`. The SystemJS creates an empty
2559        // object and copies promise properties into that object (within the `getOrCreateLoad`
2560        // function). The zone.js then checks if the resolved value has the `then` method and
2561        // invokes it with the `value` context. Otherwise, this will throw an error: `TypeError:
2562        // Cannot read properties of undefined (reading 'Symbol(Symbol.species)')`.
2563        let C = this.constructor?.[Symbol.species];
2564        if (!C || typeof C !== 'function') {
2565          C = this.constructor || ZoneAwarePromise;
2566        }
2567        const chainPromise = new C(noop);
2568        const zone = Zone.current;
2569        if (this[symbolState] == UNRESOLVED) {
2570          this[symbolValue].push(zone, chainPromise, onFulfilled, onRejected);
2571        } else {
2572          scheduleResolveOrReject(this, zone, chainPromise, onFulfilled, onRejected);
2573        }
2574        return chainPromise;
2575      }
2576      catch(onRejected) {
2577        return this.then(null, onRejected);
2578      }
2579      finally(onFinally) {
2580        // See comment on the call to `then` about why thee `Symbol.species` is safely accessed.
2581        let C = this.constructor?.[Symbol.species];
2582        if (!C || typeof C !== 'function') {
2583          C = ZoneAwarePromise;
2584        }
2585        const chainPromise = new C(noop);
2586        chainPromise[symbolFinally] = symbolFinally;
2587        const zone = Zone.current;
2588        if (this[symbolState] == UNRESOLVED) {
2589          this[symbolValue].push(zone, chainPromise, onFinally, onFinally);
2590        } else {
2591          scheduleResolveOrReject(this, zone, chainPromise, onFinally, onFinally);
2592        }
2593        return chainPromise;
2594      }
2595    }
2596    // Protect against aggressive optimizers dropping seemingly unused properties.
2597    // E.g. Closure Compiler in advanced mode.
2598    ZoneAwarePromise['resolve'] = ZoneAwarePromise.resolve;
2599    ZoneAwarePromise['reject'] = ZoneAwarePromise.reject;
2600    ZoneAwarePromise['race'] = ZoneAwarePromise.race;
2601    ZoneAwarePromise['all'] = ZoneAwarePromise.all;
2602    const NativePromise = global[symbolPromise] = global['Promise'];
2603    global['Promise'] = ZoneAwarePromise;
2604    const symbolThenPatched = __symbol__('thenPatched');
2605    function patchThen(Ctor) {
2606      const proto = Ctor.prototype;
2607      const prop = ObjectGetOwnPropertyDescriptor(proto, 'then');
2608      if (prop && (prop.writable === false || !prop.configurable)) {
2609        // check Ctor.prototype.then propertyDescriptor is writable or not
2610        // in meteor env, writable is false, we should ignore such case
2611        return;
2612      }
2613      const originalThen = proto.then;
2614      // Keep a reference to the original method.
2615      proto[symbolThen] = originalThen;
2616      Ctor.prototype.then = function (onResolve, onReject) {
2617        const wrapped = new ZoneAwarePromise((resolve, reject) => {
2618          originalThen.call(this, resolve, reject);
2619        });
2620        return wrapped.then(onResolve, onReject);
2621      };
2622      Ctor[symbolThenPatched] = true;
2623    }
2624    api.patchThen = patchThen;
2625    function zoneify(fn) {
2626      return function (self, args) {
2627        let resultPromise = fn.apply(self, args);
2628        if (resultPromise instanceof ZoneAwarePromise) {
2629          return resultPromise;
2630        }
2631        let ctor = resultPromise.constructor;
2632        if (!ctor[symbolThenPatched]) {
2633          patchThen(ctor);
2634        }
2635        return resultPromise;
2636      };
2637    }
2638    if (NativePromise) {
2639      patchThen(NativePromise);
2640      patchMethod(global, 'fetch', delegate => zoneify(delegate));
2641    }
2642    // This is not part of public API, but it is useful for tests, so we expose it.
2643    Promise[Zone.__symbol__('uncaughtPromiseErrors')] = _uncaughtPromiseErrors;
2644    return ZoneAwarePromise;
2645  });
2646}
2647function patchToString(Zone) {
2648  // override Function.prototype.toString to make zone.js patched function
2649  // look like native function
2650  Zone.__load_patch('toString', global => {
2651    // patch Func.prototype.toString to let them look like native
2652    const originalFunctionToString = Function.prototype.toString;
2653    const ORIGINAL_DELEGATE_SYMBOL = zoneSymbol('OriginalDelegate');
2654    const PROMISE_SYMBOL = zoneSymbol('Promise');
2655    const ERROR_SYMBOL = zoneSymbol('Error');
2656    const newFunctionToString = function toString() {
2657      if (typeof this === 'function') {
2658        const originalDelegate = this[ORIGINAL_DELEGATE_SYMBOL];
2659        if (originalDelegate) {
2660          if (typeof originalDelegate === 'function') {
2661            return originalFunctionToString.call(originalDelegate);
2662          } else {
2663            return Object.prototype.toString.call(originalDelegate);
2664          }
2665        }
2666        if (this === Promise) {
2667          const nativePromise = global[PROMISE_SYMBOL];
2668          if (nativePromise) {
2669            return originalFunctionToString.call(nativePromise);
2670          }
2671        }
2672        if (this === Error) {
2673          const nativeError = global[ERROR_SYMBOL];
2674          if (nativeError) {
2675            return originalFunctionToString.call(nativeError);
2676          }
2677        }
2678      }
2679      return originalFunctionToString.call(this);
2680    };
2681    newFunctionToString[ORIGINAL_DELEGATE_SYMBOL] = originalFunctionToString;
2682    Function.prototype.toString = newFunctionToString;
2683    // patch Object.prototype.toString to let them look like native
2684    const originalObjectToString = Object.prototype.toString;
2685    const PROMISE_OBJECT_TO_STRING = '[object Promise]';
2686    Object.prototype.toString = function () {
2687      if (typeof Promise === 'function' && this instanceof Promise) {
2688        return PROMISE_OBJECT_TO_STRING;
2689      }
2690      return originalObjectToString.call(this);
2691    };
2692  });
2693}
2694function patchCallbacks(api, target, targetName, method, callbacks) {
2695  const symbol = Zone.__symbol__(method);
2696  if (target[symbol]) {
2697    return;
2698  }
2699  const nativeDelegate = target[symbol] = target[method];
2700  target[method] = function (name, opts, options) {
2701    if (opts && opts.prototype) {
2702      callbacks.forEach(function (callback) {
2703        const source = `${targetName}.${method}::` + callback;
2704        const prototype = opts.prototype;
2705        // Note: the `patchCallbacks` is used for patching the `document.registerElement` and
2706        // `customElements.define`. We explicitly wrap the patching code into try-catch since
2707        // callbacks may be already patched by other web components frameworks (e.g. LWC