Updated the files.

my-app/node_modules/zone.js/fesm2015/async-test.js

@@ -0,0 +1,259 @@
+'use strict';
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+(function (_global) {
+    class AsyncTestZoneSpec {
+        static { this.symbolParentUnresolved = Zone.__symbol__('parentUnresolved'); }
+        constructor(finishCallback, failCallback, namePrefix) {
+            this.finishCallback = finishCallback;
+            this.failCallback = failCallback;
+            this._pendingMicroTasks = false;
+            this._pendingMacroTasks = false;
+            this._alreadyErrored = false;
+            this._isSync = false;
+            this._existingFinishTimer = null;
+            this.entryFunction = null;
+            this.runZone = Zone.current;
+            this.unresolvedChainedPromiseCount = 0;
+            this.supportWaitUnresolvedChainedPromise = false;
+            this.name = 'asyncTestZone for ' + namePrefix;
+            this.properties = { 'AsyncTestZoneSpec': this };
+            this.supportWaitUnresolvedChainedPromise =
+                _global[Zone.__symbol__('supportWaitUnResolvedChainedPromise')] === true;
+        }
+        isUnresolvedChainedPromisePending() {
+            return this.unresolvedChainedPromiseCount > 0;
+        }
+        _finishCallbackIfDone() {
+            // NOTE: Technically the `onHasTask` could fire together with the initial synchronous
+            // completion in `onInvoke`. `onHasTask` might call this method when it captured e.g.
+            // microtasks in the proxy zone that now complete as part of this async zone run.
+            // Consider the following scenario:
+            //    1. A test `beforeEach` schedules a microtask in the ProxyZone.
+            //    2. An actual empty `it` spec executes in the AsyncTestZone` (using e.g. `waitForAsync`).
+            //    3. The `onInvoke` invokes `_finishCallbackIfDone` because the spec runs synchronously.
+            //    4. We wait the scheduled timeout (see below) to account for unhandled promises.
+            //    5. The microtask from (1) finishes and `onHasTask` is invoked.
+            //    --> We register a second `_finishCallbackIfDone` even though we have scheduled a timeout.
+            // If the finish timeout from below is already scheduled, terminate the existing scheduled
+            // finish invocation, avoiding calling `jasmine` `done` multiple times. *Note* that we would
+            // want to schedule a new finish callback in case the task state changes again.
+            if (this._existingFinishTimer !== null) {
+                clearTimeout(this._existingFinishTimer);
+                this._existingFinishTimer = null;
+            }
+            if (!(this._pendingMicroTasks || this._pendingMacroTasks ||
+                (this.supportWaitUnresolvedChainedPromise && this.isUnresolvedChainedPromisePending()))) {
+                // We wait until the next tick because we would like to catch unhandled promises which could
+                // cause test logic to be executed. In such cases we cannot finish with tasks pending then.
+                this.runZone.run(() => {
+                    this._existingFinishTimer = setTimeout(() => {
+                        if (!this._alreadyErrored && !(this._pendingMicroTasks || this._pendingMacroTasks)) {
+                            this.finishCallback();
+                        }
+                    }, 0);
+                });
+            }
+        }
+        patchPromiseForTest() {
+            if (!this.supportWaitUnresolvedChainedPromise) {
+                return;
+            }
+            const patchPromiseForTest = Promise[Zone.__symbol__('patchPromiseForTest')];
+            if (patchPromiseForTest) {
+                patchPromiseForTest();
+            }
+        }
+        unPatchPromiseForTest() {
+            if (!this.supportWaitUnresolvedChainedPromise) {
+                return;
+            }
+            const unPatchPromiseForTest = Promise[Zone.__symbol__('unPatchPromiseForTest')];
+            if (unPatchPromiseForTest) {
+                unPatchPromiseForTest();
+            }
+        }
+        onScheduleTask(delegate, current, target, task) {
+            if (task.type !== 'eventTask') {
+                this._isSync = false;
+            }
+            if (task.type === 'microTask' && task.data && task.data instanceof Promise) {
+                // check whether the promise is a chained promise
+                if (task.data[AsyncTestZoneSpec.symbolParentUnresolved] === true) {
+                    // chained promise is being scheduled
+                    this.unresolvedChainedPromiseCount--;
+                }
+            }
+            return delegate.scheduleTask(target, task);
+        }
+        onInvokeTask(delegate, current, target, task, applyThis, applyArgs) {
+            if (task.type !== 'eventTask') {
+                this._isSync = false;
+            }
+            return delegate.invokeTask(target, task, applyThis, applyArgs);
+        }
+        onCancelTask(delegate, current, target, task) {
+            if (task.type !== 'eventTask') {
+                this._isSync = false;
+            }
+            return delegate.cancelTask(target, task);
+        }
+        // Note - we need to use onInvoke at the moment to call finish when a test is
+        // fully synchronous. TODO(juliemr): remove this when the logic for
+        // onHasTask changes and it calls whenever the task queues are dirty.
+        // updated by(JiaLiPassion), only call finish callback when no task
+        // was scheduled/invoked/canceled.
+        onInvoke(parentZoneDelegate, currentZone, targetZone, delegate, applyThis, applyArgs, source) {
+            if (!this.entryFunction) {
+                this.entryFunction = delegate;
+            }
+            try {
+                this._isSync = true;
+                return parentZoneDelegate.invoke(targetZone, delegate, applyThis, applyArgs, source);
+            }
+            finally {
+                // We need to check the delegate is the same as entryFunction or not.
+                // Consider the following case.
+                //
+                // asyncTestZone.run(() => { // Here the delegate will be the entryFunction
+                //   Zone.current.run(() => { // Here the delegate will not be the entryFunction
+                //   });
+                // });
+                //
+                // We only want to check whether there are async tasks scheduled
+                // for the entry function.
+                if (this._isSync && this.entryFunction === delegate) {
+                    this._finishCallbackIfDone();
+                }
+            }
+        }
+        onHandleError(parentZoneDelegate, currentZone, targetZone, error) {
+            // Let the parent try to handle the error.
+            const result = parentZoneDelegate.handleError(targetZone, error);
+            if (result) {
+                this.failCallback(error);
+                this._alreadyErrored = true;
+            }
+            return false;
+        }
+        onHasTask(delegate, current, target, hasTaskState) {
+            delegate.hasTask(target, hasTaskState);
+            // We should only trigger finishCallback when the target zone is the AsyncTestZone
+            // Consider the following cases.
+            //
+            // const childZone = asyncTestZone.fork({
+            //   name: 'child',
+            //   onHasTask: ...
+            // });
+            //
+            // So we have nested zones declared the onHasTask hook, in this case,
+            // the onHasTask will be triggered twice, and cause the finishCallbackIfDone()
+            // is also be invoked twice. So we need to only trigger the finishCallbackIfDone()
+            // when the current zone is the same as the target zone.
+            if (current !== target) {
+                return;
+            }
+            if (hasTaskState.change == 'microTask') {
+                this._pendingMicroTasks = hasTaskState.microTask;
+                this._finishCallbackIfDone();
+            }
+            else if (hasTaskState.change == 'macroTask') {
+                this._pendingMacroTasks = hasTaskState.macroTask;
+                this._finishCallbackIfDone();
+            }
+        }
+    }
+    // Export the class so that new instances can be created with proper
+    // constructor params.
+    Zone['AsyncTestZoneSpec'] = AsyncTestZoneSpec;
+})(typeof window !== 'undefined' && window || typeof self !== 'undefined' && self || global);
+Zone.__load_patch('asynctest', (global, Zone, api) => {
+    /**
+     * Wraps a test function in an asynchronous test zone. The test will automatically
+     * complete when all asynchronous calls within this zone are done.
+     */
+    Zone[api.symbol('asyncTest')] = function asyncTest(fn) {
+        // If we're running using the Jasmine test framework, adapt to call the 'done'
+        // function when asynchronous activity is finished.
+        if (global.jasmine) {
+            // Not using an arrow function to preserve context passed from call site
+            return function (done) {
+                if (!done) {
+                    // if we run beforeEach in @angular/core/testing/testing_internal then we get no done
+                    // fake it here and assume sync.
+                    done = function () { };
+                    done.fail = function (e) {
+                        throw e;
+                    };
+                }
+                runInTestZone(fn, this, done, (err) => {
+                    if (typeof err === 'string') {
+                        return done.fail(new Error(err));
+                    }
+                    else {
+                        done.fail(err);
+                    }
+                });
+            };
+        }
+        // Otherwise, return a promise which will resolve when asynchronous activity
+        // is finished. This will be correctly consumed by the Mocha framework with
+        // it('...', async(myFn)); or can be used in a custom framework.
+        // Not using an arrow function to preserve context passed from call site
+        return function () {
+            return new Promise((finishCallback, failCallback) => {
+                runInTestZone(fn, this, finishCallback, failCallback);
+            });
+        };
+    };
+    function runInTestZone(fn, context, finishCallback, failCallback) {
+        const currentZone = Zone.current;
+        const AsyncTestZoneSpec = Zone['AsyncTestZoneSpec'];
+        if (AsyncTestZoneSpec === undefined) {
+            throw new Error('AsyncTestZoneSpec is needed for the async() test helper but could not be found. ' +
+                'Please make sure that your environment includes zone.js/plugins/async-test');
+        }
+        const ProxyZoneSpec = Zone['ProxyZoneSpec'];
+        if (!ProxyZoneSpec) {
+            throw new Error('ProxyZoneSpec is needed for the async() test helper but could not be found. ' +
+                'Please make sure that your environment includes zone.js/plugins/proxy');
+        }
+        const proxyZoneSpec = ProxyZoneSpec.get();
+        ProxyZoneSpec.assertPresent();
+        // We need to create the AsyncTestZoneSpec outside the ProxyZone.
+        // If we do it in ProxyZone then we will get to infinite recursion.
+        const proxyZone = Zone.current.getZoneWith('ProxyZoneSpec');
+        const previousDelegate = proxyZoneSpec.getDelegate();
+        proxyZone.parent.run(() => {
+            const testZoneSpec = new AsyncTestZoneSpec(() => {
+                // Need to restore the original zone.
+                if (proxyZoneSpec.getDelegate() == testZoneSpec) {
+                    // Only reset the zone spec if it's
+                    // still this one. Otherwise, assume
+                    // it's OK.
+                    proxyZoneSpec.setDelegate(previousDelegate);
+                }
+                testZoneSpec.unPatchPromiseForTest();
+                currentZone.run(() => {
+                    finishCallback();
+                });
+            }, (error) => {
+                // Need to restore the original zone.
+                if (proxyZoneSpec.getDelegate() == testZoneSpec) {
+                    // Only reset the zone spec if it's sill this one. Otherwise, assume it's OK.
+                    proxyZoneSpec.setDelegate(previousDelegate);
+                }
+                testZoneSpec.unPatchPromiseForTest();
+                currentZone.run(() => {
+                    failCallback(error);
+                });
+            }, 'test');
+            proxyZoneSpec.setDelegate(testZoneSpec);
+            testZoneSpec.patchPromiseForTest();
+        });
+        return Zone.current.runGuarded(fn, context);
+    }
+});

my-app/node_modules/zone.js/fesm2015/async-test.min.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */!function(e){class n{static{this.symbolParentUnresolved=Zone.__symbol__("parentUnresolved")}constructor(n,s,t){this.finishCallback=n,this.failCallback=s,this._pendingMicroTasks=!1,this._pendingMacroTasks=!1,this._alreadyErrored=!1,this._isSync=!1,this._existingFinishTimer=null,this.entryFunction=null,this.runZone=Zone.current,this.unresolvedChainedPromiseCount=0,this.supportWaitUnresolvedChainedPromise=!1,this.name="asyncTestZone for "+t,this.properties={AsyncTestZoneSpec:this},this.supportWaitUnresolvedChainedPromise=!0===e[Zone.__symbol__("supportWaitUnResolvedChainedPromise")]}isUnresolvedChainedPromisePending(){return this.unresolvedChainedPromiseCount>0}_finishCallbackIfDone(){null!==this._existingFinishTimer&&(clearTimeout(this._existingFinishTimer),this._existingFinishTimer=null),this._pendingMicroTasks||this._pendingMacroTasks||this.supportWaitUnresolvedChainedPromise&&this.isUnresolvedChainedPromisePending()||this.runZone.run((()=>{this._existingFinishTimer=setTimeout((()=>{this._alreadyErrored||this._pendingMicroTasks||this._pendingMacroTasks||this.finishCallback()}),0)}))}patchPromiseForTest(){if(!this.supportWaitUnresolvedChainedPromise)return;const e=Promise[Zone.__symbol__("patchPromiseForTest")];e&&e()}unPatchPromiseForTest(){if(!this.supportWaitUnresolvedChainedPromise)return;const e=Promise[Zone.__symbol__("unPatchPromiseForTest")];e&&e()}onScheduleTask(e,s,t,i){return"eventTask"!==i.type&&(this._isSync=!1),"microTask"===i.type&&i.data&&i.data instanceof Promise&&!0===i.data[n.symbolParentUnresolved]&&this.unresolvedChainedPromiseCount--,e.scheduleTask(t,i)}onInvokeTask(e,n,s,t,i,r){return"eventTask"!==t.type&&(this._isSync=!1),e.invokeTask(s,t,i,r)}onCancelTask(e,n,s,t){return"eventTask"!==t.type&&(this._isSync=!1),e.cancelTask(s,t)}onInvoke(e,n,s,t,i,r,o){this.entryFunction||(this.entryFunction=t);try{return this._isSync=!0,e.invoke(s,t,i,r,o)}finally{this._isSync&&this.entryFunction===t&&this._finishCallbackIfDone()}}onHandleError(e,n,s,t){return e.handleError(s,t)&&(this.failCallback(t),this._alreadyErrored=!0),!1}onHasTask(e,n,s,t){e.hasTask(s,t),n===s&&("microTask"==t.change?(this._pendingMicroTasks=t.microTask,this._finishCallbackIfDone()):"macroTask"==t.change&&(this._pendingMacroTasks=t.macroTask,this._finishCallbackIfDone()))}}Zone.AsyncTestZoneSpec=n}("undefined"!=typeof window&&window||"undefined"!=typeof self&&self||global),Zone.__load_patch("asynctest",((e,n,s)=>{function t(e,s,t,i){const r=n.current,o=n.AsyncTestZoneSpec;if(void 0===o)throw new Error("AsyncTestZoneSpec is needed for the async() test helper but could not be found. Please make sure that your environment includes zone.js/plugins/async-test");const a=n.ProxyZoneSpec;if(!a)throw new Error("ProxyZoneSpec is needed for the async() test helper but could not be found. Please make sure that your environment includes zone.js/plugins/proxy");const h=a.get();a.assertPresent();const c=n.current.getZoneWith("ProxyZoneSpec"),l=h.getDelegate();return c.parent.run((()=>{const e=new o((()=>{h.getDelegate()==e&&h.setDelegate(l),e.unPatchPromiseForTest(),r.run((()=>{t()}))}),(n=>{h.getDelegate()==e&&h.setDelegate(l),e.unPatchPromiseForTest(),r.run((()=>{i(n)}))}),"test");h.setDelegate(e),e.patchPromiseForTest()})),n.current.runGuarded(e,s)}n[s.symbol("asyncTest")]=function n(s){return e.jasmine?function(e){e||((e=function(){}).fail=function(e){throw e}),t(s,this,e,(n=>{if("string"==typeof n)return e.fail(new Error(n));e.fail(n)}))}:function(){return new Promise(((e,n)=>{t(s,this,e,n)}))}}}));

my-app/node_modules/zone.js/fesm2015/fake-async-test.js

