https://www.vpb.de/typo3conf/ext/vpb_navigator/Resources/Public/JavaScript/Navigator/main.js?1765872253

1var __defProp = Object.defineProperty;
2var __defProps = Object.defineProperties;
3var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
4var __getOwnPropNames = Object.getOwnPropertyNames;
5var __getOwnPropSymbols = Object.getOwnPropertySymbols;
6var __hasOwnProp = Object.prototype.hasOwnProperty;
7var __propIsEnum = Object.prototype.propertyIsEnumerable;
8var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
9var __spreadValues = (a, b) => {
10  for (var prop in b ||= {})
11    if (__hasOwnProp.call(b, prop))
12      __defNormalProp(a, prop, b[prop]);
13  if (__getOwnPropSymbols)
14    for (var prop of __getOwnPropSymbols(b)) {
15      if (__propIsEnum.call(b, prop))
16        __defNormalProp(a, prop, b[prop]);
17    }
18  return a;
19};
20var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
21var __esm = (fn, res) => function __init() {
22  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
23};
24var __commonJS = (cb, mod) => function __require() {
25  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
26};
27var __async = (__this, __arguments, generator) => {
28  return new Promise((resolve, reject) => {
29    var fulfilled = (value) => {
30      try {
31        step(generator.next(value));
32      } catch (e) {
33        reject(e);
34      }
35    };
36    var rejected = (value) => {
37      try {
38        step(generator.throw(value));
39      } catch (e) {
40        reject(e);
41      }
42    };
43    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
44    step((generator = generator.apply(__this, __arguments)).next());
45  });
46};
47

48// node_modules/@angular/core/fesm2022/not_found.mjs
49function getCurrentInjector() {
50  return _currentInjector;
51}
52function setCurrentInjector(injector) {
53  const former = _currentInjector;
54  _currentInjector = injector;
55  return former;
56}
57function isNotFound(e) {
58  return e === NOT_FOUND || e?.name === "\u0275NotFound";
59}
60var _currentInjector, NOT_FOUND;
61var init_not_found = __esm({
62  "node_modules/@angular/core/fesm2022/not_found.mjs"() {
63    "use strict";
64    _currentInjector = void 0;
65    NOT_FOUND = Symbol("NotFound");
66  }
67});
68

69// node_modules/@angular/core/fesm2022/signal.mjs
70function setActiveConsumer(consumer) {
71  const prev = activeConsumer;
72  activeConsumer = consumer;
73  return prev;
74}
75function getActiveConsumer() {
76  return activeConsumer;
77}
78function isInNotificationPhase() {
79  return inNotificationPhase;
80}
81function producerAccessed(node) {
82  if (inNotificationPhase) {
83    throw new Error(typeof ngDevMode !== "undefined" && ngDevMode ? `Assertion error: signal read during notification phase` : "");
84  }
85  if (activeConsumer === null) {
86    return;
87  }
88  activeConsumer.consumerOnSignalRead(node);
89  const prevProducerLink = activeConsumer.producersTail;
90  if (prevProducerLink !== void 0 && prevProducerLink.producer === node) {
91    return;
92  }
93  let nextProducerLink = void 0;
94  const isRecomputing = activeConsumer.recomputing;
95  if (isRecomputing) {
96    nextProducerLink = prevProducerLink !== void 0 ? prevProducerLink.nextProducer : activeConsumer.producers;
97    if (nextProducerLink !== void 0 && nextProducerLink.producer === node) {
98      activeConsumer.producersTail = nextProducerLink;
99      nextProducerLink.lastReadVersion = node.version;
100      return;
101    }
102  }
103  const prevConsumerLink = node.consumersTail;
104  if (prevConsumerLink !== void 0 && prevConsumerLink.consumer === activeConsumer && // However, we have to make sure that the link we've discovered isn't from a node that is incrementally rebuilding its producer list
105  (!isRecomputing || isValidLink(prevConsumerLink, activeConsumer))) {
106    return;
107  }
108  const isLive = consumerIsLive(activeConsumer);
109  const newLink = {
110    producer: node,
111    consumer: activeConsumer,
112    // instead of eagerly destroying the previous link, we delay until we've finished recomputing
113    // the producers list, so that we can destroy all of the old links at once.
114    nextProducer: nextProducerLink,
115    prevConsumer: prevConsumerLink,
116    lastReadVersion: node.version,
117    nextConsumer: void 0
118  };
119  activeConsumer.producersTail = newLink;
120  if (prevProducerLink !== void 0) {
121    prevProducerLink.nextProducer = newLink;
122  } else {
123    activeConsumer.producers = newLink;
124  }
125  if (isLive) {
126    producerAddLiveConsumer(node, newLink);
127  }
128}
129function producerIncrementEpoch() {
130  epoch++;
131}
132function producerUpdateValueVersion(node) {
133  if (consumerIsLive(node) && !node.dirty) {
134    return;
135  }
136  if (!node.dirty && node.lastCleanEpoch === epoch) {
137    return;
138  }
139  if (!node.producerMustRecompute(node) && !consumerPollProducersForChange(node)) {
140    producerMarkClean(node);
141    return;
142  }
143  node.producerRecomputeValue(node);
144  producerMarkClean(node);
145}
146function producerNotifyConsumers(node) {
147  if (node.consumers === void 0) {
148    return;
149  }
150  const prev = inNotificationPhase;
151  inNotificationPhase = true;
152  try {
153    for (let link = node.consumers; link !== void 0; link = link.nextConsumer) {
154      const consumer = link.consumer;
155      if (!consumer.dirty) {
156        consumerMarkDirty(consumer);
157      }
158    }
159  } finally {
160    inNotificationPhase = prev;
161  }
162}
163function producerUpdatesAllowed() {
164  return activeConsumer?.consumerAllowSignalWrites !== false;
165}
166function consumerMarkDirty(node) {
167  node.dirty = true;
168  producerNotifyConsumers(node);
169  node.consumerMarkedDirty?.(node);
170}
171function producerMarkClean(node) {
172  node.dirty = false;
173  node.lastCleanEpoch = epoch;
174}
175function consumerBeforeComputation(node) {
176  if (node)
177    resetConsumerBeforeComputation(node);
178  return setActiveConsumer(node);
179}
180function resetConsumerBeforeComputation(node) {
181  node.producersTail = void 0;
182  node.recomputing = true;
183}
184function consumerAfterComputation(node, prevConsumer) {
185  setActiveConsumer(prevConsumer);
186  if (node)
187    finalizeConsumerAfterComputation(node);
188}
189function finalizeConsumerAfterComputation(node) {
190  node.recomputing = false;
191  const producersTail = node.producersTail;
192  let toRemove = producersTail !== void 0 ? producersTail.nextProducer : node.producers;
193  if (toRemove !== void 0) {
194    if (consumerIsLive(node)) {
195      do {
196        toRemove = producerRemoveLiveConsumerLink(toRemove);
197      } while (toRemove !== void 0);
198    }
199    if (producersTail !== void 0) {
200      producersTail.nextProducer = void 0;
201    } else {
202      node.producers = void 0;
203    }
204  }
205}
206function consumerPollProducersForChange(node) {
207  for (let link = node.producers; link !== void 0; link = link.nextProducer) {
208    const producer = link.producer;
209    const seenVersion = link.lastReadVersion;
210    if (seenVersion !== producer.version) {
211      return true;
212    }
213    producerUpdateValueVersion(producer);
214    if (seenVersion !== producer.version) {
215      return true;
216    }
217  }
218  return false;
219}
220function consumerDestroy(node) {
221  if (consumerIsLive(node)) {
222    let link = node.producers;
223    while (link !== void 0) {
224      link = producerRemoveLiveConsumerLink(link);
225    }
226  }
227  node.producers = void 0;
228  node.producersTail = void 0;
229  node.consumers = void 0;
230  node.consumersTail = void 0;
231}
232function producerAddLiveConsumer(node, link) {
233  const consumersTail = node.consumersTail;
234  const wasLive = consumerIsLive(node);
235  if (consumersTail !== void 0) {
236    link.nextConsumer = consumersTail.nextConsumer;
237    consumersTail.nextConsumer = link;
238  } else {
239    link.nextConsumer = void 0;
240    node.consumers = link;
241  }
242  link.prevConsumer = consumersTail;
243  node.consumersTail = link;
244  if (!wasLive) {
245    for (let link2 = node.producers; link2 !== void 0; link2 = link2.nextProducer) {
246      producerAddLiveConsumer(link2.producer, link2);
247    }
248  }
249}
250function producerRemoveLiveConsumerLink(link) {
251  const producer = link.producer;
252  const nextProducer = link.nextProducer;
253  const nextConsumer = link.nextConsumer;
254  const prevConsumer = link.prevConsumer;
255  link.nextConsumer = void 0;
256  link.prevConsumer = void 0;
257  if (nextConsumer !== void 0) {
258    nextConsumer.prevConsumer = prevConsumer;
259  } else {
260    producer.consumersTail = prevConsumer;
261  }
262  if (prevConsumer !== void 0) {
263    prevConsumer.nextConsumer = nextConsumer;
264  } else {
265    producer.consumers = nextConsumer;
266    if (!consumerIsLive(producer)) {
267      let producerLink = producer.producers;
268      while (producerLink !== void 0) {
269        producerLink = producerRemoveLiveConsumerLink(producerLink);
270      }
271    }
272  }
273  return nextProducer;
274}
275function consumerIsLive(node) {
276  return node.consumerIsAlwaysLive || node.consumers !== void 0;
277}
278function runPostProducerCreatedFn(node) {
279  postProducerCreatedFn?.(node);
280}
281function isValidLink(checkLink, consumer) {
282  const producersTail = consumer.producersTail;
283  if (producersTail !== void 0) {
284    let link = consumer.producers;
285    do {
286      if (link === checkLink) {
287        return true;
288      }
289      if (link === producersTail) {
290        break;
291      }
292      link = link.nextProducer;
293    } while (link !== void 0);
294  }
295  return false;
296}
297function defaultEquals(a, b) {
298  return Object.is(a, b);
299}
300function createComputed(computation, equal) {
301  const node = Object.create(COMPUTED_NODE);
302  node.computation = computation;
303  if (equal !== void 0) {
304    node.equal = equal;
305  }
306  const computed2 = () => {
307    producerUpdateValueVersion(node);
308    producerAccessed(node);
309    if (node.value === ERRORED) {
310      throw node.error;
311    }
312    return node.value;
313  };
314  computed2[SIGNAL] = node;
315  if (typeof ngDevMode !== "undefined" && ngDevMode) {
316    const debugName = node.debugName ? " (" + node.debugName + ")" : "";
317    computed2.toString = () => `[Computed${debugName}: ${node.value}]`;
318  }
319  runPostProducerCreatedFn(node);
320  return computed2;
321}
322function defaultThrowError() {
323  throw new Error();
324}
325function throwInvalidWriteToSignalError(node) {
326  throwInvalidWriteToSignalErrorFn(node);
327}
328function setThrowInvalidWriteToSignalError(fn) {
329  throwInvalidWriteToSignalErrorFn = fn;
330}
331function createSignal(initialValue, equal) {
332  const node = Object.create(SIGNAL_NODE);
333  node.value = initialValue;
334  if (equal !== void 0) {
335    node.equal = equal;
336  }
337  const getter = (() => signalGetFn(node));
338  getter[SIGNAL] = node;
339  if (typeof ngDevMode !== "undefined" && ngDevMode) {
340    const debugName = node.debugName ? " (" + node.debugName + ")" : "";
341    getter.toString = () => `[Signal${debugName}: ${node.value}]`;
342  }
343  runPostProducerCreatedFn(node);
344  const set = (newValue) => signalSetFn(node, newValue);
345  const update = (updateFn) => signalUpdateFn(node, updateFn);
346  return [getter, set, update];
347}
348function signalGetFn(node) {
349  producerAccessed(node);
350  return node.value;
351}
352function signalSetFn(node, newValue) {
353  if (!producerUpdatesAllowed()) {
354    throwInvalidWriteToSignalError(node);
355  }
356  if (!node.equal(node.value, newValue)) {
357    node.value = newValue;
358    signalValueChanged(node);
359  }
360}
361function signalUpdateFn(node, updater) {
362  if (!producerUpdatesAllowed()) {
363    throwInvalidWriteToSignalError(node);
364  }
365  signalSetFn(node, updater(node.value));
366}
367function signalValueChanged(node) {
368  node.version++;
369  producerIncrementEpoch();
370  producerNotifyConsumers(node);
371  postSignalSetFn?.(node);
372}
373var activeConsumer, inNotificationPhase, epoch, postProducerCreatedFn, SIGNAL, REACTIVE_NODE, UNSET, COMPUTING, ERRORED, COMPUTED_NODE, throwInvalidWriteToSignalErrorFn, postSignalSetFn, SIGNAL_NODE;
374var init_signal = __esm({
375  "node_modules/@angular/core/fesm2022/signal.mjs"() {
376    "use strict";
377    activeConsumer = null;
378    inNotificationPhase = false;
379    epoch = 1;
380    postProducerCreatedFn = null;
381    SIGNAL = /* @__PURE__ */ Symbol("SIGNAL");
382    REACTIVE_NODE = {
383      version: 0,
384      lastCleanEpoch: 0,
385      dirty: false,
386      producers: void 0,
387      producersTail: void 0,
388      consumers: void 0,
389      consumersTail: void 0,
390      recomputing: false,
391      consumerAllowSignalWrites: false,
392      consumerIsAlwaysLive: false,
393      kind: "unknown",
394      producerMustRecompute: () => false,
395      producerRecomputeValue: () => {
396      },
397      consumerMarkedDirty: () => {
398      },
399      consumerOnSignalRead: () => {
400      }
401    };
402    UNSET = /* @__PURE__ */ Symbol("UNSET");
403    COMPUTING = /* @__PURE__ */ Symbol("COMPUTING");
404    ERRORED = /* @__PURE__ */ Symbol("ERRORED");
405    COMPUTED_NODE = /* @__PURE__ */ (() => {
406      return __spreadProps(__spreadValues({}, REACTIVE_NODE), {
407        value: UNSET,
408        dirty: true,
409        error: null,
410        equal: defaultEquals,
411        kind: "computed",
412        producerMustRecompute(node) {
413          return node.value === UNSET || node.value === COMPUTING;
414        },
415        producerRecomputeValue(node) {
416          if (node.value === COMPUTING) {
417            throw new Error(typeof ngDevMode !== "undefined" && ngDevMode ? "Detected cycle in computations." : "");
418          }
419          const oldValue = node.value;
420          node.value = COMPUTING;
421          const prevConsumer = consumerBeforeComputation(node);
422          let newValue;
423          let wasEqual = false;
424          try {
425            newValue = node.computation();
426            setActiveConsumer(null);
427            wasEqual = oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED && node.equal(oldValue, newValue);
428          } catch (err) {
429            newValue = ERRORED;
430            node.error = err;
431          } finally {
432            consumerAfterComputation(node, prevConsumer);
433          }
434          if (wasEqual) {
435            node.value = oldValue;
436            return;
437          }
438          node.value = newValue;
439          node.version++;
440        }
441      });
442    })();
443    throwInvalidWriteToSignalErrorFn = defaultThrowError;
444    postSignalSetFn = null;
445    SIGNAL_NODE = /* @__PURE__ */ (() => {
446      return __spreadProps(__spreadValues({}, REACTIVE_NODE), {
447        equal: defaultEquals,
448        value: void 0,
449        kind: "signal"
450      });
451    })();
452  }
453});
454

455// node_modules/rxjs/dist/esm/internal/util/isFunction.js
456function isFunction(value) {
457  return typeof value === "function";
458}
459var init_isFunction = __esm({
460  "node_modules/rxjs/dist/esm/internal/util/isFunction.js"() {
461    "use strict";
462  }
463});
464

465// node_modules/rxjs/dist/esm/internal/util/createErrorClass.js
466function createErrorClass(createImpl) {
467  const _super = (instance) => {
468    Error.call(instance);
469    instance.stack = new Error().stack;
470  };
471  const ctorFunc = createImpl(_super);
472  ctorFunc.prototype = Object.create(Error.prototype);
473  ctorFunc.prototype.constructor = ctorFunc;
474  return ctorFunc;
475}
476var init_createErrorClass = __esm({
477  "node_modules/rxjs/dist/esm/internal/util/createErrorClass.js"() {
478    "use strict";
479  }
480});
481

482// node_modules/rxjs/dist/esm/internal/util/UnsubscriptionError.js
483var UnsubscriptionError;
484var init_UnsubscriptionError = __esm({
485  "node_modules/rxjs/dist/esm/internal/util/UnsubscriptionError.js"() {
486    "use strict";
487    init_createErrorClass();
488    UnsubscriptionError = createErrorClass((_super) => function UnsubscriptionErrorImpl(errors) {
489      _super(this);
490      this.message = errors ? `${errors.length} errors occurred during unsubscription:
491${errors.map((err, i) => `${i + 1}) ${err.toString()}`).join("\n  ")}` : "";
492      this.name = "UnsubscriptionError";
493      this.errors = errors;
494    });
495  }
496});
497

498// node_modules/rxjs/dist/esm/internal/util/arrRemove.js
499function arrRemove(arr, item) {
500  if (arr) {
501    const index = arr.indexOf(item);
502    0 <= index && arr.splice(index, 1);
503  }
504}
505var init_arrRemove = __esm({
506  "node_modules/rxjs/dist/esm/internal/util/arrRemove.js"() {
507    "use strict";
508  }
509});
510

511// node_modules/rxjs/dist/esm/internal/Subscription.js
512function isSubscription(value) {
513  return value instanceof Subscription || value && "closed" in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe);
514}
515function execFinalizer(finalizer) {
516  if (isFunction(finalizer)) {
517    finalizer();
518  } else {
519    finalizer.unsubscribe();
520  }
521}
522var Subscription, EMPTY_SUBSCRIPTION;
523var init_Subscription = __esm({
524  "node_modules/rxjs/dist/esm/internal/Subscription.js"() {
525    "use strict";
526    init_isFunction();
527    init_UnsubscriptionError();
528    init_arrRemove();
529    Subscription = class _Subscription {
530      constructor(initialTeardown) {
531        this.initialTeardown = initialTeardown;
532        this.closed = false;
533        this._parentage = null;
534        this._finalizers = null;
535      }
536      unsubscribe() {
537        let errors;
538        if (!this.closed) {
539          this.closed = true;
540          const { _parentage } = this;
541          if (_parentage) {
542            this._parentage = null;
543            if (Array.isArray(_parentage)) {
544              for (const parent of _parentage) {
545                parent.remove(this);
546              }
547            } else {
548              _parentage.remove(this);
549            }
550          }
551          const { initialTeardown: initialFinalizer } = this;
552          if (isFunction(initialFinalizer)) {
553            try {
554              initialFinalizer();
555            } catch (e) {
556              errors = e instanceof UnsubscriptionError ? e.errors : [e];
557            }
558          }
559          const { _finalizers } = this;
560          if (_finalizers) {
561            this._finalizers = null;
562            for (const finalizer of _finalizers) {
563              try {
564                execFinalizer(finalizer);
565              } catch (err) {
566                errors = errors !== null && errors !== void 0 ? errors : [];
567                if (err instanceof UnsubscriptionError) {
568                  errors = [...errors, ...err.errors];
569                } else {
570                  errors.push(err);
571                }
572              }
573            }
574          }
575          if (errors) {
576            throw new UnsubscriptionError(errors);
577          }
578        }
579      }
580      add(teardown) {
581        var _a;
582        if (teardown && teardown !== this) {
583          if (this.closed) {
584            execFinalizer(teardown);
585          } else {
586            if (teardown instanceof _Subscription) {
587              if (teardown.closed || teardown._hasParent(this)) {
588                return;
589              }
590              teardown._addParent(this);
591            }
592            (this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
593          }
594        }
595      }
596      _hasParent(parent) {
597        const { _parentage } = this;
598        return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent);
599      }
600      _addParent(parent) {
601        const { _parentage } = this;
602        this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
603      }
604      _removeParent(parent) {
605        const { _parentage } = this;
606        if (_parentage === parent) {
607          this._parentage = null;
608        } else if (Array.isArray(_parentage)) {
609          arrRemove(_parentage, parent);
610        }
611      }
612      remove(teardown) {
613        const { _finalizers } = this;
614        _finalizers && arrRemove(_finalizers, teardown);
615        if (teardown instanceof _Subscription) {
616          teardown._removeParent(this);
617        }
618      }
619    };
620    Subscription.EMPTY = (() => {
621      const empty = new Subscription();
622      empty.closed = true;
623      return empty;
624    })();
625    EMPTY_SUBSCRIPTION = Subscription.EMPTY;
626  }
627});
628

629// node_modules/rxjs/dist/esm/internal/config.js
630var config;
631var init_config = __esm({
632  "node_modules/rxjs/dist/esm/internal/config.js"() {
633    "use strict";
634    config = {
635      onUnhandledError: null,
636      onStoppedNotification: null,
637      Promise: void 0,
638      useDeprecatedSynchronousErrorHandling: false,
639      useDeprecatedNextContext: false
640    };
641  }
642});
643

644// node_modules/rxjs/dist/esm/internal/scheduler/timeoutProvider.js
645var timeoutProvider;
646var init_timeoutProvider = __esm({
647  "node_modules/rxjs/dist/esm/internal/scheduler/timeoutProvider.js"() {
648    "use strict";
649    timeoutProvider = {
650      setTimeout(handler, timeout, ...args) {
651        const { delegate } = timeoutProvider;
652        if (delegate === null || delegate === void 0 ? void 0 : delegate.setTimeout) {
653          return delegate.setTimeout(handler, timeout, ...args);
654        }
655        return setTimeout(handler, timeout, ...args);
656      },
657      clearTimeout(handle) {
658        const { delegate } = timeoutProvider;
659        return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearTimeout) || clearTimeout)(handle);
660      },
661      delegate: void 0
662    };
663  }
664});
665

666// node_modules/rxjs/dist/esm/internal/util/reportUnhandledError.js
667function reportUnhandledError(err) {
668  timeoutProvider.setTimeout(() => {
669    const { onUnhandledError } = config;
670    if (onUnhandledError) {
671      onUnhandledError(err);
672    } else {
673      throw err;
674    }
675  });
676}
677var init_reportUnhandledError = __esm({
678  "node_modules/rxjs/dist/esm/internal/util/reportUnhandledError.js"() {
679    "use strict";
680    init_config();
681    init_timeoutProvider();
682  }
683});
684

