https://axcoraschool.web.app/polyfills.js

103				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)) :
104    undefined;
105}((function () { 'use strict';
106
107    /**
108     * @license
109     * Copyright Google Inc. All Rights Reserved.
110     *
111     * Use of this source code is governed by an MIT-style license that can be
112     * found in the LICENSE file at https://angular.io/license
113     */
114    const Zone$1 = (function (global) {
115        const performance = global['performance'];
116        function mark(name) { performance && performance['mark'] && performance['mark'](name); }
117        function performanceMeasure(name, label) {
118            performance && performance['measure'] && performance['measure'](name, label);
119        }
120        mark('Zone');
121        // Initialize before it's accessed below.
122        // __Zone_symbol_prefix global can be used to override the default zone
123        // symbol prefix with a custom one if needed.
124        const symbolPrefix = global['__Zone_symbol_prefix'] || '__zone_symbol__';
125        function __symbol__(name) { return symbolPrefix + name; }
126        const checkDuplicate = global[__symbol__('forceDuplicateZoneCheck')] === true;
127        if (global['Zone']) {
128            // if global['Zone'] already exists (maybe zone.js was already loaded or
129            // some other lib also registered a global object named Zone), we may need
130            // to throw an error, but sometimes user may not want this error.
131            // For example,
132            // we have two web pages, page1 includes zone.js, page2 doesn't.
133            // and the 1st time user load page1 and page2, everything work fine,
134            // but when user load page2 again, error occurs because global['Zone'] already exists.
135            // so we add a flag to let user choose whether to throw this error or not.
136            // By default, if existing Zone is from zone.js, we will not throw the error.
137            if (checkDuplicate || typeof global['Zone'].__symbol__ !== 'function') {
138                throw new Error('Zone already loaded.');
139            }
140            else {
141                return global['Zone'];
142            }
143        }
144        class Zone {
145            constructor(parent, zoneSpec) {
146                this._parent = parent;
147                this._name = zoneSpec ? zoneSpec.name || 'unnamed' : '<root>';
148                this._properties = zoneSpec && zoneSpec.properties || {};
149                this._zoneDelegate =
150                    new ZoneDelegate(this, this._parent && this._parent._zoneDelegate, zoneSpec);
151            }
152            static assertZonePatched() {
153                if (global['Promise'] !== patches['ZoneAwarePromise']) {
154                    throw new Error('Zone.js has detected that ZoneAwarePromise `(window|global).Promise` ' +
155                        'has been overwritten.\n' +
156                        'Most likely cause is that a Promise polyfill has been loaded ' +
157                        'after Zone.js (Polyfilling Promise api is not necessary when zone.js is loaded. ' +
158                        'If you must load one, do so before loading zone.js.)');
159                }
160            }
161            static get root() {
162                let zone = Zone.current;
163                while (zone.parent) {
164                    zone = zone.parent;
165                }
166                return zone;
167            }
168            static get current() { return _currentZoneFrame.zone; }
169            static get currentTask() { return _currentTask; }
170            // tslint:disable-next-line:require-internal-with-underscore
171            static __load_patch(name, fn) {
172                if (patches.hasOwnProperty(name)) {
173                    if (checkDuplicate) {
174                        throw Error('Already loaded patch: ' + name);
175                    }
176                }
177                else if (!global['__Zone_disable_' + name]) {
178                    const perfName = 'Zone:' + name;
179                    mark(perfName);
180                    patches[name] = fn(global, Zone, _api);
181                    performanceMeasure(perfName, perfName);
182                }
183            }
184            get parent() { return this._parent; }
185            get name() { return this._name; }
186            get(key) {
187                const zone = this.getZoneWith(key);
188                if (zone)
189                    return zone._properties[key];
190            }
191            getZoneWith(key) {
192                let current = this;
193                while (current) {
194                    if (current._properties.hasOwnProperty(key)) {
195                        return current;
196                    }
197                    current = current._parent;
198                }
199                return null;
200            }
201            fork(zoneSpec) {
202                if (!zoneSpec)
203                    throw new Error('ZoneSpec required!');
204                return this._zoneDelegate.fork(this, zoneSpec);
205            }
206            wrap(callback, source) {
207                if (typeof callback !== 'function') {
208                    throw new Error('Expecting function got: ' + callback);
209                }
210                const _callback = this._zoneDelegate.intercept(this, callback, source);
211                const zone = this;
212                return function () {
213                    return zone.runGuarded(_callback, this, arguments, source);
214                };
215            }
216            run(callback, applyThis, applyArgs, source) {
217                _currentZoneFrame = { parent: _currentZoneFrame, zone: this };
218                try {
219                    return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source);
220                }
221                finally {
222                    _currentZoneFrame = _currentZoneFrame.parent;
223                }
224            }
225            runGuarded(callback, applyThis = null, applyArgs, source) {
226                _currentZoneFrame = { parent: _currentZoneFrame, zone: this };
227                try {
228                    try {
229                        return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source);
230                    }
231                    catch (error) {
232                        if (this._zoneDelegate.handleError(this, error)) {
233                            throw error;
234                        }
235                    }
236                }
237                finally {
238                    _currentZoneFrame = _currentZoneFrame.parent;
239                }
240            }
241            runTask(task, applyThis, applyArgs) {
242                if (task.zone != this) {
243                    throw new Error('A task can only be run in the zone of creation! (Creation: ' +
244                        (task.zone || NO_ZONE).name + '; Execution: ' + this.name + ')');
245                }
246                // https://github.com/angular/zone.js/issues/778, sometimes eventTask
247                // will run in notScheduled(canceled) state, we should not try to
248                // run such kind of task but just return
249                if (task.state === notScheduled && (task.type === eventTask || task.type === macroTask)) {
250                    return;
251                }
252                const reEntryGuard = task.state != running;
253                reEntryGuard && task._transitionTo(running, scheduled);
254                task.runCount++;
255                const previousTask = _currentTask;
256                _currentTask = task;
257                _currentZoneFrame = { parent: _currentZoneFrame, zone: this };
258                try {
259                    if (task.type == macroTask && task.data && !task.data.isPeriodic) {
260                        task.cancelFn = undefined;
261                    }
262                    try {
263                        return this._zoneDelegate.invokeTask(this, task, applyThis, applyArgs);
264                    }
265                    catch (error) {
266                        if (this._zoneDelegate.handleError(this, error)) {
267                            throw error;
268                        }
269                    }
270                }
271                finally {
272                    // if the task's state is notScheduled or unknown, then it has already been cancelled
273                    // we should not reset the state to scheduled
274                    if (task.state !== notScheduled && task.state !== unknown) {
275                        if (task.type == eventTask || (task.data && task.data.isPeriodic)) {
276                            reEntryGuard && task._transitionTo(scheduled, running);
277                        }
278                        else {
279                            task.runCount = 0;
280                            this._updateTaskCount(task, -1);
281                            reEntryGuard &&
282                                task._transitionTo(notScheduled, running, notScheduled);
283                        }
284                    }
285                    _currentZoneFrame = _currentZoneFrame.parent;
286                    _currentTask = previousTask;
287                }
288            }
289            scheduleTask(task) {
290                if (task.zone && task.zone !== this) {
291                    // check if the task was rescheduled, the newZone
292                    // should not be the children of the original zone
293                    let newZone = this;
294                    while (newZone) {
295                        if (newZone === task.zone) {
296                            throw Error(`can not reschedule task to ${this.name} which is descendants of the original zone ${task.zone.name}`);
297                        }
298                        newZone = newZone.parent;
299                    }
300                }
301                task._transitionTo(scheduling, notScheduled);
302                const zoneDelegates = [];
303                task._zoneDelegates = zoneDelegates;
304                task._zone = this;
305                try {
306                    task = this._zoneDelegate.scheduleTask(this, task);
307                }
308                catch (err) {
309                    // should set task's state to unknown when scheduleTask throw error
310                    // because the err may from reschedule, so the fromState maybe notScheduled
311                    task._transitionTo(unknown, scheduling, notScheduled);
312                    // TODO: @JiaLiPassion, should we check the result from handleError?
313                    this._zoneDelegate.handleError(this, err);
314                    throw err;
315                }
316                if (task._zoneDelegates === zoneDelegates) {
317                    // we have to check because internally the delegate can reschedule the task.
318                    this._updateTaskCount(task, 1);
319                }
320                if (task.state == scheduling) {
321                    task._transitionTo(scheduled, scheduling);
322                }
323                return task;
324            }
325            scheduleMicroTask(source, callback, data, customSchedule) {
326                return this.scheduleTask(new ZoneTask(microTask, source, callback, data, customSchedule, undefined));
327            }
328            scheduleMacroTask(source, callback, data, customSchedule, customCancel) {
329                return this.scheduleTask(new ZoneTask(macroTask, source, callback, data, customSchedule, customCancel));
330            }
331            scheduleEventTask(source, callback, data, customSchedule, customCancel) {
332                return this.scheduleTask(new ZoneTask(eventTask, source, callback, data, customSchedule, customCancel));
333            }
334            cancelTask(task) {
335                if (task.zone != this)
336                    throw new Error('A task can only be cancelled in the zone of creation! (Creation: ' +
337                        (task.zone || NO_ZONE).name + '; Execution: ' + this.name + ')');
338                task._transitionTo(canceling, scheduled, running);
339                try {
340                    this._zoneDelegate.cancelTask(this, task);
341                }
342                catch (err) {
343                    // if error occurs when cancelTask, transit the state to unknown
344                    task._transitionTo(unknown, canceling);
345                    this._zoneDelegate.handleError(this, err);
346                    throw err;
347                }
348                this._updateTaskCount(task, -1);
349                task._transitionTo(notScheduled, canceling);
350                task.runCount = 0;
351                return task;
352            }
353            _updateTaskCount(task, count) {
354                const zoneDelegates = task._zoneDelegates;
355                if (count == -1) {
356                    task._zoneDelegates = null;
357                }
358                for (let i = 0; i < zoneDelegates.length; i++) {
359                    zoneDelegates[i]._updateTaskCount(task.type, count);
360                }
361            }
362        }
363        // tslint:disable-next-line:require-internal-with-underscore
364        Zone.__symbol__ = __symbol__;
365        const DELEGATE_ZS = {
366            name: '',
367            onHasTask: (delegate, _, target, hasTaskState) => delegate.hasTask(target, hasTaskState),
368            onScheduleTask: (delegate, _, target, task) => delegate.scheduleTask(target, task),
369            onInvokeTask: (delegate, _, target, task, applyThis, applyArgs) => delegate.invokeTask(target, task, applyThis, applyArgs),
370            onCancelTask: (delegate, _, target, task) => delegate.cancelTask(target, task)
371        };
372        class ZoneDelegate {
373            constructor(zone, parentDelegate, zoneSpec) {
374                this._taskCounts = { 'microTask': 0, 'macroTask': 0, 'eventTask': 0 };
375                this.zone = zone;
376                this._parentDelegate = parentDelegate;
377                this._forkZS =
378                    zoneSpec && (zoneSpec && zoneSpec.onFork ? zoneSpec : parentDelegate._forkZS);
379                this._forkDlgt = zoneSpec && (zoneSpec.onFork ? parentDelegate : parentDelegate._forkDlgt);
380                this._forkCurrZone =
381                    zoneSpec && (zoneSpec.onFork ? this.zone : parentDelegate._forkCurrZone);
382                this._interceptZS =
383                    zoneSpec && (zoneSpec.onIntercept ? zoneSpec : parentDelegate._interceptZS);
384                this._interceptDlgt =
385                    zoneSpec && (zoneSpec.onIntercept ? parentDelegate : parentDelegate._interceptDlgt);
386                this._interceptCurrZone =
387                    zoneSpec && (zoneSpec.onIntercept ? this.zone : parentDelegate._interceptCurrZone);
388                this._invokeZS = zoneSpec && (zoneSpec.onInvoke ? zoneSpec : parentDelegate._invokeZS);
389                this._invokeDlgt =
390                    zoneSpec && (zoneSpec.onInvoke ? parentDelegate : parentDelegate._invokeDlgt);
391                this._invokeCurrZone =
392                    zoneSpec && (zoneSpec.onInvoke ? this.zone : parentDelegate._invokeCurrZone);
393                this._handleErrorZS =
394                    zoneSpec && (zoneSpec.onHandleError ? zoneSpec : parentDelegate._handleErrorZS);
395                this._handleErrorDlgt = zoneSpec &&
396                    (zoneSpec.onHandleError ? parentDelegate : parentDelegate._handleErrorDlgt);
397                this._handleErrorCurrZone =
398                    zoneSpec && (zoneSpec.onHandleError ? this.zone : parentDelegate._handleErrorCurrZone);
399                this._scheduleTaskZS =
400                    zoneSpec && (zoneSpec.onScheduleTask ? zoneSpec : parentDelegate._scheduleTaskZS);
401                this._scheduleTaskDlgt = zoneSpec &&
402                    (zoneSpec.onScheduleTask ? parentDelegate : parentDelegate._scheduleTaskDlgt);
403                this._scheduleTaskCurrZone = zoneSpec &&
404                    (zoneSpec.onScheduleTask ? this.zone : parentDelegate._scheduleTaskCurrZone);
405                this._invokeTaskZS =
406                    zoneSpec && (zoneSpec.onInvokeTask ? zoneSpec : parentDelegate._invokeTaskZS);
407                this._invokeTaskDlgt =
408                    zoneSpec && (zoneSpec.onInvokeTask ? parentDelegate : parentDelegate._invokeTaskDlgt);
409                this._invokeTaskCurrZone =
410                    zoneSpec && (zoneSpec.onInvokeTask ? this.zone : parentDelegate._invokeTaskCurrZone);
411                this._cancelTaskZS =
412                    zoneSpec && (zoneSpec.onCancelTask ? zoneSpec : parentDelegate._cancelTaskZS);
413                this._cancelTaskDlgt =
414                    zoneSpec && (zoneSpec.onCancelTask ? parentDelegate : parentDelegate._cancelTaskDlgt);
415                this._cancelTaskCurrZone =
416                    zoneSpec && (zoneSpec.onCancelTask ? this.zone : parentDelegate._cancelTaskCurrZone);
417                this._hasTaskZS = null;
418                this._hasTaskDlgt = null;
419                this._hasTaskDlgtOwner = null;
420                this._hasTaskCurrZone = null;
421                const zoneSpecHasTask = zoneSpec && zoneSpec.onHasTask;
422                const parentHasTask = parentDelegate && parentDelegate._hasTaskZS;
423                if (zoneSpecHasTask || parentHasTask) {
424                    // If we need to report hasTask, than this ZS needs to do ref counting on tasks. In such
425                    // a case all task related interceptors must go through this ZD. We can't short circuit it.
426                    this._hasTaskZS = zoneSpecHasTask ? zoneSpec : DELEGATE_ZS;
427                    this._hasTaskDlgt = parentDelegate;
428                    this._hasTaskDlgtOwner = this;
429                    this._hasTaskCurrZone = zone;
430                    if (!zoneSpec.onScheduleTask) {
431                        this._scheduleTaskZS = DELEGATE_ZS;
432                        this._scheduleTaskDlgt = parentDelegate;
433                        this._scheduleTaskCurrZone = this.zone;
434                    }
435                    if (!zoneSpec.onInvokeTask) {
436                        this._invokeTaskZS = DELEGATE_ZS;
437                        this._invokeTaskDlgt = parentDelegate;
438                        this._invokeTaskCurrZone = this.zone;
439                    }
440                    if (!zoneSpec.onCancelTask) {
441                        this._cancelTaskZS = DELEGATE_ZS;
442                        this._cancelTaskDlgt = parentDelegate;
443                        this._cancelTaskCurrZone = this.zone;
444                    }
445                }
446            }
447            fork(targetZone, zoneSpec) {
448                return this._forkZS ?
449                    this._forkZS.onFork(this._forkDlgt, this.zone, targetZone, zoneSpec) :
450                    new Zone(targetZone, zoneSpec);
451            }
452            intercept(targetZone, callback, source) {
453                return this._interceptZS ?
454                    this._interceptZS.onIntercept(this._interceptDlgt, this._interceptCurrZone, targetZone, callback, source) :
455                    callback;
456            }
457            invoke(targetZone, callback, applyThis, applyArgs, source) {
458                return this._invokeZS ?
459                    this._invokeZS.onInvoke(this._invokeDlgt, this._invokeCurrZone, targetZone, callback, applyThis, applyArgs, source) :
460                    callback.apply(applyThis, applyArgs);
461            }
462            handleError(targetZone, error) {
463                return this._handleErrorZS ?
464                    this._handleErrorZS.onHandleError(this._handleErrorDlgt, this._handleErrorCurrZone, targetZone, error) :
465                    true;
466            }
467            scheduleTask(targetZone, task) {
468                let returnTask = task;
469                if (this._scheduleTaskZS) {
470                    if (this._hasTaskZS) {
471                        returnTask._zoneDelegates.push(this._hasTaskDlgtOwner);
472                    }
473                    // clang-format off
474                    returnTask = this._scheduleTaskZS.onScheduleTask(this._scheduleTaskDlgt, this._scheduleTaskCurrZone, targetZone, task);
475                    // clang-format on
476                    if (!returnTask)
477                        returnTask = task;
478                }
479                else {
480                    if (task.scheduleFn) {
481                        task.scheduleFn(task);
482                    }
483                    else if (task.type == microTask) {
484                        scheduleMicroTask(task);
485                    }
486                    else {
487                        throw new Error('Task is missing scheduleFn.');
488                    }
489                }
490                return returnTask;
491            }
492            invokeTask(targetZone, task, applyThis, applyArgs) {
493                return this._invokeTaskZS ?
494                    this._invokeTaskZS.onInvokeTask(this._invokeTaskDlgt, this._invokeTaskCurrZone, targetZone, task, applyThis, applyArgs) :
495                    task.callback.apply(applyThis, applyArgs);
496            }
497            cancelTask(targetZone, task) {
498                let value;
499                if (this._cancelTaskZS) {
500                    value = this._cancelTaskZS.onCancelTask(this._cancelTaskDlgt, this._cancelTaskCurrZone, targetZone, task);
501                }
502                else {
503                    if (!task.cancelFn) {
504                        throw Error('Task is not cancelable');
505                    }
506                    value = task.cancelFn(task);
507                }
508                return value;
509            }
510            hasTask(targetZone, isEmpty) {
511                // hasTask should not throw error so other ZoneDelegate
512                // can still trigger hasTask callback
513                try {
514                    this._hasTaskZS &&
515                        this._hasTaskZS.onHasTask(this._hasTaskDlgt, this._hasTaskCurrZone, targetZone, isEmpty);
516                }
517                catch (err) {
518                    this.handleError(targetZone, err);
519                }
520            }
521            // tslint:disable-next-line:require-internal-with-underscore
522            _updateTaskCount(type, count) {
523                const counts = this._taskCounts;
524                const prev = counts[type];
525                const next = counts[type] = prev + count;
526                if (next < 0) {
527                    throw new Error('More tasks executed then were scheduled.');
528                }
529                if (prev == 0 || next == 0) {
530                    const isEmpty = {
531                        microTask: counts['microTask'] > 0,
532                        macroTask: counts['macroTask'] > 0,
533                        eventTask: counts['eventTask'] > 0,
534                        change: type
535                    };
536                    this.hasTask(this.zone, isEmpty);
537                }
538            }
539        }
540        class ZoneTask {
541            constructor(type, source, callback, options, scheduleFn, cancelFn) {
542                // tslint:disable-next-line:require-internal-with-underscore
543                this._zone = null;
544                this.runCount = 0;
545                // tslint:disable-next-line:require-internal-with-underscore
546                this._zoneDelegates = null;
547                // tslint:disable-next-line:require-internal-with-underscore
548                this._state = 'notScheduled';
549                this.type = type;
550                this.source = source;
551                this.data = options;
552                this.scheduleFn = scheduleFn;
553                this.cancelFn = cancelFn;
554                if (!callback) {
555                    throw new Error('callback is not defined');
556                }
557                this.callback = callback;
558                const self = this;
559                // TODO: @JiaLiPassion options should have interface
560                if (type === eventTask && options && options.useG) {
561                    this.invoke = ZoneTask.invokeTask;
562                }
563                else {
564                    this.invoke = function () {
565                        return ZoneTask.invokeTask.call(global, self, this, arguments);
566                    };
567                }
568            }
569            static invokeTask(task, target, args) {
570                if (!task) {
571                    task = this;
572                }
573                _numberOfNestedTaskFrames++;
574                try {
575                    task.runCount++;
576                    return task.zone.runTask(task, target, args);
577                }
578                finally {
579                    if (_numberOfNestedTaskFrames == 1) {
580                        drainMicroTaskQueue();
581                    }
582                    _numberOfNestedTaskFrames--;
583                }
584            }
585            get zone() { return this._zone; }
586            get state() { return this._state; }
587            cancelScheduleRequest() { this._transitionTo(notScheduled, scheduling); }
588            // tslint:disable-next-line:require-internal-with-underscore
589            _transitionTo(toState, fromState1, fromState2) {
590                if (this._state === fromState1 || this._state === fromState2) {
591                    this._state = toState;
592                    if (toState == notScheduled) {
593                        this._zoneDelegates = null;
594                    }
595                }
596                else {
597                    throw new Error(`${this.type} '${this.source}': can not transition to '${toState}', expecting state '${fromState1}'${fromState2 ? ' or \'' + fromState2 + '\'' : ''}, was '${this._state}'.`);
598                }
599            }
600            toString() {
601                if (this.data && typeof this.data.handleId !== 'undefined') {
602                    return this.data.handleId.toString();
603                }
604                else {
605                    return Object.prototype.toString.call(this);
606                }
607            }
608            // add toJSON method to prevent cyclic error when
609            // call JSON.stringify(zoneTask)
610            toJSON() {
611                return {
612                    type: this.type,
613                    state: this.state,
614                    source: this.source,
615                    zone: this.zone.name,
616                    runCount: this.runCount
617                };
618            }
619        }
620        //////////////////////////////////////////////////////
621        //////////////////////////////////////////////////////
622        ///  MICROTASK QUEUE
623        //////////////////////////////////////////////////////
624        //////////////////////////////////////////////////////
625        const symbolSetTimeout = __symbol__('setTimeout');
626        const symbolPromise = __symbol__('Promise');
627        const symbolThen = __symbol__('then');
628        let _microTaskQueue = [];
629        let _isDrainingMicrotaskQueue = false;
630        let nativeMicroTaskQueuePromise;
631        function scheduleMicroTask(task) {
632            // if we are not running in any task, and there has not been anything scheduled
633            // we must bootstrap the initial task creation by manually scheduling the drain
634            if (_numberOfNestedTaskFrames === 0 && _microTaskQueue.length === 0) {
635                // We are not running in Task, so we need to kickstart the microtask queue.
636                if (!nativeMicroTaskQueuePromise) {
637                    if (global[symbolPromise]) {
638                        nativeMicroTaskQueuePromise = global[symbolPromise].resolve(0);
639                    }
640                }
641                if (nativeMicroTaskQueuePromise) {
642                    let nativeThen = nativeMicroTaskQueuePromise[symbolThen];
643                    if (!nativeThen) {
644                        // native Promise is not patchable, we need to use `then` directly
645                        // issue 1078
646                        nativeThen = nativeMicroTaskQueuePromise['then'];
647                    }
648                    nativeThen.call(nativeMicroTaskQueuePromise, drainMicroTaskQueue);
649                }
650                else {
651                    global[symbolSetTimeout](drainMicroTaskQueue, 0);
652                }
653            }
654            task && _microTaskQueue.push(task);
655        }
656        function drainMicroTaskQueue() {
657            if (!_isDrainingMicrotaskQueue) {
658                _isDrainingMicrotaskQueue = true;
659                while (_microTaskQueue.length) {
660                    const queue = _microTaskQueue;
661                    _microTaskQueue = [];
662                    for (let i = 0; i < queue.length; i++) {
663                        const task = queue[i];
664                        try {
665                            task.zone.runTask(task, null, null);
666                        }
667                        catch (error) {
668                            _api.onUnhandledError(error);
669                        }
670                    }
671                }
672                _api.microtaskDrainDone();
673                _isDrainingMicrotaskQueue = false;
674            }
675        }

773        const UNHANDLED_PROMISE_REJECTION_HANDLER_SYMBOL = __symbol__('unhandledPromiseRejectionHandler');
774        function handleUnhandledRejection(e) {
775            api.onUnhandledError(e);
776            try {
777                const handler = Zone[UNHANDLED_PROMISE_REJECTION_HANDLER_SYMBOL];
778                if (typeof handler === 'function') {
779                    handler.call(this, e);
780                }
781            }
782            catch (err) {
783            }
784        }
785        function isThenable(value) { return value && value.then; }
786        function forwardResolution(value) { return value; }
787        function forwardRejection(rejection) { return ZoneAwarePromise.reject(rejection); }
788        const symbolState = __symbol__('state');
789        const symbolValue = __symbol__('value');
790        const symbolFinally = __symbol__('finally');
791        const symbolParentPromiseValue = __symbol__('parentPromiseValue');
792        const symbolParentPromiseState = __symbol__('parentPromiseState');
793        const source = 'Promise.then';
794        const UNRESOLVED = null;
795        const RESOLVED = true;
796        const REJECTED = false;
797        const REJECTED_NO_CATCH = 0;
798        function makeResolver(promise, state) {
799            return (v) => {
800                try {
801                    resolvePromise(promise, state, v);
802                }
803                catch (err) {
804                    resolvePromise(promise, false, err);
805                }
806                // Do not return value or you will break the Promise spec.
807            };
808        }
809        const once = function () {
810            let wasCalled = false;
811            return function wrapper(wrappedFunction) {
812                return function () {
813                    if (wasCalled) {
814                        return;
815                    }
816                    wasCalled = true;
817                    wrappedFunction.apply(null, arguments);
818                };
819            };
820        };
821        const TYPE_ERROR = 'Promise resolved with itself';
822        const CURRENT_TASK_TRACE_SYMBOL = __symbol__('currentTaskTrace');
823        // Promise Resolution
824        function resolvePromise(promise, state, value) {
825            const onceWrapper = once();
826            if (promise === value) {
827                throw new TypeError(TYPE_ERROR);
828            }
829            if (promise[symbolState] === UNRESOLVED) {
830                // should only get value.then once based on promise spec.
831                let then = null;
832                try {
833                    if (typeof value === 'object' || typeof value === 'function') {
834                        then = value && value.then;
835                    }
836                }
837                catch (err) {
838                    onceWrapper(() => { resolvePromise(promise, false, err); })();
839                    return promise;
840                }
841                // if (value instanceof ZoneAwarePromise) {
842                if (state !== REJECTED && value instanceof ZoneAwarePromise &&
843                    value.hasOwnProperty(symbolState) && value.hasOwnProperty(symbolValue) &&
844                    value[symbolState] !== UNRESOLVED) {
845                    clearRejectedNoCatch(value);
846                    resolvePromise(promise, value[symbolState], value[symbolValue]);
847                }
848                else if (state !== REJECTED && typeof then === 'function') {
849                    try {
850                        then.call(value, onceWrapper(makeResolver(promise, state)), onceWrapper(makeResolver(promise, false)));
851                    }
852                    catch (err) {
853                        onceWrapper(() => { resolvePromise(promise, false, err); })();
854                    }
855                }
856                else {
857                    promise[symbolState] = state;
858                    const queue = promise[symbolValue];
859                    promise[symbolValue] = value;
860                    if (promise[symbolFinally] === symbolFinally) {
861                        // the promise is generated by Promise.prototype.finally
862                        if (state === RESOLVED) {
863                            // the state is resolved, should ignore the value
864                            // and use parent promise value
865                            promise[symbolState] = promise[symbolParentPromiseState];
866                            promise[symbolValue] = promise[symbolParentPromiseValue];
867                        }
868                    }
869                    // record task information in value when error occurs, so we can
870                    // do some additional work such as render longStackTrace
871                    if (state === REJECTED && value instanceof Error) {
872                        // check if longStackTraceZone is here
873                        const trace = Zone.currentTask && Zone.currentTask.data &&
874                            Zone.currentTask.data[creationTrace];
875                        if (trace) {
876                            // only keep the long stack trace into error when in longStackTraceZone
877                            ObjectDefineProperty(value, CURRENT_TASK_TRACE_SYMBOL, { configurable: true, enumerable: false, writable: true, value: trace });
878                        }
879                    }
880                    for (let i = 0; i < queue.length;) {
881                        scheduleResolveOrReject(promise, queue[i++], queue[i++], queue[i++], queue[i++]);
882                    }
883                    if (queue.length == 0 && state == REJECTED) {
884                        promise[symbolState] = REJECTED_NO_CATCH;
885                        let uncaughtPromiseError = value;
886                        if (!isDisableWrappingUncaughtPromiseRejection) {
887                            // If disable wrapping uncaught promise reject
888                            // and the rejected value is an Error object,
889                            // use the value instead of wrapping it.
890                            try {
891                                // Here we throws a new Error to print more readable error log
892                                // and if the value is not an error, zone.js builds an `Error`
893                                // Object here to attach the stack information.
894                                throw new Error('Uncaught (in promise): ' + readableObjectToString(value) +
895                                    (value && value.stack ? '\n' + value.stack : ''));
896                            }
897                            catch (err) {
898                                uncaughtPromiseError = err;
899                            }
900                        }
901                        uncaughtPromiseError.rejection = value;
902                        uncaughtPromiseError.promise = promise;
903                        uncaughtPromiseError.zone = Zone.current;
904                        uncaughtPromiseError.task = Zone.currentTask;
905                        _uncaughtPromiseErrors.push(uncaughtPromiseError);
906                        api.scheduleMicroTask(); // to make sure that it is running
907                    }
908                }
909            }
910            // Resolving an already resolved promise is a noop.
911            return promise;
912        }
913        const REJECTION_HANDLED_HANDLER = __symbol__('rejectionHandledHandler');
914        function clearRejectedNoCatch(promise) {
915            if (promise[symbolState] === REJECTED_NO_CATCH) {
916                // if the promise is rejected no catch status
917                // and queue.length > 0, means there is a error handler
918                // here to handle the rejected promise, we should trigger
919                // windows.rejectionhandled eventHandler or nodejs rejectionHandled
920                // eventHandler
921                try {
922                    const handler = Zone[REJECTION_HANDLED_HANDLER];
923                    if (handler && typeof handler === 'function') {
924                        handler.call(this, { rejection: promise[symbolValue], promise: promise });
925                    }
926                }
927                catch (err) {
928                }
929                promise[symbolState] = REJECTED;
930                for (let i = 0; i < _uncaughtPromiseErrors.length; i++) {
931                    if (promise === _uncaughtPromiseErrors[i].promise) {
932                        _uncaughtPromiseErrors.splice(i, 1);
933                    }
934                }
935            }
936        }
937        function scheduleResolveOrReject(promise, zone, chainPromise, onFulfilled, onRejected) {
938            clearRejectedNoCatch(promise);
939            const promiseState = promise[symbolState];
940            const delegate = promiseState ?
941                (typeof onFulfilled === 'function') ? onFulfilled : forwardResolution :
942                (typeof onRejected === 'function') ? onRejected : forwardRejection;
943            zone.scheduleMicroTask(source, () => {
944                try {
945                    const parentPromiseValue = promise[symbolValue];

962ise);
963        }
964        const ZONE_AWARE_PROMISE_TO_STRING = 'function ZoneAwarePromise() { [native code] }';
965        const noop = function () { };
966        class ZoneAwarePromise {
967            static toString() { return ZONE_AWARE_PROMISE_TO_STRING; }
968            static resolve(value) {
969                return resolvePromise(new this(null), RESOLVED, value);
970            }
971            static reject(error) {
972                return resolvePromise(new this(null), REJECTED, error);
973            }
974            static race(values) {
975                let resolve;
976                let reject;
977                let promise = new this((res, rej) => {
978                    resolve = res;
979                    reject = rej;
980                });
981                function onResolve(value) { resolve(value); }
982                function onReject(error) { reject(error); }
983                for (let value of values) {
984                    if (!isThenable(value)) {
985                        value = this.resolve(value);
986                    }
987                    value.then(onResolve, onReject);
988                }
989                return promise;
990            }
991            static all(values) { return ZoneAwarePromise.allWithCallback(values); }
992            static allSettled(values) {
993                const P = this && this.prototype instanceof ZoneAwarePromise ? this : ZoneAwarePromise;
994                return P.allWithCallback(values, {
995                    thenCallback: (value) => ({ status: 'fulfilled', value }),
996                    errorCallback: (err) => ({ status: 'rejected', reason: err })
997                });
998            }
999            static allWithCallback(values, callback) {
1000                let resolve;
1001                let reject;
1002                let promise = new this((res, rej) => {
1003                    resolve = res;
1004                    reject = rej;
1005                });
1006                // Start at 2 to prevent prematurely resolving if .then is called immediately.
1007                let unresolvedCount = 2;
1008                let valueIndex = 0;
1009                const resolvedValues = [];
1010                for (let value of values) {
1011                    if (!isThenable(value)) {
1012                        value = this.resolve(value);
1013                    }
1014                    const curValueIndex = valueIndex;
1015                    try {
1016                        value.then((value) => {
1017                            resolvedValues[curValueIndex] = callback ? callback.thenCallback(value) : value;
1018                            unresolvedCount--;
1019                            if (unresolvedCount === 0) {
1020                                resolve(resolvedValues);
1021                            }
1022                        }, (err) => {
1023                            if (!callback) {
1024                                reject(err);
1025                            }
1026                            else {
1027                                resolvedValues[curValueIndex] = callback.errorCallback(err);
1028                                unresolvedCount--;
1029                                if (unresolvedCount === 0) {
1030                                    resolve(resolvedValues);
1031                                }
1032                            }
1033                        });
1034                    }
1035                    catch (thenErr) {
1036                        reject(thenErr);
1037                    }
1038                    unresolvedCount++;
1039                    valueIndex++;
1040                }
1041                // Make the unresolvedCount zero-based again.
1042                unresolvedCount -= 2;
1043                if (unresolvedCount === 0) {
1044                    resolve(resolvedValues);
1045                }
1046                return promise;
1047            }
1048            constructor(executor) {
1049                const promise = this;
1050                if (!(promise instanceof ZoneAwarePromise)) {
1051                    throw new Error('Must be an instanceof Promise.');
1052                }
1053                promise[symbolState] = UNRESOLVED;
1054                promise[symbolValue] = []; // queue;
1055                try {
1056                    executor && executor(makeResolver(promise, RESOLVED), makeResolver(promise, REJECTED));
1057                }
1058                catch (error) {
1059                    resolvePromise(promise, false, error);
1060                }
1061            }
1062            get [Symbol.toStringTag]() { return 'Promise'; }
1063            get [Symbol.species]() { return ZoneAwarePromise; }
1064            then(onFulfilled, onRejected) {
1065                let C = this.constructor[Symbol.species];
1066                if (!C || typeof C !== 'function') {
1067                    C = this.constructor || ZoneAwarePromise;
1068                }
1069                const chainPromise = new C(noop);
1070                const zone = Zone.current;
1071                if (this[symbolState] == UNRESOLVED) {
1072                    this[symbolValue].push(zone, chainPromise, onFulfilled, onRejected);
1073                }
1074                else {
1075                    scheduleResolveOrReject(this, zone, chainPromise, onFulfilled, onRejected);
1076                }
1077                return chainPromise;
1078            }
1079            catch(onRejected) {
1080                return this.then(null, onRejected);
1081            }
1082            finally(onFinally) {
1083                let C = this.constructor[Symbol.species];
1084                if (!C || typeof C !== 'function') {
1085                    C = ZoneAwarePromise;
1086                }
1087                const chainPromise = new C(noop);
1088                chainPromise[symbolFinally] = symbolFinally;
1089                const zone = Zone.current;
1090                if (this[symbolState] == UNRESOLVED) {
1091                    this[symbolValue].push(zone, chainPromise, onFinally, onFinally);
1092                }
1093                else {
1094                    scheduleResolveOrReject(this, zone, chainPromise, onFinally, onFinally);
1095                }

1325            const prototypeDesc = ObjectGetOwnPropertyDescriptor(prototype, prop);
1326            if (prototypeDesc) {
1327                desc = { enumerable: true, configurable: true };
1328            }
1329        }
1330        // if the descriptor not exists or is not configurable
1331        // just return
1332        if (!desc || !desc.configurable) {
1333            return;
1334        }
1335        const onPropPatchedSymbol = zoneSymbol('on' + prop + 'patched');
1336        if (obj.hasOwnProperty(onPropPatchedSymbol) && obj[onPropPatchedSymbol]) {
1337            return;
1338        }
1339        // A property descriptor cannot have getter/setter and be writable
1340        // deleting the writable and value properties avoids this error:
1341        //
1342        // TypeError: property descriptors must not specify a value or be writable when a
1343        // getter or setter has been specified
1344        delete desc.writable;
1345        delete desc.value;
1346        const originalDescGet = desc.get;
1347        const originalDescSet = desc.set;
1348        // substr(2) cuz 'onclick' -> 'click', etc
1349        const eventName = prop.substr(2);
1350        let eventNameSymbol = zoneSymbolEventNames[eventName];
1351        if (!eventNameSymbol) {
1352            eventNameSymbol = zoneSymbolEventNames[eventName] = zoneSymbol('ON_PROPERTY' + eventName);
1353        }
1354        desc.set = function (newValue) {
1355            // in some of windows's onproperty callback, this is undefined
1356            // so we need to check it
1357            let target = this;
1358            if (!target && obj === _global) {
1359                target = _global;
1360            }
1361            if (!target) {
1362                return;
1363            }
1364            let previousValue = target[eventNameSymbol];
1365            if (previousValue) {
1366                target.removeEventListener(eventName, wrapFn);
1367            }
1368            // issue #978, when onload handler was added before loading zone.js
1369            // we should remove it with originalDescSet
1370            if (originalDescSet) {
1371                originalDescSet.apply(target, NULL_ON_PROP_VALUE);
1372            }
1373            if (typeof newValue === 'function') {
1374                target[eventNameSymbol] = newValue;
1375                target.addEventListener(eventName, wrapFn, false);
1376            }
1377            else {
1378                target[eventNameSymbol] = null;
1379            }
1380        };
1381        // The getter would return undefined for unassigned properties but the default value of an
1382        // unassigned property is null
1383        desc.get = function () {
1384            // in some of windows's onproperty callback, this is undefined
1385            // so we need to check it
1386            let target = this;
1387            if (!target && obj === _global) {
1388                target = _global;
1389            }
1390            if (!target) {
1391                return null;
1392            }
1393            const listener = target[eventNameSymbol];
1394            if (listener) {
1395                return listener;
1396            }
1397            else if (originalDescGet) {
1398                // result will be null when use inline event attribute,
1399                // such as <button onclick="func();">OK</button>
1400                // because the onclick function is internal raw uncompiled handler
1401                // the onclick will be evaluated when first time event was triggered or
1402                // the property is accessed, https://github.com/angular/zone.js/issues/525
1403                // so we should use original native get to retrieve the handler
1404                let value = originalDescGet && originalDescGet.call(this);
1405                if (value) {
1406                    desc.set.call(this, value);
1407                    if (typeof target[REMOVE_ATTRIBUTE] === 'function') {
1408                        target.removeAttribute(prop);
1409                    }
1410                    return value;
1411                }
1412            }
1413            return null;
1414        };
1415        ObjectDefineProperty(obj, prop, desc);
1416        obj[onPropPatchedSymbol] = true;
1417    }
1418    function patchOnProperties(obj, properties, prototype) {
1419        if (properties) {
1420            for (let i = 0; i < properties.length; i++) {
1421                patchProperty(obj, 'on' + properties[i], prototype);
1422            }
1423        }
1424        else {
1425            const onProperties = [];
1426            for (const prop in obj) {
1427                if (prop.substr(0, 2) == 'on') {
1428                    onProperties.push(prop);
1429                }
1430            }
1431            for (let j = 0; j < onProperties.length; j++) {
1432                patchProperty(obj, onProperties[j], prototype);
1433            }
1434        }
1435    }
1436    const originalInstanceKey = zoneSymbol('originalInstance');
1437    // wrap some native API on `window`
1438    function patchClass(className) {
1439        const OriginalClass = _global[className];
1440        if (!OriginalClass)
1441            return;
1442        // keep original class in global
1443        _global[zoneSymbol(className)] = OriginalClass;
1444        _global[className] = function () {
1445            const a = bindArguments(arguments, className);
1446            switch (a.length) {
1447                case 0:
1448                    this[originalInstanceKey] = new OriginalClass();
1449                    break;
1450                case 1:
1451                    this[originalInstanceKey] = new OriginalClass(a[0]);
1452                    break;
1453                case 2:
1454                    this[originalInstanceKey] = new OriginalClass(a[0], a[1]);
1455                    break;
1456                case 3:
1457                    this[originalInstanceKey] = new OriginalClass(a[0], a[1], a[2]);
1458                    break;
1459                case 4:
1460                    this[originalInstanceKey] = new OriginalClass(a[0], a[1], a[2], a[3]);
1461                    break;
1462                default:
1463                    throw new Error('Arg list too long.');
1464            }
1465        };
1466        // attach original delegate to patched function
1467        attachOriginToPatched(_global[className], OriginalClass);
1468        const instance = new OriginalClass(function () { });
1469        let prop;
1470        for (prop in instance) {
1471            // https://bugs.webkit.org/show_bug.cgi?id=44721
1472            if (className === 'XMLHttpRequest' && prop === 'responseBlob')
1473                continue;
1474            (function (prop) {
1475                if (typeof instance[prop] === 'function') {
1476                    _global[className].prototype[prop] = function () {
1477                        return this[originalInstanceKey][prop].apply(this[originalInstanceKey], arguments);
1478                    };
1479                }
1480                else {
1481                    ObjectDefineProperty(_global[className].prototype, prop, {
1482                        set: function (fn) {
1483                            if (typeof fn === 'function') {
1484                                this[originalInstanceKey][prop] = wrapWithCurrentZone(fn, className + '.' + prop);
1485                                // keep callback in wrapped function so we can
1486                                // use it in Function.prototype.toString to return
1487                                // the native one.
1488                                attachOriginToPatched(this[originalInstanceKey][prop], fn);
1489                            }
1490                            else {
1491                                this[originalInstanceKey][prop] = fn;
1492                            }
1493                        },
1494                        get: function () { return this[originalInstanceKey][prop]; }
1495                    });
1496                }
1497            }(prop));
1498        }
1499        for (prop in OriginalClass) {
1500            if (prop !== 'prototype' && OriginalClass.hasOwnProperty(prop)) {
1501                _global[className][prop] = OriginalClass[prop];
1502            }
1503        }
1504    }
1505    function copySymbolProperties(src, dest) {
1506        if (typeof Object.getOwnPropertySymbols !== 'function') {
1507            return;
1508        }
1509        const symbols = Object.getOwnPropertySymbols(src);

1560            setNative.apply(data.target, data.args);
1561            return task;
1562        }
1563        setNative = patchMethod(obj, funcName, (delegate) => function (self, args) {
1564            const meta = metaCreator(self, args);
1565            if (meta.cbIdx >= 0 && typeof args[meta.cbIdx] === 'function') {
1566                return scheduleMacroTaskWithCurrentZone(meta.name, args[meta.cbIdx], meta, scheduleTask);
1567            }
1568            else {
1569                // cause an error by calling it directly.
1570                return delegate.apply(self, args);
1571            }
1572        });
1573    }
1574    function attachOriginToPatched(patched, original) {
1575        patched[zoneSymbol('OriginalDelegate')] = original;
1576    }
1577    let isDetectedIEOrEdge = false;
1578    let ieOrEdge = false;
1579    function isIE() {
1580        try {
1581            const ua = internalWindow.navigator.userAgent;
1582            if (ua.indexOf('MSIE ') !== -1 || ua.indexOf('Trident/') !== -1) {
1583                return true;
1584            }
1585        }
1586        catch (error) {
1587        }
1588        return false;
1589    }
1590    function isIEOrEdge() {
1591        if (isDetectedIEOrEdge) {
1592            return ieOrEdge;
1593        }
1594        isDetectedIEOrEdge = true;
1595        try {
1596            const ua = internalWindow.navigator.userAgent;
1597            if (ua.indexOf('MSIE ') !== -1 || ua.indexOf('Trident/') !== -1 || ua.indexOf('Edge/') !== -1) {
1598                ieOrEdge = true;
1599            }
1600        }
1601        catch (error) {
1602        }
1603        return ieOrEdge;
1604    }
1605
1606    /**
1607     * @license
1608     * Copyright Google Inc. All Rights Reserved.
1609     *
1610     * Use of this source code is governed by an MIT-style license that can be
1611     * found in the LICENSE file at https://angular.io/license
1612     */
1613    // override Function.prototype.toString to make zone.js patched function
1614    // look like native function
1615    Zone.__load_patch('toString', (global) => {
1616        // patch Func.prototype.toString to let them look like native
1617        const originalFunctionToString = Function.prototype.toString;
1618        const ORIGINAL_DELEGATE_SYMBOL = zoneSymbol('OriginalDelegate');
1619        const PROMISE_SYMBOL = zoneSymbol('Promise');
1620        const ERROR_SYMBOL = zoneSymbol('Error');
1621        const newFunctionToString = function toString() {
1622            if (typeof this === 'function') {
1623                const originalDelegate = this[ORIGINAL_DELEGATE_SYMBOL];
1624                if (originalDelegate) {
1625                    if (typeof originalDelegate === 'function') {
1626                        return originalFunctionToString.call(originalDelegate);
1627                    }
1628                    else {
1629                        return Object.prototype.toString.call(originalDelegate);
1630                    }
1631                }
1632                if (this === Promise) {
1633                    const nativePromise = global[PROMISE_SYMBOL];
1634                    if (nativePromise) {
1635                        return originalFunctionToString.call(nativePromise);
1636                    }
1637                }
1638                if (this === Error) {
1639                    const nativeError = global[ERROR_SYMBOL];
1640                    if (nativeError) {
1641                        return originalFunctionToString.call(nativeError);
1642                    }
1643                }
1644            }
1645            return originalFunctionToString.call(this);
1646        };
1647        newFunctionToString[ORIGINAL_DELEGATE_SYMBOL] = originalFunctionToString;
1648        Function.prototype.toString = newFunctionToString;
1649        // patch Object.prototype.toString to let them look like native
1650        const originalObjectToString = Object.prototype.toString;
1651        const PROMISE_OBJECT_TO_STRING = '[object Promise]';
1652        Object.prototype.toString = function () {
1653            if (this instanceof Promise) {
1654                return PROMISE_OBJECT_TO_STRING;
1655            }
1656            return originalObjectToString.call(this);
1657        };
1658    });
1659
1660    /**
1661     * @license
1662     * Copyright Google Inc. All Rights Reserved.
1663     *
1664     * Use of this source code is governed by an MIT-style license that can be
1665     * found in the LICENSE file at https://angular.io/license
1666     */
1667    let passiveSupported = false;

1794            }
1795            let useGlobalCallback = true;
1796            if (patchOptions && patchOptions.useG !== undefined) {
1797                useGlobalCallback = patchOptions.useG;
1798            }
1799            const validateHandler = patchOptions && patchOptions.vh;
1800            let checkDuplicate = true;
1801            if (patchOptions && patchOptions.chkDup !== undefined) {
1802                checkDuplicate = patchOptions.chkDup;
1803            }
1804            let returnTarget = false;
1805            if (patchOptions && patchOptions.rt !== undefined) {
1806                returnTarget = patchOptions.rt;
1807            }
1808            let proto = obj;
1809            while (proto && !proto.hasOwnProperty(ADD_EVENT_LISTENER)) {
1810                proto = ObjectGetPrototypeOf(proto);
1811            }
1812            if (!proto && obj[ADD_EVENT_LISTENER]) {
1813                // somehow we did not find it, but we can see it. This happens on IE for Window properties.
1814                proto = obj;
1815            }
1816            if (!proto) {
1817                return false;
1818            }
1819            if (proto[zoneSymbolAddEventListener]) {
1820                return false;
1821            }
1822            const eventNameToString = patchOptions && patchOptions.eventNameToString;
1823            // a shared global taskData to pass data for scheduleEventTask
1824            // so we do not need to create a new object just for pass some data
1825            const taskData = {};
1826            const nativeAddEventListener = proto[zoneSymbolAddEventListener] = proto[ADD_EVENT_LISTENER];
1827            const nativeRemoveEventListener = proto[zoneSymbol(REMOVE_EVENT_LISTENER)] =
1828                proto[REMOVE_EVENT_LISTENER];
1829            const nativeListeners = proto[zoneSymbol(LISTENERS_EVENT_LISTENER)] =
1830                proto[LISTENERS_EVENT_LISTENER];
1831            const nativeRemoveAllListeners = proto[zoneSymbol(REMOVE_ALL_LISTENERS_EVENT_LISTENER)] =
1832                proto[REMOVE_ALL_LISTENERS_EVENT_LISTENER];
1833            let nativePrependEventListener;
1834            if (patchOptions && patchOptions.prepend) {
1835                nativePrependEventListener = proto[zoneSymbol(patchOptions.prepend)] =
1836                    proto[patchOptions.prepend];
1837            }
1838            /**
1839             * This util function will build an option object with passive option
1840             * to handle all possible input from the user.
1841             */
1842            function buildEventListenerOptions(options, passive) {
1843                if (!passiveSupported && typeof options === 'object' && options) {
1844                    // doesn't support passive but user want to pass an object as options.
1845                    // this will not work on some old browser, so we just pass a boolean
1846                    // as useCapture parameter
1847                    return !!options.capture;
1848                }
1849                if (!passiveSupported || !passive) {
1850                    return options;
1851                }
1852                if (typeof options === 'boolean') {
1853                    return { capture: options, passive: true };
1854                }
1855                if (!options) {
1856                    return { passive: true };
1857                }
1858                if (typeof options === 'object' && options.passive !== false) {
1859                    return Object.assign(Object.assign({}, options), { passive: true });
1860                }
1861                return options;
1862            }
1863            const customScheduleGlobal = function (task) {
1864                // if there is already a task for the eventName + capture,
1865                // just return, because we use the shared globalZoneAwareCallback here.
1866                if (taskData.isExisting) {
1867                    return;
1868                }
1869                return nativeAddEventListener.call(taskData.target, taskData.eventName, taskData.capture ? globalZoneAwareCaptureCallback : globalZoneAwareCallback, taskData.options);
1870            };
1871            const customCancelGlobal = function (task) {
1872                // if task is not marked as isRemoved, this call is directly
1873                // from Zone.prototype.cancelTask, we should remove the task
1874                // from tasksList of target first
1875                if (!task.isRemoved) {
1876                    const symbolEventNames = zoneSymbolEventNames$1[task.eventName];
1877                    let symbolEventName;
1878                    if (symbolEventNames) {
1879                        symbolEventName = symbolEventNames[task.capture ? TRUE_STR : FALSE_STR];
1880                    }
1881                    const existingTasks = symbolEventName && task.target[symbolEventName];
1882                    if (existingTasks) {
1883                        for (let i = 0; i < existingTasks.length; i++) {
1884                            const existingTask = existingTasks[i];
1885                            if (existingTask === task) {
1886                                existingTasks.splice(i, 1);
1887                                // set isRemoved to data for faster invokeTask check
1888                                task.isRemoved = true;
1889                                if (existingTasks.length === 0) {
1890                                    // all tasks for the eventName + capture have gone,
1891                                    // remove globalZoneAwareCallback and remove the task cache from target
1892                                    task.allRemoved = true;
1893                                    task.target[symbolEventName] = null;
1894                                }
1895                                break;
1896                            }
1897                        }
1898                    }
1899                }
1900                // if all tasks for the eventName + capture have gone,
1901                // we will really remove the global event callback,
1902                // if not, return
1903                if (!task.allRemoved) {
1904                    return;
1905                }
1906                return nativeRemoveEventListener.call(task.target, task.eventName, task.capture ? globalZoneAwareCaptureCallback : globalZoneAwareCallback, task.options);
1907            };
1908            const customScheduleNonGlobal = function (task) {
1909                return nativeAddEventListener.call(taskData.target, taskData.eventName, task.invoke, taskData.options);
1910            };
1911            const customSchedulePrepend = function (task) {
1912                return nativePrependEventListener.call(taskData.target, taskData.eventName, task.invoke, taskData.options);
1913            };
1914            const customCancelNonGlobal = function (task) {
1915                return nativeRemoveEventListener.call(task.target, task.eventName, task.invoke, task.options);
1916            };
1917            const customSchedule = useGlobalCallback ? customScheduleGlobal : customScheduleNonGlobal;
1918            const customCancel = useGlobalCallback ? customCancelGlobal : customCancelNonGlobal;
1919            const compareTaskCallbackVsDelegate = function (task, delegate) {
1920                const typeOfDelegate = typeof delegate;
1921                return (typeOfDelegate === 'function' && task.callback === delegate) ||
1922                    (typeOfDelegate === 'object' && task.originalDelegate === delegate);
1923            };
1924            const compare = (patchOptions && patchOptions.diff) ? patchOptions.diff : compareTaskCallbackVsDelegate;
1925            const blackListedEvents = Zone[zoneSymbol('BLACK_LISTED_EVENTS')];
1926            const passiveEvents = _global[zoneSymbol('PASSIVE_EVENTS')];
1927            const makeAddListener = function (nativeListener, addSource, customScheduleFn, customCancelFn, returnTarget = false, prepend = false) {
1928                return function () {
1929                    const target = this || _global;
1930                    let eventName = arguments[0];
1931                    if (patchOptions && patchOptions.transferEventName) {
1932                        eventName = patchOptions.transferEventName(eventName);
1933                    }
1934                    let delegate = arguments[1];
1935                    if (!delegate) {
1936                        return nativeListener.apply(this, arguments);
1937                    }
1938                    if (isNode && eventName === 'uncaughtException') {
1939                        // don't patch uncaughtException of nodejs to prevent endless loop
1940                        return nativeListener.apply(this, arguments);
1941                    }
1942                    // don't create the bind delegate function for handleEvent
1943                    // case here to improve addEventListener performance
1944                    // we will create the bind delegate when invoke
1945                    let isHandleEvent = false;
1946                    if (typeof delegate !== 'function') {
1947                        if (!delegate.handleEvent) {
1948                            return nativeListener.apply(this, arguments);
1949                        }
1950                        isHandleEvent = true;
1951                    }
1952                    if (validateHandler && !validateHandler(nativeListener, delegate, target, arguments)) {
1953                        return;
1954                    }
1955                    const passive = passiveSupported && !!passiveEvents && passiveEvents.indexOf(eventName) !== -1;
1956                    const options = buildEventListenerOptions(arguments[2], passive);
1957                    if (blackListedEvents) {
1958                        // check black list
1959                        for (let i = 0; i < blackListedEvents.length; i++) {
1960                            if (eventName === blackListedEvents[i]) {
1961                                if (passive) {
1962                                    return nativeListener.call(target, eventName, delegate, options);
1963                                }
1964                                else {
1965                                    return nativeListener.apply(this, arguments);
1966                                }
1967                            }
1968                        }
1969                    }
1970                    const capture = !options ? false : typeof options === 'boolean' ? true : options.capture;
1971                    const once = options && typeof options === 'object' ? options.once : false;
1972                    const zone = Zone.current;
1973                    let symbolEventNames = zoneSymbolEventNames$1[eventName];
1974                    if (!symbolEventNames) {
1975                        prepareEventNames(eventName, eventNameToString);
1976                        symbolEventNames = zoneSymbolEventNames$1[eventName];
1977                    }
1978                    const symbolEventName = symbolEventNames[capture ? TRUE_STR : FALSE_STR];
1979                    let existingTasks = target[symbolEventName];
1980                    let isExisting = false;
1981                    if (existingTasks) {
1982                        // already have task registered
1983                        isExisting = true;
1984                        if (checkDuplicate) {
1985                            for (let i = 0; i < existingTasks.length; i++) {
1986                                if (compare(existingTasks[i], delegate)) {
1987                                    // same callback, same capture, same event name, just return
1988                                    return;
1989                                }
1990                            }
1991                        }
1992                    }
1993                    else {
1994                        existingTasks = target[symbolEventName] = [];
1995                    }
1996                    let source;
1997                    const constructorName = target.constructor['name'];
1998                    const targetSource = globalSources[constructorName];
1999                    if (targetSource) {
2000                        source = targetSource[eventName];
2001                    }
2002                    if (!source) {
2003                        source = constructorName + addSource +
2004                            (eventNameToString ? eventNameToString(eventName) : eventName);
2005                    }
2006                    // do not create a new object as task.data to pass those things
2007                    // just use the global shared one
2008                    taskData.options = options;
2009                    if (once) {
2010                        // if addEventListener with once options, we don't pass it to
2011                        // native addEventListener, instead we keep the once setting
2012                        // and handle ourselves.
2013                        taskData.options.once = false;
2014                    }
2015                    taskData.target = target;
2016                    taskData.capture = capture;
2017                    taskData.eventName = eventName;
2018                    taskData.isExisting = isExisting;
2019                    const data = useGlobalCallback ? OPTIMIZED_ZONE_EVENT_TASK_DATA : undefined;
2020                    // keep taskData into data to allow onScheduleEventTask to access the task information
2021                    if (data) {
2022                        data.taskData = taskData;
2023                    }
2024                    const task = zone.scheduleEventTask(source, delegate, data, customScheduleFn, customCancelFn);
2025                    // should clear taskData.target to avoid memory leak
2026                    // issue, https://github.com/angular/angular/issues/20442
2027                    taskData.target = null;
2028                    // need to clear up taskData because it is a global object
2029                    if (data) {
2030                        data.taskData = null;
2031                    }
2032                    // have to save those information to task in case
2033                    // application may call task.zone.cancelTask() directly
2034                    if (once) {
2035                        options.once = true;
2036                    }
2037                    if (!(!passiveSupported && typeof task.options === 'boolean')) {
2038                        // if not support passive, and we pass an option object
2039                        // to addEventListener, we should save the options to task
2040                        task.options = options;
2041                    }
2042                    task.target = target;
2043                    task.capture = capture;
2044                    task.eventName = eventName;
2045                    if (isHandleEvent) {
2046                        // save original delegate for compare to check duplicate
2047                        task.originalDelegate = delegate;
2048                    }
2049                    if (!prepend) {
2050                        existingTasks.push(task);
2051                    }
2052                    else {
2053                        existingTasks.unshift(task);
2054                    }
2055                    if (returnTarget) {
2056                        return target;
2057                    }
2058                };
2059            };
2060            proto[ADD_EVENT_LISTENER] = makeAddListener(nativeAddEventListener, ADD_EVENT_LISTENER_SOURCE, customSchedule, customCancel, returnTarget);
2061            if (nativePrependEventListener) {
2062                proto[PREPEND_EVENT_LISTENER] = makeAddListener(nativePrependEventListener, PREPEND_EVENT_LISTENER_SOURCE, customSchedulePrepend, customCancel, returnTarget, true);
2063            }
2064            proto[REMOVE_EVENT_LISTENER] = function () {
2065                const target = this || _global;
2066                let eventName = arguments[0];
2067                if (patchOptions && patchOptions.transferEventName) {
2068                    eventName = patchOptions.transferEventName(eventName);
2069                }
2070                const options = arguments[2];
2071                const capture = !options ? false : typeof options === 'boolean' ? true : options.capture;
2072                const delegate = arguments[1];
2073                if (!delegate) {
2074                    return nativeRemoveEventListener.apply(this, arguments);
2075                }
2076                if (validateHandler &&
2077                    !validateHandler(nativeRemoveEventListener, delegate, target, arguments)) {
2078                    return;
2079                }
2080                const symbolEventNames = zoneSymbolEventNames$1[eventName];
2081                let symbolEventName;
2082                if (symbolEventNames) {
2083                    symbolEventName = symbolEventNames[capture ? TRUE_STR : FALSE_STR];
2084                }
2085                const existingTasks = symbolEventName && target[symbolEventName];
2086                if (existingTasks) {
2087                    for (let i = 0; i < existingTasks.length; i++) {
2088                        const existingTask = existingTasks[i];
2089                        if (compare(existingTask, delegate)) {
2090                            existingTasks.splice(i, 1);
2091                            // set isRemoved to data for faster invokeTask check
2092                            existingTask.isRemoved = true;
2093                            if (existingTasks.length === 0) {
2094                                // all tasks for the eventName + capture have gone,
2095                                // remove globalZoneAwareCallback and remove the task cache from target
2096                                existingTask.allRemoved = true;
2097                                target[symbolEventName] = null;
2098                                // in the target, we have an event listener which is added by on_property
2099                                // such as target.onclick = function() {}, so we need to clear this internal
2100                                // property too if all delegates all removed
2101                                if (typeof eventName === 'string') {
2102                                    const onPropertySymbol = ZONE_SYMBOL_PREFIX + 'ON_PROPERTY' + eventName;
2103                                    target[onPropertySymbol] = null;
2104                                }
2105                            }
2106                            existingTask.zone.cancelTask(existingTask);
2107                            if (returnTarget) {
2108                                return target;
2109                            }
2110                            return;
2111                        }
2112                    }
2113                }
2114                // issue 930, didn't find the event name or callback
2115                // from zone kept existingTasks, the callback maybe
2116                // added outside of zone, we need to call native removeEventListener
2117                // to try to remove it.
2118                return nativeRemoveEventListener.apply(this, arguments);
2119            };
2120            proto[LISTENERS_EVENT_LISTENER] = function () {
2121                const target = this || _global;
2122                let eventName = arguments[0];
2123                if (patchOptions && patchOptions.transferEventName) {
2124                    eventName = patchOptions.transferEventName(eventName);
2125                }
2126                const listeners = [];
2127                const tasks = findEventTasks(target, eventNameToString ? eventNameToString(eventName) : eventName);
2128                for (let i = 0; i < tasks.length; i++) {
2129                    const task = tasks[i];
2130                    let delegate = task.originalDelegate ? task.originalDelegate : task.callback;
2131                    listeners.push(delegate);
2132                }
2133                return listeners;
2134            };
2135            proto[REMOVE_ALL_LISTENERS_EVENT_LISTENER] = function () {
2136                const target = this || _global;
2137                let eventName = arguments[0];
2138                if (!eventName) {
2139                    const keys = Object.keys(target);
2140                    for (let i = 0; i < keys.length; i++) {
2141                        const prop = keys[i];
2142                        const match = EVENT_NAME_SYMBOL_REGX.exec(prop);
2143                        let evtName = match && match[1];
2144                        // in nodejs EventEmitter, removeListener event is
2145                        // used for monitoring the removeListener call,
2146                        // so just keep removeListener eventListener until
2147                        // all other eventListeners are removed
2148                        if (evtName && evtName !== 'removeListener') {
2149                            this[REMOVE_ALL_LISTENERS_EVENT_LISTENER].call(this, evtName);
2150                        }
2151                    }
2152                    // remove removeListener listener finally
2153                    this[REMOVE_ALL_LISTENERS_EVENT_LISTENER].call(this, 'removeListener');
2154                }
2155                else {
2156                    if (patchOptions && patchOptions.transferEventName) {
2157                        eventName = patchOptions.transferEventName(eventName);
2158                    }
2159                    const symbolEventNames = zoneSymbolEventNames$1[eventName];
2160                    if (symbolEventNames) {
2161                        const symbolEventName = symbolEventNames[FALSE_STR];
2162                        const symbolCaptureEventName = symbolEventNames[TRUE_STR];
2163                        const tasks = target[symbolEventName];
2164                        const captureTasks = target[symbolCaptureEventName];
2165                        if (tasks) {
2166                            const removeTasks = tasks.slice();
2167                            for (let i = 0; i < removeTasks.length; i++) {
2168                                const task = removeTasks[i];
2169                                let delegate = task.originalDelegate ? task.originalDelegate : task.callback;
2170                                this[REMOVE_EVENT_LISTENER].call(this, eventName, delegate, task.options);
2171                            }
2172                        }
2173                        if (captureTasks) {
2174                            const removeTasks = captureTasks.slice();
2175                            for (let i = 0; i < removeTasks.length; i++) {
2176                                const task = removeTasks[i];
2177                                let delegate = task.originalDelegate ? task.originalDelegate : task.callback;
2178                                this[REMOVE_EVENT_LISTENER].call(this, eventName, delegate, task.options);
2179                            }
2180                        }
2181                    }
2182                }
2183                if (returnTarget) {
2184                    return this;
2185                }
2186            };
2187            // for native toString patch
2188            attachOriginToPatched(proto[ADD_EVENT_LISTENER], nativeAddEventListener);
2189            attachOriginToPatched(proto[REMOVE_EVENT_LISTENER], nativeRemoveEventListener);
2190            if (nativeRemoveAllListeners) {
2191                attachOriginToPatched(proto[REMOVE_ALL_LISTENERS_EVENT_LISTENER], nativeRemoveAllListeners);
2192            }
2193            if (nativeListeners) {
2194                attachOriginToPatched(proto[LISTENERS_EVENT_LISTENER], nativeListeners);
2195            }
2196            return true;
2197        }
2198        let results = [];
2199        for (let i = 0; i < apis.length; i++) {
2200            results[i] = patchEventTargetMethods(apis[i], patchOptions);
2201        }
2202        return results;
2203    }
2204    function findEventTasks(target, eventName) {
2205        if (!eventName) {
2206            const foundTasks = [];
2207            for (let prop in target) {
2208                const match = EVENT_NAME_SYMBOL_REGX.exec(prop);
2209                let evtName = match && match[1];
2210                if (evtName && (!eventName || evtName === eventName)) {
2211                    const tasks = target[prop];
2212                    if (tasks) {
2213                        for (let i = 0; i < tasks.length; i++) {
2214                            foundTasks.push(tasks[i]);
2215                        }
2216                    }
2217                }
2218            }
2219            return foundTasks;
2220        }
2221        let symbolEventName = zoneSymbolEventNames$1[eventName];
2222        if (!symbolEventName) {
2223            prepareEventNames(eventName);
2224            symbolEventName = zoneSymbolEventNames$1[eventName];
2225        }
2226        const captureFalseTasks = target[symbolEventName[FALSE_STR]];
2227        const captureTrueTasks = target[symbolEventName[TRUE_STR]];
2228        if (!captureFalseTasks) {
2229            return captureTrueTasks ? captureTrueTasks.slice() : [];
2230        }
2231        else {
2232            return captureTrueTasks ? captureFalseTasks.concat(captureTrueTasks) :
2233                captureFalseTasks.slice();
2234        }
2235    }
2236    function patchEventPrototype(global, api) {
2237        const Event = global['Event'];
2238        if (Event && Event.prototype) {
2239            api.patchMethod(Event.prototype, 'stopImmediatePropagation', (delegate) => function (self, args) {
2240                self[IMMEDIATE_PROPAGATION_SYMBOL] = true;
2241                // we need to call the native stopImmediatePropagation
2242                // in case in some hybrid application, some part of
2243                // application will be controlled by zone, some are not
2244                delegate && delegate.apply(self, args);
2245            });
2246        }
2247    }
2248
2249    /**
2250     * @license
2251     * Copyright Google Inc. All Rights Reserved.
2252     *
2253     * Use of this source code is governed by an MIT-style license that can be
2254     * found in the LICENSE file at https://angular.io/license
2255     */
2256    function patchCallbacks(api, target, targetName, method, callbacks) {
2257        const symbol = Zone.__symbol__(method);
2258        if (target[symbol]) {
2259            return;
2260        }
2261        const nativeDelegate = target[symbol] = target[method];
2262        target[method] = function (name, opts, options) {
2263            if (opts && opts.prototype) {
2264                callbacks.forEach(function (callback) {
2265                    const source = `${targetName}.${method}::` + callback;
2266                    const prototype = opts.prototype;
2267                    if (prototype.hasOwnProperty(callback)) {
2268                        const descriptor = api.ObjectGetOwnPropertyDescriptor(prototype, callback);
2269                        if (descriptor && descriptor.value) {
2270                            descriptor.value = api.wrapWithCurrentZone(descriptor.value, source);
2271                            api._redefineProperty(opts.prototype, callback, descriptor);
2272                        }
2273                        else if (prototype[callback]) {
2274                            prototype[callback] = api.wrapWithCurrentZone(prototype[callback], source);
2275                        }
2276                    }
2277                    else if (prototype[callback]) {
2278                        prototype[callback] = api.wrapWithCurrentZone(prototype[callback], source);
2279                    }
2280                });
2281            }
2282            return nativeDelegate.call(target, name, opts, options);
2283        };
2284        api.attachOriginToPatched(target[method], nativeDelegate);
2285    }
2286
2287    /**
2288     * @license
2289     * Copyright Google Inc. All Rights Reserved.
2290     *
2291     * Use of this source code is governed by an MIT-style license that can be
2292     * found in the LICENSE file at https://angular.io/license
2293     */
2294    const globalEventHandlersEventNames = [
2295        'abort',
2296        'animationcancel',
2297        'animationend',
2298        'animationiteration',
2299        'auxclick',
2300        'beforeinput',
2301        'blur',
2302        'cancel',
2303        'canplay',
2304        'canplaythrough',
2305        'change',
2306        'compositionstart',
2307        'compositionupdate',
2308        'compositionend',
2309        'cuechange',
2310        'click',
2311        'close',
2312        'contextmenu',
2313        'curechange',
2314        'dblclick',
2315        'drag',
2316        'dragend',
2317        'dragenter',
2318        'dragexit',
2319        'dragleave',
2320        'dragover',
2321        'drop',
2322        'durationchange',
2323        'emptied',
2324        'ended',
2325        'error',