@@ -0,0 +1,731 @@
+'use strict';
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+(function (global) {
+    const OriginalDate = global.Date;
+    // Since when we compile this file to `es2015`, and if we define
+    // this `FakeDate` as `class FakeDate`, and then set `FakeDate.prototype`
+    // there will be an error which is `Cannot assign to read only property 'prototype'`
+    // so we need to use function implementation here.
+    function FakeDate() {
+        if (arguments.length === 0) {
+            const d = new OriginalDate();
+            d.setTime(FakeDate.now());
+            return d;
+        }
+        else {
+            const args = Array.prototype.slice.call(arguments);
+            return new OriginalDate(...args);
+        }
+    }
+    FakeDate.now = function () {
+        const fakeAsyncTestZoneSpec = Zone.current.get('FakeAsyncTestZoneSpec');
+        if (fakeAsyncTestZoneSpec) {
+            return fakeAsyncTestZoneSpec.getFakeSystemTime();
+        }
+        return OriginalDate.now.apply(this, arguments);
+    };
+    FakeDate.UTC = OriginalDate.UTC;
+    FakeDate.parse = OriginalDate.parse;
+    // keep a reference for zone patched timer function
+    const timers = {
+        setTimeout: global.setTimeout,
+        setInterval: global.setInterval,
+        clearTimeout: global.clearTimeout,
+        clearInterval: global.clearInterval
+    };
+    class Scheduler {
+        // Next scheduler id.
+        static { this.nextId = 1; }
+        constructor() {
+            // Scheduler queue with the tuple of end time and callback function - sorted by end time.
+            this._schedulerQueue = [];
+            // Current simulated time in millis.
+            this._currentTickTime = 0;
+            // Current fake system base time in millis.
+            this._currentFakeBaseSystemTime = OriginalDate.now();
+            // track requeuePeriodicTimer
+            this._currentTickRequeuePeriodicEntries = [];
+        }
+        getCurrentTickTime() {
+            return this._currentTickTime;
+        }
+        getFakeSystemTime() {
+            return this._currentFakeBaseSystemTime + this._currentTickTime;
+        }
+        setFakeBaseSystemTime(fakeBaseSystemTime) {
+            this._currentFakeBaseSystemTime = fakeBaseSystemTime;
+        }
+        getRealSystemTime() {
+            return OriginalDate.now();
+        }
+        scheduleFunction(cb, delay, options) {
+            options = {
+                ...{
+                    args: [],
+                    isPeriodic: false,
+                    isRequestAnimationFrame: false,
+                    id: -1,
+                    isRequeuePeriodic: false
+                },
+                ...options
+            };
+            let currentId = options.id < 0 ? Scheduler.nextId++ : options.id;
+            let endTime = this._currentTickTime + delay;
+            // Insert so that scheduler queue remains sorted by end time.
+            let newEntry = {
+                endTime: endTime,
+                id: currentId,
+                func: cb,
+                args: options.args,
+                delay: delay,
+                isPeriodic: options.isPeriodic,
+                isRequestAnimationFrame: options.isRequestAnimationFrame
+            };
+            if (options.isRequeuePeriodic) {
+                this._currentTickRequeuePeriodicEntries.push(newEntry);
+            }
+            let i = 0;
+            for (; i < this._schedulerQueue.length; i++) {
+                let currentEntry = this._schedulerQueue[i];
+                if (newEntry.endTime < currentEntry.endTime) {
+                    break;
+                }
+            }
+            this._schedulerQueue.splice(i, 0, newEntry);
+            return currentId;
+        }
+        removeScheduledFunctionWithId(id) {
+            for (let i = 0; i < this._schedulerQueue.length; i++) {
+                if (this._schedulerQueue[i].id == id) {
+                    this._schedulerQueue.splice(i, 1);
+                    break;
+                }
+            }
+        }
+        removeAll() {
+            this._schedulerQueue = [];
+        }
+        getTimerCount() {
+            return this._schedulerQueue.length;
+        }
+        tickToNext(step = 1, doTick, tickOptions) {
+            if (this._schedulerQueue.length < step) {
+                return;
+            }
+            // Find the last task currently queued in the scheduler queue and tick
+            // till that time.
+            const startTime = this._currentTickTime;
+            const targetTask = this._schedulerQueue[step - 1];
+            this.tick(targetTask.endTime - startTime, doTick, tickOptions);
+        }
+        tick(millis = 0, doTick, tickOptions) {
+            let finalTime = this._currentTickTime + millis;
+            let lastCurrentTime = 0;
+            tickOptions = Object.assign({ processNewMacroTasksSynchronously: true }, tickOptions);
+            // we need to copy the schedulerQueue so nested timeout
+            // will not be wrongly called in the current tick
+            // https://github.com/angular/angular/issues/33799
+            const schedulerQueue = tickOptions.processNewMacroTasksSynchronously ?
+                this._schedulerQueue :
+                this._schedulerQueue.slice();
+            if (schedulerQueue.length === 0 && doTick) {
+                doTick(millis);
+                return;
+            }
+            while (schedulerQueue.length > 0) {
+                // clear requeueEntries before each loop
+                this._currentTickRequeuePeriodicEntries = [];
+                let current = schedulerQueue[0];
+                if (finalTime < current.endTime) {
+                    // Done processing the queue since it's sorted by endTime.
+                    break;
+                }
+                else {
+                    // Time to run scheduled function. Remove it from the head of queue.
+                    let current = schedulerQueue.shift();
+                    if (!tickOptions.processNewMacroTasksSynchronously) {
+                        const idx = this._schedulerQueue.indexOf(current);
+                        if (idx >= 0) {
+                            this._schedulerQueue.splice(idx, 1);
+                        }
+                    }
+                    lastCurrentTime = this._currentTickTime;
+                    this._currentTickTime = current.endTime;
+                    if (doTick) {
+                        doTick(this._currentTickTime - lastCurrentTime);
+                    }
+                    let retval = current.func.apply(global, current.isRequestAnimationFrame ? [this._currentTickTime] : current.args);
+                    if (!retval) {
+                        // Uncaught exception in the current scheduled function. Stop processing the queue.
+                        break;
+                    }
+                    // check is there any requeue periodic entry is added in
+                    // current loop, if there is, we need to add to current loop
+                    if (!tickOptions.processNewMacroTasksSynchronously) {
+                        this._currentTickRequeuePeriodicEntries.forEach(newEntry => {
+                            let i = 0;
+                            for (; i < schedulerQueue.length; i++) {
+                                const currentEntry = schedulerQueue[i];
+                                if (newEntry.endTime < currentEntry.endTime) {
+                                    break;
+                                }
+                            }
+                            schedulerQueue.splice(i, 0, newEntry);
+                        });
+                    }
+                }
+            }
+            lastCurrentTime = this._currentTickTime;
+            this._currentTickTime = finalTime;
+            if (doTick) {
+                doTick(this._currentTickTime - lastCurrentTime);
+            }
+        }
+        flushOnlyPendingTimers(doTick) {
+            if (this._schedulerQueue.length === 0) {
+                return 0;
+            }
+            // Find the last task currently queued in the scheduler queue and tick
+            // till that time.
+            const startTime = this._currentTickTime;
+            const lastTask = this._schedulerQueue[this._schedulerQueue.length - 1];
+            this.tick(lastTask.endTime - startTime, doTick, { processNewMacroTasksSynchronously: false });
+            return this._currentTickTime - startTime;
+        }
+        flush(limit = 20, flushPeriodic = false, doTick) {
+            if (flushPeriodic) {
+                return this.flushPeriodic(doTick);
+            }
+            else {
+                return this.flushNonPeriodic(limit, doTick);
+            }
+        }
+        flushPeriodic(doTick) {
+            if (this._schedulerQueue.length === 0) {
+                return 0;
+            }
+            // Find the last task currently queued in the scheduler queue and tick
+            // till that time.
+            const startTime = this._currentTickTime;
+            const lastTask = this._schedulerQueue[this._schedulerQueue.length - 1];
+            this.tick(lastTask.endTime - startTime, doTick);
+            return this._currentTickTime - startTime;
+        }
+        flushNonPeriodic(limit, doTick) {
+            const startTime = this._currentTickTime;
+            let lastCurrentTime = 0;
+            let count = 0;
+            while (this._schedulerQueue.length > 0) {
+                count++;
+                if (count > limit) {
+                    throw new Error('flush failed after reaching the limit of ' + limit +
+                        ' tasks. Does your code use a polling timeout?');
+                }
+                // flush only non-periodic timers.
+                // If the only remaining tasks are periodic(or requestAnimationFrame), finish flushing.
+                if (this._schedulerQueue.filter(task => !task.isPeriodic && !task.isRequestAnimationFrame)
+                    .length === 0) {
+                    break;
+                }
+                const current = this._schedulerQueue.shift();
+                lastCurrentTime = this._currentTickTime;
+                this._currentTickTime = current.endTime;
+                if (doTick) {
+                    // Update any secondary schedulers like Jasmine mock Date.
+                    doTick(this._currentTickTime - lastCurrentTime);
+                }
+                const retval = current.func.apply(global, current.args);
+                if (!retval) {
+                    // Uncaught exception in the current scheduled function. Stop processing the queue.
+                    break;
+                }
+            }
+            return this._currentTickTime - startTime;
+        }
+    }
+    class FakeAsyncTestZoneSpec {
+        static assertInZone() {
+            if (Zone.current.get('FakeAsyncTestZoneSpec') == null) {
+                throw new Error('The code should be running in the fakeAsync zone to call this function');
+            }
+        }
+        constructor(namePrefix, trackPendingRequestAnimationFrame = false, macroTaskOptions) {
+            this.trackPendingRequestAnimationFrame = trackPendingRequestAnimationFrame;
+            this.macroTaskOptions = macroTaskOptions;
+            this._scheduler = new Scheduler();
+            this._microtasks = [];
+            this._lastError = null;
+            this._uncaughtPromiseErrors = Promise[Zone.__symbol__('uncaughtPromiseErrors')];
+            this.pendingPeriodicTimers = [];
+            this.pendingTimers = [];
+            this.patchDateLocked = false;
+            this.properties = { 'FakeAsyncTestZoneSpec': this };
+            this.name = 'fakeAsyncTestZone for ' + namePrefix;
+            // in case user can't access the construction of FakeAsyncTestSpec
+            // user can also define macroTaskOptions by define a global variable.
+            if (!this.macroTaskOptions) {
+                this.macroTaskOptions = global[Zone.__symbol__('FakeAsyncTestMacroTask')];
+            }
+        }
+        _fnAndFlush(fn, completers) {
+            return (...args) => {
+                fn.apply(global, args);
+                if (this._lastError === null) { // Success
+                    if (completers.onSuccess != null) {
+                        completers.onSuccess.apply(global);
+                    }
+                    // Flush microtasks only on success.
+                    this.flushMicrotasks();
+                }
+                else { // Failure
+                    if (completers.onError != null) {
+                        completers.onError.apply(global);
+                    }
+                }
+                // Return true if there were no errors, false otherwise.
+                return this._lastError === null;
+            };
+        }
+        static _removeTimer(timers, id) {
+            let index = timers.indexOf(id);
+            if (index > -1) {
+                timers.splice(index, 1);
+            }
+        }
+        _dequeueTimer(id) {
+            return () => {
+                FakeAsyncTestZoneSpec._removeTimer(this.pendingTimers, id);
+            };
+        }
+        _requeuePeriodicTimer(fn, interval, args, id) {
+            return () => {
+                // Requeue the timer callback if it's not been canceled.
+                if (this.pendingPeriodicTimers.indexOf(id) !== -1) {
+                    this._scheduler.scheduleFunction(fn, interval, { args, isPeriodic: true, id, isRequeuePeriodic: true });
+                }
+            };
+        }
+        _dequeuePeriodicTimer(id) {
+            return () => {
+                FakeAsyncTestZoneSpec._removeTimer(this.pendingPeriodicTimers, id);
+            };
+        }
+        _setTimeout(fn, delay, args, isTimer = true) {
+            let removeTimerFn = this._dequeueTimer(Scheduler.nextId);
+            // Queue the callback and dequeue the timer on success and error.
+            let cb = this._fnAndFlush(fn, { onSuccess: removeTimerFn, onError: removeTimerFn });
+            let id = this._scheduler.scheduleFunction(cb, delay, { args, isRequestAnimationFrame: !isTimer });
+            if (isTimer) {
+                this.pendingTimers.push(id);
+            }
+            return id;
+        }
+        _clearTimeout(id) {
+            FakeAsyncTestZoneSpec._removeTimer(this.pendingTimers, id);
+            this._scheduler.removeScheduledFunctionWithId(id);
+        }
+        _setInterval(fn, interval, args) {
+            let id = Scheduler.nextId;
+            let completers = { onSuccess: null, onError: this._dequeuePeriodicTimer(id) };
+            let cb = this._fnAndFlush(fn, completers);
+            // Use the callback created above to requeue on success.
+            completers.onSuccess = this._requeuePeriodicTimer(cb, interval, args, id);
+            // Queue the callback and dequeue the periodic timer only on error.
+            this._scheduler.scheduleFunction(cb, interval, { args, isPeriodic: true });
+            this.pendingPeriodicTimers.push(id);
+            return id;
+        }
+        _clearInterval(id) {
+            FakeAsyncTestZoneSpec._removeTimer(this.pendingPeriodicTimers, id);
+            this._scheduler.removeScheduledFunctionWithId(id);
+        }
+        _resetLastErrorAndThrow() {
+            let error = this._lastError || this._uncaughtPromiseErrors[0];
+            this._uncaughtPromiseErrors.length = 0;
+            this._lastError = null;
+            throw error;
+        }
+        getCurrentTickTime() {
+            return this._scheduler.getCurrentTickTime();
+        }
+        getFakeSystemTime() {
+            return this._scheduler.getFakeSystemTime();
+        }
+        setFakeBaseSystemTime(realTime) {
+            this._scheduler.setFakeBaseSystemTime(realTime);
+        }
+        getRealSystemTime() {
+            return this._scheduler.getRealSystemTime();
+        }
+        static patchDate() {
+            if (!!global[Zone.__symbol__('disableDatePatching')]) {
+                // we don't want to patch global Date
+                // because in some case, global Date
+                // is already being patched, we need to provide
+                // an option to let user still use their
+                // own version of Date.
+                return;
+            }
+            if (global['Date'] === FakeDate) {
+                // already patched
+                return;
+            }
+            global['Date'] = FakeDate;
+            FakeDate.prototype = OriginalDate.prototype;
+            // try check and reset timers
+            // because jasmine.clock().install() may
+            // have replaced the global timer
+            FakeAsyncTestZoneSpec.checkTimerPatch();
+        }
+        static resetDate() {
+            if (global['Date'] === FakeDate) {
+                global['Date'] = OriginalDate;
+            }
+        }
+        static checkTimerPatch() {
+            if (global.setTimeout !== timers.setTimeout) {
+                global.setTimeout = timers.setTimeout;
+                global.clearTimeout = timers.clearTimeout;
+            }
+            if (global.setInterval !== timers.setInterval) {
+                global.setInterval = timers.setInterval;
+                global.clearInterval = timers.clearInterval;
+            }
+        }
+        lockDatePatch() {
+            this.patchDateLocked = true;
+            FakeAsyncTestZoneSpec.patchDate();
+        }
+        unlockDatePatch() {
+            this.patchDateLocked = false;
+            FakeAsyncTestZoneSpec.resetDate();
+        }
+        tickToNext(steps = 1, doTick, tickOptions = { processNewMacroTasksSynchronously: true }) {
+            if (steps <= 0) {
+                return;
+            }
+            FakeAsyncTestZoneSpec.assertInZone();
+            this.flushMicrotasks();
+            this._scheduler.tickToNext(steps, doTick, tickOptions);
+            if (this._lastError !== null) {
+                this._resetLastErrorAndThrow();
+            }
+        }
+        tick(millis = 0, doTick, tickOptions = { processNewMacroTasksSynchronously: true }) {
+            FakeAsyncTestZoneSpec.assertInZone();
+            this.flushMicrotasks();
+            this._scheduler.tick(millis, doTick, tickOptions);
+            if (this._lastError !== null) {
+                this._resetLastErrorAndThrow();
+            }
+        }
+        flushMicrotasks() {
+            FakeAsyncTestZoneSpec.assertInZone();
+            const flushErrors = () => {
+                if (this._lastError !== null || this._uncaughtPromiseErrors.length) {
+                    // If there is an error stop processing the microtask queue and rethrow the error.
+                    this._resetLastErrorAndThrow();
+                }
+            };
+            while (this._microtasks.length > 0) {
+                let microtask = this._microtasks.shift();
+                microtask.func.apply(microtask.target, microtask.args);
+            }
+            flushErrors();
+        }
+        flush(limit, flushPeriodic, doTick) {
+            FakeAsyncTestZoneSpec.assertInZone();
+            this.flushMicrotasks();
+            const elapsed = this._scheduler.flush(limit, flushPeriodic, doTick);
+            if (this._lastError !== null) {
+                this._resetLastErrorAndThrow();
+            }
+            return elapsed;
+        }
+        flushOnlyPendingTimers(doTick) {
+            FakeAsyncTestZoneSpec.assertInZone();
+            this.flushMicrotasks();
+            const elapsed = this._scheduler.flushOnlyPendingTimers(doTick);
+            if (this._lastError !== null) {
+                this._resetLastErrorAndThrow();
+            }
+            return elapsed;
+        }
+        removeAllTimers() {
+            FakeAsyncTestZoneSpec.assertInZone();
+            this._scheduler.removeAll();
+            this.pendingPeriodicTimers = [];
+            this.pendingTimers = [];
+        }
+        getTimerCount() {
+            return this._scheduler.getTimerCount() + this._microtasks.length;
+        }
+        onScheduleTask(delegate, current, target, task) {
+            switch (task.type) {
+                case 'microTask':
+                    let args = task.data && task.data.args;
+                    // should pass additional arguments to callback if have any
+                    // currently we know process.nextTick will have such additional
+                    // arguments
+                    let additionalArgs;
+                    if (args) {
+                        let callbackIndex = task.data.cbIdx;
+                        if (typeof args.length === 'number' && args.length > callbackIndex + 1) {
+                            additionalArgs = Array.prototype.slice.call(args, callbackIndex + 1);
+                        }
+                    }
+                    this._microtasks.push({
+                        func: task.invoke,
+                        args: additionalArgs,
+                        target: task.data && task.data.target
+                    });
+                    break;
+                case 'macroTask':
+                    switch (task.source) {
+                        case 'setTimeout':
+                            task.data['handleId'] = this._setTimeout(task.invoke, task.data['delay'], Array.prototype.slice.call(task.data['args'], 2));
+                            break;
+                        case 'setImmediate':
+                            task.data['handleId'] = this._setTimeout(task.invoke, 0, Array.prototype.slice.call(task.data['args'], 1));
+                            break;
+                        case 'setInterval':
+                            task.data['handleId'] = this._setInterval(task.invoke, task.data['delay'], Array.prototype.slice.call(task.data['args'], 2));
+                            break;
+                        case 'XMLHttpRequest.send':
+                            throw new Error('Cannot make XHRs from within a fake async test. Request URL: ' +
+                                task.data['url']);
+                        case 'requestAnimationFrame':
+                        case 'webkitRequestAnimationFrame':
+                        case 'mozRequestAnimationFrame':
+                            // Simulate a requestAnimationFrame by using a setTimeout with 16 ms.
+                            // (60 frames per second)
+                            task.data['handleId'] = this._setTimeout(task.invoke, 16, task.data['args'], this.trackPendingRequestAnimationFrame);
+                            break;
+                        default:
+                            // user can define which macroTask they want to support by passing
+                            // macroTaskOptions
+                            const macroTaskOption = this.findMacroTaskOption(task);
+                            if (macroTaskOption) {
+                                const args = task.data && task.data['args'];
+                                const delay = args && args.length > 1 ? args[1] : 0;
+                                let callbackArgs = macroTaskOption.callbackArgs ? macroTaskOption.callbackArgs : args;
+                                if (!!macroTaskOption.isPeriodic) {
+                                    // periodic macroTask, use setInterval to simulate
+                                    task.data['handleId'] = this._setInterval(task.invoke, delay, callbackArgs);
+                                    task.data.isPeriodic = true;
+                                }
+                                else {
+                                    // not periodic, use setTimeout to simulate
+                                    task.data['handleId'] = this._setTimeout(task.invoke, delay, callbackArgs);
+                                }
+                                break;
+                            }
+                            throw new Error('Unknown macroTask scheduled in fake async test: ' + task.source);
+                    }
+                    break;
+                case 'eventTask':
+                    task = delegate.scheduleTask(target, task);
+                    break;
+            }
+            return task;
+        }
+        onCancelTask(delegate, current, target, task) {
+            switch (task.source) {
+                case 'setTimeout':
+                case 'requestAnimationFrame':
+                case 'webkitRequestAnimationFrame':
+                case 'mozRequestAnimationFrame':
+                    return this._clearTimeout(task.data['handleId']);
+                case 'setInterval':
+                    return this._clearInterval(task.data['handleId']);
+                default:
+                    // user can define which macroTask they want to support by passing
+                    // macroTaskOptions
+                    const macroTaskOption = this.findMacroTaskOption(task);
+                    if (macroTaskOption) {
+                        const handleId = task.data['handleId'];
+                        return macroTaskOption.isPeriodic ? this._clearInterval(handleId) :
+                            this._clearTimeout(handleId);
+                    }
+                    return delegate.cancelTask(target, task);
+            }
+        }
+        onInvoke(delegate, current, target, callback, applyThis, applyArgs, source) {
+            try {
+                FakeAsyncTestZoneSpec.patchDate();
+                return delegate.invoke(target, callback, applyThis, applyArgs, source);
+            }
+            finally {
+                if (!this.patchDateLocked) {
+                    FakeAsyncTestZoneSpec.resetDate();
+                }
+            }
+        }
+        findMacroTaskOption(task) {
+            if (!this.macroTaskOptions) {
+                return null;
+            }
+            for (let i = 0; i < this.macroTaskOptions.length; i++) {
+                const macroTaskOption = this.macroTaskOptions[i];
+                if (macroTaskOption.source === task.source) {
+                    return macroTaskOption;
+                }
+            }
+            return null;
+        }
+        onHandleError(parentZoneDelegate, currentZone, targetZone, error) {
+            this._lastError = error;
+            return false; // Don't propagate error to parent zone.
+        }
+    }
+    // Export the class so that new instances can be created with proper
+    // constructor params.
+    Zone['FakeAsyncTestZoneSpec'] = FakeAsyncTestZoneSpec;
+})(typeof window === 'object' && window || typeof self === 'object' && self || global);
+Zone.__load_patch('fakeasync', (global, Zone, api) => {
+    const FakeAsyncTestZoneSpec = Zone && Zone['FakeAsyncTestZoneSpec'];
+    function getProxyZoneSpec() {
+        return Zone && Zone['ProxyZoneSpec'];
+    }
+    let _fakeAsyncTestZoneSpec = null;
+    /**
+     * Clears out the shared fake async zone for a test.
+     * To be called in a global `beforeEach`.
+     *
+     * @experimental
+     */
+    function resetFakeAsyncZone() {
+        if (_fakeAsyncTestZoneSpec) {
+            _fakeAsyncTestZoneSpec.unlockDatePatch();
+        }
+        _fakeAsyncTestZoneSpec = null;
+        // in node.js testing we may not have ProxyZoneSpec in which case there is nothing to reset.
+        getProxyZoneSpec() && getProxyZoneSpec().assertPresent().resetDelegate();
+    }
+    /**
+     * Wraps a function to be executed in the fakeAsync zone:
+     * - microtasks are manually executed by calling `flushMicrotasks()`,
+     * - timers are synchronous, `tick()` simulates the asynchronous passage of time.
+     *
+     * If there are any pending timers at the end of the function, an exception will be thrown.
+     *
+     * Can be used to wrap inject() calls.
+     *
+     * ## Example
+     *
+     * {@example core/testing/ts/fake_async.ts region='basic'}
+     *
+     * @param fn
+     * @returns The function wrapped to be executed in the fakeAsync zone
+     *
+     * @experimental
+     */
+    function fakeAsync(fn) {
+        // Not using an arrow function to preserve context passed from call site
+        const fakeAsyncFn = function (...args) {
+            const ProxyZoneSpec = getProxyZoneSpec();
+            if (!ProxyZoneSpec) {
+                throw new Error('ProxyZoneSpec is needed for the async() test helper but could not be found. ' +
+                    'Please make sure that your environment includes zone.js/plugins/proxy');
+            }
+            const proxyZoneSpec = ProxyZoneSpec.assertPresent();
+            if (Zone.current.get('FakeAsyncTestZoneSpec')) {
+                throw new Error('fakeAsync() calls can not be nested');
+            }
+            try {
+                // in case jasmine.clock init a fakeAsyncTestZoneSpec
+                if (!_fakeAsyncTestZoneSpec) {
+                    if (proxyZoneSpec.getDelegate() instanceof FakeAsyncTestZoneSpec) {
+                        throw new Error('fakeAsync() calls can not be nested');
+                    }
+                    _fakeAsyncTestZoneSpec = new FakeAsyncTestZoneSpec();
+                }
+                let res;
+                const lastProxyZoneSpec = proxyZoneSpec.getDelegate();
+                proxyZoneSpec.setDelegate(_fakeAsyncTestZoneSpec);
+                _fakeAsyncTestZoneSpec.lockDatePatch();
+                try {
+                    res = fn.apply(this, args);
+                    flushMicrotasks();
+                }
+                finally {
+                    proxyZoneSpec.setDelegate(lastProxyZoneSpec);
+                }
+                if (_fakeAsyncTestZoneSpec.pendingPeriodicTimers.length > 0) {
+                    throw new Error(`${_fakeAsyncTestZoneSpec.pendingPeriodicTimers.length} ` +
+                        `periodic timer(s) still in the queue.`);
+                }
+                if (_fakeAsyncTestZoneSpec.pendingTimers.length > 0) {
+                    throw new Error(`${_fakeAsyncTestZoneSpec.pendingTimers.length} timer(s) still in the queue.`);
+                }
+                return res;
+            }
+            finally {
+                resetFakeAsyncZone();
+            }
+        };
+        fakeAsyncFn.isFakeAsync = true;
+        return fakeAsyncFn;
+    }
+    function _getFakeAsyncZoneSpec() {
+        if (_fakeAsyncTestZoneSpec == null) {
+            _fakeAsyncTestZoneSpec = Zone.current.get('FakeAsyncTestZoneSpec');
+            if (_fakeAsyncTestZoneSpec == null) {
+                throw new Error('The code should be running in the fakeAsync zone to call this function');
+            }
+        }
+        return _fakeAsyncTestZoneSpec;
+    }
+    /**
+     * Simulates the asynchronous passage of time for the timers in the fakeAsync zone.
+     *
+     * The microtasks queue is drained at the very start of this function and after any timer callback
+     * has been executed.
+     *
+     * ## Example
+     *
+     * {@example core/testing/ts/fake_async.ts region='basic'}
+     *
+     * @experimental
+     */
+    function tick(millis = 0, ignoreNestedTimeout = false) {
+        _getFakeAsyncZoneSpec().tick(millis, null, ignoreNestedTimeout);
+    }
+    /**
+     * Simulates the asynchronous passage of time for the timers in the fakeAsync zone by
+     * draining the macrotask queue until it is empty. The returned value is the milliseconds
+     * of time that would have been elapsed.
+     *
+     * @param maxTurns
+     * @returns The simulated time elapsed, in millis.
+     *
+     * @experimental
+     */
+    function flush(maxTurns) {
+        return _getFakeAsyncZoneSpec().flush(maxTurns);
+    }
+    /**
+     * Discard all remaining periodic tasks.
+     *
+     * @experimental
+     */
+    function discardPeriodicTasks() {
+        const zoneSpec = _getFakeAsyncZoneSpec();
+        zoneSpec.pendingPeriodicTimers;
+        zoneSpec.pendingPeriodicTimers.length = 0;
+    }
+    /**
+     * Flush any pending microtasks.
+     *
+     * @experimental
+     */
+    function flushMicrotasks() {
+        _getFakeAsyncZoneSpec().flushMicrotasks();
+    }
+    Zone[api.symbol('fakeAsyncTest')] =
+        { resetFakeAsyncZone, flushMicrotasks, discardPeriodicTasks, tick, flush, fakeAsync };
+}, true);

my-app/node_modules/zone.js/fesm2015/jasmine-patch.js