685// node_modules/rxjs/dist/esm/internal/util/noop.js
686function noop() {
687}
688var init_noop = __esm({
689  "node_modules/rxjs/dist/esm/internal/util/noop.js"() {
690    "use strict";
691  }
692});
693

694// node_modules/rxjs/dist/esm/internal/NotificationFactories.js
695function errorNotification(error) {
696  return createNotification("E", void 0, error);
697}
698function nextNotification(value) {
699  return createNotification("N", value, void 0);
700}
701function createNotification(kind, value, error) {
702  return {
703    kind,
704    value,
705    error
706  };
707}
708var COMPLETE_NOTIFICATION;
709var init_NotificationFactories = __esm({
710  "node_modules/rxjs/dist/esm/internal/NotificationFactories.js"() {
711    "use strict";
712    COMPLETE_NOTIFICATION = (() => createNotification("C", void 0, void 0))();
713  }
714});
715

716// node_modules/rxjs/dist/esm/internal/util/errorContext.js
717function errorContext(cb) {
718  if (config.useDeprecatedSynchronousErrorHandling) {
719    const isRoot = !context;
720    if (isRoot) {
721      context = { errorThrown: false, error: null };
722    }
723    cb();
724    if (isRoot) {
725      const { errorThrown, error } = context;
726      context = null;
727      if (errorThrown) {
728        throw error;
729      }
730    }
731  } else {
732    cb();
733  }
734}
735function captureError(err) {
736  if (config.useDeprecatedSynchronousErrorHandling && context) {
737    context.errorThrown = true;
738    context.error = err;
739  }
740}
741var context;
742var init_errorContext = __esm({
743  "node_modules/rxjs/dist/esm/internal/util/errorContext.js"() {
744    "use strict";
745    init_config();
746    context = null;
747  }
748});
749

750// node_modules/rxjs/dist/esm/internal/Subscriber.js
751function bind(fn, thisArg) {
752  return _bind.call(fn, thisArg);
753}
754function handleUnhandledError(error) {
755  if (config.useDeprecatedSynchronousErrorHandling) {
756    captureError(error);
757  } else {
758    reportUnhandledError(error);
759  }
760}
761function defaultErrorHandler(err) {
762  throw err;
763}
764function handleStoppedNotification(notification, subscriber) {
765  const { onStoppedNotification } = config;
766  onStoppedNotification && timeoutProvider.setTimeout(() => onStoppedNotification(notification, subscriber));
767}
768var Subscriber, _bind, ConsumerObserver, SafeSubscriber, EMPTY_OBSERVER;
769var init_Subscriber = __esm({
770  "node_modules/rxjs/dist/esm/internal/Subscriber.js"() {
771    "use strict";
772    init_isFunction();
773    init_Subscription();
774    init_config();
775    init_reportUnhandledError();
776    init_noop();
777    init_NotificationFactories();
778    init_timeoutProvider();
779    init_errorContext();
780    Subscriber = class extends Subscription {
781      constructor(destination) {
782        super();
783        this.isStopped = false;
784        if (destination) {
785          this.destination = destination;
786          if (isSubscription(destination)) {
787            destination.add(this);
788          }
789        } else {
790          this.destination = EMPTY_OBSERVER;
791        }
792      }
793      static create(next, error, complete) {
794        return new SafeSubscriber(next, error, complete);
795      }
796      next(value) {
797        if (this.isStopped) {
798          handleStoppedNotification(nextNotification(value), this);
799        } else {
800          this._next(value);
801        }
802      }
803      error(err) {
804        if (this.isStopped) {
805          handleStoppedNotification(errorNotification(err), this);
806        } else {
807          this.isStopped = true;
808          this._error(err);
809        }
810      }
811      complete() {
812        if (this.isStopped) {
813          handleStoppedNotification(COMPLETE_NOTIFICATION, this);
814        } else {
815          this.isStopped = true;
816          this._complete();
817        }
818      }
819      unsubscribe() {
820        if (!this.closed) {
821          this.isStopped = true;
822          super.unsubscribe();
823          this.destination = null;
824        }
825      }
826      _next(value) {
827        this.destination.next(value);
828      }
829      _error(err) {
830        try {
831          this.destination.error(err);
832        } finally {
833          this.unsubscribe();
834        }
835      }
836      _complete() {
837        try {
838          this.destination.complete();
839        } finally {
840          this.unsubscribe();
841        }
842      }
843    };
844    _bind = Function.prototype.bind;
845    ConsumerObserver = class {
846      constructor(partialObserver) {
847        this.partialObserver = partialObserver;
848      }
849      next(value) {
850        const { partialObserver } = this;
851        if (partialObserver.next) {
852          try {
853            partialObserver.next(value);
854          } catch (error) {
855            handleUnhandledError(error);
856          }
857        }
858      }
859      error(err) {
860        const { partialObserver } = this;
861        if (partialObserver.error) {
862          try {
863            partialObserver.error(err);
864          } catch (error) {
865            handleUnhandledError(error);
866          }
867        } else {
868          handleUnhandledError(err);
869        }
870      }
871      complete() {
872        const { partialObserver } = this;
873        if (partialObserver.complete) {
874          try {
875            partialObserver.complete();
876          } catch (error) {
877            handleUnhandledError(error);
878          }
879        }
880      }
881    };
882    SafeSubscriber = class extends Subscriber {
883      constructor(observerOrNext, error, complete) {
884        super();
885        let partialObserver;
886        if (isFunction(observerOrNext) || !observerOrNext) {
887          partialObserver = {
888            next: observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : void 0,
889            error: error !== null && error !== void 0 ? error : void 0,
890            complete: complete !== null && complete !== void 0 ? complete : void 0
891          };
892        } else {
893          let context2;
894          if (this && config.useDeprecatedNextContext) {
895            context2 = Object.create(observerOrNext);
896            context2.unsubscribe = () => this.unsubscribe();
897            partialObserver = {
898              next: observerOrNext.next && bind(observerOrNext.next, context2),
899              error: observerOrNext.error && bind(observerOrNext.error, context2),
900              complete: observerOrNext.complete && bind(observerOrNext.complete, context2)
901            };
902          } else {
903            partialObserver = observerOrNext;
904          }
905        }
906        this.destination = new ConsumerObserver(partialObserver);
907      }
908    };
909    EMPTY_OBSERVER = {
910      closed: true,
911      next: noop,
912      error: defaultErrorHandler,
913      complete: noop
914    };
915  }
916});
917

918// node_modules/rxjs/dist/esm/internal/symbol/observable.js
919var observable;
920var init_observable = __esm({
921  "node_modules/rxjs/dist/esm/internal/symbol/observable.js"() {
922    "use strict";
923    observable = (() => typeof Symbol === "function" && Symbol.observable || "@@observable")();
924  }
925});
926

927// node_modules/rxjs/dist/esm/internal/util/identity.js
928function identity(x) {
929  return x;
930}
931var init_identity = __esm({
932  "node_modules/rxjs/dist/esm/internal/util/identity.js"() {
933    "use strict";
934  }
935});
936

937// node_modules/rxjs/dist/esm/internal/util/pipe.js
938function pipeFromArray(fns) {
939  if (fns.length === 0) {
940    return identity;
941  }
942  if (fns.length === 1) {
943    return fns[0];
944  }
945  return function piped(input2) {
946    return fns.reduce((prev, fn) => fn(prev), input2);
947  };
948}
949var init_pipe = __esm({
950  "node_modules/rxjs/dist/esm/internal/util/pipe.js"() {
951    "use strict";
952    init_identity();
953  }
954});
955

956// node_modules/rxjs/dist/esm/internal/Observable.js
957function getPromiseCtor(promiseCtor) {
958  var _a;
959  return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a !== void 0 ? _a : Promise;
960}
961function isObserver(value) {
962  return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
963}
964function isSubscriber(value) {
965  return value && value instanceof Subscriber || isObserver(value) && isSubscription(value);
966}
967var Observable;
968var init_Observable = __esm({
969  "node_modules/rxjs/dist/esm/internal/Observable.js"() {
970    "use strict";
971    init_Subscriber();
972    init_Subscription();
973    init_observable();
974    init_pipe();
975    init_config();
976    init_isFunction();
977    init_errorContext();
978    Observable = class _Observable {
979      constructor(subscribe) {
980        if (subscribe) {
981          this._subscribe = subscribe;
982        }
983      }
984      lift(operator) {
985        const observable2 = new _Observable();
986        observable2.source = this;
987        observable2.operator = operator;
988        return observable2;
989      }
990      subscribe(observerOrNext, error, complete) {
991        const subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
992        errorContext(() => {
993          const { operator, source } = this;
994          subscriber.add(operator ? operator.call(subscriber, source) : source ? this._subscribe(subscriber) : this._trySubscribe(subscriber));
995        });
996        return subscriber;
997      }
998      _trySubscribe(sink) {
999        try {
1000          return this._subscribe(sink);
1001        } catch (err) {
1002          sink.error(err);
1003        }
1004      }
1005      forEach(next, promiseCtor) {
1006        promiseCtor = getPromiseCtor(promiseCtor);
1007        return new promiseCtor((resolve, reject) => {
1008          const subscriber = new SafeSubscriber({
1009            next: (value) => {
1010              try {
1011                next(value);
1012              } catch (err) {
1013                reject(err);
1014                subscriber.unsubscribe();
1015              }
1016            },
1017            error: reject,
1018            complete: resolve
1019          });
1020          this.subscribe(subscriber);
1021        });
1022      }
1023      _subscribe(subscriber) {
1024        var _a;
1025        return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);
1026      }
1027      [observable]() {
1028        return this;
1029      }
1030      pipe(...operations) {
1031        return pipeFromArray(operations)(this);
1032      }
1033      toPromise(promiseCtor) {
1034        promiseCtor = getPromiseCtor(promiseCtor);
1035        return new promiseCtor((resolve, reject) => {
1036          let value;
1037          this.subscribe((x) => value = x, (err) => reject(err), () => resolve(value));
1038        });
1039      }
1040    };
1041    Observable.create = (subscribe) => {
1042      return new Observable(subscribe);
1043    };
1044  }
1045});
1046

1047// node_modules/rxjs/dist/esm/internal/util/lift.js
1048function hasLift(source) {
1049  return isFunction(source === null || source === void 0 ? void 0 : source.lift);
1050}
1051function operate(init) {
1052  return (source) => {
1053    if (hasLift(source)) {
1054      return source.lift(function(liftedSource) {
1055        try {
1056          return init(liftedSource, this);
1057        } catch (err) {
1058          this.error(err);
1059        }
1060      });
1061    }
1062    throw new TypeError("Unable to lift unknown Observable type");
1063  };
1064}
1065var init_lift = __esm({
1066  "node_modules/rxjs/dist/esm/internal/util/lift.js"() {
1067    "use strict";
1068    init_isFunction();
1069  }
1070});
1071

1072// node_modules/rxjs/dist/esm/internal/operators/OperatorSubscriber.js
1073function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
1074  return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
1075}
1076var OperatorSubscriber;
1077var init_OperatorSubscriber = __esm({
1078  "node_modules/rxjs/dist/esm/internal/operators/OperatorSubscriber.js"() {
1079    "use strict";
1080    init_Subscriber();
1081    OperatorSubscriber = class extends Subscriber {
1082      constructor(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
1083        super(destination);
1084        this.onFinalize = onFinalize;
1085        this.shouldUnsubscribe = shouldUnsubscribe;
1086        this._next = onNext ? function(value) {
1087          try {
1088            onNext(value);
1089          } catch (err) {
1090            destination.error(err);
1091          }
1092        } : super._next;
1093        this._error = onError ? function(err) {
1094          try {
1095            onError(err);
1096          } catch (err2) {
1097            destination.error(err2);
1098          } finally {
1099            this.unsubscribe();
1100          }
1101        } : super._error;
1102        this._complete = onComplete ? function() {
1103          try {
1104            onComplete();
1105          } catch (err) {
1106            destination.error(err);
1107          } finally {
1108            this.unsubscribe();
1109          }
1110        } : super._complete;
1111      }
1112      unsubscribe() {
1113        var _a;
1114        if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
1115          const { closed } = this;
1116          super.unsubscribe();
1117          !closed && ((_a = this.onFinalize) === null || _a === void 0 ? void 0 : _a.call(this));
1118        }
1119      }
1120    };
1121  }
1122});
1123

1124// node_modules/rxjs/dist/esm/internal/util/ObjectUnsubscribedError.js
1125var ObjectUnsubscribedError;
1126var init_ObjectUnsubscribedError = __esm({
1127  "node_modules/rxjs/dist/esm/internal/util/ObjectUnsubscribedError.js"() {
1128    "use strict";
1129    init_createErrorClass();
1130    ObjectUnsubscribedError = createErrorClass((_super) => function ObjectUnsubscribedErrorImpl() {
1131      _super(this);
1132      this.name = "ObjectUnsubscribedError";
1133      this.message = "object unsubscribed";
1134    });
1135  }
1136});
1137

1138// node_modules/rxjs/dist/esm/internal/Subject.js
1139var Subject, AnonymousSubject;
1140var init_Subject = __esm({
1141  "node_modules/rxjs/dist/esm/internal/Subject.js"() {
1142    "use strict";
1143    init_Observable();
1144    init_Subscription();
1145    init_ObjectUnsubscribedError();
1146    init_arrRemove();
1147    init_errorContext();
1148    Subject = class extends Observable {
1149      constructor() {
1150        super();
1151        this.closed = false;
1152        this.currentObservers = null;
1153        this.observers = [];
1154        this.isStopped = false;
1155        this.hasError = false;
1156        this.thrownError = null;
1157      }
1158      lift(operator) {
1159        const subject = new AnonymousSubject(this, this);
1160        subject.operator = operator;
1161        return subject;
1162      }
1163      _throwIfClosed() {
1164        if (this.closed) {
1165          throw new ObjectUnsubscribedError();
1166        }
1167      }
1168      next(value) {
1169        errorContext(() => {
1170          this._throwIfClosed();
1171          if (!this.isStopped) {
1172            if (!this.currentObservers) {
1173              this.currentObservers = Array.from(this.observers);
1174            }
1175            for (const observer of this.currentObservers) {
1176              observer.next(value);
1177            }
1178          }
1179        });
1180      }
1181      error(err) {
1182        errorContext(() => {
1183          this._throwIfClosed();
1184          if (!this.isStopped) {
1185            this.hasError = this.isStopped = true;
1186            this.thrownError = err;
1187            const { observers } = this;
1188            while (observers.length) {
1189              observers.shift().error(err);
1190            }
1191          }
1192        });
1193      }
1194      complete() {
1195        errorContext(() => {
1196          this._throwIfClosed();
1197          if (!this.isStopped) {
1198            this.isStopped = true;
1199            const { observers } = this;
1200            while (observers.length) {
1201              observers.shift().complete();
1202            }
1203          }
1204        });
1205      }
1206      unsubscribe() {
1207        this.isStopped = this.closed = true;
1208        this.observers = this.currentObservers = null;
1209      }
1210      get observed() {
1211        var _a;
1212        return ((_a = this.observers) === null || _a === void 0 ? void 0 : _a.length) > 0;
1213      }
1214      _trySubscribe(subscriber) {
1215        this._throwIfClosed();
1216        return super._trySubscribe(subscriber);
1217      }
1218      _subscribe(subscriber) {
1219        this._throwIfClosed();
1220        this._checkFinalizedStatuses(subscriber);
1221        return this._innerSubscribe(subscriber);
1222      }
1223      _innerSubscribe(subscriber) {
1224        const { hasError, isStopped, observers } = this;
1225        if (hasError || isStopped) {
1226          return EMPTY_SUBSCRIPTION;
1227        }
1228        this.currentObservers = null;
1229        observers.push(subscriber);
1230        return new Subscription(() => {
1231          this.currentObservers = null;
1232          arrRemove(observers, subscriber);
1233        });
1234      }
1235      _checkFinalizedStatuses(subscriber) {
1236        const { hasError, thrownError, isStopped } = this;
1237        if (hasError) {
1238          subscriber.error(thrownError);
1239        } else if (isStopped) {
1240          subscriber.complete();
1241        }
1242      }
1243      asObservable() {
1244        const observable2 = new Observable();
1245        observable2.source = this;
1246        return observable2;
1247      }
1248    };
1249    Subject.create = (destination, source) => {
1250      return new AnonymousSubject(destination, source);
1251    };
1252    AnonymousSubject = class extends Subject {
1253      constructor(destination, source) {
1254        super();
1255        this.destination = destination;
1256        this.source = source;
1257      }
1258      next(value) {
1259        var _a, _b;
1260        (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.call(_a, value);
1261      }
1262      error(err) {
1263        var _a, _b;
1264        (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
1265      }
1266      complete() {
1267        var _a, _b;
1268        (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.complete) === null || _b === void 0 ? void 0 : _b.call(_a);
1269      }
1270      _subscribe(subscriber) {
1271        var _a, _b;
1272        return (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber)) !== null && _b !== void 0 ? _b : EMPTY_SUBSCRIPTION;
1273      }
1274    };
1275  }
1276});
1277

1278// node_modules/rxjs/dist/esm/internal/BehaviorSubject.js
1279var BehaviorSubject;
1280var init_BehaviorSubject = __esm({
1281  "node_modules/rxjs/dist/esm/internal/BehaviorSubject.js"() {
1282    "use strict";
1283    init_Subject();
1284    BehaviorSubject = class extends Subject {
1285      constructor(_value) {
1286        super();
1287        this._value = _value;
1288      }
1289      get value() {
1290        return this.getValue();
1291      }
1292      _subscribe(subscriber) {
1293        const subscription = super._subscribe(subscriber);
1294        !subscription.closed && subscriber.next(this._value);
1295        return subscription;
1296      }
1297      getValue() {
1298        const { hasError, thrownError, _value } = this;
1299        if (hasError) {
1300          throw thrownError;
1301        }
1302        this._throwIfClosed();
1303        return _value;
1304      }
1305      next(value) {
1306        super.next(this._value = value);
1307      }
1308    };
1309  }
1310});
1311

1312// node_modules/rxjs/dist/esm/internal/scheduler/dateTimestampProvider.js
1313var dateTimestampProvider;
1314var init_dateTimestampProvider = __esm({
1315  "node_modules/rxjs/dist/esm/internal/scheduler/dateTimestampProvider.js"() {
1316    "use strict";
1317    dateTimestampProvider = {
1318      now() {
1319        return (dateTimestampProvider.delegate || Date).now();
1320      },
1321      delegate: void 0
1322    };
1323  }
1324});
1325

1326// node_modules/rxjs/dist/esm/internal/ReplaySubject.js
1327var ReplaySubject;
1328var init_ReplaySubject = __esm({
1329  "node_modules/rxjs/dist/esm/internal/ReplaySubject.js"() {
1330    "use strict";
1331    init_Subject();
1332    init_dateTimestampProvider();
1333    ReplaySubject = class extends Subject {
1334      constructor(_bufferSize = Infinity, _windowTime = Infinity, _timestampProvider = dateTimestampProvider) {
1335        super();
1336        this._bufferSize = _bufferSize;
1337        this._windowTime = _windowTime;
1338        this._timestampProvider = _timestampProvider;
1339        this._buffer = [];
1340        this._infiniteTimeWindow = true;
1341        this._infiniteTimeWindow = _windowTime === Infinity;
1342        this._bufferSize = Math.max(1, _bufferSize);
1343        this._windowTime = Math.max(1, _windowTime);
1344      }
1345      next(value) {
1346        const { isStopped, _buffer, _infiniteTimeWindow, _timestampProvider, _windowTime } = this;
1347        if (!isStopped) {
1348          _buffer.push(value);
1349          !_infiniteTimeWindow && _buffer.push(_timestampProvider.now() + _windowTime);
1350        }
1351        this._trimBuffer();
1352        super.next(value);
1353      }
1354      _subscribe(subscriber) {
1355        this._throwIfClosed();
1356        this._trimBuffer();
1357        const subscription = this._innerSubscribe(subscriber);
1358        const { _infiniteTimeWindow, _buffer } = this;
1359        const copy = _buffer.slice();
1360        for (let i = 0; i < copy.length && !subscriber.closed; i += _infiniteTimeWindow ? 1 : 2) {
1361          subscriber.next(copy[i]);
1362        }
1363        this._checkFinalizedStatuses(subscriber);
1364        return subscription;
1365      }
1366      _trimBuffer() {
1367        const { _bufferSize, _timestampProvider, _buffer, _infiniteTimeWindow } = this;
1368        const adjustedBufferSize = (_infiniteTimeWindow ? 1 : 2) * _bufferSize;
1369        _bufferSize < Infinity && adjustedBufferSize < _buffer.length && _buffer.splice(0, _buffer.length - adjustedBufferSize);
1370        if (!_infiniteTimeWindow) {
1371          const now = _timestampProvider.now();
1372          let last2 = 0;
1373          for (let i = 1; i < _buffer.length && _buffer[i] <= now; i += 2) {
1374            last2 = i;
1375          }
1376          last2 && _buffer.splice(0, last2 + 1);
1377        }
1378      }
1379    };
1380  }
1381});
1382

1383// node_modules/rxjs/dist/esm/internal/observable/empty.js
1384var EMPTY;
1385var init_empty = __esm({
1386  "node_modules/rxjs/dist/esm/internal/observable/empty.js"() {
1387    "use strict";
1388    init_Observable();
1389    EMPTY = new Observable((subscriber) => subscriber.complete());
1390  }
1391});
1392

1393// node_modules/rxjs/dist/esm/internal/util/isScheduler.js
1394function isScheduler(value) {
1395  return value && isFunction(value.schedule);
1396}
1397var init_isScheduler = __esm({
1398  "node_modules/rxjs/dist/esm/internal/util/isScheduler.js"() {
1399    "use strict";
1400    init_isFunction();
1401  }
1402});
1403

1404// node_modules/rxjs/dist/esm/internal/util/args.js
1405function last(arr) {
1406  return arr[arr.length - 1];
1407}
1408function popScheduler(args) {
1409  return isScheduler(last(args)) ? args.pop() : void 0;
1410}
1411function popNumber(args, defaultValue) {
1412  return typeof last(args) === "number" ? args.pop() : defaultValue;
1413}
1414var init_args = __esm({
1415  "node_modules/rxjs/dist/esm/internal/util/args.js"() {
1416    "use strict";
1417    init_isScheduler();
1418  }
1419});
1420

1421// node_modules/tslib/tslib.es6.mjs
1422function __awaiter(thisArg, _arguments, P, generator) {
1423  function adopt(value) {
1424    return value instanceof P ? value : new P(function(resolve) {
1425      resolve(value);
1426    });
1427  }
1428  return new (P || (P = Promise))(function(resolve, reject) {
1429    function fulfilled(value) {
1430      try {
1431        step(generator.next(value));
1432      } catch (e) {
1433        reject(e);
1434      }
1435    }
1436    function rejected(value) {
1437      try {
1438        step(generator["throw"](value));
1439      } catch (e) {
1440        reject(e);
1441      }
1442    }
1443    function step(result) {
1444      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
1445    }
1446    step((generator = generator.apply(thisArg, _arguments || [])).next());
1447  });
1448}
1449function __values(o) {
1450  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
1451  if (m) return m.call(o);
1452  if (o && typeof o.length === "number") return {
1453    next: function() {
1454      if (o && i >= o.length) o = void 0;
1455      return { value: o && o[i++], done: !o };
1456    }
1457  };
1458  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
1459}
1460function __await(v) {
1461  return this instanceof __await ? (this.v = v, this) : new __await(v);
1462}
1463function __asyncGenerator(thisArg, _arguments, generator) {
1464  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
1465  var g = generator.apply(thisArg, _arguments || []), i, q = [];
1466  return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
1467    return this;
1468  }, i;
1469  function awaitReturn(f) {
1470    return function(v) {
1471      return Promise.resolve(v).then(f, reject);
1472    };
1473  }
1474  function verb(n, f) {
1475    if (g[n]) {
1476      i[n] = function(v) {
1477        return new Promise(function(a, b) {
1478          q.push([n, v, a, b]) > 1 || resume(n, v);
1479        });
1480      };
1481      if (f) i[n] = f(i[n]);
1482    }
1483  }
1484  function resume(n, v) {
1485    try {
1486      step(g[n](v));
1487    } catch (e) {
1488      settle(q[0][3], e);
1489    }
1490  }
1491  function step(r) {
1492    r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
1493  }
1494  function fulfill(value) {
1495    resume("next", value);
1496  }
1497  function reject(value) {
1498    resume("throw", value);
1499  }
1500  function settle(f, v) {
1501    if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
1502  }
1503}
1504function __asyncValues(o) {
1505  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
1506  var m = o[Symbol.asyncIterator], i;
1507  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
1508    return this;
1509  }, i);
1510  function verb(n) {
1511    i[n] = o[n] && function(v) {
1512      return new Promise(function(resolve, reject) {
1513        v = o[n](v), settle(resolve, reject, v.done, v.value);
1514      });
1515    };
1516  }
1517  function settle(resolve, reject, d, v) {
1518    Promise.resolve(v).then(function(v2) {
1519      resolve({ value: v2, done: d });
1520    }, reject);
1521  }
1522}
1523var init_tslib_es6 = __esm({
1524  "node_modules/tslib/tslib.es6.mjs"() {
1525    "use strict";
1526  }
1527});
1528