@@ -0,0 +1,323 @@
+'use strict';
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+/// <reference types="jasmine"/>
+Zone.__load_patch('jasmine', (global, Zone, api) => {
+    const __extends = function (d, b) {
+        for (const p in b)
+            if (b.hasOwnProperty(p))
+                d[p] = b[p];
+        function __() {
+            this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : ((__.prototype = b.prototype), new __());
+    };
+    // Patch jasmine's describe/it/beforeEach/afterEach functions so test code always runs
+    // in a testZone (ProxyZone). (See: angular/zone.js#91 & angular/angular#10503)
+    if (!Zone)
+        throw new Error('Missing: zone.js');
+    if (typeof jest !== 'undefined') {
+        // return if jasmine is a light implementation inside jest
+        // in this case, we are running inside jest not jasmine
+        return;
+    }
+    if (typeof jasmine == 'undefined' || jasmine['__zone_patch__']) {
+        return;
+    }
+    jasmine['__zone_patch__'] = true;
+    const SyncTestZoneSpec = Zone['SyncTestZoneSpec'];
+    const ProxyZoneSpec = Zone['ProxyZoneSpec'];
+    if (!SyncTestZoneSpec)
+        throw new Error('Missing: SyncTestZoneSpec');
+    if (!ProxyZoneSpec)
+        throw new Error('Missing: ProxyZoneSpec');
+    const ambientZone = Zone.current;
+    const symbol = Zone.__symbol__;
+    // whether patch jasmine clock when in fakeAsync
+    const disablePatchingJasmineClock = global[symbol('fakeAsyncDisablePatchingClock')] === true;
+    // the original variable name fakeAsyncPatchLock is not accurate, so the name will be
+    // fakeAsyncAutoFakeAsyncWhenClockPatched and if this enablePatchingJasmineClock is false, we also
+    // automatically disable the auto jump into fakeAsync feature
+    const enableAutoFakeAsyncWhenClockPatched = !disablePatchingJasmineClock &&
+        ((global[symbol('fakeAsyncPatchLock')] === true) ||
+            (global[symbol('fakeAsyncAutoFakeAsyncWhenClockPatched')] === true));
+    const ignoreUnhandledRejection = global[symbol('ignoreUnhandledRejection')] === true;
+    if (!ignoreUnhandledRejection) {
+        const globalErrors = jasmine.GlobalErrors;
+        if (globalErrors && !jasmine[symbol('GlobalErrors')]) {
+            jasmine[symbol('GlobalErrors')] = globalErrors;
+            jasmine.GlobalErrors = function () {
+                const instance = new globalErrors();
+                const originalInstall = instance.install;
+                if (originalInstall && !instance[symbol('install')]) {
+                    instance[symbol('install')] = originalInstall;
+                    instance.install = function () {
+                        const isNode = typeof process !== 'undefined' && !!process.on;
+                        // Note: Jasmine checks internally if `process` and `process.on` is defined. Otherwise,
+                        // it installs the browser rejection handler through the `global.addEventListener`.
+                        // This code may be run in the browser environment where `process` is not defined, and
+                        // this will lead to a runtime exception since Webpack 5 removed automatic Node.js
+                        // polyfills. Note, that events are named differently, it's `unhandledRejection` in
+                        // Node.js and `unhandledrejection` in the browser.
+                        const originalHandlers = isNode ? process.listeners('unhandledRejection') :
+                            global.eventListeners('unhandledrejection');
+                        const result = originalInstall.apply(this, arguments);
+                        isNode ? process.removeAllListeners('unhandledRejection') :
+                            global.removeAllListeners('unhandledrejection');
+                        if (originalHandlers) {
+                            originalHandlers.forEach(handler => {
+                                if (isNode) {
+                                    process.on('unhandledRejection', handler);
+                                }
+                                else {
+                                    global.addEventListener('unhandledrejection', handler);
+                                }
+                            });
+                        }
+                        return result;
+                    };
+                }
+                return instance;
+            };
+        }
+    }
+    // Monkey patch all of the jasmine DSL so that each function runs in appropriate zone.
+    const jasmineEnv = jasmine.getEnv();
+    ['describe', 'xdescribe', 'fdescribe'].forEach(methodName => {
+        let originalJasmineFn = jasmineEnv[methodName];
+        jasmineEnv[methodName] = function (description, specDefinitions) {
+            return originalJasmineFn.call(this, description, wrapDescribeInZone(description, specDefinitions));
+        };
+    });
+    ['it', 'xit', 'fit'].forEach(methodName => {
+        let originalJasmineFn = jasmineEnv[methodName];
+        jasmineEnv[symbol(methodName)] = originalJasmineFn;
+        jasmineEnv[methodName] = function (description, specDefinitions, timeout) {
+            arguments[1] = wrapTestInZone(specDefinitions);
+            return originalJasmineFn.apply(this, arguments);
+        };
+    });
+    ['beforeEach', 'afterEach', 'beforeAll', 'afterAll'].forEach(methodName => {
+        let originalJasmineFn = jasmineEnv[methodName];
+        jasmineEnv[symbol(methodName)] = originalJasmineFn;
+        jasmineEnv[methodName] = function (specDefinitions, timeout) {
+            arguments[0] = wrapTestInZone(specDefinitions);
+            return originalJasmineFn.apply(this, arguments);
+        };
+    });
+    if (!disablePatchingJasmineClock) {
+        // need to patch jasmine.clock().mockDate and jasmine.clock().tick() so
+        // they can work properly in FakeAsyncTest
+        const originalClockFn = (jasmine[symbol('clock')] = jasmine['clock']);
+        jasmine['clock'] = function () {
+            const clock = originalClockFn.apply(this, arguments);
+            if (!clock[symbol('patched')]) {
+                clock[symbol('patched')] = symbol('patched');
+                const originalTick = (clock[symbol('tick')] = clock.tick);
+                clock.tick = function () {
+                    const fakeAsyncZoneSpec = Zone.current.get('FakeAsyncTestZoneSpec');
+                    if (fakeAsyncZoneSpec) {
+                        return fakeAsyncZoneSpec.tick.apply(fakeAsyncZoneSpec, arguments);
+                    }
+                    return originalTick.apply(this, arguments);
+                };
+                const originalMockDate = (clock[symbol('mockDate')] = clock.mockDate);
+                clock.mockDate = function () {
+                    const fakeAsyncZoneSpec = Zone.current.get('FakeAsyncTestZoneSpec');
+                    if (fakeAsyncZoneSpec) {
+                        const dateTime = arguments.length > 0 ? arguments[0] : new Date();
+                        return fakeAsyncZoneSpec.setFakeBaseSystemTime.apply(fakeAsyncZoneSpec, dateTime && typeof dateTime.getTime === 'function' ? [dateTime.getTime()] :
+                            arguments);
+                    }
+                    return originalMockDate.apply(this, arguments);
+                };
+                // for auto go into fakeAsync feature, we need the flag to enable it
+                if (enableAutoFakeAsyncWhenClockPatched) {
+                    ['install', 'uninstall'].forEach(methodName => {
+                        const originalClockFn = (clock[symbol(methodName)] = clock[methodName]);
+                        clock[methodName] = function () {
+                            const FakeAsyncTestZoneSpec = Zone['FakeAsyncTestZoneSpec'];
+                            if (FakeAsyncTestZoneSpec) {
+                                jasmine[symbol('clockInstalled')] = 'install' === methodName;
+                                return;
+                            }
+                            return originalClockFn.apply(this, arguments);
+                        };
+                    });
+                }
+            }
+            return clock;
+        };
+    }
+    // monkey patch createSpyObj to make properties enumerable to true
+    if (!jasmine[Zone.__symbol__('createSpyObj')]) {
+        const originalCreateSpyObj = jasmine.createSpyObj;
+        jasmine[Zone.__symbol__('createSpyObj')] = originalCreateSpyObj;
+        jasmine.createSpyObj = function () {
+            const args = Array.prototype.slice.call(arguments);
+            const propertyNames = args.length >= 3 ? args[2] : null;
+            let spyObj;
+            if (propertyNames) {
+                const defineProperty = Object.defineProperty;
+                Object.defineProperty = function (obj, p, attributes) {
+                    return defineProperty.call(this, obj, p, { ...attributes, configurable: true, enumerable: true });
+                };
+                try {
+                    spyObj = originalCreateSpyObj.apply(this, args);
+                }
+                finally {
+                    Object.defineProperty = defineProperty;
+                }
+            }
+            else {
+                spyObj = originalCreateSpyObj.apply(this, args);
+            }
+            return spyObj;
+        };
+    }
+    /**
+     * Gets a function wrapping the body of a Jasmine `describe` block to execute in a
+     * synchronous-only zone.
+     */
+    function wrapDescribeInZone(description, describeBody) {
+        return function () {
+            // Create a synchronous-only zone in which to run `describe` blocks in order to raise an
+            // error if any asynchronous operations are attempted inside of a `describe`.
+            const syncZone = ambientZone.fork(new SyncTestZoneSpec(`jasmine.describe#${description}`));
+            return syncZone.run(describeBody, this, arguments);
+        };
+    }
+    function runInTestZone(testBody, applyThis, queueRunner, done) {
+        const isClockInstalled = !!jasmine[symbol('clockInstalled')];
+        queueRunner.testProxyZoneSpec;
+        const testProxyZone = queueRunner.testProxyZone;
+        if (isClockInstalled && enableAutoFakeAsyncWhenClockPatched) {
+            // auto run a fakeAsync
+            const fakeAsyncModule = Zone[Zone.__symbol__('fakeAsyncTest')];
+            if (fakeAsyncModule && typeof fakeAsyncModule.fakeAsync === 'function') {
+                testBody = fakeAsyncModule.fakeAsync(testBody);
+            }
+        }
+        if (done) {
+            return testProxyZone.run(testBody, applyThis, [done]);
+        }
+        else {
+            return testProxyZone.run(testBody, applyThis);
+        }
+    }
+    /**
+     * Gets a function wrapping the body of a Jasmine `it/beforeEach/afterEach` block to
+     * execute in a ProxyZone zone.
+     * This will run in `testProxyZone`. The `testProxyZone` will be reset by the `ZoneQueueRunner`
+     */
+    function wrapTestInZone(testBody) {
+        // The `done` callback is only passed through if the function expects at least one argument.
+        // Note we have to make a function with correct number of arguments, otherwise jasmine will
+        // think that all functions are sync or async.
+        return (testBody && (testBody.length ? function (done) {
+            return runInTestZone(testBody, this, this.queueRunner, done);
+        } : function () {
+            return runInTestZone(testBody, this, this.queueRunner);
+        }));
+    }
+    const QueueRunner = jasmine.QueueRunner;
+    jasmine.QueueRunner = (function (_super) {
+        __extends(ZoneQueueRunner, _super);
+        function ZoneQueueRunner(attrs) {
+            if (attrs.onComplete) {
+                attrs.onComplete = (fn => () => {
+                    // All functions are done, clear the test zone.
+                    this.testProxyZone = null;
+                    this.testProxyZoneSpec = null;
+                    ambientZone.scheduleMicroTask('jasmine.onComplete', fn);
+                })(attrs.onComplete);
+            }
+            const nativeSetTimeout = global[Zone.__symbol__('setTimeout')];
+            const nativeClearTimeout = global[Zone.__symbol__('clearTimeout')];
+            if (nativeSetTimeout) {
+                // should run setTimeout inside jasmine outside of zone
+                attrs.timeout = {
+                    setTimeout: nativeSetTimeout ? nativeSetTimeout : global.setTimeout,
+                    clearTimeout: nativeClearTimeout ? nativeClearTimeout : global.clearTimeout
+                };
+            }
+            // create a userContext to hold the queueRunner itself
+            // so we can access the testProxy in it/xit/beforeEach ...
+            if (jasmine.UserContext) {
+                if (!attrs.userContext) {
+                    attrs.userContext = new jasmine.UserContext();
+                }
+                attrs.userContext.queueRunner = this;
+            }
+            else {
+                if (!attrs.userContext) {
+                    attrs.userContext = {};
+                }
+                attrs.userContext.queueRunner = this;
+            }
+            // patch attrs.onException
+            const onException = attrs.onException;
+            attrs.onException = function (error) {
+                if (error &&
+                    error.message ===
+                        'Timeout - Async callback was not invoked within timeout specified by jasmine.DEFAULT_TIMEOUT_INTERVAL.') {
+                    // jasmine timeout, we can make the error message more
+                    // reasonable to tell what tasks are pending
+                    const proxyZoneSpec = this && this.testProxyZoneSpec;
+                    if (proxyZoneSpec) {
+                        const pendingTasksInfo = proxyZoneSpec.getAndClearPendingTasksInfo();
+                        try {
+                            // try catch here in case error.message is not writable
+                            error.message += pendingTasksInfo;
+                        }
+                        catch (err) {
+                        }
+                    }
+                }
+                if (onException) {
+                    onException.call(this, error);
+                }
+            };
+            _super.call(this, attrs);
+        }
+        ZoneQueueRunner.prototype.execute = function () {
+            let zone = Zone.current;
+            let isChildOfAmbientZone = false;
+            while (zone) {
+                if (zone === ambientZone) {
+                    isChildOfAmbientZone = true;
+                    break;
+                }
+                zone = zone.parent;
+            }
+            if (!isChildOfAmbientZone)
+                throw new Error('Unexpected Zone: ' + Zone.current.name);
+            // This is the zone which will be used for running individual tests.
+            // It will be a proxy zone, so that the tests function can retroactively install
+            // different zones.
+            // Example:
+            //   - In beforeEach() do childZone = Zone.current.fork(...);
+            //   - In it() try to do fakeAsync(). The issue is that because the beforeEach forked the
+            //     zone outside of fakeAsync it will be able to escape the fakeAsync rules.
+            //   - Because ProxyZone is parent fo `childZone` fakeAsync can retroactively add
+            //     fakeAsync behavior to the childZone.
+            this.testProxyZoneSpec = new ProxyZoneSpec();
+            this.testProxyZone = ambientZone.fork(this.testProxyZoneSpec);
+            if (!Zone.currentTask) {
+                // if we are not running in a task then if someone would register a
+                // element.addEventListener and then calling element.click() the
+                // addEventListener callback would think that it is the top most task and would
+                // drain the microtask queue on element.click() which would be incorrect.
+                // For this reason we always force a task when running jasmine tests.
+                Zone.current.scheduleMicroTask('jasmine.execute().forceTask', () => QueueRunner.prototype.execute.call(this));
+            }
+            else {
+                _super.prototype.execute.call(this);
+            }
+        };
+        return ZoneQueueRunner;
+    })(QueueRunner);
+});

my-app/node_modules/zone.js/fesm2015/jasmine-patch.min.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */Zone.__load_patch("jasmine",((e,n,t)=>{if(!n)throw new Error("Missing: zone.js");if("undefined"!=typeof jest)return;if("undefined"==typeof jasmine||jasmine.__zone_patch__)return;jasmine.__zone_patch__=!0;const o=n.SyncTestZoneSpec,s=n.ProxyZoneSpec;if(!o)throw new Error("Missing: SyncTestZoneSpec");if(!s)throw new Error("Missing: ProxyZoneSpec");const r=n.current,c=n.__symbol__,i=!0===e[c("fakeAsyncDisablePatchingClock")],a=!i&&(!0===e[c("fakeAsyncPatchLock")]||!0===e[c("fakeAsyncAutoFakeAsyncWhenClockPatched")]);if(!0!==e[c("ignoreUnhandledRejection")]){const n=jasmine.GlobalErrors;n&&!jasmine[c("GlobalErrors")]&&(jasmine[c("GlobalErrors")]=n,jasmine.GlobalErrors=function(){const t=new n,o=t.install;return o&&!t[c("install")]&&(t[c("install")]=o,t.install=function(){const n="undefined"!=typeof process&&!!process.on,t=n?process.listeners("unhandledRejection"):e.eventListeners("unhandledrejection"),s=o.apply(this,arguments);return n?process.removeAllListeners("unhandledRejection"):e.removeAllListeners("unhandledrejection"),t&&t.forEach((t=>{n?process.on("unhandledRejection",t):e.addEventListener("unhandledrejection",t)})),s}),t})}const l=jasmine.getEnv();if(["describe","xdescribe","fdescribe"].forEach((e=>{let n=l[e];l[e]=function(e,t){return n.call(this,e,function s(e,n){return function(){return r.fork(new o(`jasmine.describe#${e}`)).run(n,this,arguments)}}(e,t))}})),["it","xit","fit"].forEach((e=>{let n=l[e];l[c(e)]=n,l[e]=function(e,t,o){return arguments[1]=p(t),n.apply(this,arguments)}})),["beforeEach","afterEach","beforeAll","afterAll"].forEach((e=>{let n=l[e];l[c(e)]=n,l[e]=function(e,t){return arguments[0]=p(e),n.apply(this,arguments)}})),!i){const e=jasmine[c("clock")]=jasmine.clock;jasmine.clock=function(){const t=e.apply(this,arguments);if(!t[c("patched")]){t[c("patched")]=c("patched");const e=t[c("tick")]=t.tick;t.tick=function(){const t=n.current.get("FakeAsyncTestZoneSpec");return t?t.tick.apply(t,arguments):e.apply(this,arguments)};const o=t[c("mockDate")]=t.mockDate;t.mockDate=function(){const e=n.current.get("FakeAsyncTestZoneSpec");if(e){const n=arguments.length>0?arguments[0]:new Date;return e.setFakeBaseSystemTime.apply(e,n&&"function"==typeof n.getTime?[n.getTime()]:arguments)}return o.apply(this,arguments)},a&&["install","uninstall"].forEach((e=>{const o=t[c(e)]=t[e];t[e]=function(){if(!n.FakeAsyncTestZoneSpec)return o.apply(this,arguments);jasmine[c("clockInstalled")]="install"===e}}))}return t}}if(!jasmine[n.__symbol__("createSpyObj")]){const e=jasmine.createSpyObj;jasmine[n.__symbol__("createSpyObj")]=e,jasmine.createSpyObj=function(){const n=Array.prototype.slice.call(arguments);let t;if(n.length>=3&&n[2]){const o=Object.defineProperty;Object.defineProperty=function(e,n,t){return o.call(this,e,n,{...t,configurable:!0,enumerable:!0})};try{t=e.apply(this,n)}finally{Object.defineProperty=o}}else t=e.apply(this,n);return t}}function u(e,t,o,s){const r=!!jasmine[c("clockInstalled")],i=o.testProxyZone;if(r&&a){const t=n[n.__symbol__("fakeAsyncTest")];t&&"function"==typeof t.fakeAsync&&(e=t.fakeAsync(e))}return s?i.run(e,t,[s]):i.run(e,t)}function p(e){return e&&(e.length?function(n){return u(e,this,this.queueRunner,n)}:function(){return u(e,this,this.queueRunner)})}const f=jasmine.QueueRunner;jasmine.QueueRunner=function(t){function o(o){o.onComplete&&(o.onComplete=(e=>()=>{this.testProxyZone=null,this.testProxyZoneSpec=null,r.scheduleMicroTask("jasmine.onComplete",e)})(o.onComplete));const s=e[n.__symbol__("setTimeout")],c=e[n.__symbol__("clearTimeout")];s&&(o.timeout={setTimeout:s||e.setTimeout,clearTimeout:c||e.clearTimeout}),jasmine.UserContext?(o.userContext||(o.userContext=new jasmine.UserContext),o.userContext.queueRunner=this):(o.userContext||(o.userContext={}),o.userContext.queueRunner=this);const i=o.onException;o.onException=function(e){if(e&&"Timeout - Async callback was not invoked within timeout specified by jasmine.DEFAULT_TIMEOUT_INTERVAL."===e.message){const n=this&&this.testProxyZoneSpec;if(n){const t=n.getAndClearPendingTasksInfo();try{e.message+=t}catch(e){}}}i&&i.call(this,e)},t.call(this,o)}return function(e,n){for(const t in n)n.hasOwnProperty(t)&&(e[t]=n[t]);function t(){this.constructor=e}e.prototype=null===n?Object.create(n):(t.prototype=n.prototype,new t)}(o,t),o.prototype.execute=function(){let e=n.current,o=!1;for(;e;){if(e===r){o=!0;break}e=e.parent}if(!o)throw new Error("Unexpected Zone: "+n.current.name);this.testProxyZoneSpec=new s,this.testProxyZone=r.fork(this.testProxyZoneSpec),n.currentTask?t.prototype.execute.call(this):n.current.scheduleMicroTask("jasmine.execute().forceTask",(()=>f.prototype.execute.call(this)))},o}(f)}));

my-app/node_modules/zone.js/fesm2015/long-stack-trace-zone.js

@@ -0,0 +1,166 @@
+'use strict';
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+/**
+ * @fileoverview
+ * @suppress {globalThis}
+ */
+const NEWLINE = '\n';
+const IGNORE_FRAMES = {};
+const creationTrace = '__creationTrace__';
+const ERROR_TAG = 'STACKTRACE TRACKING';
+const SEP_TAG = '__SEP_TAG__';
+let sepTemplate = SEP_TAG + '@[native]';
+class LongStackTrace {
+    constructor() {
+        this.error = getStacktrace();
+        this.timestamp = new Date();
+    }
+}
+function getStacktraceWithUncaughtError() {
+    return new Error(ERROR_TAG);
+}
+function getStacktraceWithCaughtError() {
+    try {
+        throw getStacktraceWithUncaughtError();
+    }
+    catch (err) {
+        return err;
+    }
+}
+// Some implementations of exception handling don't create a stack trace if the exception
+// isn't thrown, however it's faster not to actually throw the exception.
+const error = getStacktraceWithUncaughtError();
+const caughtError = getStacktraceWithCaughtError();
+const getStacktrace = error.stack ?
+    getStacktraceWithUncaughtError :
+    (caughtError.stack ? getStacktraceWithCaughtError : getStacktraceWithUncaughtError);
+function getFrames(error) {
+    return error.stack ? error.stack.split(NEWLINE) : [];
+}
+function addErrorStack(lines, error) {
+    let trace = getFrames(error);
+    for (let i = 0; i < trace.length; i++) {
+        const frame = trace[i];
+        // Filter out the Frames which are part of stack capturing.
+        if (!IGNORE_FRAMES.hasOwnProperty(frame)) {
+            lines.push(trace[i]);
+        }
+    }
+}
+function renderLongStackTrace(frames, stack) {
+    const longTrace = [stack ? stack.trim() : ''];
+    if (frames) {
+        let timestamp = new Date().getTime();
+        for (let i = 0; i < frames.length; i++) {
+            const traceFrames = frames[i];
+            const lastTime = traceFrames.timestamp;
+            let separator = `____________________Elapsed ${timestamp - lastTime.getTime()} ms; At: ${lastTime}`;
+            separator = separator.replace(/[^\w\d]/g, '_');
+            longTrace.push(sepTemplate.replace(SEP_TAG, separator));
+            addErrorStack(longTrace, traceFrames.error);
+            timestamp = lastTime.getTime();
+        }
+    }
+    return longTrace.join(NEWLINE);
+}
+// if Error.stackTraceLimit is 0, means stack trace
+// is disabled, so we don't need to generate long stack trace
+// this will improve performance in some test(some test will
+// set stackTraceLimit to 0, https://github.com/angular/zone.js/issues/698
+function stackTracesEnabled() {
+    // Cast through any since this property only exists on Error in the nodejs
+    // typings.
+    return Error.stackTraceLimit > 0;
+}
+Zone['longStackTraceZoneSpec'] = {
+    name: 'long-stack-trace',
+    longStackTraceLimit: 10, // Max number of task to keep the stack trace for.
+    // add a getLongStackTrace method in spec to
+    // handle handled reject promise error.
+    getLongStackTrace: function (error) {
+        if (!error) {
+            return undefined;
+        }
+        const trace = error[Zone.__symbol__('currentTaskTrace')];
+        if (!trace) {
+            return error.stack;
+        }
+        return renderLongStackTrace(trace, error.stack);
+    },
+    onScheduleTask: function (parentZoneDelegate, currentZone, targetZone, task) {
+        if (stackTracesEnabled()) {
+            const currentTask = Zone.currentTask;
+            let trace = currentTask && currentTask.data && currentTask.data[creationTrace] || [];
+            trace = [new LongStackTrace()].concat(trace);
+            if (trace.length > this.longStackTraceLimit) {
+                trace.length = this.longStackTraceLimit;
+            }
+            if (!task.data)
+                task.data = {};
+            if (task.type === 'eventTask') {
+                // Fix issue https://github.com/angular/zone.js/issues/1195,
+                // For event task of browser, by default, all task will share a
+                // singleton instance of data object, we should create a new one here
+                // The cast to `any` is required to workaround a closure bug which wrongly applies
+                // URL sanitization rules to .data access.
+                task.data = { ...task.data };
+            }
+            task.data[creationTrace] = trace;
+        }
+        return parentZoneDelegate.scheduleTask(targetZone, task);
+    },
+    onHandleError: function (parentZoneDelegate, currentZone, targetZone, error) {
+        if (stackTracesEnabled()) {
+            const parentTask = Zone.currentTask || error.task;
+            if (error instanceof Error && parentTask) {
+                const longStack = renderLongStackTrace(parentTask.data && parentTask.data[creationTrace], error.stack);
+                try {
+                    error.stack = error.longStack = longStack;
+                }
+                catch (err) {
+                }
+            }
+        }
+        return parentZoneDelegate.handleError(targetZone, error);
+    }
+};
+function captureStackTraces(stackTraces, count) {
+    if (count > 0) {
+        stackTraces.push(getFrames((new LongStackTrace()).error));
+        captureStackTraces(stackTraces, count - 1);
+    }
+}
+function computeIgnoreFrames() {
+    if (!stackTracesEnabled()) {
+        return;
+    }
+    const frames = [];
+    captureStackTraces(frames, 2);
+    const frames1 = frames[0];
+    const frames2 = frames[1];
+    for (let i = 0; i < frames1.length; i++) {
+        const frame1 = frames1[i];
+        if (frame1.indexOf(ERROR_TAG) == -1) {
+            let match = frame1.match(/^\s*at\s+/);
+            if (match) {
+                sepTemplate = match[0] + SEP_TAG + ' (http://localhost)';
+                break;
+            }
+        }
+    }
+    for (let i = 0; i < frames1.length; i++) {
+        const frame1 = frames1[i];
+        const frame2 = frames2[i];
+        if (frame1 === frame2) {
+            IGNORE_FRAMES[frame1] = true;
+        }
+        else {
+            break;
+        }
+    }
+}
+computeIgnoreFrames();

my-app/node_modules/zone.js/fesm2015/long-stack-trace-zone.min.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */const NEWLINE="\n",IGNORE_FRAMES={},creationTrace="__creationTrace__",ERROR_TAG="STACKTRACE TRACKING",SEP_TAG="__SEP_TAG__";let sepTemplate=SEP_TAG+"@[native]";class LongStackTrace{constructor(){this.error=getStacktrace(),this.timestamp=new Date}}function getStacktraceWithUncaughtError(){return new Error(ERROR_TAG)}function getStacktraceWithCaughtError(){try{throw getStacktraceWithUncaughtError()}catch(t){return t}}const error=getStacktraceWithUncaughtError(),caughtError=getStacktraceWithCaughtError(),getStacktrace=error.stack?getStacktraceWithUncaughtError:caughtError.stack?getStacktraceWithCaughtError:getStacktraceWithUncaughtError;function getFrames(t){return t.stack?t.stack.split(NEWLINE):[]}function addErrorStack(t,r){let e=getFrames(r);for(let r=0;r<e.length;r++)IGNORE_FRAMES.hasOwnProperty(e[r])||t.push(e[r])}function renderLongStackTrace(t,r){const e=[r?r.trim():""];if(t){let r=(new Date).getTime();for(let a=0;a<t.length;a++){const c=t[a],n=c.timestamp;let o=`____________________Elapsed ${r-n.getTime()} ms; At: ${n}`;o=o.replace(/[^\w\d]/g,"_"),e.push(sepTemplate.replace(SEP_TAG,o)),addErrorStack(e,c.error),r=n.getTime()}}return e.join(NEWLINE)}function stackTracesEnabled(){return Error.stackTraceLimit>0}function captureStackTraces(t,r){r>0&&(t.push(getFrames((new LongStackTrace).error)),captureStackTraces(t,r-1))}function computeIgnoreFrames(){if(!stackTracesEnabled())return;const t=[];captureStackTraces(t,2);const r=t[0],e=t[1];for(let t=0;t<r.length;t++){const e=r[t];if(-1==e.indexOf(ERROR_TAG)){let t=e.match(/^\s*at\s+/);if(t){sepTemplate=t[0]+SEP_TAG+" (http://localhost)";break}}}for(let t=0;t<r.length;t++){const a=r[t];if(a!==e[t])break;IGNORE_FRAMES[a]=!0}}Zone.longStackTraceZoneSpec={name:"long-stack-trace",longStackTraceLimit:10,getLongStackTrace:function(t){if(!t)return;const r=t[Zone.__symbol__("currentTaskTrace")];return r?renderLongStackTrace(r,t.stack):t.stack},onScheduleTask:function(t,r,e,a){if(stackTracesEnabled()){const t=Zone.currentTask;let r=t&&t.data&&t.data[creationTrace]||[];r=[new LongStackTrace].concat(r),r.length>this.longStackTraceLimit&&(r.length=this.longStackTraceLimit),a.data||(a.data={}),"eventTask"===a.type&&(a.data={...a.data}),a.data[creationTrace]=r}return t.scheduleTask(e,a)},onHandleError:function(t,r,e,a){if(stackTracesEnabled()){const t=Zone.currentTask||a.task;if(a instanceof Error&&t){const r=renderLongStackTrace(t.data&&t.data[creationTrace],a.stack);try{a.stack=a.longStack=r}catch(t){}}}return t.handleError(e,a)}},computeIgnoreFrames();

my-app/node_modules/zone.js/fesm2015/mocha-patch.js

@@ -0,0 +1,145 @@
+'use strict';
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+Zone.__load_patch('mocha', (global, Zone) => {
+    const Mocha = global.Mocha;
+    if (typeof Mocha === 'undefined') {
+        // return if Mocha is not available, because now zone-testing
+        // will load mocha patch with jasmine/jest patch
+        return;
+    }
+    if (typeof Zone === 'undefined') {
+        throw new Error('Missing Zone.js');
+    }
+    const ProxyZoneSpec = Zone['ProxyZoneSpec'];
+    const SyncTestZoneSpec = Zone['SyncTestZoneSpec'];
+    if (!ProxyZoneSpec) {
+        throw new Error('Missing ProxyZoneSpec');
+    }
+    if (Mocha['__zone_patch__']) {
+        throw new Error('"Mocha" has already been patched with "Zone".');
+    }
+    Mocha['__zone_patch__'] = true;
+    const rootZone = Zone.current;
+    const syncZone = rootZone.fork(new SyncTestZoneSpec('Mocha.describe'));
+    let testZone = null;
+    const suiteZone = rootZone.fork(new ProxyZoneSpec());
+    const mochaOriginal = {
+        after: global.after,
+        afterEach: global.afterEach,
+        before: global.before,
+        beforeEach: global.beforeEach,
+        describe: global.describe,
+        it: global.it
+    };
+    function modifyArguments(args, syncTest, asyncTest) {
+        for (let i = 0; i < args.length; i++) {
+            let arg = args[i];
+            if (typeof arg === 'function') {
+                // The `done` callback is only passed through if the function expects at
+                // least one argument.
+                // Note we have to make a function with correct number of arguments,
+                // otherwise mocha will
+                // think that all functions are sync or async.
+                args[i] = (arg.length === 0) ? syncTest(arg) : asyncTest(arg);
+                // Mocha uses toString to view the test body in the result list, make sure we return the
+                // correct function body
+                args[i].toString = function () {
+                    return arg.toString();
+                };
+            }
+        }
+        return args;
+    }
+    function wrapDescribeInZone(args) {
+        const syncTest = function (fn) {
+            return function () {
+                return syncZone.run(fn, this, arguments);
+            };
+        };
+        return modifyArguments(args, syncTest);
+    }
+    function wrapTestInZone(args) {
+        const asyncTest = function (fn) {
+            return function (done) {
+                return testZone.run(fn, this, [done]);
+            };
+        };
+        const syncTest = function (fn) {
+            return function () {
+                return testZone.run(fn, this);
+            };
+        };
+        return modifyArguments(args, syncTest, asyncTest);
+    }
+    function wrapSuiteInZone(args) {
+        const asyncTest = function (fn) {
+            return function (done) {
+                return suiteZone.run(fn, this, [done]);
+            };
+        };
+        const syncTest = function (fn) {
+            return function () {
+                return suiteZone.run(fn, this);
+            };
+        };
+        return modifyArguments(args, syncTest, asyncTest);
+    }
+    global.describe = global.suite = function () {
+        return mochaOriginal.describe.apply(this, wrapDescribeInZone(arguments));
+    };
+    global.xdescribe = global.suite.skip = global.describe.skip = function () {
+        return mochaOriginal.describe.skip.apply(this, wrapDescribeInZone(arguments));
+    };
+    global.describe.only = global.suite.only = function () {
+        return mochaOriginal.describe.only.apply(this, wrapDescribeInZone(arguments));
+    };
+    global.it = global.specify = global.test = function () {
+        return mochaOriginal.it.apply(this, wrapTestInZone(arguments));
+    };
+    global.xit = global.xspecify = global.it.skip = function () {
+        return mochaOriginal.it.skip.apply(this, wrapTestInZone(arguments));
+    };
+    global.it.only = global.test.only = function () {
+        return mochaOriginal.it.only.apply(this, wrapTestInZone(arguments));
+    };
+    global.after = global.suiteTeardown = function () {
+        return mochaOriginal.after.apply(this, wrapSuiteInZone(arguments));
+    };
+    global.afterEach = global.teardown = function () {
+        return mochaOriginal.afterEach.apply(this, wrapTestInZone(arguments));
+    };
+    global.before = global.suiteSetup = function () {
+        return mochaOriginal.before.apply(this, wrapSuiteInZone(arguments));
+    };
+    global.beforeEach = global.setup = function () {
+        return mochaOriginal.beforeEach.apply(this, wrapTestInZone(arguments));
+    };
+    ((originalRunTest, originalRun) => {
+        Mocha.Runner.prototype.runTest = function (fn) {
+            Zone.current.scheduleMicroTask('mocha.forceTask', () => {
+                originalRunTest.call(this, fn);
+            });
+        };
+        Mocha.Runner.prototype.run = function (fn) {
+            this.on('test', (e) => {
+                testZone = rootZone.fork(new ProxyZoneSpec());
+            });
+            this.on('fail', (test, err) => {
+                const proxyZoneSpec = testZone && testZone.get('ProxyZoneSpec');
+                if (proxyZoneSpec && err) {
+                    try {
+                        // try catch here in case err.message is not writable
+                        err.message += proxyZoneSpec.getAndClearPendingTasksInfo();
+                    }
+                    catch (error) {
+                    }
+                }
+            });
+            return originalRun.call(this, fn);
+        };
+    })(Mocha.Runner.prototype.runTest, Mocha.Runner.prototype.run);
+});

my-app/node_modules/zone.js/fesm2015/mocha-patch.min.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */Zone.__load_patch("mocha",((t,n)=>{const e=t.Mocha;if(void 0===e)return;if(void 0===n)throw new Error("Missing Zone.js");const r=n.ProxyZoneSpec,i=n.SyncTestZoneSpec;if(!r)throw new Error("Missing ProxyZoneSpec");if(e.__zone_patch__)throw new Error('"Mocha" has already been patched with "Zone".');e.__zone_patch__=!0;const o=n.current,u=o.fork(new i("Mocha.describe"));let c=null;const s=o.fork(new r),f={after:t.after,afterEach:t.afterEach,before:t.before,beforeEach:t.beforeEach,describe:t.describe,it:t.it};function a(t,n,e){for(let r=0;r<t.length;r++){let i=t[r];"function"==typeof i&&(t[r]=0===i.length?n(i):e(i),t[r].toString=function(){return i.toString()})}return t}function p(t){return a(t,(function(t){return function(){return u.run(t,this,arguments)}}))}function h(t){return a(t,(function(t){return function(){return c.run(t,this)}}),(function(t){return function(n){return c.run(t,this,[n])}}))}function l(t){return a(t,(function(t){return function(){return s.run(t,this)}}),(function(t){return function(n){return s.run(t,this,[n])}}))}var y,d;t.describe=t.suite=function(){return f.describe.apply(this,p(arguments))},t.xdescribe=t.suite.skip=t.describe.skip=function(){return f.describe.skip.apply(this,p(arguments))},t.describe.only=t.suite.only=function(){return f.describe.only.apply(this,p(arguments))},t.it=t.specify=t.test=function(){return f.it.apply(this,h(arguments))},t.xit=t.xspecify=t.it.skip=function(){return f.it.skip.apply(this,h(arguments))},t.it.only=t.test.only=function(){return f.it.only.apply(this,h(arguments))},t.after=t.suiteTeardown=function(){return f.after.apply(this,l(arguments))},t.afterEach=t.teardown=function(){return f.afterEach.apply(this,h(arguments))},t.before=t.suiteSetup=function(){return f.before.apply(this,l(arguments))},t.beforeEach=t.setup=function(){return f.beforeEach.apply(this,h(arguments))},y=e.Runner.prototype.runTest,d=e.Runner.prototype.run,e.Runner.prototype.runTest=function(t){n.current.scheduleMicroTask("mocha.forceTask",(()=>{y.call(this,t)}))},e.Runner.prototype.run=function(t){return this.on("test",(t=>{c=o.fork(new r)})),this.on("fail",((t,n)=>{const e=c&&c.get("ProxyZoneSpec");if(e&&n)try{n.message+=e.getAndClearPendingTasksInfo()}catch(t){}})),d.call(this,t)}}));

my-app/node_modules/zone.js/fesm2015/proxy.js

@@ -0,0 +1,170 @@
+'use strict';
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+class ProxyZoneSpec {
+    static get() {
+        return Zone.current.get('ProxyZoneSpec');
+    }
+    static isLoaded() {
+        return ProxyZoneSpec.get() instanceof ProxyZoneSpec;
+    }
+    static assertPresent() {
+        if (!ProxyZoneSpec.isLoaded()) {
+            throw new Error(`Expected to be running in 'ProxyZone', but it was not found.`);
+        }
+        return ProxyZoneSpec.get();
+    }
+    constructor(defaultSpecDelegate = null) {
+        this.defaultSpecDelegate = defaultSpecDelegate;
+        this.name = 'ProxyZone';
+        this._delegateSpec = null;
+        this.properties = { 'ProxyZoneSpec': this };
+        this.propertyKeys = null;
+        this.lastTaskState = null;
+        this.isNeedToTriggerHasTask = false;
+        this.tasks = [];
+        this.setDelegate(defaultSpecDelegate);
+    }
+    setDelegate(delegateSpec) {
+        const isNewDelegate = this._delegateSpec !== delegateSpec;
+        this._delegateSpec = delegateSpec;
+        this.propertyKeys && this.propertyKeys.forEach((key) => delete this.properties[key]);
+        this.propertyKeys = null;
+        if (delegateSpec && delegateSpec.properties) {
+            this.propertyKeys = Object.keys(delegateSpec.properties);
+            this.propertyKeys.forEach((k) => this.properties[k] = delegateSpec.properties[k]);
+        }
+        // if a new delegateSpec was set, check if we need to trigger hasTask
+        if (isNewDelegate && this.lastTaskState &&
+            (this.lastTaskState.macroTask || this.lastTaskState.microTask)) {
+            this.isNeedToTriggerHasTask = true;
+        }
+    }
+    getDelegate() {
+        return this._delegateSpec;
+    }
+    resetDelegate() {
+        this.getDelegate();
+        this.setDelegate(this.defaultSpecDelegate);
+    }
+    tryTriggerHasTask(parentZoneDelegate, currentZone, targetZone) {
+        if (this.isNeedToTriggerHasTask && this.lastTaskState) {
+            // last delegateSpec has microTask or macroTask
+            // should call onHasTask in current delegateSpec
+            this.isNeedToTriggerHasTask = false;
+            this.onHasTask(parentZoneDelegate, currentZone, targetZone, this.lastTaskState);
+        }
+    }
+    removeFromTasks(task) {
+        if (!this.tasks) {
+            return;
+        }
+        for (let i = 0; i < this.tasks.length; i++) {
+            if (this.tasks[i] === task) {
+                this.tasks.splice(i, 1);
+                return;
+            }
+        }
+    }
+    getAndClearPendingTasksInfo() {
+        if (this.tasks.length === 0) {
+            return '';
+        }
+        const taskInfo = this.tasks.map((task) => {
+            const dataInfo = task.data &&
+                Object.keys(task.data)
+                    .map((key) => {
+                    return key + ':' + task.data[key];
+                })
+                    .join(',');
+            return `type: ${task.type}, source: ${task.source}, args: {${dataInfo}}`;
+        });
+        const pendingTasksInfo = '--Pending async tasks are: [' + taskInfo + ']';
+        // clear tasks
+        this.tasks = [];
+        return pendingTasksInfo;
+    }
+    onFork(parentZoneDelegate, currentZone, targetZone, zoneSpec) {
+        if (this._delegateSpec && this._delegateSpec.onFork) {
+            return this._delegateSpec.onFork(parentZoneDelegate, currentZone, targetZone, zoneSpec);
+        }
+        else {
+            return parentZoneDelegate.fork(targetZone, zoneSpec);
+        }
+    }
+    onIntercept(parentZoneDelegate, currentZone, targetZone, delegate, source) {
+        if (this._delegateSpec && this._delegateSpec.onIntercept) {
+            return this._delegateSpec.onIntercept(parentZoneDelegate, currentZone, targetZone, delegate, source);
+        }
+        else {
+            return parentZoneDelegate.intercept(targetZone, delegate, source);
+        }
+    }
+    onInvoke(parentZoneDelegate, currentZone, targetZone, delegate, applyThis, applyArgs, source) {
+        this.tryTriggerHasTask(parentZoneDelegate, currentZone, targetZone);
+        if (this._delegateSpec && this._delegateSpec.onInvoke) {
+            return this._delegateSpec.onInvoke(parentZoneDelegate, currentZone, targetZone, delegate, applyThis, applyArgs, source);
+        }
+        else {
+            return parentZoneDelegate.invoke(targetZone, delegate, applyThis, applyArgs, source);
+        }
+    }
+    onHandleError(parentZoneDelegate, currentZone, targetZone, error) {
+        if (this._delegateSpec && this._delegateSpec.onHandleError) {
+            return this._delegateSpec.onHandleError(parentZoneDelegate, currentZone, targetZone, error);
+        }
+        else {
+            return parentZoneDelegate.handleError(targetZone, error);
+        }
+    }
+    onScheduleTask(parentZoneDelegate, currentZone, targetZone, task) {
+        if (task.type !== 'eventTask') {
+            this.tasks.push(task);
+        }
+        if (this._delegateSpec && this._delegateSpec.onScheduleTask) {
+            return this._delegateSpec.onScheduleTask(parentZoneDelegate, currentZone, targetZone, task);
+        }
+        else {
+            return parentZoneDelegate.scheduleTask(targetZone, task);
+        }
+    }
+    onInvokeTask(parentZoneDelegate, currentZone, targetZone, task, applyThis, applyArgs) {
+        if (task.type !== 'eventTask') {
+            this.removeFromTasks(task);
+        }
+        this.tryTriggerHasTask(parentZoneDelegate, currentZone, targetZone);
+        if (this._delegateSpec && this._delegateSpec.onInvokeTask) {
+            return this._delegateSpec.onInvokeTask(parentZoneDelegate, currentZone, targetZone, task, applyThis, applyArgs);
+        }
+        else {
+            return parentZoneDelegate.invokeTask(targetZone, task, applyThis, applyArgs);
+        }
+    }
+    onCancelTask(parentZoneDelegate, currentZone, targetZone, task) {
+        if (task.type !== 'eventTask') {
+            this.removeFromTasks(task);
+        }
+        this.tryTriggerHasTask(parentZoneDelegate, currentZone, targetZone);
+        if (this._delegateSpec && this._delegateSpec.onCancelTask) {
+            return this._delegateSpec.onCancelTask(parentZoneDelegate, currentZone, targetZone, task);
+        }
+        else {
+            return parentZoneDelegate.cancelTask(targetZone, task);
+        }
+    }
+    onHasTask(delegate, current, target, hasTaskState) {
+        this.lastTaskState = hasTaskState;
+        if (this._delegateSpec && this._delegateSpec.onHasTask) {
+            this._delegateSpec.onHasTask(delegate, current, target, hasTaskState);
+        }
+        else {
+            delegate.hasTask(target, hasTaskState);
+        }
+    }
+}
+// Export the class so that new instances can be created with proper
+// constructor params.
+Zone['ProxyZoneSpec'] = ProxyZoneSpec;

my-app/node_modules/zone.js/fesm2015/proxy.min.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */class ProxyZoneSpec{static get(){return Zone.current.get("ProxyZoneSpec")}static isLoaded(){return ProxyZoneSpec.get()instanceof ProxyZoneSpec}static assertPresent(){if(!ProxyZoneSpec.isLoaded())throw new Error("Expected to be running in 'ProxyZone', but it was not found.");return ProxyZoneSpec.get()}constructor(e=null){this.defaultSpecDelegate=e,this.name="ProxyZone",this._delegateSpec=null,this.properties={ProxyZoneSpec:this},this.propertyKeys=null,this.lastTaskState=null,this.isNeedToTriggerHasTask=!1,this.tasks=[],this.setDelegate(e)}setDelegate(e){const t=this._delegateSpec!==e;this._delegateSpec=e,this.propertyKeys&&this.propertyKeys.forEach((e=>delete this.properties[e])),this.propertyKeys=null,e&&e.properties&&(this.propertyKeys=Object.keys(e.properties),this.propertyKeys.forEach((t=>this.properties[t]=e.properties[t]))),t&&this.lastTaskState&&(this.lastTaskState.macroTask||this.lastTaskState.microTask)&&(this.isNeedToTriggerHasTask=!0)}getDelegate(){return this._delegateSpec}resetDelegate(){this.getDelegate(),this.setDelegate(this.defaultSpecDelegate)}tryTriggerHasTask(e,t,s){this.isNeedToTriggerHasTask&&this.lastTaskState&&(this.isNeedToTriggerHasTask=!1,this.onHasTask(e,t,s,this.lastTaskState))}removeFromTasks(e){if(this.tasks)for(let t=0;t<this.tasks.length;t++)if(this.tasks[t]===e)return void this.tasks.splice(t,1)}getAndClearPendingTasksInfo(){if(0===this.tasks.length)return"";const e="--Pending async tasks are: ["+this.tasks.map((e=>{const t=e.data&&Object.keys(e.data).map((t=>t+":"+e.data[t])).join(",");return`type: ${e.type}, source: ${e.source}, args: {${t}}`}))+"]";return this.tasks=[],e}onFork(e,t,s,a){return this._delegateSpec&&this._delegateSpec.onFork?this._delegateSpec.onFork(e,t,s,a):e.fork(s,a)}onIntercept(e,t,s,a,r){return this._delegateSpec&&this._delegateSpec.onIntercept?this._delegateSpec.onIntercept(e,t,s,a,r):e.intercept(s,a,r)}onInvoke(e,t,s,a,r,i,o){return this.tryTriggerHasTask(e,t,s),this._delegateSpec&&this._delegateSpec.onInvoke?this._delegateSpec.onInvoke(e,t,s,a,r,i,o):e.invoke(s,a,r,i,o)}onHandleError(e,t,s,a){return this._delegateSpec&&this._delegateSpec.onHandleError?this._delegateSpec.onHandleError(e,t,s,a):e.handleError(s,a)}onScheduleTask(e,t,s,a){return"eventTask"!==a.type&&this.tasks.push(a),this._delegateSpec&&this._delegateSpec.onScheduleTask?this._delegateSpec.onScheduleTask(e,t,s,a):e.scheduleTask(s,a)}onInvokeTask(e,t,s,a,r,i){return"eventTask"!==a.type&&this.removeFromTasks(a),this.tryTriggerHasTask(e,t,s),this._delegateSpec&&this._delegateSpec.onInvokeTask?this._delegateSpec.onInvokeTask(e,t,s,a,r,i):e.invokeTask(s,a,r,i)}onCancelTask(e,t,s,a){return"eventTask"!==a.type&&this.removeFromTasks(a),this.tryTriggerHasTask(e,t,s),this._delegateSpec&&this._delegateSpec.onCancelTask?this._delegateSpec.onCancelTask(e,t,s,a):e.cancelTask(s,a)}onHasTask(e,t,s,a){this.lastTaskState=a,this._delegateSpec&&this._delegateSpec.onHasTask?this._delegateSpec.onHasTask(e,t,s,a):e.hasTask(s,a)}}Zone.ProxyZoneSpec=ProxyZoneSpec;

my-app/node_modules/zone.js/fesm2015/sync-test.js

@@ -0,0 +1,26 @@
+'use strict';
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+class SyncTestZoneSpec {
+    constructor(namePrefix) {
+        this.runZone = Zone.current;
+        this.name = 'syncTestZone for ' + namePrefix;
+    }
+    onScheduleTask(delegate, current, target, task) {
+        switch (task.type) {
+            case 'microTask':
+            case 'macroTask':
+                throw new Error(`Cannot call ${task.source} from within a sync test (${this.name}).`);
+            case 'eventTask':
+                task = delegate.scheduleTask(target, task);
+                break;
+        }
+        return task;
+    }
+}
+// Export the class so that new instances can be created with proper
+// constructor params.
+Zone['SyncTestZoneSpec'] = SyncTestZoneSpec;

my-app/node_modules/zone.js/fesm2015/sync-test.min.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */class SyncTestZoneSpec{constructor(e){this.runZone=Zone.current,this.name="syncTestZone for "+e}onScheduleTask(e,s,n,c){switch(c.type){case"microTask":case"macroTask":throw new Error(`Cannot call ${c.source} from within a sync test (${this.name}).`);case"eventTask":c=e.scheduleTask(n,c)}return c}}Zone.SyncTestZoneSpec=SyncTestZoneSpec;

my-app/node_modules/zone.js/fesm2015/task-tracking.js

@@ -0,0 +1,71 @@
+'use strict';
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+/**
+ * A `TaskTrackingZoneSpec` allows one to track all outstanding Tasks.
+ *
+ * This is useful in tests. For example to see which tasks are preventing a test from completing
+ * or an automated way of releasing all of the event listeners at the end of the test.
+ */
+class TaskTrackingZoneSpec {
+    constructor() {
+        this.name = 'TaskTrackingZone';
+        this.microTasks = [];
+        this.macroTasks = [];
+        this.eventTasks = [];
+        this.properties = { 'TaskTrackingZone': this };
+    }
+    static get() {
+        return Zone.current.get('TaskTrackingZone');
+    }
+    getTasksFor(type) {
+        switch (type) {
+            case 'microTask':
+                return this.microTasks;
+            case 'macroTask':
+                return this.macroTasks;
+            case 'eventTask':
+                return this.eventTasks;
+        }
+        throw new Error('Unknown task format: ' + type);
+    }
+    onScheduleTask(parentZoneDelegate, currentZone, targetZone, task) {
+        task['creationLocation'] = new Error(`Task '${task.type}' from '${task.source}'.`);
+        const tasks = this.getTasksFor(task.type);
+        tasks.push(task);
+        return parentZoneDelegate.scheduleTask(targetZone, task);
+    }
+    onCancelTask(parentZoneDelegate, currentZone, targetZone, task) {
+        const tasks = this.getTasksFor(task.type);
+        for (let i = 0; i < tasks.length; i++) {
+            if (tasks[i] == task) {
+                tasks.splice(i, 1);
+                break;
+            }
+        }
+        return parentZoneDelegate.cancelTask(targetZone, task);
+    }
+    onInvokeTask(parentZoneDelegate, currentZone, targetZone, task, applyThis, applyArgs) {
+        if (task.type === 'eventTask' || task.data?.isPeriodic)
+            return parentZoneDelegate.invokeTask(targetZone, task, applyThis, applyArgs);
+        const tasks = this.getTasksFor(task.type);
+        for (let i = 0; i < tasks.length; i++) {
+            if (tasks[i] == task) {
+                tasks.splice(i, 1);
+                break;
+            }
+        }
+        return parentZoneDelegate.invokeTask(targetZone, task, applyThis, applyArgs);
+    }
+    clearEvents() {
+        while (this.eventTasks.length) {
+            Zone.current.cancelTask(this.eventTasks[0]);
+        }
+    }
+}
+// Export the class so that new instances can be created with proper
+// constructor params.
+Zone['TaskTrackingZoneSpec'] = TaskTrackingZoneSpec;

my-app/node_modules/zone.js/fesm2015/task-tracking.min.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */class TaskTrackingZoneSpec{constructor(){this.name="TaskTrackingZone",this.microTasks=[],this.macroTasks=[],this.eventTasks=[],this.properties={TaskTrackingZone:this}}static get(){return Zone.current.get("TaskTrackingZone")}getTasksFor(e){switch(e){case"microTask":return this.microTasks;case"macroTask":return this.macroTasks;case"eventTask":return this.eventTasks}throw new Error("Unknown task format: "+e)}onScheduleTask(e,s,t,r){return r.creationLocation=new Error(`Task '${r.type}' from '${r.source}'.`),this.getTasksFor(r.type).push(r),e.scheduleTask(t,r)}onCancelTask(e,s,t,r){const a=this.getTasksFor(r.type);for(let e=0;e<a.length;e++)if(a[e]==r){a.splice(e,1);break}return e.cancelTask(t,r)}onInvokeTask(e,s,t,r,a,n){if("eventTask"===r.type||r.data?.isPeriodic)return e.invokeTask(t,r,a,n);const k=this.getTasksFor(r.type);for(let e=0;e<k.length;e++)if(k[e]==r){k.splice(e,1);break}return e.invokeTask(t,r,a,n)}clearEvents(){for(;this.eventTasks.length;)Zone.current.cancelTask(this.eventTasks[0])}}Zone.TaskTrackingZoneSpec=TaskTrackingZoneSpec;

my-app/node_modules/zone.js/fesm2015/webapis-media-query.js

@@ -0,0 +1,67 @@
+'use strict';
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+Zone.__load_patch('mediaQuery', (global, Zone, api) => {
+    function patchAddListener(proto) {
+        api.patchMethod(proto, 'addListener', (delegate) => (self, args) => {
+            const callback = args.length > 0 ? args[0] : null;
+            if (typeof callback === 'function') {
+                const wrapperedCallback = Zone.current.wrap(callback, 'MediaQuery');
+                callback[api.symbol('mediaQueryCallback')] = wrapperedCallback;
+                return delegate.call(self, wrapperedCallback);
+            }
+            else {
+                return delegate.apply(self, args);
+            }
+        });
+    }
+    function patchRemoveListener(proto) {
+        api.patchMethod(proto, 'removeListener', (delegate) => (self, args) => {
+            const callback = args.length > 0 ? args[0] : null;
+            if (typeof callback === 'function') {
+                const wrapperedCallback = callback[api.symbol('mediaQueryCallback')];
+                if (wrapperedCallback) {
+                    return delegate.call(self, wrapperedCallback);
+                }
+                else {
+                    return delegate.apply(self, args);
+                }
+            }
+            else {
+                return delegate.apply(self, args);
+            }
+        });
+    }
+    if (global['MediaQueryList']) {
+        const proto = global['MediaQueryList'].prototype;
+        patchAddListener(proto);
+        patchRemoveListener(proto);
+    }
+    else if (global['matchMedia']) {
+        api.patchMethod(global, 'matchMedia', (delegate) => (self, args) => {
+            const mql = delegate.apply(self, args);
+            if (mql) {
+                // try to patch MediaQueryList.prototype
+                const proto = Object.getPrototypeOf(mql);
+                if (proto && proto['addListener']) {
+                    // try to patch proto, don't need to worry about patch
+                    // multiple times, because, api.patchEventTarget will check it
+                    patchAddListener(proto);
+                    patchRemoveListener(proto);
+                    patchAddListener(mql);
+                    patchRemoveListener(mql);
+                }
+                else if (mql['addListener']) {
+                    // proto not exists, or proto has no addListener method
+                    // try to patch mql instance
+                    patchAddListener(mql);
+                    patchRemoveListener(mql);
+                }
+            }
+            return mql;
+        });
+    }
+});

my-app/node_modules/zone.js/fesm2015/webapis-media-query.min.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */Zone.__load_patch("mediaQuery",((e,t,n)=>{function a(e){n.patchMethod(e,"addListener",(e=>(a,r)=>{const o=r.length>0?r[0]:null;if("function"==typeof o){const r=t.current.wrap(o,"MediaQuery");return o[n.symbol("mediaQueryCallback")]=r,e.call(a,r)}return e.apply(a,r)}))}function r(e){n.patchMethod(e,"removeListener",(e=>(t,a)=>{const r=a.length>0?a[0]:null;if("function"==typeof r){const o=r[n.symbol("mediaQueryCallback")];return o?e.call(t,o):e.apply(t,a)}return e.apply(t,a)}))}if(e.MediaQueryList){const t=e.MediaQueryList.prototype;a(t),r(t)}else e.matchMedia&&n.patchMethod(e,"matchMedia",(e=>(t,n)=>{const o=e.apply(t,n);if(o){const e=Object.getPrototypeOf(o);e&&e.addListener?(a(e),r(e),a(o),r(o)):o.addListener&&(a(o),r(o))}return o}))}));

my-app/node_modules/zone.js/fesm2015/webapis-notification.js

@@ -0,0 +1,17 @@
+'use strict';
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+Zone.__load_patch('notification', (global, Zone, api) => {
+    const Notification = global['Notification'];
+    if (!Notification || !Notification.prototype) {
+        return;
+    }
+    const desc = Object.getOwnPropertyDescriptor(Notification.prototype, 'onerror');
+    if (!desc || !desc.configurable) {
+        return;
+    }
+    api.patchOnProperties(Notification.prototype, null);
+});

my-app/node_modules/zone.js/fesm2015/webapis-notification.min.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */Zone.__load_patch("notification",((t,o,r)=>{const e=t.Notification;if(!e||!e.prototype)return;const n=Object.getOwnPropertyDescriptor(e.prototype,"onerror");n&&n.configurable&&r.patchOnProperties(e.prototype,null)}));

my-app/node_modules/zone.js/fesm2015/webapis-rtc-peer-connection.js

@@ -0,0 +1,21 @@
+'use strict';
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+Zone.__load_patch('RTCPeerConnection', (global, Zone, api) => {
+    const RTCPeerConnection = global['RTCPeerConnection'];
+    if (!RTCPeerConnection) {
+        return;
+    }
+    const addSymbol = api.symbol('addEventListener');
+    const removeSymbol = api.symbol('removeEventListener');
+    RTCPeerConnection.prototype.addEventListener = RTCPeerConnection.prototype[addSymbol];
+    RTCPeerConnection.prototype.removeEventListener = RTCPeerConnection.prototype[removeSymbol];
+    // RTCPeerConnection extends EventTarget, so we must clear the symbol
+    // to allow patch RTCPeerConnection.prototype.addEventListener again
+    RTCPeerConnection.prototype[addSymbol] = null;
+    RTCPeerConnection.prototype[removeSymbol] = null;
+    api.patchEventTarget(global, api, [RTCPeerConnection.prototype], { useG: false });
+});

my-app/node_modules/zone.js/fesm2015/webapis-rtc-peer-connection.min.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */Zone.__load_patch("RTCPeerConnection",((e,t,o)=>{const n=e.RTCPeerConnection;if(!n)return;const r=o.symbol("addEventListener"),p=o.symbol("removeEventListener");n.prototype.addEventListener=n.prototype[r],n.prototype.removeEventListener=n.prototype[p],n.prototype[r]=null,n.prototype[p]=null,o.patchEventTarget(e,o,[n.prototype],{useG:!1})}));

my-app/node_modules/zone.js/fesm2015/webapis-shadydom.js

@@ -0,0 +1,25 @@
+'use strict';
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+Zone.__load_patch('shadydom', (global, Zone, api) => {
+    // https://github.com/angular/zone.js/issues/782
+    // in web components, shadydom will patch addEventListener/removeEventListener of
+    // Node.prototype and WindowPrototype, this will have conflict with zone.js
+    // so zone.js need to patch them again.
+    const HTMLSlotElement = global.HTMLSlotElement;
+    const prototypes = [
+        Object.getPrototypeOf(window), Node.prototype, Text.prototype, Element.prototype,
+        HTMLElement.prototype, HTMLSlotElement && HTMLSlotElement.prototype, DocumentFragment.prototype,
+        Document.prototype
+    ];
+    prototypes.forEach(function (proto) {
+        if (proto && proto.hasOwnProperty('addEventListener')) {
+            proto[Zone.__symbol__('addEventListener')] = null;
+            proto[Zone.__symbol__('removeEventListener')] = null;
+            api.patchEventTarget(global, api, [proto]);
+        }
+    });
+});

my-app/node_modules/zone.js/fesm2015/webapis-shadydom.min.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */Zone.__load_patch("shadydom",((t,e,o)=>{const n=t.HTMLSlotElement;[Object.getPrototypeOf(window),Node.prototype,Text.prototype,Element.prototype,HTMLElement.prototype,n&&n.prototype,DocumentFragment.prototype,Document.prototype].forEach((function(n){n&&n.hasOwnProperty("addEventListener")&&(n[e.__symbol__("addEventListener")]=null,n[e.__symbol__("removeEventListener")]=null,o.patchEventTarget(t,o,[n]))}))}));

my-app/node_modules/zone.js/fesm2015/wtf.js

@@ -0,0 +1,116 @@
+'use strict';
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+/**
+ * @fileoverview
+ * @suppress {missingRequire}
+ */
+(function (global) {
+    // Detect and setup WTF.
+    let wtfTrace = null;
+    let wtfEvents = null;
+    const wtfEnabled = (function () {
+        const wtf = global['wtf'];
+        if (wtf) {
+            wtfTrace = wtf.trace;
+            if (wtfTrace) {
+                wtfEvents = wtfTrace.events;
+                return true;
+            }
+        }
+        return false;
+    })();
+    class WtfZoneSpec {
+        constructor() {
+            this.name = 'WTF';
+        }
+        static { this.forkInstance = wtfEnabled ? wtfEvents.createInstance('Zone:fork(ascii zone, ascii newZone)') : null; }
+        static { this.scheduleInstance = {}; }
+        static { this.cancelInstance = {}; }
+        static { this.invokeScope = {}; }
+        static { this.invokeTaskScope = {}; }
+        onFork(parentZoneDelegate, currentZone, targetZone, zoneSpec) {
+            const retValue = parentZoneDelegate.fork(targetZone, zoneSpec);
+            WtfZoneSpec.forkInstance(zonePathName(targetZone), retValue.name);
+            return retValue;
+        }
+        onInvoke(parentZoneDelegate, currentZone, targetZone, delegate, applyThis, applyArgs, source) {
+            const src = source || 'unknown';
+            let scope = WtfZoneSpec.invokeScope[src];
+            if (!scope) {
+                scope = WtfZoneSpec.invokeScope[src] =
+                    wtfEvents.createScope(`Zone:invoke:${source}(ascii zone)`);
+            }
+            return wtfTrace.leaveScope(scope(zonePathName(targetZone)), parentZoneDelegate.invoke(targetZone, delegate, applyThis, applyArgs, source));
+        }
+        onHandleError(parentZoneDelegate, currentZone, targetZone, error) {
+            return parentZoneDelegate.handleError(targetZone, error);
+        }
+        onScheduleTask(parentZoneDelegate, currentZone, targetZone, task) {
+            const key = task.type + ':' + task.source;
+            let instance = WtfZoneSpec.scheduleInstance[key];
+            if (!instance) {
+                instance = WtfZoneSpec.scheduleInstance[key] =
+                    wtfEvents.createInstance(`Zone:schedule:${key}(ascii zone, any data)`);
+            }
+            const retValue = parentZoneDelegate.scheduleTask(targetZone, task);
+            instance(zonePathName(targetZone), shallowObj(task.data, 2));
+            return retValue;
+        }
+        onInvokeTask(parentZoneDelegate, currentZone, targetZone, task, applyThis, applyArgs) {
+            const source = task.source;
+            let scope = WtfZoneSpec.invokeTaskScope[source];
+            if (!scope) {
+                scope = WtfZoneSpec.invokeTaskScope[source] =
+                    wtfEvents.createScope(`Zone:invokeTask:${source}(ascii zone)`);
+            }
+            return wtfTrace.leaveScope(scope(zonePathName(targetZone)), parentZoneDelegate.invokeTask(targetZone, task, applyThis, applyArgs));
+        }
+        onCancelTask(parentZoneDelegate, currentZone, targetZone, task) {
+            const key = task.source;
+            let instance = WtfZoneSpec.cancelInstance[key];
+            if (!instance) {
+                instance = WtfZoneSpec.cancelInstance[key] =
+                    wtfEvents.createInstance(`Zone:cancel:${key}(ascii zone, any options)`);
+            }
+            const retValue = parentZoneDelegate.cancelTask(targetZone, task);
+            instance(zonePathName(targetZone), shallowObj(task.data, 2));
+            return retValue;
+        }
+    }
+    function shallowObj(obj, depth) {
+        if (!obj || !depth)
+            return null;
+        const out = {};
+        for (const key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                // explicit : any due to https://github.com/microsoft/TypeScript/issues/33191
+                let value = obj[key];
+                switch (typeof value) {
+                    case 'object':
+                        const name = value && value.constructor && value.constructor.name;
+                        value = name == Object.name ? shallowObj(value, depth - 1) : name;
+                        break;
+                    case 'function':
+                        value = value.name || undefined;
+                        break;
+                }
+                out[key] = value;
+            }
+        }
+        return out;
+    }
+    function zonePathName(zone) {
+        let name = zone.name;
+        let localZone = zone.parent;
+        while (localZone != null) {
+            name = localZone.name + '::' + name;
+            localZone = localZone.parent;
+        }
+        return name;
+    }
+    Zone['wtfZoneSpec'] = !wtfEnabled ? null : new WtfZoneSpec();
+})(typeof window === 'object' && window || typeof self === 'object' && self || global);

my-app/node_modules/zone.js/fesm2015/wtf.min.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */!function(e){let n=null,t=null;const c=function(){const c=e.wtf;return!(!c||(n=c.trace,!n)||(t=n.events,0))}();class o{constructor(){this.name="WTF"}static{this.forkInstance=c?t.createInstance("Zone:fork(ascii zone, ascii newZone)"):null}static{this.scheduleInstance={}}static{this.cancelInstance={}}static{this.invokeScope={}}static{this.invokeTaskScope={}}onFork(e,n,t,c){const s=e.fork(t,c);return o.forkInstance(a(t),s.name),s}onInvoke(e,c,s,r,i,l,u){const k=u||"unknown";let f=o.invokeScope[k];return f||(f=o.invokeScope[k]=t.createScope(`Zone:invoke:${u}(ascii zone)`)),n.leaveScope(f(a(s)),e.invoke(s,r,i,l,u))}onHandleError(e,n,t,c){return e.handleError(t,c)}onScheduleTask(e,n,c,r){const i=r.type+":"+r.source;let l=o.scheduleInstance[i];l||(l=o.scheduleInstance[i]=t.createInstance(`Zone:schedule:${i}(ascii zone, any data)`));const u=e.scheduleTask(c,r);return l(a(c),s(r.data,2)),u}onInvokeTask(e,c,s,r,i,l){const u=r.source;let k=o.invokeTaskScope[u];return k||(k=o.invokeTaskScope[u]=t.createScope(`Zone:invokeTask:${u}(ascii zone)`)),n.leaveScope(k(a(s)),e.invokeTask(s,r,i,l))}onCancelTask(e,n,c,r){const i=r.source;let l=o.cancelInstance[i];l||(l=o.cancelInstance[i]=t.createInstance(`Zone:cancel:${i}(ascii zone, any options)`));const u=e.cancelTask(c,r);return l(a(c),s(r.data,2)),u}}function s(e,n){if(!e||!n)return null;const t={};for(const c in e)if(e.hasOwnProperty(c)){let o=e[c];switch(typeof o){case"object":const e=o&&o.constructor&&o.constructor.name;o=e==Object.name?s(o,n-1):e;break;case"function":o=o.name||void 0}t[c]=o}return t}function a(e){let n=e.name,t=e.parent;for(;null!=t;)n=t.name+"::"+n,t=t.parent;return n}Zone.wtfZoneSpec=c?new o:null}("object"==typeof window&&window||"object"==typeof self&&self||global);