1529// node_modules/rxjs/dist/esm/internal/util/isArrayLike.js
1530var isArrayLike;
1531var init_isArrayLike = __esm({
1532  "node_modules/rxjs/dist/esm/internal/util/isArrayLike.js"() {
1533    "use strict";
1534    isArrayLike = ((x) => x && typeof x.length === "number" && typeof x !== "function");
1535  }
1536});
1537

1538// node_modules/rxjs/dist/esm/internal/util/isPromise.js
1539function isPromise(value) {
1540  return isFunction(value === null || value === void 0 ? void 0 : value.then);
1541}
1542var init_isPromise = __esm({
1543  "node_modules/rxjs/dist/esm/internal/util/isPromise.js"() {
1544    "use strict";
1545    init_isFunction();
1546  }
1547});
1548

1549// node_modules/rxjs/dist/esm/internal/util/isInteropObservable.js
1550function isInteropObservable(input2) {
1551  return isFunction(input2[observable]);
1552}
1553var init_isInteropObservable = __esm({
1554  "node_modules/rxjs/dist/esm/internal/util/isInteropObservable.js"() {
1555    "use strict";
1556    init_observable();
1557    init_isFunction();
1558  }
1559});
1560

1561// node_modules/rxjs/dist/esm/internal/util/isAsyncIterable.js
1562function isAsyncIterable(obj) {
1563  return Symbol.asyncIterator && isFunction(obj === null || obj === void 0 ? void 0 : obj[Symbol.asyncIterator]);
1564}
1565var init_isAsyncIterable = __esm({
1566  "node_modules/rxjs/dist/esm/internal/util/isAsyncIterable.js"() {
1567    "use strict";
1568    init_isFunction();
1569  }
1570});
1571

1572// node_modules/rxjs/dist/esm/internal/util/throwUnobservableError.js
1573function createInvalidObservableTypeError(input2) {
1574  return new TypeError(`You provided ${input2 !== null && typeof input2 === "object" ? "an invalid object" : `'${input2}'`} where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.`);
1575}
1576var init_throwUnobservableError = __esm({
1577  "node_modules/rxjs/dist/esm/internal/util/throwUnobservableError.js"() {
1578    "use strict";
1579  }
1580});
1581

1582// node_modules/rxjs/dist/esm/internal/symbol/iterator.js
1583function getSymbolIterator() {
1584  if (typeof Symbol !== "function" || !Symbol.iterator) {
1585    return "@@iterator";
1586  }
1587  return Symbol.iterator;
1588}
1589var iterator;
1590var init_iterator = __esm({
1591  "node_modules/rxjs/dist/esm/internal/symbol/iterator.js"() {
1592    "use strict";
1593    iterator = getSymbolIterator();
1594  }
1595});
1596

1597// node_modules/rxjs/dist/esm/internal/util/isIterable.js
1598function isIterable(input2) {
1599  return isFunction(input2 === null || input2 === void 0 ? void 0 : input2[iterator]);
1600}
1601var init_isIterable = __esm({
1602  "node_modules/rxjs/dist/esm/internal/util/isIterable.js"() {
1603    "use strict";
1604    init_iterator();
1605    init_isFunction();
1606  }
1607});
1608

1609// node_modules/rxjs/dist/esm/internal/util/isReadableStreamLike.js
1610function readableStreamLikeToAsyncGenerator(readableStream) {
1611  return __asyncGenerator(this, arguments, function* readableStreamLikeToAsyncGenerator_1() {
1612    const reader = readableStream.getReader();
1613    try {
1614      while (true) {
1615        const { value, done } = yield __await(reader.read());
1616        if (done) {
1617          return yield __await(void 0);
1618        }
1619        yield yield __await(value);
1620      }
1621    } finally {
1622      reader.releaseLock();
1623    }
1624  });
1625}
1626function isReadableStreamLike(obj) {
1627  return isFunction(obj === null || obj === void 0 ? void 0 : obj.getReader);
1628}
1629var init_isReadableStreamLike = __esm({
1630  "node_modules/rxjs/dist/esm/internal/util/isReadableStreamLike.js"() {
1631    "use strict";
1632    init_tslib_es6();
1633    init_isFunction();
1634  }
1635});
1636

1637// node_modules/rxjs/dist/esm/internal/observable/innerFrom.js
1638function innerFrom(input2) {
1639  if (input2 instanceof Observable) {
1640    return input2;
1641  }
1642  if (input2 != null) {
1643    if (isInteropObservable(input2)) {
1644      return fromInteropObservable(input2);
1645    }
1646    if (isArrayLike(input2)) {
1647      return fromArrayLike(input2);
1648    }
1649    if (isPromise(input2)) {
1650      return fromPromise(input2);
1651    }
1652    if (isAsyncIterable(input2)) {
1653      return fromAsyncIterable(input2);
1654    }
1655    if (isIterable(input2)) {
1656      return fromIterable(input2);
1657    }
1658    if (isReadableStreamLike(input2)) {
1659      return fromReadableStreamLike(input2);
1660    }
1661  }
1662  throw createInvalidObservableTypeError(input2);
1663}
1664function fromInteropObservable(obj) {
1665  return new Observable((subscriber) => {
1666    const obs = obj[observable]();
1667    if (isFunction(obs.subscribe)) {
1668      return obs.subscribe(subscriber);
1669    }
1670    throw new TypeError("Provided object does not correctly implement Symbol.observable");
1671  });
1672}
1673function fromArrayLike(array) {
1674  return new Observable((subscriber) => {
1675    for (let i = 0; i < array.length && !subscriber.closed; i++) {
1676      subscriber.next(array[i]);
1677    }
1678    subscriber.complete();
1679  });
1680}
1681function fromPromise(promise) {
1682  return new Observable((subscriber) => {
1683    promise.then((value) => {
1684      if (!subscriber.closed) {
1685        subscriber.next(value);
1686        subscriber.complete();
1687      }
1688    }, (err) => subscriber.error(err)).then(null, reportUnhandledError);
1689  });
1690}
1691function fromIterable(iterable) {
1692  return new Observable((subscriber) => {
1693    for (const value of iterable) {
1694      subscriber.next(value);
1695      if (subscriber.closed) {
1696        return;
1697      }
1698    }
1699    subscriber.complete();
1700  });
1701}
1702function fromAsyncIterable(asyncIterable) {
1703  return new Observable((subscriber) => {
1704    process(asyncIterable, subscriber).catch((err) => subscriber.error(err));
1705  });
1706}
1707function fromReadableStreamLike(readableStream) {
1708  return fromAsyncIterable(readableStreamLikeToAsyncGenerator(readableStream));
1709}
1710function process(asyncIterable, subscriber) {
1711  var asyncIterable_1, asyncIterable_1_1;
1712  var e_1, _a;
1713  return __awaiter(this, void 0, void 0, function* () {
1714    try {
1715      for (asyncIterable_1 = __asyncValues(asyncIterable); asyncIterable_1_1 = yield asyncIterable_1.next(), !asyncIterable_1_1.done; ) {
1716        const value = asyncIterable_1_1.value;
1717        subscriber.next(value);
1718        if (subscriber.closed) {
1719          return;
1720        }
1721      }
1722    } catch (e_1_1) {
1723      e_1 = { error: e_1_1 };
1724    } finally {
1725      try {
1726        if (asyncIterable_1_1 && !asyncIterable_1_1.done && (_a = asyncIterable_1.return)) yield _a.call(asyncIterable_1);
1727      } finally {
1728        if (e_1) throw e_1.error;
1729      }
1730    }
1731    subscriber.complete();
1732  });
1733}
1734var init_innerFrom = __esm({
1735  "node_modules/rxjs/dist/esm/internal/observable/innerFrom.js"() {
1736    "use strict";
1737    init_tslib_es6();
1738    init_isArrayLike();
1739    init_isPromise();
1740    init_Observable();
1741    init_isInteropObservable();
1742    init_isAsyncIterable();
1743    init_throwUnobservableError();
1744    init_isIterable();
1745    init_isReadableStreamLike();
1746    init_isFunction();
1747    init_reportUnhandledError();
1748    init_observable();
1749  }
1750});
1751

1752// node_modules/rxjs/dist/esm/internal/util/executeSchedule.js
1753function executeSchedule(parentSubscription, scheduler2, work, delay = 0, repeat = false) {
1754  const scheduleSubscription = scheduler2.schedule(function() {
1755    work();
1756    if (repeat) {
1757      parentSubscription.add(this.schedule(null, delay));
1758    } else {
1759      this.unsubscribe();
1760    }
1761  }, delay);
1762  parentSubscription.add(scheduleSubscription);
1763  if (!repeat) {
1764    return scheduleSubscription;
1765  }
1766}
1767var init_executeSchedule = __esm({
1768  "node_modules/rxjs/dist/esm/internal/util/executeSchedule.js"() {
1769    "use strict";
1770  }
1771});
1772

1773// node_modules/rxjs/dist/esm/internal/operators/observeOn.js
1774function observeOn(scheduler2, delay = 0) {
1775  return operate((source, subscriber) => {
1776    source.subscribe(createOperatorSubscriber(subscriber, (value) => executeSchedule(subscriber, scheduler2, () => subscriber.next(value), delay), () => executeSchedule(subscriber, scheduler2, () => subscriber.complete(), delay), (err) => executeSchedule(subscriber, scheduler2, () => subscriber.error(err), delay)));
1777  });
1778}
1779var init_observeOn = __esm({
1780  "node_modules/rxjs/dist/esm/internal/operators/observeOn.js"() {
1781    "use strict";
1782    init_executeSchedule();
1783    init_lift();
1784    init_OperatorSubscriber();
1785  }
1786});
1787

1788// node_modules/rxjs/dist/esm/internal/operators/subscribeOn.js
1789function subscribeOn(scheduler2, delay = 0) {
1790  return operate((source, subscriber) => {
1791    subscriber.add(scheduler2.schedule(() => source.subscribe(subscriber), delay));
1792  });
1793}
1794var init_subscribeOn = __esm({
1795  "node_modules/rxjs/dist/esm/internal/operators/subscribeOn.js"() {
1796    "use strict";
1797    init_lift();
1798  }
1799});
1800

1801// node_modules/rxjs/dist/esm/internal/scheduled/scheduleObservable.js
1802function scheduleObservable(input2, scheduler2) {
1803  return innerFrom(input2).pipe(subscribeOn(scheduler2), observeOn(scheduler2));
1804}
1805var init_scheduleObservable = __esm({
1806  "node_modules/rxjs/dist/esm/internal/scheduled/scheduleObservable.js"() {
1807    "use strict";
1808    init_innerFrom();
1809    init_observeOn();
1810    init_subscribeOn();
1811  }
1812});
1813

1814// node_modules/rxjs/dist/esm/internal/scheduled/schedulePromise.js
1815function schedulePromise(input2, scheduler2) {
1816  return innerFrom(input2).pipe(subscribeOn(scheduler2), observeOn(scheduler2));
1817}
1818var init_schedulePromise = __esm({
1819  "node_modules/rxjs/dist/esm/internal/scheduled/schedulePromise.js"() {
1820    "use strict";
1821    init_innerFrom();
1822    init_observeOn();
1823    init_subscribeOn();
1824  }
1825});
1826

1827// node_modules/rxjs/dist/esm/internal/scheduled/scheduleArray.js
1828function scheduleArray(input2, scheduler2) {
1829  return new Observable((subscriber) => {
1830    let i = 0;
1831    return scheduler2.schedule(function() {
1832      if (i === input2.length) {
1833        subscriber.complete();
1834      } else {
1835        subscriber.next(input2[i++]);
1836        if (!subscriber.closed) {
1837          this.schedule();
1838        }
1839      }
1840    });
1841  });
1842}
1843var init_scheduleArray = __esm({
1844  "node_modules/rxjs/dist/esm/internal/scheduled/scheduleArray.js"() {
1845    "use strict";
1846    init_Observable();
1847  }
1848});
1849

1850// node_modules/rxjs/dist/esm/internal/scheduled/scheduleIterable.js
1851function scheduleIterable(input2, scheduler2) {
1852  return new Observable((subscriber) => {
1853    let iterator2;
1854    executeSchedule(subscriber, scheduler2, () => {
1855      iterator2 = input2[iterator]();
1856      executeSchedule(subscriber, scheduler2, () => {
1857        let value;
1858        let done;
1859        try {
1860          ({ value, done } = iterator2.next());
1861        } catch (err) {
1862          subscriber.error(err);
1863          return;
1864        }
1865        if (done) {
1866          subscriber.complete();
1867        } else {
1868          subscriber.next(value);
1869        }
1870      }, 0, true);
1871    });
1872    return () => isFunction(iterator2 === null || iterator2 === void 0 ? void 0 : iterator2.return) && iterator2.return();
1873  });
1874}
1875var init_scheduleIterable = __esm({
1876  "node_modules/rxjs/dist/esm/internal/scheduled/scheduleIterable.js"() {
1877    "use strict";
1878    init_Observable();
1879    init_iterator();
1880    init_isFunction();
1881    init_executeSchedule();
1882  }
1883});
1884

1885// node_modules/rxjs/dist/esm/internal/scheduled/scheduleAsyncIterable.js
1886function scheduleAsyncIterable(input2, scheduler2) {
1887  if (!input2) {
1888    throw new Error("Iterable cannot be null");
1889  }
1890  return new Observable((subscriber) => {
1891    executeSchedule(subscriber, scheduler2, () => {
1892      const iterator2 = input2[Symbol.asyncIterator]();
1893      executeSchedule(subscriber, scheduler2, () => {
1894        iterator2.next().then((result) => {
1895          if (result.done) {
1896            subscriber.complete();
1897          } else {
1898            subscriber.next(result.value);
1899          }
1900        });
1901      }, 0, true);
1902    });
1903  });
1904}
1905var init_scheduleAsyncIterable = __esm({
1906  "node_modules/rxjs/dist/esm/internal/scheduled/scheduleAsyncIterable.js"() {
1907    "use strict";
1908    init_Observable();
1909    init_executeSchedule();
1910  }
1911});
1912

1913// node_modules/rxjs/dist/esm/internal/scheduled/scheduleReadableStreamLike.js
1914function scheduleReadableStreamLike(input2, scheduler2) {
1915  return scheduleAsyncIterable(readableStreamLikeToAsyncGenerator(input2), scheduler2);
1916}
1917var init_scheduleReadableStreamLike = __esm({
1918  "node_modules/rxjs/dist/esm/internal/scheduled/scheduleReadableStreamLike.js"() {
1919    "use strict";
1920    init_scheduleAsyncIterable();
1921    init_isReadableStreamLike();
1922  }
1923});
1924

1925// node_modules/rxjs/dist/esm/internal/scheduled/scheduled.js
1926function scheduled(input2, scheduler2) {
1927  if (input2 != null) {
1928    if (isInteropObservable(input2)) {
1929      return scheduleObservable(input2, scheduler2);
1930    }
1931    if (isArrayLike(input2)) {
1932      return scheduleArray(input2, scheduler2);
1933    }
1934    if (isPromise(input2)) {
1935      return schedulePromise(input2, scheduler2);
1936    }
1937    if (isAsyncIterable(input2)) {
1938      return scheduleAsyncIterable(input2, scheduler2);
1939    }
1940    if (isIterable(input2)) {
1941      return scheduleIterable(input2, scheduler2);
1942    }
1943    if (isReadableStreamLike(input2)) {
1944      return scheduleReadableStreamLike(input2, scheduler2);
1945    }
1946  }
1947  throw createInvalidObservableTypeError(input2);
1948}
1949var init_scheduled = __esm({
1950  "node_modules/rxjs/dist/esm/internal/scheduled/scheduled.js"() {
1951    "use strict";
1952    init_scheduleObservable();
1953    init_schedulePromise();
1954    init_scheduleArray();
1955    init_scheduleIterable();
1956    init_scheduleAsyncIterable();
1957    init_isInteropObservable();
1958    init_isPromise();
1959    init_isArrayLike();
1960    init_isIterable();
1961    init_isAsyncIterable();
1962    init_throwUnobservableError();
1963    init_isReadableStreamLike();
1964    init_scheduleReadableStreamLike();
1965  }
1966});
1967

1968// node_modules/rxjs/dist/esm/internal/observable/from.js
1969function from(input2, scheduler2) {
1970  return scheduler2 ? scheduled(input2, scheduler2) : innerFrom(input2);
1971}
1972var init_from = __esm({
1973  "node_modules/rxjs/dist/esm/internal/observable/from.js"() {
1974    "use strict";
1975    init_scheduled();
1976    init_innerFrom();
1977  }
1978});
1979

1980// node_modules/rxjs/dist/esm/internal/observable/of.js
1981function of(...args) {
1982  const scheduler2 = popScheduler(args);
1983  return from(args, scheduler2);
1984}
1985var init_of = __esm({
1986  "node_modules/rxjs/dist/esm/internal/observable/of.js"() {
1987    "use strict";
1988    init_args();
1989    init_from();
1990  }
1991});
1992

1993// node_modules/rxjs/dist/esm/internal/operators/map.js
1994function map(project, thisArg) {
1995  return operate((source, subscriber) => {
1996    let index = 0;
1997    source.subscribe(createOperatorSubscriber(subscriber, (value) => {
1998      subscriber.next(project.call(thisArg, value, index++));
1999    }));
2000  });
2001}
2002var init_map = __esm({
2003  "node_modules/rxjs/dist/esm/internal/operators/map.js"() {
2004    "use strict";
2005    init_lift();
2006    init_OperatorSubscriber();
2007  }
2008});
2009

2010// node_modules/rxjs/dist/esm/internal/operators/mergeInternals.js
2011function mergeInternals(source, subscriber, project, concurrent, onBeforeNext, expand, innerSubScheduler, additionalFinalizer) {
2012  const buffer = [];
2013  let active = 0;
2014  let index = 0;
2015  let isComplete = false;
2016  const checkComplete = () => {
2017    if (isComplete && !buffer.length && !active) {
2018      subscriber.complete();
2019    }
2020  };
2021  const outerNext = (value) => active < concurrent ? doInnerSub(value) : buffer.push(value);
2022  const doInnerSub = (value) => {
2023    expand && subscriber.next(value);
2024    active++;
2025    let innerComplete = false;
2026    innerFrom(project(value, index++)).subscribe(createOperatorSubscriber(subscriber, (innerValue) => {
2027      onBeforeNext === null || onBeforeNext === void 0 ? void 0 : onBeforeNext(innerValue);
2028      if (expand) {
2029        outerNext(innerValue);
2030      } else {
2031        subscriber.next(innerValue);
2032      }
2033    }, () => {
2034      innerComplete = true;
2035    }, void 0, () => {
2036      if (innerComplete) {
2037        try {
2038          active--;
2039          while (buffer.length && active < concurrent) {
2040            const bufferedValue = buffer.shift();
2041            if (innerSubScheduler) {
2042              executeSchedule(subscriber, innerSubScheduler, () => doInnerSub(bufferedValue));
2043            } else {
2044              doInnerSub(bufferedValue);
2045            }
2046          }
2047          checkComplete();
2048        } catch (err) {
2049          subscriber.error(err);
2050        }
2051      }
2052    }));
2053  };
2054  source.subscribe(createOperatorSubscriber(subscriber, outerNext, () => {
2055    isComplete = true;
2056    checkComplete();
2057  }));
2058  return () => {
2059    additionalFinalizer === null || additionalFinalizer === void 0 ? void 0 : additionalFinalizer();
2060  };
2061}
2062var init_mergeInternals = __esm({
2063  "node_modules/rxjs/dist/esm/internal/operators/mergeInternals.js"() {
2064    "use strict";
2065    init_innerFrom();
2066    init_executeSchedule();
2067    init_OperatorSubscriber();
2068  }
2069});
2070