my-app/node_modules/zone.js/fesm2015/zone-bluebird.js

@@ -0,0 +1,83 @@
+'use strict';
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+Zone.__load_patch('bluebird', (global, Zone, api) => {
+    // TODO: @JiaLiPassion, we can automatically patch bluebird
+    // if global.Promise = Bluebird, but sometimes in nodejs,
+    // global.Promise is not Bluebird, and Bluebird is just be
+    // used by other libraries such as sequelize, so I think it is
+    // safe to just expose a method to patch Bluebird explicitly
+    const BLUEBIRD = 'bluebird';
+    Zone[Zone.__symbol__(BLUEBIRD)] = function patchBluebird(Bluebird) {
+        // patch method of Bluebird.prototype which not using `then` internally
+        const bluebirdApis = ['then', 'spread', 'finally'];
+        bluebirdApis.forEach(bapi => {
+            api.patchMethod(Bluebird.prototype, bapi, (delegate) => (self, args) => {
+                const zone = Zone.current;
+                for (let i = 0; i < args.length; i++) {
+                    const func = args[i];
+                    if (typeof func === 'function') {
+                        args[i] = function () {
+                            const argSelf = this;
+                            const argArgs = arguments;
+                            return new Bluebird((res, rej) => {
+                                zone.scheduleMicroTask('Promise.then', () => {
+                                    try {
+                                        res(func.apply(argSelf, argArgs));
+                                    }
+                                    catch (error) {
+                                        rej(error);
+                                    }
+                                });
+                            });
+                        };
+                    }
+                }
+                return delegate.apply(self, args);
+            });
+        });
+        if (typeof window !== 'undefined') {
+            window.addEventListener('unhandledrejection', function (event) {
+                const error = event.detail && event.detail.reason;
+                if (error && error.isHandledByZone) {
+                    event.preventDefault();
+                    if (typeof event.stopImmediatePropagation === 'function') {
+                        event.stopImmediatePropagation();
+                    }
+                }
+            });
+        }
+        else if (typeof process !== 'undefined') {
+            process.on('unhandledRejection', (reason, p) => {
+                if (reason && reason.isHandledByZone) {
+                    const listeners = process.listeners('unhandledRejection');
+                    if (listeners) {
+                        // remove unhandledRejection listeners so the callback
+                        // will not be triggered.
+                        process.removeAllListeners('unhandledRejection');
+                        process.nextTick(() => {
+                            listeners.forEach(listener => process.on('unhandledRejection', listener));
+                        });
+                    }
+                }
+            });
+        }
+        Bluebird.onPossiblyUnhandledRejection(function (e, promise) {
+            try {
+                Zone.current.runGuarded(() => {
+                    e.isHandledByZone = true;
+                    throw e;
+                });
+            }
+            catch (err) {
+                err.isHandledByZone = false;
+                api.onUnhandledError(err);
+            }
+        });
+        // override global promise
+        global.Promise = Bluebird;
+    };
+});

my-app/node_modules/zone.js/fesm2015/zone-bluebird.min.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */Zone.__load_patch("bluebird",((e,n,o)=>{n[n.__symbol__("bluebird")]=function t(d){["then","spread","finally"].forEach((e=>{o.patchMethod(d.prototype,e,(e=>(o,t)=>{const r=n.current;for(let e=0;e<t.length;e++){const n=t[e];"function"==typeof n&&(t[e]=function(){const e=this,o=arguments;return new d(((t,d)=>{r.scheduleMicroTask("Promise.then",(()=>{try{t(n.apply(e,o))}catch(e){d(e)}}))}))})}return e.apply(o,t)}))})),"undefined"!=typeof window?window.addEventListener("unhandledrejection",(function(e){const n=e.detail&&e.detail.reason;n&&n.isHandledByZone&&(e.preventDefault(),"function"==typeof e.stopImmediatePropagation&&e.stopImmediatePropagation())})):"undefined"!=typeof process&&process.on("unhandledRejection",((e,n)=>{if(e&&e.isHandledByZone){const e=process.listeners("unhandledRejection");e&&(process.removeAllListeners("unhandledRejection"),process.nextTick((()=>{e.forEach((e=>process.on("unhandledRejection",e)))})))}})),d.onPossiblyUnhandledRejection((function(e,t){try{n.current.runGuarded((()=>{throw e.isHandledByZone=!0,e}))}catch(e){e.isHandledByZone=!1,o.onUnhandledError(e)}})),e.Promise=d}}));

my-app/node_modules/zone.js/fesm2015/zone-error.js

@@ -0,0 +1,330 @@
+'use strict';
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+/**
+ * @fileoverview
+ * @suppress {globalThis,undefinedVars}
+ */
+Zone.__load_patch('Error', (global, Zone, api) => {
+    /*
+     * This code patches Error so that:
+     *   - It ignores un-needed stack frames.
+     *   - It Shows the associated Zone for reach frame.
+     */
+    const zoneJsInternalStackFramesSymbol = api.symbol('zoneJsInternalStackFrames');
+    const NativeError = global[api.symbol('Error')] = global['Error'];
+    // Store the frames which should be removed from the stack frames
+    const zoneJsInternalStackFrames = {};
+    // We must find the frame where Error was created, otherwise we assume we don't understand stack
+    let zoneAwareFrame1;
+    let zoneAwareFrame2;
+    let zoneAwareFrame1WithoutNew;
+    let zoneAwareFrame2WithoutNew;
+    let zoneAwareFrame3WithoutNew;
+    global['Error'] = ZoneAwareError;
+    const stackRewrite = 'stackRewrite';
+    const zoneJsInternalStackFramesPolicy = global['__Zone_Error_BlacklistedStackFrames_policy'] ||
+        global['__Zone_Error_ZoneJsInternalStackFrames_policy'] || 'default';
+    function buildZoneFrameNames(zoneFrame) {
+        let zoneFrameName = { zoneName: zoneFrame.zone.name };
+        let result = zoneFrameName;
+        while (zoneFrame.parent) {
+            zoneFrame = zoneFrame.parent;
+            const parentZoneFrameName = { zoneName: zoneFrame.zone.name };
+            zoneFrameName.parent = parentZoneFrameName;
+            zoneFrameName = parentZoneFrameName;
+        }
+        return result;
+    }
+    function buildZoneAwareStackFrames(originalStack, zoneFrame, isZoneFrame = true) {
+        let frames = originalStack.split('\n');
+        let i = 0;
+        // Find the first frame
+        while (!(frames[i] === zoneAwareFrame1 || frames[i] === zoneAwareFrame2 ||
+            frames[i] === zoneAwareFrame1WithoutNew || frames[i] === zoneAwareFrame2WithoutNew ||
+            frames[i] === zoneAwareFrame3WithoutNew) &&
+            i < frames.length) {
+            i++;
+        }
+        for (; i < frames.length && zoneFrame; i++) {
+            let frame = frames[i];
+            if (frame.trim()) {
+                switch (zoneJsInternalStackFrames[frame]) {
+                    case 0 /* FrameType.zoneJsInternal */:
+                        frames.splice(i, 1);
+                        i--;
+                        break;
+                    case 1 /* FrameType.transition */:
+                        if (zoneFrame.parent) {
+                            // This is the special frame where zone changed. Print and process it accordingly
+                            zoneFrame = zoneFrame.parent;
+                        }
+                        else {
+                            zoneFrame = null;
+                        }
+                        frames.splice(i, 1);
+                        i--;
+                        break;
+                    default:
+                        frames[i] += isZoneFrame ? ` [${zoneFrame.zone.name}]` :
+                            ` [${zoneFrame.zoneName}]`;
+                }
+            }
+        }
+        return frames.join('\n');
+    }
+    /**
+     * This is ZoneAwareError which processes the stack frame and cleans up extra frames as well as
+     * adds zone information to it.
+     */
+    function ZoneAwareError() {
+        // We always have to return native error otherwise the browser console will not work.
+        let error = NativeError.apply(this, arguments);
+        // Save original stack trace
+        const originalStack = error['originalStack'] = error.stack;
+        // Process the stack trace and rewrite the frames.
+        if (ZoneAwareError[stackRewrite] && originalStack) {
+            let zoneFrame = api.currentZoneFrame();
+            if (zoneJsInternalStackFramesPolicy === 'lazy') {
+                // don't handle stack trace now
+                error[api.symbol('zoneFrameNames')] = buildZoneFrameNames(zoneFrame);
+            }
+            else if (zoneJsInternalStackFramesPolicy === 'default') {
+                try {
+                    error.stack = error.zoneAwareStack = buildZoneAwareStackFrames(originalStack, zoneFrame);
+                }
+                catch (e) {
+                    // ignore as some browsers don't allow overriding of stack
+                }
+            }
+        }
+        if (this instanceof NativeError && this.constructor != NativeError) {
+            // We got called with a `new` operator AND we are subclass of ZoneAwareError
+            // in that case we have to copy all of our properties to `this`.
+            Object.keys(error).concat('stack', 'message').forEach((key) => {
+                const value = error[key];
+                if (value !== undefined) {
+                    try {
+                        this[key] = value;
+                    }
+                    catch (e) {
+                        // ignore the assignment in case it is a setter and it throws.
+                    }
+                }
+            });
+            return this;
+        }
+        return error;
+    }
+    // Copy the prototype so that instanceof operator works as expected
+    ZoneAwareError.prototype = NativeError.prototype;
+    ZoneAwareError[zoneJsInternalStackFramesSymbol] = zoneJsInternalStackFrames;
+    ZoneAwareError[stackRewrite] = false;
+    const zoneAwareStackSymbol = api.symbol('zoneAwareStack');
+    // try to define zoneAwareStack property when zoneJsInternal frames policy is delay
+    if (zoneJsInternalStackFramesPolicy === 'lazy') {
+        Object.defineProperty(ZoneAwareError.prototype, 'zoneAwareStack', {
+            configurable: true,
+            enumerable: true,
+            get: function () {
+                if (!this[zoneAwareStackSymbol]) {
+                    this[zoneAwareStackSymbol] = buildZoneAwareStackFrames(this.originalStack, this[api.symbol('zoneFrameNames')], false);
+                }
+                return this[zoneAwareStackSymbol];
+            },
+            set: function (newStack) {
+                this.originalStack = newStack;
+                this[zoneAwareStackSymbol] = buildZoneAwareStackFrames(this.originalStack, this[api.symbol('zoneFrameNames')], false);
+            }
+        });
+    }
+    // those properties need special handling
+    const specialPropertyNames = ['stackTraceLimit', 'captureStackTrace', 'prepareStackTrace'];
+    // those properties of NativeError should be set to ZoneAwareError
+    const nativeErrorProperties = Object.keys(NativeError);
+    if (nativeErrorProperties) {
+        nativeErrorProperties.forEach(prop => {
+            if (specialPropertyNames.filter(sp => sp === prop).length === 0) {
+                Object.defineProperty(ZoneAwareError, prop, {
+                    get: function () {
+                        return NativeError[prop];
+                    },
+                    set: function (value) {
+                        NativeError[prop] = value;
+                    }
+                });
+            }
+        });
+    }
+    if (NativeError.hasOwnProperty('stackTraceLimit')) {
+        // Extend default stack limit as we will be removing few frames.
+        NativeError.stackTraceLimit = Math.max(NativeError.stackTraceLimit, 15);
+        // make sure that ZoneAwareError has the same property which forwards to NativeError.
+        Object.defineProperty(ZoneAwareError, 'stackTraceLimit', {
+            get: function () {
+                return NativeError.stackTraceLimit;
+            },
+            set: function (value) {
+                return NativeError.stackTraceLimit = value;
+            }
+        });
+    }
+    if (NativeError.hasOwnProperty('captureStackTrace')) {
+        Object.defineProperty(ZoneAwareError, 'captureStackTrace', {
+            // add named function here because we need to remove this
+            // stack frame when prepareStackTrace below
+            value: function zoneCaptureStackTrace(targetObject, constructorOpt) {
+                NativeError.captureStackTrace(targetObject, constructorOpt);
+            }
+        });
+    }
+    const ZONE_CAPTURESTACKTRACE = 'zoneCaptureStackTrace';
+    Object.defineProperty(ZoneAwareError, 'prepareStackTrace', {
+        get: function () {
+            return NativeError.prepareStackTrace;
+        },
+        set: function (value) {
+            if (!value || typeof value !== 'function') {
+                return NativeError.prepareStackTrace = value;
+            }
+            return NativeError.prepareStackTrace = function (error, structuredStackTrace) {
+                // remove additional stack information from ZoneAwareError.captureStackTrace
+                if (structuredStackTrace) {
+                    for (let i = 0; i < structuredStackTrace.length; i++) {
+                        const st = structuredStackTrace[i];
+                        // remove the first function which name is zoneCaptureStackTrace
+                        if (st.getFunctionName() === ZONE_CAPTURESTACKTRACE) {
+                            structuredStackTrace.splice(i, 1);
+                            break;
+                        }
+                    }
+                }
+                return value.call(this, error, structuredStackTrace);
+            };
+        }
+    });
+    if (zoneJsInternalStackFramesPolicy === 'disable') {
+        // don't need to run detectZone to populate zoneJs internal stack frames
+        return;
+    }
+    // Now we need to populate the `zoneJsInternalStackFrames` as well as find the
+    // run/runGuarded/runTask frames. This is done by creating a detect zone and then threading
+    // the execution through all of the above methods so that we can look at the stack trace and
+    // find the frames of interest.
+    let detectZone = Zone.current.fork({
+        name: 'detect',
+        onHandleError: function (parentZD, current, target, error) {
+            if (error.originalStack && Error === ZoneAwareError) {
+                let frames = error.originalStack.split(/\n/);
+                let runFrame = false, runGuardedFrame = false, runTaskFrame = false;
+                while (frames.length) {
+                    let frame = frames.shift();
+                    // On safari it is possible to have stack frame with no line number.
+                    // This check makes sure that we don't filter frames on name only (must have
+                    // line number or exact equals to `ZoneAwareError`)
+                    if (/:\d+:\d+/.test(frame) || frame === 'ZoneAwareError') {
+                        // Get rid of the path so that we don't accidentally find function name in path.
+                        // In chrome the separator is `(` and `@` in FF and safari
+                        // Chrome: at Zone.run (zone.js:100)
+                        // Chrome: at Zone.run (http://localhost:9876/base/build/lib/zone.js:100:24)
+                        // FireFox: Zone.prototype.run@http://localhost:9876/base/build/lib/zone.js:101:24
+                        // Safari: run@http://localhost:9876/base/build/lib/zone.js:101:24
+                        let fnName = frame.split('(')[0].split('@')[0];
+                        let frameType = 1 /* FrameType.transition */;
+                        if (fnName.indexOf('ZoneAwareError') !== -1) {
+                            if (fnName.indexOf('new ZoneAwareError') !== -1) {
+                                zoneAwareFrame1 = frame;
+                                zoneAwareFrame2 = frame.replace('new ZoneAwareError', 'new Error.ZoneAwareError');
+                            }
+                            else {
+                                zoneAwareFrame1WithoutNew = frame;
+                                zoneAwareFrame2WithoutNew = frame.replace('Error.', '');
+                                if (frame.indexOf('Error.ZoneAwareError') === -1) {
+                                    zoneAwareFrame3WithoutNew =
+                                        frame.replace('ZoneAwareError', 'Error.ZoneAwareError');
+                                }
+                            }
+                            zoneJsInternalStackFrames[zoneAwareFrame2] = 0 /* FrameType.zoneJsInternal */;
+                        }
+                        if (fnName.indexOf('runGuarded') !== -1) {
+                            runGuardedFrame = true;
+                        }
+                        else if (fnName.indexOf('runTask') !== -1) {
+                            runTaskFrame = true;
+                        }
+                        else if (fnName.indexOf('run') !== -1) {
+                            runFrame = true;
+                        }
+                        else {
+                            frameType = 0 /* FrameType.zoneJsInternal */;
+                        }
+                        zoneJsInternalStackFrames[frame] = frameType;
+                        // Once we find all of the frames we can stop looking.
+                        if (runFrame && runGuardedFrame && runTaskFrame) {
+                            ZoneAwareError[stackRewrite] = true;
+                            break;
+                        }
+                    }
+                }
+            }
+            return false;
+        }
+    });
+    // carefully constructor a stack frame which contains all of the frames of interest which
+    // need to be detected and marked as an internal zoneJs frame.
+    const childDetectZone = detectZone.fork({
+        name: 'child',
+        onScheduleTask: function (delegate, curr, target, task) {
+            return delegate.scheduleTask(target, task);
+        },
+        onInvokeTask: function (delegate, curr, target, task, applyThis, applyArgs) {
+            return delegate.invokeTask(target, task, applyThis, applyArgs);
+        },
+        onCancelTask: function (delegate, curr, target, task) {
+            return delegate.cancelTask(target, task);
+        },
+        onInvoke: function (delegate, curr, target, callback, applyThis, applyArgs, source) {
+            return delegate.invoke(target, callback, applyThis, applyArgs, source);
+        }
+    });
+    // we need to detect all zone related frames, it will
+    // exceed default stackTraceLimit, so we set it to
+    // larger number here, and restore it after detect finish.
+    // We cast through any so we don't need to depend on nodejs typings.
+    const originalStackTraceLimit = Error.stackTraceLimit;
+    Error.stackTraceLimit = 100;
+    // we schedule event/micro/macro task, and invoke them
+    // when onSchedule, so we can get all stack traces for
+    // all kinds of tasks with one error thrown.
+    childDetectZone.run(() => {
+        childDetectZone.runGuarded(() => {
+            const fakeTransitionTo = () => { };
+            childDetectZone.scheduleEventTask(zoneJsInternalStackFramesSymbol, () => {
+                childDetectZone.scheduleMacroTask(zoneJsInternalStackFramesSymbol, () => {
+                    childDetectZone.scheduleMicroTask(zoneJsInternalStackFramesSymbol, () => {
+                        throw new Error();
+                    }, undefined, (t) => {
+                        t._transitionTo = fakeTransitionTo;
+                        t.invoke();
+                    });
+                    childDetectZone.scheduleMicroTask(zoneJsInternalStackFramesSymbol, () => {
+                        throw Error();
+                    }, undefined, (t) => {
+                        t._transitionTo = fakeTransitionTo;
+                        t.invoke();
+                    });
+                }, undefined, (t) => {
+                    t._transitionTo = fakeTransitionTo;
+                    t.invoke();
+                }, () => { });
+            }, undefined, (t) => {
+                t._transitionTo = fakeTransitionTo;
+                t.invoke();
+            }, () => { });
+        });
+    });
+    Error.stackTraceLimit = originalStackTraceLimit;
+});