2071// node_modules/rxjs/dist/esm/internal/operators/mergeMap.js
2072function mergeMap(project, resultSelector, concurrent = Infinity) {
2073  if (isFunction(resultSelector)) {
2074    return mergeMap((a, i) => map((b, ii) => resultSelector(a, b, i, ii))(innerFrom(project(a, i))), concurrent);
2075  } else if (typeof resultSelector === "number") {
2076    concurrent = resultSelector;
2077  }
2078  return operate((source, subscriber) => mergeInternals(source, subscriber, project, concurrent));
2079}
2080var init_mergeMap = __esm({
2081  "node_modules/rxjs/dist/esm/internal/operators/mergeMap.js"() {
2082    "use strict";
2083    init_map();
2084    init_innerFrom();
2085    init_lift();
2086    init_mergeInternals();
2087    init_isFunction();
2088  }
2089});
2090

2091// node_modules/rxjs/dist/esm/internal/operators/mergeAll.js
2092function mergeAll(concurrent = Infinity) {
2093  return mergeMap(identity, concurrent);
2094}
2095var init_mergeAll = __esm({
2096  "node_modules/rxjs/dist/esm/internal/operators/mergeAll.js"() {
2097    "use strict";
2098    init_mergeMap();
2099    init_identity();
2100  }
2101});
2102

2103// node_modules/rxjs/dist/esm/internal/observable/merge.js
2104function merge(...args) {
2105  const scheduler2 = popScheduler(args);
2106  const concurrent = popNumber(args, Infinity);
2107  const sources = args;
2108  return !sources.length ? EMPTY : sources.length === 1 ? innerFrom(sources[0]) : mergeAll(concurrent)(from(sources, scheduler2));
2109}
2110var init_merge = __esm({
2111  "node_modules/rxjs/dist/esm/internal/observable/merge.js"() {
2112    "use strict";
2113    init_mergeAll();
2114    init_innerFrom();
2115    init_empty();
2116    init_args();
2117    init_from();
2118  }
2119});
2120

2121// node_modules/rxjs/dist/esm/internal/operators/filter.js
2122function filter(predicate, thisArg) {
2123  return operate((source, subscriber) => {
2124    let index = 0;
2125    source.subscribe(createOperatorSubscriber(subscriber, (value) => predicate.call(thisArg, value, index++) && subscriber.next(value)));
2126  });
2127}
2128var init_filter = __esm({
2129  "node_modules/rxjs/dist/esm/internal/operators/filter.js"() {
2130    "use strict";
2131    init_lift();
2132    init_OperatorSubscriber();
2133  }
2134});
2135

2136// node_modules/rxjs/dist/esm/internal/types.js
2137var init_types = __esm({
2138  "node_modules/rxjs/dist/esm/internal/types.js"() {
2139    "use strict";
2140  }
2141});
2142

2143// node_modules/rxjs/dist/esm/internal/operators/concatMap.js
2144function concatMap(project, resultSelector) {
2145  return isFunction(resultSelector) ? mergeMap(project, resultSelector, 1) : mergeMap(project, 1);
2146}
2147var init_concatMap = __esm({
2148  "node_modules/rxjs/dist/esm/internal/operators/concatMap.js"() {
2149    "use strict";
2150    init_mergeMap();
2151    init_isFunction();
2152  }
2153});
2154

2155// node_modules/rxjs/dist/esm/internal/operators/finalize.js
2156function finalize(callback) {
2157  return operate((source, subscriber) => {
2158    try {
2159      source.subscribe(subscriber);
2160    } finally {
2161      subscriber.add(callback);
2162    }
2163  });
2164}
2165var init_finalize = __esm({
2166  "node_modules/rxjs/dist/esm/internal/operators/finalize.js"() {
2167    "use strict";
2168    init_lift();
2169  }
2170});
2171

2172// node_modules/rxjs/dist/esm/internal/operators/switchMap.js
2173function switchMap(project, resultSelector) {
2174  return operate((source, subscriber) => {
2175    let innerSubscriber = null;
2176    let index = 0;
2177    let isComplete = false;
2178    const checkComplete = () => isComplete && !innerSubscriber && subscriber.complete();
2179    source.subscribe(createOperatorSubscriber(subscriber, (value) => {
2180      innerSubscriber === null || innerSubscriber === void 0 ? void 0 : innerSubscriber.unsubscribe();
2181      let innerIndex = 0;
2182      const outerIndex = index++;
2183      innerFrom(project(value, outerIndex)).subscribe(innerSubscriber = createOperatorSubscriber(subscriber, (innerValue) => subscriber.next(resultSelector ? resultSelector(value, innerValue, outerIndex, innerIndex++) : innerValue), () => {
2184        innerSubscriber = null;
2185        checkComplete();
2186      }));
2187    }, () => {
2188      isComplete = true;
2189      checkComplete();
2190    }));
2191  });
2192}
2193var init_switchMap = __esm({
2194  "node_modules/rxjs/dist/esm/internal/operators/switchMap.js"() {
2195    "use strict";
2196    init_innerFrom();
2197    init_lift();
2198    init_OperatorSubscriber();
2199  }
2200});
2201

2202// node_modules/rxjs/dist/esm/index.js
2203var init_esm = __esm({
2204  "node_modules/rxjs/dist/esm/index.js"() {
2205    "use strict";
2206    init_Observable();
2207    init_Subject();
2208    init_BehaviorSubject();
2209    init_ReplaySubject();
2210    init_Subscription();
2211    init_merge();
2212    init_of();
2213    init_types();
2214  }
2215});
2216

2217// node_modules/@angular/core/fesm2022/effect.mjs
2218function createLinkedSignal(sourceFn, computationFn, equalityFn) {
2219  const node = Object.create(LINKED_SIGNAL_NODE);
2220  node.source = sourceFn;
2221  node.computation = computationFn;
2222  if (equalityFn != void 0) {
2223    node.equal = equalityFn;
2224  }
2225  const linkedSignalGetter = () => {
2226    producerUpdateValueVersion(node);
2227    producerAccessed(node);
2228    if (node.value === ERRORED) {
2229      throw node.error;
2230    }
2231    return node.value;
2232  };
2233  const getter = linkedSignalGetter;
2234  getter[SIGNAL] = node;
2235  if (typeof ngDevMode !== "undefined" && ngDevMode) {
2236    const debugName = node.debugName ? " (" + node.debugName + ")" : "";
2237    getter.toString = () => `[LinkedSignal${debugName}: ${node.value}]`;
2238  }
2239  runPostProducerCreatedFn(node);
2240  return getter;
2241}
2242function linkedSignalSetFn(node, newValue) {
2243  producerUpdateValueVersion(node);
2244  signalSetFn(node, newValue);
2245  producerMarkClean(node);
2246}
2247function linkedSignalUpdateFn(node, updater) {
2248  producerUpdateValueVersion(node);
2249  signalUpdateFn(node, updater);
2250  producerMarkClean(node);
2251}
2252function untracked(nonReactiveReadsFn) {
2253  const prevConsumer = setActiveConsumer(null);
2254  try {
2255    return nonReactiveReadsFn();
2256  } finally {
2257    setActiveConsumer(prevConsumer);
2258  }
2259}
2260function runEffect(node) {
2261  node.dirty = false;
2262  if (node.version > 0 && !consumerPollProducersForChange(node)) {
2263    return;
2264  }
2265  node.version++;
2266  const prevNode = consumerBeforeComputation(node);
2267  try {
2268    node.cleanup();
2269    node.fn();
2270  } finally {
2271    consumerAfterComputation(node, prevNode);
2272  }
2273}
2274var LINKED_SIGNAL_NODE, BASE_EFFECT_NODE;
2275var init_effect = __esm({
2276  "node_modules/@angular/core/fesm2022/effect.mjs"() {
2277    "use strict";
2278    init_signal();
2279    LINKED_SIGNAL_NODE = /* @__PURE__ */ (() => {
2280      return __spreadProps(__spreadValues({}, REACTIVE_NODE), {
2281        value: UNSET,
2282        dirty: true,
2283        error: null,
2284        equal: defaultEquals,
2285        kind: "linkedSignal",
2286        producerMustRecompute(node) {
2287          return node.value === UNSET || node.value === COMPUTING;
2288        },
2289        producerRecomputeValue(node) {
2290          if (node.value === COMPUTING) {
2291            throw new Error(typeof ngDevMode !== "undefined" && ngDevMode ? "Detected cycle in computations." : "");
2292          }
2293          const oldValue = node.value;
2294          node.value = COMPUTING;
2295          const prevConsumer = consumerBeforeComputation(node);
2296          let newValue;
2297          try {
2298            const newSourceValue = node.source();
2299            const prev = oldValue === UNSET || oldValue === ERRORED ? void 0 : {
2300              source: node.sourceValue,
2301              value: oldValue
2302            };
2303            newValue = node.computation(newSourceValue, prev);
2304            node.sourceValue = newSourceValue;
2305          } catch (err) {
2306            newValue = ERRORED;
2307            node.error = err;
2308          } finally {
2309            consumerAfterComputation(node, prevConsumer);
2310          }
2311          if (oldValue !== UNSET && newValue !== ERRORED && node.equal(oldValue, newValue)) {
2312            node.value = oldValue;
2313            return;
2314          }
2315          node.value = newValue;
2316          node.version++;
2317        }
2318      });
2319    })();
2320    BASE_EFFECT_NODE = /* @__PURE__ */ (() => __spreadProps(__spreadValues({}, REACTIVE_NODE), {
2321      consumerIsAlwaysLive: true,
2322      consumerAllowSignalWrites: true,
2323      dirty: true,
2324      kind: "effect"
2325    }))();
2326  }
2327});
2328

2329// node_modules/@angular/core/fesm2022/primitives/signals.mjs
2330function prettifyPreview(value) {
2331  if (value === null)
2332    return "null";
2333  if (Array.isArray(value))
2334    return `Array(${value.length})`;
2335  if (value instanceof Element)
2336    return `<${value.tagName.toLowerCase()}>`;
2337  if (value instanceof URL)
2338    return `URL`;
2339  switch (typeof value) {
2340    case "undefined": {
2341      return "undefined";
2342    }
2343    case "function": {
2344      if ("prototype" in value) {
2345        return "class";
2346      } else {
2347        return "() => {\u2026}";
2348      }
2349    }
2350    case "object": {
2351      if (value.constructor.name === "Object") {
2352        return "{\u2026}";
2353      } else {
2354        return `${value.constructor.name} {}`;
2355      }
2356    }
2357    default: {
2358      return ["object", { object: value, config: { skipFormatting: true } }];
2359    }
2360  }
2361}
2362function isSignal(value) {
2363  return value[SIGNAL] !== void 0;
2364}
2365function installDevToolsSignalFormatter() {
2366  globalThis.devtoolsFormatters ??= [];
2367  if (!globalThis.devtoolsFormatters.some((f) => f === formatter)) {
2368    globalThis.devtoolsFormatters.push(formatter);
2369  }
2370}
2371var formatter;
2372var init_signals = __esm({
2373  "node_modules/@angular/core/fesm2022/primitives/signals.mjs"() {
2374    "use strict";
2375    init_signal();
2376    init_signal();
2377    formatter = {
2378      /**
2379       *  If the function returns `null`, the formatter is not used for this reference
2380       */
2381      header: (sig, config2) => {
2382        if (!isSignal(sig) || config2?.ngSkipFormatting)
2383          return null;
2384        let value;
2385        try {
2386          value = sig();
2387        } catch {
2388          return ["span", "Signal(\u26A0\uFE0F Error)"];
2389        }
2390        const kind = "computation" in sig[SIGNAL] ? "Computed" : "Signal";
2391        const isPrimitive = value === null || !Array.isArray(value) && typeof value !== "object";
2392        return [
2393          "span",
2394          {},
2395          ["span", {}, `${kind}(`],
2396          (() => {
2397            if (isSignal(value)) {
2398              return formatter.header(value, config2);
2399            } else if (isPrimitive && value !== void 0 && typeof value !== "function") {
2400              return ["object", { object: value }];
2401            } else {
2402              return prettifyPreview(value);
2403            }
2404          })(),
2405          ["span", {}, `)`]
2406        ];
2407      },
2408      hasBody: (sig, config2) => {
2409        if (!isSignal(sig))
2410          return false;
2411        try {
2412          sig();
2413        } catch {
2414          return false;
2415        }
2416        return !config2?.ngSkipFormatting;
2417      },
2418      body: (sig, config2) => {
2419        const color = "var(--sys-color-primary)";
2420        return [
2421          "div",
2422          { style: `background: #FFFFFF10; padding-left: 4px; padding-top: 2px; padding-bottom: 2px;` },
2423          ["div", { style: `color: ${color}` }, "Signal value: "],
2424          ["div", { style: `padding-left: .5rem;` }, ["object", { object: sig(), config: config2 }]],
2425          ["div", { style: `color: ${color}` }, "Signal function: "],
2426          [
2427            "div",
2428            { style: `padding-left: .5rem;` },
2429            ["object", { object: sig, config: __spreadProps(__spreadValues({}, config2), { skipFormatting: true }) }]
2430          ]
2431        ];
2432      }
2433    };
2434    if (typeof ngDevMode !== "undefined" && ngDevMode) {
2435      installDevToolsSignalFormatter();
2436    }
2437  }
2438});
2439

2440// node_modules/@angular/core/fesm2022/primitives/di.mjs
2441var init_di = __esm({
2442  "node_modules/@angular/core/fesm2022/primitives/di.mjs"() {
2443    "use strict";
2444    init_not_found();
2445  }
2446});
2447