my-app/node_modules/zone.js/fesm2015/zone-error.min.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */Zone.__load_patch("Error",((e,r,t)=>{const n=t.symbol("zoneJsInternalStackFrames"),a=e[t.symbol("Error")]=e.Error,o={};let c,i,s,l,u;e.Error=h;const k="stackRewrite",f=e.__Zone_Error_BlacklistedStackFrames_policy||e.__Zone_Error_ZoneJsInternalStackFrames_policy||"default";function p(e,r,t=!0){let n=e.split("\n"),a=0;for(;n[a]!==c&&n[a]!==i&&n[a]!==s&&n[a]!==l&&n[a]!==u&&a<n.length;)a++;for(;a<n.length&&r;a++){let e=n[a];if(e.trim())switch(o[e]){case 0:n.splice(a,1),a--;break;case 1:r=r.parent?r.parent:null,n.splice(a,1),a--;break;default:n[a]+=t?` [${r.zone.name}]`:` [${r.zoneName}]`}}return n.join("\n")}function h(){let e=a.apply(this,arguments);const r=e.originalStack=e.stack;if(h[k]&&r){let n=t.currentZoneFrame();if("lazy"===f)e[t.symbol("zoneFrameNames")]=function a(e){let r={zoneName:e.zone.name},t=r;for(;e.parent;){const t={zoneName:(e=e.parent).zone.name};r.parent=t,r=t}return t}(n);else if("default"===f)try{e.stack=e.zoneAwareStack=p(r,n)}catch(e){}}return this instanceof a&&this.constructor!=a?(Object.keys(e).concat("stack","message").forEach((r=>{const t=e[r];if(void 0!==t)try{this[r]=t}catch(e){}})),this):e}h.prototype=a.prototype,h[n]=o,h[k]=!1;const m=t.symbol("zoneAwareStack");"lazy"===f&&Object.defineProperty(h.prototype,"zoneAwareStack",{configurable:!0,enumerable:!0,get:function(){return this[m]||(this[m]=p(this.originalStack,this[t.symbol("zoneFrameNames")],!1)),this[m]},set:function(e){this.originalStack=e,this[m]=p(this.originalStack,this[t.symbol("zoneFrameNames")],!1)}});const d=["stackTraceLimit","captureStackTrace","prepareStackTrace"],T=Object.keys(a);if(T&&T.forEach((e=>{0===d.filter((r=>r===e)).length&&Object.defineProperty(h,e,{get:function(){return a[e]},set:function(r){a[e]=r}})})),a.hasOwnProperty("stackTraceLimit")&&(a.stackTraceLimit=Math.max(a.stackTraceLimit,15),Object.defineProperty(h,"stackTraceLimit",{get:function(){return a.stackTraceLimit},set:function(e){return a.stackTraceLimit=e}})),a.hasOwnProperty("captureStackTrace")&&Object.defineProperty(h,"captureStackTrace",{value:function e(r,t){a.captureStackTrace(r,t)}}),Object.defineProperty(h,"prepareStackTrace",{get:function(){return a.prepareStackTrace},set:function(e){return a.prepareStackTrace=e&&"function"==typeof e?function(r,t){if(t)for(let e=0;e<t.length;e++)if("zoneCaptureStackTrace"===t[e].getFunctionName()){t.splice(e,1);break}return e.call(this,r,t)}:e}}),"disable"===f)return;const E=r.current.fork({name:"detect",onHandleError:function(e,r,t,n){if(n.originalStack&&Error===h){let e=n.originalStack.split(/\n/),r=!1,t=!1,a=!1;for(;e.length;){let n=e.shift();if(/:\d+:\d+/.test(n)||"ZoneAwareError"===n){let e=n.split("(")[0].split("@")[0],f=1;if(-1!==e.indexOf("ZoneAwareError")&&(-1!==e.indexOf("new ZoneAwareError")?(c=n,i=n.replace("new ZoneAwareError","new Error.ZoneAwareError")):(s=n,l=n.replace("Error.",""),-1===n.indexOf("Error.ZoneAwareError")&&(u=n.replace("ZoneAwareError","Error.ZoneAwareError"))),o[i]=0),-1!==e.indexOf("runGuarded")?t=!0:-1!==e.indexOf("runTask")?a=!0:-1!==e.indexOf("run")?r=!0:f=0,o[n]=f,r&&t&&a){h[k]=!0;break}}}}return!1}}).fork({name:"child",onScheduleTask:function(e,r,t,n){return e.scheduleTask(t,n)},onInvokeTask:function(e,r,t,n,a,o){return e.invokeTask(t,n,a,o)},onCancelTask:function(e,r,t,n){return e.cancelTask(t,n)},onInvoke:function(e,r,t,n,a,o,c){return e.invoke(t,n,a,o,c)}}),y=Error.stackTraceLimit;Error.stackTraceLimit=100,E.run((()=>{E.runGuarded((()=>{const e=()=>{};E.scheduleEventTask(n,(()=>{E.scheduleMacroTask(n,(()=>{E.scheduleMicroTask(n,(()=>{throw new Error}),void 0,(r=>{r._transitionTo=e,r.invoke()})),E.scheduleMicroTask(n,(()=>{throw Error()}),void 0,(r=>{r._transitionTo=e,r.invoke()}))}),void 0,(r=>{r._transitionTo=e,r.invoke()}),(()=>{}))}),void 0,(r=>{r._transitionTo=e,r.invoke()}),(()=>{}))}))})),Error.stackTraceLimit=y}));

my-app/node_modules/zone.js/fesm2015/zone-legacy.js

@@ -0,0 +1,659 @@
+'use strict';
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+/*
+ * This is necessary for Chrome and Chrome mobile, to enable
+ * things like redefining `createdCallback` on an element.
+ */
+let zoneSymbol;
+let _defineProperty;
+let _getOwnPropertyDescriptor;
+let _create;
+let unconfigurablesKey;
+function propertyPatch() {
+    zoneSymbol = Zone.__symbol__;
+    _defineProperty = Object[zoneSymbol('defineProperty')] = Object.defineProperty;
+    _getOwnPropertyDescriptor = Object[zoneSymbol('getOwnPropertyDescriptor')] =
+        Object.getOwnPropertyDescriptor;
+    _create = Object.create;
+    unconfigurablesKey = zoneSymbol('unconfigurables');
+    Object.defineProperty = function (obj, prop, desc) {
+        if (isUnconfigurable(obj, prop)) {
+            throw new TypeError('Cannot assign to read only property \'' + prop + '\' of ' + obj);
+        }
+        const originalConfigurableFlag = desc.configurable;
+        if (prop !== 'prototype') {
+            desc = rewriteDescriptor(obj, prop, desc);
+        }
+        return _tryDefineProperty(obj, prop, desc, originalConfigurableFlag);
+    };
+    Object.defineProperties = function (obj, props) {
+        Object.keys(props).forEach(function (prop) {
+            Object.defineProperty(obj, prop, props[prop]);
+        });
+        for (const sym of Object.getOwnPropertySymbols(props)) {
+            const desc = Object.getOwnPropertyDescriptor(props, sym);
+            // Since `Object.getOwnPropertySymbols` returns *all* symbols,
+            // including non-enumerable ones, retrieve property descriptor and check
+            // enumerability there. Proceed with the rewrite only when a property is
+            // enumerable to make the logic consistent with the way regular
+            // properties are retrieved (via `Object.keys`, which respects
+            // `enumerable: false` flag). More information:
+            // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Enumerability_and_ownership_of_properties#retrieval
+            if (desc?.enumerable) {
+                Object.defineProperty(obj, sym, props[sym]);
+            }
+        }
+        return obj;
+    };
+    Object.create = function (proto, propertiesObject) {
+        if (typeof propertiesObject === 'object' && !Object.isFrozen(propertiesObject)) {
+            Object.keys(propertiesObject).forEach(function (prop) {
+                propertiesObject[prop] = rewriteDescriptor(proto, prop, propertiesObject[prop]);
+            });
+        }
+        return _create(proto, propertiesObject);
+    };
+    Object.getOwnPropertyDescriptor = function (obj, prop) {
+        const desc = _getOwnPropertyDescriptor(obj, prop);
+        if (desc && isUnconfigurable(obj, prop)) {
+            desc.configurable = false;
+        }
+        return desc;
+    };
+}
+function _redefineProperty(obj, prop, desc) {
+    const originalConfigurableFlag = desc.configurable;
+    desc = rewriteDescriptor(obj, prop, desc);
+    return _tryDefineProperty(obj, prop, desc, originalConfigurableFlag);
+}
+function isUnconfigurable(obj, prop) {
+    return obj && obj[unconfigurablesKey] && obj[unconfigurablesKey][prop];
+}
+function rewriteDescriptor(obj, prop, desc) {
+    // issue-927, if the desc is frozen, don't try to change the desc
+    if (!Object.isFrozen(desc)) {
+        desc.configurable = true;
+    }
+    if (!desc.configurable) {
+        // issue-927, if the obj is frozen, don't try to set the desc to obj
+        if (!obj[unconfigurablesKey] && !Object.isFrozen(obj)) {
+            _defineProperty(obj, unconfigurablesKey, { writable: true, value: {} });
+        }
+        if (obj[unconfigurablesKey]) {
+            obj[unconfigurablesKey][prop] = true;
+        }
+    }
+    return desc;
+}
+function _tryDefineProperty(obj, prop, desc, originalConfigurableFlag) {
+    try {
+        return _defineProperty(obj, prop, desc);
+    }
+    catch (error) {
+        if (desc.configurable) {
+            // In case of errors, when the configurable flag was likely set by rewriteDescriptor(),
+            // let's retry with the original flag value
+            if (typeof originalConfigurableFlag == 'undefined') {
+                delete desc.configurable;
+            }
+            else {
+                desc.configurable = originalConfigurableFlag;
+            }
+            try {
+                return _defineProperty(obj, prop, desc);
+            }
+            catch (error) {
+                let swallowError = false;
+                if (prop === 'createdCallback' || prop === 'attachedCallback' ||
+                    prop === 'detachedCallback' || prop === 'attributeChangedCallback') {
+                    // We only swallow the error in registerElement patch
+                    // this is the work around since some applications
+                    // fail if we throw the error
+                    swallowError = true;
+                }
+                if (!swallowError) {
+                    throw error;
+                }
+                // TODO: @JiaLiPassion, Some application such as `registerElement` patch
+                // still need to swallow the error, in the future after these applications
+                // are updated, the following logic can be removed.
+                let descJson = null;
+                try {
+                    descJson = JSON.stringify(desc);
+                }
+                catch (error) {
+                    descJson = desc.toString();
+                }
+                console.log(`Attempting to configure '${prop}' with descriptor '${descJson}' on object '${obj}' and got error, giving up: ${error}`);
+            }
+        }
+        else {
+            throw error;
+        }
+    }
+}
+
+function eventTargetLegacyPatch(_global, api) {
+    const { eventNames, globalSources, zoneSymbolEventNames, TRUE_STR, FALSE_STR, ZONE_SYMBOL_PREFIX } = api.getGlobalObjects();
+    const WTF_ISSUE_555 = 'Anchor,Area,Audio,BR,Base,BaseFont,Body,Button,Canvas,Content,DList,Directory,Div,Embed,FieldSet,Font,Form,Frame,FrameSet,HR,Head,Heading,Html,IFrame,Image,Input,Keygen,LI,Label,Legend,Link,Map,Marquee,Media,Menu,Meta,Meter,Mod,OList,Object,OptGroup,Option,Output,Paragraph,Pre,Progress,Quote,Script,Select,Source,Span,Style,TableCaption,TableCell,TableCol,Table,TableRow,TableSection,TextArea,Title,Track,UList,Unknown,Video';
+    const NO_EVENT_TARGET = 'ApplicationCache,EventSource,FileReader,InputMethodContext,MediaController,MessagePort,Node,Performance,SVGElementInstance,SharedWorker,TextTrack,TextTrackCue,TextTrackList,WebKitNamedFlow,Window,Worker,WorkerGlobalScope,XMLHttpRequest,XMLHttpRequestEventTarget,XMLHttpRequestUpload,IDBRequest,IDBOpenDBRequest,IDBDatabase,IDBTransaction,IDBCursor,DBIndex,WebSocket'
+        .split(',');
+    const EVENT_TARGET = 'EventTarget';
+    let apis = [];
+    const isWtf = _global['wtf'];
+    const WTF_ISSUE_555_ARRAY = WTF_ISSUE_555.split(',');
+    if (isWtf) {
+        // Workaround for: https://github.com/google/tracing-framework/issues/555
+        apis = WTF_ISSUE_555_ARRAY.map((v) => 'HTML' + v + 'Element').concat(NO_EVENT_TARGET);
+    }
+    else if (_global[EVENT_TARGET]) {
+        apis.push(EVENT_TARGET);
+    }
+    else {
+        // Note: EventTarget is not available in all browsers,
+        // if it's not available, we instead patch the APIs in the IDL that inherit from EventTarget
+        apis = NO_EVENT_TARGET;
+    }
+    const isDisableIECheck = _global['__Zone_disable_IE_check'] || false;
+    const isEnableCrossContextCheck = _global['__Zone_enable_cross_context_check'] || false;
+    const ieOrEdge = api.isIEOrEdge();
+    const ADD_EVENT_LISTENER_SOURCE = '.addEventListener:';
+    const FUNCTION_WRAPPER = '[object FunctionWrapper]';
+    const BROWSER_TOOLS = 'function __BROWSERTOOLS_CONSOLE_SAFEFUNC() { [native code] }';
+    const pointerEventsMap = {
+        'MSPointerCancel': 'pointercancel',
+        'MSPointerDown': 'pointerdown',
+        'MSPointerEnter': 'pointerenter',
+        'MSPointerHover': 'pointerhover',
+        'MSPointerLeave': 'pointerleave',
+        'MSPointerMove': 'pointermove',
+        'MSPointerOut': 'pointerout',
+        'MSPointerOver': 'pointerover',
+        'MSPointerUp': 'pointerup'
+    };
+    //  predefine all __zone_symbol__ + eventName + true/false string
+    for (let i = 0; i < eventNames.length; i++) {
+        const eventName = eventNames[i];
+        const falseEventName = eventName + FALSE_STR;
+        const trueEventName = eventName + TRUE_STR;
+        const symbol = ZONE_SYMBOL_PREFIX + falseEventName;
+        const symbolCapture = ZONE_SYMBOL_PREFIX + trueEventName;
+        zoneSymbolEventNames[eventName] = {};
+        zoneSymbolEventNames[eventName][FALSE_STR] = symbol;
+        zoneSymbolEventNames[eventName][TRUE_STR] = symbolCapture;
+    }
+    //  predefine all task.source string
+    for (let i = 0; i < WTF_ISSUE_555_ARRAY.length; i++) {
+        const target = WTF_ISSUE_555_ARRAY[i];
+        const targets = globalSources[target] = {};
+        for (let j = 0; j < eventNames.length; j++) {
+            const eventName = eventNames[j];
+            targets[eventName] = target + ADD_EVENT_LISTENER_SOURCE + eventName;
+        }
+    }
+    const checkIEAndCrossContext = function (nativeDelegate, delegate, target, args) {
+        if (!isDisableIECheck && ieOrEdge) {
+            if (isEnableCrossContextCheck) {
+                try {
+                    const testString = delegate.toString();
+                    if ((testString === FUNCTION_WRAPPER || testString == BROWSER_TOOLS)) {
+                        nativeDelegate.apply(target, args);
+                        return false;
+                    }
+                }
+                catch (error) {
+                    nativeDelegate.apply(target, args);
+                    return false;
+                }
+            }
+            else {
+                const testString = delegate.toString();
+                if ((testString === FUNCTION_WRAPPER || testString == BROWSER_TOOLS)) {
+                    nativeDelegate.apply(target, args);
+                    return false;
+                }
+            }
+        }
+        else if (isEnableCrossContextCheck) {
+            try {
+                delegate.toString();
+            }
+            catch (error) {
+                nativeDelegate.apply(target, args);
+                return false;
+            }
+        }
+        return true;
+    };
+    const apiTypes = [];
+    for (let i = 0; i < apis.length; i++) {
+        const type = _global[apis[i]];
+        apiTypes.push(type && type.prototype);
+    }
+    // vh is validateHandler to check event handler
+    // is valid or not(for security check)
+    api.patchEventTarget(_global, api, apiTypes, {
+        vh: checkIEAndCrossContext,
+        transferEventName: (eventName) => {
+            const pointerEventName = pointerEventsMap[eventName];
+            return pointerEventName || eventName;
+        }
+    });
+    Zone[api.symbol('patchEventTarget')] = !!_global[EVENT_TARGET];
+    return true;
+}
+
+// we have to patch the instance since the proto is non-configurable
+function apply(api, _global) {
+    const { ADD_EVENT_LISTENER_STR, REMOVE_EVENT_LISTENER_STR } = api.getGlobalObjects();
+    const WS = _global.WebSocket;
+    // On Safari window.EventTarget doesn't exist so need to patch WS add/removeEventListener
+    // On older Chrome, no need since EventTarget was already patched
+    if (!_global.EventTarget) {
+        api.patchEventTarget(_global, api, [WS.prototype]);
+    }
+    _global.WebSocket = function (x, y) {
+        const socket = arguments.length > 1 ? new WS(x, y) : new WS(x);
+        let proxySocket;
+        let proxySocketProto;
+        // Safari 7.0 has non-configurable own 'onmessage' and friends properties on the socket instance
+        const onmessageDesc = api.ObjectGetOwnPropertyDescriptor(socket, 'onmessage');
+        if (onmessageDesc && onmessageDesc.configurable === false) {
+            proxySocket = api.ObjectCreate(socket);
+            // socket have own property descriptor 'onopen', 'onmessage', 'onclose', 'onerror'
+            // but proxySocket not, so we will keep socket as prototype and pass it to
+            // patchOnProperties method
+            proxySocketProto = socket;
+            [ADD_EVENT_LISTENER_STR, REMOVE_EVENT_LISTENER_STR, 'send', 'close'].forEach(function (propName) {
+                proxySocket[propName] = function () {
+                    const args = api.ArraySlice.call(arguments);
+                    if (propName === ADD_EVENT_LISTENER_STR || propName === REMOVE_EVENT_LISTENER_STR) {
+                        const eventName = args.length > 0 ? args[0] : undefined;
+                        if (eventName) {
+                            const propertySymbol = Zone.__symbol__('ON_PROPERTY' + eventName);
+                            socket[propertySymbol] = proxySocket[propertySymbol];
+                        }
+                    }
+                    return socket[propName].apply(socket, args);
+                };
+            });
+        }
+        else {
+            // we can patch the real socket
+            proxySocket = socket;
+        }
+        api.patchOnProperties(proxySocket, ['close', 'error', 'message', 'open'], proxySocketProto);
+        return proxySocket;
+    };
+    const globalWebSocket = _global['WebSocket'];
+    for (const prop in WS) {
+        globalWebSocket[prop] = WS[prop];
+    }
+}
+
+/**
+ * @fileoverview
+ * @suppress {globalThis}
+ */
+function propertyDescriptorLegacyPatch(api, _global) {
+    const { isNode, isMix } = api.getGlobalObjects();
+    if (isNode && !isMix) {
+        return;
+    }
+    if (!canPatchViaPropertyDescriptor(api, _global)) {
+        const supportsWebSocket = typeof WebSocket !== 'undefined';
+        // Safari, Android browsers (Jelly Bean)
+        patchViaCapturingAllTheEvents(api);
+        api.patchClass('XMLHttpRequest');
+        if (supportsWebSocket) {
+            apply(api, _global);
+        }
+        Zone[api.symbol('patchEvents')] = true;
+    }
+}
+function canPatchViaPropertyDescriptor(api, _global) {
+    const { isBrowser, isMix } = api.getGlobalObjects();
+    if ((isBrowser || isMix) &&
+        !api.ObjectGetOwnPropertyDescriptor(HTMLElement.prototype, 'onclick') &&
+        typeof Element !== 'undefined') {
+        // WebKit https://bugs.webkit.org/show_bug.cgi?id=134364
+        // IDL interface attributes are not configurable
+        const desc = api.ObjectGetOwnPropertyDescriptor(Element.prototype, 'onclick');
+        if (desc && !desc.configurable)
+            return false;
+        // try to use onclick to detect whether we can patch via propertyDescriptor
+        // because XMLHttpRequest is not available in service worker
+        if (desc) {
+            api.ObjectDefineProperty(Element.prototype, 'onclick', {
+                enumerable: true,
+                configurable: true,
+                get: function () {
+                    return true;
+                }
+            });
+            const div = document.createElement('div');
+            const result = !!div.onclick;
+            api.ObjectDefineProperty(Element.prototype, 'onclick', desc);
+            return result;
+        }
+    }
+    const XMLHttpRequest = _global['XMLHttpRequest'];
+    if (!XMLHttpRequest) {
+        // XMLHttpRequest is not available in service worker
+        return false;
+    }
+    const ON_READY_STATE_CHANGE = 'onreadystatechange';
+    const XMLHttpRequestPrototype = XMLHttpRequest.prototype;
+    const xhrDesc = api.ObjectGetOwnPropertyDescriptor(XMLHttpRequestPrototype, ON_READY_STATE_CHANGE);
+    // add enumerable and configurable here because in opera
+    // by default XMLHttpRequest.prototype.onreadystatechange is undefined
+    // without adding enumerable and configurable will cause onreadystatechange
+    // non-configurable
+    // and if XMLHttpRequest.prototype.onreadystatechange is undefined,
+    // we should set a real desc instead a fake one
+    if (xhrDesc) {
+        api.ObjectDefineProperty(XMLHttpRequestPrototype, ON_READY_STATE_CHANGE, {
+            enumerable: true,
+            configurable: true,
+            get: function () {
+                return true;
+            }
+        });
+        const req = new XMLHttpRequest();
+        const result = !!req.onreadystatechange;
+        // restore original desc
+        api.ObjectDefineProperty(XMLHttpRequestPrototype, ON_READY_STATE_CHANGE, xhrDesc || {});
+        return result;
+    }
+    else {
+        const SYMBOL_FAKE_ONREADYSTATECHANGE = api.symbol('fake');
+        api.ObjectDefineProperty(XMLHttpRequestPrototype, ON_READY_STATE_CHANGE, {
+            enumerable: true,
+            configurable: true,
+            get: function () {
+                return this[SYMBOL_FAKE_ONREADYSTATECHANGE];
+            },
+            set: function (value) {
+                this[SYMBOL_FAKE_ONREADYSTATECHANGE] = value;
+            }
+        });
+        const req = new XMLHttpRequest();
+        const detectFunc = () => { };
+        req.onreadystatechange = detectFunc;
+        const result = req[SYMBOL_FAKE_ONREADYSTATECHANGE] === detectFunc;
+        req.onreadystatechange = null;
+        return result;
+    }
+}
+const globalEventHandlersEventNames = [
+    'abort',
+    'animationcancel',
+    'animationend',
+    'animationiteration',
+    'auxclick',
+    'beforeinput',
+    'blur',
+    'cancel',
+    'canplay',
+    'canplaythrough',
+    'change',
+    'compositionstart',
+    'compositionupdate',
+    'compositionend',
+    'cuechange',
+    'click',
+    'close',
+    'contextmenu',
+    'curechange',
+    'dblclick',
+    'drag',
+    'dragend',
+    'dragenter',
+    'dragexit',
+    'dragleave',
+    'dragover',
+    'drop',
+    'durationchange',
+    'emptied',
+    'ended',
+    'error',
+    'focus',
+    'focusin',
+    'focusout',
+    'gotpointercapture',
+    'input',
+    'invalid',
+    'keydown',
+    'keypress',
+    'keyup',
+    'load',
+    'loadstart',
+    'loadeddata',
+    'loadedmetadata',
+    'lostpointercapture',
+    'mousedown',
+    'mouseenter',
+    'mouseleave',
+    'mousemove',
+    'mouseout',
+    'mouseover',
+    'mouseup',
+    'mousewheel',
+    'orientationchange',
+    'pause',
+    'play',
+    'playing',
+    'pointercancel',
+    'pointerdown',
+    'pointerenter',
+    'pointerleave',
+    'pointerlockchange',
+    'mozpointerlockchange',
+    'webkitpointerlockerchange',
+    'pointerlockerror',
+    'mozpointerlockerror',
+    'webkitpointerlockerror',
+    'pointermove',
+    'pointout',
+    'pointerover',
+    'pointerup',
+    'progress',
+    'ratechange',
+    'reset',
+    'resize',
+    'scroll',
+    'seeked',
+    'seeking',
+    'select',
+    'selectionchange',
+    'selectstart',
+    'show',
+    'sort',
+    'stalled',
+    'submit',
+    'suspend',
+    'timeupdate',
+    'volumechange',
+    'touchcancel',
+    'touchmove',
+    'touchstart',
+    'touchend',
+    'transitioncancel',
+    'transitionend',
+    'waiting',
+    'wheel'
+];
+const documentEventNames = [
+    'afterscriptexecute', 'beforescriptexecute', 'DOMContentLoaded', 'freeze', 'fullscreenchange',
+    'mozfullscreenchange', 'webkitfullscreenchange', 'msfullscreenchange', 'fullscreenerror',
+    'mozfullscreenerror', 'webkitfullscreenerror', 'msfullscreenerror', 'readystatechange',
+    'visibilitychange', 'resume'
+];
+const windowEventNames = [
+    'absolutedeviceorientation',
+    'afterinput',
+    'afterprint',
+    'appinstalled',
+    'beforeinstallprompt',
+    'beforeprint',
+    'beforeunload',
+    'devicelight',
+    'devicemotion',
+    'deviceorientation',
+    'deviceorientationabsolute',
+    'deviceproximity',
+    'hashchange',
+    'languagechange',
+    'message',
+    'mozbeforepaint',
+    'offline',
+    'online',
+    'paint',
+    'pageshow',
+    'pagehide',
+    'popstate',
+    'rejectionhandled',
+    'storage',
+    'unhandledrejection',
+    'unload',
+    'userproximity',
+    'vrdisplayconnected',
+    'vrdisplaydisconnected',
+    'vrdisplaypresentchange'
+];
+const htmlElementEventNames = [
+    'beforecopy', 'beforecut', 'beforepaste', 'copy', 'cut', 'paste', 'dragstart', 'loadend',
+    'animationstart', 'search', 'transitionrun', 'transitionstart', 'webkitanimationend',
+    'webkitanimationiteration', 'webkitanimationstart', 'webkittransitionend'
+];
+const ieElementEventNames = [
+    'activate',
+    'afterupdate',
+    'ariarequest',
+    'beforeactivate',
+    'beforedeactivate',
+    'beforeeditfocus',
+    'beforeupdate',
+    'cellchange',
+    'controlselect',
+    'dataavailable',
+    'datasetchanged',
+    'datasetcomplete',
+    'errorupdate',
+    'filterchange',
+    'layoutcomplete',
+    'losecapture',
+    'move',
+    'moveend',
+    'movestart',
+    'propertychange',
+    'resizeend',
+    'resizestart',
+    'rowenter',
+    'rowexit',
+    'rowsdelete',
+    'rowsinserted',
+    'command',
+    'compassneedscalibration',
+    'deactivate',
+    'help',
+    'mscontentzoom',
+    'msmanipulationstatechanged',
+    'msgesturechange',
+    'msgesturedoubletap',
+    'msgestureend',
+    'msgesturehold',
+    'msgesturestart',
+    'msgesturetap',
+    'msgotpointercapture',
+    'msinertiastart',
+    'mslostpointercapture',
+    'mspointercancel',
+    'mspointerdown',
+    'mspointerenter',
+    'mspointerhover',
+    'mspointerleave',
+    'mspointermove',
+    'mspointerout',
+    'mspointerover',
+    'mspointerup',
+    'pointerout',
+    'mssitemodejumplistitemremoved',
+    'msthumbnailclick',
+    'stop',
+    'storagecommit'
+];
+const webglEventNames = ['webglcontextrestored', 'webglcontextlost', 'webglcontextcreationerror'];
+const formEventNames = ['autocomplete', 'autocompleteerror'];
+const detailEventNames = ['toggle'];
+const eventNames = [
+    ...globalEventHandlersEventNames, ...webglEventNames, ...formEventNames, ...detailEventNames,
+    ...documentEventNames, ...windowEventNames, ...htmlElementEventNames, ...ieElementEventNames
+];
+// Whenever any eventListener fires, we check the eventListener target and all parents
+// for `onwhatever` properties and replace them with zone-bound functions
+// - Chrome (for now)
+function patchViaCapturingAllTheEvents(api) {
+    const unboundKey = api.symbol('unbound');
+    for (let i = 0; i < eventNames.length; i++) {
+        const property = eventNames[i];
+        const onproperty = 'on' + property;
+        self.addEventListener(property, function (event) {
+            let elt = event.target, bound, source;
+            if (elt) {
+                source = elt.constructor['name'] + '.' + onproperty;
+            }
+            else {
+                source = 'unknown.' + onproperty;
+            }
+            while (elt) {
+                if (elt[onproperty] && !elt[onproperty][unboundKey]) {
+                    bound = api.wrapWithCurrentZone(elt[onproperty], source);
+                    bound[unboundKey] = elt[onproperty];
+                    elt[onproperty] = bound;
+                }
+                elt = elt.parentElement;
+            }
+        }, true);
+    }
+}
+
+function registerElementPatch(_global, api) {
+    const { isBrowser, isMix } = api.getGlobalObjects();
+    if ((!isBrowser && !isMix) || !('registerElement' in _global.document)) {
+        return;
+    }
+    const callbacks = ['createdCallback', 'attachedCallback', 'detachedCallback', 'attributeChangedCallback'];
+    api.patchCallbacks(api, document, 'Document', 'registerElement', callbacks);
+}
+
+/**
+ * @fileoverview
+ * @suppress {missingRequire}
+ */
+(function (_global) {
+    const symbolPrefix = _global['__Zone_symbol_prefix'] || '__zone_symbol__';
+    function __symbol__(name) {
+        return symbolPrefix + name;
+    }
+    _global[__symbol__('legacyPatch')] = function () {
+        const Zone = _global['Zone'];
+        Zone.__load_patch('defineProperty', (global, Zone, api) => {
+            api._redefineProperty = _redefineProperty;
+            propertyPatch();
+        });
+        Zone.__load_patch('registerElement', (global, Zone, api) => {
+            registerElementPatch(global, api);
+        });
+        Zone.__load_patch('EventTargetLegacy', (global, Zone, api) => {
+            eventTargetLegacyPatch(global, api);
+            propertyDescriptorLegacyPatch(api, global);
+        });
+    };
+})(typeof window !== 'undefined' ?
+    window :
+    typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {});

my-app/node_modules/zone.js/fesm2015/zone-patch-canvas.js

@@ -0,0 +1,15 @@
+'use strict';
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+Zone.__load_patch('canvas', (global, Zone, api) => {
+    const HTMLCanvasElement = global['HTMLCanvasElement'];
+    if (typeof HTMLCanvasElement !== 'undefined' && HTMLCanvasElement.prototype &&
+        HTMLCanvasElement.prototype.toBlob) {
+        api.patchMacroTask(HTMLCanvasElement.prototype, 'toBlob', (self, args) => {
+            return { name: 'HTMLCanvasElement.toBlob', target: self, cbIdx: 0, args: args };
+        });
+    }
+});

my-app/node_modules/zone.js/fesm2015/zone-patch-canvas.min.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */Zone.__load_patch("canvas",((t,o,a)=>{const e=t.HTMLCanvasElement;void 0!==e&&e.prototype&&e.prototype.toBlob&&a.patchMacroTask(e.prototype,"toBlob",((t,o)=>({name:"HTMLCanvasElement.toBlob",target:t,cbIdx:0,args:o})))}));

my-app/node_modules/zone.js/fesm2015/zone-patch-cordova.js

@@ -0,0 +1,38 @@
+'use strict';
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+Zone.__load_patch('cordova', (global, Zone, api) => {
+    if (global.cordova) {
+        const SUCCESS_SOURCE = 'cordova.exec.success';
+        const ERROR_SOURCE = 'cordova.exec.error';
+        const FUNCTION = 'function';
+        const nativeExec = api.patchMethod(global.cordova, 'exec', () => function (self, args) {
+            if (args.length > 0 && typeof args[0] === FUNCTION) {
+                args[0] = Zone.current.wrap(args[0], SUCCESS_SOURCE);
+            }
+            if (args.length > 1 && typeof args[1] === FUNCTION) {
+                args[1] = Zone.current.wrap(args[1], ERROR_SOURCE);
+            }
+            return nativeExec.apply(self, args);
+        });
+    }
+});
+Zone.__load_patch('cordova.FileReader', (global, Zone) => {
+    if (global.cordova && typeof global['FileReader'] !== 'undefined') {
+        document.addEventListener('deviceReady', () => {
+            const FileReader = global['FileReader'];
+            ['abort', 'error', 'load', 'loadstart', 'loadend', 'progress'].forEach(prop => {
+                const eventNameSymbol = Zone.__symbol__('ON_PROPERTY' + prop);
+                Object.defineProperty(FileReader.prototype, eventNameSymbol, {
+                    configurable: true,
+                    get: function () {
+                        return this._realReader && this._realReader[eventNameSymbol];
+                    }
+                });
+            });
+        });
+    }
+});

my-app/node_modules/zone.js/fesm2015/zone-patch-cordova.min.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */Zone.__load_patch("cordova",((e,o,r)=>{if(e.cordova){const t="cordova.exec.success",a="cordova.exec.error",c="function",d=r.patchMethod(e.cordova,"exec",(()=>function(e,r){return r.length>0&&typeof r[0]===c&&(r[0]=o.current.wrap(r[0],t)),r.length>1&&typeof r[1]===c&&(r[1]=o.current.wrap(r[1],a)),d.apply(e,r)}))}})),Zone.__load_patch("cordova.FileReader",((e,o)=>{e.cordova&&void 0!==e.FileReader&&document.addEventListener("deviceReady",(()=>{const r=e.FileReader;["abort","error","load","loadstart","loadend","progress"].forEach((e=>{const t=o.__symbol__("ON_PROPERTY"+e);Object.defineProperty(r.prototype,t,{configurable:!0,get:function(){return this._realReader&&this._realReader[t]}})}))}))}));

my-app/node_modules/zone.js/fesm2015/zone-patch-electron.js

@@ -0,0 +1,42 @@
+'use strict';
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+Zone.__load_patch('electron', (global, Zone, api) => {
+    function patchArguments(target, name, source) {
+        return api.patchMethod(target, name, (delegate) => (self, args) => {
+            return delegate && delegate.apply(self, api.bindArguments(args, source));
+        });
+    }
+    let { desktopCapturer, shell, CallbacksRegistry, ipcRenderer } = require('electron');
+    if (!CallbacksRegistry) {
+        try {
+            // Try to load CallbacksRegistry class from @electron/remote src
+            // since from electron 14+, the CallbacksRegistry is moved to @electron/remote
+            // package and not exported to outside, so this is a hack to patch CallbacksRegistry.
+            CallbacksRegistry =
+                require('@electron/remote/dist/src/renderer/callbacks-registry').CallbacksRegistry;
+        }
+        catch (err) {
+        }
+    }
+    // patch api in renderer process directly
+    // desktopCapturer
+    if (desktopCapturer) {
+        patchArguments(desktopCapturer, 'getSources', 'electron.desktopCapturer.getSources');
+    }
+    // shell
+    if (shell) {
+        patchArguments(shell, 'openExternal', 'electron.shell.openExternal');
+    }
+    // patch api in main process through CallbackRegistry
+    if (!CallbacksRegistry) {
+        if (ipcRenderer) {
+            patchArguments(ipcRenderer, 'on', 'ipcRenderer.on');
+        }
+        return;
+    }
+    patchArguments(CallbacksRegistry.prototype, 'add', 'CallbackRegistry.add');
+});

my-app/node_modules/zone.js/fesm2015/zone-patch-electron.min.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */Zone.__load_patch("electron",((e,r,t)=>{function l(e,r,l){return t.patchMethod(e,r,(e=>(r,c)=>e&&e.apply(r,t.bindArguments(c,l))))}let{desktopCapturer:c,shell:n,CallbacksRegistry:o,ipcRenderer:a}=require("electron");if(!o)try{o=require("@electron/remote/dist/src/renderer/callbacks-registry").CallbacksRegistry}catch(e){}c&&l(c,"getSources","electron.desktopCapturer.getSources"),n&&l(n,"openExternal","electron.shell.openExternal"),o?l(o.prototype,"add","CallbackRegistry.add"):a&&l(a,"on","ipcRenderer.on")}));

my-app/node_modules/zone.js/fesm2015/zone-patch-fetch.js

@@ -0,0 +1,76 @@
+'use strict';
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+/**
+ * @fileoverview
+ * @suppress {missingRequire}
+ */
+Zone.__load_patch('fetch', (global, Zone, api) => {
+    let fetch = global['fetch'];
+    if (typeof fetch !== 'function') {
+        return;
+    }
+    const originalFetch = global[api.symbol('fetch')];
+    if (originalFetch) {
+        // restore unpatched fetch first
+        fetch = originalFetch;
+    }
+    const ZoneAwarePromise = global.Promise;
+    const symbolThenPatched = api.symbol('thenPatched');
+    const fetchTaskScheduling = api.symbol('fetchTaskScheduling');
+    const placeholder = function () { };
+    global['fetch'] = function () {
+        const args = Array.prototype.slice.call(arguments);
+        const options = args.length > 1 ? args[1] : {};
+        const signal = options && options.signal;
+        const ac = new AbortController();
+        const fetchSignal = ac.signal;
+        options.signal = fetchSignal;
+        args[1] = options;
+        if (signal) {
+            const nativeAddEventListener = signal[Zone.__symbol__('addEventListener')] || signal.addEventListener;
+            nativeAddEventListener.call(signal, 'abort', function () {
+                ac.abort();
+            }, { once: true });
+        }
+        return new Promise((res, rej) => {
+            const task = Zone.current.scheduleMacroTask('fetch', placeholder, { fetchArgs: args }, () => {
+                let fetchPromise;
+                let zone = Zone.current;
+                try {
+                    zone[fetchTaskScheduling] = true;
+                    fetchPromise = fetch.apply(this, args);
+                }
+                catch (error) {
+                    rej(error);
+                    return;
+                }
+                finally {
+                    zone[fetchTaskScheduling] = false;
+                }
+                if (!(fetchPromise instanceof ZoneAwarePromise)) {
+                    let ctor = fetchPromise.constructor;
+                    if (!ctor[symbolThenPatched]) {
+                        api.patchThen(ctor);
+                    }
+                }
+                fetchPromise.then((resource) => {
+                    if (task.state !== 'notScheduled') {
+                        task.invoke();
+                    }
+                    res(resource);
+                }, (error) => {
+                    if (task.state !== 'notScheduled') {
+                        task.invoke();
+                    }
+                    rej(error);
+                });
+            }, () => {
+                ac.abort();
+            });
+        });
+    };
+});

my-app/node_modules/zone.js/fesm2015/zone-patch-fetch.min.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */Zone.__load_patch("fetch",((t,e,n)=>{let c=t.fetch;if("function"!=typeof c)return;const o=t[n.symbol("fetch")];o&&(c=o);const r=t.Promise,s=n.symbol("thenPatched"),l=n.symbol("fetchTaskScheduling"),a=function(){};t.fetch=function(){const t=Array.prototype.slice.call(arguments),o=t.length>1?t[1]:{},i=o&&o.signal,h=new AbortController;return o.signal=h.signal,t[1]=o,i&&(i[e.__symbol__("addEventListener")]||i.addEventListener).call(i,"abort",(function(){h.abort()}),{once:!0}),new Promise(((o,i)=>{const f=e.current.scheduleMacroTask("fetch",a,{fetchArgs:t},(()=>{let a,h=e.current;try{h[l]=!0,a=c.apply(this,t)}catch(t){return void i(t)}finally{h[l]=!1}if(!(a instanceof r)){let t=a.constructor;t[s]||n.patchThen(t)}a.then((t=>{"notScheduled"!==f.state&&f.invoke(),o(t)}),(t=>{"notScheduled"!==f.state&&f.invoke(),i(t)}))}),(()=>{h.abort()}))}))}}));

my-app/node_modules/zone.js/fesm2015/zone-patch-jsonp.js

@@ -0,0 +1,74 @@
+'use strict';
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+Zone.__load_patch('jsonp', (global, Zone, api) => {
+    // because jsonp is not a standard api, there are a lot of
+    // implementations, so zone.js just provide a helper util to
+    // patch the jsonp send and onSuccess/onError callback
+    // the options is an object which contains
+    // - jsonp, the jsonp object which hold the send function
+    // - sendFuncName, the name of the send function
+    // - successFuncName, success func name
+    // - failedFuncName, failed func name
+    Zone[Zone.__symbol__('jsonp')] = function patchJsonp(options) {
+        if (!options || !options.jsonp || !options.sendFuncName) {
+            return;
+        }
+        const noop = function () { };
+        [options.successFuncName, options.failedFuncName].forEach(methodName => {
+            if (!methodName) {
+                return;
+            }
+            const oriFunc = global[methodName];
+            if (oriFunc) {
+                api.patchMethod(global, methodName, (delegate) => (self, args) => {
+                    const task = global[api.symbol('jsonTask')];
+                    if (task) {
+                        task.callback = delegate;
+                        return task.invoke.apply(self, args);
+                    }
+                    else {
+                        return delegate.apply(self, args);
+                    }
+                });
+            }
+            else {
+                Object.defineProperty(global, methodName, {
+                    configurable: true,
+                    enumerable: true,
+                    get: function () {
+                        return function () {
+                            const task = global[api.symbol('jsonpTask')];
+                            const delegate = global[api.symbol(`jsonp${methodName}callback`)];
+                            if (task) {
+                                if (delegate) {
+                                    task.callback = delegate;
+                                }
+                                global[api.symbol('jsonpTask')] = undefined;
+                                return task.invoke.apply(this, arguments);
+                            }
+                            else {
+                                if (delegate) {
+                                    return delegate.apply(this, arguments);
+                                }
+                            }
+                            return null;
+                        };
+                    },
+                    set: function (callback) {
+                        this[api.symbol(`jsonp${methodName}callback`)] = callback;
+                    }
+                });
+            }
+        });
+        api.patchMethod(options.jsonp, options.sendFuncName, (delegate) => (self, args) => {
+            global[api.symbol('jsonpTask')] =
+                Zone.current.scheduleMacroTask('jsonp', noop, {}, (task) => {
+                    return delegate.apply(self, args);
+                }, noop);
+        });
+    };
+});

my-app/node_modules/zone.js/fesm2015/zone-patch-jsonp.min.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */Zone.__load_patch("jsonp",((n,s,o)=>{s[s.__symbol__("jsonp")]=function c(a){if(!a||!a.jsonp||!a.sendFuncName)return;const e=function(){};[a.successFuncName,a.failedFuncName].forEach((s=>{s&&(n[s]?o.patchMethod(n,s,(s=>(c,a)=>{const e=n[o.symbol("jsonTask")];return e?(e.callback=s,e.invoke.apply(c,a)):s.apply(c,a)})):Object.defineProperty(n,s,{configurable:!0,enumerable:!0,get:function(){return function(){const c=n[o.symbol("jsonpTask")],a=n[o.symbol(`jsonp${s}callback`)];return c?(a&&(c.callback=a),n[o.symbol("jsonpTask")]=void 0,c.invoke.apply(this,arguments)):a?a.apply(this,arguments):null}},set:function(n){this[o.symbol(`jsonp${s}callback`)]=n}}))})),o.patchMethod(a.jsonp,a.sendFuncName,(c=>(a,l)=>{n[o.symbol("jsonpTask")]=s.current.scheduleMacroTask("jsonp",e,{},(n=>c.apply(a,l)),e)}))}}));

my-app/node_modules/zone.js/fesm2015/zone-patch-message-port.js

@@ -0,0 +1,16 @@
+'use strict';
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+/**
+ * Monkey patch `MessagePort.prototype.onmessage` and `MessagePort.prototype.onmessageerror`
+ * properties to make the callback in the zone when the value are set.
+ */
+Zone.__load_patch('MessagePort', (global, Zone, api) => {
+    const MessagePort = global['MessagePort'];
+    if (typeof MessagePort !== 'undefined' && MessagePort.prototype) {
+        api.patchOnProperties(MessagePort.prototype, ['message', 'messageerror']);
+    }
+});

my-app/node_modules/zone.js/fesm2015/zone-patch-message-port.min.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */Zone.__load_patch("MessagePort",((e,o,s)=>{const t=e.MessagePort;void 0!==t&&t.prototype&&s.patchOnProperties(t.prototype,["message","messageerror"])}));

my-app/node_modules/zone.js/fesm2015/zone-patch-promise-test.js

@@ -0,0 +1,64 @@
+'use strict';
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+/**
+ * Promise for async/fakeAsync zoneSpec test
+ * can support async operation which not supported by zone.js
+ * such as
+ * it ('test jsonp in AsyncZone', async() => {
+ *   new Promise(res => {
+ *     jsonp(url, (data) => {
+ *       // success callback
+ *       res(data);
+ *     });
+ *   }).then((jsonpResult) => {
+ *     // get jsonp result.
+ *
+ *     // user will expect AsyncZoneSpec wait for
+ *     // then, but because jsonp is not zone aware
+ *     // AsyncZone will finish before then is called.
+ *   });
+ * });
+ */
+Zone.__load_patch('promisefortest', (global, Zone, api) => {
+    const symbolState = api.symbol('state');
+    const UNRESOLVED = null;
+    const symbolParentUnresolved = api.symbol('parentUnresolved');
+    // patch Promise.prototype.then to keep an internal
+    // number for tracking unresolved chained promise
+    // we will decrease this number when the parent promise
+    // being resolved/rejected and chained promise was
+    // scheduled as a microTask.
+    // so we can know such kind of chained promise still
+    // not resolved in AsyncTestZone
+    Promise[api.symbol('patchPromiseForTest')] = function patchPromiseForTest() {
+        let oriThen = Promise[Zone.__symbol__('ZonePromiseThen')];
+        if (oriThen) {
+            return;
+        }
+        oriThen = Promise[Zone.__symbol__('ZonePromiseThen')] = Promise.prototype.then;
+        Promise.prototype.then = function () {
+            const chained = oriThen.apply(this, arguments);
+            if (this[symbolState] === UNRESOLVED) {
+                // parent promise is unresolved.
+                const asyncTestZoneSpec = Zone.current.get('AsyncTestZoneSpec');
+                if (asyncTestZoneSpec) {
+                    asyncTestZoneSpec.unresolvedChainedPromiseCount++;
+                    chained[symbolParentUnresolved] = true;
+                }
+            }
+            return chained;
+        };
+    };
+    Promise[api.symbol('unPatchPromiseForTest')] = function unpatchPromiseForTest() {
+        // restore origin then
+        const oriThen = Promise[Zone.__symbol__('ZonePromiseThen')];
+        if (oriThen) {
+            Promise.prototype.then = oriThen;
+            Promise[Zone.__symbol__('ZonePromiseThen')] = undefined;
+        }
+    };
+});

my-app/node_modules/zone.js/fesm2015/zone-patch-promise-test.min.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */Zone.__load_patch("promisefortest",((o,e,s)=>{const t=s.symbol("state"),n=s.symbol("parentUnresolved");Promise[s.symbol("patchPromiseForTest")]=function o(){let s=Promise[e.__symbol__("ZonePromiseThen")];s||(s=Promise[e.__symbol__("ZonePromiseThen")]=Promise.prototype.then,Promise.prototype.then=function(){const o=s.apply(this,arguments);if(null===this[t]){const s=e.current.get("AsyncTestZoneSpec");s&&(s.unresolvedChainedPromiseCount++,o[n]=!0)}return o})},Promise[s.symbol("unPatchPromiseForTest")]=function o(){const s=Promise[e.__symbol__("ZonePromiseThen")];s&&(Promise.prototype.then=s,Promise[e.__symbol__("ZonePromiseThen")]=void 0)}}));

my-app/node_modules/zone.js/fesm2015/zone-patch-resize-observer.js

@@ -0,0 +1,83 @@
+'use strict';
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+Zone.__load_patch('ResizeObserver', (global, Zone, api) => {
+    const ResizeObserver = global['ResizeObserver'];
+    if (!ResizeObserver) {
+        return;
+    }
+    const resizeObserverSymbol = api.symbol('ResizeObserver');
+    api.patchMethod(global, 'ResizeObserver', (delegate) => (self, args) => {
+        const callback = args.length > 0 ? args[0] : null;
+        if (callback) {
+            args[0] = function (entries, observer) {
+                const zones = {};
+                const currZone = Zone.current;
+                for (let entry of entries) {
+                    let zone = entry.target[resizeObserverSymbol];
+                    if (!zone) {
+                        zone = currZone;
+                    }
+                    let zoneEntriesInfo = zones[zone.name];
+                    if (!zoneEntriesInfo) {
+                        zones[zone.name] = zoneEntriesInfo = { entries: [], zone: zone };
+                    }
+                    zoneEntriesInfo.entries.push(entry);
+                }
+                Object.keys(zones).forEach(zoneName => {
+                    const zoneEntriesInfo = zones[zoneName];
+                    if (zoneEntriesInfo.zone !== Zone.current) {
+                        zoneEntriesInfo.zone.run(callback, this, [zoneEntriesInfo.entries, observer], 'ResizeObserver');
+                    }
+                    else {
+                        callback.call(this, zoneEntriesInfo.entries, observer);
+                    }
+                });
+            };
+        }
+        return args.length > 0 ? new ResizeObserver(args[0]) : new ResizeObserver();
+    });
+    api.patchMethod(ResizeObserver.prototype, 'observe', (delegate) => (self, args) => {
+        const target = args.length > 0 ? args[0] : null;
+        if (!target) {
+            return delegate.apply(self, args);
+        }
+        let targets = self[resizeObserverSymbol];
+        if (!targets) {
+            targets = self[resizeObserverSymbol] = [];
+        }
+        targets.push(target);
+        target[resizeObserverSymbol] = Zone.current;
+        return delegate.apply(self, args);
+    });
+    api.patchMethod(ResizeObserver.prototype, 'unobserve', (delegate) => (self, args) => {
+        const target = args.length > 0 ? args[0] : null;
+        if (!target) {
+            return delegate.apply(self, args);
+        }
+        let targets = self[resizeObserverSymbol];
+        if (targets) {
+            for (let i = 0; i < targets.length; i++) {
+                if (targets[i] === target) {
+                    targets.splice(i, 1);
+                    break;
+                }
+            }
+        }
+        target[resizeObserverSymbol] = undefined;
+        return delegate.apply(self, args);
+    });
+    api.patchMethod(ResizeObserver.prototype, 'disconnect', (delegate) => (self, args) => {
+        const targets = self[resizeObserverSymbol];
+        if (targets) {
+            targets.forEach((target) => {
+                target[resizeObserverSymbol] = undefined;
+            });
+            self[resizeObserverSymbol] = undefined;
+        }
+        return delegate.apply(self, args);
+    });
+});