2448// node_modules/@angular/core/fesm2022/root_effect_scheduler.mjs
2449function formatRuntimeErrorCode(code) {
2450  return `NG0${Math.abs(code)}`;
2451}
2452function formatRuntimeError(code, message) {
2453  const fullCode = formatRuntimeErrorCode(code);
2454  let errorMessage = `${fullCode}${message ? ": " + message : ""}`;
2455  if (ngDevMode && code < 0) {
2456    const addPeriodSeparator = !errorMessage.match(/[.,;!?\n]$/);
2457    const separator = addPeriodSeparator ? "." : "";
2458    errorMessage = `${errorMessage}${separator} Find more at ${ERROR_DETAILS_PAGE_BASE_URL}/${fullCode}`;
2459  }
2460  return errorMessage;
2461}
2462function ngDevModeResetPerfCounters() {
2463  const locationString = typeof location !== "undefined" ? location.toString() : "";
2464  const newCounters = {
2465    hydratedNodes: 0,
2466    hydratedComponents: 0,
2467    dehydratedViewsRemoved: 0,
2468    dehydratedViewsCleanupRuns: 0,
2469    componentsSkippedHydration: 0,
2470    deferBlocksWithIncrementalHydration: 0
2471  };
2472  const allowNgDevModeTrue = locationString.indexOf("ngDevMode=false") === -1;
2473  if (!allowNgDevModeTrue) {
2474    _global["ngDevMode"] = false;
2475  } else {
2476    if (typeof _global["ngDevMode"] !== "object") {
2477      _global["ngDevMode"] = {};
2478    }
2479    Object.assign(_global["ngDevMode"], newCounters);
2480  }
2481  return newCounters;
2482}
2483function initNgDevMode() {
2484  if (typeof ngDevMode === "undefined" || ngDevMode) {
2485    if (typeof ngDevMode !== "object" || Object.keys(ngDevMode).length === 0) {
2486      ngDevModeResetPerfCounters();
2487    }
2488    return typeof ngDevMode !== "undefined" && !!ngDevMode;
2489  }
2490  return false;
2491}
2492function getClosureSafeProperty(objWithPropertyToExtract) {
2493  for (let key in objWithPropertyToExtract) {
2494    if (objWithPropertyToExtract[key] === getClosureSafeProperty) {
2495      return key;
2496    }
2497  }
2498  throw Error(typeof ngDevMode !== "undefined" && ngDevMode ? "Could not find renamed property on target object." : "");
2499}
2500function fillProperties(target, source) {
2501  for (const key in source) {
2502    if (source.hasOwnProperty(key) && !target.hasOwnProperty(key)) {
2503      target[key] = source[key];
2504    }
2505  }
2506}
2507function stringify(token) {
2508  if (typeof token === "string") {
2509    return token;
2510  }
2511  if (Array.isArray(token)) {
2512    return `[${token.map(stringify).join(", ")}]`;
2513  }
2514  if (token == null) {
2515    return "" + token;
2516  }
2517  const name = token.overriddenName || token.name;
2518  if (name) {
2519    return `${name}`;
2520  }
2521  const result = token.toString();
2522  if (result == null) {
2523    return "" + result;
2524  }
2525  const newLineIndex = result.indexOf("\n");
2526  return newLineIndex >= 0 ? result.slice(0, newLineIndex) : result;
2527}
2528function concatStringsWithSpace(before, after) {
2529  if (!before)
2530    return after || "";
2531  if (!after)
2532    return before;
2533  return `${before} ${after}`;
2534}
2535function forwardRef(forwardRefFn) {
2536  forwardRefFn.__forward_ref__ = forwardRef;
2537  forwardRefFn.toString = function() {
2538    return stringify(this());
2539  };
2540  return forwardRefFn;
2541}
2542function resolveForwardRef(type) {
2543  return isForwardRef(type) ? type() : type;
2544}
2545function isForwardRef(fn) {
2546  return typeof fn === "function" && fn.hasOwnProperty(__forward_ref__) && fn.__forward_ref__ === forwardRef;
2547}
2548function assertNumber(actual, msg) {
2549  if (!(typeof actual === "number")) {
2550    throwError(msg, typeof actual, "number", "===");
2551  }
2552}
2553function assertNumberInRange(actual, minInclusive, maxInclusive) {
2554  assertNumber(actual, "Expected a number");
2555  assertLessThanOrEqual(actual, maxInclusive, "Expected number to be less than or equal to");
2556  assertGreaterThanOrEqual(actual, minInclusive, "Expected number to be greater than or equal to");
2557}
2558function assertString(actual, msg) {
2559  if (!(typeof actual === "string")) {
2560    throwError(msg, actual === null ? "null" : typeof actual, "string", "===");
2561  }
2562}
2563function assertFunction(actual, msg) {
2564  if (!(typeof actual === "function")) {
2565    throwError(msg, actual === null ? "null" : typeof actual, "function", "===");
2566  }
2567}
2568function assertEqual(actual, expected, msg) {
2569  if (!(actual == expected)) {
2570    throwError(msg, actual, expected, "==");
2571  }
2572}
2573function assertNotEqual(actual, expected, msg) {
2574  if (!(actual != expected)) {
2575    throwError(msg, actual, expected, "!=");
2576  }
2577}
2578function assertSame(actual, expected, msg) {
2579  if (!(actual === expected)) {
2580    throwError(msg, actual, expected, "===");
2581  }
2582}
2583function assertNotSame(actual, expected, msg) {
2584  if (!(actual !== expected)) {
2585    throwError(msg, actual, expected, "!==");
2586  }
2587}
2588function assertLessThan(actual, expected, msg) {
2589  if (!(actual < expected)) {
2590    throwError(msg, actual, expected, "<");
2591  }
2592}
2593function assertLessThanOrEqual(actual, expected, msg) {
2594  if (!(actual <= expected)) {
2595    throwError(msg, actual, expected, "<=");
2596  }
2597}
2598function assertGreaterThan(actual, expected, msg) {
2599  if (!(actual > expected)) {
2600    throwError(msg, actual, expected, ">");
2601  }
2602}
2603function assertGreaterThanOrEqual(actual, expected, msg) {
2604  if (!(actual >= expected)) {
2605    throwError(msg, actual, expected, ">=");
2606  }
2607}
2608function assertDefined(actual, msg) {
2609  if (actual == null) {
2610    throwError(msg, actual, null, "!=");
2611  }
2612}
2613function throwError(msg, actual, expected, comparison) {
2614  throw new Error(`ASSERTION ERROR: ${msg}` + (comparison == null ? "" : ` [Expected=> ${expected} ${comparison} ${actual} <=Actual]`));
2615}
2616function assertDomNode(node) {
2617  if (!(node instanceof Node)) {
2618    throwError(`The provided value must be an instance of a DOM Node but got ${stringify(node)}`);
2619  }
2620}
2621function assertElement(node) {
2622  if (!(node instanceof Element)) {
2623    throwError(`The provided value must be an element but got ${stringify(node)}`);
2624  }
2625}
2626function assertIndexInRange(arr, index) {
2627  assertDefined(arr, "Array must be defined.");
2628  const maxLen = arr.length;
2629  if (index < 0 || index >= maxLen) {
2630    throwError(`Index expected to be less than ${maxLen} but got ${index}`);
2631  }
2632}
2633function assertOneOf(value, ...validValues) {
2634  if (validValues.indexOf(value) !== -1)
2635    return true;
2636  throwError(`Expected value to be one of ${JSON.stringify(validValues)} but was ${JSON.stringify(value)}.`);
2637}
2638function assertNotReactive(fn) {
2639  if (getActiveConsumer() !== null) {
2640    throwError(`${fn}() should never be called in a reactive context.`);
2641  }
2642}
2643function \u0275\u0275defineInjectable(opts) {
2644  return {
2645    token: opts.token,
2646    providedIn: opts.providedIn || null,
2647    factory: opts.factory,
2648    value: void 0
2649  };
2650}
2651function \u0275\u0275defineInjector(options) {
2652  return { providers: options.providers || [], imports: options.imports || [] };
2653}
2654function getInjectableDef(type) {
2655  return getOwnDefinition(type, NG_PROV_DEF);
2656}
2657function getOwnDefinition(type, field) {
2658  return type.hasOwnProperty(field) && type[field] || null;
2659}
2660function getInheritedInjectableDef(type) {
2661  const def = type?.[NG_PROV_DEF] ?? null;
2662  if (def) {
2663    ngDevMode && console.warn(`DEPRECATED: DI is instantiating a token "${type.name}" that inherits its @Injectable decorator but does not provide one itself.
2664This will become an error in a future version of Angular. Please add @Injectable() to the "${type.name}" class.`);
2665    return def;
2666  } else {
2667    return null;
2668  }
2669}
2670function getInjectorDef(type) {
2671  return type && type.hasOwnProperty(NG_INJ_DEF) ? type[NG_INJ_DEF] : null;
2672}
2673function getInjectorProfilerContext() {
2674  !ngDevMode && throwError("getInjectorProfilerContext should never be called in production mode");
2675  return _injectorProfilerContext;
2676}
2677function setInjectorProfilerContext(context2) {
2678  !ngDevMode && throwError("setInjectorProfilerContext should never be called in production mode");
2679  const previous = _injectorProfilerContext;
2680  _injectorProfilerContext = context2;
2681  return previous;
2682}
2683function removeProfiler(profiler2) {
2684  const profilerIdx = injectorProfilerCallbacks.indexOf(profiler2);
2685  if (profilerIdx !== -1) {
2686    injectorProfilerCallbacks.splice(profilerIdx, 1);
2687  }
2688}
2689function setInjectorProfiler(injectorProfiler2) {
2690  !ngDevMode && throwError("setInjectorProfiler should never be called in production mode");
2691  if (injectorProfiler2 !== null) {
2692    if (!injectorProfilerCallbacks.includes(injectorProfiler2)) {
2693      injectorProfilerCallbacks.push(injectorProfiler2);
2694    }
2695    return () => removeProfiler(injectorProfiler2);
2696  } else {
2697    injectorProfilerCallbacks.length = 0;
2698    return NOOP_PROFILER_REMOVAL;
2699  }
2700}
2701function injectorProfiler(event) {
2702  !ngDevMode && throwError("Injector profiler should never be called in production mode");
2703  for (let i = 0; i < injectorProfilerCallbacks.length; i++) {
2704    const injectorProfilerCallback = injectorProfilerCallbacks[i];
2705    injectorProfilerCallback(event);
2706  }
2707}
2708function emitProviderConfiguredEvent(eventProvider, isViewProvider = false) {
2709  !ngDevMode && throwError("Injector profiler should never be called in production mode");
2710  let token;
2711  if (typeof eventProvider === "function") {
2712    token = eventProvider;
2713  } else if (eventProvider instanceof InjectionToken) {
2714    token = eventProvider;
2715  } else {
2716    token = resolveForwardRef(eventProvider.provide);
2717  }
2718  let provider = eventProvider;
2719  if (eventProvider instanceof InjectionToken) {
2720    provider = eventProvider.\u0275prov || eventProvider;
2721  }
2722  injectorProfiler({
2723    type: 2,
2724    context: getInjectorProfilerContext(),
2725    providerRecord: { token, provider, isViewProvider }
2726  });
2727}
2728function emitInjectorToCreateInstanceEvent(token) {
2729  !ngDevMode && throwError("Injector profiler should never be called in production mode");
2730  injectorProfiler({
2731    type: 4,
2732    context: getInjectorProfilerContext(),
2733    token
2734  });
2735}
2736function emitInstanceCreatedByInjectorEvent(instance) {
2737  !ngDevMode && throwError("Injector profiler should never be called in production mode");
2738  injectorProfiler({
2739    type: 1,
2740    context: getInjectorProfilerContext(),
2741    instance: { value: instance }
2742  });
2743}
2744function emitInjectEvent(token, value, flags) {
2745  !ngDevMode && throwError("Injector profiler should never be called in production mode");
2746  injectorProfiler({
2747    type: 0,
2748    context: getInjectorProfilerContext(),
2749    service: { token, value, flags }
2750  });
2751}
2752function emitEffectCreatedEvent(effect2) {
2753  !ngDevMode && throwError("Injector profiler should never be called in production mode");
2754  injectorProfiler({
2755    type: 3,
2756    context: getInjectorProfilerContext(),
2757    effect: effect2
2758  });
2759}
2760function runInInjectorProfilerContext(injector, token, callback) {
2761  !ngDevMode && throwError("runInInjectorProfilerContext should never be called in production mode");
2762  const prevInjectContext = setInjectorProfilerContext({ injector, token });
2763  try {
2764    callback();
2765  } finally {
2766    setInjectorProfilerContext(prevInjectContext);
2767  }
2768}
2769function isEnvironmentProviders(value) {
2770  return value && !!value.\u0275providers;
2771}
2772function renderStringify(value) {
2773  if (typeof value === "string")
2774    return value;
2775  if (value == null)
2776    return "";
2777  return String(value);
2778}
2779function stringifyForError(value) {
2780  if (typeof value === "function")
2781    return value.name || value.toString();
2782  if (typeof value === "object" && value != null && typeof value.type === "function") {
2783    return value.type.name || value.type.toString();
2784  }
2785  return renderStringify(value);
2786}
2787function cyclicDependencyError(token, path) {
2788  const message = ngDevMode ? `Circular dependency detected for \`${token}\`.` : "";
2789  return createRuntimeError(message, -200, path);
2790}
2791function cyclicDependencyErrorWithDetails(token, path) {
2792  return augmentRuntimeError(cyclicDependencyError(token, path), null);
2793}
2794function throwMixedMultiProviderError() {
2795  throw new Error(`Cannot mix multi providers and regular providers`);
2796}
2797function throwInvalidProviderError(ngModuleType, providers, provider) {
2798  if (ngModuleType && providers) {
2799    const providerDetail = providers.map((v) => v == provider ? "?" + provider + "?" : "...");
2800    throw new Error(`Invalid provider for the NgModule '${stringify(ngModuleType)}' - only instances of Provider and Type are allowed, got: [${providerDetail.join(", ")}]`);
2801  } else if (isEnvironmentProviders(provider)) {
2802    if (provider.\u0275fromNgModule) {
2803      throw new RuntimeError(207, `Invalid providers from 'importProvidersFrom' present in a non-environment injector. 'importProvidersFrom' can't be used for component providers.`);
2804    } else {
2805      throw new RuntimeError(207, `Invalid providers present in a non-environment injector. 'EnvironmentProviders' can't be used for component providers.`);
2806    }
2807  } else {
2808    throw new Error("Invalid provider");
2809  }
2810}
2811function throwProviderNotFoundError(token, injectorName) {
2812  const errorMessage = ngDevMode && `No provider for ${stringifyForError(token)} found${injectorName ? ` in ${injectorName}` : ""}`;
2813  throw new RuntimeError(-201, errorMessage);
2814}
2815function prependTokenToDependencyPath(error, token) {
2816  error[NG_TOKEN_PATH] ??= [];
2817  const currentPath = error[NG_TOKEN_PATH];
2818  let pathStr;
2819  if (typeof token === "object" && "multi" in token && token?.multi === true) {
2820    assertDefined(token.provide, "Token with multi: true should have a provide property");
2821    pathStr = stringifyForError(token.provide);
2822  } else {
2823    pathStr = stringifyForError(token);
2824  }
2825  if (currentPath[0] !== pathStr) {
2826    error[NG_TOKEN_PATH].unshift(pathStr);
2827  }
2828}
2829function augmentRuntimeError(error, source) {
2830  const tokenPath = error[NG_TOKEN_PATH];
2831  const errorCode = error[NG_RUNTIME_ERROR_CODE];
2832  const message = error[NG_RUNTIME_ERROR_MESSAGE] || error.message;
2833  error.message = formatErrorMessage(message, errorCode, tokenPath, source);
2834  return error;
2835}
2836function createRuntimeError(message, code, path) {
2837  const error = new RuntimeError(code, message);
2838  error[NG_RUNTIME_ERROR_CODE] = code;
2839  error[NG_RUNTIME_ERROR_MESSAGE] = message;
2840  if (path) {
2841    error[NG_TOKEN_PATH] = path;
2842  }
2843  return error;
2844}
2845function getRuntimeErrorCode(error) {
2846  return error[NG_RUNTIME_ERROR_CODE];
2847}
2848function formatErrorMessage(text, code, path = [], source = null) {
2849  let pathDetails = "";
2850  if (path && path.length > 1) {
2851    pathDetails = ` Path: ${path.join(" -> ")}.`;
2852  }
2853  const sourceDetails = source ? ` Source: ${source}.` : "";
2854  return formatRuntimeError(code, `${text}${sourceDetails}${pathDetails}`);
2855}
2856function getInjectImplementation() {
2857  return _injectImplementation;
2858}
2859function setInjectImplementation(impl) {
2860  const previous = _injectImplementation;
2861  _injectImplementation = impl;
2862  return previous;
2863}
2864function injectRootLimpMode(token, notFoundValue, flags) {
2865  const injectableDef = getInjectableDef(token);
2866  if (injectableDef && injectableDef.providedIn == "root") {
2867    return injectableDef.value === void 0 ? injectableDef.value = injectableDef.factory() : injectableDef.value;
2868  }
2869  if (flags & 8)
2870    return null;
2871  if (notFoundValue !== void 0)
2872    return notFoundValue;
2873  throwProviderNotFoundError(token, "Injector");
2874}
2875function assertInjectImplementationNotEqual(fn) {
2876  ngDevMode && assertNotEqual(_injectImplementation, fn, "Calling \u0275\u0275inject would cause infinite recursion");
2877}
2878function injectInjectorOnly(token, flags = 0) {
2879  const currentInjector = getCurrentInjector();
2880  if (currentInjector === void 0) {
2881    throw new RuntimeError(-203, ngDevMode && `The \`${stringify(token)}\` token injection failed. \`inject()\` function must be called from an injection context such as a constructor, a factory function, a field initializer, or a function used with \`runInInjectionContext\`.`);
2882  } else if (currentInjector === null) {
2883    return injectRootLimpMode(token, void 0, flags);
2884  } else {
2885    const options = convertToInjectOptions(flags);
2886    const value = currentInjector.retrieve(token, options);
2887    ngDevMode && emitInjectEvent(token, value, flags);
2888    if (isNotFound(value)) {
2889      if (options.optional) {
2890        return null;
2891      }
2892      throw value;
2893    }
2894    return value;
2895  }
2896}
2897function \u0275\u0275inject(token, flags = 0) {
2898  return (getInjectImplementation() || injectInjectorOnly)(resolveForwardRef(token), flags);
2899}
2900function \u0275\u0275invalidFactoryDep(index) {
2901  throw new RuntimeError(202, ngDevMode && `This constructor is not compatible with Angular Dependency Injection because its dependency at index ${index} of the parameter list is invalid.
2902This can happen if the dependency type is a primitive like a string or if an ancestor of this class is missing an Angular decorator.
2903
2904Please check that 1) the type for the parameter at index ${index} is correct and 2) the correct Angular decorators are defined for this class and its ancestors.`);
2905}
2906function inject2(token, options) {
2907  return \u0275\u0275inject(token, convertToBitFlags(options));
2908}
2909function convertToBitFlags(flags) {
2910  if (typeof flags === "undefined" || typeof flags === "number") {
2911    return flags;
2912  }
2913  return 0 | // comment to force a line break in the formatter
2914  (flags.optional && 8) | (flags.host && 1) | (flags.self && 2) | (flags.skipSelf && 4);
2915}
2916function convertToInjectOptions(flags) {
2917  return {
2918    optional: !!(flags & 8),
2919    host: !!(flags & 1),
2920    self: !!(flags & 2),
2921    skipSelf: !!(flags & 4)
2922  };
2923}
2924function injectArgs(types) {
2925  const args = [];
2926  for (let i = 0; i < types.length; i++) {
2927    const arg = resolveForwardRef(types[i]);
2928    if (Array.isArray(arg)) {
2929      if (arg.length === 0) {
2930        throw new RuntimeError(900, ngDevMode && "Arguments array must have arguments.");
2931      }
2932      let type = void 0;
2933      let flags = 0;
2934      for (let j = 0; j < arg.length; j++) {
2935        const meta = arg[j];
2936        const flag = getInjectFlag(meta);
2937        if (typeof flag === "number") {
2938          if (flag === -1) {
2939            type = meta.token;
2940          } else {
2941            flags |= flag;
2942          }
2943        } else {
2944          type = meta;
2945        }
2946      }
2947      args.push(\u0275\u0275inject(type, flags));
2948    } else {
2949      args.push(\u0275\u0275inject(arg));
2950    }
2951  }
2952  return args;
2953}
2954function attachInjectFlag(decorator, flag) {
2955  decorator[DI_DECORATOR_FLAG] = flag;
2956  decorator.prototype[DI_DECORATOR_FLAG] = flag;
2957  return decorator;
2958}
2959function getInjectFlag(token) {
2960  return token[DI_DECORATOR_FLAG];
2961}
2962function getFactoryDef(type, throwNotFound) {
2963  const hasFactoryDef = type.hasOwnProperty(NG_FACTORY_DEF);
2964  if (!hasFactoryDef && throwNotFound === true && ngDevMode) {
2965    throw new Error(`Type ${stringify(type)} does not have '\u0275fac' property.`);
2966  }
2967  return hasFactoryDef ? type[NG_FACTORY_DEF] : null;
2968}
2969function arrayEquals(a, b, identityAccessor) {
2970  if (a.length !== b.length)
2971    return false;
2972  for (let i = 0; i < a.length; i++) {
2973    let valueA = a[i];
2974    let valueB = b[i];
2975    if (identityAccessor) {
2976      valueA = identityAccessor(valueA);
2977      valueB = identityAccessor(valueB);
2978    }
2979    if (valueB !== valueA) {
2980      return false;
2981    }
2982  }
2983  return true;
2984}
2985function flatten(list) {
2986  return list.flat(Number.POSITIVE_INFINITY);
2987}
2988function deepForEach(input2, fn) {
2989  input2.forEach((value) => Array.isArray(value) ? deepForEach(value, fn) : fn(value));
2990}
2991function addToArray(arr, index, value) {
2992  if (index >= arr.length) {
2993    arr.push(value);
2994  } else {
2995    arr.splice(index, 0, value);
2996  }
2997}
2998function removeFromArray(arr, index) {
2999  if (index >= arr.length - 1) {
3000    return arr.pop();
3001  } else {
3002    return arr.splice(index, 1)[0];
3003  }
3004}
3005function newArray(size, value) {
3006  const list = [];
3007  for (let i = 0; i < size; i++) {
3008    list.push(value);
3009  }
3010  return list;
3011}
3012function arraySplice(array, index, count) {
3013  const length = array.length - count;
3014  while (index < length) {
3015    array[index] = array[index + count];
3016    index++;
3017  }
3018  while (count--) {
3019    array.pop();
3020  }
3021}
3022function arrayInsert2(array, index, value1, value2) {
3023  ngDevMode && assertLessThanOrEqual(index, array.length, "Can't insert past array end.");
3024  let end = array.length;
3025  if (end == index) {
3026    array.push(value1, value2);
3027  } else if (end === 1) {
3028    array.push(value2, array[0]);
3029    array[0] = value1;
3030  } else {
3031    end--;
3032    array.push(array[end - 1], array[end]);
3033    while (end > index) {
3034      const previousEnd = end - 2;
3035      array[end] = array[previousEnd];
3036      end--;
3037    }
3038    array[index] = value1;
3039    array[index + 1] = value2;
3040  }
3041}
3042function keyValueArraySet(keyValueArray, key, value) {
3043  let index = keyValueArrayIndexOf(keyValueArray, key);
3044  if (index >= 0) {
3045    keyValueArray[index | 1] = value;
3046  } else {
3047    index = ~index;
3048    arrayInsert2(keyValueArray, index, key, value);
3049  }
3050  return index;
3051}
3052function keyValueArrayGet(keyValueArray, key) {
3053  const index = keyValueArrayIndexOf(keyValueArray, key);
3054  if (index >= 0) {
3055    return keyValueArray[index | 1];
3056  }
3057  return void 0;
3058}
3059function keyValueArrayIndexOf(keyValueArray, key) {
3060  return _arrayIndexOfSorted(keyValueArray, key, 1);
3061}
3062function _arrayIndexOfSorted(array, value, shift) {
3063  ngDevMode && assertEqual(Array.isArray(array), true, "Expecting an array");
3064  let start = 0;
3065  let end = array.length >> shift;
3066  while (end !== start) {
3067    const middle = start + (end - start >> 1);
3068    const current = array[middle << shift];
3069    if (value === current) {
3070      return middle << shift;
3071    } else if (current > value) {
3072      end = middle;
3073    } else {
3074      start = middle + 1;
3075    }
3076  }
3077  return ~(end << shift);
3078}
3079function getNgModuleDef(type) {
3080  return type[NG_MOD_DEF] || null;
3081}
3082function getNgModuleDefOrThrow(type) {
3083  const ngModuleDef = getNgModuleDef(type);
3084  if (!ngModuleDef) {
3085    throw new RuntimeError(915, (typeof ngDevMode === "undefined" || ngDevMode) && `Type ${stringify(type)} does not have '\u0275mod' property.`);
3086  }
3087  return ngModuleDef;
3088}
3089function getComponentDef(type) {
3090  return type[NG_COMP_DEF] || null;
3091}
3092function getDirectiveDefOrThrow(type) {
3093  const def = getDirectiveDef(type);
3094  if (!def) {
3095    throw new RuntimeError(916, (typeof ngDevMode === "undefined" || ngDevMode) && `Type ${stringify(type)} does not have '\u0275dir' property.`);
3096  }
3097  return def;
3098}
3099function getDirectiveDef(type) {
3100  return type[NG_DIR_DEF] || null;
3101}
3102function getPipeDef(type) {
3103  return type[NG_PIPE_DEF] || null;
3104}
3105function isStandalone(type) {
3106  const def = getComponentDef(type) || getDirectiveDef(type) || getPipeDef(type);
3107  return def !== null && def.standalone;
3108}
3109function makeEnvironmentProviders(providers) {
3110  return {
3111    \u0275providers: providers
3112  };
3113}
3114function importProvidersFrom(...sources) {
3115  return {
3116    \u0275providers: internalImportProvidersFrom(true, sources),
3117    \u0275fromNgModule: true
3118  };
3119}
3120function internalImportProvidersFrom(checkForStandaloneCmp, ...sources) {
3121  const providersOut = [];
3122  const dedup = /* @__PURE__ */ new Set();
3123  let injectorTypesWithProviders;
3124  const collectProviders = (provider) => {
3125    providersOut.push(provider);
3126  };
3127  deepForEach(sources, (source) => {
3128    if ((typeof ngDevMode === "undefined" || ngDevMode) && checkForStandaloneCmp) {
3129      const cmpDef = getComponentDef(source);
3130      if (cmpDef?.standalone) {
3131        throw new RuntimeError(800, `Importing providers supports NgModule or ModuleWithProviders but got a standalone component "${stringifyForError(source)}"`);
3132      }
3133    }
3134    const internalSource = source;
3135    if (walkProviderTree(internalSource, collectProviders, [], dedup)) {
3136      injectorTypesWithProviders ||= [];
3137      injectorTypesWithProviders.push(internalSource);
3138    }
3139  });
3140  if (injectorTypesWithProviders !== void 0) {
3141    processInjectorTypesWithProviders(injectorTypesWithProviders, collectProviders);
3142  }
3143  return providersOut;
3144}
3145function processInjectorTypesWithProviders(typesWithProviders, visitor) {
3146  for (let i = 0; i < typesWithProviders.length; i++) {
3147    const { ngModule, providers } = typesWithProviders[i];
3148    deepForEachProvider(providers, (provider) => {
3149      ngDevMode && validateProvider(provider, providers || EMPTY_ARRAY, ngModule);
3150      visitor(provider, ngModule);
3151    });
3152  }
3153}
3154function walkProviderTree(container, visitor, parents, dedup) {
3155  container = resolveForwardRef(container);
3156  if (!container)
3157    return false;
3158  let defType = null;
3159  let injDef = getInjectorDef(container);
3160  const cmpDef = !injDef && getComponentDef(container);
3161  if (!injDef && !cmpDef) {
3162    const ngModule = container.ngModule;
3163    injDef = getInjectorDef(ngModule);
3164    if (injDef) {
3165      defType = ngModule;
3166    } else {
3167      return false;
3168    }
3169  } else if (cmpDef && !cmpDef.standalone) {
3170    return false;
3171  } else {
3172    defType = container;
3173  }
3174  if (ngDevMode && parents.indexOf(defType) !== -1) {
3175    const defName = stringify(defType);
3176    const path = parents.map(stringify).concat(defName);
3177    throw cyclicDependencyErrorWithDetails(defName, path);
3178  }
3179  const isDuplicate = dedup.has(defType);
3180  if (cmpDef) {
3181    if (isDuplicate) {
3182      return false;
3183    }
3184    dedup.add(defType);
3185    if (cmpDef.dependencies) {
3186      const deps = typeof cmpDef.dependencies === "function" ? cmpDef.dependencies() : cmpDef.dependencies;
3187      for (const dep of deps) {
3188        walkProviderTree(dep, visitor, parents, dedup);
3189      }
3190    }
3191  } else if (injDef) {
3192    if (injDef.imports != null && !isDuplicate) {
3193      ngDevMode && parents.push(defType);
3194      dedup.add(defType);
3195      let importTypesWithProviders;
3196      try {
3197        deepForEach(injDef.imports, (imported) => {
3198          if (walkProviderTree(imported, visitor, parents, dedup)) {
3199            importTypesWithProviders ||= [];
3200            importTypesWithProviders.push(imported);
3201          }
3202        });
3203      } finally {
3204        ngDevMode && parents.pop();
3205      }
3206      if (importTypesWithProviders !== void 0) {
3207        processInjectorTypesWithProviders(importTypesWithProviders, visitor);
3208      }
3209    }
3210    if (!isDuplicate) {
3211      const factory = getFactoryDef(defType) || (() => new defType());
3212      visitor({ provide: defType, useFactory: factory, deps: EMPTY_ARRAY }, defType);
3213      visitor({ provide: INJECTOR_DEF_TYPES, useValue: defType, multi: true }, defType);
3214      visitor({ provide: ENVIRONMENT_INITIALIZER, useValue: () => \u0275\u0275inject(defType), multi: true }, defType);
3215    }
3216    const defProviders = injDef.providers;
3217    if (defProviders != null && !isDuplicate) {
3218      const injectorType = container;
3219      deepForEachProvider(defProviders, (provider) => {
3220        ngDevMode && validateProvider(provider, defProviders, injectorType);
3221        visitor(provider, injectorType);
3222      });
3223    }
3224  } else {
3225    return false;
3226  }
3227  return defType !== container && container.providers !== void 0;
3228}
3229function validateProvider(provider, providers, containerType) {
3230  if (isTypeProvider(provider) || isValueProvider(provider) || isFactoryProvider(provider) || isExistingProvider(provider)) {
3231    return;
3232  }
3233  const classRef = resolveForwardRef(provider && (provider.useClass || provider.provide));
3234  if (!classRef) {
3235    throwInvalidProviderError(containerType, providers, provider);
3236  }
3237}
3238function deepForEachProvider(providers, fn) {
3239  for (let provider of providers) {
3240    if (isEnvironmentProviders(provider)) {
3241      provider = provider.\u0275providers;
3242    }
3243    if (Array.isArray(provider)) {
3244      deepForEachProvider(provider, fn);
3245    } else {
3246      fn(provider);
3247    }
3248  }
3249}
3250function isValueProvider(value) {
3251  return value !== null && typeof value == "object" && USE_VALUE in value;
3252}
3253function isExistingProvider(value) {
3254  return !!(value && value.useExisting);
3255}
3256function isFactoryProvider(value) {
3257  return !!(value && value.useFactory);
3258}
3259function isTypeProvider(value) {
3260  return typeof value === "function";
3261}
3262function isClassProvider(value) {
3263  return !!value.useClass;
3264}
3265function getNullInjector() {
3266  if (NULL_INJECTOR === void 0) {
3267    NULL_INJECTOR = new NullInjector();
3268  }
3269  return NULL_INJECTOR;
3270}
3271function injectableDefOrInjectorDefFactory(token) {
3272  const injectableDef = getInjectableDef(token);
3273  const factory = injectableDef !== null ? injectableDef.factory : getFactoryDef(token);
3274  if (factory !== null) {
3275    return factory;
3276  }
3277  if (token instanceof InjectionToken) {
3278    throw new RuntimeError(204, ngDevMode && `Token ${stringify(token)} is missing a \u0275prov definition.`);
3279  }
3280  if (token instanceof Function) {
3281    return getUndecoratedInjectableFactory(token);
3282  }
3283  throw new RuntimeError(204, ngDevMode && "unreachable");
3284}
3285function getUndecoratedInjectableFactory(token) {
3286  const paramLength = token.length;
3287  if (paramLength > 0) {
3288    throw new RuntimeError(204, ngDevMode && `Can't resolve all parameters for ${stringify(token)}: (${newArray(paramLength, "?").join(", ")}).`);
3289  }
3290  const inheritedInjectableDef = getInheritedInjectableDef(token);
3291  if (inheritedInjectableDef !== null) {
3292    return () => inheritedInjectableDef.factory(token);
3293  } else {
3294    return () => new token();
3295  }
3296}
3297function providerToRecord(provider) {
3298  if (isValueProvider(provider)) {
3299    return makeRecord(void 0, provider.useValue);
3300  } else {
3301    const factory = providerToFactory(provider);
3302    return makeRecord(factory, NOT_YET);
3303  }
3304}
3305function providerToFactory(provider, ngModuleType, providers) {
3306  let factory = void 0;
3307  if (ngDevMode && isEnvironmentProviders(provider)) {
3308    throwInvalidProviderError(void 0, providers, provider);
3309  }
3310  if (isTypeProvider(provider)) {
3311    const unwrappedProvider = resolveForwardRef(provider);
3312    return getFactoryDef(unwrappedProvider) || injectableDefOrInjectorDefFactory(unwrappedProvider);
3313  } else {
3314    if (isValueProvider(provider)) {
3315      factory = () => resolveForwardRef(provider.useValue);
3316    } else if (isFactoryProvider(provider)) {
3317      factory = () => provider.useFactory(...injectArgs(provider.deps || []));
3318    } else if (isExistingProvider(provider)) {
3319      factory = (_, flags) => \u0275\u0275inject(resolveForwardRef(provider.useExisting), flags !== void 0 && flags & 8 ? 8 : void 0);
3320    } else {
3321      const classRef = resolveForwardRef(provider && (provider.useClass || provider.provide));
3322      if (ngDevMode && !classRef) {
3323        throwInvalidProviderError(ngModuleType, providers, provider);
3324      }
3325      if (hasDeps(provider)) {
3326        factory = () => new classRef(...injectArgs(provider.deps));
3327      } else {
3328        return getFactoryDef(classRef) || injectableDefOrInjectorDefFactory(classRef);
3329      }
3330    }
3331  }
3332  return factory;
3333}
3334function assertNotDestroyed(injector) {
3335  if (injector.destroyed) {
3336    throw new RuntimeError(205, ngDevMode && "Injector has already been destroyed.");
3337  }
3338}
3339function makeRecord(factory, value, multi = false) {
3340  return {
3341    factory,
3342    value,
3343    multi: multi ? [] : void 0
3344  };
3345}
3346function hasDeps(value) {
3347  return !!value.deps;
3348}
3349function hasOnDestroy(value) {
3350  return value !== null && typeof value === "object" && typeof value.ngOnDestroy === "function";
3351}
3352function couldBeInjectableType(value) {
3353  return typeof value === "function" || typeof value === "object" && value.ngMetadataName === "InjectionToken";
3354}
3355function forEachSingleProvider(providers, fn) {
3356  for (const provider of providers) {
3357    if (Array.isArray(provider)) {
3358      forEachSingleProvider(provider, fn);
3359    } else if (provider && isEnvironmentProviders(provider)) {
3360      forEachSingleProvider(provider.\u0275providers, fn);
3361    } else {
3362      fn(provider);
3363    }
3364  }
3365}
3366function runInInjectionContext(injector, fn) {
3367  let internalInjector;
3368  if (injector instanceof R3Injector) {
3369    assertNotDestroyed(injector);
3370    internalInjector = injector;
3371  } else {
3372    internalInjector = new RetrievingInjector(injector);
3373  }
3374  let prevInjectorProfilerContext;
3375  if (ngDevMode) {
3376    prevInjectorProfilerContext = setInjectorProfilerContext({ injector, token: null });
3377  }
3378  const prevInjector = setCurrentInjector(internalInjector);
3379  const previousInjectImplementation = setInjectImplementation(void 0);
3380  try {
3381    return fn();
3382  } finally {
3383    setCurrentInjector(prevInjector);
3384    ngDevMode && setInjectorProfilerContext(prevInjectorProfilerContext);
3385    setInjectImplementation(previousInjectImplementation);
3386  }
3387}
3388function isInInjectionContext() {
3389  return getInjectImplementation() !== void 0 || getCurrentInjector() != null;
3390}
3391function assertInInjectionContext(debugFn) {
3392  if (!isInInjectionContext()) {
3393    throw new RuntimeError(-203, ngDevMode && debugFn.name + "() can only be used within an injection context such as a constructor, a factory function, a field initializer, or a function used with `runInInjectionContext`");
3394  }
3395}
3396function isLView(value) {
3397  return Array.isArray(value) && typeof value[TYPE] === "object";
3398}
3399function isLContainer(value) {
3400  return Array.isArray(value) && value[TYPE] === true;
3401}
3402function isContentQueryHost(tNode) {
3403  return (tNode.flags & 4) !== 0;
3404}
3405function isComponentHost(tNode) {
3406  return tNode.componentOffset > -1;
3407}
3408function isDirectiveHost(tNode) {
3409  return (tNode.flags & 1) === 1;
3410}
3411function isComponentDef(def) {
3412  return !!def.template;
3413}
3414function isRootView(target) {
3415  return (target[FLAGS] & 512) !== 0;
3416}
3417function isDestroyed(lView) {
3418  return (lView[FLAGS] & 256) === 256;
3419}
3420function assertTNodeForLView(tNode, lView) {
3421  assertTNodeForTView(tNode, lView[TVIEW]);
3422}
3423function assertTNodeCreationIndex(lView, index) {
3424  const adjustedIndex = index + HEADER_OFFSET;
3425  assertIndexInRange(lView, adjustedIndex);
3426  assertLessThan(adjustedIndex, lView[TVIEW].bindingStartIndex, "TNodes should be created before any bindings");
3427}
3428function assertTNodeForTView(tNode, tView) {
3429  assertTNode(tNode);
3430  const tData = tView.data;
3431  for (let i = HEADER_OFFSET; i < tData.length; i++) {
3432    if (tData[i] === tNode) {
3433      return;
3434    }
3435  }
3436  throwError("This TNode does not belong to this TView.");
3437}
3438function assertTNode(tNode) {
3439  assertDefined(tNode, "TNode must be defined");
3440  if (!(tNode && typeof tNode === "object" && tNode.hasOwnProperty("directiveStylingLast"))) {
3441    throwError("Not of type TNode, got: " + tNode);
3442  }
3443}
3444function assertTIcu(tIcu) {
3445  assertDefined(tIcu, "Expected TIcu to be defined");
3446  if (!(typeof tIcu.currentCaseLViewIndex === "number")) {
3447    throwError("Object is not of TIcu type.");
3448  }
3449}
3450function assertComponentType(actual, msg = "Type passed in is not ComponentType, it does not have '\u0275cmp' property.") {
3451  if (!getComponentDef(actual)) {
3452    throwError(msg);
3453  }
3454}
3455function assertNgModuleType(actual, msg = "Type passed in is not NgModuleType, it does not have '\u0275mod' property.") {
3456  if (!getNgModuleDef(actual)) {
3457    throwError(msg);
3458  }
3459}
3460function assertHasParent(tNode) {
3461  assertDefined(tNode, "currentTNode should exist!");
3462  assertDefined(tNode.parent, "currentTNode should have a parent");
3463}
3464function assertLContainer(value) {
3465  assertDefined(value, "LContainer must be defined");
3466  assertEqual(isLContainer(value), true, "Expecting LContainer");
3467}
3468function assertLViewOrUndefined(value) {
3469  value && assertEqual(isLView(value), true, "Expecting LView or undefined or null");
3470}
3471function assertLView(value) {
3472  assertDefined(value, "LView must be defined");
3473  assertEqual(isLView(value), true, "Expecting LView");
3474}
3475function assertFirstCreatePass(tView, errMessage) {
3476  assertEqual(tView.firstCreatePass, true, errMessage || "Should only be called in first create pass.");
3477}
3478function assertFirstUpdatePass(tView, errMessage) {
3479  assertEqual(tView.firstUpdatePass, true, "Should only be called in first update pass.");
3480}
3481function assertDirectiveDef(obj) {
3482  if (obj.type === void 0 || obj.selectors == void 0 || obj.inputs === void 0) {
3483    throwError(`Expected a DirectiveDef/ComponentDef and this object does not seem to have the expected shape.`);
3484  }
3485}
3486function assertIndexInDeclRange(tView, index) {
3487  assertBetween(HEADER_OFFSET, tView.bindingStartIndex, index);
3488}
3489function assertIndexInExpandoRange(lView, index) {
3490  const tView = lView[1];
3491  assertBetween(tView.expandoStartIndex, lView.length, index);
3492}
3493function assertBetween(lower, upper, index) {
3494  if (!(lower <= index && index < upper)) {
3495    throwError(`Index out of range (expecting ${lower} <= ${index} < ${upper})`);
3496  }
3497}
3498function assertProjectionSlots(lView, errMessage) {
3499  assertDefined(lView[DECLARATION_COMPONENT_VIEW], "Component views should exist.");
3500  assertDefined(lView[DECLARATION_COMPONENT_VIEW][T_HOST].projection, "Components with projection nodes (<ng-content>) must have projection slots defined.");
3501}
3502function assertParentView(lView, errMessage) {
3503  assertDefined(lView, "Component views should always have a parent view (component's host view)");
3504}
3505function assertNodeInjector(lView, injectorIndex) {
3506  assertIndexInExpandoRange(lView, injectorIndex);
3507  assertIndexInExpandoRange(
3508    lView,
3509    injectorIndex + 8
3510    /* NodeInjectorOffset.PARENT */
3511  );
3512  assertNumber(lView[injectorIndex + 0], "injectorIndex should point to a bloom filter");
3513  assertNumber(lView[injectorIndex + 1], "injectorIndex should point to a bloom filter");
3514  assertNumber(lView[injectorIndex + 2], "injectorIndex should point to a bloom filter");
3515  assertNumber(lView[injectorIndex + 3], "injectorIndex should point to a bloom filter");
3516  assertNumber(lView[injectorIndex + 4], "injectorIndex should point to a bloom filter");
3517  assertNumber(lView[injectorIndex + 5], "injectorIndex should point to a bloom filter");
3518  assertNumber(lView[injectorIndex + 6], "injectorIndex should point to a bloom filter");
3519  assertNumber(lView[injectorIndex + 7], "injectorIndex should point to a bloom filter");
3520  assertNumber(lView[
3521    injectorIndex + 8
3522    /* NodeInjectorOffset.PARENT */
3523  ], "injectorIndex should point to parent injector");
3524}
3525function unwrapRNode(value) {
3526  while (Array.isArray(value)) {
3527    value = value[HOST];
3528  }
3529  return value;
3530}
3531function unwrapLView(value) {
3532  while (Array.isArray(value)) {
3533    if (typeof value[TYPE] === "object")
3534      return value;
3535    value = value[HOST];
3536  }
3537  return null;
3538}
3539function getNativeByIndex(index, lView) {
3540  ngDevMode && assertIndexInRange(lView, index);
3541  ngDevMode && assertGreaterThanOrEqual(index, HEADER_OFFSET, "Expected to be past HEADER_OFFSET");
3542  return unwrapRNode(lView[index]);
3543}
3544function getNativeByTNode(tNode, lView) {
3545  ngDevMode && assertTNodeForLView(tNode, lView);
3546  ngDevMode && assertIndexInRange(lView, tNode.index);
3547  const node = unwrapRNode(lView[tNode.index]);
3548  return node;
3549}
3550function getTNode(tView, index) {
3551  ngDevMode && assertGreaterThan(index, -1, "wrong index for TNode");
3552  ngDevMode && assertLessThan(index, tView.data.length, "wrong index for TNode");
3553  const tNode = tView.data[index];
3554  ngDevMode && tNode !== null && assertTNode(tNode);
3555  return tNode;
3556}
3557function load(view, index) {
3558  ngDevMode && assertIndexInRange(view, index);
3559  return view[index];
3560}
3561function store(tView, lView, index, value) {
3562  if (index >= tView.data.length) {
3563    tView.data[index] = null;
3564    tView.blueprint[index] = null;
3565  }
3566  lView[index] = value;
3567}
3568function getComponentLViewByIndex(nodeIndex, hostView) {
3569  ngDevMode && assertIndexInRange(hostView, nodeIndex);
3570  const slotValue = hostView[nodeIndex];
3571  const lView = isLView(slotValue) ? slotValue : slotValue[HOST];
3572  return lView;
3573}
3574function isCreationMode(view) {
3575  return (view[FLAGS] & 4) === 4;
3576}
3577function viewAttachedToChangeDetector(view) {
3578  return (view[FLAGS] & 128) === 128;
3579}
3580function viewAttachedToContainer(view) {
3581  return isLContainer(view[PARENT]);
3582}
3583function getConstant(consts, index) {
3584  if (index === null || index === void 0)
3585    return null;
3586  ngDevMode && assertIndexInRange(consts, index);
3587  return consts[index];
3588}
3589function resetPreOrderHookFlags(lView) {
3590  lView[PREORDER_HOOK_FLAGS] = 0;
3591}
3592function markViewForRefresh(lView) {
3593  if (lView[FLAGS] & 1024) {
3594    return;
3595  }
3596  lView[FLAGS] |= 1024;
3597  if (viewAttachedToChangeDetector(lView)) {
3598    markAncestorsForTraversal(lView);
3599  }
3600}
3601function walkUpViews(nestingLevel, currentView) {
3602  while (nestingLevel > 0) {
3603    ngDevMode && assertDefined(currentView[DECLARATION_VIEW], "Declaration view should be defined if nesting level is greater than 0.");
3604    currentView = currentView[DECLARATION_VIEW];
3605    nestingLevel--;
3606  }
3607  return currentView;
3608}
3609function requiresRefreshOrTraversal(lView) {
3610  return !!(lView[FLAGS] & (1024 | 8192) || lView[REACTIVE_TEMPLATE_CONSUMER]?.dirty);
3611}
3612function updateAncestorTraversalFlagsOnAttach(lView) {
3613  lView[ENVIRONMENT].changeDetectionScheduler?.notify(
3614    8
3615    /* NotificationSource.ViewAttached */
3616  );
3617  if (lView[FLAGS] & 64) {
3618    lView[FLAGS] |= 1024;
3619  }
3620  if (requiresRefreshOrTraversal(lView)) {
3621    markAncestorsForTraversal(lView);
3622  }
3623}
3624function markAncestorsForTraversal(lView) {
3625  lView[ENVIRONMENT].changeDetectionScheduler?.notify(
3626    0
3627    /* NotificationSource.MarkAncestorsForTraversal */
3628  );
3629  let parent = getLViewParent(lView);
3630  while (parent !== null) {
3631    if (parent[FLAGS] & 8192) {
3632      break;
3633    }
3634    parent[FLAGS] |= 8192;
3635    if (!viewAttachedToChangeDetector(parent)) {
3636      break;
3637    }
3638    parent = getLViewParent(parent);
3639  }
3640}
3641function storeLViewOnDestroy(lView, onDestroyCallback) {
3642  if (isDestroyed(lView)) {
3643    throw new RuntimeError(911, ngDevMode && "View has already been destroyed.");
3644  }
3645  if (lView[ON_DESTROY_HOOKS] === null) {
3646    lView[ON_DESTROY_HOOKS] = [];
3647  }
3648  lView[ON_DESTROY_HOOKS].push(onDestroyCallback);
3649}
3650function removeLViewOnDestroy(lView, onDestroyCallback) {
3651  if (lView[ON_DESTROY_HOOKS] === null)
3652    return;
3653  const destroyCBIdx = lView[ON_DESTROY_HOOKS].indexOf(onDestroyCallback);
3654  if (destroyCBIdx !== -1) {
3655    lView[ON_DESTROY_HOOKS].splice(destroyCBIdx, 1);
3656  }
3657}
3658function getLViewParent(lView) {
3659  ngDevMode && assertLView(lView);
3660  const parent = lView[PARENT];
3661  return isLContainer(parent) ? parent[PARENT] : parent;
3662}
3663function getOrCreateLViewCleanup(view) {
3664  return view[CLEANUP] ??= [];
3665}
3666function getOrCreateTViewCleanup(tView) {
3667  return tView.cleanup ??= [];
3668}
3669function storeCleanupWithContext(tView, lView, context2, cleanupFn) {
3670  const lCleanup = getOrCreateLViewCleanup(lView);
3671  ngDevMode && assertDefined(context2, "Cleanup context is mandatory when registering framework-level destroy hooks");
3672  lCleanup.push(context2);
3673  if (tView.firstCreatePass) {
3674    getOrCreateTViewCleanup(tView).push(cleanupFn, lCleanup.length - 1);
3675  } else {
3676    if (ngDevMode) {
3677      Object.freeze(getOrCreateTViewCleanup(tView));
3678    }
3679  }
3680}
3681function getElementDepthCount() {
3682  return instructionState.lFrame.elementDepthCount;
3683}
3684function increaseElementDepthCount() {
3685  instructionState.lFrame.elementDepthCount++;
3686}
3687function decreaseElementDepthCount() {
3688  instructionState.lFrame.elementDepthCount--;
3689}
3690function getBindingsEnabled() {
3691  return instructionState.bindingsEnabled;
3692}
3693function isInSkipHydrationBlock() {
3694  return instructionState.skipHydrationRootTNode !== null;
3695}
3696function isSkipHydrationRootTNode(tNode) {
3697  return instructionState.skipHydrationRootTNode === tNode;
3698}
3699function \u0275\u0275enableBindings() {
3700  instructionState.bindingsEnabled = true;
3701}
3702function \u0275\u0275disableBindings() {
3703  instructionState.bindingsEnabled = false;
3704}
3705function leaveSkipHydrationBlock() {
3706  instructionState.skipHydrationRootTNode = null;
3707}
3708function getLView() {
3709  return instructionState.lFrame.lView;
3710}
3711function getTView() {
3712  return instructionState.lFrame.tView;
3713}
3714function \u0275\u0275restoreView(viewToRestore) {
3715  instructionState.lFrame.contextLView = viewToRestore;
3716  return viewToRestore[CONTEXT];
3717}
3718function \u0275\u0275resetView(value) {
3719  instructionState.lFrame.contextLView = null;
3720  return value;
3721}
3722function getCurrentTNode() {
3723  let currentTNode = getCurrentTNodePlaceholderOk();
3724  while (currentTNode !== null && currentTNode.type === 64) {
3725    currentTNode = currentTNode.parent;
3726  }
3727  return currentTNode;
3728}
3729function getCurrentTNodePlaceholderOk() {
3730  return instructionState.lFrame.currentTNode;
3731}
3732function getCurrentParentTNode() {
3733  const lFrame = instructionState.lFrame;
3734  const currentTNode = lFrame.currentTNode;
3735  return lFrame.isParent ? currentTNode : currentTNode.parent;
3736}
3737function setCurrentTNode(tNode, isParent) {
3738  ngDevMode && tNode && assertTNodeForTView(tNode, instructionState.lFrame.tView);
3739  const lFrame = instructionState.lFrame;
3740  lFrame.currentTNode = tNode;
3741  lFrame.isParent = isParent;
3742}
3743function isCurrentTNodeParent() {
3744  return instructionState.lFrame.isParent;
3745}
3746function setCurrentTNodeAsNotParent() {
3747  instructionState.lFrame.isParent = false;
3748}
3749function getContextLView() {
3750  const contextLView = instructionState.lFrame.contextLView;
3751  ngDevMode && assertDefined(contextLView, "contextLView must be defined.");
3752  return contextLView;
3753}
3754function isInCheckNoChangesMode() {
3755  !ngDevMode && throwError("Must never be called in production mode");
3756  return _checkNoChangesMode !== CheckNoChangesMode.Off;
3757}
3758function isExhaustiveCheckNoChanges() {
3759  !ngDevMode && throwError("Must never be called in production mode");
3760  return _checkNoChangesMode === CheckNoChangesMode.Exhaustive;
3761}
3762function setIsInCheckNoChangesMode(mode) {
3763  !ngDevMode && throwError("Must never be called in production mode");
3764  _checkNoChangesMode = mode;
3765}
3766function isRefreshingViews() {
3767  return _isRefreshingViews;
3768}
3769function setIsRefreshingViews(mode) {
3770  const prev = _isRefreshingViews;
3771  _isRefreshingViews = mode;
3772  return prev;
3773}
3774function getBindingRoot() {
3775  const lFrame = instructionState.lFrame;
3776  let index = lFrame.bindingRootIndex;
3777  if (index === -1) {
3778    index = lFrame.bindingRootIndex = lFrame.tView.bindingStartIndex;
3779  }
3780  return index;
3781}
3782function getBindingIndex() {
3783  return instructionState.lFrame.bindingIndex;
3784}
3785function setBindingIndex(value) {
3786  return instructionState.lFrame.bindingIndex = value;
3787}
3788function nextBindingIndex() {
3789  return instructionState.lFrame.bindingIndex++;
3790}
3791function incrementBindingIndex(count) {
3792  const lFrame = instructionState.lFrame;
3793  const index = lFrame.bindingIndex;
3794  lFrame.bindingIndex = lFrame.bindingIndex + count;
3795  return index;
3796}
3797function isInI18nBlock() {
3798  return instructionState.lFrame.inI18n;
3799}
3800function setInI18nBlock(isInI18nBlock2) {
3801  instructionState.lFrame.inI18n = isInI18nBlock2;
3802}
3803function setBindingRootForHostBindings(bindingRootIndex, currentDirectiveIndex) {
3804  const lFrame = instructionState.lFrame;
3805  lFrame.bindingIndex = lFrame.bindingRootIndex = bindingRootIndex;
3806  setCurrentDirectiveIndex(currentDirectiveIndex);
3807}
3808function getCurrentDirectiveIndex() {
3809  return instructionState.lFrame.currentDirectiveIndex;
3810}
3811function setCurrentDirectiveIndex(currentDirectiveIndex) {
3812  instructionState.lFrame.currentDirectiveIndex = currentDirectiveIndex;
3813}
3814function getCurrentDirectiveDef(tData) {
3815  const currentDirectiveIndex = instructionState.lFrame.currentDirectiveIndex;
3816  return currentDirectiveIndex === -1 ? null : tData[currentDirectiveIndex];
3817}
3818function getCurrentQueryIndex() {
3819  return instructionState.lFrame.currentQueryIndex;
3820}
3821function setCurrentQueryIndex(value) {
3822  instructionState.lFrame.currentQueryIndex = value;
3823}
3824function getDeclarationTNode(lView) {
3825  const tView = lView[TVIEW];
3826  if (tView.type === 2) {
3827    ngDevMode && assertDefined(tView.declTNode, "Embedded TNodes should have declaration parents.");
3828    return tView.declTNode;
3829  }
3830  if (tView.type === 1) {
3831    return lView[T_HOST];
3832  }
3833  return null;
3834}
3835function enterDI(lView, tNode, flags) {
3836  ngDevMode && assertLViewOrUndefined(lView);
3837  if (flags & 4) {
3838    ngDevMode && assertTNodeForTView(tNode, lView[TVIEW]);
3839    let parentTNode = tNode;
3840    let parentLView = lView;
3841    while (true) {
3842      ngDevMode && assertDefined(parentTNode, "Parent TNode should be defined");
3843      parentTNode = parentTNode.parent;
3844      if (parentTNode === null && !(flags & 1)) {
3845        parentTNode = getDeclarationTNode(parentLView);
3846        if (parentTNode === null)
3847          break;
3848        ngDevMode && assertDefined(parentLView, "Parent LView should be defined");
3849        parentLView = parentLView[DECLARATION_VIEW];
3850        if (parentTNode.type & (2 | 8)) {
3851          break;
3852        }
3853      } else {
3854        break;
3855      }
3856    }
3857    if (parentTNode === null) {
3858      return false;
3859    } else {
3860      tNode = parentTNode;
3861      lView = parentLView;
3862    }
3863  }
3864  ngDevMode && assertTNodeForLView(tNode, lView);
3865  const lFrame = instructionState.lFrame = allocLFrame();
3866  lFrame.currentTNode = tNode;
3867  lFrame.lView = lView;
3868  return true;
3869}
3870function enterView(newView) {
3871  ngDevMode && assertNotEqual(newView[0], newView[1], "????");
3872  ngDevMode && assertLViewOrUndefined(newView);
3873  const newLFrame = allocLFrame();
3874  if (ngDevMode) {
3875    assertEqual(newLFrame.isParent, true, "Expected clean LFrame");
3876    assertEqual(newLFrame.lView, null, "Expected clean LFrame");
3877    assertEqual(newLFrame.tView, null, "Expected clean LFrame");
3878    assertEqual(newLFrame.selectedIndex, -1, "Expected clean LFrame");
3879    assertEqual(newLFrame.elementDepthCount, 0, "Expected clean LFrame");
3880    assertEqual(newLFrame.currentDirectiveIndex, -1, "Expected clean LFrame");
3881    assertEqual(newLFrame.currentNamespace, null, "Expected clean LFrame");
3882    assertEqual(newLFrame.bindingRootIndex, -1, "Expected clean LFrame");
3883    assertEqual(newLFrame.currentQueryIndex, 0, "Expected clean LFrame");
3884  }
3885  const tView = newView[TVIEW];
3886  instructionState.lFrame = newLFrame;
3887  ngDevMode && tView.firstChild && assertTNodeForTView(tView.firstChild, tView);
3888  newLFrame.currentTNode = tView.firstChild;
3889  newLFrame.lView = newView;
3890  newLFrame.tView = tView;
3891  newLFrame.contextLView = newView;
3892  newLFrame.bindingIndex = tView.bindingStartIndex;
3893  newLFrame.inI18n = false;
3894}
3895function allocLFrame() {
3896  const currentLFrame = instructionState.lFrame;
3897  const childLFrame = currentLFrame === null ? null : currentLFrame.child;
3898  const newLFrame = childLFrame === null ? createLFrame(currentLFrame) : childLFrame;
3899  return newLFrame;
3900}
3901function createLFrame(parent) {
3902  const lFrame = {
3903    currentTNode: null,
3904    isParent: true,
3905    lView: null,
3906    tView: null,
3907    selectedIndex: -1,
3908    contextLView: null,
3909    elementDepthCount: 0,
3910    currentNamespace: null,
3911    currentDirectiveIndex: -1,
3912    bindingRootIndex: -1,
3913    bindingIndex: -1,
3914    currentQueryIndex: 0,
3915    parent,
3916    child: null,
3917    inI18n: false
3918  };
3919  parent !== null && (parent.child = lFrame);
3920  return lFrame;
3921}
3922function leaveViewLight() {
3923  const oldLFrame = instructionState.lFrame;
3924  instructionState.lFrame = oldLFrame.parent;
3925  oldLFrame.currentTNode = null;
3926  oldLFrame.lView = null;
3927  return oldLFrame;
3928}
3929function leaveView() {
3930  const oldLFrame = leaveViewLight();
3931  oldLFrame.isParent = true;
3932  oldLFrame.tView = null;
3933  oldLFrame.selectedIndex = -1;
3934  oldLFrame.contextLView = null;
3935  oldLFrame.elementDepthCount = 0;
3936  oldLFrame.currentDirectiveIndex = -1;
3937  oldLFrame.currentNamespace = null;
3938  oldLFrame.bindingRootIndex = -1;
3939  oldLFrame.bindingIndex = -1;
3940  oldLFrame.currentQueryIndex = 0;
3941}
3942function nextContextImpl(level) {
3943  const contextLView = instructionState.lFrame.contextLView = walkUpViews(level, instructionState.lFrame.contextLView);
3944  return contextLView[CONTEXT];
3945}
3946function getSelectedIndex() {
3947  return instructionState.lFrame.selectedIndex;
3948}
3949function setSelectedIndex(index) {
3950  ngDevMode && index !== -1 && assertGreaterThanOrEqual(index, HEADER_OFFSET, "Index must be past HEADER_OFFSET (or -1).");
3951  ngDevMode && assertLessThan(index, instructionState.lFrame.lView.length, "Can't set index passed end of LView");
3952  instructionState.lFrame.selectedIndex = index;
3953}
3954function getSelectedTNode() {
3955  const lFrame = instructionState.lFrame;
3956  return getTNode(lFrame.tView, lFrame.selectedIndex);
3957}
3958function \u0275\u0275namespaceSVG() {
3959  instructionState.lFrame.currentNamespace = SVG_NAMESPACE;
3960}
3961function \u0275\u0275namespaceMathML() {
3962  instructionState.lFrame.currentNamespace = MATH_ML_NAMESPACE;
3963}
3964function \u0275\u0275namespaceHTML() {
3965  namespaceHTMLInternal();
3966}
3967function namespaceHTMLInternal() {
3968  instructionState.lFrame.currentNamespace = null;
3969}
3970function getNamespace() {
3971  return instructionState.lFrame.currentNamespace;
3972}
3973function wasLastNodeCreated() {
3974  return _wasLastNodeCreated;
3975}
3976function lastNodeWasCreated(flag) {
3977  _wasLastNodeCreated = flag;
3978}
3979function createInjector(defType, parent = null, additionalProviders = null, name) {
3980  const injector = createInjectorWithoutInjectorInstances(defType, parent, additionalProviders, name);
3981  injector.resolveInjectorInitializers();
3982  return injector;
3983}
3984function createInjectorWithoutInjectorInstances(defType, parent = null, additionalProviders = null, name, scopes = /* @__PURE__ */ new Set()) {
3985  const providers = [additionalProviders || EMPTY_ARRAY, importProvidersFrom(defType)];
3986  name = name || (typeof defType === "object" ? void 0 : stringify(defType));
3987  return new R3Injector(providers, parent || getNullInjector(), name || null, scopes);
3988}
3989function injectDestroyRef() {
3990  return new NodeInjectorDestroyRef(getLView());
3991}
3992function isSignal2(value) {
3993  return typeof value === "function" && value[SIGNAL] !== void 0;
3994}
3995function signal(initialValue, options) {
3996  const [get, set, update] = createSignal(initialValue, options?.equal);
3997  const signalFn = get;
3998  const node = signalFn[SIGNAL];
3999  signalFn.set = set;
4000  signalFn.update = update;
4001  signalFn.asReadonly = signalAsReadonlyFn.bind(signalFn);
4002  if (ngDevMode) {
4003    signalFn.toString = () => `[Signal: ${signalFn()}]`;
4004    node.debugName = options?.debugName;
4005  }
4006  return signalFn;
4007}
4008function signalAsReadonlyFn() {
4009  const node = this[SIGNAL];
4010  if (node.readonlyFn === void 0) {
4011    const readonlyFn = () => this();
4012    readonlyFn[SIGNAL] = node;
4013    node.readonlyFn = readonlyFn;
4014  }
4015  return node.readonlyFn;
4016}
4017function isWritableSignal(value) {
4018  return isSignal2(value) && typeof value.set === "function";
4019}
4020function assertNotInReactiveContext(debugFn, extraContext) {
4021  if (getActiveConsumer() !== null) {
4022    throw new RuntimeError(-602, ngDevMode && `${debugFn.name}() cannot be called from within a reactive context.${extraContext ? ` ${extraContext}` : ""}`);
4023  }
4024}
4025function injectViewContext() {
4026  return new ViewContext(getLView(), getCurrentTNode());
4027}
4028function noop2(...args) {
4029}
4030var Version, VERSION, ERROR_DETAILS_PAGE_BASE_URL, XSS_SECURITY_URL, RuntimeError, _global, __forward_ref__, NG_PROV_DEF, NG_INJ_DEF, InjectionToken, _injectorProfilerContext, injectorProfilerCallbacks, NOOP_PROFILER_REMOVAL, NG_COMP_DEF, NG_DIR_DEF, NG_PIPE_DEF, NG_MOD_DEF, NG_FACTORY_DEF, NG_ELEMENT_ID, NG_ENV_ID, NG_RUNTIME_ERROR_CODE, NG_RUNTIME_ERROR_MESSAGE, NG_TOKEN_PATH, _injectImplementation, _THROW_IF_NOT_FOUND, THROW_IF_NOT_FOUND, DI_DECORATOR_FLAG, RetrievingInjector, EMPTY_OBJ, EMPTY_ARRAY, ENVIRONMENT_INITIALIZER, INJECTOR$1, INJECTOR_DEF_TYPES, NullInjector, USE_VALUE, INJECTOR_SCOPE, NOT_YET, CIRCULAR, NULL_INJECTOR, EnvironmentInjector, R3Injector, HOST, TVIEW, FLAGS, PARENT, NEXT, T_HOST, HYDRATION, CLEANUP, CONTEXT, INJECTOR, ENVIRONMENT, RENDERER, CHILD_HEAD, CHILD_TAIL, DECLARATION_VIEW, DECLARATION_COMPONENT_VIEW, DECLARATION_LCONTAINER, PREORDER_HOOK_FLAGS, QUERIES, ID, EMBEDDED_VIEW_INJECTOR, ON_DESTROY_HOOKS, EFFECTS_TO_SCHEDULE, EFFECTS, REACTIVE_TEMPLATE_CONSUMER, AFTER_RENDER_SEQUENCES_TO_ADD, ANIMATIONS, HEADER_OFFSET, TYPE, DEHYDRATED_VIEWS, NATIVE, VIEW_REFS, MOVED_VIEWS, CONTAINER_HEADER_OFFSET, SVG_NAMESPACE, MATH_ML_NAMESPACE, instructionState, CheckNoChangesMode, _checkNoChangesMode, _isRefreshingViews, leaveDI, _wasLastNodeCreated, Injector, DOCUMENT, DestroyRef, NodeInjectorDestroyRef, ErrorHandler, INTERNAL_APPLICATION_ERROR_HANDLER, errorHandlerEnvironmentInitializer, globalErrorListeners, ViewContext, ChangeDetectionScheduler, ZONELESS_ENABLED, PROVIDED_ZONELESS, ZONELESS_SCHEDULER_DISABLED, SCHEDULE_IN_ROOT_ZONE, PendingTasksInternal, PendingTasks, EffectScheduler, ZoneAwareEffectScheduler;
4031var init_root_effect_scheduler = __esm({
4032  "node_modules/@angular/core/fesm2022/root_effect_scheduler.mjs"() {
4033    "use strict";
4034    init_not_found();
4035    init_signal();
4036    init_esm();
4037    init_signals();
4038    init_di();
4039    Version = class {
4040      full;
4041      major;
4042      minor;
4043      patch;
4044      constructor(full) {
4045        this.full = full;
4046        const parts = full.split(".");
4047        this.major = parts[0];
4048        this.minor = parts[1];
4049        this.patch = parts.slice(2).join(".");
4050      }
4051    };
4052    VERSION = /* @__PURE__ */ new Version("20.3.15");
4053    ERROR_DETAILS_PAGE_BASE_URL = (() => {
4054      const versionSubDomain = VERSION.major !== "0" ? `v${VERSION.major}.` : "";
4055      return `https://${versionSubDomain}angular.dev/errors`;
4056    })();
4057    XSS_SECURITY_URL = "https://angular.dev/best-practices/security#preventing-cross-site-scripting-xss";
4058    RuntimeError = class extends Error {
4059      code;
4060      constructor(code, message) {
4061        super(formatRuntimeError(code, message));
4062        this.code = code;
4063      }
4064    };
4065    _global = globalThis;
4066    __forward_ref__ = getClosureSafeProperty({ __forward_ref__: getClosureSafeProperty });
4067    NG_PROV_DEF = getClosureSafeProperty({ \u0275prov: getClosureSafeProperty });
4068    NG_INJ_DEF = getClosureSafeProperty({ \u0275inj: getClosureSafeProperty });
4069    InjectionToken = class {
4070      _desc;
4071      /** @internal */
4072      ngMetadataName = "InjectionToken";
4073      \u0275prov;
4074      /**
4075       * @param _desc   Description for the token,
4076       *                used only for debugging purposes,
4077       *                it should but does not need to be unique
4078       * @param options Options for the token's usage, as described above
4079       */
4080      constructor(_desc, options) {
4081        this._desc = _desc;
4082        this.\u0275prov = void 0;
4083        if (typeof options == "number") {
4084          (typeof ngDevMode === "undefined" || ngDevMode) && assertLessThan(options, 0, "Only negative numbers are supported here");
4085          this.__NG_ELEMENT_ID__ = options;
4086        } else if (options !== void 0) {
4087          this.\u0275prov = \u0275\u0275defineInjectable({
4088            token: this,
4089            providedIn: options.providedIn || "root",
4090            factory: options.factory
4091          });
4092        }
4093      }
4094      /**
4095       * @internal
4096       */
4097      get multi() {
4098        return this;
4099      }
4100      toString() {
4101        return `InjectionToken ${this._desc}`;
4102      }
4103    };
4104    injectorProfilerCallbacks = [];
4105    NOOP_PROFILER_REMOVAL = () => {
4106    };
4107    NG_COMP_DEF = getClosureSafeProperty({ \u0275cmp: getClosureSafeProperty });
4108    NG_DIR_DEF = getClosureSafeProperty({ \u0275dir: getClosureSafeProperty });
4109    NG_PIPE_DEF = getClosureSafeProperty({ \u0275pipe: getClosureSafeProperty });
4110    NG_MOD_DEF = getClosureSafeProperty({ \u0275mod: getClosureSafeProperty });
4111    NG_FACTORY_DEF = getClosureSafeProperty({ \u0275fac: getClosureSafeProperty });
4112    NG_ELEMENT_ID = getClosureSafeProperty({
4113      __NG_ELEMENT_ID__: getClosureSafeProperty
4114    });
4115    NG_ENV_ID = getClosureSafeProperty({ __NG_ENV_ID__: getClosureSafeProperty });
4116    NG_RUNTIME_ERROR_CODE = getClosureSafeProperty({ "ngErrorCode": getClosureSafeProperty });
4117    NG_RUNTIME_ERROR_MESSAGE = getClosureSafeProperty({ "ngErrorMessage": getClosureSafeProperty });
4118    NG_TOKEN_PATH = getClosureSafeProperty({ "ngTokenPath": getClosureSafeProperty });
4119    _THROW_IF_NOT_FOUND = {};
4120    THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;
4121    DI_DECORATOR_FLAG = "__NG_DI_FLAG__";
4122    RetrievingInjector = class {
4123      injector;
4124      constructor(injector) {
4125        this.injector = injector;
4126      }
4127      retrieve(token, options) {
4128        const flags = convertToBitFlags(options) || 0;
4129        try {
4130          return this.injector.get(
4131            token,
4132            // When a dependency is requested with an optional flag, DI returns null as the default value.
4133            flags & 8 ? null : THROW_IF_NOT_FOUND,
4134            flags
4135          );
4136        } catch (e) {
4137          if (isNotFound(e)) {
4138            return e;
4139          }
4140          throw e;
4141        }
4142      }
4143    };
4144    EMPTY_OBJ = {};
4145    EMPTY_ARRAY = [];
4146    if ((typeof ngDevMode === "undefined" || ngDevMode) && initNgDevMode()) {
4147      Object.freeze(EMPTY_OBJ);
4148      Object.freeze(EMPTY_ARRAY);
4149    }
4150    ENVIRONMENT_INITIALIZER = new InjectionToken(ngDevMode ? "ENVIRONMENT_INITIALIZER" : "");
4151    INJECTOR$1 = new InjectionToken(
4152      ngDevMode ? "INJECTOR" : "",
4153      // Disable tslint because this is const enum which gets inlined not top level prop access.
4154      // tslint:disable-next-line: no-toplevel-property-access
4155      -1
4156      /* InjectorMarkers.Injector */
4157    );
4158    INJECTOR_DEF_TYPES = new InjectionToken(ngDevMode ? "INJECTOR_DEF_TYPES" : "");
4159    NullInjector = class {
4160      get(token, notFoundValue = THROW_IF_NOT_FOUND) {
4161        if (notFoundValue === THROW_IF_NOT_FOUND) {
4162          const message = ngDevMode ? `No provider found for \`${stringify(token)}\`.` : "";
4163          const error = createRuntimeError(
4164            message,
4165            -201
4166            /* RuntimeErrorCode.PROVIDER_NOT_FOUND */
4167          );
4168          error.name = "\u0275NotFound";
4169          throw error;
4170        }
4171        return notFoundValue;
4172      }
4173    };
4174    USE_VALUE = getClosureSafeProperty({
4175      provide: String,
4176      useValue: getClosureSafeProperty
4177    });
4178    INJECTOR_SCOPE = new InjectionToken(ngDevMode ? "Set Injector scope." : "");
4179    NOT_YET = {};
4180    CIRCULAR = {};
4181    NULL_INJECTOR = void 0;
4182    EnvironmentInjector = class {
4183    };
4184    R3Injector = class extends EnvironmentInjector {
4185      parent;
4186      source;
4187      scopes;
4188      /**
4189       * Map of tokens to records which contain the instances of those tokens.
4190       * - `null` value implies that we don't have the record. Used by tree-shakable injectors
4191       * to prevent further searches.
4192       */
4193      records = /* @__PURE__ */ new Map();
4194      /**
4195       * Set of values instantiated by this injector which contain `ngOnDestroy` lifecycle hooks.
4196       */
4197      _ngOnDestroyHooks = /* @__PURE__ */ new Set();
4198      _onDestroyHooks = [];
4199      /**
4200       * Flag indicating that this injector was previously destroyed.
4201       */
4202      get destroyed() {
4203        return this._destroyed;
4204      }
4205      _destroyed = false;
4206      injectorDefTypes;
4207      constructor(providers, parent, source, scopes) {
4208        super();
4209        this.parent = parent;
4210        this.source = source;
4211        this.scopes = scopes;
4212        forEachSingleProvider(providers, (provider) => this.processProvider(provider));
4213        this.records.set(INJECTOR$1, makeRecord(void 0, this));
4214        if (scopes.has("environment")) {
4215          this.records.set(EnvironmentInjector, makeRecord(void 0, this));
4216        }
4217        const record = this.records.get(INJECTOR_SCOPE);
4218        if (record != null && typeof record.value === "string") {
4219          this.scopes.add(record.value);
4220        }
4221        this.injectorDefTypes = new Set(this.get(INJECTOR_DEF_TYPES, EMPTY_ARRAY, { self: true }));
4222      }
4223      retrieve(token, options) {
4224        const flags = convertToBitFlags(options) || 0;
4225        try {
4226          return this.get(
4227            token,
4228            // When a dependency is requested with an optional flag, DI returns null as the default value.
4229            THROW_IF_NOT_FOUND,
4230            flags
4231          );
4232        } catch (e) {
4233          if (isNotFound(e)) {
4234            return e;
4235          }
4236          throw e;
4237        }
4238      }
4239      /**
4240       * Destroy the injector and release references to every instance or provider associated with it.
4241       *
4242       * Also calls the `OnDestroy` lifecycle hooks of every instance that was created for which a
4243       * hook was found.
4244       */
4245      destroy() {
4246        assertNotDestroyed(this);
4247        this._destroyed = true;
4248        const prevConsumer = setActiveConsumer(null);
4249        try {
4250          for (const service of this._ngOnDestroyHooks) {
4251            service.ngOnDestroy();
4252          }
4253          const onDestroyHooks = this._onDestroyHooks;
4254          this._onDestroyHooks = [];
4255          for (const hook of onDestroyHooks) {
4256            hook();
4257          }
4258        } finally {
4259          this.records.clear();
4260          this._ngOnDestroyHooks.clear();
4261          this.injectorDefTypes.clear();
4262          setActiveConsumer(prevConsumer);
4263        }
4264      }
4265      onDestroy(callback) {
4266        assertNotDestroyed(this);
4267        this._onDestroyHooks.push(callback);
4268        return () => this.removeOnDestroy(callback);
4269      }
4270      runInContext(fn) {
4271        assertNotDestroyed(this);
4272        const previousInjector = setCurrentInjector(this);
4273        const previousInjectImplementation = setInjectImplementation(void 0);
4274        let prevInjectContext;
4275        if (ngDevMode) {
4276          prevInjectContext = setInjectorProfilerContext({ injector: this, token: null });
4277        }
4278        try {
4279          return fn();
4280        } finally {
4281          setCurrentInjector(previousInjector);
4282          setInjectImplementation(previousInjectImplementation);
4283          ngDevMode && setInjectorProfilerContext(prevInjectContext);
4284        }
4285      }
4286      get(token, notFoundValue = THROW_IF_NOT_FOUND, options) {
4287        assertNotDestroyed(this);
4288        if (token.hasOwnProperty(NG_ENV_ID)) {
4289          return token[NG_ENV_ID](this);
4290        }
4291        const flags = convertToBitFlags(options);
4292        let prevInjectContext;
4293        if (ngDevMode) {
4294          prevInjectContext = setInjectorProfilerContext({ injector: this, token });
4295        }
4296        const previousInjector = setCurrentInjector(this);
4297        const previousInjectImplementation = setInjectImplementation(void 0);
4298        try {
4299          if (!(flags & 4)) {
4300            let record = this.records.get(token);
4301            if (record === void 0) {
4302              const def = couldBeInjectableType(token) && getInjectableDef(token);
4303              if (def && this.injectableDefInScope(def)) {
4304                if (ngDevMode) {
4305                  runInInjectorProfilerContext(this, token, () => {
4306                    emitProviderConfiguredEvent(token);
4307                  });
4308                }
4309                record = makeRecord(injectableDefOrInjectorDefFactory(token), NOT_YET);
4310              } else {
4311                record = null;
4312              }
4313              this.records.set(token, record);
4314            }
4315            if (record != null) {
4316              return this.hydrate(token, record, flags);
4317            }
4318          }
4319          const nextInjector = !(flags & 2) ? this.parent : getNullInjector();
4320          notFoundValue = flags & 8 && notFoundValue === THROW_IF_NOT_FOUND ? null : notFoundValue;
4321          return nextInjector.get(token, notFoundValue);
4322        } catch (error) {
4323          const errorCode = getRuntimeErrorCode(error);
4324          if (errorCode === -200 || errorCode === -201) {
4325            if (ngDevMode) {
4326              prependTokenToDependencyPath(error, token);
4327              if (previousInjector) {
4328                throw error;
4329              } else {
4330                throw augmentRuntimeError(error, this.source);
4331              }
4332            } else {
4333              throw new RuntimeError(errorCode, null);
4334            }
4335          } else {
4336            throw error;
4337          }
4338        } finally {
4339          setInjectImplementation(previousInjectImplementation);
4340          setCurrentInjector(previousInjector);
4341          ngDevMode && setInjectorProfilerContext(prevInjectContext);
4342        }
4343      }
4344      /** @internal */
4345      resolveInjectorInitializers() {
4346        const prevConsumer = setActiveConsumer(null);
4347        const previousInjector = setCurrentInjector(this);
4348        const previousInjectImplementation = setInjectImplementation(void 0);
4349        let prevInjectContext;
4350        if (ngDevMode) {
4351          prevInjectContext = setInjectorProfilerContext({ injector: this, token: null });
4352        }
4353        try {
4354          const initializers = this.get(ENVIRONMENT_INITIALIZER, EMPTY_ARRAY, { self: true });
4355          if (ngDevMode && !Array.isArray(initializers)) {
4356            throw new RuntimeError(-209, `Unexpected type of the \`ENVIRONMENT_INITIALIZER\` token value (expected an array, but got ${typeof initializers}). Please check that the \`ENVIRONMENT_INITIALIZER\` token is configured as a \`multi: true\` provider.`);
4357          }
4358          for (const initializer of initializers) {
4359            initializer();
4360          }
4361        } finally {
4362          setCurrentInjector(previousInjector);
4363          setInjectImplementation(previousInjectImplementation);
4364          ngDevMode && setInjectorProfilerContext(prevInjectContext);
4365          setActiveConsumer(prevConsumer);
4366        }
4367      }
4368      toString() {
4369        const tokens = [];
4370        const records = this.records;
4371        for (const token of records.keys()) {
4372          tokens.push(stringify(token));
4373        }
4374        return `R3Injector[${tokens.join(", ")}]`;
4375      }
4376      /**
4377       * Process a `SingleProvider` and add it.
4378       */
4379      processProvider(provider) {
4380        provider = resolveForwardRef(provider);
4381        let token = isTypeProvider(provider) ? provider : resolveForwardRef(provider && provider.provide);
4382        const record = providerToRecord(provider);
4383        if (ngDevMode) {
4384          runInInjectorProfilerContext(this, token, () => {
4385            if (isValueProvider(provider)) {
4386              emitInjectorToCreateInstanceEvent(token);
4387              emitInstanceCreatedByInjectorEvent(provider.useValue);
4388            }
4389            emitProviderConfiguredEvent(provider);
4390          });
4391        }
4392        if (!isTypeProvider(provider) && provider.multi === true) {
4393          let multiRecord = this.records.get(token);
4394          if (multiRecord) {
4395            if (ngDevMode && multiRecord.multi === void 0) {
4396              throwMixedMultiProviderError();
4397            }
4398          } else {
4399            multiRecord = makeRecord(void 0, NOT_YET, true);
4400            multiRecord.factory = () => injectArgs(multiRecord.multi);
4401            this.records.set(token, multiRecord);
4402          }
4403          token = provider;
4404          multiRecord.multi.push(provider);
4405        } else {
4406          if (ngDevMode) {
4407            const existing = this.records.get(token);
4408            if (existing && existing.multi !== void 0) {
4409              throwMixedMultiProviderError();
4410            }
4411          }
4412        }
4413        this.records.set(token, record);
4414      }
4415      hydrate(token, record, flags) {
4416        const prevConsumer = setActiveConsumer(null);
4417        try {
4418          if (record.value === CIRCULAR) {
4419            throw cyclicDependencyError(stringify(token));
4420          } else if (record.value === NOT_YET) {
4421            record.value = CIRCULAR;
4422            if (ngDevMode) {
4423              runInInjectorProfilerContext(this, token, () => {
4424                emitInjectorToCreateInstanceEvent(token);
4425                record.value = record.factory(void 0, flags);
4426                emitInstanceCreatedByInjectorEvent(record.value);
4427              });
4428            } else {
4429              record.value = record.factory(void 0, flags);
4430            }
4431          }
4432          if (typeof record.value === "object" && record.value && hasOnDestroy(record.value)) {
4433            this._ngOnDestroyHooks.add(record.value);
4434          }
4435          return record.value;
4436        } finally {
4437          setActiveConsumer(prevConsumer);
4438        }
4439      }
4440      injectableDefInScope(def) {
4441        if (!def.providedIn) {
4442          return false;
4443        }
4444        const providedIn = resolveForwardRef(def.providedIn);
4445        if (typeof providedIn === "string") {
4446          return providedIn === "any" || this.scopes.has(providedIn);
4447        } else {
4448          return this.injectorDefTypes.has(providedIn);
4449        }
4450      }
4451      removeOnDestroy(callback) {
4452        const destroyCBIdx = this._onDestroyHooks.indexOf(callback);
4453        if (destroyCBIdx !== -1) {
4454          this._onDestroyHooks.splice(destroyCBIdx, 1);
4455        }
4456      }
4457    };
4458    HOST = 0;
4459    TVIEW = 1;
4460    FLAGS = 2;
4461    PARENT = 3;
4462    NEXT = 4;
4463    T_HOST = 5;
4464    HYDRATION = 6;
4465    CLEANUP = 7;
4466    CONTEXT = 8;
4467    INJECTOR = 9;
4468    ENVIRONMENT = 10;
4469    RENDERER = 11;
4470    CHILD_HEAD = 12;
4471    CHILD_TAIL = 13;
4472    DECLARATION_VIEW = 14;
4473    DECLARATION_COMPONENT_VIEW = 15;
4474    DECLARATION_LCONTAINER = 16;
4475    PREORDER_HOOK_FLAGS = 17;
4476    QUERIES = 18;
4477    ID = 19;
4478    EMBEDDED_VIEW_INJECTOR = 20;
4479    ON_DESTROY_HOOKS = 21;
4480    EFFECTS_TO_SCHEDULE = 22;
4481    EFFECTS = 23;
4482    REACTIVE_TEMPLATE_CONSUMER = 24;
4483    AFTER_RENDER_SEQUENCES_TO_ADD = 25;
4484    ANIMATIONS = 26;
4485    HEADER_OFFSET = 27;
4486    TYPE = 1;
4487    DEHYDRATED_VIEWS = 6;
4488    NATIVE = 7;
4489    VIEW_REFS = 8;
4490    MOVED_VIEWS = 9;
4491    CONTAINER_HEADER_OFFSET = 10;
4492    SVG_NAMESPACE = "svg";
4493    MATH_ML_NAMESPACE = "math";
4494    instructionState = {
4495      lFrame: createLFrame(null),
4496      bindingsEnabled: true,
4497      skipHydrationRootTNode: null
4498    };
4499    (function(CheckNoChangesMode2) {
4500      CheckNoChangesMode2[CheckNoChangesMode2["Off"] = 0] = "Off";
4501      CheckNoChangesMode2[CheckNoChangesMode2["Exhaustive"] = 1] = "Exhaustive";
4502      CheckNoChangesMode2[CheckNoChangesMode2["OnlyDirtyViews"] = 2] = "OnlyDirtyViews";
4503    })(CheckNoChangesMode || (CheckNoChangesMode = {}));
4504    _checkNoChangesMode = 0;
4505    _isRefreshingViews = false;
4506    leaveDI = leaveViewLight;
4507    _wasLastNodeCreated = true;
4508    Injector = class _Injector {
4509      static THROW_IF_NOT_FOUND = THROW_IF_NOT_FOUND;
4510      static NULL = new NullInjector();
4511      static create(options, parent) {
4512        if (Array.isArray(options)) {
4513          return createInjector({ name: "" }, parent, options, "");
4514        } else {
4515          const name = options.name ?? "";
4516          return createInjector({ name }, options.parent, options.providers, name);
4517        }
4518      }
4519      /** @nocollapse */
4520      static \u0275prov = (
4521        /** @pureOrBreakMyCode */
4522        /* @__PURE__ */ \u0275\u0275defineInjectable({
4523          token: _Injector,
4524          providedIn: "any",
4525          factory: () => \u0275\u0275inject(INJECTOR$1)
4526        })
4527      );
4528      /**
4529       * @internal
4530       * @nocollapse
4531       */
4532      static __NG_ELEMENT_ID__ = -1;
4533    };
4534    DOCUMENT = new InjectionToken(ngDevMode ? "DocumentToken" : "");
4535    DestroyRef = class {
4536      /**
4537       * @internal
4538       * @nocollapse
4539       */
4540      static __NG_ELEMENT_ID__ = injectDestroyRef;
4541      /**
4542       * @internal
4543       * @nocollapse
4544       */
4545      static __NG_ENV_ID__ = (injector) => injector;
4546    };
4547    NodeInjectorDestroyRef = class extends DestroyRef {
4548      _lView;
4549      constructor(_lView) {
4550        super();
4551        this._lView = _lView;
4552      }
4553      get destroyed() {
4554        return isDestroyed(this._lView);
4555      }
4556      onDestroy(callback) {
4557        const lView = this._lView;
4558        storeLViewOnDestroy(lView, callback);
4559        return () => removeLViewOnDestroy(lView, callback);
4560      }
4561    };
4562    ErrorHandler = class {
4563      /**
4564       * @internal
4565       */
4566      _console = console;
4567      handleError(error) {
4568        this._console.error("ERROR", error);
4569      }
4570    };
4571    INTERNAL_APPLICATION_ERROR_HANDLER = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "internal error handler" : "", {
4572      providedIn: "root",
4573      factory: () => {
4574        const injector = inject2(EnvironmentInjector);
4575        let userErrorHandler;
4576        return (e) => {
4577          if (injector.destroyed && !userErrorHandler) {
4578            setTimeout(() => {
4579              throw e;
4580            });
4581          } else {
4582            userErrorHandler ??= injector.get(ErrorHandler);
4583            userErrorHandler.handleError(e);
4584          }
4585        };
4586      }
4587    });
4588    errorHandlerEnvironmentInitializer = {
4589      provide: ENVIRONMENT_INITIALIZER,
4590      useValue: () => void inject2(ErrorHandler),
4591      multi: true
4592    };
4593    globalErrorListeners = new InjectionToken(ngDevMode ? "GlobalErrorListeners" : "", {
4594      providedIn: "root",
4595      factory: () => {
4596        if (false) {
4597          return;
4598        }
4599        const window2 = inject2(DOCUMENT).defaultView;
4600        if (!window2) {
4601          return;
4602        }
4603        const errorHandler2 = inject2(INTERNAL_APPLICATION_ERROR_HANDLER);
4604        const rejectionListener = (e) => {
4605          errorHandler2(e.reason);
4606          e.preventDefault();
4607        };
4608        const errorListener = (e) => {
4609          if (e.error) {
4610            errorHandler2(e.error);
4611          } else {
4612            errorHandler2(new Error(ngDevMode ? `An ErrorEvent with no error occurred. See Error.cause for details: ${e.message}` : e.message, { cause: e }));
4613          }
4614          e.preventDefault();
4615        };
4616        const setupEventListeners = () => {
4617          window2.addEventListener("unhandledrejection", rejectionListener);
4618          window2.addEventListener("error", errorListener);
4619        };
4620        if (typeof Zone !== "undefined") {
4621          Zone.root.run(setupEventListeners);
4622        } else {
4623          setupEventListeners();
4624        }
4625        inject2(DestroyRef).onDestroy(() => {
4626          window2.removeEventListener("error", errorListener);
4627          window2.removeEventListener("unhandledrejection", rejectionListener);
4628        });
4629      }
4630    });
4631    ViewContext = class {
4632      view;
4633      node;
4634      constructor(view, node) {
4635        this.view = view;
4636        this.node = node;
4637      }
4638      /**
4639       * @internal
4640       * @nocollapse
4641       */
4642      static __NG_ELEMENT_ID__ = injectViewContext;
4643    };
4644    ChangeDetectionScheduler = class {
4645    };
4646    ZONELESS_ENABLED = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "Zoneless enabled" : "", { providedIn: "root", factory: () => false });
4647    PROVIDED_ZONELESS = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "Zoneless provided" : "", { providedIn: "root", factory: () => false });
4648    ZONELESS_SCHEDULER_DISABLED = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "scheduler disabled" : "");
4649    SCHEDULE_IN_ROOT_ZONE = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "run changes outside zone in root" : "");
4650    PendingTasksInternal = class _PendingTasksInternal {
4651      taskId = 0;
4652      pendingTasks = /* @__PURE__ */ new Set();
4653      destroyed = false;
4654      pendingTask = new BehaviorSubject(false);
4655      get hasPendingTasks() {
4656        return this.destroyed ? false : this.pendingTask.value;
4657      }
4658      /**
4659       * In case the service is about to be destroyed, return a self-completing observable.
4660       * Otherwise, return the observable that emits the current state of pending tasks.
4661       */
4662      get hasPendingTasksObservable() {
4663        if (this.destroyed) {
4664          return new Observable((subscriber) => {
4665            subscriber.next(false);
4666            subscriber.complete();
4667          });
4668        }
4669        return this.pendingTask;
4670      }
4671      add() {
4672        if (!this.hasPendingTasks && !this.destroyed) {
4673          this.pendingTask.next(true);
4674        }
4675        const taskId = this.taskId++;
4676        this.pendingTasks.add(taskId);
4677        return taskId;
4678      }
4679      has(taskId) {
4680        return this.pendingTasks.has(taskId);
4681      }
4682      remove(taskId) {
4683        this.pendingTasks.delete(taskId);
4684        if (this.pendingTasks.size === 0 && this.hasPendingTasks) {
4685          this.pendingTask.next(false);
4686        }
4687      }
4688      ngOnDestroy() {
4689        this.pendingTasks.clear();
4690        if (this.hasPendingTasks) {
4691          this.pendingTask.next(false);
4692        }
4693        this.destroyed = true;
4694        this.pendingTask.unsubscribe();
4695      }
4696      /** @nocollapse */
4697      static \u0275prov = (
4698        /** @pureOrBreakMyCode */
4699        /* @__PURE__ */ \u0275\u0275defineInjectable({
4700          token: _PendingTasksInternal,
4701          providedIn: "root",
4702          factory: () => new _PendingTasksInternal()
4703        })
4704      );
4705    };
4706    PendingTasks = class _PendingTasks {
4707      internalPendingTasks = inject2(PendingTasksInternal);
4708      scheduler = inject2(ChangeDetectionScheduler);
4709      errorHandler = inject2(INTERNAL_APPLICATION_ERROR_HANDLER);
4710      /**
4711       * Adds a new task that should block application's stability.
4712       * @returns A cleanup function that removes a task when called.
4713       */
4714      add() {
4715        const taskId = this.internalPendingTasks.add();
4716        return () => {
4717          if (!this.internalPendingTasks.has(taskId)) {
4718            return;
4719          }
4720          this.scheduler.notify(
4721            11
4722            /* NotificationSource.PendingTaskRemoved */
4723          );
4724          this.internalPendingTasks.remove(taskId);
4725        };
4726      }
4727      /**
4728       * Runs an asynchronous function and blocks the application's stability until the function completes.
4729       *
4730       * ```ts
4731       * pendingTasks.run(async () => {
4732       *   const userData = await fetch('/api/user');
4733       *   this.userData.set(userData);
4734       * });
4735       * ```
4736       *
4737       * @param fn The asynchronous function to execute
4738       * @developerPreview 19.0
4739       */
4740      run(fn) {
4741        const removeTask = this.add();
4742        fn().catch(this.errorHandler).finally(removeTask);
4743      }
4744      /** @nocollapse */
4745      static \u0275prov = (
4746        /** @pureOrBreakMyCode */
4747        /* @__PURE__ */ \u0275\u0275defineInjectable({
4748          token: _PendingTasks,
4749          providedIn: "root",
4750          factory: () => new _PendingTasks()
4751        })
4752      );
4753    };
4754    EffectScheduler = class _EffectScheduler {
4755      /** @nocollapse */
4756      static \u0275prov = (
4757        /** @pureOrBreakMyCode */
4758        /* @__PURE__ */ \u0275\u0275defineInjectable({
4759          token: _EffectScheduler,
4760          providedIn: "root",
4761          factory: () => new ZoneAwareEffectScheduler()
4762        })
4763      );
4764    };
4765    ZoneAwareEffectScheduler = class {
4766      dirtyEffectCount = 0;
4767      queues = /* @__PURE__ */ new Map();
4768      add(handle) {
4769        this.enqueue(handle);
4770        this.schedule(handle);
4771      }
4772      schedule(handle) {
4773        if (!handle.dirty) {
4774          return;
4775        }
4776        this.dirtyEffectCount++;
4777      }
4778      remove(handle) {
4779        const zone = handle.zone;
4780        const queue = this.queues.get(zone);
4781        if (!queue.has(handle)) {
4782          return;
4783        }
4784        queue.delete(handle);
4785        if (handle.dirty) {
4786          this.dirtyEffectCount--;
4787        }
4788      }
4789      enqueue(handle) {
4790        const zone = handle.zone;
4791        if (!this.queues.has(zone)) {
4792          this.queues.set(zone, /* @__PURE__ */ new Set());
4793        }
4794        const queue = this.queues.get(zone);
4795        if (queue.has(handle)) {
4796          return;
4797        }
4798        queue.add(handle);
4799      }
4800      /**
4801       * Run all scheduled effects.
4802       *
4803       * Execution order of effects within the same zone is guaranteed to be FIFO, but there is no
4804       * ordering guarantee between effects scheduled in different zones.
4805       */
4806      flush() {
4807        while (this.dirtyEffectCount > 0) {
4808          let ranOneEffect = false;
4809          for (const [zone, queue] of this.queues) {
4810            if (zone === null) {
4811              ranOneEffect ||= this.flushQueue(queue);
4812            } else {
4813              ranOneEffect ||= zone.run(() => this.flushQueue(queue));
4814            }
4815          }
4816          if (!ranOneEffect) {
4817            this.dirtyEffectCount = 0;
4818          }
4819        }
4820      }
4821      flushQueue(queue) {
4822        let ranOneEffect = false;
4823        for (const handle of queue) {
4824          if (!handle.dirty) {
4825            continue;
4826          }
4827          this.dirtyEffectCount--;
4828          ranOneEffect = true;
4829          handle.run();
4830        }
4831        return ranOneEffect;
4832      }
4833    };
4834  }
4835});
4836