my-app/node_modules/zone.js/fesm2015/zone-patch-resize-observer.min.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */Zone.__load_patch("ResizeObserver",((e,t,r)=>{const n=e.ResizeObserver;if(!n)return;const o=r.symbol("ResizeObserver");r.patchMethod(e,"ResizeObserver",(e=>(e,r)=>{const s=r.length>0?r[0]:null;return s&&(r[0]=function(e,r){const n={},l=t.current;for(let t of e){let e=t.target[o];e||(e=l);let r=n[e.name];r||(n[e.name]=r={entries:[],zone:e}),r.entries.push(t)}Object.keys(n).forEach((e=>{const o=n[e];o.zone!==t.current?o.zone.run(s,this,[o.entries,r],"ResizeObserver"):s.call(this,o.entries,r)}))}),r.length>0?new n(r[0]):new n})),r.patchMethod(n.prototype,"observe",(e=>(r,n)=>{const s=n.length>0?n[0]:null;if(!s)return e.apply(r,n);let l=r[o];return l||(l=r[o]=[]),l.push(s),s[o]=t.current,e.apply(r,n)})),r.patchMethod(n.prototype,"unobserve",(e=>(t,r)=>{const n=r.length>0?r[0]:null;if(!n)return e.apply(t,r);let s=t[o];if(s)for(let e=0;e<s.length;e++)if(s[e]===n){s.splice(e,1);break}return n[o]=void 0,e.apply(t,r)})),r.patchMethod(n.prototype,"disconnect",(e=>(t,r)=>{const n=t[o];return n&&(n.forEach((e=>{e[o]=void 0})),t[o]=void 0),e.apply(t,r)}))}));

my-app/node_modules/zone.js/fesm2015/zone-patch-rxjs-fake-async.js

@@ -0,0 +1,170 @@
+'use strict';
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+class ProxyZoneSpec {
+    static get() {
+        return Zone.current.get('ProxyZoneSpec');
+    }
+    static isLoaded() {
+        return ProxyZoneSpec.get() instanceof ProxyZoneSpec;
+    }
+    static assertPresent() {
+        if (!ProxyZoneSpec.isLoaded()) {
+            throw new Error(`Expected to be running in 'ProxyZone', but it was not found.`);
+        }
+        return ProxyZoneSpec.get();
+    }
+    constructor(defaultSpecDelegate = null) {
+        this.defaultSpecDelegate = defaultSpecDelegate;
+        this.name = 'ProxyZone';
+        this._delegateSpec = null;
+        this.properties = { 'ProxyZoneSpec': this };
+        this.propertyKeys = null;
+        this.lastTaskState = null;
+        this.isNeedToTriggerHasTask = false;
+        this.tasks = [];
+        this.setDelegate(defaultSpecDelegate);
+    }
+    setDelegate(delegateSpec) {
+        const isNewDelegate = this._delegateSpec !== delegateSpec;
+        this._delegateSpec = delegateSpec;
+        this.propertyKeys && this.propertyKeys.forEach((key) => delete this.properties[key]);
+        this.propertyKeys = null;
+        if (delegateSpec && delegateSpec.properties) {
+            this.propertyKeys = Object.keys(delegateSpec.properties);
+            this.propertyKeys.forEach((k) => this.properties[k] = delegateSpec.properties[k]);
+        }
+        // if a new delegateSpec was set, check if we need to trigger hasTask
+        if (isNewDelegate && this.lastTaskState &&
+            (this.lastTaskState.macroTask || this.lastTaskState.microTask)) {
+            this.isNeedToTriggerHasTask = true;
+        }
+    }
+    getDelegate() {
+        return this._delegateSpec;
+    }
+    resetDelegate() {
+        this.getDelegate();
+        this.setDelegate(this.defaultSpecDelegate);
+    }
+    tryTriggerHasTask(parentZoneDelegate, currentZone, targetZone) {
+        if (this.isNeedToTriggerHasTask && this.lastTaskState) {
+            // last delegateSpec has microTask or macroTask
+            // should call onHasTask in current delegateSpec
+            this.isNeedToTriggerHasTask = false;
+            this.onHasTask(parentZoneDelegate, currentZone, targetZone, this.lastTaskState);
+        }
+    }
+    removeFromTasks(task) {
+        if (!this.tasks) {
+            return;
+        }
+        for (let i = 0; i < this.tasks.length; i++) {
+            if (this.tasks[i] === task) {
+                this.tasks.splice(i, 1);
+                return;
+            }
+        }
+    }
+    getAndClearPendingTasksInfo() {
+        if (this.tasks.length === 0) {
+            return '';
+        }
+        const taskInfo = this.tasks.map((task) => {
+            const dataInfo = task.data &&
+                Object.keys(task.data)
+                    .map((key) => {
+                    return key + ':' + task.data[key];
+                })
+                    .join(',');
+            return `type: ${task.type}, source: ${task.source}, args: {${dataInfo}}`;
+        });
+        const pendingTasksInfo = '--Pending async tasks are: [' + taskInfo + ']';
+        // clear tasks
+        this.tasks = [];
+        return pendingTasksInfo;
+    }
+    onFork(parentZoneDelegate, currentZone, targetZone, zoneSpec) {
+        if (this._delegateSpec && this._delegateSpec.onFork) {
+            return this._delegateSpec.onFork(parentZoneDelegate, currentZone, targetZone, zoneSpec);
+        }
+        else {
+            return parentZoneDelegate.fork(targetZone, zoneSpec);
+        }
+    }
+    onIntercept(parentZoneDelegate, currentZone, targetZone, delegate, source) {
+        if (this._delegateSpec && this._delegateSpec.onIntercept) {
+            return this._delegateSpec.onIntercept(parentZoneDelegate, currentZone, targetZone, delegate, source);
+        }
+        else {
+            return parentZoneDelegate.intercept(targetZone, delegate, source);
+        }
+    }
+    onInvoke(parentZoneDelegate, currentZone, targetZone, delegate, applyThis, applyArgs, source) {
+        this.tryTriggerHasTask(parentZoneDelegate, currentZone, targetZone);
+        if (this._delegateSpec && this._delegateSpec.onInvoke) {
+            return this._delegateSpec.onInvoke(parentZoneDelegate, currentZone, targetZone, delegate, applyThis, applyArgs, source);
+        }
+        else {
+            return parentZoneDelegate.invoke(targetZone, delegate, applyThis, applyArgs, source);
+        }
+    }
+    onHandleError(parentZoneDelegate, currentZone, targetZone, error) {
+        if (this._delegateSpec && this._delegateSpec.onHandleError) {
+            return this._delegateSpec.onHandleError(parentZoneDelegate, currentZone, targetZone, error);
+        }
+        else {
+            return parentZoneDelegate.handleError(targetZone, error);
+        }
+    }
+    onScheduleTask(parentZoneDelegate, currentZone, targetZone, task) {
+        if (task.type !== 'eventTask') {
+            this.tasks.push(task);
+        }
+        if (this._delegateSpec && this._delegateSpec.onScheduleTask) {
+            return this._delegateSpec.onScheduleTask(parentZoneDelegate, currentZone, targetZone, task);
+        }
+        else {
+            return parentZoneDelegate.scheduleTask(targetZone, task);
+        }
+    }
+    onInvokeTask(parentZoneDelegate, currentZone, targetZone, task, applyThis, applyArgs) {
+        if (task.type !== 'eventTask') {
+            this.removeFromTasks(task);
+        }
+        this.tryTriggerHasTask(parentZoneDelegate, currentZone, targetZone);
+        if (this._delegateSpec && this._delegateSpec.onInvokeTask) {
+            return this._delegateSpec.onInvokeTask(parentZoneDelegate, currentZone, targetZone, task, applyThis, applyArgs);
+        }
+        else {
+            return parentZoneDelegate.invokeTask(targetZone, task, applyThis, applyArgs);
+        }
+    }
+    onCancelTask(parentZoneDelegate, currentZone, targetZone, task) {
+        if (task.type !== 'eventTask') {
+            this.removeFromTasks(task);
+        }
+        this.tryTriggerHasTask(parentZoneDelegate, currentZone, targetZone);
+        if (this._delegateSpec && this._delegateSpec.onCancelTask) {
+            return this._delegateSpec.onCancelTask(parentZoneDelegate, currentZone, targetZone, task);
+        }
+        else {
+            return parentZoneDelegate.cancelTask(targetZone, task);
+        }
+    }
+    onHasTask(delegate, current, target, hasTaskState) {
+        this.lastTaskState = hasTaskState;
+        if (this._delegateSpec && this._delegateSpec.onHasTask) {
+            this._delegateSpec.onHasTask(delegate, current, target, hasTaskState);
+        }
+        else {
+            delegate.hasTask(target, hasTaskState);
+        }
+    }
+}
+// Export the class so that new instances can be created with proper
+// constructor params.
+Zone['ProxyZoneSpec'] = ProxyZoneSpec;

my-app/node_modules/zone.js/fesm2015/zone-patch-rxjs-fake-async.min.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */class ProxyZoneSpec{static get(){return Zone.current.get("ProxyZoneSpec")}static isLoaded(){return ProxyZoneSpec.get()instanceof ProxyZoneSpec}static assertPresent(){if(!ProxyZoneSpec.isLoaded())throw new Error("Expected to be running in 'ProxyZone', but it was not found.");return ProxyZoneSpec.get()}constructor(e=null){this.defaultSpecDelegate=e,this.name="ProxyZone",this._delegateSpec=null,this.properties={ProxyZoneSpec:this},this.propertyKeys=null,this.lastTaskState=null,this.isNeedToTriggerHasTask=!1,this.tasks=[],this.setDelegate(e)}setDelegate(e){const t=this._delegateSpec!==e;this._delegateSpec=e,this.propertyKeys&&this.propertyKeys.forEach((e=>delete this.properties[e])),this.propertyKeys=null,e&&e.properties&&(this.propertyKeys=Object.keys(e.properties),this.propertyKeys.forEach((t=>this.properties[t]=e.properties[t]))),t&&this.lastTaskState&&(this.lastTaskState.macroTask||this.lastTaskState.microTask)&&(this.isNeedToTriggerHasTask=!0)}getDelegate(){return this._delegateSpec}resetDelegate(){this.getDelegate(),this.setDelegate(this.defaultSpecDelegate)}tryTriggerHasTask(e,t,s){this.isNeedToTriggerHasTask&&this.lastTaskState&&(this.isNeedToTriggerHasTask=!1,this.onHasTask(e,t,s,this.lastTaskState))}removeFromTasks(e){if(this.tasks)for(let t=0;t<this.tasks.length;t++)if(this.tasks[t]===e)return void this.tasks.splice(t,1)}getAndClearPendingTasksInfo(){if(0===this.tasks.length)return"";const e="--Pending async tasks are: ["+this.tasks.map((e=>{const t=e.data&&Object.keys(e.data).map((t=>t+":"+e.data[t])).join(",");return`type: ${e.type}, source: ${e.source}, args: {${t}}`}))+"]";return this.tasks=[],e}onFork(e,t,s,a){return this._delegateSpec&&this._delegateSpec.onFork?this._delegateSpec.onFork(e,t,s,a):e.fork(s,a)}onIntercept(e,t,s,a,r){return this._delegateSpec&&this._delegateSpec.onIntercept?this._delegateSpec.onIntercept(e,t,s,a,r):e.intercept(s,a,r)}onInvoke(e,t,s,a,r,i,o){return this.tryTriggerHasTask(e,t,s),this._delegateSpec&&this._delegateSpec.onInvoke?this._delegateSpec.onInvoke(e,t,s,a,r,i,o):e.invoke(s,a,r,i,o)}onHandleError(e,t,s,a){return this._delegateSpec&&this._delegateSpec.onHandleError?this._delegateSpec.onHandleError(e,t,s,a):e.handleError(s,a)}onScheduleTask(e,t,s,a){return"eventTask"!==a.type&&this.tasks.push(a),this._delegateSpec&&this._delegateSpec.onScheduleTask?this._delegateSpec.onScheduleTask(e,t,s,a):e.scheduleTask(s,a)}onInvokeTask(e,t,s,a,r,i){return"eventTask"!==a.type&&this.removeFromTasks(a),this.tryTriggerHasTask(e,t,s),this._delegateSpec&&this._delegateSpec.onInvokeTask?this._delegateSpec.onInvokeTask(e,t,s,a,r,i):e.invokeTask(s,a,r,i)}onCancelTask(e,t,s,a){return"eventTask"!==a.type&&this.removeFromTasks(a),this.tryTriggerHasTask(e,t,s),this._delegateSpec&&this._delegateSpec.onCancelTask?this._delegateSpec.onCancelTask(e,t,s,a):e.cancelTask(s,a)}onHasTask(e,t,s,a){this.lastTaskState=a,this._delegateSpec&&this._delegateSpec.onHasTask?this._delegateSpec.onHasTask(e,t,s,a):e.hasTask(s,a)}}Zone.ProxyZoneSpec=ProxyZoneSpec;

my-app/node_modules/zone.js/fesm2015/zone-patch-rxjs.js

@@ -0,0 +1,196 @@
+'use strict';
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+import { Observable, Subscription, Subscriber } from 'rxjs';
+
+Zone.__load_patch('rxjs', (global, Zone, api) => {
+    const symbol = Zone.__symbol__;
+    const nextSource = 'rxjs.Subscriber.next';
+    const errorSource = 'rxjs.Subscriber.error';
+    const completeSource = 'rxjs.Subscriber.complete';
+    const ObjectDefineProperties = Object.defineProperties;
+    const patchObservable = function () {
+        const ObservablePrototype = Observable.prototype;
+        const _symbolSubscribe = symbol('_subscribe');
+        const _subscribe = ObservablePrototype[_symbolSubscribe] = ObservablePrototype._subscribe;
+        ObjectDefineProperties(Observable.prototype, {
+            _zone: { value: null, writable: true, configurable: true },
+            _zoneSource: { value: null, writable: true, configurable: true },
+            _zoneSubscribe: { value: null, writable: true, configurable: true },
+            source: {
+                configurable: true,
+                get: function () {
+                    return this._zoneSource;
+                },
+                set: function (source) {
+                    this._zone = Zone.current;
+                    this._zoneSource = source;
+                }
+            },
+            _subscribe: {
+                configurable: true,
+                get: function () {
+                    if (this._zoneSubscribe) {
+                        return this._zoneSubscribe;
+                    }
+                    else if (this.constructor === Observable) {
+                        return _subscribe;
+                    }
+                    const proto = Object.getPrototypeOf(this);
+                    return proto && proto._subscribe;
+                },
+                set: function (subscribe) {
+                    this._zone = Zone.current;
+                    if (!subscribe) {
+                        this._zoneSubscribe = subscribe;
+                    }
+                    else {
+                        this._zoneSubscribe = function () {
+                            if (this._zone && this._zone !== Zone.current) {
+                                const tearDown = this._zone.run(subscribe, this, arguments);
+                                if (typeof tearDown === 'function') {
+                                    const zone = this._zone;
+                                    return function () {
+                                        if (zone !== Zone.current) {
+                                            return zone.run(tearDown, this, arguments);
+                                        }
+                                        return tearDown.apply(this, arguments);
+                                    };
+                                }
+                                else {
+                                    return tearDown;
+                                }
+                            }
+                            else {
+                                return subscribe.apply(this, arguments);
+                            }
+                        };
+                    }
+                }
+            },
+            subjectFactory: {
+                get: function () {
+                    return this._zoneSubjectFactory;
+                },
+                set: function (factory) {
+                    const zone = this._zone;
+                    this._zoneSubjectFactory = function () {
+                        if (zone && zone !== Zone.current) {
+                            return zone.run(factory, this, arguments);
+                        }
+                        return factory.apply(this, arguments);
+                    };
+                }
+            }
+        });
+    };
+    api.patchMethod(Observable.prototype, 'lift', (delegate) => (self, args) => {
+        const observable = delegate.apply(self, args);
+        if (observable.operator) {
+            observable.operator._zone = Zone.current;
+            api.patchMethod(observable.operator, 'call', (operatorDelegate) => (operatorSelf, operatorArgs) => {
+                if (operatorSelf._zone && operatorSelf._zone !== Zone.current) {
+                    return operatorSelf._zone.run(operatorDelegate, operatorSelf, operatorArgs);
+                }
+                return operatorDelegate.apply(operatorSelf, operatorArgs);
+            });
+        }
+        return observable;
+    });
+    const patchSubscription = function () {
+        ObjectDefineProperties(Subscription.prototype, {
+            _zone: { value: null, writable: true, configurable: true },
+            _zoneUnsubscribe: { value: null, writable: true, configurable: true },
+            _unsubscribe: {
+                get: function () {
+                    if (this._zoneUnsubscribe || this._zoneUnsubscribeCleared) {
+                        return this._zoneUnsubscribe;
+                    }
+                    const proto = Object.getPrototypeOf(this);
+                    return proto && proto._unsubscribe;
+                },
+                set: function (unsubscribe) {
+                    this._zone = Zone.current;
+                    if (!unsubscribe) {
+                        this._zoneUnsubscribe = unsubscribe;
+                        // In some operator such as `retryWhen`, the _unsubscribe
+                        // method will be set to null, so we need to set another flag
+                        // to tell that we should return null instead of finding
+                        // in the prototype chain.
+                        this._zoneUnsubscribeCleared = true;
+                    }
+                    else {
+                        this._zoneUnsubscribeCleared = false;
+                        this._zoneUnsubscribe = function () {
+                            if (this._zone && this._zone !== Zone.current) {
+                                return this._zone.run(unsubscribe, this, arguments);
+                            }
+                            else {
+                                return unsubscribe.apply(this, arguments);
+                            }
+                        };
+                    }
+                }
+            }
+        });
+    };
+    const patchSubscriber = function () {
+        const next = Subscriber.prototype.next;
+        const error = Subscriber.prototype.error;
+        const complete = Subscriber.prototype.complete;
+        Object.defineProperty(Subscriber.prototype, 'destination', {
+            configurable: true,
+            get: function () {
+                return this._zoneDestination;
+            },
+            set: function (destination) {
+                this._zone = Zone.current;
+                this._zoneDestination = destination;
+            }
+        });
+        // patch Subscriber.next to make sure it run
+        // into SubscriptionZone
+        Subscriber.prototype.next = function () {
+            const currentZone = Zone.current;
+            const subscriptionZone = this._zone;
+            // for performance concern, check Zone.current
+            // equal with this._zone(SubscriptionZone) or not
+            if (subscriptionZone && subscriptionZone !== currentZone) {
+                return subscriptionZone.run(next, this, arguments, nextSource);
+            }
+            else {
+                return next.apply(this, arguments);
+            }
+        };
+        Subscriber.prototype.error = function () {
+            const currentZone = Zone.current;
+            const subscriptionZone = this._zone;
+            // for performance concern, check Zone.current
+            // equal with this._zone(SubscriptionZone) or not
+            if (subscriptionZone && subscriptionZone !== currentZone) {
+                return subscriptionZone.run(error, this, arguments, errorSource);
+            }
+            else {
+                return error.apply(this, arguments);
+            }
+        };
+        Subscriber.prototype.complete = function () {
+            const currentZone = Zone.current;
+            const subscriptionZone = this._zone;
+            // for performance concern, check Zone.current
+            // equal with this._zone(SubscriptionZone) or not
+            if (subscriptionZone && subscriptionZone !== currentZone) {
+                return subscriptionZone.run(complete, this, arguments, completeSource);
+            }
+            else {
+                return complete.call(this);
+            }
+        };
+    };
+    patchObservable();
+    patchSubscription();
+    patchSubscriber();
+});

my-app/node_modules/zone.js/fesm2015/zone-patch-rxjs.min.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */import{Observable,Subscription,Subscriber}from"rxjs";Zone.__load_patch("rxjs",((e,t,r)=>{const n=t.__symbol__,o=Object.defineProperties;r.patchMethod(Observable.prototype,"lift",(e=>(n,o)=>{const i=e.apply(n,o);return i.operator&&(i.operator._zone=t.current,r.patchMethod(i.operator,"call",(e=>(r,n)=>r._zone&&r._zone!==t.current?r._zone.run(e,r,n):e.apply(r,n)))),i})),function(){const e=Observable.prototype,r=e[n("_subscribe")]=e._subscribe;o(Observable.prototype,{_zone:{value:null,writable:!0,configurable:!0},_zoneSource:{value:null,writable:!0,configurable:!0},_zoneSubscribe:{value:null,writable:!0,configurable:!0},source:{configurable:!0,get:function(){return this._zoneSource},set:function(e){this._zone=t.current,this._zoneSource=e}},_subscribe:{configurable:!0,get:function(){if(this._zoneSubscribe)return this._zoneSubscribe;if(this.constructor===Observable)return r;const e=Object.getPrototypeOf(this);return e&&e._subscribe},set:function(e){this._zone=t.current,this._zoneSubscribe=e?function(){if(this._zone&&this._zone!==t.current){const r=this._zone.run(e,this,arguments);if("function"==typeof r){const e=this._zone;return function(){return e!==t.current?e.run(r,this,arguments):r.apply(this,arguments)}}return r}return e.apply(this,arguments)}:e}},subjectFactory:{get:function(){return this._zoneSubjectFactory},set:function(e){const r=this._zone;this._zoneSubjectFactory=function(){return r&&r!==t.current?r.run(e,this,arguments):e.apply(this,arguments)}}}})}(),o(Subscription.prototype,{_zone:{value:null,writable:!0,configurable:!0},_zoneUnsubscribe:{value:null,writable:!0,configurable:!0},_unsubscribe:{get:function(){if(this._zoneUnsubscribe||this._zoneUnsubscribeCleared)return this._zoneUnsubscribe;const e=Object.getPrototypeOf(this);return e&&e._unsubscribe},set:function(e){this._zone=t.current,e?(this._zoneUnsubscribeCleared=!1,this._zoneUnsubscribe=function(){return this._zone&&this._zone!==t.current?this._zone.run(e,this,arguments):e.apply(this,arguments)}):(this._zoneUnsubscribe=e,this._zoneUnsubscribeCleared=!0)}}}),function(){const e=Subscriber.prototype.next,r=Subscriber.prototype.error,n=Subscriber.prototype.complete;Object.defineProperty(Subscriber.prototype,"destination",{configurable:!0,get:function(){return this._zoneDestination},set:function(e){this._zone=t.current,this._zoneDestination=e}}),Subscriber.prototype.next=function(){const r=this._zone;return r&&r!==t.current?r.run(e,this,arguments,"rxjs.Subscriber.next"):e.apply(this,arguments)},Subscriber.prototype.error=function(){const e=this._zone;return e&&e!==t.current?e.run(r,this,arguments,"rxjs.Subscriber.error"):r.apply(this,arguments)},Subscriber.prototype.complete=function(){const e=this._zone;return e&&e!==t.current?e.run(n,this,arguments,"rxjs.Subscriber.complete"):n.call(this)}}()}));

my-app/node_modules/zone.js/fesm2015/zone-patch-socket-io.js

@@ -0,0 +1,23 @@
+'use strict';
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+Zone.__load_patch('socketio', (global, Zone, api) => {
+    Zone[Zone.__symbol__('socketio')] = function patchSocketIO(io) {
+        // patch io.Socket.prototype event listener related method
+        api.patchEventTarget(global, api, [io.Socket.prototype], {
+            useG: false,
+            chkDup: false,
+            rt: true,
+            diff: (task, delegate) => {
+                return task.callback === delegate;
+            }
+        });
+        // also patch io.Socket.prototype.on/off/removeListener/removeAllListeners
+        io.Socket.prototype.on = io.Socket.prototype.addEventListener;
+        io.Socket.prototype.off = io.Socket.prototype.removeListener =
+            io.Socket.prototype.removeAllListeners = io.Socket.prototype.removeEventListener;
+    };
+});

my-app/node_modules/zone.js/fesm2015/zone-patch-socket-io.min.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */Zone.__load_patch("socketio",((e,t,o)=>{t[t.__symbol__("socketio")]=function t(p){o.patchEventTarget(e,o,[p.Socket.prototype],{useG:!1,chkDup:!1,rt:!0,diff:(e,t)=>e.callback===t}),p.Socket.prototype.on=p.Socket.prototype.addEventListener,p.Socket.prototype.off=p.Socket.prototype.removeListener=p.Socket.prototype.removeAllListeners=p.Socket.prototype.removeEventListener}}));

my-app/node_modules/zone.js/fesm2015/zone-patch-user-media.js

@@ -0,0 +1,19 @@
+'use strict';
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */
+Zone.__load_patch('getUserMedia', (global, Zone, api) => {
+    function wrapFunctionArgs(func, source) {
+        return function () {
+            const args = Array.prototype.slice.call(arguments);
+            const wrappedArgs = api.bindArguments(args, source ? source : func.name);
+            return func.apply(this, wrappedArgs);
+        };
+    }
+    let navigator = global['navigator'];
+    if (navigator && navigator.getUserMedia) {
+        navigator.getUserMedia = wrapFunctionArgs(navigator.getUserMedia);
+    }
+});

my-app/node_modules/zone.js/fesm2015/zone-patch-user-media.min.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @license Angular v<unknown>
+ * (c) 2010-2022 Google LLC. https://angular.io/
+ * License: MIT
+ */Zone.__load_patch("getUserMedia",((e,t,r)=>{let a=e.navigator;a&&a.getUserMedia&&(a.getUserMedia=function n(e,t){return function(){const a=Array.prototype.slice.call(arguments),n=r.bindArguments(a,t||e.name);return e.apply(this,n)}}(a.getUserMedia))}));