diff --git "a/frontend/dist/frontend/browser/main.js" "b/frontend/dist/frontend/browser/main.js"
new file mode 100644--- /dev/null
+++ "b/frontend/dist/frontend/browser/main.js"
@@ -0,0 +1,44624 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b ||= {})
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+
+// node_modules/@angular/core/fesm2022/_effect-chunk.mjs
+/**
+ * @license Angular v21.2.17
+ * (c) 2010-2026 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+var activeConsumer = null;
+var inNotificationPhase = false;
+var epoch = 1;
+var postProducerCreatedFn = null;
+var SIGNAL = /* @__PURE__ */ Symbol("SIGNAL");
+function setActiveConsumer(consumer) {
+  const prev = activeConsumer;
+  activeConsumer = consumer;
+  return prev;
+}
+function getActiveConsumer() {
+  return activeConsumer;
+}
+function isInNotificationPhase() {
+  return inNotificationPhase;
+}
+var REACTIVE_NODE = {
+  version: 0,
+  lastCleanEpoch: 0,
+  dirty: false,
+  producers: void 0,
+  producersTail: void 0,
+  consumers: void 0,
+  consumersTail: void 0,
+  recomputing: false,
+  consumerAllowSignalWrites: false,
+  consumerIsAlwaysLive: false,
+  kind: "unknown",
+  producerMustRecompute: () => false,
+  producerRecomputeValue: () => {
+  },
+  consumerMarkedDirty: () => {
+  },
+  consumerOnSignalRead: () => {
+  }
+};
+function producerAccessed(node) {
+  if (inNotificationPhase) {
+    throw new Error(typeof ngDevMode !== "undefined" && ngDevMode ? `Assertion error: signal read during notification phase` : "");
+  }
+  if (activeConsumer === null) {
+    return;
+  }
+  activeConsumer.consumerOnSignalRead(node);
+  const prevProducerLink = activeConsumer.producersTail;
+  if (prevProducerLink !== void 0 && prevProducerLink.producer === node) {
+    return;
+  }
+  let nextProducerLink = void 0;
+  const isRecomputing = activeConsumer.recomputing;
+  if (isRecomputing) {
+    nextProducerLink = prevProducerLink !== void 0 ? prevProducerLink.nextProducer : activeConsumer.producers;
+    if (nextProducerLink !== void 0 && nextProducerLink.producer === node) {
+      activeConsumer.producersTail = nextProducerLink;
+      nextProducerLink.lastReadVersion = node.version;
+      return;
+    }
+  }
+  const prevConsumerLink = node.consumersTail;
+  if (prevConsumerLink !== void 0 && prevConsumerLink.consumer === activeConsumer && (!isRecomputing || isValidLink(prevConsumerLink, activeConsumer))) {
+    return;
+  }
+  const isLive = consumerIsLive(activeConsumer);
+  const newLink = {
+    producer: node,
+    consumer: activeConsumer,
+    nextProducer: nextProducerLink,
+    prevConsumer: prevConsumerLink,
+    lastReadVersion: node.version,
+    nextConsumer: void 0
+  };
+  activeConsumer.producersTail = newLink;
+  if (prevProducerLink !== void 0) {
+    prevProducerLink.nextProducer = newLink;
+  } else {
+    activeConsumer.producers = newLink;
+  }
+  if (isLive) {
+    producerAddLiveConsumer(node, newLink);
+  }
+}
+function producerIncrementEpoch() {
+  epoch++;
+}
+function producerUpdateValueVersion(node) {
+  if (consumerIsLive(node) && !node.dirty) {
+    return;
+  }
+  if (!node.dirty && node.lastCleanEpoch === epoch) {
+    return;
+  }
+  if (!node.producerMustRecompute(node) && !consumerPollProducersForChange(node)) {
+    producerMarkClean(node);
+    return;
+  }
+  node.producerRecomputeValue(node);
+  producerMarkClean(node);
+}
+function producerNotifyConsumers(node) {
+  if (node.consumers === void 0) {
+    return;
+  }
+  const prev = inNotificationPhase;
+  inNotificationPhase = true;
+  try {
+    for (let link = node.consumers; link !== void 0; link = link.nextConsumer) {
+      const consumer = link.consumer;
+      if (!consumer.dirty) {
+        consumerMarkDirty(consumer);
+      }
+    }
+  } finally {
+    inNotificationPhase = prev;
+  }
+}
+function producerUpdatesAllowed() {
+  return activeConsumer?.consumerAllowSignalWrites !== false;
+}
+function consumerMarkDirty(node) {
+  node.dirty = true;
+  producerNotifyConsumers(node);
+  node.consumerMarkedDirty?.(node);
+}
+function producerMarkClean(node) {
+  node.dirty = false;
+  node.lastCleanEpoch = epoch;
+}
+function consumerBeforeComputation(node) {
+  if (node) resetConsumerBeforeComputation(node);
+  return setActiveConsumer(node);
+}
+function resetConsumerBeforeComputation(node) {
+  node.producersTail = void 0;
+  node.recomputing = true;
+}
+function consumerAfterComputation(node, prevConsumer) {
+  setActiveConsumer(prevConsumer);
+  if (node) finalizeConsumerAfterComputation(node);
+}
+function finalizeConsumerAfterComputation(node) {
+  node.recomputing = false;
+  const producersTail = node.producersTail;
+  let toRemove = producersTail !== void 0 ? producersTail.nextProducer : node.producers;
+  if (toRemove !== void 0) {
+    if (consumerIsLive(node)) {
+      do {
+        toRemove = producerRemoveLiveConsumerLink(toRemove);
+      } while (toRemove !== void 0);
+    }
+    if (producersTail !== void 0) {
+      producersTail.nextProducer = void 0;
+    } else {
+      node.producers = void 0;
+    }
+  }
+}
+function consumerPollProducersForChange(node) {
+  for (let link = node.producers; link !== void 0; link = link.nextProducer) {
+    const producer = link.producer;
+    const seenVersion = link.lastReadVersion;
+    if (seenVersion !== producer.version) {
+      return true;
+    }
+    producerUpdateValueVersion(producer);
+    if (seenVersion !== producer.version) {
+      return true;
+    }
+  }
+  return false;
+}
+function consumerDestroy(node) {
+  if (consumerIsLive(node)) {
+    let link = node.producers;
+    while (link !== void 0) {
+      link = producerRemoveLiveConsumerLink(link);
+    }
+  }
+  node.producers = void 0;
+  node.producersTail = void 0;
+  node.consumers = void 0;
+  node.consumersTail = void 0;
+}
+function producerAddLiveConsumer(node, link) {
+  const consumersTail = node.consumersTail;
+  const wasLive = consumerIsLive(node);
+  if (consumersTail !== void 0) {
+    link.nextConsumer = consumersTail.nextConsumer;
+    consumersTail.nextConsumer = link;
+  } else {
+    link.nextConsumer = void 0;
+    node.consumers = link;
+  }
+  link.prevConsumer = consumersTail;
+  node.consumersTail = link;
+  if (!wasLive) {
+    for (let link2 = node.producers; link2 !== void 0; link2 = link2.nextProducer) {
+      producerAddLiveConsumer(link2.producer, link2);
+    }
+  }
+}
+function producerRemoveLiveConsumerLink(link) {
+  const producer = link.producer;
+  const nextProducer = link.nextProducer;
+  const nextConsumer = link.nextConsumer;
+  const prevConsumer = link.prevConsumer;
+  link.nextConsumer = void 0;
+  link.prevConsumer = void 0;
+  if (nextConsumer !== void 0) {
+    nextConsumer.prevConsumer = prevConsumer;
+  } else {
+    producer.consumersTail = prevConsumer;
+  }
+  if (prevConsumer !== void 0) {
+    prevConsumer.nextConsumer = nextConsumer;
+  } else {
+    producer.consumers = nextConsumer;
+    if (!consumerIsLive(producer)) {
+      let producerLink = producer.producers;
+      while (producerLink !== void 0) {
+        producerLink = producerRemoveLiveConsumerLink(producerLink);
+      }
+    }
+  }
+  return nextProducer;
+}
+function consumerIsLive(node) {
+  return node.consumerIsAlwaysLive || node.consumers !== void 0;
+}
+function runPostProducerCreatedFn(node) {
+  postProducerCreatedFn?.(node);
+}
+function isValidLink(checkLink, consumer) {
+  const producersTail = consumer.producersTail;
+  if (producersTail !== void 0) {
+    let link = consumer.producers;
+    do {
+      if (link === checkLink) {
+        return true;
+      }
+      if (link === producersTail) {
+        break;
+      }
+      link = link.nextProducer;
+    } while (link !== void 0);
+  }
+  return false;
+}
+function defaultEquals(a, b) {
+  return Object.is(a, b);
+}
+function createComputed(computation, equal) {
+  const node = Object.create(COMPUTED_NODE);
+  node.computation = computation;
+  if (equal !== void 0) {
+    node.equal = equal;
+  }
+  const computed2 = () => {
+    producerUpdateValueVersion(node);
+    producerAccessed(node);
+    if (node.value === ERRORED) {
+      throw node.error;
+    }
+    return node.value;
+  };
+  computed2[SIGNAL] = node;
+  if (typeof ngDevMode !== "undefined" && ngDevMode) {
+    computed2.toString = () => `[Computed${node.debugName ? " (" + node.debugName + ")" : ""}: ${String(node.value)}]`;
+  }
+  runPostProducerCreatedFn(node);
+  return computed2;
+}
+var UNSET = /* @__PURE__ */ Symbol("UNSET");
+var COMPUTING = /* @__PURE__ */ Symbol("COMPUTING");
+var ERRORED = /* @__PURE__ */ Symbol("ERRORED");
+var COMPUTED_NODE = /* @__PURE__ */ (() => {
+  return __spreadProps(__spreadValues({}, REACTIVE_NODE), {
+    value: UNSET,
+    dirty: true,
+    error: null,
+    equal: defaultEquals,
+    kind: "computed",
+    producerMustRecompute(node) {
+      return node.value === UNSET || node.value === COMPUTING;
+    },
+    producerRecomputeValue(node) {
+      if (node.value === COMPUTING) {
+        throw new Error(typeof ngDevMode !== "undefined" && ngDevMode ? "Detected cycle in computations." : "");
+      }
+      const oldValue = node.value;
+      node.value = COMPUTING;
+      const prevConsumer = consumerBeforeComputation(node);
+      let newValue;
+      let wasEqual = false;
+      try {
+        newValue = node.computation();
+        setActiveConsumer(null);
+        wasEqual = oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED && node.equal(oldValue, newValue);
+      } catch (err) {
+        newValue = ERRORED;
+        node.error = err;
+      } finally {
+        consumerAfterComputation(node, prevConsumer);
+      }
+      if (wasEqual) {
+        node.value = oldValue;
+        return;
+      }
+      node.value = newValue;
+      node.version++;
+    }
+  });
+})();
+function defaultThrowError() {
+  throw new Error();
+}
+var throwInvalidWriteToSignalErrorFn = defaultThrowError;
+function throwInvalidWriteToSignalError(node) {
+  throwInvalidWriteToSignalErrorFn(node);
+}
+function setThrowInvalidWriteToSignalError(fn) {
+  throwInvalidWriteToSignalErrorFn = fn;
+}
+var postSignalSetFn = null;
+function createSignal(initialValue, equal) {
+  const node = Object.create(SIGNAL_NODE);
+  node.value = initialValue;
+  if (equal !== void 0) {
+    node.equal = equal;
+  }
+  const getter = () => signalGetFn(node);
+  getter[SIGNAL] = node;
+  if (typeof ngDevMode !== "undefined" && ngDevMode) {
+    getter.toString = () => `[Signal${node.debugName ? " (" + node.debugName + ")" : ""}: ${String(node.value)}]`;
+  }
+  runPostProducerCreatedFn(node);
+  const set = (newValue) => signalSetFn(node, newValue);
+  const update = (updateFn) => signalUpdateFn(node, updateFn);
+  return [getter, set, update];
+}
+function signalGetFn(node) {
+  producerAccessed(node);
+  return node.value;
+}
+function signalSetFn(node, newValue) {
+  if (!producerUpdatesAllowed()) {
+    throwInvalidWriteToSignalError(node);
+  }
+  if (!node.equal(node.value, newValue)) {
+    node.value = newValue;
+    signalValueChanged(node);
+  }
+}
+function signalUpdateFn(node, updater) {
+  if (!producerUpdatesAllowed()) {
+    throwInvalidWriteToSignalError(node);
+  }
+  signalSetFn(node, updater(node.value));
+}
+var SIGNAL_NODE = /* @__PURE__ */ (() => {
+  return __spreadProps(__spreadValues({}, REACTIVE_NODE), {
+    equal: defaultEquals,
+    value: void 0,
+    kind: "signal"
+  });
+})();
+function signalValueChanged(node) {
+  node.version++;
+  producerIncrementEpoch();
+  producerNotifyConsumers(node);
+  postSignalSetFn?.(node);
+}
+var BASE_EFFECT_NODE = /* @__PURE__ */ (() => __spreadProps(__spreadValues({}, REACTIVE_NODE), {
+  consumerIsAlwaysLive: true,
+  consumerAllowSignalWrites: true,
+  dirty: true,
+  kind: "effect"
+}))();
+function runEffect(node) {
+  node.dirty = false;
+  if (node.version > 0 && !consumerPollProducersForChange(node)) {
+    return;
+  }
+  node.version++;
+  const prevNode = consumerBeforeComputation(node);
+  try {
+    node.cleanup();
+    node.fn();
+  } finally {
+    consumerAfterComputation(node, prevNode);
+  }
+}
+
+// node_modules/rxjs/dist/esm/internal/util/isFunction.js
+function isFunction(value) {
+  return typeof value === "function";
+}
+
+// node_modules/rxjs/dist/esm/internal/util/createErrorClass.js
+function createErrorClass(createImpl) {
+  const _super = (instance) => {
+    Error.call(instance);
+    instance.stack = new Error().stack;
+  };
+  const ctorFunc = createImpl(_super);
+  ctorFunc.prototype = Object.create(Error.prototype);
+  ctorFunc.prototype.constructor = ctorFunc;
+  return ctorFunc;
+}
+
+// node_modules/rxjs/dist/esm/internal/util/UnsubscriptionError.js
+var UnsubscriptionError = createErrorClass((_super) => function UnsubscriptionErrorImpl(errors) {
+  _super(this);
+  this.message = errors ? `${errors.length} errors occurred during unsubscription:
+${errors.map((err, i) => `${i + 1}) ${err.toString()}`).join("\n  ")}` : "";
+  this.name = "UnsubscriptionError";
+  this.errors = errors;
+});
+
+// node_modules/rxjs/dist/esm/internal/util/arrRemove.js
+function arrRemove(arr, item) {
+  if (arr) {
+    const index = arr.indexOf(item);
+    0 <= index && arr.splice(index, 1);
+  }
+}
+
+// node_modules/rxjs/dist/esm/internal/Subscription.js
+var Subscription = class _Subscription {
+  constructor(initialTeardown) {
+    this.initialTeardown = initialTeardown;
+    this.closed = false;
+    this._parentage = null;
+    this._finalizers = null;
+  }
+  unsubscribe() {
+    let errors;
+    if (!this.closed) {
+      this.closed = true;
+      const { _parentage } = this;
+      if (_parentage) {
+        this._parentage = null;
+        if (Array.isArray(_parentage)) {
+          for (const parent of _parentage) {
+            parent.remove(this);
+          }
+        } else {
+          _parentage.remove(this);
+        }
+      }
+      const { initialTeardown: initialFinalizer } = this;
+      if (isFunction(initialFinalizer)) {
+        try {
+          initialFinalizer();
+        } catch (e) {
+          errors = e instanceof UnsubscriptionError ? e.errors : [e];
+        }
+      }
+      const { _finalizers } = this;
+      if (_finalizers) {
+        this._finalizers = null;
+        for (const finalizer of _finalizers) {
+          try {
+            execFinalizer(finalizer);
+          } catch (err) {
+            errors = errors !== null && errors !== void 0 ? errors : [];
+            if (err instanceof UnsubscriptionError) {
+              errors = [...errors, ...err.errors];
+            } else {
+              errors.push(err);
+            }
+          }
+        }
+      }
+      if (errors) {
+        throw new UnsubscriptionError(errors);
+      }
+    }
+  }
+  add(teardown) {
+    var _a;
+    if (teardown && teardown !== this) {
+      if (this.closed) {
+        execFinalizer(teardown);
+      } else {
+        if (teardown instanceof _Subscription) {
+          if (teardown.closed || teardown._hasParent(this)) {
+            return;
+          }
+          teardown._addParent(this);
+        }
+        (this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
+      }
+    }
+  }
+  _hasParent(parent) {
+    const { _parentage } = this;
+    return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent);
+  }
+  _addParent(parent) {
+    const { _parentage } = this;
+    this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
+  }
+  _removeParent(parent) {
+    const { _parentage } = this;
+    if (_parentage === parent) {
+      this._parentage = null;
+    } else if (Array.isArray(_parentage)) {
+      arrRemove(_parentage, parent);
+    }
+  }
+  remove(teardown) {
+    const { _finalizers } = this;
+    _finalizers && arrRemove(_finalizers, teardown);
+    if (teardown instanceof _Subscription) {
+      teardown._removeParent(this);
+    }
+  }
+};
+Subscription.EMPTY = (() => {
+  const empty = new Subscription();
+  empty.closed = true;
+  return empty;
+})();
+var EMPTY_SUBSCRIPTION = Subscription.EMPTY;
+function isSubscription(value) {
+  return value instanceof Subscription || value && "closed" in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe);
+}
+function execFinalizer(finalizer) {
+  if (isFunction(finalizer)) {
+    finalizer();
+  } else {
+    finalizer.unsubscribe();
+  }
+}
+
+// node_modules/rxjs/dist/esm/internal/config.js
+var config = {
+  onUnhandledError: null,
+  onStoppedNotification: null,
+  Promise: void 0,
+  useDeprecatedSynchronousErrorHandling: false,
+  useDeprecatedNextContext: false
+};
+
+// node_modules/rxjs/dist/esm/internal/scheduler/timeoutProvider.js
+var timeoutProvider = {
+  setTimeout(handler, timeout2, ...args) {
+    const { delegate } = timeoutProvider;
+    if (delegate === null || delegate === void 0 ? void 0 : delegate.setTimeout) {
+      return delegate.setTimeout(handler, timeout2, ...args);
+    }
+    return setTimeout(handler, timeout2, ...args);
+  },
+  clearTimeout(handle) {
+    const { delegate } = timeoutProvider;
+    return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearTimeout) || clearTimeout)(handle);
+  },
+  delegate: void 0
+};
+
+// node_modules/rxjs/dist/esm/internal/util/reportUnhandledError.js
+function reportUnhandledError(err) {
+  timeoutProvider.setTimeout(() => {
+    const { onUnhandledError } = config;
+    if (onUnhandledError) {
+      onUnhandledError(err);
+    } else {
+      throw err;
+    }
+  });
+}
+
+// node_modules/rxjs/dist/esm/internal/util/noop.js
+function noop() {
+}
+
+// node_modules/rxjs/dist/esm/internal/NotificationFactories.js
+var COMPLETE_NOTIFICATION = (() => createNotification("C", void 0, void 0))();
+function errorNotification(error) {
+  return createNotification("E", void 0, error);
+}
+function nextNotification(value) {
+  return createNotification("N", value, void 0);
+}
+function createNotification(kind, value, error) {
+  return {
+    kind,
+    value,
+    error
+  };
+}
+
+// node_modules/rxjs/dist/esm/internal/util/errorContext.js
+var context = null;
+function errorContext(cb) {
+  if (config.useDeprecatedSynchronousErrorHandling) {
+    const isRoot = !context;
+    if (isRoot) {
+      context = { errorThrown: false, error: null };
+    }
+    cb();
+    if (isRoot) {
+      const { errorThrown, error } = context;
+      context = null;
+      if (errorThrown) {
+        throw error;
+      }
+    }
+  } else {
+    cb();
+  }
+}
+function captureError(err) {
+  if (config.useDeprecatedSynchronousErrorHandling && context) {
+    context.errorThrown = true;
+    context.error = err;
+  }
+}
+
+// node_modules/rxjs/dist/esm/internal/Subscriber.js
+var Subscriber = class extends Subscription {
+  constructor(destination) {
+    super();
+    this.isStopped = false;
+    if (destination) {
+      this.destination = destination;
+      if (isSubscription(destination)) {
+        destination.add(this);
+      }
+    } else {
+      this.destination = EMPTY_OBSERVER;
+    }
+  }
+  static create(next, error, complete) {
+    return new SafeSubscriber(next, error, complete);
+  }
+  next(value) {
+    if (this.isStopped) {
+      handleStoppedNotification(nextNotification(value), this);
+    } else {
+      this._next(value);
+    }
+  }
+  error(err) {
+    if (this.isStopped) {
+      handleStoppedNotification(errorNotification(err), this);
+    } else {
+      this.isStopped = true;
+      this._error(err);
+    }
+  }
+  complete() {
+    if (this.isStopped) {
+      handleStoppedNotification(COMPLETE_NOTIFICATION, this);
+    } else {
+      this.isStopped = true;
+      this._complete();
+    }
+  }
+  unsubscribe() {
+    if (!this.closed) {
+      this.isStopped = true;
+      super.unsubscribe();
+      this.destination = null;
+    }
+  }
+  _next(value) {
+    this.destination.next(value);
+  }
+  _error(err) {
+    try {
+      this.destination.error(err);
+    } finally {
+      this.unsubscribe();
+    }
+  }
+  _complete() {
+    try {
+      this.destination.complete();
+    } finally {
+      this.unsubscribe();
+    }
+  }
+};
+var _bind = Function.prototype.bind;
+function bind(fn, thisArg) {
+  return _bind.call(fn, thisArg);
+}
+var ConsumerObserver = class {
+  constructor(partialObserver) {
+    this.partialObserver = partialObserver;
+  }
+  next(value) {
+    const { partialObserver } = this;
+    if (partialObserver.next) {
+      try {
+        partialObserver.next(value);
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    }
+  }
+  error(err) {
+    const { partialObserver } = this;
+    if (partialObserver.error) {
+      try {
+        partialObserver.error(err);
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    } else {
+      handleUnhandledError(err);
+    }
+  }
+  complete() {
+    const { partialObserver } = this;
+    if (partialObserver.complete) {
+      try {
+        partialObserver.complete();
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    }
+  }
+};
+var SafeSubscriber = class extends Subscriber {
+  constructor(observerOrNext, error, complete) {
+    super();
+    let partialObserver;
+    if (isFunction(observerOrNext) || !observerOrNext) {
+      partialObserver = {
+        next: observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : void 0,
+        error: error !== null && error !== void 0 ? error : void 0,
+        complete: complete !== null && complete !== void 0 ? complete : void 0
+      };
+    } else {
+      let context2;
+      if (this && config.useDeprecatedNextContext) {
+        context2 = Object.create(observerOrNext);
+        context2.unsubscribe = () => this.unsubscribe();
+        partialObserver = {
+          next: observerOrNext.next && bind(observerOrNext.next, context2),
+          error: observerOrNext.error && bind(observerOrNext.error, context2),
+          complete: observerOrNext.complete && bind(observerOrNext.complete, context2)
+        };
+      } else {
+        partialObserver = observerOrNext;
+      }
+    }
+    this.destination = new ConsumerObserver(partialObserver);
+  }
+};
+function handleUnhandledError(error) {
+  if (config.useDeprecatedSynchronousErrorHandling) {
+    captureError(error);
+  } else {
+    reportUnhandledError(error);
+  }
+}
+function defaultErrorHandler(err) {
+  throw err;
+}
+function handleStoppedNotification(notification, subscriber) {
+  const { onStoppedNotification } = config;
+  onStoppedNotification && timeoutProvider.setTimeout(() => onStoppedNotification(notification, subscriber));
+}
+var EMPTY_OBSERVER = {
+  closed: true,
+  next: noop,
+  error: defaultErrorHandler,
+  complete: noop
+};
+
+// node_modules/rxjs/dist/esm/internal/symbol/observable.js
+var observable = (() => typeof Symbol === "function" && Symbol.observable || "@@observable")();
+
+// node_modules/rxjs/dist/esm/internal/util/identity.js
+function identity(x) {
+  return x;
+}
+
+// node_modules/rxjs/dist/esm/internal/util/pipe.js
+function pipe(...fns) {
+  return pipeFromArray(fns);
+}
+function pipeFromArray(fns) {
+  if (fns.length === 0) {
+    return identity;
+  }
+  if (fns.length === 1) {
+    return fns[0];
+  }
+  return function piped(input2) {
+    return fns.reduce((prev, fn) => fn(prev), input2);
+  };
+}
+
+// node_modules/rxjs/dist/esm/internal/Observable.js
+var Observable = class _Observable {
+  constructor(subscribe) {
+    if (subscribe) {
+      this._subscribe = subscribe;
+    }
+  }
+  lift(operator) {
+    const observable2 = new _Observable();
+    observable2.source = this;
+    observable2.operator = operator;
+    return observable2;
+  }
+  subscribe(observerOrNext, error, complete) {
+    const subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
+    errorContext(() => {
+      const { operator, source } = this;
+      subscriber.add(operator ? operator.call(subscriber, source) : source ? this._subscribe(subscriber) : this._trySubscribe(subscriber));
+    });
+    return subscriber;
+  }
+  _trySubscribe(sink) {
+    try {
+      return this._subscribe(sink);
+    } catch (err) {
+      sink.error(err);
+    }
+  }
+  forEach(next, promiseCtor) {
+    promiseCtor = getPromiseCtor(promiseCtor);
+    return new promiseCtor((resolve, reject) => {
+      const subscriber = new SafeSubscriber({
+        next: (value) => {
+          try {
+            next(value);
+          } catch (err) {
+            reject(err);
+            subscriber.unsubscribe();
+          }
+        },
+        error: reject,
+        complete: resolve
+      });
+      this.subscribe(subscriber);
+    });
+  }
+  _subscribe(subscriber) {
+    var _a;
+    return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);
+  }
+  [observable]() {
+    return this;
+  }
+  pipe(...operations) {
+    return pipeFromArray(operations)(this);
+  }
+  toPromise(promiseCtor) {
+    promiseCtor = getPromiseCtor(promiseCtor);
+    return new promiseCtor((resolve, reject) => {
+      let value;
+      this.subscribe((x) => value = x, (err) => reject(err), () => resolve(value));
+    });
+  }
+};
+Observable.create = (subscribe) => {
+  return new Observable(subscribe);
+};
+function getPromiseCtor(promiseCtor) {
+  var _a;
+  return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a !== void 0 ? _a : Promise;
+}
+function isObserver(value) {
+  return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
+}
+function isSubscriber(value) {
+  return value && value instanceof Subscriber || isObserver(value) && isSubscription(value);
+}
+
+// node_modules/rxjs/dist/esm/internal/util/lift.js
+function hasLift(source) {
+  return isFunction(source === null || source === void 0 ? void 0 : source.lift);
+}
+function operate(init) {
+  return (source) => {
+    if (hasLift(source)) {
+      return source.lift(function(liftedSource) {
+        try {
+          return init(liftedSource, this);
+        } catch (err) {
+          this.error(err);
+        }
+      });
+    }
+    throw new TypeError("Unable to lift unknown Observable type");
+  };
+}
+
+// node_modules/rxjs/dist/esm/internal/operators/OperatorSubscriber.js
+function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
+  return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
+}
+var OperatorSubscriber = class extends Subscriber {
+  constructor(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
+    super(destination);
+    this.onFinalize = onFinalize;
+    this.shouldUnsubscribe = shouldUnsubscribe;
+    this._next = onNext ? function(value) {
+      try {
+        onNext(value);
+      } catch (err) {
+        destination.error(err);
+      }
+    } : super._next;
+    this._error = onError ? function(err) {
+      try {
+        onError(err);
+      } catch (err2) {
+        destination.error(err2);
+      } finally {
+        this.unsubscribe();
+      }
+    } : super._error;
+    this._complete = onComplete ? function() {
+      try {
+        onComplete();
+      } catch (err) {
+        destination.error(err);
+      } finally {
+        this.unsubscribe();
+      }
+    } : super._complete;
+  }
+  unsubscribe() {
+    var _a;
+    if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+      const { closed } = this;
+      super.unsubscribe();
+      !closed && ((_a = this.onFinalize) === null || _a === void 0 ? void 0 : _a.call(this));
+    }
+  }
+};
+
+// node_modules/rxjs/dist/esm/internal/util/ObjectUnsubscribedError.js
+var ObjectUnsubscribedError = createErrorClass((_super) => function ObjectUnsubscribedErrorImpl() {
+  _super(this);
+  this.name = "ObjectUnsubscribedError";
+  this.message = "object unsubscribed";
+});
+
+// node_modules/rxjs/dist/esm/internal/Subject.js
+var Subject = class extends Observable {
+  constructor() {
+    super();
+    this.closed = false;
+    this.currentObservers = null;
+    this.observers = [];
+    this.isStopped = false;
+    this.hasError = false;
+    this.thrownError = null;
+  }
+  lift(operator) {
+    const subject = new AnonymousSubject(this, this);
+    subject.operator = operator;
+    return subject;
+  }
+  _throwIfClosed() {
+    if (this.closed) {
+      throw new ObjectUnsubscribedError();
+    }
+  }
+  next(value) {
+    errorContext(() => {
+      this._throwIfClosed();
+      if (!this.isStopped) {
+        if (!this.currentObservers) {
+          this.currentObservers = Array.from(this.observers);
+        }
+        for (const observer of this.currentObservers) {
+          observer.next(value);
+        }
+      }
+    });
+  }
+  error(err) {
+    errorContext(() => {
+      this._throwIfClosed();
+      if (!this.isStopped) {
+        this.hasError = this.isStopped = true;
+        this.thrownError = err;
+        const { observers } = this;
+        while (observers.length) {
+          observers.shift().error(err);
+        }
+      }
+    });
+  }
+  complete() {
+    errorContext(() => {
+      this._throwIfClosed();
+      if (!this.isStopped) {
+        this.isStopped = true;
+        const { observers } = this;
+        while (observers.length) {
+          observers.shift().complete();
+        }
+      }
+    });
+  }
+  unsubscribe() {
+    this.isStopped = this.closed = true;
+    this.observers = this.currentObservers = null;
+  }
+  get observed() {
+    var _a;
+    return ((_a = this.observers) === null || _a === void 0 ? void 0 : _a.length) > 0;
+  }
+  _trySubscribe(subscriber) {
+    this._throwIfClosed();
+    return super._trySubscribe(subscriber);
+  }
+  _subscribe(subscriber) {
+    this._throwIfClosed();
+    this._checkFinalizedStatuses(subscriber);
+    return this._innerSubscribe(subscriber);
+  }
+  _innerSubscribe(subscriber) {
+    const { hasError, isStopped, observers } = this;
+    if (hasError || isStopped) {
+      return EMPTY_SUBSCRIPTION;
+    }
+    this.currentObservers = null;
+    observers.push(subscriber);
+    return new Subscription(() => {
+      this.currentObservers = null;
+      arrRemove(observers, subscriber);
+    });
+  }
+  _checkFinalizedStatuses(subscriber) {
+    const { hasError, thrownError, isStopped } = this;
+    if (hasError) {
+      subscriber.error(thrownError);
+    } else if (isStopped) {
+      subscriber.complete();
+    }
+  }
+  asObservable() {
+    const observable2 = new Observable();
+    observable2.source = this;
+    return observable2;
+  }
+};
+Subject.create = (destination, source) => {
+  return new AnonymousSubject(destination, source);
+};
+var AnonymousSubject = class extends Subject {
+  constructor(destination, source) {
+    super();
+    this.destination = destination;
+    this.source = source;
+  }
+  next(value) {
+    var _a, _b;
+    (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.call(_a, value);
+  }
+  error(err) {
+    var _a, _b;
+    (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
+  }
+  complete() {
+    var _a, _b;
+    (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.complete) === null || _b === void 0 ? void 0 : _b.call(_a);
+  }
+  _subscribe(subscriber) {
+    var _a, _b;
+    return (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber)) !== null && _b !== void 0 ? _b : EMPTY_SUBSCRIPTION;
+  }
+};
+
+// node_modules/rxjs/dist/esm/internal/BehaviorSubject.js
+var BehaviorSubject = class extends Subject {
+  constructor(_value) {
+    super();
+    this._value = _value;
+  }
+  get value() {
+    return this.getValue();
+  }
+  _subscribe(subscriber) {
+    const subscription = super._subscribe(subscriber);
+    !subscription.closed && subscriber.next(this._value);
+    return subscription;
+  }
+  getValue() {
+    const { hasError, thrownError, _value } = this;
+    if (hasError) {
+      throw thrownError;
+    }
+    this._throwIfClosed();
+    return _value;
+  }
+  next(value) {
+    super.next(this._value = value);
+  }
+};
+
+// node_modules/rxjs/dist/esm/internal/scheduler/dateTimestampProvider.js
+var dateTimestampProvider = {
+  now() {
+    return (dateTimestampProvider.delegate || Date).now();
+  },
+  delegate: void 0
+};
+
+// node_modules/rxjs/dist/esm/internal/scheduler/Action.js
+var Action = class extends Subscription {
+  constructor(scheduler, work) {
+    super();
+  }
+  schedule(state, delay = 0) {
+    return this;
+  }
+};
+
+// node_modules/rxjs/dist/esm/internal/scheduler/intervalProvider.js
+var intervalProvider = {
+  setInterval(handler, timeout2, ...args) {
+    const { delegate } = intervalProvider;
+    if (delegate === null || delegate === void 0 ? void 0 : delegate.setInterval) {
+      return delegate.setInterval(handler, timeout2, ...args);
+    }
+    return setInterval(handler, timeout2, ...args);
+  },
+  clearInterval(handle) {
+    const { delegate } = intervalProvider;
+    return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearInterval) || clearInterval)(handle);
+  },
+  delegate: void 0
+};
+
+// node_modules/rxjs/dist/esm/internal/scheduler/AsyncAction.js
+var AsyncAction = class extends Action {
+  constructor(scheduler, work) {
+    super(scheduler, work);
+    this.scheduler = scheduler;
+    this.work = work;
+    this.pending = false;
+  }
+  schedule(state, delay = 0) {
+    var _a;
+    if (this.closed) {
+      return this;
+    }
+    this.state = state;
+    const id = this.id;
+    const scheduler = this.scheduler;
+    if (id != null) {
+      this.id = this.recycleAsyncId(scheduler, id, delay);
+    }
+    this.pending = true;
+    this.delay = delay;
+    this.id = (_a = this.id) !== null && _a !== void 0 ? _a : this.requestAsyncId(scheduler, this.id, delay);
+    return this;
+  }
+  requestAsyncId(scheduler, _id, delay = 0) {
+    return intervalProvider.setInterval(scheduler.flush.bind(scheduler, this), delay);
+  }
+  recycleAsyncId(_scheduler, id, delay = 0) {
+    if (delay != null && this.delay === delay && this.pending === false) {
+      return id;
+    }
+    if (id != null) {
+      intervalProvider.clearInterval(id);
+    }
+    return void 0;
+  }
+  execute(state, delay) {
+    if (this.closed) {
+      return new Error("executing a cancelled action");
+    }
+    this.pending = false;
+    const error = this._execute(state, delay);
+    if (error) {
+      return error;
+    } else if (this.pending === false && this.id != null) {
+      this.id = this.recycleAsyncId(this.scheduler, this.id, null);
+    }
+  }
+  _execute(state, _delay) {
+    let errored = false;
+    let errorValue;
+    try {
+      this.work(state);
+    } catch (e) {
+      errored = true;
+      errorValue = e ? e : new Error("Scheduled action threw falsy error");
+    }
+    if (errored) {
+      this.unsubscribe();
+      return errorValue;
+    }
+  }
+  unsubscribe() {
+    if (!this.closed) {
+      const { id, scheduler } = this;
+      const { actions } = scheduler;
+      this.work = this.state = this.scheduler = null;
+      this.pending = false;
+      arrRemove(actions, this);
+      if (id != null) {
+        this.id = this.recycleAsyncId(scheduler, id, null);
+      }
+      this.delay = null;
+      super.unsubscribe();
+    }
+  }
+};
+
+// node_modules/rxjs/dist/esm/internal/Scheduler.js
+var Scheduler = class _Scheduler {
+  constructor(schedulerActionCtor, now = _Scheduler.now) {
+    this.schedulerActionCtor = schedulerActionCtor;
+    this.now = now;
+  }
+  schedule(work, delay = 0, state) {
+    return new this.schedulerActionCtor(this, work).schedule(state, delay);
+  }
+};
+Scheduler.now = dateTimestampProvider.now;
+
+// node_modules/rxjs/dist/esm/internal/scheduler/AsyncScheduler.js
+var AsyncScheduler = class extends Scheduler {
+  constructor(SchedulerAction, now = Scheduler.now) {
+    super(SchedulerAction, now);
+    this.actions = [];
+    this._active = false;
+  }
+  flush(action) {
+    const { actions } = this;
+    if (this._active) {
+      actions.push(action);
+      return;
+    }
+    let error;
+    this._active = true;
+    do {
+      if (error = action.execute(action.state, action.delay)) {
+        break;
+      }
+    } while (action = actions.shift());
+    this._active = false;
+    if (error) {
+      while (action = actions.shift()) {
+        action.unsubscribe();
+      }
+      throw error;
+    }
+  }
+};
+
+// node_modules/rxjs/dist/esm/internal/scheduler/async.js
+var asyncScheduler = new AsyncScheduler(AsyncAction);
+
+// node_modules/rxjs/dist/esm/internal/observable/empty.js
+var EMPTY = new Observable((subscriber) => subscriber.complete());
+
+// node_modules/rxjs/dist/esm/internal/util/isScheduler.js
+function isScheduler(value) {
+  return value && isFunction(value.schedule);
+}
+
+// node_modules/rxjs/dist/esm/internal/util/args.js
+function last(arr) {
+  return arr[arr.length - 1];
+}
+function popResultSelector(args) {
+  return isFunction(last(args)) ? args.pop() : void 0;
+}
+function popScheduler(args) {
+  return isScheduler(last(args)) ? args.pop() : void 0;
+}
+
+// node_modules/tslib/tslib.es6.mjs
+function __awaiter(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+}
+function __values(o) {
+  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+  if (m) return m.call(o);
+  if (o && typeof o.length === "number") return {
+    next: function() {
+      if (o && i >= o.length) o = void 0;
+      return { value: o && o[i++], done: !o };
+    }
+  };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __await(v) {
+  return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+function __asyncGenerator(thisArg, _arguments, generator) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var g = generator.apply(thisArg, _arguments || []), i, q = [];
+  return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i;
+  function awaitReturn(f) {
+    return function(v) {
+      return Promise.resolve(v).then(f, reject);
+    };
+  }
+  function verb(n, f) {
+    if (g[n]) {
+      i[n] = function(v) {
+        return new Promise(function(a, b) {
+          q.push([n, v, a, b]) > 1 || resume(n, v);
+        });
+      };
+      if (f) i[n] = f(i[n]);
+    }
+  }
+  function resume(n, v) {
+    try {
+      step(g[n](v));
+    } catch (e) {
+      settle(q[0][3], e);
+    }
+  }
+  function step(r) {
+    r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+  }
+  function fulfill(value) {
+    resume("next", value);
+  }
+  function reject(value) {
+    resume("throw", value);
+  }
+  function settle(f, v) {
+    if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+  }
+}
+function __asyncValues(o) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var m = o[Symbol.asyncIterator], i;
+  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() {
+    return this;
+  }, i);
+  function verb(n) {
+    i[n] = o[n] && function(v) {
+      return new Promise(function(resolve, reject) {
+        v = o[n](v), settle(resolve, reject, v.done, v.value);
+      });
+    };
+  }
+  function settle(resolve, reject, d, v) {
+    Promise.resolve(v).then(function(v2) {
+      resolve({ value: v2, done: d });
+    }, reject);
+  }
+}
+
+// node_modules/rxjs/dist/esm/internal/util/isArrayLike.js
+var isArrayLike = ((x) => x && typeof x.length === "number" && typeof x !== "function");
+
+// node_modules/rxjs/dist/esm/internal/util/isPromise.js
+function isPromise(value) {
+  return isFunction(value === null || value === void 0 ? void 0 : value.then);
+}
+
+// node_modules/rxjs/dist/esm/internal/util/isInteropObservable.js
+function isInteropObservable(input2) {
+  return isFunction(input2[observable]);
+}
+
+// node_modules/rxjs/dist/esm/internal/util/isAsyncIterable.js
+function isAsyncIterable(obj) {
+  return Symbol.asyncIterator && isFunction(obj === null || obj === void 0 ? void 0 : obj[Symbol.asyncIterator]);
+}
+
+// node_modules/rxjs/dist/esm/internal/util/throwUnobservableError.js
+function createInvalidObservableTypeError(input2) {
+  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.`);
+}
+
+// node_modules/rxjs/dist/esm/internal/symbol/iterator.js
+function getSymbolIterator() {
+  if (typeof Symbol !== "function" || !Symbol.iterator) {
+    return "@@iterator";
+  }
+  return Symbol.iterator;
+}
+var iterator = getSymbolIterator();
+
+// node_modules/rxjs/dist/esm/internal/util/isIterable.js
+function isIterable(input2) {
+  return isFunction(input2 === null || input2 === void 0 ? void 0 : input2[iterator]);
+}
+
+// node_modules/rxjs/dist/esm/internal/util/isReadableStreamLike.js
+function readableStreamLikeToAsyncGenerator(readableStream) {
+  return __asyncGenerator(this, arguments, function* readableStreamLikeToAsyncGenerator_1() {
+    const reader = readableStream.getReader();
+    try {
+      while (true) {
+        const { value, done } = yield __await(reader.read());
+        if (done) {
+          return yield __await(void 0);
+        }
+        yield yield __await(value);
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  });
+}
+function isReadableStreamLike(obj) {
+  return isFunction(obj === null || obj === void 0 ? void 0 : obj.getReader);
+}
+
+// node_modules/rxjs/dist/esm/internal/observable/innerFrom.js
+function innerFrom(input2) {
+  if (input2 instanceof Observable) {
+    return input2;
+  }
+  if (input2 != null) {
+    if (isInteropObservable(input2)) {
+      return fromInteropObservable(input2);
+    }
+    if (isArrayLike(input2)) {
+      return fromArrayLike(input2);
+    }
+    if (isPromise(input2)) {
+      return fromPromise(input2);
+    }
+    if (isAsyncIterable(input2)) {
+      return fromAsyncIterable(input2);
+    }
+    if (isIterable(input2)) {
+      return fromIterable(input2);
+    }
+    if (isReadableStreamLike(input2)) {
+      return fromReadableStreamLike(input2);
+    }
+  }
+  throw createInvalidObservableTypeError(input2);
+}
+function fromInteropObservable(obj) {
+  return new Observable((subscriber) => {
+    const obs = obj[observable]();
+    if (isFunction(obs.subscribe)) {
+      return obs.subscribe(subscriber);
+    }
+    throw new TypeError("Provided object does not correctly implement Symbol.observable");
+  });
+}
+function fromArrayLike(array) {
+  return new Observable((subscriber) => {
+    for (let i = 0; i < array.length && !subscriber.closed; i++) {
+      subscriber.next(array[i]);
+    }
+    subscriber.complete();
+  });
+}
+function fromPromise(promise) {
+  return new Observable((subscriber) => {
+    promise.then((value) => {
+      if (!subscriber.closed) {
+        subscriber.next(value);
+        subscriber.complete();
+      }
+    }, (err) => subscriber.error(err)).then(null, reportUnhandledError);
+  });
+}
+function fromIterable(iterable) {
+  return new Observable((subscriber) => {
+    for (const value of iterable) {
+      subscriber.next(value);
+      if (subscriber.closed) {
+        return;
+      }
+    }
+    subscriber.complete();
+  });
+}
+function fromAsyncIterable(asyncIterable) {
+  return new Observable((subscriber) => {
+    process(asyncIterable, subscriber).catch((err) => subscriber.error(err));
+  });
+}
+function fromReadableStreamLike(readableStream) {
+  return fromAsyncIterable(readableStreamLikeToAsyncGenerator(readableStream));
+}
+function process(asyncIterable, subscriber) {
+  var asyncIterable_1, asyncIterable_1_1;
+  var e_1, _a;
+  return __awaiter(this, void 0, void 0, function* () {
+    try {
+      for (asyncIterable_1 = __asyncValues(asyncIterable); asyncIterable_1_1 = yield asyncIterable_1.next(), !asyncIterable_1_1.done; ) {
+        const value = asyncIterable_1_1.value;
+        subscriber.next(value);
+        if (subscriber.closed) {
+          return;
+        }
+      }
+    } catch (e_1_1) {
+      e_1 = { error: e_1_1 };
+    } finally {
+      try {
+        if (asyncIterable_1_1 && !asyncIterable_1_1.done && (_a = asyncIterable_1.return)) yield _a.call(asyncIterable_1);
+      } finally {
+        if (e_1) throw e_1.error;
+      }
+    }
+    subscriber.complete();
+  });
+}
+
+// node_modules/rxjs/dist/esm/internal/util/executeSchedule.js
+function executeSchedule(parentSubscription, scheduler, work, delay = 0, repeat = false) {
+  const scheduleSubscription = scheduler.schedule(function() {
+    work();
+    if (repeat) {
+      parentSubscription.add(this.schedule(null, delay));
+    } else {
+      this.unsubscribe();
+    }
+  }, delay);
+  parentSubscription.add(scheduleSubscription);
+  if (!repeat) {
+    return scheduleSubscription;
+  }
+}
+
+// node_modules/rxjs/dist/esm/internal/operators/observeOn.js
+function observeOn(scheduler, delay = 0) {
+  return operate((source, subscriber) => {
+    source.subscribe(createOperatorSubscriber(subscriber, (value) => executeSchedule(subscriber, scheduler, () => subscriber.next(value), delay), () => executeSchedule(subscriber, scheduler, () => subscriber.complete(), delay), (err) => executeSchedule(subscriber, scheduler, () => subscriber.error(err), delay)));
+  });
+}
+
+// node_modules/rxjs/dist/esm/internal/operators/subscribeOn.js
+function subscribeOn(scheduler, delay = 0) {
+  return operate((source, subscriber) => {
+    subscriber.add(scheduler.schedule(() => source.subscribe(subscriber), delay));
+  });
+}
+
+// node_modules/rxjs/dist/esm/internal/scheduled/scheduleObservable.js
+function scheduleObservable(input2, scheduler) {
+  return innerFrom(input2).pipe(subscribeOn(scheduler), observeOn(scheduler));
+}
+
+// node_modules/rxjs/dist/esm/internal/scheduled/schedulePromise.js
+function schedulePromise(input2, scheduler) {
+  return innerFrom(input2).pipe(subscribeOn(scheduler), observeOn(scheduler));
+}
+
+// node_modules/rxjs/dist/esm/internal/scheduled/scheduleArray.js
+function scheduleArray(input2, scheduler) {
+  return new Observable((subscriber) => {
+    let i = 0;
+    return scheduler.schedule(function() {
+      if (i === input2.length) {
+        subscriber.complete();
+      } else {
+        subscriber.next(input2[i++]);
+        if (!subscriber.closed) {
+          this.schedule();
+        }
+      }
+    });
+  });
+}
+
+// node_modules/rxjs/dist/esm/internal/scheduled/scheduleIterable.js
+function scheduleIterable(input2, scheduler) {
+  return new Observable((subscriber) => {
+    let iterator2;
+    executeSchedule(subscriber, scheduler, () => {
+      iterator2 = input2[iterator]();
+      executeSchedule(subscriber, scheduler, () => {
+        let value;
+        let done;
+        try {
+          ({ value, done } = iterator2.next());
+        } catch (err) {
+          subscriber.error(err);
+          return;
+        }
+        if (done) {
+          subscriber.complete();
+        } else {
+          subscriber.next(value);
+        }
+      }, 0, true);
+    });
+    return () => isFunction(iterator2 === null || iterator2 === void 0 ? void 0 : iterator2.return) && iterator2.return();
+  });
+}
+
+// node_modules/rxjs/dist/esm/internal/scheduled/scheduleAsyncIterable.js
+function scheduleAsyncIterable(input2, scheduler) {
+  if (!input2) {
+    throw new Error("Iterable cannot be null");
+  }
+  return new Observable((subscriber) => {
+    executeSchedule(subscriber, scheduler, () => {
+      const iterator2 = input2[Symbol.asyncIterator]();
+      executeSchedule(subscriber, scheduler, () => {
+        iterator2.next().then((result) => {
+          if (result.done) {
+            subscriber.complete();
+          } else {
+            subscriber.next(result.value);
+          }
+        });
+      }, 0, true);
+    });
+  });
+}
+
+// node_modules/rxjs/dist/esm/internal/scheduled/scheduleReadableStreamLike.js
+function scheduleReadableStreamLike(input2, scheduler) {
+  return scheduleAsyncIterable(readableStreamLikeToAsyncGenerator(input2), scheduler);
+}
+
+// node_modules/rxjs/dist/esm/internal/scheduled/scheduled.js
+function scheduled(input2, scheduler) {
+  if (input2 != null) {
+    if (isInteropObservable(input2)) {
+      return scheduleObservable(input2, scheduler);
+    }
+    if (isArrayLike(input2)) {
+      return scheduleArray(input2, scheduler);
+    }
+    if (isPromise(input2)) {
+      return schedulePromise(input2, scheduler);
+    }
+    if (isAsyncIterable(input2)) {
+      return scheduleAsyncIterable(input2, scheduler);
+    }
+    if (isIterable(input2)) {
+      return scheduleIterable(input2, scheduler);
+    }
+    if (isReadableStreamLike(input2)) {
+      return scheduleReadableStreamLike(input2, scheduler);
+    }
+  }
+  throw createInvalidObservableTypeError(input2);
+}
+
+// node_modules/rxjs/dist/esm/internal/observable/from.js
+function from(input2, scheduler) {
+  return scheduler ? scheduled(input2, scheduler) : innerFrom(input2);
+}
+
+// node_modules/rxjs/dist/esm/internal/observable/of.js
+function of(...args) {
+  const scheduler = popScheduler(args);
+  return from(args, scheduler);
+}
+
+// node_modules/rxjs/dist/esm/internal/observable/throwError.js
+function throwError(errorOrErrorFactory, scheduler) {
+  const errorFactory = isFunction(errorOrErrorFactory) ? errorOrErrorFactory : () => errorOrErrorFactory;
+  const init = (subscriber) => subscriber.error(errorFactory());
+  return new Observable(scheduler ? (subscriber) => scheduler.schedule(init, 0, subscriber) : init);
+}
+
+// node_modules/rxjs/dist/esm/internal/util/isObservable.js
+function isObservable(obj) {
+  return !!obj && (obj instanceof Observable || isFunction(obj.lift) && isFunction(obj.subscribe));
+}
+
+// node_modules/rxjs/dist/esm/internal/util/EmptyError.js
+var EmptyError = createErrorClass((_super) => function EmptyErrorImpl() {
+  _super(this);
+  this.name = "EmptyError";
+  this.message = "no elements in sequence";
+});
+
+// node_modules/rxjs/dist/esm/internal/util/isDate.js
+function isValidDate(value) {
+  return value instanceof Date && !isNaN(value);
+}
+
+// node_modules/rxjs/dist/esm/internal/operators/timeout.js
+var TimeoutError = createErrorClass((_super) => function TimeoutErrorImpl(info = null) {
+  _super(this);
+  this.message = "Timeout has occurred";
+  this.name = "TimeoutError";
+  this.info = info;
+});
+function timeout(config2, schedulerArg) {
+  const { first: first2, each, with: _with = timeoutErrorFactory, scheduler = schedulerArg !== null && schedulerArg !== void 0 ? schedulerArg : asyncScheduler, meta = null } = isValidDate(config2) ? { first: config2 } : typeof config2 === "number" ? { each: config2 } : config2;
+  if (first2 == null && each == null) {
+    throw new TypeError("No timeout provided.");
+  }
+  return operate((source, subscriber) => {
+    let originalSourceSubscription;
+    let timerSubscription;
+    let lastValue = null;
+    let seen = 0;
+    const startTimer = (delay) => {
+      timerSubscription = executeSchedule(subscriber, scheduler, () => {
+        try {
+          originalSourceSubscription.unsubscribe();
+          innerFrom(_with({
+            meta,
+            lastValue,
+            seen
+          })).subscribe(subscriber);
+        } catch (err) {
+          subscriber.error(err);
+        }
+      }, delay);
+    };
+    originalSourceSubscription = source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+      timerSubscription === null || timerSubscription === void 0 ? void 0 : timerSubscription.unsubscribe();
+      seen++;
+      subscriber.next(lastValue = value);
+      each > 0 && startTimer(each);
+    }, void 0, void 0, () => {
+      if (!(timerSubscription === null || timerSubscription === void 0 ? void 0 : timerSubscription.closed)) {
+        timerSubscription === null || timerSubscription === void 0 ? void 0 : timerSubscription.unsubscribe();
+      }
+      lastValue = null;
+    }));
+    !seen && startTimer(first2 != null ? typeof first2 === "number" ? first2 : +first2 - scheduler.now() : each);
+  });
+}
+function timeoutErrorFactory(info) {
+  throw new TimeoutError(info);
+}
+
+// node_modules/rxjs/dist/esm/internal/operators/map.js
+function map(project, thisArg) {
+  return operate((source, subscriber) => {
+    let index = 0;
+    source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+      subscriber.next(project.call(thisArg, value, index++));
+    }));
+  });
+}
+
+// node_modules/rxjs/dist/esm/internal/util/mapOneOrManyArgs.js
+var { isArray } = Array;
+function callOrApply(fn, args) {
+  return isArray(args) ? fn(...args) : fn(args);
+}
+function mapOneOrManyArgs(fn) {
+  return map((args) => callOrApply(fn, args));
+}
+
+// node_modules/rxjs/dist/esm/internal/util/argsArgArrayOrObject.js
+var { isArray: isArray2 } = Array;
+var { getPrototypeOf, prototype: objectProto, keys: getKeys } = Object;
+function argsArgArrayOrObject(args) {
+  if (args.length === 1) {
+    const first2 = args[0];
+    if (isArray2(first2)) {
+      return { args: first2, keys: null };
+    }
+    if (isPOJO(first2)) {
+      const keys = getKeys(first2);
+      return {
+        args: keys.map((key) => first2[key]),
+        keys
+      };
+    }
+  }
+  return { args, keys: null };
+}
+function isPOJO(obj) {
+  return obj && typeof obj === "object" && getPrototypeOf(obj) === objectProto;
+}
+
+// node_modules/rxjs/dist/esm/internal/util/createObject.js
+function createObject(keys, values) {
+  return keys.reduce((result, key, i) => (result[key] = values[i], result), {});
+}
+
+// node_modules/rxjs/dist/esm/internal/observable/combineLatest.js
+function combineLatest(...args) {
+  const scheduler = popScheduler(args);
+  const resultSelector = popResultSelector(args);
+  const { args: observables, keys } = argsArgArrayOrObject(args);
+  if (observables.length === 0) {
+    return from([], scheduler);
+  }
+  const result = new Observable(combineLatestInit(observables, scheduler, keys ? (values) => createObject(keys, values) : identity));
+  return resultSelector ? result.pipe(mapOneOrManyArgs(resultSelector)) : result;
+}
+function combineLatestInit(observables, scheduler, valueTransform = identity) {
+  return (subscriber) => {
+    maybeSchedule(scheduler, () => {
+      const { length } = observables;
+      const values = new Array(length);
+      let active = length;
+      let remainingFirstValues = length;
+      for (let i = 0; i < length; i++) {
+        maybeSchedule(scheduler, () => {
+          const source = from(observables[i], scheduler);
+          let hasFirstValue = false;
+          source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+            values[i] = value;
+            if (!hasFirstValue) {
+              hasFirstValue = true;
+              remainingFirstValues--;
+            }
+            if (!remainingFirstValues) {
+              subscriber.next(valueTransform(values.slice()));
+            }
+          }, () => {
+            if (!--active) {
+              subscriber.complete();
+            }
+          }));
+        }, subscriber);
+      }
+    }, subscriber);
+  };
+}
+function maybeSchedule(scheduler, execute, subscription) {
+  if (scheduler) {
+    executeSchedule(subscription, scheduler, execute);
+  } else {
+    execute();
+  }
+}
+
+// node_modules/rxjs/dist/esm/internal/operators/mergeInternals.js
+function mergeInternals(source, subscriber, project, concurrent, onBeforeNext, expand, innerSubScheduler, additionalFinalizer) {
+  const buffer = [];
+  let active = 0;
+  let index = 0;
+  let isComplete = false;
+  const checkComplete = () => {
+    if (isComplete && !buffer.length && !active) {
+      subscriber.complete();
+    }
+  };
+  const outerNext = (value) => active < concurrent ? doInnerSub(value) : buffer.push(value);
+  const doInnerSub = (value) => {
+    expand && subscriber.next(value);
+    active++;
+    let innerComplete = false;
+    innerFrom(project(value, index++)).subscribe(createOperatorSubscriber(subscriber, (innerValue) => {
+      onBeforeNext === null || onBeforeNext === void 0 ? void 0 : onBeforeNext(innerValue);
+      if (expand) {
+        outerNext(innerValue);
+      } else {
+        subscriber.next(innerValue);
+      }
+    }, () => {
+      innerComplete = true;
+    }, void 0, () => {
+      if (innerComplete) {
+        try {
+          active--;
+          while (buffer.length && active < concurrent) {
+            const bufferedValue = buffer.shift();
+            if (innerSubScheduler) {
+              executeSchedule(subscriber, innerSubScheduler, () => doInnerSub(bufferedValue));
+            } else {
+              doInnerSub(bufferedValue);
+            }
+          }
+          checkComplete();
+        } catch (err) {
+          subscriber.error(err);
+        }
+      }
+    }));
+  };
+  source.subscribe(createOperatorSubscriber(subscriber, outerNext, () => {
+    isComplete = true;
+    checkComplete();
+  }));
+  return () => {
+    additionalFinalizer === null || additionalFinalizer === void 0 ? void 0 : additionalFinalizer();
+  };
+}
+
+// node_modules/rxjs/dist/esm/internal/operators/mergeMap.js
+function mergeMap(project, resultSelector, concurrent = Infinity) {
+  if (isFunction(resultSelector)) {
+    return mergeMap((a, i) => map((b, ii) => resultSelector(a, b, i, ii))(innerFrom(project(a, i))), concurrent);
+  } else if (typeof resultSelector === "number") {
+    concurrent = resultSelector;
+  }
+  return operate((source, subscriber) => mergeInternals(source, subscriber, project, concurrent));
+}
+
+// node_modules/rxjs/dist/esm/internal/operators/mergeAll.js
+function mergeAll(concurrent = Infinity) {
+  return mergeMap(identity, concurrent);
+}
+
+// node_modules/rxjs/dist/esm/internal/operators/concatAll.js
+function concatAll() {
+  return mergeAll(1);
+}
+
+// node_modules/rxjs/dist/esm/internal/observable/concat.js
+function concat(...args) {
+  return concatAll()(from(args, popScheduler(args)));
+}
+
+// node_modules/rxjs/dist/esm/internal/observable/defer.js
+function defer(observableFactory) {
+  return new Observable((subscriber) => {
+    innerFrom(observableFactory()).subscribe(subscriber);
+  });
+}
+
+// node_modules/rxjs/dist/esm/internal/observable/forkJoin.js
+function forkJoin(...args) {
+  const resultSelector = popResultSelector(args);
+  const { args: sources, keys } = argsArgArrayOrObject(args);
+  const result = new Observable((subscriber) => {
+    const { length } = sources;
+    if (!length) {
+      subscriber.complete();
+      return;
+    }
+    const values = new Array(length);
+    let remainingCompletions = length;
+    let remainingEmissions = length;
+    for (let sourceIndex = 0; sourceIndex < length; sourceIndex++) {
+      let hasValue = false;
+      innerFrom(sources[sourceIndex]).subscribe(createOperatorSubscriber(subscriber, (value) => {
+        if (!hasValue) {
+          hasValue = true;
+          remainingEmissions--;
+        }
+        values[sourceIndex] = value;
+      }, () => remainingCompletions--, void 0, () => {
+        if (!remainingCompletions || !hasValue) {
+          if (!remainingEmissions) {
+            subscriber.next(keys ? createObject(keys, values) : values);
+          }
+          subscriber.complete();
+        }
+      }));
+    }
+  });
+  return resultSelector ? result.pipe(mapOneOrManyArgs(resultSelector)) : result;
+}
+
+// node_modules/rxjs/dist/esm/internal/operators/filter.js
+function filter(predicate, thisArg) {
+  return operate((source, subscriber) => {
+    let index = 0;
+    source.subscribe(createOperatorSubscriber(subscriber, (value) => predicate.call(thisArg, value, index++) && subscriber.next(value)));
+  });
+}
+
+// node_modules/rxjs/dist/esm/internal/operators/catchError.js
+function catchError(selector) {
+  return operate((source, subscriber) => {
+    let innerSub = null;
+    let syncUnsub = false;
+    let handledResult;
+    innerSub = source.subscribe(createOperatorSubscriber(subscriber, void 0, void 0, (err) => {
+      handledResult = innerFrom(selector(err, catchError(selector)(source)));
+      if (innerSub) {
+        innerSub.unsubscribe();
+        innerSub = null;
+        handledResult.subscribe(subscriber);
+      } else {
+        syncUnsub = true;
+      }
+    }));
+    if (syncUnsub) {
+      innerSub.unsubscribe();
+      innerSub = null;
+      handledResult.subscribe(subscriber);
+    }
+  });
+}
+
+// node_modules/rxjs/dist/esm/internal/operators/concatMap.js
+function concatMap(project, resultSelector) {
+  return isFunction(resultSelector) ? mergeMap(project, resultSelector, 1) : mergeMap(project, 1);
+}
+
+// node_modules/rxjs/dist/esm/internal/operators/defaultIfEmpty.js
+function defaultIfEmpty(defaultValue) {
+  return operate((source, subscriber) => {
+    let hasValue = false;
+    source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+      hasValue = true;
+      subscriber.next(value);
+    }, () => {
+      if (!hasValue) {
+        subscriber.next(defaultValue);
+      }
+      subscriber.complete();
+    }));
+  });
+}
+
+// node_modules/rxjs/dist/esm/internal/operators/take.js
+function take(count) {
+  return count <= 0 ? () => EMPTY : operate((source, subscriber) => {
+    let seen = 0;
+    source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+      if (++seen <= count) {
+        subscriber.next(value);
+        if (count <= seen) {
+          subscriber.complete();
+        }
+      }
+    }));
+  });
+}
+
+// node_modules/rxjs/dist/esm/internal/operators/throwIfEmpty.js
+function throwIfEmpty(errorFactory = defaultErrorFactory) {
+  return operate((source, subscriber) => {
+    let hasValue = false;
+    source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+      hasValue = true;
+      subscriber.next(value);
+    }, () => hasValue ? subscriber.complete() : subscriber.error(errorFactory())));
+  });
+}
+function defaultErrorFactory() {
+  return new EmptyError();
+}
+
+// node_modules/rxjs/dist/esm/internal/operators/finalize.js
+function finalize(callback) {
+  return operate((source, subscriber) => {
+    try {
+      source.subscribe(subscriber);
+    } finally {
+      subscriber.add(callback);
+    }
+  });
+}
+
+// node_modules/rxjs/dist/esm/internal/operators/first.js
+function first(predicate, defaultValue) {
+  const hasDefaultValue = arguments.length >= 2;
+  return (source) => source.pipe(predicate ? filter((v, i) => predicate(v, i, source)) : identity, take(1), hasDefaultValue ? defaultIfEmpty(defaultValue) : throwIfEmpty(() => new EmptyError()));
+}
+
+// node_modules/rxjs/dist/esm/internal/operators/takeLast.js
+function takeLast(count) {
+  return count <= 0 ? () => EMPTY : operate((source, subscriber) => {
+    let buffer = [];
+    source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+      buffer.push(value);
+      count < buffer.length && buffer.shift();
+    }, () => {
+      for (const value of buffer) {
+        subscriber.next(value);
+      }
+      subscriber.complete();
+    }, void 0, () => {
+      buffer = null;
+    }));
+  });
+}
+
+// node_modules/rxjs/dist/esm/internal/operators/startWith.js
+function startWith(...values) {
+  const scheduler = popScheduler(values);
+  return operate((source, subscriber) => {
+    (scheduler ? concat(values, source, scheduler) : concat(values, source)).subscribe(subscriber);
+  });
+}
+
+// node_modules/rxjs/dist/esm/internal/operators/switchMap.js
+function switchMap(project, resultSelector) {
+  return operate((source, subscriber) => {
+    let innerSubscriber = null;
+    let index = 0;
+    let isComplete = false;
+    const checkComplete = () => isComplete && !innerSubscriber && subscriber.complete();
+    source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+      innerSubscriber === null || innerSubscriber === void 0 ? void 0 : innerSubscriber.unsubscribe();
+      let innerIndex = 0;
+      const outerIndex = index++;
+      innerFrom(project(value, outerIndex)).subscribe(innerSubscriber = createOperatorSubscriber(subscriber, (innerValue) => subscriber.next(resultSelector ? resultSelector(value, innerValue, outerIndex, innerIndex++) : innerValue), () => {
+        innerSubscriber = null;
+        checkComplete();
+      }));
+    }, () => {
+      isComplete = true;
+      checkComplete();
+    }));
+  });
+}
+
+// node_modules/rxjs/dist/esm/internal/operators/takeUntil.js
+function takeUntil(notifier) {
+  return operate((source, subscriber) => {
+    innerFrom(notifier).subscribe(createOperatorSubscriber(subscriber, () => subscriber.complete(), noop));
+    !subscriber.closed && source.subscribe(subscriber);
+  });
+}
+
+// node_modules/rxjs/dist/esm/internal/operators/tap.js
+function tap(observerOrNext, error, complete) {
+  const tapObserver = isFunction(observerOrNext) || error || complete ? { next: observerOrNext, error, complete } : observerOrNext;
+  return tapObserver ? operate((source, subscriber) => {
+    var _a;
+    (_a = tapObserver.subscribe) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
+    let isUnsub = true;
+    source.subscribe(createOperatorSubscriber(subscriber, (value) => {
+      var _a2;
+      (_a2 = tapObserver.next) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver, value);
+      subscriber.next(value);
+    }, () => {
+      var _a2;
+      isUnsub = false;
+      (_a2 = tapObserver.complete) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver);
+      subscriber.complete();
+    }, (err) => {
+      var _a2;
+      isUnsub = false;
+      (_a2 = tapObserver.error) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver, err);
+      subscriber.error(err);
+    }, () => {
+      var _a2, _b;
+      if (isUnsub) {
+        (_a2 = tapObserver.unsubscribe) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver);
+      }
+      (_b = tapObserver.finalize) === null || _b === void 0 ? void 0 : _b.call(tapObserver);
+    }));
+  }) : identity;
+}
+
+// node_modules/@angular/core/fesm2022/_not_found-chunk.mjs
+/**
+ * @license Angular v21.2.17
+ * (c) 2010-2026 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+var _currentInjector = void 0;
+function getCurrentInjector() {
+  return _currentInjector;
+}
+function setCurrentInjector(injector) {
+  const former = _currentInjector;
+  _currentInjector = injector;
+  return former;
+}
+var NOT_FOUND = /* @__PURE__ */ Symbol("NotFound");
+function isNotFound(e) {
+  return e === NOT_FOUND || e?.name === "\u0275NotFound";
+}
+
+// node_modules/@angular/core/fesm2022/_untracked-chunk.mjs
+/**
+ * @license Angular v21.2.17
+ * (c) 2010-2026 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+function createLinkedSignal(sourceFn, computationFn, equalityFn) {
+  const node = Object.create(LINKED_SIGNAL_NODE);
+  node.source = sourceFn;
+  node.computation = computationFn;
+  if (equalityFn != void 0) {
+    node.equal = equalityFn;
+  }
+  const linkedSignalGetter = () => {
+    producerUpdateValueVersion(node);
+    producerAccessed(node);
+    if (node.value === ERRORED) {
+      throw node.error;
+    }
+    return node.value;
+  };
+  const getter = linkedSignalGetter;
+  getter[SIGNAL] = node;
+  if (typeof ngDevMode !== "undefined" && ngDevMode) {
+    getter.toString = () => `[LinkedSignal${node.debugName ? " (" + node.debugName + ")" : ""}: ${String(node.value)}]`;
+  }
+  runPostProducerCreatedFn(node);
+  return getter;
+}
+function linkedSignalSetFn(node, newValue) {
+  producerUpdateValueVersion(node);
+  signalSetFn(node, newValue);
+  producerMarkClean(node);
+}
+function linkedSignalUpdateFn(node, updater) {
+  producerUpdateValueVersion(node);
+  if (node.value === ERRORED) {
+    throw node.error;
+  }
+  signalUpdateFn(node, updater);
+  producerMarkClean(node);
+}
+var LINKED_SIGNAL_NODE = /* @__PURE__ */ (() => {
+  return __spreadProps(__spreadValues({}, REACTIVE_NODE), {
+    value: UNSET,
+    dirty: true,
+    error: null,
+    equal: defaultEquals,
+    kind: "linkedSignal",
+    producerMustRecompute(node) {
+      return node.value === UNSET || node.value === COMPUTING;
+    },
+    producerRecomputeValue(node) {
+      if (node.value === COMPUTING) {
+        throw new Error(typeof ngDevMode !== "undefined" && ngDevMode ? "Detected cycle in computations." : "");
+      }
+      const oldValue = node.value;
+      node.value = COMPUTING;
+      const prevConsumer = consumerBeforeComputation(node);
+      let newValue;
+      let wasEqual = false;
+      try {
+        const newSourceValue = node.source();
+        const oldValueValid = oldValue !== UNSET && oldValue !== ERRORED;
+        const prev = oldValueValid ? {
+          source: node.sourceValue,
+          value: oldValue
+        } : void 0;
+        newValue = node.computation(newSourceValue, prev);
+        node.sourceValue = newSourceValue;
+        setActiveConsumer(null);
+        wasEqual = oldValueValid && newValue !== ERRORED && node.equal(oldValue, newValue);
+      } catch (err) {
+        newValue = ERRORED;
+        node.error = err;
+      } finally {
+        consumerAfterComputation(node, prevConsumer);
+      }
+      if (wasEqual) {
+        node.value = oldValue;
+        return;
+      }
+      node.value = newValue;
+      node.version++;
+    }
+  });
+})();
+function untracked(nonReactiveReadsFn) {
+  const prevConsumer = setActiveConsumer(null);
+  try {
+    return nonReactiveReadsFn();
+  } finally {
+    setActiveConsumer(prevConsumer);
+  }
+}
+
+// node_modules/@angular/core/fesm2022/primitives-signals.mjs
+/**
+ * @license Angular v21.2.17
+ * (c) 2010-2026 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+var formatter = {
+  header: (sig, config2) => {
+    if (!isSignal(sig) || config2?.ngSkipFormatting) return null;
+    let value;
+    try {
+      value = sig();
+    } catch (e) {
+      return ["span", `Signal(\u26A0\uFE0F Error)${e.message ? `: ${e.message}` : ""}`];
+    }
+    const kind = "computation" in sig[SIGNAL] ? "Computed" : "Signal";
+    const isPrimitive = value === null || !Array.isArray(value) && typeof value !== "object";
+    return ["span", {}, ["span", {}, `${kind}(`], (() => {
+      if (isSignal(value)) {
+        return formatter.header(value, config2);
+      } else if (isPrimitive && value !== void 0 && typeof value !== "function") {
+        return ["object", {
+          object: value
+        }];
+      } else {
+        return prettifyPreview(value);
+      }
+    })(), ["span", {}, `)`]];
+  },
+  hasBody: (sig, config2) => {
+    if (!isSignal(sig)) return false;
+    try {
+      sig();
+    } catch {
+      return false;
+    }
+    return !config2?.ngSkipFormatting;
+  },
+  body: (sig, config2) => {
+    const color = "var(--sys-color-primary)";
+    return ["div", {
+      style: `background: #FFFFFF10; padding-left: 4px; padding-top: 2px; padding-bottom: 2px;`
+    }, ["div", {
+      style: `color: ${color}`
+    }, "Signal value: "], ["div", {
+      style: `padding-left: .5rem;`
+    }, ["object", {
+      object: sig(),
+      config: config2
+    }]], ["div", {
+      style: `color: ${color}`
+    }, "Signal function: "], ["div", {
+      style: `padding-left: .5rem;`
+    }, ["object", {
+      object: sig,
+      config: __spreadProps(__spreadValues({}, config2), {
+        ngSkipFormatting: true
+      })
+    }]]];
+  }
+};
+function prettifyPreview(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return `Array(${value.length})`;
+  if (value instanceof Element) return `<${value.tagName.toLowerCase()}>`;
+  if (value instanceof URL) return `URL`;
+  switch (typeof value) {
+    case "undefined": {
+      return "undefined";
+    }
+    case "function": {
+      if ("prototype" in value) {
+        return "class";
+      } else {
+        return "() => {\u2026}";
+      }
+    }
+    case "object": {
+      if (value.constructor.name === "Object") {
+        return "{\u2026}";
+      } else {
+        return `${value.constructor.name} {}`;
+      }
+    }
+    default: {
+      return ["object", {
+        object: value,
+        config: {
+          ngSkipFormatting: true
+        }
+      }];
+    }
+  }
+}
+function isSignal(value) {
+  return value[SIGNAL] !== void 0;
+}
+function installDevToolsSignalFormatter() {
+  globalThis.devtoolsFormatters ??= [];
+  if (!globalThis.devtoolsFormatters.some((f) => f === formatter)) {
+    globalThis.devtoolsFormatters.push(formatter);
+  }
+}
+if (typeof ngDevMode === "undefined" || ngDevMode) {
+  installDevToolsSignalFormatter();
+}
+
+// node_modules/@angular/core/fesm2022/primitives-di.mjs
+/**
+ * @license Angular v21.2.17
+ * (c) 2010-2026 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+
+// node_modules/@angular/core/fesm2022/_effect-chunk2.mjs
+/**
+ * @license Angular v21.2.17
+ * (c) 2010-2026 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+var Version = class {
+  full;
+  major;
+  minor;
+  patch;
+  constructor(full) {
+    this.full = full;
+    const parts = full.split(".");
+    this.major = parts[0];
+    this.minor = parts[1];
+    this.patch = parts.slice(2).join(".");
+  }
+};
+var VERSION = /* @__PURE__ */ new Version("21.2.17");
+var DOC_PAGE_BASE_URL = (() => {
+  const full = VERSION.full;
+  const isPreRelease = full.includes("-next") || full.includes("-rc") || full === "0.0.0-PLACEHOLDER";
+  const prefix = isPreRelease ? "next" : `v${VERSION.major}`;
+  return `https://${prefix}.angular.dev`;
+})();
+var ERROR_DETAILS_PAGE_BASE_URL = (() => {
+  return `${DOC_PAGE_BASE_URL}/errors`;
+})();
+var XSS_SECURITY_URL = "https://angular.dev/best-practices/security#preventing-cross-site-scripting-xss";
+var RuntimeError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(formatRuntimeError(code, message));
+    this.code = code;
+  }
+};
+function formatRuntimeErrorCode(code) {
+  return `NG0${Math.abs(code)}`;
+}
+function formatRuntimeError(code, message) {
+  const fullCode = formatRuntimeErrorCode(code);
+  let errorMessage = `${fullCode}${message ? ": " + message : ""}`;
+  if (ngDevMode && code < 0) {
+    const addPeriodSeparator = !errorMessage.match(/[.,;!?\n]$/);
+    const separator = addPeriodSeparator ? "." : "";
+    errorMessage = `${errorMessage}${separator} Find more at ${ERROR_DETAILS_PAGE_BASE_URL}/${fullCode}`;
+  }
+  return errorMessage;
+}
+var _global = globalThis;
+function ngDevModeResetPerfCounters() {
+  const locationString = typeof location !== "undefined" ? location.toString() : "";
+  const newCounters = {
+    hydratedNodes: 0,
+    hydratedComponents: 0,
+    dehydratedViewsRemoved: 0,
+    dehydratedViewsCleanupRuns: 0,
+    componentsSkippedHydration: 0,
+    deferBlocksWithIncrementalHydration: 0
+  };
+  const allowNgDevModeTrue = locationString.indexOf("ngDevMode=false") === -1;
+  if (!allowNgDevModeTrue) {
+    _global["ngDevMode"] = false;
+  } else {
+    if (typeof _global["ngDevMode"] !== "object") {
+      _global["ngDevMode"] = {};
+    }
+    Object.assign(_global["ngDevMode"], newCounters);
+  }
+  return newCounters;
+}
+function initNgDevMode() {
+  if (typeof ngDevMode === "undefined" || ngDevMode) {
+    if (typeof ngDevMode !== "object" || Object.keys(ngDevMode).length === 0) {
+      ngDevModeResetPerfCounters();
+    }
+    return typeof ngDevMode !== "undefined" && !!ngDevMode;
+  }
+  return false;
+}
+function getClosureSafeProperty(objWithPropertyToExtract) {
+  for (let key in objWithPropertyToExtract) {
+    if (objWithPropertyToExtract[key] === getClosureSafeProperty) {
+      return key;
+    }
+  }
+  throw Error(typeof ngDevMode !== "undefined" && ngDevMode ? "Could not find renamed property on target object." : "");
+}
+function fillProperties(target, source) {
+  for (const key in source) {
+    if (source.hasOwnProperty(key) && !target.hasOwnProperty(key)) {
+      target[key] = source[key];
+    }
+  }
+}
+function stringify(token) {
+  if (typeof token === "string") {
+    return token;
+  }
+  if (Array.isArray(token)) {
+    return `[${token.map(stringify).join(", ")}]`;
+  }
+  if (token == null) {
+    return "" + token;
+  }
+  const name = token.overriddenName || token.name;
+  if (name) {
+    return `${name}`;
+  }
+  const result = token.toString();
+  if (result == null) {
+    return "" + result;
+  }
+  const newLineIndex = result.indexOf("\n");
+  return newLineIndex >= 0 ? result.slice(0, newLineIndex) : result;
+}
+function concatStringsWithSpace(before, after) {
+  if (!before) return after || "";
+  if (!after) return before;
+  return `${before} ${after}`;
+}
+function truncateMiddle(str, maxLength = 100) {
+  if (!str || maxLength < 1 || str.length <= maxLength) return str;
+  if (maxLength == 1) return str.substring(0, 1) + "...";
+  const halfLimit = Math.round(maxLength / 2);
+  return str.substring(0, halfLimit) + "..." + str.substring(str.length - halfLimit);
+}
+var __forward_ref__ = getClosureSafeProperty({
+  __forward_ref__: getClosureSafeProperty
+});
+function forwardRef(forwardRefFn) {
+  forwardRefFn.__forward_ref__ = forwardRef;
+  if (ngDevMode) {
+    forwardRefFn.toString = function() {
+      return stringify(this());
+    };
+  }
+  return forwardRefFn;
+}
+function resolveForwardRef(type) {
+  return isForwardRef(type) ? type() : type;
+}
+function isForwardRef(fn) {
+  return typeof fn === "function" && fn.hasOwnProperty(__forward_ref__) && fn.__forward_ref__ === forwardRef;
+}
+function assertNumber(actual, msg) {
+  if (!(typeof actual === "number")) {
+    throwError2(msg, typeof actual, "number", "===");
+  }
+}
+function assertNumberInRange(actual, minInclusive, maxInclusive) {
+  assertNumber(actual, "Expected a number");
+  assertLessThanOrEqual(actual, maxInclusive, "Expected number to be less than or equal to");
+  assertGreaterThanOrEqual(actual, minInclusive, "Expected number to be greater than or equal to");
+}
+function assertString(actual, msg) {
+  if (!(typeof actual === "string")) {
+    throwError2(msg, actual === null ? "null" : typeof actual, "string", "===");
+  }
+}
+function assertFunction(actual, msg) {
+  if (!(typeof actual === "function")) {
+    throwError2(msg, actual === null ? "null" : typeof actual, "function", "===");
+  }
+}
+function assertEqual(actual, expected, msg) {
+  if (!(actual == expected)) {
+    throwError2(msg, actual, expected, "==");
+  }
+}
+function assertNotEqual(actual, expected, msg) {
+  if (!(actual != expected)) {
+    throwError2(msg, actual, expected, "!=");
+  }
+}
+function assertSame(actual, expected, msg) {
+  if (!(actual === expected)) {
+    throwError2(msg, actual, expected, "===");
+  }
+}
+function assertNotSame(actual, expected, msg) {
+  if (!(actual !== expected)) {
+    throwError2(msg, actual, expected, "!==");
+  }
+}
+function assertLessThan(actual, expected, msg) {
+  if (!(actual < expected)) {
+    throwError2(msg, actual, expected, "<");
+  }
+}
+function assertLessThanOrEqual(actual, expected, msg) {
+  if (!(actual <= expected)) {
+    throwError2(msg, actual, expected, "<=");
+  }
+}
+function assertGreaterThan(actual, expected, msg) {
+  if (!(actual > expected)) {
+    throwError2(msg, actual, expected, ">");
+  }
+}
+function assertGreaterThanOrEqual(actual, expected, msg) {
+  if (!(actual >= expected)) {
+    throwError2(msg, actual, expected, ">=");
+  }
+}
+function assertDefined(actual, msg) {
+  if (actual == null) {
+    throwError2(msg, actual, null, "!=");
+  }
+}
+function throwError2(msg, actual, expected, comparison) {
+  throw new Error(`ASSERTION ERROR: ${msg}` + (comparison == null ? "" : ` [Expected=> ${expected} ${comparison} ${actual} <=Actual]`));
+}
+function assertDomNode(node) {
+  if (!(node instanceof Node)) {
+    throwError2(`The provided value must be an instance of a DOM Node but got ${stringify(node)}`);
+  }
+}
+function assertElement(node) {
+  if (!(node instanceof Element)) {
+    throwError2(`The provided value must be an element but got ${stringify(node)}`);
+  }
+}
+function assertIndexInRange(arr, index) {
+  assertDefined(arr, "Array must be defined.");
+  const maxLen = arr.length;
+  if (index < 0 || index >= maxLen) {
+    throwError2(`Index expected to be less than ${maxLen} but got ${index}`);
+  }
+}
+function assertOneOf(value, ...validValues) {
+  if (validValues.indexOf(value) !== -1) return true;
+  throwError2(`Expected value to be one of ${JSON.stringify(validValues)} but was ${JSON.stringify(value)}.`);
+}
+function assertNotReactive(fn) {
+  if (getActiveConsumer() !== null) {
+    throwError2(`${fn}() should never be called in a reactive context.`);
+  }
+}
+function \u0275\u0275defineInjectable(opts) {
+  return {
+    token: opts.token,
+    providedIn: opts.providedIn || null,
+    factory: opts.factory,
+    value: void 0
+  };
+}
+function \u0275\u0275defineInjector(options) {
+  return {
+    providers: options.providers || [],
+    imports: options.imports || []
+  };
+}
+function getInjectableDef(type) {
+  return getOwnDefinition(type, NG_PROV_DEF);
+}
+function isInjectable(type) {
+  return getInjectableDef(type) !== null;
+}
+function getOwnDefinition(type, field) {
+  return type.hasOwnProperty(field) && type[field] || null;
+}
+function getInheritedInjectableDef(type) {
+  const def = type?.[NG_PROV_DEF] ?? null;
+  if (def) {
+    ngDevMode && console.warn(`DEPRECATED: DI is instantiating a token "${type.name}" that inherits its @Injectable decorator but does not provide one itself.
+This will become an error in a future version of Angular. Please add @Injectable() to the "${type.name}" class.`);
+    return def;
+  } else {
+    return null;
+  }
+}
+function getInjectorDef(type) {
+  return type && type.hasOwnProperty(NG_INJ_DEF) ? type[NG_INJ_DEF] : null;
+}
+var NG_PROV_DEF = getClosureSafeProperty({
+  \u0275prov: getClosureSafeProperty
+});
+var NG_INJ_DEF = getClosureSafeProperty({
+  \u0275inj: getClosureSafeProperty
+});
+var InjectionToken = class {
+  _desc;
+  ngMetadataName = "InjectionToken";
+  \u0275prov;
+  constructor(_desc, options) {
+    this._desc = _desc;
+    this.\u0275prov = void 0;
+    if (typeof options == "number") {
+      (typeof ngDevMode === "undefined" || ngDevMode) && assertLessThan(options, 0, "Only negative numbers are supported here");
+      this.__NG_ELEMENT_ID__ = options;
+    } else if (options !== void 0) {
+      this.\u0275prov = \u0275\u0275defineInjectable({
+        token: this,
+        providedIn: options.providedIn || "root",
+        factory: options.factory
+      });
+    }
+  }
+  get multi() {
+    return this;
+  }
+  toString() {
+    return `InjectionToken ${this._desc}`;
+  }
+};
+var _injectorProfilerContext;
+function getInjectorProfilerContext() {
+  !ngDevMode && throwError2("getInjectorProfilerContext should never be called in production mode");
+  return _injectorProfilerContext;
+}
+function setInjectorProfilerContext(context2) {
+  !ngDevMode && throwError2("setInjectorProfilerContext should never be called in production mode");
+  const previous = _injectorProfilerContext;
+  _injectorProfilerContext = context2;
+  return previous;
+}
+var injectorProfilerCallbacks = [];
+var NOOP_PROFILER_REMOVAL = () => {
+};
+function removeProfiler(profiler2) {
+  const profilerIdx = injectorProfilerCallbacks.indexOf(profiler2);
+  if (profilerIdx !== -1) {
+    injectorProfilerCallbacks.splice(profilerIdx, 1);
+  }
+}
+function setInjectorProfiler(injectorProfiler2) {
+  !ngDevMode && throwError2("setInjectorProfiler should never be called in production mode");
+  if (injectorProfiler2 !== null) {
+    if (!injectorProfilerCallbacks.includes(injectorProfiler2)) {
+      injectorProfilerCallbacks.push(injectorProfiler2);
+    }
+    return () => removeProfiler(injectorProfiler2);
+  } else {
+    injectorProfilerCallbacks.length = 0;
+    return NOOP_PROFILER_REMOVAL;
+  }
+}
+function injectorProfiler(event) {
+  !ngDevMode && throwError2("Injector profiler should never be called in production mode");
+  for (let i = 0; i < injectorProfilerCallbacks.length; i++) {
+    const injectorProfilerCallback = injectorProfilerCallbacks[i];
+    injectorProfilerCallback(event);
+  }
+}
+function emitProviderConfiguredEvent(eventProvider, isViewProvider = false) {
+  !ngDevMode && throwError2("Injector profiler should never be called in production mode");
+  let token;
+  if (typeof eventProvider === "function") {
+    token = eventProvider;
+  } else if (eventProvider instanceof InjectionToken) {
+    token = eventProvider;
+  } else {
+    token = resolveForwardRef(eventProvider.provide);
+  }
+  let provider = eventProvider;
+  if (eventProvider instanceof InjectionToken) {
+    provider = eventProvider.\u0275prov || eventProvider;
+  }
+  injectorProfiler({
+    type: 2,
+    context: getInjectorProfilerContext(),
+    providerRecord: {
+      token,
+      provider,
+      isViewProvider
+    }
+  });
+}
+function emitInjectorToCreateInstanceEvent(token) {
+  !ngDevMode && throwError2("Injector profiler should never be called in production mode");
+  injectorProfiler({
+    type: 5,
+    context: getInjectorProfilerContext(),
+    token
+  });
+}
+function emitInstanceCreatedByInjectorEvent(instance) {
+  !ngDevMode && throwError2("Injector profiler should never be called in production mode");
+  injectorProfiler({
+    type: 1,
+    context: getInjectorProfilerContext(),
+    instance: {
+      value: instance
+    }
+  });
+}
+function emitInjectEvent(token, value, flags) {
+  !ngDevMode && throwError2("Injector profiler should never be called in production mode");
+  injectorProfiler({
+    type: 0,
+    context: getInjectorProfilerContext(),
+    service: {
+      token,
+      value,
+      flags
+    }
+  });
+}
+function emitEffectCreatedEvent(effect2) {
+  !ngDevMode && throwError2("Injector profiler should never be called in production mode");
+  injectorProfiler({
+    type: 3,
+    context: getInjectorProfilerContext(),
+    effect: effect2
+  });
+}
+function runInInjectorProfilerContext(injector, token, callback) {
+  !ngDevMode && throwError2("runInInjectorProfilerContext should never be called in production mode");
+  const prevInjectContext = setInjectorProfilerContext({
+    injector,
+    token
+  });
+  try {
+    callback();
+  } finally {
+    setInjectorProfilerContext(prevInjectContext);
+  }
+}
+function isEnvironmentProviders(value) {
+  return value && !!value.\u0275providers;
+}
+var NG_COMP_DEF = getClosureSafeProperty({
+  \u0275cmp: getClosureSafeProperty
+});
+var NG_DIR_DEF = getClosureSafeProperty({
+  \u0275dir: getClosureSafeProperty
+});
+var NG_PIPE_DEF = getClosureSafeProperty({
+  \u0275pipe: getClosureSafeProperty
+});
+var NG_MOD_DEF = getClosureSafeProperty({
+  \u0275mod: getClosureSafeProperty
+});
+var NG_FACTORY_DEF = getClosureSafeProperty({
+  \u0275fac: getClosureSafeProperty
+});
+var NG_ELEMENT_ID = getClosureSafeProperty({
+  __NG_ELEMENT_ID__: getClosureSafeProperty
+});
+var NG_ENV_ID = getClosureSafeProperty({
+  __NG_ENV_ID__: getClosureSafeProperty
+});
+function getNgModuleDef(type) {
+  assertTypeDefined(type, "@NgModule");
+  return type[NG_MOD_DEF] || null;
+}
+function getNgModuleDefOrThrow(type) {
+  const ngModuleDef = getNgModuleDef(type);
+  if (!ngModuleDef) {
+    throw new RuntimeError(915, (typeof ngDevMode === "undefined" || ngDevMode) && `Type ${stringify(type)} does not have '\u0275mod' property.`);
+  }
+  return ngModuleDef;
+}
+function getComponentDef(type) {
+  assertTypeDefined(type, "@Component");
+  return type[NG_COMP_DEF] || null;
+}
+function getDirectiveDefOrThrow(type) {
+  const def = getDirectiveDef(type);
+  if (!def) {
+    throw new RuntimeError(916, (typeof ngDevMode === "undefined" || ngDevMode) && `Type ${stringify(type)} does not have '\u0275dir' property.`);
+  }
+  return def;
+}
+function getDirectiveDef(type) {
+  assertTypeDefined(type, "@Directive");
+  return type[NG_DIR_DEF] || null;
+}
+function getPipeDef(type) {
+  assertTypeDefined(type, "@Pipe");
+  return type[NG_PIPE_DEF] || null;
+}
+function assertTypeDefined(type, symbolType) {
+  if (type == null) {
+    throw new RuntimeError(-919, (typeof ngDevMode === "undefined" || ngDevMode) && `Cannot read ${symbolType} metadata. This can indicate a runtime circular dependency in your app that needs to be resolved.`);
+  }
+}
+function isStandalone(type) {
+  const def = getComponentDef(type) || getDirectiveDef(type) || getPipeDef(type);
+  return def !== null && def.standalone;
+}
+function renderStringify(value) {
+  if (typeof value === "string") return value;
+  if (value == null) return "";
+  return String(value);
+}
+function stringifyForError(value) {
+  if (typeof value === "function") return value.name || value.toString();
+  if (typeof value === "object" && value != null && typeof value.type === "function") {
+    return value.type.name || value.type.toString();
+  }
+  return renderStringify(value);
+}
+function debugStringifyTypeForError(type) {
+  const componentDef = getComponentDef(type);
+  if (componentDef !== null && componentDef.debugInfo) {
+    return stringifyTypeFromDebugInfo(componentDef.debugInfo);
+  }
+  return stringifyForError(type);
+}
+function stringifyTypeFromDebugInfo(debugInfo) {
+  if (!debugInfo.filePath || !debugInfo.lineNumber) {
+    return debugInfo.className;
+  } else {
+    return `${debugInfo.className} (at ${debugInfo.filePath}:${debugInfo.lineNumber})`;
+  }
+}
+var NG_RUNTIME_ERROR_CODE = getClosureSafeProperty({
+  "ngErrorCode": getClosureSafeProperty
+});
+var NG_RUNTIME_ERROR_MESSAGE = getClosureSafeProperty({
+  "ngErrorMessage": getClosureSafeProperty
+});
+var NG_TOKEN_PATH = getClosureSafeProperty({
+  "ngTokenPath": getClosureSafeProperty
+});
+function cyclicDependencyError(token, path) {
+  const message = ngDevMode ? `Circular dependency detected for \`${token}\`.` : "";
+  return createRuntimeError(message, -200, path);
+}
+function cyclicDependencyErrorWithDetails(token, path) {
+  return augmentRuntimeError(cyclicDependencyError(token, path), null);
+}
+function throwMixedMultiProviderError() {
+  throw new Error(`Cannot mix multi providers and regular providers`);
+}
+function throwInvalidProviderError(ngModuleType, providers, provider) {
+  if (ngModuleType && providers) {
+    const providerDetail = providers.map((v) => v == provider ? "?" + provider + "?" : "...");
+    throw new Error(`Invalid provider for the NgModule '${stringify(ngModuleType)}' - only instances of Provider and Type are allowed, got: [${providerDetail.join(", ")}]`);
+  } else if (isEnvironmentProviders(provider)) {
+    if (provider.\u0275fromNgModule) {
+      throw new RuntimeError(-207, `Invalid providers from 'importProvidersFrom' present in a non-environment injector. 'importProvidersFrom' can't be used for component providers.`);
+    } else {
+      throw new RuntimeError(-207, `Invalid providers present in a non-environment injector. 'EnvironmentProviders' can't be used for component providers.`);
+    }
+  } else {
+    throw new Error("Invalid provider");
+  }
+}
+function throwProviderNotFoundError(token, injectorName) {
+  const errorMessage = ngDevMode && `No provider for ${stringifyForError(token)} found${injectorName ? ` in ${injectorName}` : ""}`;
+  throw new RuntimeError(-201, errorMessage);
+}
+function prependTokenToDependencyPath(error, token) {
+  error[NG_TOKEN_PATH] ??= [];
+  const currentPath = error[NG_TOKEN_PATH];
+  let pathStr;
+  if (typeof token === "object" && "multi" in token && token?.multi === true) {
+    assertDefined(token.provide, "Token with multi: true should have a provide property");
+    pathStr = stringifyForError(token.provide);
+  } else {
+    pathStr = stringifyForError(token);
+  }
+  if (currentPath[0] !== pathStr) {
+    error[NG_TOKEN_PATH].unshift(pathStr);
+  }
+}
+function augmentRuntimeError(error, source) {
+  const tokenPath = error[NG_TOKEN_PATH];
+  const errorCode = error[NG_RUNTIME_ERROR_CODE];
+  const message = error[NG_RUNTIME_ERROR_MESSAGE] || error.message;
+  error.message = formatErrorMessage(message, errorCode, tokenPath, source);
+  return error;
+}
+function createRuntimeError(message, code, path) {
+  const error = new RuntimeError(code, message);
+  error[NG_RUNTIME_ERROR_CODE] = code;
+  error[NG_RUNTIME_ERROR_MESSAGE] = message;
+  if (path) {
+    error[NG_TOKEN_PATH] = path;
+  }
+  return error;
+}
+function getRuntimeErrorCode(error) {
+  return error[NG_RUNTIME_ERROR_CODE];
+}
+function formatErrorMessage(text, code, path = [], source = null) {
+  let pathDetails = "";
+  if (path && path.length > 1) {
+    pathDetails = ` Path: ${path.join(" -> ")}.`;
+  }
+  const sourceDetails = source ? ` Source: ${source}.` : "";
+  return formatRuntimeError(code, `${text}${sourceDetails}${pathDetails}`);
+}
+var _injectImplementation;
+function getInjectImplementation() {
+  return _injectImplementation;
+}
+function setInjectImplementation(impl) {
+  const previous = _injectImplementation;
+  _injectImplementation = impl;
+  return previous;
+}
+function injectRootLimpMode(token, notFoundValue, flags) {
+  const injectableDef = getInjectableDef(token);
+  if (injectableDef && injectableDef.providedIn == "root") {
+    return injectableDef.value === void 0 ? injectableDef.value = injectableDef.factory() : injectableDef.value;
+  }
+  if (flags & 8) return null;
+  if (notFoundValue !== void 0) return notFoundValue;
+  throwProviderNotFoundError(token, typeof ngDevMode !== "undefined" && ngDevMode ? "Injector" : "");
+}
+function assertInjectImplementationNotEqual(fn) {
+  ngDevMode && assertNotEqual(_injectImplementation, fn, "Calling \u0275\u0275inject would cause infinite recursion");
+}
+var _THROW_IF_NOT_FOUND = {};
+var THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;
+var DI_DECORATOR_FLAG = "__NG_DI_FLAG__";
+var RetrievingInjector = class {
+  injector;
+  constructor(injector) {
+    this.injector = injector;
+  }
+  retrieve(token, options) {
+    const flags = convertToBitFlags(options) || 0;
+    try {
+      return this.injector.get(token, flags & 8 ? null : THROW_IF_NOT_FOUND, flags);
+    } catch (e) {
+      if (isNotFound(e)) {
+        return e;
+      }
+      throw e;
+    }
+  }
+};
+function injectInjectorOnly(token, flags = 0) {
+  const currentInjector = getCurrentInjector();
+  if (currentInjector === void 0) {
+    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\`.`);
+  } else if (currentInjector === null) {
+    return injectRootLimpMode(token, void 0, flags);
+  } else {
+    const options = convertToInjectOptions(flags);
+    const value = currentInjector.retrieve(token, options);
+    ngDevMode && emitInjectEvent(token, value, flags);
+    if (isNotFound(value)) {
+      if (options.optional) {
+        return null;
+      }
+      throw value;
+    }
+    return value;
+  }
+}
+function \u0275\u0275inject(token, flags = 0) {
+  return (getInjectImplementation() || injectInjectorOnly)(resolveForwardRef(token), flags);
+}
+function \u0275\u0275invalidFactoryDep(index) {
+  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.
+This can happen if the dependency type is a primitive like a string or if an ancestor of this class is missing an Angular decorator.
+
+Please 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.`);
+}
+function inject2(token, options) {
+  return \u0275\u0275inject(token, convertToBitFlags(options));
+}
+function convertToBitFlags(flags) {
+  if (typeof flags === "undefined" || typeof flags === "number") {
+    return flags;
+  }
+  return 0 | (flags.optional && 8) | (flags.host && 1) | (flags.self && 2) | (flags.skipSelf && 4);
+}
+function convertToInjectOptions(flags) {
+  return {
+    optional: !!(flags & 8),
+    host: !!(flags & 1),
+    self: !!(flags & 2),
+    skipSelf: !!(flags & 4)
+  };
+}
+function injectArgs(types) {
+  const args = [];
+  for (let i = 0; i < types.length; i++) {
+    const arg = resolveForwardRef(types[i]);
+    if (Array.isArray(arg)) {
+      if (arg.length === 0) {
+        throw new RuntimeError(900, ngDevMode && "Arguments array must have arguments.");
+      }
+      let type = void 0;
+      let flags = 0;
+      for (let j = 0; j < arg.length; j++) {
+        const meta = arg[j];
+        const flag = getInjectFlag(meta);
+        if (typeof flag === "number") {
+          if (flag === -1) {
+            type = meta.token;
+          } else {
+            flags |= flag;
+          }
+        } else {
+          type = meta;
+        }
+      }
+      args.push(\u0275\u0275inject(type, flags));
+    } else {
+      args.push(\u0275\u0275inject(arg));
+    }
+  }
+  return args;
+}
+function attachInjectFlag(decorator, flag) {
+  decorator[DI_DECORATOR_FLAG] = flag;
+  decorator.prototype[DI_DECORATOR_FLAG] = flag;
+  return decorator;
+}
+function getInjectFlag(token) {
+  return token[DI_DECORATOR_FLAG];
+}
+function getFactoryDef(type, throwNotFound) {
+  const hasFactoryDef = type.hasOwnProperty(NG_FACTORY_DEF);
+  if (!hasFactoryDef && throwNotFound === true && ngDevMode) {
+    throw new Error(`Type ${stringify(type)} does not have '\u0275fac' property.`);
+  }
+  return hasFactoryDef ? type[NG_FACTORY_DEF] : null;
+}
+function arrayEquals(a, b, identityAccessor) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    let valueA = a[i];
+    let valueB = b[i];
+    if (identityAccessor) {
+      valueA = identityAccessor(valueA);
+      valueB = identityAccessor(valueB);
+    }
+    if (valueB !== valueA) {
+      return false;
+    }
+  }
+  return true;
+}
+function flatten(list) {
+  return list.flat(Number.POSITIVE_INFINITY);
+}
+function deepForEach(input2, fn) {
+  input2.forEach((value) => Array.isArray(value) ? deepForEach(value, fn) : fn(value));
+}
+function addToArray(arr, index, value) {
+  if (index >= arr.length) {
+    arr.push(value);
+  } else {
+    arr.splice(index, 0, value);
+  }
+}
+function removeFromArray(arr, index) {
+  if (index >= arr.length - 1) {
+    return arr.pop();
+  } else {
+    return arr.splice(index, 1)[0];
+  }
+}
+function newArray(size, value) {
+  const list = [];
+  for (let i = 0; i < size; i++) {
+    list.push(value);
+  }
+  return list;
+}
+function arraySplice(array, index, count) {
+  const length = array.length - count;
+  while (index < length) {
+    array[index] = array[index + count];
+    index++;
+  }
+  while (count--) {
+    array.pop();
+  }
+}
+function arrayInsert2(array, index, value1, value2) {
+  ngDevMode && assertLessThanOrEqual(index, array.length, "Can't insert past array end.");
+  let end = array.length;
+  if (end == index) {
+    array.push(value1, value2);
+  } else if (end === 1) {
+    array.push(value2, array[0]);
+    array[0] = value1;
+  } else {
+    end--;
+    array.push(array[end - 1], array[end]);
+    while (end > index) {
+      const previousEnd = end - 2;
+      array[end] = array[previousEnd];
+      end--;
+    }
+    array[index] = value1;
+    array[index + 1] = value2;
+  }
+}
+function keyValueArraySet(keyValueArray, key, value) {
+  let index = keyValueArrayIndexOf(keyValueArray, key);
+  if (index >= 0) {
+    keyValueArray[index | 1] = value;
+  } else {
+    index = ~index;
+    arrayInsert2(keyValueArray, index, key, value);
+  }
+  return index;
+}
+function keyValueArrayGet(keyValueArray, key) {
+  const index = keyValueArrayIndexOf(keyValueArray, key);
+  if (index >= 0) {
+    return keyValueArray[index | 1];
+  }
+  return void 0;
+}
+function keyValueArrayIndexOf(keyValueArray, key) {
+  return _arrayIndexOfSorted(keyValueArray, key, 1);
+}
+function _arrayIndexOfSorted(array, value, shift) {
+  ngDevMode && assertEqual(Array.isArray(array), true, "Expecting an array");
+  let start = 0;
+  let end = array.length >> shift;
+  while (end !== start) {
+    const middle = start + (end - start >> 1);
+    const current = array[middle << shift];
+    if (value === current) {
+      return middle << shift;
+    } else if (current > value) {
+      end = middle;
+    } else {
+      start = middle + 1;
+    }
+  }
+  return ~(end << shift);
+}
+var EMPTY_OBJ = {};
+var EMPTY_ARRAY = [];
+if ((typeof ngDevMode === "undefined" || ngDevMode) && initNgDevMode()) {
+  Object.freeze(EMPTY_OBJ);
+  Object.freeze(EMPTY_ARRAY);
+}
+var ENVIRONMENT_INITIALIZER = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "ENVIRONMENT_INITIALIZER" : "");
+var INJECTOR$1 = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "INJECTOR" : "", -1);
+var INJECTOR_DEF_TYPES = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "INJECTOR_DEF_TYPES" : "");
+var NullInjector = class {
+  get(token, notFoundValue = THROW_IF_NOT_FOUND) {
+    if (notFoundValue === THROW_IF_NOT_FOUND) {
+      const message = ngDevMode ? `No provider found for \`${stringify(token)}\`.` : "";
+      const error = createRuntimeError(message, -201);
+      error.name = "\u0275NotFound";
+      throw error;
+    }
+    return notFoundValue;
+  }
+};
+function makeEnvironmentProviders(providers) {
+  return {
+    \u0275providers: providers
+  };
+}
+function provideEnvironmentInitializer(initializerFn) {
+  return makeEnvironmentProviders([{
+    provide: ENVIRONMENT_INITIALIZER,
+    multi: true,
+    useValue: initializerFn
+  }]);
+}
+function importProvidersFrom(...sources) {
+  return {
+    \u0275providers: internalImportProvidersFrom(true, sources),
+    \u0275fromNgModule: true
+  };
+}
+function internalImportProvidersFrom(checkForStandaloneCmp, ...sources) {
+  const providersOut = [];
+  const dedup = /* @__PURE__ */ new Set();
+  let injectorTypesWithProviders;
+  const collectProviders = (provider) => {
+    providersOut.push(provider);
+  };
+  deepForEach(sources, (source) => {
+    if ((typeof ngDevMode === "undefined" || ngDevMode) && checkForStandaloneCmp) {
+      const cmpDef = getComponentDef(source);
+      if (cmpDef?.standalone) {
+        throw new RuntimeError(800, `Importing providers supports NgModule or ModuleWithProviders but got a standalone component "${stringifyForError(source)}"`);
+      }
+    }
+    const internalSource = source;
+    if (walkProviderTree(internalSource, collectProviders, [], dedup)) {
+      injectorTypesWithProviders ||= [];
+      injectorTypesWithProviders.push(internalSource);
+    }
+  });
+  if (injectorTypesWithProviders !== void 0) {
+    processInjectorTypesWithProviders(injectorTypesWithProviders, collectProviders);
+  }
+  return providersOut;
+}
+function processInjectorTypesWithProviders(typesWithProviders, visitor) {
+  for (let i = 0; i < typesWithProviders.length; i++) {
+    const {
+      ngModule,
+      providers
+    } = typesWithProviders[i];
+    deepForEachProvider(providers, (provider) => {
+      ngDevMode && validateProvider(provider, providers || EMPTY_ARRAY, ngModule);
+      visitor(provider, ngModule);
+    });
+  }
+}
+function walkProviderTree(container, visitor, parents, dedup) {
+  container = resolveForwardRef(container);
+  if (!container) return false;
+  let defType = null;
+  let injDef = getInjectorDef(container);
+  const cmpDef = !injDef && getComponentDef(container);
+  if (!injDef && !cmpDef) {
+    const ngModule = container.ngModule;
+    injDef = getInjectorDef(ngModule);
+    if (injDef) {
+      defType = ngModule;
+    } else {
+      return false;
+    }
+  } else if (cmpDef && !cmpDef.standalone) {
+    return false;
+  } else {
+    defType = container;
+  }
+  if (ngDevMode && parents.indexOf(defType) !== -1) {
+    const defName = stringify(defType);
+    const path = parents.map(stringify).concat(defName);
+    throw cyclicDependencyErrorWithDetails(defName, path);
+  }
+  const isDuplicate = dedup.has(defType);
+  if (cmpDef) {
+    if (isDuplicate) {
+      return false;
+    }
+    dedup.add(defType);
+    if (cmpDef.dependencies) {
+      const deps = typeof cmpDef.dependencies === "function" ? cmpDef.dependencies() : cmpDef.dependencies;
+      for (const dep of deps) {
+        walkProviderTree(dep, visitor, parents, dedup);
+      }
+    }
+  } else if (injDef) {
+    if (injDef.imports != null && !isDuplicate) {
+      ngDevMode && parents.push(defType);
+      dedup.add(defType);
+      let importTypesWithProviders;
+      try {
+        deepForEach(injDef.imports, (imported) => {
+          if (walkProviderTree(imported, visitor, parents, dedup)) {
+            importTypesWithProviders ||= [];
+            importTypesWithProviders.push(imported);
+          }
+        });
+      } finally {
+        ngDevMode && parents.pop();
+      }
+      if (importTypesWithProviders !== void 0) {
+        processInjectorTypesWithProviders(importTypesWithProviders, visitor);
+      }
+    }
+    if (!isDuplicate) {
+      const factory = getFactoryDef(defType) || (() => new defType());
+      visitor({
+        provide: defType,
+        useFactory: factory,
+        deps: EMPTY_ARRAY
+      }, defType);
+      visitor({
+        provide: INJECTOR_DEF_TYPES,
+        useValue: defType,
+        multi: true
+      }, defType);
+      visitor({
+        provide: ENVIRONMENT_INITIALIZER,
+        useValue: () => \u0275\u0275inject(defType),
+        multi: true
+      }, defType);
+    }
+    const defProviders = injDef.providers;
+    if (defProviders != null && !isDuplicate) {
+      const injectorType = container;
+      deepForEachProvider(defProviders, (provider) => {
+        ngDevMode && validateProvider(provider, defProviders, injectorType);
+        visitor(provider, injectorType);
+      });
+    }
+  } else {
+    return false;
+  }
+  return defType !== container && container.providers !== void 0;
+}
+function validateProvider(provider, providers, containerType) {
+  if (isTypeProvider(provider) || isValueProvider(provider) || isFactoryProvider(provider) || isExistingProvider(provider)) {
+    return;
+  }
+  const classRef = resolveForwardRef(provider && (provider.useClass || provider.provide));
+  if (!classRef) {
+    throwInvalidProviderError(containerType, providers, provider);
+  }
+}
+function deepForEachProvider(providers, fn) {
+  for (let provider of providers) {
+    if (isEnvironmentProviders(provider)) {
+      provider = provider.\u0275providers;
+    }
+    if (Array.isArray(provider)) {
+      deepForEachProvider(provider, fn);
+    } else {
+      fn(provider);
+    }
+  }
+}
+var USE_VALUE = getClosureSafeProperty({
+  provide: String,
+  useValue: getClosureSafeProperty
+});
+function isValueProvider(value) {
+  return value !== null && typeof value == "object" && USE_VALUE in value;
+}
+function isExistingProvider(value) {
+  return !!(value && value.useExisting);
+}
+function isFactoryProvider(value) {
+  return !!(value && value.useFactory);
+}
+function isTypeProvider(value) {
+  return typeof value === "function";
+}
+function isClassProvider(value) {
+  return !!value.useClass;
+}
+var INJECTOR_SCOPE = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "Set Injector scope." : "");
+var NOT_YET = {};
+var CIRCULAR = {};
+var NULL_INJECTOR = void 0;
+function getNullInjector() {
+  if (NULL_INJECTOR === void 0) {
+    NULL_INJECTOR = new NullInjector();
+  }
+  return NULL_INJECTOR;
+}
+var EnvironmentInjector = class {
+};
+var R3Injector = class extends EnvironmentInjector {
+  parent;
+  source;
+  scopes;
+  records = /* @__PURE__ */ new Map();
+  _ngOnDestroyHooks = /* @__PURE__ */ new Set();
+  _onDestroyHooks = [];
+  get destroyed() {
+    return this._destroyed;
+  }
+  _destroyed = false;
+  injectorDefTypes;
+  constructor(providers, parent, source, scopes) {
+    super();
+    this.parent = parent;
+    this.source = source;
+    this.scopes = scopes;
+    forEachSingleProvider(providers, (provider) => this.processProvider(provider));
+    this.records.set(INJECTOR$1, makeRecord(void 0, this));
+    if (scopes.has("environment")) {
+      this.records.set(EnvironmentInjector, makeRecord(void 0, this));
+    }
+    const record = this.records.get(INJECTOR_SCOPE);
+    if (record != null && typeof record.value === "string") {
+      this.scopes.add(record.value);
+    }
+    this.injectorDefTypes = new Set(this.get(INJECTOR_DEF_TYPES, EMPTY_ARRAY, {
+      self: true
+    }));
+  }
+  retrieve(token, options) {
+    const flags = convertToBitFlags(options) || 0;
+    try {
+      return this.get(token, THROW_IF_NOT_FOUND, flags);
+    } catch (e) {
+      if (isNotFound(e)) {
+        return e;
+      }
+      throw e;
+    }
+  }
+  destroy() {
+    assertNotDestroyed(this);
+    this._destroyed = true;
+    const prevConsumer = setActiveConsumer(null);
+    try {
+      for (const service of this._ngOnDestroyHooks) {
+        service.ngOnDestroy();
+      }
+      const onDestroyHooks = this._onDestroyHooks;
+      this._onDestroyHooks = [];
+      for (const hook of onDestroyHooks) {
+        hook();
+      }
+    } finally {
+      this.records.clear();
+      this._ngOnDestroyHooks.clear();
+      this.injectorDefTypes.clear();
+      setActiveConsumer(prevConsumer);
+    }
+  }
+  onDestroy(callback) {
+    assertNotDestroyed(this);
+    this._onDestroyHooks.push(callback);
+    return () => this.removeOnDestroy(callback);
+  }
+  runInContext(fn) {
+    assertNotDestroyed(this);
+    const previousInjector = setCurrentInjector(this);
+    const previousInjectImplementation = setInjectImplementation(void 0);
+    let prevInjectContext;
+    if (ngDevMode) {
+      prevInjectContext = setInjectorProfilerContext({
+        injector: this,
+        token: null
+      });
+    }
+    try {
+      return fn();
+    } finally {
+      setCurrentInjector(previousInjector);
+      setInjectImplementation(previousInjectImplementation);
+      ngDevMode && setInjectorProfilerContext(prevInjectContext);
+    }
+  }
+  get(token, notFoundValue = THROW_IF_NOT_FOUND, options) {
+    assertNotDestroyed(this);
+    if (token.hasOwnProperty(NG_ENV_ID)) {
+      return token[NG_ENV_ID](this);
+    }
+    const flags = convertToBitFlags(options);
+    let prevInjectContext;
+    if (ngDevMode) {
+      prevInjectContext = setInjectorProfilerContext({
+        injector: this,
+        token
+      });
+    }
+    const previousInjector = setCurrentInjector(this);
+    const previousInjectImplementation = setInjectImplementation(void 0);
+    try {
+      if (!(flags & 4)) {
+        let record = this.records.get(token);
+        if (record === void 0) {
+          const def = couldBeInjectableType(token) && getInjectableDef(token);
+          if (def && this.injectableDefInScope(def)) {
+            if (ngDevMode) {
+              runInInjectorProfilerContext(this, token, () => {
+                emitProviderConfiguredEvent(token);
+              });
+            }
+            record = makeRecord(injectableDefOrInjectorDefFactory(token), NOT_YET);
+          } else {
+            record = null;
+          }
+          this.records.set(token, record);
+        }
+        if (record != null) {
+          return this.hydrate(token, record, flags);
+        }
+      }
+      const nextInjector = !(flags & 2) ? this.parent : getNullInjector();
+      notFoundValue = flags & 8 && notFoundValue === THROW_IF_NOT_FOUND ? null : notFoundValue;
+      return nextInjector.get(token, notFoundValue);
+    } catch (error) {
+      const errorCode = getRuntimeErrorCode(error);
+      if (errorCode === -200 || errorCode === -201) {
+        if (ngDevMode) {
+          prependTokenToDependencyPath(error, token);
+          if (previousInjector) {
+            throw error;
+          } else {
+            throw augmentRuntimeError(error, this.source);
+          }
+        } else {
+          throw new RuntimeError(errorCode, null);
+        }
+      } else {
+        throw error;
+      }
+    } finally {
+      setInjectImplementation(previousInjectImplementation);
+      setCurrentInjector(previousInjector);
+      ngDevMode && setInjectorProfilerContext(prevInjectContext);
+    }
+  }
+  resolveInjectorInitializers() {
+    const prevConsumer = setActiveConsumer(null);
+    const previousInjector = setCurrentInjector(this);
+    const previousInjectImplementation = setInjectImplementation(void 0);
+    let prevInjectContext;
+    if (ngDevMode) {
+      prevInjectContext = setInjectorProfilerContext({
+        injector: this,
+        token: null
+      });
+    }
+    try {
+      const initializers = this.get(ENVIRONMENT_INITIALIZER, EMPTY_ARRAY, {
+        self: true
+      });
+      if (ngDevMode && !Array.isArray(initializers)) {
+        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.`);
+      }
+      for (const initializer of initializers) {
+        initializer();
+      }
+    } finally {
+      setCurrentInjector(previousInjector);
+      setInjectImplementation(previousInjectImplementation);
+      ngDevMode && setInjectorProfilerContext(prevInjectContext);
+      setActiveConsumer(prevConsumer);
+    }
+  }
+  toString() {
+    if (ngDevMode) {
+      const tokens = [];
+      const records = this.records;
+      for (const token of records.keys()) {
+        tokens.push(stringify(token));
+      }
+      return `R3Injector[${tokens.join(", ")}]`;
+    }
+    return "R3Injector[...]";
+  }
+  processProvider(provider) {
+    provider = resolveForwardRef(provider);
+    let token = isTypeProvider(provider) ? provider : resolveForwardRef(provider && provider.provide);
+    const record = providerToRecord(provider);
+    if (ngDevMode) {
+      runInInjectorProfilerContext(this, token, () => {
+        if (isValueProvider(provider)) {
+          emitInjectorToCreateInstanceEvent(token);
+          emitInstanceCreatedByInjectorEvent(provider.useValue);
+        }
+        emitProviderConfiguredEvent(provider);
+      });
+    }
+    if (!isTypeProvider(provider) && provider.multi === true) {
+      let multiRecord = this.records.get(token);
+      if (multiRecord) {
+        if (ngDevMode && multiRecord.multi === void 0) {
+          throwMixedMultiProviderError();
+        }
+      } else {
+        multiRecord = makeRecord(void 0, NOT_YET, true);
+        multiRecord.factory = () => injectArgs(multiRecord.multi);
+        this.records.set(token, multiRecord);
+      }
+      token = provider;
+      multiRecord.multi.push(provider);
+    } else {
+      if (ngDevMode) {
+        const existing = this.records.get(token);
+        if (existing && existing.multi !== void 0) {
+          throwMixedMultiProviderError();
+        }
+      }
+    }
+    this.records.set(token, record);
+  }
+  hydrate(token, record, flags) {
+    const prevConsumer = setActiveConsumer(null);
+    try {
+      if (record.value === CIRCULAR) {
+        throw cyclicDependencyError(ngDevMode ? stringify(token) : "");
+      } else if (record.value === NOT_YET) {
+        record.value = CIRCULAR;
+        if (ngDevMode) {
+          runInInjectorProfilerContext(this, token, () => {
+            emitInjectorToCreateInstanceEvent(token);
+            record.value = record.factory(void 0, flags);
+            emitInstanceCreatedByInjectorEvent(record.value);
+          });
+        } else {
+          record.value = record.factory(void 0, flags);
+        }
+      }
+      if (typeof record.value === "object" && record.value && hasOnDestroy(record.value)) {
+        this._ngOnDestroyHooks.add(record.value);
+      }
+      return record.value;
+    } finally {
+      setActiveConsumer(prevConsumer);
+    }
+  }
+  injectableDefInScope(def) {
+    if (!def.providedIn) {
+      return false;
+    }
+    const providedIn = resolveForwardRef(def.providedIn);
+    if (typeof providedIn === "string") {
+      return providedIn === "any" || this.scopes.has(providedIn);
+    } else {
+      return this.injectorDefTypes.has(providedIn);
+    }
+  }
+  removeOnDestroy(callback) {
+    const destroyCBIdx = this._onDestroyHooks.indexOf(callback);
+    if (destroyCBIdx !== -1) {
+      this._onDestroyHooks.splice(destroyCBIdx, 1);
+    }
+  }
+};
+function injectableDefOrInjectorDefFactory(token) {
+  const injectableDef = getInjectableDef(token);
+  const factory = injectableDef !== null ? injectableDef.factory : getFactoryDef(token);
+  if (factory !== null) {
+    return factory;
+  }
+  if (token instanceof InjectionToken) {
+    throw new RuntimeError(-204, ngDevMode && `Token ${stringify(token)} is missing a \u0275prov definition.`);
+  }
+  if (token instanceof Function) {
+    return getUndecoratedInjectableFactory(token);
+  }
+  throw new RuntimeError(-204, ngDevMode && "unreachable");
+}
+function getUndecoratedInjectableFactory(token) {
+  const paramLength = token.length;
+  if (paramLength > 0) {
+    throw new RuntimeError(-204, ngDevMode && `Can't resolve all parameters for ${stringify(token)}: (${newArray(paramLength, "?").join(", ")}).`);
+  }
+  const inheritedInjectableDef = getInheritedInjectableDef(token);
+  if (inheritedInjectableDef !== null) {
+    return () => inheritedInjectableDef.factory(token);
+  } else {
+    return () => new token();
+  }
+}
+function providerToRecord(provider) {
+  if (isValueProvider(provider)) {
+    return makeRecord(void 0, provider.useValue);
+  } else {
+    const factory = providerToFactory(provider);
+    return makeRecord(factory, NOT_YET);
+  }
+}
+function providerToFactory(provider, ngModuleType, providers) {
+  let factory = void 0;
+  if (ngDevMode && isEnvironmentProviders(provider)) {
+    throwInvalidProviderError(void 0, providers, provider);
+  }
+  if (isTypeProvider(provider)) {
+    const unwrappedProvider = resolveForwardRef(provider);
+    return getFactoryDef(unwrappedProvider) || injectableDefOrInjectorDefFactory(unwrappedProvider);
+  } else {
+    if (isValueProvider(provider)) {
+      factory = () => resolveForwardRef(provider.useValue);
+    } else if (isFactoryProvider(provider)) {
+      factory = () => provider.useFactory(...injectArgs(provider.deps || []));
+    } else if (isExistingProvider(provider)) {
+      factory = (_, flags) => \u0275\u0275inject(resolveForwardRef(provider.useExisting), flags !== void 0 && flags & 8 ? 8 : void 0);
+    } else {
+      const classRef = resolveForwardRef(provider && (provider.useClass || provider.provide));
+      if (ngDevMode && !classRef) {
+        throwInvalidProviderError(ngModuleType, providers, provider);
+      }
+      if (hasDeps(provider)) {
+        factory = () => new classRef(...injectArgs(provider.deps));
+      } else {
+        return getFactoryDef(classRef) || injectableDefOrInjectorDefFactory(classRef);
+      }
+    }
+  }
+  return factory;
+}
+function assertNotDestroyed(injector) {
+  if (injector.destroyed) {
+    throw new RuntimeError(-205, ngDevMode && "Injector has already been destroyed.");
+  }
+}
+function makeRecord(factory, value, multi = false) {
+  return {
+    factory,
+    value,
+    multi: multi ? [] : void 0
+  };
+}
+function hasDeps(value) {
+  return !!value.deps;
+}
+function hasOnDestroy(value) {
+  return value !== null && typeof value === "object" && typeof value.ngOnDestroy === "function";
+}
+function couldBeInjectableType(value) {
+  return typeof value === "function" || typeof value === "object" && value.ngMetadataName === "InjectionToken";
+}
+function forEachSingleProvider(providers, fn) {
+  for (const provider of providers) {
+    if (Array.isArray(provider)) {
+      forEachSingleProvider(provider, fn);
+    } else if (provider && isEnvironmentProviders(provider)) {
+      forEachSingleProvider(provider.\u0275providers, fn);
+    } else {
+      fn(provider);
+    }
+  }
+}
+function runInInjectionContext(injector, fn) {
+  let internalInjector;
+  if (injector instanceof R3Injector) {
+    assertNotDestroyed(injector);
+    internalInjector = injector;
+  } else {
+    internalInjector = new RetrievingInjector(injector);
+  }
+  let prevInjectorProfilerContext;
+  if (ngDevMode) {
+    prevInjectorProfilerContext = setInjectorProfilerContext({
+      injector,
+      token: null
+    });
+  }
+  const prevInjector = setCurrentInjector(internalInjector);
+  const previousInjectImplementation = setInjectImplementation(void 0);
+  try {
+    return fn();
+  } finally {
+    setCurrentInjector(prevInjector);
+    ngDevMode && setInjectorProfilerContext(prevInjectorProfilerContext);
+    setInjectImplementation(previousInjectImplementation);
+  }
+}
+function isInInjectionContext() {
+  return getInjectImplementation() !== void 0 || getCurrentInjector() != null;
+}
+function assertInInjectionContext(debugFn) {
+  if (!isInInjectionContext()) {
+    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`");
+  }
+}
+var HOST = 0;
+var TVIEW = 1;
+var FLAGS = 2;
+var PARENT = 3;
+var NEXT = 4;
+var T_HOST = 5;
+var HYDRATION = 6;
+var CLEANUP = 7;
+var CONTEXT = 8;
+var INJECTOR = 9;
+var ENVIRONMENT = 10;
+var RENDERER = 11;
+var CHILD_HEAD = 12;
+var CHILD_TAIL = 13;
+var DECLARATION_VIEW = 14;
+var DECLARATION_COMPONENT_VIEW = 15;
+var DECLARATION_LCONTAINER = 16;
+var PREORDER_HOOK_FLAGS = 17;
+var QUERIES = 18;
+var ID = 19;
+var EMBEDDED_VIEW_INJECTOR = 20;
+var ON_DESTROY_HOOKS = 21;
+var EFFECTS_TO_SCHEDULE = 22;
+var EFFECTS = 23;
+var REACTIVE_TEMPLATE_CONSUMER = 24;
+var AFTER_RENDER_SEQUENCES_TO_ADD = 25;
+var ANIMATIONS = 26;
+var HEADER_OFFSET = 27;
+var TYPE = 1;
+var DEHYDRATED_VIEWS = 6;
+var NATIVE = 7;
+var VIEW_REFS = 8;
+var MOVED_VIEWS = 9;
+var CONTAINER_HEADER_OFFSET = 10;
+function isLView(value) {
+  return Array.isArray(value) && typeof value[TYPE] === "object";
+}
+function isLContainer(value) {
+  return Array.isArray(value) && value[TYPE] === true;
+}
+function isContentQueryHost(tNode) {
+  return (tNode.flags & 4) !== 0;
+}
+function isComponentHost(tNode) {
+  return tNode.componentOffset > -1;
+}
+function isDirectiveHost(tNode) {
+  return (tNode.flags & 1) === 1;
+}
+function isComponentDef(def) {
+  return !!def.template;
+}
+function isRootView(target) {
+  return (target[FLAGS] & 512) !== 0;
+}
+function isDestroyed(lView) {
+  return (lView[FLAGS] & 256) === 256;
+}
+function assertTNodeForLView(tNode, lView) {
+  assertTNodeForTView(tNode, lView[TVIEW]);
+}
+function assertTNodeCreationIndex(lView, index) {
+  const adjustedIndex = index + HEADER_OFFSET;
+  assertIndexInRange(lView, adjustedIndex);
+  assertLessThan(adjustedIndex, lView[TVIEW].bindingStartIndex, "TNodes should be created before any bindings");
+}
+function assertTNodeForTView(tNode, tView) {
+  assertTNode(tNode);
+  const tData = tView.data;
+  for (let i = HEADER_OFFSET; i < tData.length; i++) {
+    if (tData[i] === tNode) {
+      return;
+    }
+  }
+  throwError2("This TNode does not belong to this TView.");
+}
+function assertTNode(tNode) {
+  assertDefined(tNode, "TNode must be defined");
+  if (!(tNode && typeof tNode === "object" && tNode.hasOwnProperty("directiveStylingLast"))) {
+    throwError2("Not of type TNode, got: " + tNode);
+  }
+}
+function assertTIcu(tIcu) {
+  assertDefined(tIcu, "Expected TIcu to be defined");
+  if (!(typeof tIcu.currentCaseLViewIndex === "number")) {
+    throwError2("Object is not of TIcu type.");
+  }
+}
+function assertComponentType(actual, msg = "Type passed in is not ComponentType, it does not have '\u0275cmp' property.") {
+  if (!getComponentDef(actual)) {
+    throwError2(msg);
+  }
+}
+function assertNgModuleType(actual, msg = "Type passed in is not NgModuleType, it does not have '\u0275mod' property.") {
+  if (!getNgModuleDef(actual)) {
+    throwError2(msg);
+  }
+}
+function assertHasParent(tNode) {
+  assertDefined(tNode, "currentTNode should exist!");
+  assertDefined(tNode.parent, "currentTNode should have a parent");
+}
+function assertLContainer(value) {
+  assertDefined(value, "LContainer must be defined");
+  assertEqual(isLContainer(value), true, "Expecting LContainer");
+}
+function assertLViewOrUndefined(value) {
+  value && assertEqual(isLView(value), true, "Expecting LView or undefined or null");
+}
+function assertLView(value) {
+  assertDefined(value, "LView must be defined");
+  assertEqual(isLView(value), true, "Expecting LView");
+}
+function assertFirstCreatePass(tView, errMessage) {
+  assertEqual(tView.firstCreatePass, true, errMessage || "Should only be called in first create pass.");
+}
+function assertFirstUpdatePass(tView, errMessage) {
+  assertEqual(tView.firstUpdatePass, true, "Should only be called in first update pass.");
+}
+function assertDirectiveDef(obj) {
+  if (obj.type === void 0 || obj.selectors == void 0 || obj.inputs === void 0) {
+    throwError2(`Expected a DirectiveDef/ComponentDef and this object does not seem to have the expected shape.`);
+  }
+}
+function assertIndexInDeclRange(tView, index) {
+  assertBetween(HEADER_OFFSET, tView.bindingStartIndex, index);
+}
+function assertIndexInExpandoRange(lView, index) {
+  const tView = lView[1];
+  assertBetween(tView.expandoStartIndex, lView.length, index);
+}
+function assertBetween(lower, upper, index) {
+  if (!(lower <= index && index < upper)) {
+    throwError2(`Index out of range (expecting ${lower} <= ${index} < ${upper})`);
+  }
+}
+function assertProjectionSlots(lView, errMessage) {
+  assertDefined(lView[DECLARATION_COMPONENT_VIEW], "Component views should exist.");
+  assertDefined(lView[DECLARATION_COMPONENT_VIEW][T_HOST].projection, "Components with projection nodes (<ng-content>) must have projection slots defined.");
+}
+function assertParentView(lView, errMessage) {
+  assertDefined(lView, "Component views should always have a parent view (component's host view)");
+}
+function assertNodeInjector(lView, injectorIndex) {
+  assertIndexInExpandoRange(lView, injectorIndex);
+  assertIndexInExpandoRange(lView, injectorIndex + 8);
+  assertNumber(lView[injectorIndex + 0], "injectorIndex should point to a bloom filter");
+  assertNumber(lView[injectorIndex + 1], "injectorIndex should point to a bloom filter");
+  assertNumber(lView[injectorIndex + 2], "injectorIndex should point to a bloom filter");
+  assertNumber(lView[injectorIndex + 3], "injectorIndex should point to a bloom filter");
+  assertNumber(lView[injectorIndex + 4], "injectorIndex should point to a bloom filter");
+  assertNumber(lView[injectorIndex + 5], "injectorIndex should point to a bloom filter");
+  assertNumber(lView[injectorIndex + 6], "injectorIndex should point to a bloom filter");
+  assertNumber(lView[injectorIndex + 7], "injectorIndex should point to a bloom filter");
+  assertNumber(lView[injectorIndex + 8], "injectorIndex should point to parent injector");
+}
+var SVG_NAMESPACE = "svg";
+var MATH_ML_NAMESPACE = "math";
+function unwrapRNode(value) {
+  while (Array.isArray(value)) {
+    value = value[HOST];
+  }
+  return value;
+}
+function unwrapLView(value) {
+  while (Array.isArray(value)) {
+    if (typeof value[TYPE] === "object") return value;
+    value = value[HOST];
+  }
+  return null;
+}
+function getNativeByIndex(index, lView) {
+  ngDevMode && assertIndexInRange(lView, index);
+  ngDevMode && assertGreaterThanOrEqual(index, HEADER_OFFSET, "Expected to be past HEADER_OFFSET");
+  return unwrapRNode(lView[index]);
+}
+function getNativeByTNode(tNode, lView) {
+  ngDevMode && assertTNodeForLView(tNode, lView);
+  ngDevMode && assertIndexInRange(lView, tNode.index);
+  const node = unwrapRNode(lView[tNode.index]);
+  return node;
+}
+function getTNode(tView, index) {
+  ngDevMode && assertGreaterThan(index, -1, "wrong index for TNode");
+  ngDevMode && assertLessThan(index, tView.data.length, "wrong index for TNode");
+  const tNode = tView.data[index];
+  ngDevMode && tNode !== null && assertTNode(tNode);
+  return tNode;
+}
+function load(view, index) {
+  ngDevMode && assertIndexInRange(view, index);
+  return view[index];
+}
+function store(tView, lView, index, value) {
+  if (index >= tView.data.length) {
+    tView.data[index] = null;
+    tView.blueprint[index] = null;
+  }
+  lView[index] = value;
+}
+function getComponentLViewByIndex(nodeIndex, hostView) {
+  ngDevMode && assertIndexInRange(hostView, nodeIndex);
+  const slotValue = hostView[nodeIndex];
+  const lView = isLView(slotValue) ? slotValue : slotValue[HOST];
+  return lView;
+}
+function isCreationMode(view) {
+  return (view[FLAGS] & 4) === 4;
+}
+function viewAttachedToChangeDetector(view) {
+  return (view[FLAGS] & 128) === 128;
+}
+function viewAttachedToContainer(view) {
+  return isLContainer(view[PARENT]);
+}
+function getConstant(consts, index) {
+  if (index === null || index === void 0) return null;
+  ngDevMode && assertIndexInRange(consts, index);
+  return consts[index];
+}
+function resetPreOrderHookFlags(lView) {
+  lView[PREORDER_HOOK_FLAGS] = 0;
+}
+function markViewForRefresh(lView) {
+  if (lView[FLAGS] & 1024) {
+    return;
+  }
+  lView[FLAGS] |= 1024;
+  if (viewAttachedToChangeDetector(lView)) {
+    markAncestorsForTraversal(lView);
+  }
+}
+function walkUpViews(nestingLevel, currentView) {
+  while (nestingLevel > 0) {
+    ngDevMode && assertDefined(currentView[DECLARATION_VIEW], "Declaration view should be defined if nesting level is greater than 0.");
+    currentView = currentView[DECLARATION_VIEW];
+    nestingLevel--;
+  }
+  return currentView;
+}
+function requiresRefreshOrTraversal(lView) {
+  return !!(lView[FLAGS] & (1024 | 8192) || lView[REACTIVE_TEMPLATE_CONSUMER]?.dirty);
+}
+function updateAncestorTraversalFlagsOnAttach(lView) {
+  lView[ENVIRONMENT].changeDetectionScheduler?.notify(8);
+  if (lView[FLAGS] & 64) {
+    lView[FLAGS] |= 1024;
+  }
+  if (requiresRefreshOrTraversal(lView)) {
+    markAncestorsForTraversal(lView);
+  }
+}
+function markAncestorsForTraversal(lView) {
+  lView[ENVIRONMENT].changeDetectionScheduler?.notify(0);
+  let parent = getLViewParent(lView);
+  while (parent !== null) {
+    if (parent[FLAGS] & 8192) {
+      break;
+    }
+    parent[FLAGS] |= 8192;
+    if (!viewAttachedToChangeDetector(parent)) {
+      break;
+    }
+    parent = getLViewParent(parent);
+  }
+}
+function storeLViewOnDestroy(lView, onDestroyCallback) {
+  if (isDestroyed(lView)) {
+    throw new RuntimeError(911, ngDevMode && "View has already been destroyed.");
+  }
+  if (lView[ON_DESTROY_HOOKS] === null) {
+    lView[ON_DESTROY_HOOKS] = [];
+  }
+  lView[ON_DESTROY_HOOKS].push(onDestroyCallback);
+}
+function removeLViewOnDestroy(lView, onDestroyCallback) {
+  if (lView[ON_DESTROY_HOOKS] === null) return;
+  const destroyCBIdx = lView[ON_DESTROY_HOOKS].indexOf(onDestroyCallback);
+  if (destroyCBIdx !== -1) {
+    lView[ON_DESTROY_HOOKS].splice(destroyCBIdx, 1);
+  }
+}
+function getLViewParent(lView) {
+  ngDevMode && assertLView(lView);
+  const parent = lView[PARENT];
+  return isLContainer(parent) ? parent[PARENT] : parent;
+}
+function getOrCreateLViewCleanup(view) {
+  return view[CLEANUP] ??= [];
+}
+function getOrCreateTViewCleanup(tView) {
+  return tView.cleanup ??= [];
+}
+function storeCleanupWithContext(tView, lView, context2, cleanupFn) {
+  const lCleanup = getOrCreateLViewCleanup(lView);
+  ngDevMode && assertDefined(context2, "Cleanup context is mandatory when registering framework-level destroy hooks");
+  lCleanup.push(context2);
+  if (tView.firstCreatePass) {
+    getOrCreateTViewCleanup(tView).push(cleanupFn, lCleanup.length - 1);
+  } else {
+    if (ngDevMode) {
+      Object.freeze(getOrCreateTViewCleanup(tView));
+    }
+  }
+}
+var instructionState = {
+  lFrame: createLFrame(null),
+  bindingsEnabled: true,
+  skipHydrationRootTNode: null
+};
+var CheckNoChangesMode;
+(function(CheckNoChangesMode2) {
+  CheckNoChangesMode2[CheckNoChangesMode2["Off"] = 0] = "Off";
+  CheckNoChangesMode2[CheckNoChangesMode2["Exhaustive"] = 1] = "Exhaustive";
+  CheckNoChangesMode2[CheckNoChangesMode2["OnlyDirtyViews"] = 2] = "OnlyDirtyViews";
+})(CheckNoChangesMode || (CheckNoChangesMode = {}));
+var _checkNoChangesMode = 0;
+var _isRefreshingViews = false;
+function getElementDepthCount() {
+  return instructionState.lFrame.elementDepthCount;
+}
+function increaseElementDepthCount() {
+  instructionState.lFrame.elementDepthCount++;
+}
+function decreaseElementDepthCount() {
+  instructionState.lFrame.elementDepthCount--;
+}
+function getBindingsEnabled() {
+  return instructionState.bindingsEnabled;
+}
+function isInSkipHydrationBlock() {
+  return instructionState.skipHydrationRootTNode !== null;
+}
+function isSkipHydrationRootTNode(tNode) {
+  return instructionState.skipHydrationRootTNode === tNode;
+}
+function \u0275\u0275enableBindings() {
+  instructionState.bindingsEnabled = true;
+}
+function \u0275\u0275disableBindings() {
+  instructionState.bindingsEnabled = false;
+}
+function leaveSkipHydrationBlock() {
+  instructionState.skipHydrationRootTNode = null;
+}
+function getLView() {
+  return instructionState.lFrame.lView;
+}
+function getTView() {
+  return instructionState.lFrame.tView;
+}
+function \u0275\u0275restoreView(viewToRestore) {
+  instructionState.lFrame.contextLView = viewToRestore;
+  return viewToRestore[CONTEXT];
+}
+function \u0275\u0275resetView(value) {
+  instructionState.lFrame.contextLView = null;
+  return value;
+}
+function getCurrentTNode() {
+  let currentTNode = getCurrentTNodePlaceholderOk();
+  while (currentTNode !== null && currentTNode.type === 64) {
+    currentTNode = currentTNode.parent;
+  }
+  return currentTNode;
+}
+function getCurrentTNodePlaceholderOk() {
+  return instructionState.lFrame.currentTNode;
+}
+function getCurrentParentTNode() {
+  const lFrame = instructionState.lFrame;
+  const currentTNode = lFrame.currentTNode;
+  return lFrame.isParent ? currentTNode : currentTNode.parent;
+}
+function setCurrentTNode(tNode, isParent) {
+  ngDevMode && tNode && assertTNodeForTView(tNode, instructionState.lFrame.tView);
+  const lFrame = instructionState.lFrame;
+  lFrame.currentTNode = tNode;
+  lFrame.isParent = isParent;
+}
+function isCurrentTNodeParent() {
+  return instructionState.lFrame.isParent;
+}
+function setCurrentTNodeAsNotParent() {
+  instructionState.lFrame.isParent = false;
+}
+function getContextLView() {
+  const contextLView = instructionState.lFrame.contextLView;
+  ngDevMode && assertDefined(contextLView, "contextLView must be defined.");
+  return contextLView;
+}
+function isInCheckNoChangesMode() {
+  !ngDevMode && throwError2("Must never be called in production mode");
+  return _checkNoChangesMode !== CheckNoChangesMode.Off;
+}
+function isExhaustiveCheckNoChanges() {
+  !ngDevMode && throwError2("Must never be called in production mode");
+  return _checkNoChangesMode === CheckNoChangesMode.Exhaustive;
+}
+function setIsInCheckNoChangesMode(mode) {
+  !ngDevMode && throwError2("Must never be called in production mode");
+  _checkNoChangesMode = mode;
+}
+function isRefreshingViews() {
+  return _isRefreshingViews;
+}
+function setIsRefreshingViews(mode) {
+  const prev = _isRefreshingViews;
+  _isRefreshingViews = mode;
+  return prev;
+}
+function getBindingRoot() {
+  const lFrame = instructionState.lFrame;
+  let index = lFrame.bindingRootIndex;
+  if (index === -1) {
+    index = lFrame.bindingRootIndex = lFrame.tView.bindingStartIndex;
+  }
+  return index;
+}
+function getBindingIndex() {
+  return instructionState.lFrame.bindingIndex;
+}
+function setBindingIndex(value) {
+  return instructionState.lFrame.bindingIndex = value;
+}
+function nextBindingIndex() {
+  return instructionState.lFrame.bindingIndex++;
+}
+function incrementBindingIndex(count) {
+  const lFrame = instructionState.lFrame;
+  const index = lFrame.bindingIndex;
+  lFrame.bindingIndex = lFrame.bindingIndex + count;
+  return index;
+}
+function isInI18nBlock() {
+  return instructionState.lFrame.inI18n;
+}
+function setInI18nBlock(isInI18nBlock2) {
+  instructionState.lFrame.inI18n = isInI18nBlock2;
+}
+function setBindingRootForHostBindings(bindingRootIndex, currentDirectiveIndex) {
+  const lFrame = instructionState.lFrame;
+  lFrame.bindingIndex = lFrame.bindingRootIndex = bindingRootIndex;
+  setCurrentDirectiveIndex(currentDirectiveIndex);
+}
+function getCurrentDirectiveIndex() {
+  return instructionState.lFrame.currentDirectiveIndex;
+}
+function setCurrentDirectiveIndex(currentDirectiveIndex) {
+  instructionState.lFrame.currentDirectiveIndex = currentDirectiveIndex;
+}
+function getCurrentDirectiveDef(tData) {
+  const currentDirectiveIndex = instructionState.lFrame.currentDirectiveIndex;
+  return currentDirectiveIndex === -1 ? null : tData[currentDirectiveIndex];
+}
+function getCurrentQueryIndex() {
+  return instructionState.lFrame.currentQueryIndex;
+}
+function setCurrentQueryIndex(value) {
+  instructionState.lFrame.currentQueryIndex = value;
+}
+function getDeclarationTNode(lView) {
+  const tView = lView[TVIEW];
+  if (tView.type === 2) {
+    ngDevMode && assertDefined(tView.declTNode, "Embedded TNodes should have declaration parents.");
+    return tView.declTNode;
+  }
+  if (tView.type === 1) {
+    return lView[T_HOST];
+  }
+  return null;
+}
+function enterDI(lView, tNode, flags) {
+  ngDevMode && assertLViewOrUndefined(lView);
+  if (flags & 4) {
+    ngDevMode && assertTNodeForTView(tNode, lView[TVIEW]);
+    let parentTNode = tNode;
+    let parentLView = lView;
+    while (true) {
+      ngDevMode && assertDefined(parentTNode, "Parent TNode should be defined");
+      parentTNode = parentTNode.parent;
+      if (parentTNode === null && !(flags & 1)) {
+        parentTNode = getDeclarationTNode(parentLView);
+        if (parentTNode === null) break;
+        ngDevMode && assertDefined(parentLView, "Parent LView should be defined");
+        parentLView = parentLView[DECLARATION_VIEW];
+        if (parentTNode.type & (2 | 8)) {
+          break;
+        }
+      } else {
+        break;
+      }
+    }
+    if (parentTNode === null) {
+      return false;
+    } else {
+      tNode = parentTNode;
+      lView = parentLView;
+    }
+  }
+  ngDevMode && assertTNodeForLView(tNode, lView);
+  const lFrame = instructionState.lFrame = allocLFrame();
+  lFrame.currentTNode = tNode;
+  lFrame.lView = lView;
+  return true;
+}
+function enterView(newView) {
+  ngDevMode && assertNotEqual(newView[0], newView[1], "????");
+  ngDevMode && assertLViewOrUndefined(newView);
+  const newLFrame = allocLFrame();
+  if (ngDevMode) {
+    assertEqual(newLFrame.isParent, true, "Expected clean LFrame");
+    assertEqual(newLFrame.lView, null, "Expected clean LFrame");
+    assertEqual(newLFrame.tView, null, "Expected clean LFrame");
+    assertEqual(newLFrame.selectedIndex, -1, "Expected clean LFrame");
+    assertEqual(newLFrame.elementDepthCount, 0, "Expected clean LFrame");
+    assertEqual(newLFrame.currentDirectiveIndex, -1, "Expected clean LFrame");
+    assertEqual(newLFrame.currentNamespace, null, "Expected clean LFrame");
+    assertEqual(newLFrame.bindingRootIndex, -1, "Expected clean LFrame");
+    assertEqual(newLFrame.currentQueryIndex, 0, "Expected clean LFrame");
+  }
+  const tView = newView[TVIEW];
+  instructionState.lFrame = newLFrame;
+  ngDevMode && tView.firstChild && assertTNodeForTView(tView.firstChild, tView);
+  newLFrame.currentTNode = tView.firstChild;
+  newLFrame.lView = newView;
+  newLFrame.tView = tView;
+  newLFrame.contextLView = newView;
+  newLFrame.bindingIndex = tView.bindingStartIndex;
+  newLFrame.inI18n = false;
+}
+function allocLFrame() {
+  const currentLFrame = instructionState.lFrame;
+  const childLFrame = currentLFrame === null ? null : currentLFrame.child;
+  const newLFrame = childLFrame === null ? createLFrame(currentLFrame) : childLFrame;
+  return newLFrame;
+}
+function createLFrame(parent) {
+  const lFrame = {
+    currentTNode: null,
+    isParent: true,
+    lView: null,
+    tView: null,
+    selectedIndex: -1,
+    contextLView: null,
+    elementDepthCount: 0,
+    currentNamespace: null,
+    currentDirectiveIndex: -1,
+    bindingRootIndex: -1,
+    bindingIndex: -1,
+    currentQueryIndex: 0,
+    parent,
+    child: null,
+    inI18n: false
+  };
+  parent !== null && (parent.child = lFrame);
+  return lFrame;
+}
+function leaveViewLight() {
+  const oldLFrame = instructionState.lFrame;
+  instructionState.lFrame = oldLFrame.parent;
+  oldLFrame.currentTNode = null;
+  oldLFrame.lView = null;
+  return oldLFrame;
+}
+var leaveDI = leaveViewLight;
+function leaveView() {
+  const oldLFrame = leaveViewLight();
+  oldLFrame.isParent = true;
+  oldLFrame.tView = null;
+  oldLFrame.selectedIndex = -1;
+  oldLFrame.contextLView = null;
+  oldLFrame.elementDepthCount = 0;
+  oldLFrame.currentDirectiveIndex = -1;
+  oldLFrame.currentNamespace = null;
+  oldLFrame.bindingRootIndex = -1;
+  oldLFrame.bindingIndex = -1;
+  oldLFrame.currentQueryIndex = 0;
+}
+function nextContextImpl(level) {
+  const contextLView = instructionState.lFrame.contextLView = walkUpViews(level, instructionState.lFrame.contextLView);
+  return contextLView[CONTEXT];
+}
+function getSelectedIndex() {
+  return instructionState.lFrame.selectedIndex;
+}
+function setSelectedIndex(index) {
+  ngDevMode && index !== -1 && assertGreaterThanOrEqual(index, HEADER_OFFSET, "Index must be past HEADER_OFFSET (or -1).");
+  ngDevMode && assertLessThan(index, instructionState.lFrame.lView.length, "Can't set index passed end of LView");
+  instructionState.lFrame.selectedIndex = index;
+}
+function getSelectedTNode() {
+  const lFrame = instructionState.lFrame;
+  return getTNode(lFrame.tView, lFrame.selectedIndex);
+}
+function \u0275\u0275namespaceSVG() {
+  instructionState.lFrame.currentNamespace = SVG_NAMESPACE;
+}
+function \u0275\u0275namespaceMathML() {
+  instructionState.lFrame.currentNamespace = MATH_ML_NAMESPACE;
+}
+function \u0275\u0275namespaceHTML() {
+  namespaceHTMLInternal();
+}
+function namespaceHTMLInternal() {
+  instructionState.lFrame.currentNamespace = null;
+}
+function getNamespace() {
+  return instructionState.lFrame.currentNamespace;
+}
+var _wasLastNodeCreated = true;
+function wasLastNodeCreated() {
+  return _wasLastNodeCreated;
+}
+function lastNodeWasCreated(flag) {
+  _wasLastNodeCreated = flag;
+}
+function createInjector(defType, parent = null, additionalProviders = null, name) {
+  const injector = createInjectorWithoutInjectorInstances(defType, parent, additionalProviders, name);
+  injector.resolveInjectorInitializers();
+  return injector;
+}
+function createInjectorWithoutInjectorInstances(defType, parent = null, additionalProviders = null, name, scopes = /* @__PURE__ */ new Set()) {
+  const providers = [additionalProviders || EMPTY_ARRAY, importProvidersFrom(defType)];
+  let source = void 0;
+  if (ngDevMode) {
+    source = name || (typeof defType === "object" ? void 0 : stringify(defType));
+  }
+  return new R3Injector(providers, parent || getNullInjector(), source || null, scopes);
+}
+var Injector = class _Injector {
+  static THROW_IF_NOT_FOUND = THROW_IF_NOT_FOUND;
+  static NULL = new NullInjector();
+  static create(options, parent) {
+    if (Array.isArray(options)) {
+      return createInjector({
+        name: ""
+      }, parent, options, "");
+    } else {
+      const name = options.name ?? "";
+      return createInjector({
+        name
+      }, options.parent, options.providers, name);
+    }
+  }
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _Injector,
+    providedIn: "any",
+    factory: () => \u0275\u0275inject(INJECTOR$1)
+  });
+  static __NG_ELEMENT_ID__ = -1;
+};
+var DOCUMENT = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "DocumentToken" : "");
+var DestroyRef = class {
+  static __NG_ELEMENT_ID__ = injectDestroyRef;
+  static __NG_ENV_ID__ = (injector) => injector;
+};
+var NodeInjectorDestroyRef = class extends DestroyRef {
+  _lView;
+  constructor(_lView) {
+    super();
+    this._lView = _lView;
+  }
+  get destroyed() {
+    return isDestroyed(this._lView);
+  }
+  onDestroy(callback) {
+    const lView = this._lView;
+    storeLViewOnDestroy(lView, callback);
+    return () => removeLViewOnDestroy(lView, callback);
+  }
+};
+function injectDestroyRef() {
+  return new NodeInjectorDestroyRef(getLView());
+}
+var SCHEDULE_IN_ROOT_ZONE_DEFAULT = false;
+var DEBUG_TASK_TRACKER = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "DEBUG_TASK_TRACKER" : "");
+var PendingTasksInternal = class _PendingTasksInternal {
+  taskId = 0;
+  pendingTasks = /* @__PURE__ */ new Set();
+  destroyed = false;
+  pendingTask = new BehaviorSubject(false);
+  debugTaskTracker = inject2(DEBUG_TASK_TRACKER, {
+    optional: true
+  });
+  get hasPendingTasks() {
+    return this.destroyed ? false : this.pendingTask.value;
+  }
+  get hasPendingTasksObservable() {
+    if (this.destroyed) {
+      return new Observable((subscriber) => {
+        subscriber.next(false);
+        subscriber.complete();
+      });
+    }
+    return this.pendingTask;
+  }
+  add() {
+    if (!this.hasPendingTasks && !this.destroyed) {
+      this.pendingTask.next(true);
+    }
+    const taskId = this.taskId++;
+    this.pendingTasks.add(taskId);
+    this.debugTaskTracker?.add(taskId);
+    return taskId;
+  }
+  has(taskId) {
+    return this.pendingTasks.has(taskId);
+  }
+  remove(taskId) {
+    this.pendingTasks.delete(taskId);
+    this.debugTaskTracker?.remove(taskId);
+    if (this.pendingTasks.size === 0 && this.hasPendingTasks) {
+      this.pendingTask.next(false);
+    }
+  }
+  ngOnDestroy() {
+    this.pendingTasks.clear();
+    if (this.hasPendingTasks) {
+      this.pendingTask.next(false);
+    }
+    this.destroyed = true;
+    this.pendingTask.unsubscribe();
+  }
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _PendingTasksInternal,
+    providedIn: "root",
+    factory: () => new _PendingTasksInternal()
+  });
+};
+var EventEmitter_ = class extends Subject {
+  __isAsync;
+  destroyRef = void 0;
+  pendingTasks = void 0;
+  constructor(isAsync = false) {
+    super();
+    this.__isAsync = isAsync;
+    if (isInInjectionContext()) {
+      this.destroyRef = inject2(DestroyRef, {
+        optional: true
+      }) ?? void 0;
+      this.pendingTasks = inject2(PendingTasksInternal, {
+        optional: true
+      }) ?? void 0;
+    }
+  }
+  emit(value) {
+    const prevConsumer = setActiveConsumer(null);
+    try {
+      super.next(value);
+    } finally {
+      setActiveConsumer(prevConsumer);
+    }
+  }
+  subscribe(observerOrNext, error, complete) {
+    let nextFn = observerOrNext;
+    let errorFn = error || (() => null);
+    let completeFn = complete;
+    if (observerOrNext && typeof observerOrNext === "object") {
+      const observer = observerOrNext;
+      nextFn = observer.next?.bind(observer);
+      errorFn = observer.error?.bind(observer);
+      completeFn = observer.complete?.bind(observer);
+    }
+    if (this.__isAsync) {
+      errorFn = this.wrapInTimeout(errorFn);
+      if (nextFn) {
+        nextFn = this.wrapInTimeout(nextFn);
+      }
+      if (completeFn) {
+        completeFn = this.wrapInTimeout(completeFn);
+      }
+    }
+    const sink = super.subscribe({
+      next: nextFn,
+      error: errorFn,
+      complete: completeFn
+    });
+    if (observerOrNext instanceof Subscription) {
+      observerOrNext.add(sink);
+    }
+    return sink;
+  }
+  wrapInTimeout(fn) {
+    return (value) => {
+      const taskId = this.pendingTasks?.add();
+      setTimeout(() => {
+        try {
+          fn(value);
+        } finally {
+          if (taskId !== void 0) {
+            this.pendingTasks?.remove(taskId);
+          }
+        }
+      });
+    };
+  }
+};
+var EventEmitter = EventEmitter_;
+function noop2(...args) {
+}
+function scheduleCallbackWithRafRace(callback) {
+  let timeoutId;
+  let animationFrameId;
+  function cleanup() {
+    callback = noop2;
+    try {
+      if (animationFrameId !== void 0 && typeof cancelAnimationFrame === "function") {
+        cancelAnimationFrame(animationFrameId);
+      }
+      if (timeoutId !== void 0) {
+        clearTimeout(timeoutId);
+      }
+    } catch {
+    }
+  }
+  timeoutId = setTimeout(() => {
+    callback();
+    cleanup();
+  });
+  if (typeof requestAnimationFrame === "function") {
+    animationFrameId = requestAnimationFrame(() => {
+      callback();
+      cleanup();
+    });
+  }
+  return () => cleanup();
+}
+function scheduleCallbackWithMicrotask(callback) {
+  queueMicrotask(() => callback());
+  return () => {
+    callback = noop2;
+  };
+}
+var AsyncStackTaggingZoneSpec = class {
+  createTask;
+  constructor(namePrefix, consoleAsyncStackTaggingImpl = console) {
+    this.name = "asyncStackTagging for " + namePrefix;
+    this.createTask = consoleAsyncStackTaggingImpl?.createTask ?? (() => null);
+  }
+  name;
+  onScheduleTask(delegate, _current, target, task) {
+    task.consoleTask = this.createTask(`Zone - ${task.source || task.type}`);
+    return delegate.scheduleTask(target, task);
+  }
+  onInvokeTask(delegate, _currentZone, targetZone, task, applyThis, applyArgs) {
+    let ret;
+    if (task.consoleTask) {
+      ret = task.consoleTask.run(() => delegate.invokeTask(targetZone, task, applyThis, applyArgs));
+    } else {
+      ret = delegate.invokeTask(targetZone, task, applyThis, applyArgs);
+    }
+    return ret;
+  }
+};
+var isAngularZoneProperty = "isAngularZone";
+var angularZoneInstanceIdProperty = isAngularZoneProperty + "_ID";
+var ngZoneInstanceId = 0;
+var NgZone = class _NgZone {
+  hasPendingMacrotasks = false;
+  hasPendingMicrotasks = false;
+  isStable = true;
+  onUnstable = new EventEmitter(false);
+  onMicrotaskEmpty = new EventEmitter(false);
+  onStable = new EventEmitter(false);
+  onError = new EventEmitter(false);
+  constructor(options) {
+    const {
+      enableLongStackTrace = false,
+      shouldCoalesceEventChangeDetection = false,
+      shouldCoalesceRunChangeDetection = false,
+      scheduleInRootZone = SCHEDULE_IN_ROOT_ZONE_DEFAULT
+    } = options;
+    if (typeof Zone == "undefined") {
+      throw new RuntimeError(908, ngDevMode && `In this configuration Angular requires Zone.js`);
+    }
+    Zone.assertZonePatched();
+    const self = this;
+    self._nesting = 0;
+    self._outer = self._inner = Zone.current;
+    if (ngDevMode) {
+      self._inner = self._inner.fork(new AsyncStackTaggingZoneSpec("Angular"));
+    }
+    if (Zone["TaskTrackingZoneSpec"]) {
+      self._inner = self._inner.fork(new Zone["TaskTrackingZoneSpec"]());
+    }
+    if (enableLongStackTrace && Zone["longStackTraceZoneSpec"]) {
+      self._inner = self._inner.fork(Zone["longStackTraceZoneSpec"]);
+    }
+    self.shouldCoalesceEventChangeDetection = !shouldCoalesceRunChangeDetection && shouldCoalesceEventChangeDetection;
+    self.shouldCoalesceRunChangeDetection = shouldCoalesceRunChangeDetection;
+    self.callbackScheduled = false;
+    self.scheduleInRootZone = scheduleInRootZone;
+    forkInnerZoneWithAngularBehavior(self);
+  }
+  static isInAngularZone() {
+    return typeof Zone !== "undefined" && Zone.current.get(isAngularZoneProperty) === true;
+  }
+  static assertInAngularZone() {
+    if (!_NgZone.isInAngularZone()) {
+      throw new RuntimeError(909, ngDevMode && "Expected to be in Angular Zone, but it is not!");
+    }
+  }
+  static assertNotInAngularZone() {
+    if (_NgZone.isInAngularZone()) {
+      throw new RuntimeError(909, ngDevMode && "Expected to not be in Angular Zone, but it is!");
+    }
+  }
+  run(fn, applyThis, applyArgs) {
+    return this._inner.run(fn, applyThis, applyArgs);
+  }
+  runTask(fn, applyThis, applyArgs, name) {
+    const zone = this._inner;
+    const task = zone.scheduleEventTask("NgZoneEvent: " + name, fn, EMPTY_PAYLOAD, noop2, noop2);
+    try {
+      return zone.runTask(task, applyThis, applyArgs);
+    } finally {
+      zone.cancelTask(task);
+    }
+  }
+  runGuarded(fn, applyThis, applyArgs) {
+    return this._inner.runGuarded(fn, applyThis, applyArgs);
+  }
+  runOutsideAngular(fn) {
+    return this._outer.run(fn);
+  }
+};
+var EMPTY_PAYLOAD = {};
+function checkStable(zone) {
+  if (zone._nesting == 0 && !zone.hasPendingMicrotasks && !zone.isStable) {
+    try {
+      zone._nesting++;
+      zone.onMicrotaskEmpty.emit(null);
+    } finally {
+      zone._nesting--;
+      if (!zone.hasPendingMicrotasks) {
+        try {
+          zone.runOutsideAngular(() => zone.onStable.emit(null));
+        } finally {
+          zone.isStable = true;
+        }
+      }
+    }
+  }
+}
+function delayChangeDetectionForEvents(zone) {
+  if (zone.isCheckStableRunning || zone.callbackScheduled) {
+    return;
+  }
+  zone.callbackScheduled = true;
+  function scheduleCheckStable() {
+    scheduleCallbackWithRafRace(() => {
+      zone.callbackScheduled = false;
+      updateMicroTaskStatus(zone);
+      zone.isCheckStableRunning = true;
+      checkStable(zone);
+      zone.isCheckStableRunning = false;
+    });
+  }
+  if (zone.scheduleInRootZone) {
+    Zone.root.run(() => {
+      scheduleCheckStable();
+    });
+  } else {
+    zone._outer.run(() => {
+      scheduleCheckStable();
+    });
+  }
+  updateMicroTaskStatus(zone);
+}
+function forkInnerZoneWithAngularBehavior(zone) {
+  const delayChangeDetectionForEventsDelegate = () => {
+    delayChangeDetectionForEvents(zone);
+  };
+  const instanceId = ngZoneInstanceId++;
+  zone._inner = zone._inner.fork({
+    name: "angular",
+    properties: {
+      [isAngularZoneProperty]: true,
+      [angularZoneInstanceIdProperty]: instanceId,
+      [angularZoneInstanceIdProperty + instanceId]: true
+    },
+    onInvokeTask: (delegate, current, target, task, applyThis, applyArgs) => {
+      if (shouldBeIgnoredByZone(applyArgs)) {
+        return delegate.invokeTask(target, task, applyThis, applyArgs);
+      }
+      try {
+        onEnter(zone);
+        return delegate.invokeTask(target, task, applyThis, applyArgs);
+      } finally {
+        if (zone.shouldCoalesceEventChangeDetection && task.type === "eventTask" || zone.shouldCoalesceRunChangeDetection) {
+          delayChangeDetectionForEventsDelegate();
+        }
+        onLeave(zone);
+      }
+    },
+    onInvoke: (delegate, current, target, callback, applyThis, applyArgs, source) => {
+      try {
+        onEnter(zone);
+        return delegate.invoke(target, callback, applyThis, applyArgs, source);
+      } finally {
+        if (zone.shouldCoalesceRunChangeDetection && !zone.callbackScheduled && !isSchedulerTick(applyArgs)) {
+          delayChangeDetectionForEventsDelegate();
+        }
+        onLeave(zone);
+      }
+    },
+    onHasTask: (delegate, current, target, hasTaskState) => {
+      delegate.hasTask(target, hasTaskState);
+      if (current === target) {
+        if (hasTaskState.change == "microTask") {
+          zone._hasPendingMicrotasks = hasTaskState.microTask;
+          updateMicroTaskStatus(zone);
+          checkStable(zone);
+        } else if (hasTaskState.change == "macroTask") {
+          zone.hasPendingMacrotasks = hasTaskState.macroTask;
+        }
+      }
+    },
+    onHandleError: (delegate, current, target, error) => {
+      delegate.handleError(target, error);
+      zone.runOutsideAngular(() => zone.onError.emit(error));
+      return false;
+    }
+  });
+}
+function updateMicroTaskStatus(zone) {
+  if (zone._hasPendingMicrotasks || (zone.shouldCoalesceEventChangeDetection || zone.shouldCoalesceRunChangeDetection) && zone.callbackScheduled === true) {
+    zone.hasPendingMicrotasks = true;
+  } else {
+    zone.hasPendingMicrotasks = false;
+  }
+}
+function onEnter(zone) {
+  zone._nesting++;
+  if (zone.isStable) {
+    zone.isStable = false;
+    zone.onUnstable.emit(null);
+  }
+}
+function onLeave(zone) {
+  zone._nesting--;
+  checkStable(zone);
+}
+var NoopNgZone = class {
+  hasPendingMicrotasks = false;
+  hasPendingMacrotasks = false;
+  isStable = true;
+  onUnstable = new EventEmitter();
+  onMicrotaskEmpty = new EventEmitter();
+  onStable = new EventEmitter();
+  onError = new EventEmitter();
+  run(fn, applyThis, applyArgs) {
+    return fn.apply(applyThis, applyArgs);
+  }
+  runGuarded(fn, applyThis, applyArgs) {
+    return fn.apply(applyThis, applyArgs);
+  }
+  runOutsideAngular(fn) {
+    return fn();
+  }
+  runTask(fn, applyThis, applyArgs, name) {
+    return fn.apply(applyThis, applyArgs);
+  }
+};
+function shouldBeIgnoredByZone(applyArgs) {
+  return hasApplyArgsData(applyArgs, "__ignore_ng_zone__");
+}
+function isSchedulerTick(applyArgs) {
+  return hasApplyArgsData(applyArgs, "__scheduler_tick__");
+}
+function hasApplyArgsData(applyArgs, key) {
+  if (!Array.isArray(applyArgs)) {
+    return false;
+  }
+  if (applyArgs.length !== 1) {
+    return false;
+  }
+  return applyArgs[0]?.data?.[key] === true;
+}
+var ErrorHandler = class {
+  _console = console;
+  handleError(error) {
+    this._console.error("ERROR", error);
+  }
+};
+var INTERNAL_APPLICATION_ERROR_HANDLER = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "internal error handler" : "", {
+  factory: () => {
+    const zone = inject2(NgZone);
+    const injector = inject2(EnvironmentInjector);
+    let userErrorHandler;
+    return (e) => {
+      zone.runOutsideAngular(() => {
+        if (injector.destroyed && !userErrorHandler) {
+          setTimeout(() => {
+            throw e;
+          });
+        } else {
+          userErrorHandler ??= injector.get(ErrorHandler);
+          userErrorHandler.handleError(e);
+        }
+      });
+    };
+  }
+});
+var errorHandlerEnvironmentInitializer = {
+  provide: ENVIRONMENT_INITIALIZER,
+  useValue: () => {
+    const handler = inject2(ErrorHandler, {
+      optional: true
+    });
+    if ((typeof ngDevMode === "undefined" || ngDevMode) && handler === null) {
+      throw new RuntimeError(402, `A required Injectable was not found in the dependency injection tree. If you are bootstrapping an NgModule, make sure that the \`BrowserModule\` is imported.`);
+    }
+  },
+  multi: true
+};
+var globalErrorListeners = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "GlobalErrorListeners" : "", {
+  factory: () => {
+    if (false) {
+      return;
+    }
+    const window2 = inject2(DOCUMENT).defaultView;
+    if (!window2) {
+      return;
+    }
+    const errorHandler2 = inject2(INTERNAL_APPLICATION_ERROR_HANDLER);
+    const rejectionListener = (e) => {
+      errorHandler2(e.reason);
+      e.preventDefault();
+    };
+    const errorListener = (e) => {
+      if (e.error) {
+        errorHandler2(e.error);
+      } else {
+        errorHandler2(new Error(ngDevMode ? `An ErrorEvent with no error occurred. See Error.cause for details: ${e.message}` : e.message, {
+          cause: e
+        }));
+      }
+      e.preventDefault();
+    };
+    const setupEventListeners = () => {
+      window2.addEventListener("unhandledrejection", rejectionListener);
+      window2.addEventListener("error", errorListener);
+    };
+    if (typeof Zone !== "undefined") {
+      Zone.root.run(setupEventListeners);
+    } else {
+      setupEventListeners();
+    }
+    inject2(DestroyRef).onDestroy(() => {
+      window2.removeEventListener("error", errorListener);
+      window2.removeEventListener("unhandledrejection", rejectionListener);
+    });
+  }
+});
+function provideBrowserGlobalErrorListeners() {
+  return makeEnvironmentProviders([provideEnvironmentInitializer(() => void inject2(globalErrorListeners))]);
+}
+function signal(initialValue, options) {
+  const [get, set, update] = createSignal(initialValue, options?.equal);
+  const signalFn = get;
+  const node = signalFn[SIGNAL];
+  signalFn.set = set;
+  signalFn.update = update;
+  signalFn.asReadonly = signalAsReadonlyFn.bind(signalFn);
+  if (typeof ngDevMode !== "undefined" && ngDevMode) {
+    const debugName = options?.debugName;
+    node.debugName = debugName;
+    signalFn.toString = () => `[Signal${debugName ? " (" + debugName + ")" : ""}: ${signalFn()}]`;
+  }
+  return signalFn;
+}
+function signalAsReadonlyFn() {
+  const node = this[SIGNAL];
+  if (node.readonlyFn === void 0) {
+    const readonlyFn = () => this();
+    readonlyFn[SIGNAL] = node;
+    node.readonlyFn = readonlyFn;
+  }
+  return node.readonlyFn;
+}
+function assertNotInReactiveContext(debugFn, extraContext) {
+  if (getActiveConsumer() !== null) {
+    throw new RuntimeError(-602, ngDevMode && `${debugFn.name}() cannot be called from within a reactive context.${extraContext ? ` ${extraContext}` : ""}`);
+  }
+}
+var ViewContext = class {
+  view;
+  node;
+  constructor(view, node) {
+    this.view = view;
+    this.node = node;
+  }
+  static __NG_ELEMENT_ID__ = injectViewContext;
+};
+function injectViewContext() {
+  return new ViewContext(getLView(), getCurrentTNode());
+}
+var ChangeDetectionScheduler = class {
+};
+var ZONELESS_ENABLED = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "Zoneless enabled" : "", {
+  factory: () => true
+});
+var PROVIDED_ZONELESS = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "Zoneless provided" : "", {
+  factory: () => false
+});
+var SCHEDULE_IN_ROOT_ZONE = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "run changes outside zone in root" : "");
+var PendingTasks = class _PendingTasks {
+  internalPendingTasks = inject2(PendingTasksInternal);
+  scheduler = inject2(ChangeDetectionScheduler);
+  errorHandler = inject2(INTERNAL_APPLICATION_ERROR_HANDLER);
+  add() {
+    const taskId = this.internalPendingTasks.add();
+    return () => {
+      if (!this.internalPendingTasks.has(taskId)) {
+        return;
+      }
+      this.scheduler.notify(11);
+      this.internalPendingTasks.remove(taskId);
+    };
+  }
+  run(fn) {
+    const removeTask = this.add();
+    fn().catch(this.errorHandler).finally(removeTask);
+  }
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _PendingTasks,
+    providedIn: "root",
+    factory: () => new _PendingTasks()
+  });
+};
+var EffectScheduler = class _EffectScheduler {
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _EffectScheduler,
+    providedIn: "root",
+    factory: () => new ZoneAwareEffectScheduler()
+  });
+};
+var ZoneAwareEffectScheduler = class {
+  dirtyEffectCount = 0;
+  queues = /* @__PURE__ */ new Map();
+  add(handle) {
+    this.enqueue(handle);
+    this.schedule(handle);
+  }
+  schedule(handle) {
+    if (!handle.dirty) {
+      return;
+    }
+    this.dirtyEffectCount++;
+  }
+  remove(handle) {
+    const zone = handle.zone;
+    const queue = this.queues.get(zone);
+    if (!queue.has(handle)) {
+      return;
+    }
+    queue.delete(handle);
+    if (handle.dirty) {
+      this.dirtyEffectCount--;
+    }
+  }
+  enqueue(handle) {
+    const zone = handle.zone;
+    if (!this.queues.has(zone)) {
+      this.queues.set(zone, /* @__PURE__ */ new Set());
+    }
+    const queue = this.queues.get(zone);
+    if (queue.has(handle)) {
+      return;
+    }
+    queue.add(handle);
+  }
+  flush() {
+    while (this.dirtyEffectCount > 0) {
+      let ranOneEffect = false;
+      for (const [zone, queue] of this.queues) {
+        if (zone === null) {
+          ranOneEffect ||= this.flushQueue(queue);
+        } else {
+          ranOneEffect ||= zone.run(() => this.flushQueue(queue));
+        }
+      }
+      if (!ranOneEffect) {
+        this.dirtyEffectCount = 0;
+      }
+    }
+  }
+  flushQueue(queue) {
+    let ranOneEffect = false;
+    for (const handle of queue) {
+      if (!handle.dirty) {
+        continue;
+      }
+      this.dirtyEffectCount--;
+      ranOneEffect = true;
+      handle.run();
+    }
+    return ranOneEffect;
+  }
+};
+var EffectRefImpl = class {
+  [SIGNAL];
+  constructor(node) {
+    this[SIGNAL] = node;
+  }
+  destroy() {
+    this[SIGNAL].destroy();
+  }
+};
+function effect(effectFn, options) {
+  ngDevMode && assertNotInReactiveContext(effect, "Call `effect` outside of a reactive context. For example, schedule the effect inside the component constructor.");
+  if (ngDevMode && !options?.injector) {
+    assertInInjectionContext(effect);
+  }
+  if (ngDevMode && options?.allowSignalWrites !== void 0) {
+    console.warn(`The 'allowSignalWrites' flag is deprecated and no longer impacts effect() (writes are always allowed)`);
+  }
+  const injector = options?.injector ?? inject2(Injector);
+  let destroyRef = options?.manualCleanup !== true ? injector.get(DestroyRef) : null;
+  let node;
+  const viewContext = injector.get(ViewContext, null, {
+    optional: true
+  });
+  const notifier = injector.get(ChangeDetectionScheduler);
+  if (viewContext !== null) {
+    node = createViewEffect(viewContext.view, notifier, effectFn);
+    if (destroyRef instanceof NodeInjectorDestroyRef && destroyRef._lView === viewContext.view) {
+      destroyRef = null;
+    }
+  } else {
+    node = createRootEffect(effectFn, injector.get(EffectScheduler), notifier);
+  }
+  node.injector = injector;
+  if (destroyRef !== null) {
+    node.onDestroyFns = [destroyRef.onDestroy(() => node.destroy())];
+  }
+  const effectRef = new EffectRefImpl(node);
+  if (ngDevMode) {
+    node.debugName = options?.debugName ?? "";
+    const prevInjectorProfilerContext = setInjectorProfilerContext({
+      injector,
+      token: null
+    });
+    try {
+      emitEffectCreatedEvent(effectRef);
+    } finally {
+      setInjectorProfilerContext(prevInjectorProfilerContext);
+    }
+  }
+  return effectRef;
+}
+var EFFECT_NODE = /* @__PURE__ */ (() => __spreadProps(__spreadValues({}, BASE_EFFECT_NODE), {
+  cleanupFns: void 0,
+  zone: null,
+  onDestroyFns: null,
+  run() {
+    if (ngDevMode && isInNotificationPhase()) {
+      throw new Error(`Schedulers cannot synchronously execute watches while scheduling.`);
+    }
+    const prevRefreshingViews = setIsRefreshingViews(false);
+    try {
+      runEffect(this);
+    } finally {
+      setIsRefreshingViews(prevRefreshingViews);
+    }
+  },
+  cleanup() {
+    if (!this.cleanupFns?.length) {
+      return;
+    }
+    const prevConsumer = setActiveConsumer(null);
+    try {
+      while (this.cleanupFns.length) {
+        this.cleanupFns.pop()();
+      }
+    } finally {
+      this.cleanupFns = [];
+      setActiveConsumer(prevConsumer);
+    }
+  }
+}))();
+var ROOT_EFFECT_NODE = /* @__PURE__ */ (() => __spreadProps(__spreadValues({}, EFFECT_NODE), {
+  consumerMarkedDirty() {
+    this.scheduler.schedule(this);
+    this.notifier.notify(12);
+  },
+  destroy() {
+    consumerDestroy(this);
+    if (this.onDestroyFns !== null) {
+      for (const fn of this.onDestroyFns) {
+        fn();
+      }
+    }
+    this.cleanup();
+    this.scheduler.remove(this);
+  }
+}))();
+var VIEW_EFFECT_NODE = /* @__PURE__ */ (() => __spreadProps(__spreadValues({}, EFFECT_NODE), {
+  consumerMarkedDirty() {
+    this.view[FLAGS] |= 8192;
+    markAncestorsForTraversal(this.view);
+    this.notifier.notify(13);
+  },
+  destroy() {
+    consumerDestroy(this);
+    if (this.onDestroyFns !== null) {
+      for (const fn of this.onDestroyFns) {
+        fn();
+      }
+    }
+    this.cleanup();
+    this.view[EFFECTS]?.delete(this);
+  }
+}))();
+function createViewEffect(view, notifier, fn) {
+  const node = Object.create(VIEW_EFFECT_NODE);
+  node.view = view;
+  node.zone = typeof Zone !== "undefined" ? Zone.current : null;
+  node.notifier = notifier;
+  node.fn = createEffectFn(node, fn);
+  view[EFFECTS] ??= /* @__PURE__ */ new Set();
+  view[EFFECTS].add(node);
+  node.consumerMarkedDirty(node);
+  return node;
+}
+function createRootEffect(fn, scheduler, notifier) {
+  const node = Object.create(ROOT_EFFECT_NODE);
+  node.fn = createEffectFn(node, fn);
+  node.scheduler = scheduler;
+  node.notifier = notifier;
+  node.zone = typeof Zone !== "undefined" ? Zone.current : null;
+  node.scheduler.add(node);
+  node.notifier.notify(12);
+  return node;
+}
+function createEffectFn(node, fn) {
+  return () => {
+    fn((cleanupFn) => (node.cleanupFns ??= []).push(cleanupFn));
+  };
+}
+
+// node_modules/@angular/core/fesm2022/_debug_node-chunk.mjs
+/**
+ * @license Angular v21.2.17
+ * (c) 2010-2026 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+function noSideEffects(fn) {
+  return {
+    toString: fn
+  }.toString();
+}
+var ANNOTATIONS = "__annotations__";
+var PARAMETERS = "__parameters__";
+var PROP_METADATA = "__prop__metadata__";
+function makeDecorator(name, props, parentClass, additionalProcessing, typeFn) {
+  return noSideEffects(() => {
+    const metaCtor = makeMetadataCtor(props);
+    function DecoratorFactory(...args) {
+      if (this instanceof DecoratorFactory) {
+        metaCtor.call(this, ...args);
+        return this;
+      }
+      const annotationInstance = new DecoratorFactory(...args);
+      return function TypeDecorator(cls) {
+        if (typeFn) typeFn(cls, ...args);
+        const annotations = cls.hasOwnProperty(ANNOTATIONS) ? cls[ANNOTATIONS] : Object.defineProperty(cls, ANNOTATIONS, {
+          value: []
+        })[ANNOTATIONS];
+        annotations.push(annotationInstance);
+        return cls;
+      };
+    }
+    if (parentClass) {
+      DecoratorFactory.prototype = Object.create(parentClass.prototype);
+    }
+    DecoratorFactory.prototype.ngMetadataName = name;
+    DecoratorFactory.annotationCls = DecoratorFactory;
+    return DecoratorFactory;
+  });
+}
+function makeMetadataCtor(props) {
+  return function ctor(...args) {
+    if (props) {
+      const values = props(...args);
+      for (const propName in values) {
+        this[propName] = values[propName];
+      }
+    }
+  };
+}
+function makeParamDecorator(name, props, parentClass) {
+  return noSideEffects(() => {
+    const metaCtor = makeMetadataCtor(props);
+    function ParamDecoratorFactory(...args) {
+      if (this instanceof ParamDecoratorFactory) {
+        metaCtor.apply(this, args);
+        return this;
+      }
+      const annotationInstance = new ParamDecoratorFactory(...args);
+      ParamDecorator.annotation = annotationInstance;
+      return ParamDecorator;
+      function ParamDecorator(cls, unusedKey, index) {
+        const parameters = cls.hasOwnProperty(PARAMETERS) ? cls[PARAMETERS] : Object.defineProperty(cls, PARAMETERS, {
+          value: []
+        })[PARAMETERS];
+        while (parameters.length <= index) {
+          parameters.push(null);
+        }
+        (parameters[index] = parameters[index] || []).push(annotationInstance);
+        return cls;
+      }
+    }
+    ParamDecoratorFactory.prototype.ngMetadataName = name;
+    ParamDecoratorFactory.annotationCls = ParamDecoratorFactory;
+    return ParamDecoratorFactory;
+  });
+}
+function makePropDecorator(name, props, parentClass, additionalProcessing) {
+  return noSideEffects(() => {
+    const metaCtor = makeMetadataCtor(props);
+    function PropDecoratorFactory(...args) {
+      if (this instanceof PropDecoratorFactory) {
+        metaCtor.apply(this, args);
+        return this;
+      }
+      const decoratorInstance = new PropDecoratorFactory(...args);
+      function PropDecorator(target, name2) {
+        if (target === void 0) {
+          throw new Error("Standard Angular field decorators are not supported in JIT mode.");
+        }
+        const constructor = target.constructor;
+        const meta = constructor.hasOwnProperty(PROP_METADATA) ? constructor[PROP_METADATA] : Object.defineProperty(constructor, PROP_METADATA, {
+          value: {}
+        })[PROP_METADATA];
+        meta[name2] = meta.hasOwnProperty(name2) && meta[name2] || [];
+        meta[name2].unshift(decoratorInstance);
+      }
+      return PropDecorator;
+    }
+    if (parentClass) {
+      PropDecoratorFactory.prototype = Object.create(parentClass.prototype);
+    }
+    PropDecoratorFactory.prototype.ngMetadataName = name;
+    PropDecoratorFactory.annotationCls = PropDecoratorFactory;
+    return PropDecoratorFactory;
+  });
+}
+var Inject = attachInjectFlag(makeParamDecorator("Inject", (token) => ({
+  token
+})), -1);
+var Optional = attachInjectFlag(makeParamDecorator("Optional"), 8);
+var Self = attachInjectFlag(makeParamDecorator("Self"), 2);
+var SkipSelf = attachInjectFlag(makeParamDecorator("SkipSelf"), 4);
+var Host = attachInjectFlag(makeParamDecorator("Host"), 1);
+function getCompilerFacade(request) {
+  const globalNg = _global["ng"];
+  if (globalNg && globalNg.\u0275compilerFacade) {
+    return globalNg.\u0275compilerFacade;
+  }
+  if (typeof ngDevMode === "undefined" || ngDevMode) {
+    console.error(`JIT compilation failed for ${request.kind}`, request.type);
+    let message = `The ${request.kind} '${request.type.name}' needs to be compiled using the JIT compiler, but '@angular/compiler' is not available.
+
+`;
+    if (request.usage === 1) {
+      message += `The ${request.kind} is part of a library that has been partially compiled.
+`;
+      message += `However, the Angular Linker has not processed the library such that JIT compilation is used as fallback.
+`;
+      message += "\n";
+      message += `Ideally, the library is processed using the Angular Linker to become fully AOT compiled.
+`;
+    } else {
+      message += `JIT compilation is discouraged for production use-cases! Consider using AOT mode instead.
+`;
+    }
+    message += `Alternatively, the JIT compiler should be loaded by bootstrapping using '@angular/platform-browser-dynamic' or '@angular/platform-server',
+`;
+    message += `or manually provide the compiler with 'import "@angular/compiler";' before bootstrapping.`;
+    throw new Error(message);
+  } else {
+    throw new Error("JIT compiler unavailable");
+  }
+}
+var angularCoreDiEnv = {
+  "\u0275\u0275defineInjectable": \u0275\u0275defineInjectable,
+  "\u0275\u0275defineInjector": \u0275\u0275defineInjector,
+  "\u0275\u0275inject": \u0275\u0275inject,
+  "\u0275\u0275invalidFactoryDep": \u0275\u0275invalidFactoryDep,
+  "resolveForwardRef": resolveForwardRef
+};
+var Type = Function;
+function isType(v) {
+  return typeof v === "function";
+}
+var ES5_DELEGATE_CTOR = /^function\s+\S+\(\)\s*{[\s\S]+\.apply\(this,\s*(arguments|(?:[^()]+\(\[\],)?[^()]+\(arguments\).*)\)/;
+var ES2015_INHERITED_CLASS = /^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{/;
+var ES2015_INHERITED_CLASS_WITH_CTOR = /^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{[\s\S]*constructor\s*\(/;
+var ES2015_INHERITED_CLASS_WITH_DELEGATE_CTOR = /^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{[\s\S]*constructor\s*\(\)\s*{[^}]*super\(\.\.\.arguments\)/;
+function isDelegateCtor(typeStr) {
+  return ES5_DELEGATE_CTOR.test(typeStr) || ES2015_INHERITED_CLASS_WITH_DELEGATE_CTOR.test(typeStr) || ES2015_INHERITED_CLASS.test(typeStr) && !ES2015_INHERITED_CLASS_WITH_CTOR.test(typeStr);
+}
+var ReflectionCapabilities = class {
+  _reflect;
+  constructor(reflect) {
+    this._reflect = reflect || _global["Reflect"];
+  }
+  factory(t) {
+    return (...args) => new t(...args);
+  }
+  _zipTypesAndAnnotations(paramTypes, paramAnnotations) {
+    let result;
+    if (typeof paramTypes === "undefined") {
+      result = newArray(paramAnnotations.length);
+    } else {
+      result = newArray(paramTypes.length);
+    }
+    for (let i = 0; i < result.length; i++) {
+      if (typeof paramTypes === "undefined") {
+        result[i] = [];
+      } else if (paramTypes[i] && paramTypes[i] != Object) {
+        result[i] = [paramTypes[i]];
+      } else {
+        result[i] = [];
+      }
+      if (paramAnnotations && paramAnnotations[i] != null) {
+        result[i] = result[i].concat(paramAnnotations[i]);
+      }
+    }
+    return result;
+  }
+  _ownParameters(type, parentCtor) {
+    const typeStr = type.toString();
+    if (isDelegateCtor(typeStr)) {
+      return null;
+    }
+    if (type.parameters && type.parameters !== parentCtor.parameters) {
+      return type.parameters;
+    }
+    const tsickleCtorParams = type.ctorParameters;
+    if (tsickleCtorParams && tsickleCtorParams !== parentCtor.ctorParameters) {
+      const ctorParameters = typeof tsickleCtorParams === "function" ? tsickleCtorParams() : tsickleCtorParams;
+      const paramTypes2 = ctorParameters.map((ctorParam) => ctorParam && ctorParam.type);
+      const paramAnnotations2 = ctorParameters.map((ctorParam) => ctorParam && convertTsickleDecoratorIntoMetadata(ctorParam.decorators));
+      return this._zipTypesAndAnnotations(paramTypes2, paramAnnotations2);
+    }
+    const paramAnnotations = type.hasOwnProperty(PARAMETERS) && type[PARAMETERS];
+    const paramTypes = this._reflect && this._reflect.getOwnMetadata && this._reflect.getOwnMetadata("design:paramtypes", type);
+    if (paramTypes || paramAnnotations) {
+      return this._zipTypesAndAnnotations(paramTypes, paramAnnotations);
+    }
+    return newArray(type.length);
+  }
+  parameters(type) {
+    if (!isType(type)) {
+      return [];
+    }
+    const parentCtor = getParentCtor(type);
+    let parameters = this._ownParameters(type, parentCtor);
+    if (!parameters && parentCtor !== Object) {
+      parameters = this.parameters(parentCtor);
+    }
+    return parameters || [];
+  }
+  _ownAnnotations(typeOrFunc, parentCtor) {
+    if (typeOrFunc.annotations && typeOrFunc.annotations !== parentCtor.annotations) {
+      let annotations = typeOrFunc.annotations;
+      if (typeof annotations === "function" && annotations.annotations) {
+        annotations = annotations.annotations;
+      }
+      return annotations;
+    }
+    if (typeOrFunc.decorators && typeOrFunc.decorators !== parentCtor.decorators) {
+      return convertTsickleDecoratorIntoMetadata(typeOrFunc.decorators);
+    }
+    if (typeOrFunc.hasOwnProperty(ANNOTATIONS)) {
+      return typeOrFunc[ANNOTATIONS];
+    }
+    return null;
+  }
+  annotations(typeOrFunc) {
+    if (!isType(typeOrFunc)) {
+      return [];
+    }
+    const parentCtor = getParentCtor(typeOrFunc);
+    const ownAnnotations = this._ownAnnotations(typeOrFunc, parentCtor) || [];
+    const parentAnnotations = parentCtor !== Object ? this.annotations(parentCtor) : [];
+    return parentAnnotations.concat(ownAnnotations);
+  }
+  _ownPropMetadata(typeOrFunc, parentCtor) {
+    if (typeOrFunc.propMetadata && typeOrFunc.propMetadata !== parentCtor.propMetadata) {
+      let propMetadata = typeOrFunc.propMetadata;
+      if (typeof propMetadata === "function" && propMetadata.propMetadata) {
+        propMetadata = propMetadata.propMetadata;
+      }
+      return propMetadata;
+    }
+    if (typeOrFunc.propDecorators && typeOrFunc.propDecorators !== parentCtor.propDecorators) {
+      const propDecorators = typeOrFunc.propDecorators;
+      const propMetadata = {};
+      Object.keys(propDecorators).forEach((prop) => {
+        propMetadata[prop] = convertTsickleDecoratorIntoMetadata(propDecorators[prop]);
+      });
+      return propMetadata;
+    }
+    if (typeOrFunc.hasOwnProperty(PROP_METADATA)) {
+      return typeOrFunc[PROP_METADATA];
+    }
+    return null;
+  }
+  propMetadata(typeOrFunc) {
+    if (!isType(typeOrFunc)) {
+      return {};
+    }
+    const parentCtor = getParentCtor(typeOrFunc);
+    const propMetadata = {};
+    if (parentCtor !== Object) {
+      const parentPropMetadata = this.propMetadata(parentCtor);
+      Object.keys(parentPropMetadata).forEach((propName) => {
+        propMetadata[propName] = parentPropMetadata[propName];
+      });
+    }
+    const ownPropMetadata = this._ownPropMetadata(typeOrFunc, parentCtor);
+    if (ownPropMetadata) {
+      Object.keys(ownPropMetadata).forEach((propName) => {
+        const decorators = [];
+        if (propMetadata.hasOwnProperty(propName)) {
+          decorators.push(...propMetadata[propName]);
+        }
+        decorators.push(...ownPropMetadata[propName]);
+        propMetadata[propName] = decorators;
+      });
+    }
+    return propMetadata;
+  }
+  ownPropMetadata(typeOrFunc) {
+    if (!isType(typeOrFunc)) {
+      return {};
+    }
+    return this._ownPropMetadata(typeOrFunc, getParentCtor(typeOrFunc)) || {};
+  }
+  hasLifecycleHook(type, lcProperty) {
+    return type instanceof Type && lcProperty in type.prototype;
+  }
+};
+function convertTsickleDecoratorIntoMetadata(decoratorInvocations) {
+  if (!decoratorInvocations) {
+    return [];
+  }
+  return decoratorInvocations.map((decoratorInvocation) => {
+    const decoratorType = decoratorInvocation.type;
+    const annotationCls = decoratorType.annotationCls;
+    const annotationArgs = decoratorInvocation.args ? decoratorInvocation.args : [];
+    return new annotationCls(...annotationArgs);
+  });
+}
+function getParentCtor(ctor) {
+  const parentProto = ctor.prototype ? Object.getPrototypeOf(ctor.prototype) : null;
+  const parentCtor = parentProto ? parentProto.constructor : null;
+  return parentCtor || Object;
+}
+function applyValueToInputField(instance, inputSignalNode, privateName, value) {
+  if (inputSignalNode !== null) {
+    inputSignalNode.applyValueToInputSignal(inputSignalNode, value);
+  } else {
+    instance[privateName] = value;
+  }
+}
+var SimpleChange = class {
+  previousValue;
+  currentValue;
+  firstChange;
+  constructor(previousValue, currentValue, firstChange) {
+    this.previousValue = previousValue;
+    this.currentValue = currentValue;
+    this.firstChange = firstChange;
+  }
+  isFirstChange() {
+    return this.firstChange;
+  }
+};
+var \u0275\u0275NgOnChangesFeature = /* @__PURE__ */ (() => {
+  const \u0275\u0275NgOnChangesFeatureImpl = () => NgOnChangesFeatureImpl;
+  \u0275\u0275NgOnChangesFeatureImpl.ngInherit = true;
+  return \u0275\u0275NgOnChangesFeatureImpl;
+})();
+function NgOnChangesFeatureImpl(definition) {
+  if (definition.type.prototype.ngOnChanges) {
+    definition.setInput = ngOnChangesSetInput;
+  }
+  return rememberChangeHistoryAndInvokeOnChangesHook;
+}
+function rememberChangeHistoryAndInvokeOnChangesHook() {
+  const simpleChangesStore = getSimpleChangesStore(this);
+  const current = simpleChangesStore?.current;
+  if (current) {
+    const previous = simpleChangesStore.previous;
+    if (previous === EMPTY_OBJ) {
+      simpleChangesStore.previous = current;
+    } else {
+      for (let key in current) {
+        previous[key] = current[key];
+      }
+    }
+    simpleChangesStore.current = null;
+    this.ngOnChanges(current);
+  }
+}
+function ngOnChangesSetInput(instance, inputSignalNode, value, publicName, privateName) {
+  const declaredName = this.declaredInputs[publicName];
+  ngDevMode && assertString(declaredName, "Name of input in ngOnChanges has to be a string");
+  const simpleChangesStore = getSimpleChangesStore(instance) || setSimpleChangesStore(instance, {
+    previous: EMPTY_OBJ,
+    current: null
+  });
+  const current = simpleChangesStore.current || (simpleChangesStore.current = {});
+  const previous = simpleChangesStore.previous;
+  const previousChange = previous[declaredName];
+  current[declaredName] = new SimpleChange(previousChange && previousChange.currentValue, value, previous === EMPTY_OBJ);
+  applyValueToInputField(instance, inputSignalNode, privateName, value);
+}
+var SIMPLE_CHANGES_STORE = "__ngSimpleChanges__";
+function getSimpleChangesStore(instance) {
+  return instance[SIMPLE_CHANGES_STORE] || null;
+}
+function setSimpleChangesStore(instance, store2) {
+  return instance[SIMPLE_CHANGES_STORE] = store2;
+}
+var profilerCallbacks = [];
+var NOOP_PROFILER_REMOVAL2 = () => {
+};
+function removeProfiler2(profiler2) {
+  const profilerIdx = profilerCallbacks.indexOf(profiler2);
+  if (profilerIdx !== -1) {
+    profilerCallbacks.splice(profilerIdx, 1);
+  }
+}
+function setProfiler(profiler2) {
+  if (profiler2 !== null) {
+    if (!profilerCallbacks.includes(profiler2)) {
+      profilerCallbacks.push(profiler2);
+    }
+    return () => removeProfiler2(profiler2);
+  } else {
+    profilerCallbacks.length = 0;
+    return NOOP_PROFILER_REMOVAL2;
+  }
+}
+var profiler = function(event, instance = null, eventFn) {
+  for (let i = 0; i < profilerCallbacks.length; i++) {
+    const profilerCallback = profilerCallbacks[i];
+    profilerCallback(event, instance, eventFn);
+  }
+};
+var ProfilerEvent;
+(function(ProfilerEvent2) {
+  ProfilerEvent2[ProfilerEvent2["TemplateCreateStart"] = 0] = "TemplateCreateStart";
+  ProfilerEvent2[ProfilerEvent2["TemplateCreateEnd"] = 1] = "TemplateCreateEnd";
+  ProfilerEvent2[ProfilerEvent2["TemplateUpdateStart"] = 2] = "TemplateUpdateStart";
+  ProfilerEvent2[ProfilerEvent2["TemplateUpdateEnd"] = 3] = "TemplateUpdateEnd";
+  ProfilerEvent2[ProfilerEvent2["LifecycleHookStart"] = 4] = "LifecycleHookStart";
+  ProfilerEvent2[ProfilerEvent2["LifecycleHookEnd"] = 5] = "LifecycleHookEnd";
+  ProfilerEvent2[ProfilerEvent2["OutputStart"] = 6] = "OutputStart";
+  ProfilerEvent2[ProfilerEvent2["OutputEnd"] = 7] = "OutputEnd";
+  ProfilerEvent2[ProfilerEvent2["BootstrapApplicationStart"] = 8] = "BootstrapApplicationStart";
+  ProfilerEvent2[ProfilerEvent2["BootstrapApplicationEnd"] = 9] = "BootstrapApplicationEnd";
+  ProfilerEvent2[ProfilerEvent2["BootstrapComponentStart"] = 10] = "BootstrapComponentStart";
+  ProfilerEvent2[ProfilerEvent2["BootstrapComponentEnd"] = 11] = "BootstrapComponentEnd";
+  ProfilerEvent2[ProfilerEvent2["ChangeDetectionStart"] = 12] = "ChangeDetectionStart";
+  ProfilerEvent2[ProfilerEvent2["ChangeDetectionEnd"] = 13] = "ChangeDetectionEnd";
+  ProfilerEvent2[ProfilerEvent2["ChangeDetectionSyncStart"] = 14] = "ChangeDetectionSyncStart";
+  ProfilerEvent2[ProfilerEvent2["ChangeDetectionSyncEnd"] = 15] = "ChangeDetectionSyncEnd";
+  ProfilerEvent2[ProfilerEvent2["AfterRenderHooksStart"] = 16] = "AfterRenderHooksStart";
+  ProfilerEvent2[ProfilerEvent2["AfterRenderHooksEnd"] = 17] = "AfterRenderHooksEnd";
+  ProfilerEvent2[ProfilerEvent2["ComponentStart"] = 18] = "ComponentStart";
+  ProfilerEvent2[ProfilerEvent2["ComponentEnd"] = 19] = "ComponentEnd";
+  ProfilerEvent2[ProfilerEvent2["DeferBlockStateStart"] = 20] = "DeferBlockStateStart";
+  ProfilerEvent2[ProfilerEvent2["DeferBlockStateEnd"] = 21] = "DeferBlockStateEnd";
+  ProfilerEvent2[ProfilerEvent2["DynamicComponentStart"] = 22] = "DynamicComponentStart";
+  ProfilerEvent2[ProfilerEvent2["DynamicComponentEnd"] = 23] = "DynamicComponentEnd";
+  ProfilerEvent2[ProfilerEvent2["HostBindingsUpdateStart"] = 24] = "HostBindingsUpdateStart";
+  ProfilerEvent2[ProfilerEvent2["HostBindingsUpdateEnd"] = 25] = "HostBindingsUpdateEnd";
+})(ProfilerEvent || (ProfilerEvent = {}));
+function registerPreOrderHooks(directiveIndex, directiveDef, tView) {
+  ngDevMode && assertFirstCreatePass(tView);
+  const {
+    ngOnChanges,
+    ngOnInit,
+    ngDoCheck
+  } = directiveDef.type.prototype;
+  if (ngOnChanges) {
+    const wrappedOnChanges = NgOnChangesFeatureImpl(directiveDef);
+    (tView.preOrderHooks ??= []).push(directiveIndex, wrappedOnChanges);
+    (tView.preOrderCheckHooks ??= []).push(directiveIndex, wrappedOnChanges);
+  }
+  if (ngOnInit) {
+    (tView.preOrderHooks ??= []).push(0 - directiveIndex, ngOnInit);
+  }
+  if (ngDoCheck) {
+    (tView.preOrderHooks ??= []).push(directiveIndex, ngDoCheck);
+    (tView.preOrderCheckHooks ??= []).push(directiveIndex, ngDoCheck);
+  }
+}
+function registerPostOrderHooks(tView, tNode) {
+  ngDevMode && assertFirstCreatePass(tView);
+  for (let i = tNode.directiveStart, end = tNode.directiveEnd; i < end; i++) {
+    const directiveDef = tView.data[i];
+    ngDevMode && assertDefined(directiveDef, "Expecting DirectiveDef");
+    const lifecycleHooks = directiveDef.type.prototype;
+    const {
+      ngAfterContentInit,
+      ngAfterContentChecked,
+      ngAfterViewInit,
+      ngAfterViewChecked,
+      ngOnDestroy
+    } = lifecycleHooks;
+    if (ngAfterContentInit) {
+      (tView.contentHooks ??= []).push(-i, ngAfterContentInit);
+    }
+    if (ngAfterContentChecked) {
+      (tView.contentHooks ??= []).push(i, ngAfterContentChecked);
+      (tView.contentCheckHooks ??= []).push(i, ngAfterContentChecked);
+    }
+    if (ngAfterViewInit) {
+      (tView.viewHooks ??= []).push(-i, ngAfterViewInit);
+    }
+    if (ngAfterViewChecked) {
+      (tView.viewHooks ??= []).push(i, ngAfterViewChecked);
+      (tView.viewCheckHooks ??= []).push(i, ngAfterViewChecked);
+    }
+    if (ngOnDestroy != null) {
+      (tView.destroyHooks ??= []).push(i, ngOnDestroy);
+    }
+  }
+}
+function executeCheckHooks(lView, hooks, nodeIndex) {
+  callHooks(lView, hooks, 3, nodeIndex);
+}
+function executeInitAndCheckHooks(lView, hooks, initPhase, nodeIndex) {
+  ngDevMode && assertNotEqual(initPhase, 3, "Init pre-order hooks should not be called more than once");
+  if ((lView[FLAGS] & 3) === initPhase) {
+    callHooks(lView, hooks, initPhase, nodeIndex);
+  }
+}
+function incrementInitPhaseFlags(lView, initPhase) {
+  ngDevMode && assertNotEqual(initPhase, 3, "Init hooks phase should not be incremented after all init hooks have been run.");
+  let flags = lView[FLAGS];
+  if ((flags & 3) === initPhase) {
+    flags &= 16383;
+    flags += 1;
+    lView[FLAGS] = flags;
+  }
+}
+function callHooks(currentView, arr, initPhase, currentNodeIndex) {
+  ngDevMode && assertEqual(isInCheckNoChangesMode(), false, "Hooks should never be run when in check no changes mode.");
+  const startIndex = currentNodeIndex !== void 0 ? currentView[PREORDER_HOOK_FLAGS] & 65535 : 0;
+  const nodeIndexLimit = currentNodeIndex != null ? currentNodeIndex : -1;
+  const max = arr.length - 1;
+  let lastNodeIndexFound = 0;
+  for (let i = startIndex; i < max; i++) {
+    const hook = arr[i + 1];
+    if (typeof hook === "number") {
+      lastNodeIndexFound = arr[i];
+      if (currentNodeIndex != null && lastNodeIndexFound >= currentNodeIndex) {
+        break;
+      }
+    } else {
+      const isInitHook = arr[i] < 0;
+      if (isInitHook) {
+        currentView[PREORDER_HOOK_FLAGS] += 65536;
+      }
+      if (lastNodeIndexFound < nodeIndexLimit || nodeIndexLimit == -1) {
+        callHook(currentView, initPhase, arr, i);
+        currentView[PREORDER_HOOK_FLAGS] = (currentView[PREORDER_HOOK_FLAGS] & 4294901760) + i + 2;
+      }
+      i++;
+    }
+  }
+}
+function callHookInternal(directive, hook) {
+  profiler(ProfilerEvent.LifecycleHookStart, directive, hook);
+  const prevConsumer = setActiveConsumer(null);
+  try {
+    hook.call(directive);
+  } finally {
+    setActiveConsumer(prevConsumer);
+    profiler(ProfilerEvent.LifecycleHookEnd, directive, hook);
+  }
+}
+function callHook(currentView, initPhase, arr, i) {
+  const isInitHook = arr[i] < 0;
+  const hook = arr[i + 1];
+  const directiveIndex = isInitHook ? -arr[i] : arr[i];
+  const directive = currentView[directiveIndex];
+  if (isInitHook) {
+    const indexWithintInitPhase = currentView[FLAGS] >> 14;
+    if (indexWithintInitPhase < currentView[PREORDER_HOOK_FLAGS] >> 16 && (currentView[FLAGS] & 3) === initPhase) {
+      currentView[FLAGS] += 16384;
+      callHookInternal(directive, hook);
+    }
+  } else {
+    callHookInternal(directive, hook);
+  }
+}
+var NO_PARENT_INJECTOR = -1;
+var NodeInjectorFactory = class {
+  factory;
+  name;
+  injectImpl;
+  resolving = false;
+  canSeeViewProviders;
+  multi;
+  componentProviders;
+  index;
+  providerFactory;
+  constructor(factory, isViewProvider, injectImplementation, name) {
+    this.factory = factory;
+    this.name = name;
+    ngDevMode && assertDefined(factory, "Factory not specified");
+    ngDevMode && assertEqual(typeof factory, "function", "Expected factory function.");
+    this.canSeeViewProviders = isViewProvider;
+    this.injectImpl = injectImplementation;
+  }
+};
+function toTNodeTypeAsString(tNodeType) {
+  let text = "";
+  tNodeType & 1 && (text += "|Text");
+  tNodeType & 2 && (text += "|Element");
+  tNodeType & 4 && (text += "|Container");
+  tNodeType & 8 && (text += "|ElementContainer");
+  tNodeType & 16 && (text += "|Projection");
+  tNodeType & 32 && (text += "|IcuContainer");
+  tNodeType & 64 && (text += "|Placeholder");
+  tNodeType & 128 && (text += "|LetDeclaration");
+  return text.length > 0 ? text.substring(1) : text;
+}
+function isTNodeShape(value) {
+  return value != null && typeof value === "object" && (value.insertBeforeIndex === null || typeof value.insertBeforeIndex === "number" || Array.isArray(value.insertBeforeIndex));
+}
+function hasClassInput(tNode) {
+  return (tNode.flags & 8) !== 0;
+}
+function hasStyleInput(tNode) {
+  return (tNode.flags & 16) !== 0;
+}
+function assertTNodeType(tNode, expectedTypes, message) {
+  assertDefined(tNode, "should be called with a TNode");
+  if ((tNode.type & expectedTypes) === 0) {
+    throwError2(message || `Expected [${toTNodeTypeAsString(expectedTypes)}] but got ${toTNodeTypeAsString(tNode.type)}.`);
+  }
+}
+function assertPureTNodeType(type) {
+  if (!(type === 2 || type === 1 || type === 4 || type === 8 || type === 32 || type === 16 || type === 64 || type === 128)) {
+    throwError2(`Expected TNodeType to have only a single type selected, but got ${toTNodeTypeAsString(type)}.`);
+  }
+}
+function setUpAttributes(renderer, native, attrs) {
+  let i = 0;
+  while (i < attrs.length) {
+    const value = attrs[i];
+    if (typeof value === "number") {
+      if (value !== 0) {
+        break;
+      }
+      i++;
+      const namespaceURI = attrs[i++];
+      const attrName = attrs[i++];
+      const attrVal = attrs[i++];
+      renderer.setAttribute(native, attrName, attrVal, namespaceURI);
+    } else {
+      const attrName = value;
+      const attrVal = attrs[++i];
+      if (isAnimationProp(attrName)) {
+        renderer.setProperty(native, attrName, attrVal);
+      } else {
+        renderer.setAttribute(native, attrName, attrVal);
+      }
+      i++;
+    }
+  }
+  return i;
+}
+function isNameOnlyAttributeMarker(marker) {
+  return marker === 3 || marker === 4 || marker === 6;
+}
+function isAnimationProp(name) {
+  return name.charCodeAt(0) === 64;
+}
+function mergeHostAttrs(dst, src) {
+  if (src === null || src.length === 0) ;
+  else if (dst === null || dst.length === 0) {
+    dst = src.slice();
+  } else {
+    let srcMarker = -1;
+    for (let i = 0; i < src.length; i++) {
+      const item = src[i];
+      if (typeof item === "number") {
+        srcMarker = item;
+      } else {
+        if (srcMarker === 0) ;
+        else if (srcMarker === -1 || srcMarker === 2) {
+          mergeHostAttribute(dst, srcMarker, item, null, src[++i]);
+        } else {
+          mergeHostAttribute(dst, srcMarker, item, null, null);
+        }
+      }
+    }
+  }
+  return dst;
+}
+function mergeHostAttribute(dst, marker, key1, key2, value) {
+  let i = 0;
+  let markerInsertPosition = dst.length;
+  if (marker === -1) {
+    markerInsertPosition = -1;
+  } else {
+    while (i < dst.length) {
+      const dstValue = dst[i++];
+      if (typeof dstValue === "number") {
+        if (dstValue === marker) {
+          markerInsertPosition = -1;
+          break;
+        } else if (dstValue > marker) {
+          markerInsertPosition = i - 1;
+          break;
+        }
+      }
+    }
+  }
+  while (i < dst.length) {
+    const item = dst[i];
+    if (typeof item === "number") {
+      break;
+    } else if (item === key1) {
+      {
+        if (value !== null) {
+          dst[i + 1] = value;
+        }
+        return;
+      }
+    }
+    i++;
+    if (value !== null) i++;
+  }
+  if (markerInsertPosition !== -1) {
+    dst.splice(markerInsertPosition, 0, marker);
+    i = markerInsertPosition + 1;
+  }
+  dst.splice(i++, 0, key1);
+  if (value !== null) {
+    dst.splice(i++, 0, value);
+  }
+}
+function hasParentInjector(parentLocation) {
+  return parentLocation !== NO_PARENT_INJECTOR;
+}
+function getParentInjectorIndex(parentLocation) {
+  if (ngDevMode) {
+    assertNumber(parentLocation, "Number expected");
+    assertNotEqual(parentLocation, -1, "Not a valid state.");
+    const parentInjectorIndex = parentLocation & 32767;
+    assertGreaterThan(parentInjectorIndex, HEADER_OFFSET, "Parent injector must be pointing past HEADER_OFFSET.");
+  }
+  return parentLocation & 32767;
+}
+function getParentInjectorViewOffset(parentLocation) {
+  return parentLocation >> 16;
+}
+function getParentInjectorView(location2, startView) {
+  let viewOffset = getParentInjectorViewOffset(location2);
+  let parentView = startView;
+  while (viewOffset > 0) {
+    parentView = parentView[DECLARATION_VIEW];
+    viewOffset--;
+  }
+  return parentView;
+}
+var includeViewProviders = true;
+function setIncludeViewProviders(v) {
+  const oldValue = includeViewProviders;
+  includeViewProviders = v;
+  return oldValue;
+}
+var BLOOM_SIZE = 256;
+var BLOOM_MASK = BLOOM_SIZE - 1;
+var BLOOM_BUCKET_BITS = 5;
+var nextNgElementId = 0;
+var NOT_FOUND2 = {};
+function bloomAdd(injectorIndex, tView, type) {
+  ngDevMode && assertEqual(tView.firstCreatePass, true, "expected firstCreatePass to be true");
+  let id;
+  if (typeof type === "string") {
+    id = type.charCodeAt(0) || 0;
+  } else if (type.hasOwnProperty(NG_ELEMENT_ID)) {
+    id = type[NG_ELEMENT_ID];
+  }
+  if (id == null) {
+    id = type[NG_ELEMENT_ID] = nextNgElementId++;
+  }
+  const bloomHash = id & BLOOM_MASK;
+  const mask = 1 << bloomHash;
+  tView.data[injectorIndex + (bloomHash >> BLOOM_BUCKET_BITS)] |= mask;
+}
+function getOrCreateNodeInjectorForNode(tNode, lView) {
+  const existingInjectorIndex = getInjectorIndex(tNode, lView);
+  if (existingInjectorIndex !== -1) {
+    return existingInjectorIndex;
+  }
+  const tView = lView[TVIEW];
+  if (tView.firstCreatePass) {
+    tNode.injectorIndex = lView.length;
+    insertBloom(tView.data, tNode);
+    insertBloom(lView, null);
+    insertBloom(tView.blueprint, null);
+  }
+  const parentLoc = getParentInjectorLocation(tNode, lView);
+  const injectorIndex = tNode.injectorIndex;
+  if (hasParentInjector(parentLoc)) {
+    const parentIndex = getParentInjectorIndex(parentLoc);
+    const parentLView = getParentInjectorView(parentLoc, lView);
+    const parentData = parentLView[TVIEW].data;
+    for (let i = 0; i < 8; i++) {
+      lView[injectorIndex + i] = parentLView[parentIndex + i] | parentData[parentIndex + i];
+    }
+  }
+  lView[injectorIndex + 8] = parentLoc;
+  return injectorIndex;
+}
+function insertBloom(arr, footer) {
+  arr.push(0, 0, 0, 0, 0, 0, 0, 0, footer);
+}
+function getInjectorIndex(tNode, lView) {
+  if (tNode.injectorIndex === -1 || tNode.parent && tNode.parent.injectorIndex === tNode.injectorIndex || lView[tNode.injectorIndex + 8] === null) {
+    return -1;
+  } else {
+    ngDevMode && assertIndexInRange(lView, tNode.injectorIndex);
+    return tNode.injectorIndex;
+  }
+}
+function getParentInjectorLocation(tNode, lView) {
+  if (tNode.parent && tNode.parent.injectorIndex !== -1) {
+    return tNode.parent.injectorIndex;
+  }
+  let declarationViewOffset = 0;
+  let parentTNode = null;
+  let lViewCursor = lView;
+  while (lViewCursor !== null) {
+    parentTNode = getTNodeFromLView(lViewCursor);
+    if (parentTNode === null) {
+      return NO_PARENT_INJECTOR;
+    }
+    ngDevMode && parentTNode && assertTNodeForLView(parentTNode, lViewCursor[DECLARATION_VIEW]);
+    declarationViewOffset++;
+    lViewCursor = lViewCursor[DECLARATION_VIEW];
+    if (parentTNode.injectorIndex !== -1) {
+      return parentTNode.injectorIndex | declarationViewOffset << 16;
+    }
+  }
+  return NO_PARENT_INJECTOR;
+}
+function diPublicInInjector(injectorIndex, tView, token) {
+  bloomAdd(injectorIndex, tView, token);
+}
+function injectAttributeImpl(tNode, attrNameToInject) {
+  ngDevMode && assertTNodeType(tNode, 12 | 3);
+  ngDevMode && assertDefined(tNode, "expecting tNode");
+  if (attrNameToInject === "class") {
+    return tNode.classes;
+  }
+  if (attrNameToInject === "style") {
+    return tNode.styles;
+  }
+  const attrs = tNode.attrs;
+  if (attrs) {
+    const attrsLength = attrs.length;
+    let i = 0;
+    while (i < attrsLength) {
+      const value = attrs[i];
+      if (isNameOnlyAttributeMarker(value)) break;
+      if (value === 0) {
+        i = i + 2;
+      } else if (typeof value === "number") {
+        i++;
+        while (i < attrsLength && typeof attrs[i] === "string") {
+          i++;
+        }
+      } else if (value === attrNameToInject) {
+        return attrs[i + 1];
+      } else {
+        i = i + 2;
+      }
+    }
+  }
+  return null;
+}
+function notFoundValueOrThrow(notFoundValue, token, flags) {
+  if (flags & 8 || notFoundValue !== void 0) {
+    return notFoundValue;
+  } else {
+    throwProviderNotFoundError(token, "NodeInjector");
+  }
+}
+function lookupTokenUsingModuleInjector(lView, token, flags, notFoundValue) {
+  if (flags & 8 && notFoundValue === void 0) {
+    notFoundValue = null;
+  }
+  if ((flags & (2 | 1)) === 0) {
+    const moduleInjector = lView[INJECTOR];
+    const previousInjectImplementation = setInjectImplementation(void 0);
+    try {
+      if (moduleInjector) {
+        return moduleInjector.get(token, notFoundValue, flags & 8);
+      } else {
+        return injectRootLimpMode(token, notFoundValue, flags & 8);
+      }
+    } finally {
+      setInjectImplementation(previousInjectImplementation);
+    }
+  }
+  return notFoundValueOrThrow(notFoundValue, token, flags);
+}
+function getOrCreateInjectable(tNode, lView, token, flags = 0, notFoundValue) {
+  if (tNode !== null) {
+    if (lView[FLAGS] & 2048 && !(flags & 2)) {
+      const embeddedInjectorValue = lookupTokenUsingEmbeddedInjector(tNode, lView, token, flags, NOT_FOUND2);
+      if (embeddedInjectorValue !== NOT_FOUND2) {
+        return embeddedInjectorValue;
+      }
+    }
+    const value = lookupTokenUsingNodeInjector(tNode, lView, token, flags, NOT_FOUND2);
+    if (value !== NOT_FOUND2) {
+      return value;
+    }
+  }
+  return lookupTokenUsingModuleInjector(lView, token, flags, notFoundValue);
+}
+function lookupTokenUsingNodeInjector(tNode, lView, token, flags, notFoundValue) {
+  const bloomHash = bloomHashBitOrFactory(token);
+  if (typeof bloomHash === "function") {
+    if (!enterDI(lView, tNode, flags)) {
+      return flags & 1 ? notFoundValueOrThrow(notFoundValue, token, flags) : lookupTokenUsingModuleInjector(lView, token, flags, notFoundValue);
+    }
+    try {
+      let value;
+      if (ngDevMode) {
+        runInInjectorProfilerContext(new NodeInjector(getCurrentTNode(), getLView()), token, () => {
+          emitInjectorToCreateInstanceEvent(token);
+          value = bloomHash(flags);
+          emitInstanceCreatedByInjectorEvent(value);
+        });
+      } else {
+        value = bloomHash(flags);
+      }
+      if (value == null && !(flags & 8)) {
+        throwProviderNotFoundError(token);
+      } else {
+        return value;
+      }
+    } finally {
+      leaveDI();
+    }
+  } else if (typeof bloomHash === "number") {
+    let previousTView = null;
+    let injectorIndex = getInjectorIndex(tNode, lView);
+    let parentLocation = NO_PARENT_INJECTOR;
+    let hostTElementNode = flags & 1 ? lView[DECLARATION_COMPONENT_VIEW][T_HOST] : null;
+    if (injectorIndex === -1 || flags & 4) {
+      parentLocation = injectorIndex === -1 ? getParentInjectorLocation(tNode, lView) : lView[injectorIndex + 8];
+      if (parentLocation === NO_PARENT_INJECTOR || !shouldSearchParent(flags, false)) {
+        injectorIndex = -1;
+      } else {
+        previousTView = lView[TVIEW];
+        injectorIndex = getParentInjectorIndex(parentLocation);
+        lView = getParentInjectorView(parentLocation, lView);
+      }
+    }
+    while (injectorIndex !== -1) {
+      ngDevMode && assertNodeInjector(lView, injectorIndex);
+      const tView = lView[TVIEW];
+      ngDevMode && assertTNodeForLView(tView.data[injectorIndex + 8], lView);
+      if (bloomHasToken(bloomHash, injectorIndex, tView.data)) {
+        const instance = searchTokensOnInjector(injectorIndex, lView, token, previousTView, flags, hostTElementNode);
+        if (instance !== NOT_FOUND2) {
+          return instance;
+        }
+      }
+      parentLocation = lView[injectorIndex + 8];
+      if (parentLocation !== NO_PARENT_INJECTOR && shouldSearchParent(flags, lView[TVIEW].data[injectorIndex + 8] === hostTElementNode) && bloomHasToken(bloomHash, injectorIndex, lView)) {
+        previousTView = tView;
+        injectorIndex = getParentInjectorIndex(parentLocation);
+        lView = getParentInjectorView(parentLocation, lView);
+      } else {
+        injectorIndex = -1;
+      }
+    }
+  }
+  return notFoundValue;
+}
+function searchTokensOnInjector(injectorIndex, lView, token, previousTView, flags, hostTElementNode) {
+  const currentTView = lView[TVIEW];
+  const tNode = currentTView.data[injectorIndex + 8];
+  const canAccessViewProviders = previousTView == null ? isComponentHost(tNode) && includeViewProviders : previousTView != currentTView && (tNode.type & 3) !== 0;
+  const isHostSpecialCase = flags & 1 && hostTElementNode === tNode;
+  const injectableIdx = locateDirectiveOrProvider(tNode, currentTView, token, canAccessViewProviders, isHostSpecialCase);
+  if (injectableIdx !== null) {
+    return getNodeInjectable(lView, currentTView, injectableIdx, tNode, flags);
+  } else {
+    return NOT_FOUND2;
+  }
+}
+function locateDirectiveOrProvider(tNode, tView, token, canAccessViewProviders, isHostSpecialCase) {
+  const nodeProviderIndexes = tNode.providerIndexes;
+  const tInjectables = tView.data;
+  const injectablesStart = nodeProviderIndexes & 1048575;
+  const directivesStart = tNode.directiveStart;
+  const directiveEnd = tNode.directiveEnd;
+  const cptViewProvidersCount = nodeProviderIndexes >> 20;
+  const startingIndex = canAccessViewProviders ? injectablesStart : injectablesStart + cptViewProvidersCount;
+  const endIndex = isHostSpecialCase ? injectablesStart + cptViewProvidersCount : directiveEnd;
+  for (let i = startingIndex; i < endIndex; i++) {
+    const providerTokenOrDef = tInjectables[i];
+    if (i < directivesStart && token === providerTokenOrDef || i >= directivesStart && providerTokenOrDef.type === token) {
+      return i;
+    }
+  }
+  if (isHostSpecialCase) {
+    const dirDef = tInjectables[directivesStart];
+    if (dirDef && isComponentDef(dirDef) && dirDef.type === token) {
+      return directivesStart;
+    }
+  }
+  return null;
+}
+var injectionPath = [];
+function getNodeInjectable(lView, tView, index, tNode, flags) {
+  let value = lView[index];
+  const tData = tView.data;
+  if (value instanceof NodeInjectorFactory) {
+    const factory = value;
+    ngDevMode && injectionPath.push(factory.name ?? "unknown");
+    if (factory.resolving) {
+      let token2 = "";
+      if (ngDevMode) {
+        token2 = stringifyForError(tData[index]);
+        throw cyclicDependencyErrorWithDetails(token2, injectionPath);
+      } else {
+        throw cyclicDependencyError(token2);
+      }
+    }
+    const previousIncludeViewProviders = setIncludeViewProviders(factory.canSeeViewProviders);
+    factory.resolving = true;
+    const token = tData[index].type || tData[index];
+    let prevInjectContext;
+    if (ngDevMode) {
+      const injector = new NodeInjector(tNode, lView);
+      prevInjectContext = setInjectorProfilerContext({
+        injector,
+        token
+      });
+    }
+    const previousInjectImplementation = factory.injectImpl ? setInjectImplementation(factory.injectImpl) : null;
+    const success = enterDI(lView, tNode, 0);
+    ngDevMode && assertEqual(success, true, "Because flags do not contain `SkipSelf' we expect this to always succeed.");
+    try {
+      ngDevMode && emitInjectorToCreateInstanceEvent(token);
+      value = lView[index] = factory.factory(void 0, flags, tData, lView, tNode);
+      ngDevMode && emitInstanceCreatedByInjectorEvent(value);
+      if (tView.firstCreatePass && index >= tNode.directiveStart) {
+        ngDevMode && assertDirectiveDef(tData[index]);
+        registerPreOrderHooks(index, tData[index], tView);
+      }
+    } finally {
+      ngDevMode && setInjectorProfilerContext(prevInjectContext);
+      previousInjectImplementation !== null && setInjectImplementation(previousInjectImplementation);
+      setIncludeViewProviders(previousIncludeViewProviders);
+      factory.resolving = false;
+      leaveDI();
+      ngDevMode && (injectionPath = []);
+    }
+  }
+  return value;
+}
+function bloomHashBitOrFactory(token) {
+  ngDevMode && assertDefined(token, "token must be defined");
+  if (typeof token === "string") {
+    return token.charCodeAt(0) || 0;
+  }
+  const tokenId = token.hasOwnProperty(NG_ELEMENT_ID) ? token[NG_ELEMENT_ID] : void 0;
+  if (typeof tokenId === "number") {
+    if (tokenId >= 0) {
+      return tokenId & BLOOM_MASK;
+    } else {
+      ngDevMode && assertEqual(tokenId, -1, "Expecting to get Special Injector Id");
+      return createNodeInjector;
+    }
+  } else {
+    return tokenId;
+  }
+}
+function bloomHasToken(bloomHash, injectorIndex, injectorView) {
+  const mask = 1 << bloomHash;
+  const value = injectorView[injectorIndex + (bloomHash >> BLOOM_BUCKET_BITS)];
+  return !!(value & mask);
+}
+function shouldSearchParent(flags, isFirstHostTNode) {
+  return !(flags & 2) && !(flags & 1 && isFirstHostTNode);
+}
+function getNodeInjectorLView(nodeInjector) {
+  return nodeInjector._lView;
+}
+function getNodeInjectorTNode(nodeInjector) {
+  return nodeInjector._tNode;
+}
+var NodeInjector = class {
+  _tNode;
+  _lView;
+  constructor(_tNode, _lView) {
+    this._tNode = _tNode;
+    this._lView = _lView;
+  }
+  get(token, notFoundValue, flags) {
+    return getOrCreateInjectable(this._tNode, this._lView, token, convertToBitFlags(flags), notFoundValue);
+  }
+};
+function createNodeInjector() {
+  return new NodeInjector(getCurrentTNode(), getLView());
+}
+function \u0275\u0275getInheritedFactory(type) {
+  return noSideEffects(() => {
+    const ownConstructor = type.prototype.constructor;
+    const ownFactory = ownConstructor[NG_FACTORY_DEF] || getFactoryOf(ownConstructor);
+    const objectPrototype = Object.prototype;
+    let parent = Object.getPrototypeOf(type.prototype).constructor;
+    while (parent && parent !== objectPrototype) {
+      const factory = parent[NG_FACTORY_DEF] || getFactoryOf(parent);
+      if (factory && factory !== ownFactory) {
+        return factory;
+      }
+      parent = Object.getPrototypeOf(parent);
+    }
+    return (t) => new t();
+  });
+}
+function getFactoryOf(type) {
+  if (isForwardRef(type)) {
+    return () => {
+      const factory = getFactoryOf(resolveForwardRef(type));
+      return factory && factory();
+    };
+  }
+  return getFactoryDef(type);
+}
+function lookupTokenUsingEmbeddedInjector(tNode, lView, token, flags, notFoundValue) {
+  let currentTNode = tNode;
+  let currentLView = lView;
+  while (currentTNode !== null && currentLView !== null && currentLView[FLAGS] & 2048 && !isRootView(currentLView)) {
+    ngDevMode && assertTNodeForLView(currentTNode, currentLView);
+    const nodeInjectorValue = lookupTokenUsingNodeInjector(currentTNode, currentLView, token, flags | 2, NOT_FOUND2);
+    if (nodeInjectorValue !== NOT_FOUND2) {
+      return nodeInjectorValue;
+    }
+    let parentTNode = currentTNode.parent;
+    if (!parentTNode) {
+      const embeddedViewInjector = currentLView[EMBEDDED_VIEW_INJECTOR];
+      if (embeddedViewInjector) {
+        const embeddedViewInjectorValue = embeddedViewInjector.get(token, NOT_FOUND2, flags & -5);
+        if (embeddedViewInjectorValue !== NOT_FOUND2) {
+          return embeddedViewInjectorValue;
+        }
+      }
+      parentTNode = getTNodeFromLView(currentLView);
+      currentLView = currentLView[DECLARATION_VIEW];
+    }
+    currentTNode = parentTNode;
+  }
+  return notFoundValue;
+}
+function getTNodeFromLView(lView) {
+  const tView = lView[TVIEW];
+  const tViewType = tView.type;
+  if (tViewType === 2) {
+    ngDevMode && assertDefined(tView.declTNode, "Embedded TNodes should have declaration parents.");
+    return tView.declTNode;
+  } else if (tViewType === 1) {
+    return lView[T_HOST];
+  }
+  return null;
+}
+function \u0275\u0275injectAttribute(attrNameToInject) {
+  return injectAttributeImpl(getCurrentTNode(), attrNameToInject);
+}
+var Attribute = makeParamDecorator("Attribute", (attributeName) => ({
+  attributeName,
+  __NG_ELEMENT_ID__: () => \u0275\u0275injectAttribute(attributeName)
+}));
+var _reflect = null;
+function getReflect() {
+  return _reflect = _reflect || new ReflectionCapabilities();
+}
+function reflectDependencies(type) {
+  return convertDependencies(getReflect().parameters(type));
+}
+function convertDependencies(deps) {
+  return deps.map((dep) => reflectDependency(dep));
+}
+function reflectDependency(dep) {
+  const meta = {
+    token: null,
+    attribute: null,
+    host: false,
+    optional: false,
+    self: false,
+    skipSelf: false
+  };
+  if (Array.isArray(dep) && dep.length > 0) {
+    for (let j = 0; j < dep.length; j++) {
+      const param = dep[j];
+      if (param === void 0) {
+        continue;
+      }
+      const proto = Object.getPrototypeOf(param);
+      if (param instanceof Optional || proto.ngMetadataName === "Optional") {
+        meta.optional = true;
+      } else if (param instanceof SkipSelf || proto.ngMetadataName === "SkipSelf") {
+        meta.skipSelf = true;
+      } else if (param instanceof Self || proto.ngMetadataName === "Self") {
+        meta.self = true;
+      } else if (param instanceof Host || proto.ngMetadataName === "Host") {
+        meta.host = true;
+      } else if (param instanceof Inject) {
+        meta.token = param.token;
+      } else if (param instanceof Attribute) {
+        if (param.attributeName === void 0) {
+          throw new RuntimeError(-204, ngDevMode && `Attribute name must be defined.`);
+        }
+        meta.attribute = param.attributeName;
+      } else {
+        meta.token = param;
+      }
+    }
+  } else if (dep === void 0 || Array.isArray(dep) && dep.length === 0) {
+    meta.token = null;
+  } else {
+    meta.token = dep;
+  }
+  return meta;
+}
+function compileInjectable(type, meta) {
+  let ngInjectableDef = null;
+  let ngFactoryDef = null;
+  if (!type.hasOwnProperty(NG_PROV_DEF)) {
+    Object.defineProperty(type, NG_PROV_DEF, {
+      get: () => {
+        if (ngInjectableDef === null) {
+          const compiler = getCompilerFacade({
+            usage: 0,
+            kind: "injectable",
+            type
+          });
+          ngInjectableDef = compiler.compileInjectable(angularCoreDiEnv, `ng:///${type.name}/\u0275prov.js`, getInjectableMetadata(type, meta));
+        }
+        return ngInjectableDef;
+      }
+    });
+  }
+  if (!type.hasOwnProperty(NG_FACTORY_DEF)) {
+    Object.defineProperty(type, NG_FACTORY_DEF, {
+      get: () => {
+        if (ngFactoryDef === null) {
+          const compiler = getCompilerFacade({
+            usage: 0,
+            kind: "injectable",
+            type
+          });
+          ngFactoryDef = compiler.compileFactory(angularCoreDiEnv, `ng:///${type.name}/\u0275fac.js`, {
+            name: type.name,
+            type,
+            typeArgumentCount: 0,
+            deps: reflectDependencies(type),
+            target: compiler.FactoryTarget.Injectable
+          });
+        }
+        return ngFactoryDef;
+      },
+      configurable: true
+    });
+  }
+}
+var USE_VALUE2 = getClosureSafeProperty({
+  provide: String,
+  useValue: getClosureSafeProperty
+});
+function isUseClassProvider(meta) {
+  return meta.useClass !== void 0;
+}
+function isUseValueProvider(meta) {
+  return USE_VALUE2 in meta;
+}
+function isUseFactoryProvider(meta) {
+  return meta.useFactory !== void 0;
+}
+function isUseExistingProvider(meta) {
+  return meta.useExisting !== void 0;
+}
+function getInjectableMetadata(type, srcMeta) {
+  const meta = srcMeta || {
+    providedIn: null
+  };
+  const compilerMeta = {
+    name: type.name,
+    type,
+    typeArgumentCount: 0,
+    providedIn: meta.providedIn
+  };
+  if ((isUseClassProvider(meta) || isUseFactoryProvider(meta)) && meta.deps !== void 0) {
+    compilerMeta.deps = convertDependencies(meta.deps);
+  }
+  if (isUseClassProvider(meta)) {
+    compilerMeta.useClass = meta.useClass;
+  } else if (isUseValueProvider(meta)) {
+    compilerMeta.useValue = meta.useValue;
+  } else if (isUseFactoryProvider(meta)) {
+    compilerMeta.useFactory = meta.useFactory;
+  } else if (isUseExistingProvider(meta)) {
+    compilerMeta.useExisting = meta.useExisting;
+  }
+  return compilerMeta;
+}
+var Injectable = makeDecorator("Injectable", void 0, void 0, void 0, (type, meta) => compileInjectable(type, meta));
+function injectElementRef() {
+  return createElementRef(getCurrentTNode(), getLView());
+}
+function createElementRef(tNode, lView) {
+  return new ElementRef(getNativeByTNode(tNode, lView));
+}
+var ElementRef = class {
+  nativeElement;
+  constructor(nativeElement) {
+    this.nativeElement = nativeElement;
+  }
+  static __NG_ELEMENT_ID__ = injectElementRef;
+};
+function unwrapElementRef(value) {
+  return value instanceof ElementRef ? value.nativeElement : value;
+}
+function symbolIterator() {
+  return this._results[Symbol.iterator]();
+}
+var QueryList = class {
+  _emitDistinctChangesOnly;
+  dirty = true;
+  _onDirty = void 0;
+  _results = [];
+  _changesDetected = false;
+  _changes = void 0;
+  length = 0;
+  first = void 0;
+  last = void 0;
+  get changes() {
+    return this._changes ??= new Subject();
+  }
+  constructor(_emitDistinctChangesOnly = false) {
+    this._emitDistinctChangesOnly = _emitDistinctChangesOnly;
+  }
+  get(index) {
+    return this._results[index];
+  }
+  map(fn) {
+    return this._results.map(fn);
+  }
+  filter(fn) {
+    return this._results.filter(fn);
+  }
+  find(fn) {
+    return this._results.find(fn);
+  }
+  reduce(fn, init) {
+    return this._results.reduce(fn, init);
+  }
+  forEach(fn) {
+    this._results.forEach(fn);
+  }
+  some(fn) {
+    return this._results.some(fn);
+  }
+  toArray() {
+    return this._results.slice();
+  }
+  toString() {
+    return this._results.toString();
+  }
+  reset(resultsTree, identityAccessor) {
+    this.dirty = false;
+    const newResultFlat = flatten(resultsTree);
+    if (this._changesDetected = !arrayEquals(this._results, newResultFlat, identityAccessor)) {
+      this._results = newResultFlat;
+      this.length = newResultFlat.length;
+      this.last = newResultFlat[this.length - 1];
+      this.first = newResultFlat[0];
+    }
+  }
+  notifyOnChanges() {
+    if (this._changes !== void 0 && (this._changesDetected || !this._emitDistinctChangesOnly)) this._changes.next(this);
+  }
+  onDirty(cb) {
+    this._onDirty = cb;
+  }
+  setDirty() {
+    this.dirty = true;
+    this._onDirty?.();
+  }
+  destroy() {
+    if (this._changes !== void 0) {
+      this._changes.complete();
+      this._changes.unsubscribe();
+    }
+  }
+  [Symbol.iterator] = /* @__PURE__ */ (() => symbolIterator)();
+};
+function hasInSkipHydrationBlockFlag(tNode) {
+  return (tNode.flags & 128) === 128;
+}
+var ChangeDetectionStrategy;
+(function(ChangeDetectionStrategy2) {
+  ChangeDetectionStrategy2[ChangeDetectionStrategy2["OnPush"] = 0] = "OnPush";
+  ChangeDetectionStrategy2[ChangeDetectionStrategy2["Eager"] = 1] = "Eager";
+  ChangeDetectionStrategy2[ChangeDetectionStrategy2["Default"] = 1] = "Default";
+})(ChangeDetectionStrategy || (ChangeDetectionStrategy = {}));
+var TRACKED_LVIEWS = /* @__PURE__ */ new Map();
+var uniqueIdCounter = 0;
+function getUniqueLViewId() {
+  return uniqueIdCounter++;
+}
+function registerLView(lView) {
+  ngDevMode && assertNumber(lView[ID], "LView must have an ID in order to be registered");
+  TRACKED_LVIEWS.set(lView[ID], lView);
+}
+function getLViewById(id) {
+  ngDevMode && assertNumber(id, "ID used for LView lookup must be a number");
+  return TRACKED_LVIEWS.get(id) || null;
+}
+function unregisterLView(lView) {
+  ngDevMode && assertNumber(lView[ID], "Cannot stop tracking an LView that does not have an ID");
+  TRACKED_LVIEWS.delete(lView[ID]);
+}
+function getTrackedLViews() {
+  return TRACKED_LVIEWS;
+}
+var LContext = class {
+  lViewId;
+  nodeIndex;
+  native;
+  component;
+  directives;
+  localRefs;
+  get lView() {
+    return getLViewById(this.lViewId);
+  }
+  constructor(lViewId, nodeIndex, native) {
+    this.lViewId = lViewId;
+    this.nodeIndex = nodeIndex;
+    this.native = native;
+  }
+};
+function getLContext(target) {
+  let mpValue = readPatchedData(target);
+  if (mpValue) {
+    if (isLView(mpValue)) {
+      const lView = mpValue;
+      let nodeIndex;
+      let component = void 0;
+      let directives = void 0;
+      if (isComponentInstance(target)) {
+        nodeIndex = findViaComponent(lView, target);
+        if (nodeIndex == -1) {
+          throw new Error("The provided component was not found in the application");
+        }
+        component = target;
+      } else if (isDirectiveInstance(target)) {
+        nodeIndex = findViaDirective(lView, target);
+        if (nodeIndex == -1) {
+          throw new Error("The provided directive was not found in the application");
+        }
+        directives = getDirectivesAtNodeIndex(nodeIndex, lView);
+      } else {
+        nodeIndex = findViaNativeElement(lView, target);
+        if (nodeIndex == -1) {
+          return null;
+        }
+      }
+      const native = unwrapRNode(lView[nodeIndex]);
+      const existingCtx = readPatchedData(native);
+      const context2 = existingCtx && !Array.isArray(existingCtx) ? existingCtx : createLContext(lView, nodeIndex, native);
+      if (component && context2.component === void 0) {
+        context2.component = component;
+        attachPatchData(context2.component, context2);
+      }
+      if (directives && context2.directives === void 0) {
+        context2.directives = directives;
+        for (let i = 0; i < directives.length; i++) {
+          attachPatchData(directives[i], context2);
+        }
+      }
+      attachPatchData(context2.native, context2);
+      mpValue = context2;
+    }
+  } else {
+    const rElement = target;
+    ngDevMode && assertDomNode(rElement);
+    let parent = rElement;
+    while (parent = parent.parentNode) {
+      const parentContext = readPatchedData(parent);
+      if (parentContext) {
+        const lView = Array.isArray(parentContext) ? parentContext : parentContext.lView;
+        if (!lView) {
+          return null;
+        }
+        const index = findViaNativeElement(lView, rElement);
+        if (index >= 0) {
+          const native = unwrapRNode(lView[index]);
+          const context2 = createLContext(lView, index, native);
+          attachPatchData(native, context2);
+          mpValue = context2;
+          break;
+        }
+      }
+    }
+  }
+  return mpValue || null;
+}
+function createLContext(lView, nodeIndex, native) {
+  return new LContext(lView[ID], nodeIndex, native);
+}
+function getComponentViewByInstance(componentInstance) {
+  let patchedData = readPatchedData(componentInstance);
+  let lView;
+  if (isLView(patchedData)) {
+    const contextLView = patchedData;
+    const nodeIndex = findViaComponent(contextLView, componentInstance);
+    lView = getComponentLViewByIndex(nodeIndex, contextLView);
+    const context2 = createLContext(contextLView, nodeIndex, lView[HOST]);
+    context2.component = componentInstance;
+    attachPatchData(componentInstance, context2);
+    attachPatchData(context2.native, context2);
+  } else {
+    const context2 = patchedData;
+    const contextLView = context2.lView;
+    ngDevMode && assertLView(contextLView);
+    lView = getComponentLViewByIndex(context2.nodeIndex, contextLView);
+  }
+  return lView;
+}
+var MONKEY_PATCH_KEY_NAME = "__ngContext__";
+function attachPatchData(target, data) {
+  ngDevMode && assertDefined(target, "Target expected");
+  if (isLView(data)) {
+    target[MONKEY_PATCH_KEY_NAME] = data[ID];
+    registerLView(data);
+  } else {
+    target[MONKEY_PATCH_KEY_NAME] = data;
+  }
+}
+function readPatchedData(target) {
+  ngDevMode && assertDefined(target, "Target expected");
+  const data = target[MONKEY_PATCH_KEY_NAME];
+  return typeof data === "number" ? getLViewById(data) : data || null;
+}
+function readPatchedLView(target) {
+  const value = readPatchedData(target);
+  if (value) {
+    return isLView(value) ? value : value.lView;
+  }
+  return null;
+}
+function isComponentInstance(instance) {
+  return instance && instance.constructor && instance.constructor.\u0275cmp;
+}
+function isDirectiveInstance(instance) {
+  return instance && instance.constructor && instance.constructor.\u0275dir;
+}
+function findViaNativeElement(lView, target) {
+  const tView = lView[TVIEW];
+  for (let i = HEADER_OFFSET; i < tView.bindingStartIndex; i++) {
+    if (unwrapRNode(lView[i]) === target) {
+      return i;
+    }
+  }
+  return -1;
+}
+function traverseNextElement(tNode) {
+  if (tNode.child) {
+    return tNode.child;
+  } else if (tNode.next) {
+    return tNode.next;
+  } else {
+    while (tNode.parent && !tNode.parent.next) {
+      tNode = tNode.parent;
+    }
+    return tNode.parent && tNode.parent.next;
+  }
+}
+function findViaComponent(lView, componentInstance) {
+  const componentIndices = lView[TVIEW].components;
+  if (componentIndices) {
+    for (let i = 0; i < componentIndices.length; i++) {
+      const elementComponentIndex = componentIndices[i];
+      const componentView = getComponentLViewByIndex(elementComponentIndex, lView);
+      if (componentView[CONTEXT] === componentInstance) {
+        return elementComponentIndex;
+      }
+    }
+  } else {
+    const rootComponentView = getComponentLViewByIndex(HEADER_OFFSET, lView);
+    const rootComponent = rootComponentView[CONTEXT];
+    if (rootComponent === componentInstance) {
+      return HEADER_OFFSET;
+    }
+  }
+  return -1;
+}
+function findViaDirective(lView, directiveInstance) {
+  let tNode = lView[TVIEW].firstChild;
+  while (tNode) {
+    const directiveIndexStart = tNode.directiveStart;
+    const directiveIndexEnd = tNode.directiveEnd;
+    for (let i = directiveIndexStart; i < directiveIndexEnd; i++) {
+      if (lView[i] === directiveInstance) {
+        return tNode.index;
+      }
+    }
+    tNode = traverseNextElement(tNode);
+  }
+  return -1;
+}
+function getDirectivesAtNodeIndex(nodeIndex, lView) {
+  const tNode = lView[TVIEW].data[nodeIndex];
+  if (tNode.directiveStart === 0) return EMPTY_ARRAY;
+  const results = [];
+  for (let i = tNode.directiveStart; i < tNode.directiveEnd; i++) {
+    const directiveInstance = lView[i];
+    if (!isComponentInstance(directiveInstance)) {
+      results.push(directiveInstance);
+    }
+  }
+  return results;
+}
+function getComponentAtNodeIndex(nodeIndex, lView) {
+  const tNode = lView[TVIEW].data[nodeIndex];
+  return isComponentHost(tNode) ? lView[tNode.directiveStart + tNode.componentOffset] : null;
+}
+function getRootView(componentOrLView) {
+  ngDevMode && assertDefined(componentOrLView, "component");
+  let lView = isLView(componentOrLView) ? componentOrLView : readPatchedLView(componentOrLView);
+  while (lView && !isRootView(lView)) {
+    lView = getLViewParent(lView);
+  }
+  ngDevMode && assertLView(lView);
+  return lView;
+}
+function getRootContext(viewOrComponent) {
+  const rootView = getRootView(viewOrComponent);
+  ngDevMode && assertDefined(rootView[CONTEXT], "Root view has no context. Perhaps it is disconnected?");
+  return rootView[CONTEXT];
+}
+function getFirstLContainer(lView) {
+  return getNearestLContainer(lView[CHILD_HEAD]);
+}
+function getNextLContainer(container) {
+  return getNearestLContainer(container[NEXT]);
+}
+function getNearestLContainer(viewOrContainer) {
+  while (viewOrContainer !== null && !isLContainer(viewOrContainer)) {
+    viewOrContainer = viewOrContainer[NEXT];
+  }
+  return viewOrContainer;
+}
+function getComponent(element) {
+  ngDevMode && assertDomElement(element);
+  const context2 = getLContext(element);
+  if (context2 === null) return null;
+  if (context2.component === void 0) {
+    const lView = context2.lView;
+    if (lView === null) {
+      return null;
+    }
+    context2.component = getComponentAtNodeIndex(context2.nodeIndex, lView);
+  }
+  return context2.component;
+}
+function getContext(element) {
+  assertDomElement(element);
+  const context2 = getLContext(element);
+  const lView = context2 ? context2.lView : null;
+  return lView === null ? null : lView[CONTEXT];
+}
+function getOwningComponent(elementOrDir) {
+  const context2 = getLContext(elementOrDir);
+  let lView = context2 ? context2.lView : null;
+  if (lView === null) return null;
+  let parent;
+  while (lView[TVIEW].type === 2 && (parent = getLViewParent(lView))) {
+    lView = parent;
+  }
+  return isRootView(lView) ? null : lView[CONTEXT];
+}
+function getRootComponents(elementOrDir) {
+  const lView = readPatchedLView(elementOrDir);
+  return lView !== null ? [getRootContext(lView)] : [];
+}
+function getInjector(elementOrDir) {
+  const context2 = getLContext(elementOrDir);
+  const lView = context2 ? context2.lView : null;
+  if (lView === null) return Injector.NULL;
+  const tNode = lView[TVIEW].data[context2.nodeIndex];
+  return new NodeInjector(tNode, lView);
+}
+function getDirectives(node) {
+  if (node instanceof Text) {
+    return [];
+  }
+  const context2 = getLContext(node);
+  const lView = context2 ? context2.lView : null;
+  if (lView === null) {
+    return [];
+  }
+  const tView = lView[TVIEW];
+  const nodeIndex = context2.nodeIndex;
+  if (!tView?.data[nodeIndex]) {
+    return [];
+  }
+  if (context2.directives === void 0) {
+    context2.directives = getDirectivesAtNodeIndex(nodeIndex, lView);
+  }
+  return context2.directives === null ? [] : [...context2.directives];
+}
+var AcxChangeDetectionStrategy;
+(function(AcxChangeDetectionStrategy2) {
+  AcxChangeDetectionStrategy2[AcxChangeDetectionStrategy2["Default"] = 0] = "Default";
+  AcxChangeDetectionStrategy2[AcxChangeDetectionStrategy2["OnPush"] = 1] = "OnPush";
+})(AcxChangeDetectionStrategy || (AcxChangeDetectionStrategy = {}));
+var AcxViewEncapsulation;
+(function(AcxViewEncapsulation2) {
+  AcxViewEncapsulation2[AcxViewEncapsulation2["Emulated"] = 0] = "Emulated";
+  AcxViewEncapsulation2[AcxViewEncapsulation2["None"] = 1] = "None";
+})(AcxViewEncapsulation || (AcxViewEncapsulation = {}));
+function getDirectiveMetadata$1(directiveOrComponentInstance) {
+  const {
+    constructor
+  } = directiveOrComponentInstance;
+  if (!constructor) {
+    throw new Error("Unable to find the instance constructor");
+  }
+  const componentDef = getComponentDef(constructor);
+  if (componentDef) {
+    const inputs = extractInputDebugMetadata(componentDef.inputs);
+    return {
+      inputs,
+      outputs: componentDef.outputs,
+      encapsulation: componentDef.encapsulation,
+      changeDetection: componentDef.onPush ? ChangeDetectionStrategy.OnPush : ChangeDetectionStrategy.Eager
+    };
+  }
+  const directiveDef = getDirectiveDef(constructor);
+  if (directiveDef) {
+    const inputs = extractInputDebugMetadata(directiveDef.inputs);
+    return {
+      inputs,
+      outputs: directiveDef.outputs
+    };
+  }
+  return null;
+}
+function getHostElement(componentOrDirective) {
+  return getLContext(componentOrDirective).native;
+}
+function getListeners(element) {
+  ngDevMode && assertDomElement(element);
+  const lContext = getLContext(element);
+  const lView = lContext === null ? null : lContext.lView;
+  if (lView === null) return [];
+  const tView = lView[TVIEW];
+  const lCleanup = lView[CLEANUP];
+  const tCleanup = tView.cleanup;
+  const listeners = [];
+  if (tCleanup && lCleanup) {
+    for (let i = 0; i < tCleanup.length; ) {
+      const firstParam = tCleanup[i++];
+      const secondParam = tCleanup[i++];
+      if (typeof firstParam === "string") {
+        const name = firstParam;
+        const listenerElement = unwrapRNode(lView[secondParam]);
+        const callback = lCleanup[tCleanup[i++]];
+        const useCaptureOrIndx = tCleanup[i++];
+        const type = typeof useCaptureOrIndx === "boolean" || useCaptureOrIndx >= 0 ? "dom" : "output";
+        const useCapture = typeof useCaptureOrIndx === "boolean" ? useCaptureOrIndx : false;
+        if (element == listenerElement) {
+          listeners.push({
+            element,
+            name,
+            callback,
+            useCapture,
+            type
+          });
+        }
+      }
+    }
+  }
+  listeners.sort(sortListeners);
+  return listeners;
+}
+function sortListeners(a, b) {
+  if (a.name == b.name) return 0;
+  return a.name < b.name ? -1 : 1;
+}
+function assertDomElement(value) {
+  if (typeof Element !== "undefined" && !(value instanceof Element)) {
+    throw new Error("Expecting instance of DOM Element");
+  }
+}
+function extractInputDebugMetadata(inputs) {
+  const res = {};
+  for (const key in inputs) {
+    if (inputs.hasOwnProperty(key)) {
+      const value = inputs[key];
+      if (value !== void 0) {
+        res[key] = value[0];
+      }
+    }
+  }
+  return res;
+}
+var DOCUMENT2 = void 0;
+function setDocument(document2) {
+  DOCUMENT2 = document2;
+}
+function getDocument() {
+  if (DOCUMENT2 !== void 0) {
+    return DOCUMENT2;
+  } else if (typeof document !== "undefined") {
+    return document;
+  }
+  throw new RuntimeError(210, (typeof ngDevMode === "undefined" || ngDevMode) && `The document object is not available in this context. Make sure the DOCUMENT injection token is provided.`);
+}
+var APP_ID = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "AppId" : "", {
+  factory: () => DEFAULT_APP_ID
+});
+var DEFAULT_APP_ID = "ng";
+var validAppIdInitializer = {
+  provide: ENVIRONMENT_INITIALIZER,
+  multi: true,
+  useValue: () => {
+    const appId = inject2(APP_ID);
+    const isAlphanumeric = /^[a-zA-Z0-9\-_]+$/.test(appId);
+    if (!isAlphanumeric) {
+      throw new RuntimeError(211, `APP_ID value "${appId}" is not alphanumeric. The APP_ID must be a string of alphanumeric characters. (a-zA-Z0-9), hyphens (-) and underscores (_) are allowed.`);
+    }
+  }
+};
+var PLATFORM_INITIALIZER = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "Platform Initializer" : "");
+var PLATFORM_ID = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "Platform ID" : "", {
+  providedIn: "platform",
+  factory: () => "unknown"
+});
+var ANIMATION_MODULE_TYPE = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "AnimationModuleType" : "");
+var CSP_NONCE = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "CSP nonce" : "", {
+  factory: () => {
+    return inject2(DOCUMENT).body?.querySelector("[ngCspNonce]")?.getAttribute("ngCspNonce") || null;
+  }
+});
+var IMAGE_CONFIG_DEFAULTS = {
+  breakpoints: [16, 32, 48, 64, 96, 128, 256, 384, 640, 750, 828, 1080, 1200, 1920, 2048, 3840],
+  placeholderResolution: 30,
+  disableImageSizeWarning: false,
+  disableImageLazyLoadWarning: false
+};
+var IMAGE_CONFIG = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "ImageConfig" : "", {
+  factory: () => IMAGE_CONFIG_DEFAULTS
+});
+function makeStateKey(key) {
+  return key;
+}
+var TransferState = class _TransferState {
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _TransferState,
+    providedIn: "root",
+    factory: () => {
+      const transferState = new _TransferState();
+      if (true) {
+        transferState.store = retrieveTransferredState(inject2(DOCUMENT), inject2(APP_ID));
+      }
+      return transferState;
+    }
+  });
+  store = {};
+  onSerializeCallbacks = {};
+  get(key, defaultValue) {
+    return this.store[key] !== void 0 ? this.store[key] : defaultValue;
+  }
+  set(key, value) {
+    this.store[key] = value;
+  }
+  remove(key) {
+    delete this.store[key];
+  }
+  hasKey(key) {
+    return this.store.hasOwnProperty(key);
+  }
+  get isEmpty() {
+    return Object.keys(this.store).length === 0;
+  }
+  onSerialize(key, callback) {
+    this.onSerializeCallbacks[key] = callback;
+  }
+  toJson() {
+    for (const key in this.onSerializeCallbacks) {
+      if (this.onSerializeCallbacks.hasOwnProperty(key)) {
+        try {
+          this.store[key] = this.onSerializeCallbacks[key]();
+        } catch (e) {
+          console.warn("Exception in onSerialize callback: ", e);
+        }
+      }
+    }
+    return JSON.stringify(this.store).replace(/</g, "\\u003C").replace(/\//g, "\\u002F");
+  }
+};
+function retrieveTransferredState(doc, appId) {
+  const script = doc.getElementById(appId + "-state");
+  if (script?.tagName === "SCRIPT" && script.textContent) {
+    try {
+      return JSON.parse(script.textContent);
+    } catch (e) {
+      console.warn("Exception while restoring TransferState for app " + appId, e);
+    }
+  }
+  return {};
+}
+var NUM_ROOT_NODES = "r";
+var DEFER_BLOCK_ID = "di";
+var DEFER_BLOCK_STATE$1 = "s";
+var DEFER_PARENT_BLOCK_ID = "p";
+var IS_HYDRATION_DOM_REUSE_ENABLED = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "IS_HYDRATION_DOM_REUSE_ENABLED" : "");
+var PRESERVE_HOST_CONTENT_DEFAULT = false;
+var PRESERVE_HOST_CONTENT = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "PRESERVE_HOST_CONTENT" : "", {
+  factory: () => PRESERVE_HOST_CONTENT_DEFAULT
+});
+var IS_I18N_HYDRATION_ENABLED = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "IS_I18N_HYDRATION_ENABLED" : "");
+var IS_EVENT_REPLAY_ENABLED = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "IS_EVENT_REPLAY_ENABLED" : "");
+var EVENT_REPLAY_QUEUE = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "EVENT_REPLAY_QUEUE" : "", {
+  factory: () => []
+});
+var IS_INCREMENTAL_HYDRATION_ENABLED = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "IS_INCREMENTAL_HYDRATION_ENABLED" : "");
+var JSACTION_BLOCK_ELEMENT_MAP = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "JSACTION_BLOCK_ELEMENT_MAP" : "", {
+  factory: () => /* @__PURE__ */ new Map()
+});
+var IS_ENABLED_BLOCKING_INITIAL_NAVIGATION = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "IS_ENABLED_BLOCKING_INITIAL_NAVIGATION" : "");
+var eventListenerOptions = {
+  passive: true,
+  capture: true
+};
+var hoverTriggers = /* @__PURE__ */ new WeakMap();
+var interactionTriggers = /* @__PURE__ */ new WeakMap();
+var viewportTriggers = /* @__PURE__ */ new WeakMap();
+var interactionEventNames = ["click", "keydown"];
+var hoverEventNames = ["mouseenter", "mouseover", "focusin"];
+var intersectionObservers = /* @__PURE__ */ new Map();
+var DeferEventEntry = class {
+  callbacks = /* @__PURE__ */ new Set();
+  listener = () => {
+    for (const callback of this.callbacks) {
+      callback();
+    }
+  };
+};
+function onInteraction(trigger, callback) {
+  let entry = interactionTriggers.get(trigger);
+  if (!entry) {
+    entry = new DeferEventEntry();
+    interactionTriggers.set(trigger, entry);
+    for (const name of interactionEventNames) {
+      trigger.addEventListener(name, entry.listener, eventListenerOptions);
+    }
+  }
+  entry.callbacks.add(callback);
+  return () => {
+    const {
+      callbacks,
+      listener
+    } = entry;
+    callbacks.delete(callback);
+    if (callbacks.size === 0) {
+      interactionTriggers.delete(trigger);
+      for (const name of interactionEventNames) {
+        trigger.removeEventListener(name, listener, eventListenerOptions);
+      }
+    }
+  };
+}
+function onHover(trigger, callback) {
+  let entry = hoverTriggers.get(trigger);
+  if (!entry) {
+    entry = new DeferEventEntry();
+    hoverTriggers.set(trigger, entry);
+    for (const name of hoverEventNames) {
+      trigger.addEventListener(name, entry.listener, eventListenerOptions);
+    }
+  }
+  entry.callbacks.add(callback);
+  return () => {
+    const {
+      callbacks,
+      listener
+    } = entry;
+    callbacks.delete(callback);
+    if (callbacks.size === 0) {
+      for (const name of hoverEventNames) {
+        trigger.removeEventListener(name, listener, eventListenerOptions);
+      }
+      hoverTriggers.delete(trigger);
+    }
+  };
+}
+function createIntersectionObserver(options) {
+  const key = getIntersectionObserverKey(options);
+  return new IntersectionObserver((entries) => {
+    for (const current of entries) {
+      if (current.isIntersecting && viewportTriggers.has(current.target)) {
+        viewportTriggers.get(current.target)?.get(key)?.listener();
+      }
+    }
+  }, options);
+}
+function onViewport(trigger, callback, observerFactoryFn, options) {
+  const key = getIntersectionObserverKey(options);
+  let entry = viewportTriggers.get(trigger)?.get(key);
+  if (!intersectionObservers.has(key)) {
+    intersectionObservers.set(key, {
+      observer: observerFactoryFn(options),
+      count: 0
+    });
+  }
+  const config2 = intersectionObservers.get(key);
+  if (!entry) {
+    entry = new DeferEventEntry();
+    config2.observer.observe(trigger);
+    let triggerConfig = viewportTriggers.get(trigger);
+    if (triggerConfig) {
+      triggerConfig.set(key, entry);
+    } else {
+      triggerConfig = /* @__PURE__ */ new Map();
+      viewportTriggers.set(trigger, triggerConfig);
+    }
+    triggerConfig.set(key, entry);
+    config2.count++;
+  }
+  entry.callbacks.add(callback);
+  return () => {
+    if (!viewportTriggers.get(trigger)?.has(key)) {
+      return;
+    }
+    entry.callbacks.delete(callback);
+    if (entry.callbacks.size === 0) {
+      config2.observer.unobserve(trigger);
+      config2.count--;
+      const triggerConfig = viewportTriggers.get(trigger);
+      if (triggerConfig) {
+        triggerConfig.delete(key);
+        if (triggerConfig.size === 0) {
+          viewportTriggers.delete(trigger);
+        }
+      }
+    }
+    if (config2.count === 0) {
+      config2.observer.disconnect();
+      intersectionObservers.delete(key);
+    }
+  };
+}
+function getIntersectionObserverKey(options) {
+  if (!options) {
+    return "";
+  }
+  return `${options.rootMargin}/${typeof options.threshold === "number" ? options.threshold : options.threshold?.join("\n")}`;
+}
+var JSACTION_EVENT_CONTRACT = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "EVENT_CONTRACT_DETAILS" : "", {
+  factory: () => ({})
+});
+var handledEventElements = /* @__PURE__ */ new WeakMap();
+function markEventHandledForElement(event, element) {
+  if (event == null || typeof event !== "object") return;
+  let elements = handledEventElements.get(event);
+  if (!elements) {
+    elements = /* @__PURE__ */ new WeakSet();
+    handledEventElements.set(event, elements);
+  }
+  elements.add(element);
+}
+var _stashEventListenerImpl = (lView, target, eventName, wrappedListener) => {
+};
+function stashEventListenerImpl(lView, target, eventName, wrappedListener) {
+  _stashEventListenerImpl(lView, target, eventName, wrappedListener);
+}
+var DEHYDRATED_BLOCK_REGISTRY = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "DEHYDRATED_BLOCK_REGISTRY" : "");
+function isDetachedByI18n(tNode) {
+  return (tNode.flags & 32) === 32;
+}
+var TRANSFER_STATE_TOKEN_ID = "__nghData__";
+var NGH_DATA_KEY = makeStateKey(TRANSFER_STATE_TOKEN_ID);
+var TRANSFER_STATE_DEFER_BLOCKS_INFO = "__nghDeferData__";
+var NGH_DEFER_BLOCKS_KEY = makeStateKey(TRANSFER_STATE_DEFER_BLOCKS_INFO);
+function isInternalHydrationTransferStateKey(key) {
+  return key === TRANSFER_STATE_TOKEN_ID || key === TRANSFER_STATE_DEFER_BLOCKS_INFO;
+}
+var _retrieveHydrationInfoImpl = () => null;
+function retrieveHydrationInfo(rNode, injector, isRootView2 = false) {
+  return _retrieveHydrationInfoImpl(rNode, injector, isRootView2);
+}
+function getLNodeForHydration(viewRef) {
+  let lView = viewRef._lView;
+  const tView = lView[TVIEW];
+  if (tView.type === 2) {
+    return null;
+  }
+  if (isRootView(lView)) {
+    lView = lView[HEADER_OFFSET];
+  }
+  return lView;
+}
+var HydrationStatus;
+(function(HydrationStatus2) {
+  HydrationStatus2["Hydrated"] = "hydrated";
+  HydrationStatus2["Skipped"] = "skipped";
+  HydrationStatus2["Mismatched"] = "mismatched";
+})(HydrationStatus || (HydrationStatus = {}));
+var HYDRATION_INFO_KEY = "__ngDebugHydrationInfo__";
+function patchHydrationInfo(node, info) {
+  node[HYDRATION_INFO_KEY] = info;
+}
+function markRNodeAsHavingHydrationMismatch(node, expectedNodeDetails = null, actualNodeDetails = null) {
+  if (!ngDevMode) {
+    throw new Error("Calling `markRNodeAsMismatchedByHydration` in prod mode is not supported and likely a mistake.");
+  }
+  while (node && !getComponent(node)) {
+    node = node?.parentNode;
+  }
+  if (node) {
+    patchHydrationInfo(node, {
+      status: HydrationStatus.Mismatched,
+      expectedNodeDetails,
+      actualNodeDetails
+    });
+  }
+}
+function isIncrementalHydrationEnabled(injector) {
+  return injector.get(IS_INCREMENTAL_HYDRATION_ENABLED, false, {
+    optional: true
+  });
+}
+var incrementalHydrationEnabledWarned = false;
+function warnIncrementalHydrationNotConfigured() {
+  if (!incrementalHydrationEnabledWarned) {
+    incrementalHydrationEnabledWarned = true;
+    console.warn(formatRuntimeError(508, "Angular has detected that some `@defer` blocks use `hydrate` triggers, but incremental hydration was not enabled. Please ensure that the `withIncrementalHydration()` call is added as an argument for the `provideClientHydration()` function call in your application config."));
+  }
+}
+function assertSsrIdDefined(ssrUniqueId) {
+  assertDefined(ssrUniqueId, "Internal error: expecting an SSR id for a defer block that should be hydrated, but the id is not present");
+}
+function getParentBlockHydrationQueue(deferBlockId, injector) {
+  const dehydratedBlockRegistry = injector.get(DEHYDRATED_BLOCK_REGISTRY);
+  const transferState = injector.get(TransferState);
+  const deferBlockParents = transferState.get(NGH_DEFER_BLOCKS_KEY, {});
+  let isTopMostDeferBlock = false;
+  let currentBlockId = deferBlockId;
+  let parentBlockPromise = null;
+  const hydrationQueue = [];
+  while (!isTopMostDeferBlock && currentBlockId) {
+    ngDevMode && assertEqual(hydrationQueue.indexOf(currentBlockId), -1, "Internal error: defer block hierarchy has a cycle.");
+    isTopMostDeferBlock = dehydratedBlockRegistry.has(currentBlockId);
+    const hydratingParentBlock = dehydratedBlockRegistry.hydrating.get(currentBlockId);
+    if (parentBlockPromise === null && hydratingParentBlock != null) {
+      parentBlockPromise = hydratingParentBlock.promise;
+      break;
+    }
+    hydrationQueue.unshift(currentBlockId);
+    currentBlockId = deferBlockParents[currentBlockId][DEFER_PARENT_BLOCK_ID];
+  }
+  return {
+    parentBlockPromise,
+    hydrationQueue
+  };
+}
+function refreshContentQueries(tView, lView) {
+  const contentQueries = tView.contentQueries;
+  if (contentQueries !== null) {
+    const prevConsumer = setActiveConsumer(null);
+    try {
+      for (let i = 0; i < contentQueries.length; i += 2) {
+        const queryStartIdx = contentQueries[i];
+        const directiveDefIdx = contentQueries[i + 1];
+        if (directiveDefIdx !== -1) {
+          const directiveDef = tView.data[directiveDefIdx];
+          ngDevMode && assertDefined(directiveDef, "DirectiveDef not found.");
+          ngDevMode && assertDefined(directiveDef.contentQueries, "contentQueries function should be defined");
+          setCurrentQueryIndex(queryStartIdx);
+          directiveDef.contentQueries(2, lView[directiveDefIdx], directiveDefIdx);
+        }
+      }
+    } finally {
+      setActiveConsumer(prevConsumer);
+    }
+  }
+}
+function executeViewQueryFn(flags, viewQueryFn, component) {
+  ngDevMode && assertDefined(viewQueryFn, "View queries function to execute must be defined.");
+  setCurrentQueryIndex(0);
+  const prevConsumer = setActiveConsumer(null);
+  try {
+    viewQueryFn(flags, component);
+  } finally {
+    setActiveConsumer(prevConsumer);
+  }
+}
+function executeContentQueries(tView, tNode, lView) {
+  if (isContentQueryHost(tNode)) {
+    const prevConsumer = setActiveConsumer(null);
+    try {
+      const start = tNode.directiveStart;
+      const end = tNode.directiveEnd;
+      for (let directiveIndex = start; directiveIndex < end; directiveIndex++) {
+        const def = tView.data[directiveIndex];
+        if (def.contentQueries) {
+          const directiveInstance = lView[directiveIndex];
+          ngDevMode && assertDefined(directiveIndex, "Incorrect reference to a directive defining a content query");
+          def.contentQueries(1, directiveInstance, directiveIndex);
+        }
+      }
+    } finally {
+      setActiveConsumer(prevConsumer);
+    }
+  }
+}
+var ViewEncapsulation;
+(function(ViewEncapsulation3) {
+  ViewEncapsulation3[ViewEncapsulation3["Emulated"] = 0] = "Emulated";
+  ViewEncapsulation3[ViewEncapsulation3["None"] = 2] = "None";
+  ViewEncapsulation3[ViewEncapsulation3["ShadowDom"] = 3] = "ShadowDom";
+  ViewEncapsulation3[ViewEncapsulation3["ExperimentalIsolatedShadowDom"] = 4] = "ExperimentalIsolatedShadowDom";
+})(ViewEncapsulation || (ViewEncapsulation = {}));
+var CUSTOM_ELEMENTS_SCHEMA = {
+  name: "custom-elements"
+};
+var NO_ERRORS_SCHEMA = {
+  name: "no-errors-schema"
+};
+var shouldThrowErrorOnUnknownElement = false;
+var shouldThrowErrorOnUnknownProperty = false;
+function validateElementIsKnown(lView, tNode) {
+  const tView = lView[TVIEW];
+  if (tView.schemas === null) return;
+  const tagName = tNode.value;
+  if (!isDirectiveHost(tNode) && tagName !== null) {
+    const isUnknown = typeof HTMLUnknownElement !== "undefined" && HTMLUnknownElement && getNativeByTNode(tNode, lView) instanceof HTMLUnknownElement || typeof customElements !== "undefined" && tagName.indexOf("-") > -1 && !customElements.get(tagName);
+    if (isUnknown && !matchingSchemas(tView.schemas, tagName)) {
+      const isHostStandalone = isHostComponentStandalone(lView);
+      const templateLocation = getTemplateLocationDetails(lView);
+      const schemas = `'${isHostStandalone ? "@Component" : "@NgModule"}.schemas'`;
+      let message = `'${tagName}' is not a known element${templateLocation}:
+`;
+      message += `1. If '${tagName}' is an Angular component, then verify that it is ${isHostStandalone ? "included in the '@Component.imports' of this component" : "a part of an @NgModule where this component is declared"}.
+`;
+      if (tagName && tagName.indexOf("-") > -1) {
+        message += `2. If '${tagName}' is a Web Component then add 'CUSTOM_ELEMENTS_SCHEMA' to the ${schemas} of this component to suppress this message.`;
+      } else {
+        message += `2. To allow any element add 'NO_ERRORS_SCHEMA' to the ${schemas} of this component.`;
+      }
+      if (shouldThrowErrorOnUnknownElement) {
+        throw new RuntimeError(304, message);
+      } else {
+        console.error(formatRuntimeError(304, message));
+      }
+    }
+  }
+}
+function isPropertyValid(element, propName, tagName, schemas) {
+  if (schemas === null) return true;
+  if (matchingSchemas(schemas, tagName) || propName in element || isAnimationProp(propName)) {
+    return true;
+  }
+  return typeof Node === "undefined" || Node === null || !(element instanceof Node);
+}
+function handleUnknownPropertyError(propName, tagName, nodeType, lView) {
+  if (!tagName && nodeType === 4) {
+    tagName = "ng-template";
+  }
+  const isHostStandalone = isHostComponentStandalone(lView);
+  const templateLocation = getTemplateLocationDetails(lView);
+  let message = `Can't bind to '${propName}' since it isn't a known property of '${tagName}'${templateLocation}.`;
+  const schemas = `'${isHostStandalone ? "@Component" : "@NgModule"}.schemas'`;
+  const importLocation = isHostStandalone ? "included in the '@Component.imports' of this component" : "a part of an @NgModule where this component is declared";
+  if (KNOWN_CONTROL_FLOW_DIRECTIVES.has(propName)) {
+    const correspondingImport = KNOWN_CONTROL_FLOW_DIRECTIVES.get(propName);
+    message += `
+If the '${propName}' is an Angular control flow directive, please make sure that either the '${correspondingImport}' directive or the 'CommonModule' is ${importLocation}.`;
+  } else {
+    message += `
+1. If '${tagName}' is an Angular component and it has the '${propName}' input, then verify that it is ${importLocation}.`;
+    if (tagName && tagName.indexOf("-") > -1) {
+      message += `
+2. If '${tagName}' is a Web Component then add 'CUSTOM_ELEMENTS_SCHEMA' to the ${schemas} of this component to suppress this message.`;
+      message += `
+3. To allow any property add 'NO_ERRORS_SCHEMA' to the ${schemas} of this component.`;
+    } else {
+      message += `
+2. To allow any property add 'NO_ERRORS_SCHEMA' to the ${schemas} of this component.`;
+    }
+  }
+  reportUnknownPropertyError(message);
+}
+function reportUnknownPropertyError(message) {
+  if (shouldThrowErrorOnUnknownProperty) {
+    throw new RuntimeError(303, message);
+  } else {
+    console.error(formatRuntimeError(303, message));
+  }
+}
+function getDeclarationComponentDef(lView) {
+  !ngDevMode && throwError2("Must never be called in production mode");
+  const declarationLView = lView[DECLARATION_COMPONENT_VIEW];
+  const context2 = declarationLView[CONTEXT];
+  if (!context2) return null;
+  return context2.constructor ? getComponentDef(context2.constructor) : null;
+}
+function isHostComponentStandalone(lView) {
+  !ngDevMode && throwError2("Must never be called in production mode");
+  const componentDef = getDeclarationComponentDef(lView);
+  return !!componentDef?.standalone;
+}
+function getTemplateLocationDetails(lView) {
+  !ngDevMode && throwError2("Must never be called in production mode");
+  const hostComponentDef = getDeclarationComponentDef(lView);
+  const componentClassName = hostComponentDef?.type?.name;
+  return componentClassName ? ` (used in the '${componentClassName}' component template)` : "";
+}
+var KNOWN_CONTROL_FLOW_DIRECTIVES = /* @__PURE__ */ new Map([["ngIf", "NgIf"], ["ngFor", "NgFor"], ["ngSwitchCase", "NgSwitchCase"], ["ngSwitchDefault", "NgSwitchDefault"]]);
+function matchingSchemas(schemas, tagName) {
+  if (schemas !== null) {
+    for (let i = 0; i < schemas.length; i++) {
+      const schema = schemas[i];
+      if (schema === NO_ERRORS_SCHEMA || schema === CUSTOM_ELEMENTS_SCHEMA && tagName && tagName.indexOf("-") > -1) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+var policy$1;
+function getPolicy$1() {
+  if (policy$1 === void 0) {
+    policy$1 = null;
+    if (_global.trustedTypes) {
+      try {
+        policy$1 = _global.trustedTypes.createPolicy("angular", {
+          createHTML: (s) => s,
+          createScript: (s) => s,
+          createScriptURL: (s) => s
+        });
+      } catch {
+      }
+    }
+  }
+  return policy$1;
+}
+function trustedHTMLFromString(html) {
+  return getPolicy$1()?.createHTML(html) || html;
+}
+function trustedScriptURLFromString(url) {
+  return getPolicy$1()?.createScriptURL(url) || url;
+}
+var policy;
+function getPolicy() {
+  if (policy === void 0) {
+    policy = null;
+    if (_global.trustedTypes) {
+      try {
+        policy = _global.trustedTypes.createPolicy("angular#unsafe-bypass", {
+          createHTML: (s) => s,
+          createScript: (s) => s,
+          createScriptURL: (s) => s
+        });
+      } catch {
+      }
+    }
+  }
+  return policy;
+}
+function trustedHTMLFromStringBypass(html) {
+  return getPolicy()?.createHTML(html) || html;
+}
+function trustedScriptFromStringBypass(script) {
+  return getPolicy()?.createScript(script) || script;
+}
+function trustedScriptURLFromStringBypass(url) {
+  return getPolicy()?.createScriptURL(url) || url;
+}
+var SafeValueImpl = class {
+  changingThisBreaksApplicationSecurity;
+  constructor(changingThisBreaksApplicationSecurity) {
+    this.changingThisBreaksApplicationSecurity = changingThisBreaksApplicationSecurity;
+  }
+  toString() {
+    return `SafeValue must use [property]=binding: ${this.changingThisBreaksApplicationSecurity} (see ${XSS_SECURITY_URL})`;
+  }
+};
+var SafeHtmlImpl = class extends SafeValueImpl {
+  getTypeName() {
+    return "HTML";
+  }
+};
+var SafeStyleImpl = class extends SafeValueImpl {
+  getTypeName() {
+    return "Style";
+  }
+};
+var SafeScriptImpl = class extends SafeValueImpl {
+  getTypeName() {
+    return "Script";
+  }
+};
+var SafeUrlImpl = class extends SafeValueImpl {
+  getTypeName() {
+    return "URL";
+  }
+};
+var SafeResourceUrlImpl = class extends SafeValueImpl {
+  getTypeName() {
+    return "ResourceURL";
+  }
+};
+function unwrapSafeValue(value) {
+  return value instanceof SafeValueImpl ? value.changingThisBreaksApplicationSecurity : value;
+}
+function allowSanitizationBypassAndThrow(value, type) {
+  const actualType = getSanitizationBypassType(value);
+  if (actualType != null && actualType !== type) {
+    if (actualType === "ResourceURL" && type === "URL") return true;
+    throw new Error(`Required a safe ${type}, got a ${actualType} (see ${XSS_SECURITY_URL})`);
+  }
+  return actualType === type;
+}
+function getSanitizationBypassType(value) {
+  return value instanceof SafeValueImpl && value.getTypeName() || null;
+}
+function bypassSanitizationTrustHtml(trustedHtml) {
+  return new SafeHtmlImpl(trustedHtml);
+}
+function bypassSanitizationTrustStyle(trustedStyle) {
+  return new SafeStyleImpl(trustedStyle);
+}
+function bypassSanitizationTrustScript(trustedScript) {
+  return new SafeScriptImpl(trustedScript);
+}
+function bypassSanitizationTrustUrl(trustedUrl) {
+  return new SafeUrlImpl(trustedUrl);
+}
+function bypassSanitizationTrustResourceUrl(trustedResourceUrl) {
+  return new SafeResourceUrlImpl(trustedResourceUrl);
+}
+function getInertBodyHelper(defaultDoc) {
+  const inertDocumentHelper = new InertDocumentHelper(defaultDoc);
+  return isDOMParserAvailable() ? new DOMParserHelper(inertDocumentHelper) : inertDocumentHelper;
+}
+var DOMParserHelper = class {
+  inertDocumentHelper;
+  constructor(inertDocumentHelper) {
+    this.inertDocumentHelper = inertDocumentHelper;
+  }
+  getInertBodyElement(html) {
+    html = "<body><remove></remove>" + html;
+    try {
+      const body = new window.DOMParser().parseFromString(trustedHTMLFromString(html), "text/html").body;
+      if (body === null) {
+        return this.inertDocumentHelper.getInertBodyElement(html);
+      }
+      body.firstChild?.remove();
+      return body;
+    } catch {
+      return null;
+    }
+  }
+};
+var InertDocumentHelper = class {
+  defaultDoc;
+  inertDocument;
+  constructor(defaultDoc) {
+    this.defaultDoc = defaultDoc;
+    this.inertDocument = this.defaultDoc.implementation.createHTMLDocument("sanitization-inert");
+  }
+  getInertBodyElement(html) {
+    const templateEl = this.inertDocument.createElement("template");
+    templateEl.innerHTML = trustedHTMLFromString(html);
+    return templateEl;
+  }
+};
+function isDOMParserAvailable() {
+  try {
+    return !!new window.DOMParser().parseFromString(trustedHTMLFromString(""), "text/html");
+  } catch {
+    return false;
+  }
+}
+var SAFE_URL_PATTERN = /^(?!javascript:)(?:[a-z0-9+.-]+:|[^&:\/?#]*(?:[\/?#]|$))/i;
+function _sanitizeUrl(url) {
+  url = String(url);
+  if (url.match(SAFE_URL_PATTERN)) return url;
+  if (typeof ngDevMode === "undefined" || ngDevMode) {
+    console.warn(`WARNING: sanitizing unsafe URL value ${url} (see ${XSS_SECURITY_URL})`);
+  }
+  return "unsafe:" + url;
+}
+function tagSet(tags) {
+  const res = {};
+  for (const t of tags.split(",")) res[t] = true;
+  return res;
+}
+function merge(...sets) {
+  const res = {};
+  for (const s of sets) {
+    for (const v in s) {
+      if (s.hasOwnProperty(v)) res[v] = true;
+    }
+  }
+  return res;
+}
+var VOID_ELEMENTS = tagSet("area,br,col,hr,img,wbr");
+var OPTIONAL_END_TAG_BLOCK_ELEMENTS = tagSet("colgroup,dd,dt,li,p,tbody,td,tfoot,th,thead,tr");
+var OPTIONAL_END_TAG_INLINE_ELEMENTS = tagSet("rp,rt");
+var OPTIONAL_END_TAG_ELEMENTS = merge(OPTIONAL_END_TAG_INLINE_ELEMENTS, OPTIONAL_END_TAG_BLOCK_ELEMENTS);
+var BLOCK_ELEMENTS = merge(OPTIONAL_END_TAG_BLOCK_ELEMENTS, tagSet("address,article,aside,blockquote,caption,center,del,details,dialog,dir,div,dl,figure,figcaption,footer,h1,h2,h3,h4,h5,h6,header,hgroup,hr,ins,main,map,menu,nav,ol,pre,section,summary,table,ul"));
+var INLINE_ELEMENTS = merge(OPTIONAL_END_TAG_INLINE_ELEMENTS, tagSet("a,abbr,acronym,audio,b,bdi,bdo,big,br,cite,code,del,dfn,em,font,i,img,ins,kbd,label,map,mark,picture,q,ruby,rp,rt,s,samp,small,source,span,strike,strong,sub,sup,time,track,tt,u,var,video"));
+var VALID_ELEMENTS = merge(VOID_ELEMENTS, BLOCK_ELEMENTS, INLINE_ELEMENTS, OPTIONAL_END_TAG_ELEMENTS);
+var URI_ATTRS = tagSet("background,cite,href,itemtype,longdesc,poster,src,xlink:href");
+var HTML_ATTRS = tagSet("abbr,accesskey,align,alt,autoplay,axis,bgcolor,border,cellpadding,cellspacing,class,clear,color,cols,colspan,compact,controls,coords,datetime,default,dir,download,face,headers,height,hidden,hreflang,hspace,ismap,itemscope,itemprop,kind,label,lang,language,loop,media,muted,nohref,nowrap,open,preload,rel,rev,role,rows,rowspan,rules,scope,scrolling,shape,size,sizes,span,srclang,srcset,start,summary,tabindex,target,title,translate,type,usemap,valign,value,vspace,width");
+var ARIA_ATTRS = tagSet("aria-activedescendant,aria-atomic,aria-autocomplete,aria-busy,aria-checked,aria-colcount,aria-colindex,aria-colspan,aria-controls,aria-current,aria-describedby,aria-details,aria-disabled,aria-dropeffect,aria-errormessage,aria-expanded,aria-flowto,aria-grabbed,aria-haspopup,aria-hidden,aria-invalid,aria-keyshortcuts,aria-label,aria-labelledby,aria-level,aria-live,aria-modal,aria-multiline,aria-multiselectable,aria-orientation,aria-owns,aria-placeholder,aria-posinset,aria-pressed,aria-readonly,aria-relevant,aria-required,aria-roledescription,aria-rowcount,aria-rowindex,aria-rowspan,aria-selected,aria-setsize,aria-sort,aria-valuemax,aria-valuemin,aria-valuenow,aria-valuetext");
+var VALID_ATTRS = merge(URI_ATTRS, HTML_ATTRS, ARIA_ATTRS);
+var SKIP_TRAVERSING_CONTENT_IF_INVALID_ELEMENTS = tagSet("script,style,template");
+var SanitizingHtmlSerializer = class {
+  sanitizedSomething = false;
+  buf = [];
+  sanitizeChildren(el) {
+    let current = el.firstChild;
+    let traverseContent = true;
+    let parentNodes = [];
+    while (current) {
+      if (current.nodeType === Node.ELEMENT_NODE) {
+        traverseContent = this.startElement(current);
+      } else if (current.nodeType === Node.TEXT_NODE) {
+        this.chars(current.nodeValue);
+      } else {
+        this.sanitizedSomething = true;
+      }
+      if (traverseContent && current.firstChild) {
+        parentNodes.push(current);
+        current = getFirstChild(current);
+        continue;
+      }
+      while (current) {
+        if (current.nodeType === Node.ELEMENT_NODE) {
+          this.endElement(current);
+        }
+        let next = getNextSibling(current);
+        if (next) {
+          current = next;
+          break;
+        }
+        current = parentNodes.pop();
+      }
+    }
+    return this.buf.join("");
+  }
+  startElement(element) {
+    const tagName = getNodeName(element).toLowerCase();
+    if (!VALID_ELEMENTS.hasOwnProperty(tagName)) {
+      this.sanitizedSomething = true;
+      return !SKIP_TRAVERSING_CONTENT_IF_INVALID_ELEMENTS.hasOwnProperty(tagName);
+    }
+    this.buf.push("<");
+    this.buf.push(tagName);
+    const elAttrs = element.attributes;
+    for (let i = 0; i < elAttrs.length; i++) {
+      const elAttr = elAttrs.item(i);
+      const attrName = elAttr.name;
+      const lower = attrName.toLowerCase();
+      if (!VALID_ATTRS.hasOwnProperty(lower)) {
+        this.sanitizedSomething = true;
+        continue;
+      }
+      let value = elAttr.value;
+      if (URI_ATTRS[lower]) value = _sanitizeUrl(value);
+      this.buf.push(" ", attrName, '="', encodeEntities(value), '"');
+    }
+    this.buf.push(">");
+    return true;
+  }
+  endElement(current) {
+    const tagName = getNodeName(current).toLowerCase();
+    if (VALID_ELEMENTS.hasOwnProperty(tagName) && !VOID_ELEMENTS.hasOwnProperty(tagName)) {
+      this.buf.push("</");
+      this.buf.push(tagName);
+      this.buf.push(">");
+    }
+  }
+  chars(chars) {
+    this.buf.push(encodeEntities(chars));
+  }
+};
+function isClobberedElement(parentNode, childNode) {
+  return (parentNode.compareDocumentPosition(childNode) & Node.DOCUMENT_POSITION_CONTAINED_BY) !== Node.DOCUMENT_POSITION_CONTAINED_BY;
+}
+function getNextSibling(node) {
+  const nextSibling = node.nextSibling;
+  if (nextSibling && node !== nextSibling.previousSibling) {
+    throw clobberedElementError(nextSibling);
+  }
+  return nextSibling;
+}
+function getFirstChild(node) {
+  const firstChild = node.firstChild;
+  if (firstChild && isClobberedElement(node, firstChild)) {
+    throw clobberedElementError(firstChild);
+  }
+  return firstChild;
+}
+function getNodeName(node) {
+  const nodeName = node.nodeName;
+  return typeof nodeName === "string" ? nodeName : "FORM";
+}
+function clobberedElementError(node) {
+  return new Error(`Failed to sanitize html because the element is clobbered: ${node.outerHTML}`);
+}
+var SURROGATE_PAIR_REGEXP = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+var NON_ALPHANUMERIC_REGEXP = /([^\#-~ |!])/g;
+function encodeEntities(value) {
+  return value.replace(/&/g, "&amp;").replace(SURROGATE_PAIR_REGEXP, function(match2) {
+    const hi = match2.charCodeAt(0);
+    const low = match2.charCodeAt(1);
+    return "&#" + ((hi - 55296) * 1024 + (low - 56320) + 65536) + ";";
+  }).replace(NON_ALPHANUMERIC_REGEXP, function(match2) {
+    return "&#" + match2.charCodeAt(0) + ";";
+  }).replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+var inertBodyHelper;
+function _sanitizeHtml(defaultDoc, unsafeHtmlInput) {
+  let inertBodyElement = null;
+  try {
+    inertBodyHelper = inertBodyHelper || getInertBodyHelper(defaultDoc);
+    let unsafeHtml = unsafeHtmlInput ? String(unsafeHtmlInput) : "";
+    inertBodyElement = inertBodyHelper.getInertBodyElement(unsafeHtml);
+    let mXSSAttempts = 5;
+    let parsedHtml = unsafeHtml;
+    do {
+      if (mXSSAttempts === 0) {
+        throw new Error("Failed to sanitize html because the input is unstable");
+      }
+      mXSSAttempts--;
+      unsafeHtml = parsedHtml;
+      parsedHtml = inertBodyElement.innerHTML;
+      inertBodyElement = inertBodyHelper.getInertBodyElement(unsafeHtml);
+    } while (unsafeHtml !== parsedHtml);
+    const sanitizer = new SanitizingHtmlSerializer();
+    const safeHtml = sanitizer.sanitizeChildren(getTemplateContent(inertBodyElement) || inertBodyElement);
+    if ((typeof ngDevMode === "undefined" || ngDevMode) && sanitizer.sanitizedSomething) {
+      console.warn(`WARNING: sanitizing HTML stripped some content, see ${XSS_SECURITY_URL}`);
+    }
+    return trustedHTMLFromString(safeHtml);
+  } finally {
+    if (inertBodyElement) {
+      const parent = getTemplateContent(inertBodyElement) || inertBodyElement;
+      while (parent.firstChild) {
+        parent.firstChild.remove();
+      }
+    }
+  }
+}
+function getTemplateContent(el) {
+  return "content" in el && isTemplateElement(el) ? el.content : null;
+}
+function isTemplateElement(el) {
+  return el.nodeType === Node.ELEMENT_NODE && el.nodeName === "TEMPLATE";
+}
+var COMMENT_DISALLOWED = /^>|^->|<!--|-->|--!>|<!-$/g;
+var COMMENT_DELIMITER = /(<|>)/g;
+var COMMENT_DELIMITER_ESCAPED = "\u200B$1\u200B";
+function escapeCommentText(value) {
+  return value.replace(COMMENT_DISALLOWED, (text) => text.replace(COMMENT_DELIMITER, COMMENT_DELIMITER_ESCAPED));
+}
+function createTextNode(renderer, value) {
+  return renderer.createText(value);
+}
+function updateTextNode(renderer, rNode, value) {
+  renderer.setValue(rNode, value);
+}
+function createCommentNode(renderer, value) {
+  return renderer.createComment(escapeCommentText(value));
+}
+function createElementNode(renderer, name, namespace) {
+  return renderer.createElement(name, namespace);
+}
+function nativeInsertBefore(renderer, parent, child, beforeNode, isMove) {
+  renderer.insertBefore(parent, child, beforeNode, isMove);
+}
+function nativeAppendChild(renderer, parent, child) {
+  ngDevMode && assertDefined(parent, "parent node must be defined");
+  renderer.appendChild(parent, child);
+}
+function nativeAppendOrInsertBefore(renderer, parent, child, beforeNode, isMove) {
+  if (beforeNode !== null) {
+    nativeInsertBefore(renderer, parent, child, beforeNode, isMove);
+  } else {
+    nativeAppendChild(renderer, parent, child);
+  }
+}
+function nativeRemoveNode(renderer, rNode, isHostElement, requireSynchronousElementRemoval) {
+  renderer.removeChild(null, rNode, isHostElement, requireSynchronousElementRemoval);
+}
+function writeDirectStyle(renderer, element, newValue) {
+  ngDevMode && assertString(newValue, "'newValue' should be a string");
+  renderer.setAttribute(element, "style", newValue);
+}
+function writeDirectClass(renderer, element, newValue) {
+  ngDevMode && assertString(newValue, "'newValue' should be a string");
+  if (newValue === "") {
+    renderer.removeAttribute(element, "class");
+  } else {
+    renderer.setAttribute(element, "class", newValue);
+  }
+}
+function setupStaticAttributes(renderer, element, tNode) {
+  const {
+    mergedAttrs,
+    classes,
+    styles
+  } = tNode;
+  if (mergedAttrs !== null) {
+    setUpAttributes(renderer, element, mergedAttrs);
+  }
+  if (classes !== null) {
+    writeDirectClass(renderer, element, classes);
+  }
+  if (styles !== null) {
+    writeDirectStyle(renderer, element, styles);
+  }
+}
+function enforceIframeSecurity(iframe) {
+  const lView = getLView();
+  iframe.src = "";
+  iframe.srcdoc = trustedHTMLFromString("");
+  nativeRemoveNode(lView[RENDERER], iframe);
+}
+var SecurityContext;
+(function(SecurityContext2) {
+  SecurityContext2[SecurityContext2["NONE"] = 0] = "NONE";
+  SecurityContext2[SecurityContext2["HTML"] = 1] = "HTML";
+  SecurityContext2[SecurityContext2["STYLE"] = 2] = "STYLE";
+  SecurityContext2[SecurityContext2["SCRIPT"] = 3] = "SCRIPT";
+  SecurityContext2[SecurityContext2["URL"] = 4] = "URL";
+  SecurityContext2[SecurityContext2["RESOURCE_URL"] = 5] = "RESOURCE_URL";
+  SecurityContext2[SecurityContext2["ATTRIBUTE_NO_BINDING"] = 6] = "ATTRIBUTE_NO_BINDING";
+})(SecurityContext || (SecurityContext = {}));
+var _SECURITY_SCHEMA;
+var SVG_NAMESPACE2 = "svg";
+var MATH_ML_NAMESPACE2 = "math";
+function SECURITY_SCHEMA() {
+  if (!_SECURITY_SCHEMA) {
+    _SECURITY_SCHEMA = {};
+    registerContext(SecurityContext.HTML, void 0, [["iframe", ["srcdoc"]], ["*", ["innerHTML", "outerHTML"]]]);
+    registerContext(SecurityContext.STYLE, void 0, [["*", ["style"]]]);
+    registerContext(SecurityContext.URL, void 0, [["*", ["formAction"]], ["area", ["href"]], ["a", ["href", "xlink:href"]], ["form", ["action"]], ["img", ["src"]], ["video", ["src"]]]);
+    registerContext(SecurityContext.URL, MATH_ML_NAMESPACE2, [["annotation", ["href", "xlink:href"]], ["annotation-xml", ["href", "xlink:href"]], ["maction", ["href", "xlink:href"]], ["malignmark", ["href", "xlink:href"]], ["math", ["href", "xlink:href"]], ["mroot", ["href", "xlink:href"]], ["msqrt", ["href", "xlink:href"]], ["merror", ["href", "xlink:href"]], ["mfrac", ["href", "xlink:href"]], ["mglyph", ["href", "xlink:href"]], ["msub", ["href", "xlink:href"]], ["msup", ["href", "xlink:href"]], ["msubsup", ["href", "xlink:href"]], ["mmultiscripts", ["href", "xlink:href"]], ["mprescripts", ["href", "xlink:href"]], ["mi", ["href", "xlink:href"]], ["mn", ["href", "xlink:href"]], ["mo", ["href", "xlink:href"]], ["mpadded", ["href", "xlink:href"]], ["mphantom", ["href", "xlink:href"]], ["mrow", ["href", "xlink:href"]], ["ms", ["href", "xlink:href"]], ["mspace", ["href", "xlink:href"]], ["mstyle", ["href", "xlink:href"]], ["mtable", ["href", "xlink:href"]], ["mtd", ["href", "xlink:href"]], ["mtr", ["href", "xlink:href"]], ["mtext", ["href", "xlink:href"]], ["mover", ["href", "xlink:href"]], ["munder", ["href", "xlink:href"]], ["munderover", ["href", "xlink:href"]], ["semantics", ["href", "xlink:href"]], ["none", ["href", "xlink:href"]]]);
+    registerContext(SecurityContext.RESOURCE_URL, void 0, [["base", ["href"]], ["embed", ["src"]], ["frame", ["src"]], ["iframe", ["src"]], ["link", ["href"]], ["object", ["codebase", "data"]]]);
+    registerContext(SecurityContext.URL, SVG_NAMESPACE2, [["a", ["href", "xlink:href"]]]);
+    registerContext(SecurityContext.ATTRIBUTE_NO_BINDING, SVG_NAMESPACE2, [["animate", ["attributeName", "values", "to", "from"]], ["set", ["to", "attributeName"]], ["animateMotion", ["attributeName"]], ["animateTransform", ["attributeName"]]]);
+    registerContext(SecurityContext.ATTRIBUTE_NO_BINDING, void 0, [["unknown", ["attributeName", "values", "to", "from", "sandbox", "allow", "allowFullscreen", "referrerPolicy", "csp", "fetchPriority"]], ["iframe", ["sandbox", "allow", "allowFullscreen", "referrerPolicy", "csp", "fetchPriority"]]]);
+  }
+  return _SECURITY_SCHEMA;
+}
+function registerContext(ctx, namespace, specs) {
+  for (const [element, attributeNames] of specs) {
+    let tagName = namespace && element !== "*" && element !== "unknown" ? `:${namespace}:${element}` : element;
+    tagName = tagName.toLowerCase();
+    for (const attr of attributeNames) {
+      _SECURITY_SCHEMA[`${tagName}|${attr.toLowerCase()}`] = ctx;
+    }
+  }
+}
+function \u0275\u0275sanitizeHtml(unsafeHtml) {
+  const sanitizer = getSanitizer();
+  if (sanitizer) {
+    return trustedHTMLFromStringBypass(sanitizer.sanitize(SecurityContext.HTML, unsafeHtml) || "");
+  }
+  if (allowSanitizationBypassAndThrow(unsafeHtml, "HTML")) {
+    return trustedHTMLFromStringBypass(unwrapSafeValue(unsafeHtml));
+  }
+  return _sanitizeHtml(getDocument(), renderStringify(unsafeHtml));
+}
+function \u0275\u0275sanitizeStyle(unsafeStyle) {
+  const sanitizer = getSanitizer();
+  if (sanitizer) {
+    return sanitizer.sanitize(SecurityContext.STYLE, unsafeStyle) || "";
+  }
+  if (allowSanitizationBypassAndThrow(unsafeStyle, "Style")) {
+    return unwrapSafeValue(unsafeStyle);
+  }
+  return renderStringify(unsafeStyle);
+}
+function \u0275\u0275sanitizeUrl(unsafeUrl) {
+  const sanitizer = getSanitizer();
+  if (sanitizer) {
+    return sanitizer.sanitize(SecurityContext.URL, unsafeUrl) || "";
+  }
+  if (allowSanitizationBypassAndThrow(unsafeUrl, "URL")) {
+    return unwrapSafeValue(unsafeUrl);
+  }
+  return _sanitizeUrl(renderStringify(unsafeUrl));
+}
+function \u0275\u0275sanitizeResourceUrl(unsafeResourceUrl) {
+  const sanitizer = getSanitizer();
+  if (sanitizer) {
+    return trustedScriptURLFromStringBypass(sanitizer.sanitize(SecurityContext.RESOURCE_URL, unsafeResourceUrl) || "");
+  }
+  if (allowSanitizationBypassAndThrow(unsafeResourceUrl, "ResourceURL")) {
+    return trustedScriptURLFromStringBypass(unwrapSafeValue(unsafeResourceUrl));
+  }
+  throw new RuntimeError(904, ngDevMode && `unsafe value used in a resource URL context (see ${XSS_SECURITY_URL})`);
+}
+function \u0275\u0275sanitizeScript(unsafeScript) {
+  const sanitizer = getSanitizer();
+  if (sanitizer) {
+    return trustedScriptFromStringBypass(sanitizer.sanitize(SecurityContext.SCRIPT, unsafeScript) || "");
+  }
+  if (allowSanitizationBypassAndThrow(unsafeScript, "Script")) {
+    return trustedScriptFromStringBypass(unwrapSafeValue(unsafeScript));
+  }
+  throw new RuntimeError(905, ngDevMode && "unsafe value used in a script context");
+}
+function \u0275\u0275trustConstantHtml(html) {
+  if (ngDevMode && (!Array.isArray(html) || !Array.isArray(html.raw) || html.length !== 1)) {
+    throw new Error(`Unexpected interpolation in trusted HTML constant: ${html.join("?")}`);
+  }
+  return trustedHTMLFromString(html[0]);
+}
+function \u0275\u0275trustConstantResourceUrl(url) {
+  if (ngDevMode && (!Array.isArray(url) || !Array.isArray(url.raw) || url.length !== 1)) {
+    throw new Error(`Unexpected interpolation in trusted URL constant: ${url.join("?")}`);
+  }
+  return trustedScriptURLFromString(url[0]);
+}
+var RESOURCE_MAP = {
+  "embed": {
+    "src": true
+  },
+  "frame": {
+    "src": true
+  },
+  "iframe": {
+    "src": true
+  },
+  "media": {
+    "src": true
+  },
+  "base": {
+    "href": true
+  },
+  "link": {
+    "href": true
+  },
+  "object": {
+    "data": true,
+    "codebase": true
+  }
+};
+function getUrlSanitizer(tag, prop) {
+  const isResource = RESOURCE_MAP[tag.toLowerCase()]?.[prop.toLowerCase()] === true;
+  return isResource ? \u0275\u0275sanitizeResourceUrl : \u0275\u0275sanitizeUrl;
+}
+function \u0275\u0275sanitizeUrlOrResourceUrl(unsafeUrl, tag, prop) {
+  return getUrlSanitizer(tag, prop)(unsafeUrl);
+}
+function validateAgainstEventProperties(name) {
+  if (name.toLowerCase().startsWith("on")) {
+    const errorMessage = `Binding to event property '${name}' is disallowed for security reasons, please use (${name.slice(2)})=...
+If '${name}' is a directive input, make sure the directive is imported by the current module.`;
+    throw new RuntimeError(306, errorMessage);
+  }
+}
+function getSanitizer() {
+  const lView = getLView();
+  return lView && lView[ENVIRONMENT].sanitizer;
+}
+var SECURITY_SENSITIVE_ATTRIBUTE_NAMES = /* @__PURE__ */ new Set(["href", "xlink:href"]);
+var SVG_ANIMATION_ATTRIBUTE_NAME_CANDIDATES = ["attributeName", "attributename"];
+var SECURITY_SENSITIVE_ELEMENTS = {
+  "iframe": {
+    "sandbox": true,
+    "allow": true,
+    "allowfullscreen": true,
+    "referrerpolicy": true,
+    "csp": true,
+    "fetchpriority": true
+  },
+  ":svg:animate": {
+    "attributename": true,
+    "to": SECURITY_SENSITIVE_ATTRIBUTE_NAMES,
+    "values": SECURITY_SENSITIVE_ATTRIBUTE_NAMES,
+    "from": SECURITY_SENSITIVE_ATTRIBUTE_NAMES
+  },
+  ":svg:set": {
+    "attributename": true,
+    "to": SECURITY_SENSITIVE_ATTRIBUTE_NAMES
+  },
+  ":svg:animatemotion": {
+    "attributename": true
+  },
+  ":svg:animatetransform": {
+    "attributename": true
+  }
+};
+function \u0275\u0275validateAttribute(value, tagName, attributeName) {
+  const lowerCaseTagName = tagName.toLowerCase();
+  const lowerCaseAttrName = attributeName.toLowerCase();
+  const index = getSelectedIndex();
+  const tNode = index === -1 ? null : getSelectedTNode();
+  if (tNode && tNode.type !== 2) {
+    return value;
+  }
+  const fullTagName = lowerCaseTagName[0] !== ":" && tNode?.namespace ? `:${tNode.namespace}:${lowerCaseTagName}` : lowerCaseTagName;
+  const validationConfig = SECURITY_SENSITIVE_ELEMENTS[fullTagName]?.[lowerCaseAttrName];
+  if (!validationConfig) {
+    return value;
+  }
+  const lView = getLView();
+  if (tNode && lowerCaseTagName === "iframe") {
+    const element = getNativeByTNode(tNode, lView);
+    enforceIframeSecurity(element);
+  }
+  const displayTagName = tagName[0] === ":" ? tagName.split(":").pop() : tagName;
+  if (typeof validationConfig !== "boolean") {
+    if (!tNode) {
+      const errorMessage2 = ngDevMode && `Angular has detected that the \`${attributeName}\` was applied as a binding to the <${tagName}> element. For security reasons, the \`${attributeName}\` can be set on the <${tagName}> element as a static attribute only. 
+To fix this, switch the \`${attributeName}\` binding to a static attribute in a template or in host bindings section.`;
+      throw new RuntimeError(-910, errorMessage2);
+    }
+    const element = getNativeByTNode(tNode, lView);
+    const attributeNameValue = getSecuritySensitiveSVGAnimationAttributeName(element, validationConfig);
+    if (attributeNameValue) {
+      const errorMessage2 = ngDevMode && `Angular has detected that the \`${attributeName}\` was applied as a binding to the <${displayTagName}> element${getTemplateLocationDetails(lView)}. For security reasons, the \`${attributeName}\` can be set on the <${displayTagName}> element as a static attribute only when the "attributeName" is set to '${attributeNameValue}'. 
+To fix this, switch the \`${attributeNameValue}\` binding to a static attribute in a template or in host bindings section.`;
+      throw new RuntimeError(-910, errorMessage2);
+    }
+    return value;
+  }
+  const errorMessage = ngDevMode && `Angular has detected that the \`${attributeName}\` was applied as a binding to the <${displayTagName}> element${tNode ? getTemplateLocationDetails(lView) : ""}. For security reasons, the \`${attributeName}\` can be set on the <${displayTagName}> element as a static attribute only. 
+To fix this, switch the \`${attributeName}\` binding to a static attribute in a template or in host bindings section.`;
+  throw new RuntimeError(-910, errorMessage);
+}
+function getSecuritySensitiveSVGAnimationAttributeName(element, validationConfig) {
+  for (const attributeName of SVG_ANIMATION_ATTRIBUTE_NAME_CANDIDATES) {
+    const attributeNameValue = element.getAttribute(attributeName);
+    if (attributeNameValue !== null && validationConfig.has(attributeNameValue.toLowerCase())) {
+      return attributeNameValue;
+    }
+  }
+  return null;
+}
+var NG_REFLECT_ATTRS_FLAG_DEFAULT = false;
+var NG_REFLECT_ATTRS_FLAG = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "NG_REFLECT_FLAG" : "", {
+  factory: () => NG_REFLECT_ATTRS_FLAG_DEFAULT
+});
+function normalizeDebugBindingName(name) {
+  name = camelCaseToDashCase(name.replace(/[$@]/g, "_"));
+  return `ng-reflect-${name}`;
+}
+var CAMEL_CASE_REGEXP = /([A-Z])/g;
+function camelCaseToDashCase(input2) {
+  return input2.replace(CAMEL_CASE_REGEXP, (...m) => "-" + m[1].toLowerCase());
+}
+function normalizeDebugBindingValue(value) {
+  try {
+    return value != null ? value.toString().slice(0, 30) : value;
+  } catch (e) {
+    return "[ERROR] Exception while trying to serialize the value";
+  }
+}
+function \u0275\u0275resolveWindow(element) {
+  return element.ownerDocument.defaultView;
+}
+function \u0275\u0275resolveDocument(element) {
+  return element.ownerDocument;
+}
+function \u0275\u0275resolveBody(element) {
+  return element.ownerDocument.body;
+}
+var INTERPOLATION_DELIMITER = `\uFFFD`;
+function maybeUnwrapFn(value) {
+  if (value instanceof Function) {
+    return value();
+  } else {
+    return value;
+  }
+}
+var VALUE_STRING_LENGTH_LIMIT = 200;
+function assertStandaloneComponentType(type) {
+  assertComponentDef(type);
+  const componentDef = getComponentDef(type);
+  if (!componentDef.standalone) {
+    throw new RuntimeError(907, `The ${stringifyForError(type)} component is not marked as standalone, but Angular expects to have a standalone component here. Please make sure the ${stringifyForError(type)} component does not have the \`standalone: false\` flag in the decorator.`);
+  }
+}
+function assertComponentDef(type) {
+  if (!getComponentDef(type)) {
+    throw new RuntimeError(906, `The ${stringifyForError(type)} is not an Angular component, make sure it has the \`@Component\` decorator.`);
+  }
+}
+function throwMultipleComponentError(tNode, first2, second) {
+  throw new RuntimeError(-300, `Multiple components match node with tagname ${tNode.value}: ${stringifyForError(first2)} and ${stringifyForError(second)}`);
+}
+function throwErrorIfNoChangesMode(creationMode, oldValue, currValue, propName, lView) {
+  const hostComponentDef = getDeclarationComponentDef(lView);
+  const componentClassName = hostComponentDef?.type?.name;
+  const field = propName ? ` for '${propName}'` : "";
+  let msg = `ExpressionChangedAfterItHasBeenCheckedError: Expression has changed after it was checked. Previous value${field}: '${formatValue(oldValue)}'. Current value: '${formatValue(currValue)}'.${componentClassName ? ` Expression location: ${componentClassName} component` : ""}`;
+  if (creationMode) {
+    msg += ` It seems like the view has been created after its parent and its children have been dirty checked. Has it been created in a change detection hook?`;
+  }
+  throw new RuntimeError(-100, msg);
+}
+function formatValue(value) {
+  let strValue = String(value);
+  try {
+    if (Array.isArray(value) || strValue === "[object Object]") {
+      strValue = JSON.stringify(value);
+    }
+  } catch (error) {
+  }
+  return strValue.length > VALUE_STRING_LENGTH_LIMIT ? strValue.substring(0, VALUE_STRING_LENGTH_LIMIT) + "\u2026" : strValue;
+}
+function constructDetailsForInterpolation(lView, rootIndex, expressionIndex, meta, changedValue) {
+  const [propName, prefix, ...chunks] = meta.split(INTERPOLATION_DELIMITER);
+  let oldValue = prefix, newValue = prefix;
+  for (let i = 0; i < chunks.length; i++) {
+    const slotIdx = rootIndex + i;
+    oldValue += `${lView[slotIdx]}${chunks[i]}`;
+    newValue += `${slotIdx === expressionIndex ? changedValue : lView[slotIdx]}${chunks[i]}`;
+  }
+  return {
+    propName,
+    oldValue,
+    newValue
+  };
+}
+function getExpressionChangedErrorDetails(lView, bindingIndex, oldValue, newValue) {
+  const tData = lView[TVIEW].data;
+  const metadata = tData[bindingIndex];
+  if (typeof metadata === "string") {
+    if (metadata.indexOf(INTERPOLATION_DELIMITER) > -1) {
+      return constructDetailsForInterpolation(lView, bindingIndex, bindingIndex, metadata, newValue);
+    }
+    return {
+      propName: metadata,
+      oldValue,
+      newValue
+    };
+  }
+  if (metadata === null) {
+    let idx = bindingIndex - 1;
+    while (typeof tData[idx] !== "string" && tData[idx + 1] === null) {
+      idx--;
+    }
+    const meta = tData[idx];
+    if (typeof meta === "string") {
+      const matches = meta.match(new RegExp(INTERPOLATION_DELIMITER, "g"));
+      if (matches && matches.length - 1 > bindingIndex - idx) {
+        return constructDetailsForInterpolation(lView, idx, bindingIndex, meta, newValue);
+      }
+    }
+  }
+  return {
+    propName: void 0,
+    oldValue,
+    newValue
+  };
+}
+function classIndexOf(className, classToSearch, startingIndex) {
+  ngDevMode && assertNotEqual(classToSearch, "", 'can not look for "" string.');
+  let end = className.length;
+  while (true) {
+    const foundIndex = className.indexOf(classToSearch, startingIndex);
+    if (foundIndex === -1) return foundIndex;
+    if (foundIndex === 0 || className.charCodeAt(foundIndex - 1) <= 32) {
+      const length = classToSearch.length;
+      if (foundIndex + length === end || className.charCodeAt(foundIndex + length) <= 32) {
+        return foundIndex;
+      }
+    }
+    startingIndex = foundIndex + 1;
+  }
+}
+var NG_TEMPLATE_SELECTOR = "ng-template";
+function isCssClassMatching(tNode, attrs, cssClassToMatch, isProjectionMode) {
+  ngDevMode && assertEqual(cssClassToMatch, cssClassToMatch.toLowerCase(), "Class name expected to be lowercase.");
+  let i = 0;
+  if (isProjectionMode) {
+    for (; i < attrs.length && typeof attrs[i] === "string"; i += 2) {
+      if (attrs[i] === "class" && classIndexOf(attrs[i + 1].toLowerCase(), cssClassToMatch, 0) !== -1) {
+        return true;
+      }
+    }
+  } else if (isInlineTemplate(tNode)) {
+    return false;
+  }
+  i = attrs.indexOf(1, i);
+  if (i > -1) {
+    let item;
+    while (++i < attrs.length && typeof (item = attrs[i]) === "string") {
+      if (item.toLowerCase() === cssClassToMatch) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function isInlineTemplate(tNode) {
+  return tNode.type === 4 && tNode.value !== NG_TEMPLATE_SELECTOR;
+}
+function hasTagAndTypeMatch(tNode, currentSelector, isProjectionMode) {
+  const tagNameToCompare = tNode.type === 4 && !isProjectionMode ? NG_TEMPLATE_SELECTOR : tNode.value;
+  return currentSelector === tagNameToCompare;
+}
+function isNodeMatchingSelector(tNode, selector, isProjectionMode) {
+  ngDevMode && assertDefined(selector[0], "Selector should have a tag name");
+  let mode = 4;
+  const nodeAttrs = tNode.attrs;
+  const nameOnlyMarkerIdx = nodeAttrs !== null ? getNameOnlyMarkerIndex(nodeAttrs) : 0;
+  let skipToNextSelector = false;
+  for (let i = 0; i < selector.length; i++) {
+    const current = selector[i];
+    if (typeof current === "number") {
+      if (!skipToNextSelector && !isPositive(mode) && !isPositive(current)) {
+        return false;
+      }
+      if (skipToNextSelector && isPositive(current)) continue;
+      skipToNextSelector = false;
+      mode = current | mode & 1;
+      continue;
+    }
+    if (skipToNextSelector) continue;
+    if (mode & 4) {
+      mode = 2 | mode & 1;
+      if (current !== "" && !hasTagAndTypeMatch(tNode, current, isProjectionMode) || current === "" && selector.length === 1) {
+        if (isPositive(mode)) return false;
+        skipToNextSelector = true;
+      }
+    } else if (mode & 8) {
+      if (nodeAttrs === null || !isCssClassMatching(tNode, nodeAttrs, current, isProjectionMode)) {
+        if (isPositive(mode)) return false;
+        skipToNextSelector = true;
+      }
+    } else {
+      const selectorAttrValue = selector[++i];
+      const attrIndexInNode = findAttrIndexInNode(current, nodeAttrs, isInlineTemplate(tNode), isProjectionMode);
+      if (attrIndexInNode === -1) {
+        if (isPositive(mode)) return false;
+        skipToNextSelector = true;
+        continue;
+      }
+      if (selectorAttrValue !== "") {
+        let nodeAttrValue;
+        if (attrIndexInNode > nameOnlyMarkerIdx) {
+          nodeAttrValue = "";
+        } else {
+          ngDevMode && assertNotEqual(nodeAttrs[attrIndexInNode], 0, "We do not match directives on namespaced attributes");
+          nodeAttrValue = nodeAttrs[attrIndexInNode + 1].toLowerCase();
+        }
+        if (mode & 2 && selectorAttrValue !== nodeAttrValue) {
+          if (isPositive(mode)) return false;
+          skipToNextSelector = true;
+        }
+      }
+    }
+  }
+  return isPositive(mode) || skipToNextSelector;
+}
+function isPositive(mode) {
+  return (mode & 1) === 0;
+}
+function findAttrIndexInNode(name, attrs, isInlineTemplate2, isProjectionMode) {
+  if (attrs === null) return -1;
+  let i = 0;
+  if (isProjectionMode || !isInlineTemplate2) {
+    let bindingsMode = false;
+    while (i < attrs.length) {
+      const maybeAttrName = attrs[i];
+      if (maybeAttrName === name) {
+        return i;
+      } else if (maybeAttrName === 3 || maybeAttrName === 6) {
+        bindingsMode = true;
+      } else if (maybeAttrName === 1 || maybeAttrName === 2) {
+        let value = attrs[++i];
+        while (typeof value === "string") {
+          value = attrs[++i];
+        }
+        continue;
+      } else if (maybeAttrName === 4) {
+        break;
+      } else if (maybeAttrName === 0) {
+        i += 4;
+        continue;
+      }
+      i += bindingsMode ? 1 : 2;
+    }
+    return -1;
+  } else {
+    return matchTemplateAttribute(attrs, name);
+  }
+}
+function isNodeMatchingSelectorList(tNode, selector, isProjectionMode = false) {
+  for (let i = 0; i < selector.length; i++) {
+    if (isNodeMatchingSelector(tNode, selector[i], isProjectionMode)) {
+      return true;
+    }
+  }
+  return false;
+}
+function getProjectAsAttrValue(tNode) {
+  const nodeAttrs = tNode.attrs;
+  if (nodeAttrs != null) {
+    const ngProjectAsAttrIdx = nodeAttrs.indexOf(5);
+    if ((ngProjectAsAttrIdx & 1) === 0) {
+      return nodeAttrs[ngProjectAsAttrIdx + 1];
+    }
+  }
+  return null;
+}
+function getNameOnlyMarkerIndex(nodeAttrs) {
+  for (let i = 0; i < nodeAttrs.length; i++) {
+    const nodeAttr = nodeAttrs[i];
+    if (isNameOnlyAttributeMarker(nodeAttr)) {
+      return i;
+    }
+  }
+  return nodeAttrs.length;
+}
+function matchTemplateAttribute(attrs, name) {
+  let i = attrs.indexOf(4);
+  if (i > -1) {
+    i++;
+    while (i < attrs.length) {
+      const attr = attrs[i];
+      if (typeof attr === "number") return -1;
+      if (attr === name) return i;
+      i++;
+    }
+  }
+  return -1;
+}
+function isSelectorInSelectorList(selector, list) {
+  selectorListLoop: for (let i = 0; i < list.length; i++) {
+    const currentSelectorInList = list[i];
+    if (selector.length !== currentSelectorInList.length) {
+      continue;
+    }
+    for (let j = 0; j < selector.length; j++) {
+      if (selector[j] !== currentSelectorInList[j]) {
+        continue selectorListLoop;
+      }
+    }
+    return true;
+  }
+  return false;
+}
+function maybeWrapInNotSelector(isNegativeMode, chunk) {
+  return isNegativeMode ? ":not(" + chunk.trim() + ")" : chunk;
+}
+function stringifyCSSSelector(selector) {
+  let result = selector[0];
+  let i = 1;
+  let mode = 2;
+  let currentChunk = "";
+  let isNegativeMode = false;
+  while (i < selector.length) {
+    let valueOrMarker = selector[i];
+    if (typeof valueOrMarker === "string") {
+      if (mode & 2) {
+        const attrValue = selector[++i];
+        currentChunk += "[" + valueOrMarker + (attrValue.length > 0 ? '="' + attrValue + '"' : "") + "]";
+      } else if (mode & 8) {
+        currentChunk += "." + valueOrMarker;
+      } else if (mode & 4) {
+        currentChunk += " " + valueOrMarker;
+      }
+    } else {
+      if (currentChunk !== "" && !isPositive(valueOrMarker)) {
+        result += maybeWrapInNotSelector(isNegativeMode, currentChunk);
+        currentChunk = "";
+      }
+      mode = valueOrMarker;
+      isNegativeMode = isNegativeMode || !isPositive(mode);
+    }
+    i++;
+  }
+  if (currentChunk !== "") {
+    result += maybeWrapInNotSelector(isNegativeMode, currentChunk);
+  }
+  return result;
+}
+function stringifyCSSSelectorList(selectorList) {
+  return selectorList.map(stringifyCSSSelector).join(",");
+}
+function extractAttrsAndClassesFromSelector(selector) {
+  const attrs = [];
+  const classes = [];
+  let i = 1;
+  let mode = 2;
+  while (i < selector.length) {
+    let valueOrMarker = selector[i];
+    if (typeof valueOrMarker === "string") {
+      if (mode === 2) {
+        if (valueOrMarker !== "") {
+          attrs.push(valueOrMarker, selector[++i]);
+        }
+      } else if (mode === 8) {
+        classes.push(valueOrMarker);
+      }
+    } else {
+      if (!isPositive(mode)) break;
+      mode = valueOrMarker;
+    }
+    i++;
+  }
+  if (classes.length) {
+    attrs.push(1, ...classes);
+  }
+  return attrs;
+}
+var NO_CHANGE = typeof ngDevMode === "undefined" || ngDevMode ? {
+  __brand__: "NO_CHANGE"
+} : {};
+function createTView(type, declTNode, templateFn, decls, vars, directives, pipes, viewQuery, schemas, constsOrFactory, ssrId) {
+  const bindingStartIndex = HEADER_OFFSET + decls;
+  const initialViewLength = bindingStartIndex + vars;
+  const blueprint = createViewBlueprint(bindingStartIndex, initialViewLength);
+  const consts = typeof constsOrFactory === "function" ? constsOrFactory() : constsOrFactory;
+  const tView = blueprint[TVIEW] = {
+    type,
+    blueprint,
+    template: templateFn,
+    queries: null,
+    viewQuery,
+    declTNode,
+    data: blueprint.slice().fill(null, bindingStartIndex),
+    bindingStartIndex,
+    expandoStartIndex: initialViewLength,
+    hostBindingOpCodes: null,
+    firstCreatePass: true,
+    firstUpdatePass: true,
+    staticViewQueries: false,
+    staticContentQueries: false,
+    preOrderHooks: null,
+    preOrderCheckHooks: null,
+    contentHooks: null,
+    contentCheckHooks: null,
+    viewHooks: null,
+    viewCheckHooks: null,
+    destroyHooks: null,
+    cleanup: null,
+    contentQueries: null,
+    components: null,
+    directiveRegistry: typeof directives === "function" ? directives() : directives,
+    pipeRegistry: typeof pipes === "function" ? pipes() : pipes,
+    firstChild: null,
+    schemas,
+    consts,
+    incompleteFirstPass: false,
+    ssrId
+  };
+  if (ngDevMode) {
+    Object.seal(tView);
+  }
+  return tView;
+}
+function createViewBlueprint(bindingStartIndex, initialViewLength) {
+  const blueprint = [];
+  for (let i = 0; i < initialViewLength; i++) {
+    blueprint.push(i < bindingStartIndex ? null : NO_CHANGE);
+  }
+  return blueprint;
+}
+function getOrCreateComponentTView(def) {
+  const tView = def.tView;
+  if (tView === null || tView.incompleteFirstPass) {
+    const declTNode = null;
+    return def.tView = createTView(1, declTNode, def.template, def.decls, def.vars, def.directiveDefs, def.pipeDefs, def.viewQuery, def.schemas, def.consts, def.id);
+  }
+  return tView;
+}
+function createLView(parentLView, tView, context2, flags, host, tHostNode, environment, renderer, injector, embeddedViewInjector, hydrationInfo) {
+  const lView = tView.blueprint.slice();
+  lView[HOST] = host;
+  lView[FLAGS] = flags | 4 | 128 | 8 | 64 | 1024;
+  if (embeddedViewInjector !== null || parentLView && parentLView[FLAGS] & 2048) {
+    lView[FLAGS] |= 2048;
+  }
+  resetPreOrderHookFlags(lView);
+  ngDevMode && tView.declTNode && parentLView && assertTNodeForLView(tView.declTNode, parentLView);
+  lView[PARENT] = lView[DECLARATION_VIEW] = parentLView;
+  lView[CONTEXT] = context2;
+  lView[ENVIRONMENT] = environment || parentLView && parentLView[ENVIRONMENT];
+  ngDevMode && assertDefined(lView[ENVIRONMENT], "LViewEnvironment is required");
+  lView[RENDERER] = renderer || parentLView && parentLView[RENDERER];
+  ngDevMode && assertDefined(lView[RENDERER], "Renderer is required");
+  lView[INJECTOR] = injector || parentLView && parentLView[INJECTOR] || null;
+  lView[T_HOST] = tHostNode;
+  lView[ID] = getUniqueLViewId();
+  lView[HYDRATION] = hydrationInfo;
+  lView[EMBEDDED_VIEW_INJECTOR] = embeddedViewInjector;
+  ngDevMode && assertEqual(tView.type == 2 ? parentLView !== null : true, true, "Embedded views must have parentLView");
+  lView[DECLARATION_COMPONENT_VIEW] = tView.type == 2 ? parentLView[DECLARATION_COMPONENT_VIEW] : lView;
+  return lView;
+}
+function createComponentLView(lView, hostTNode, def) {
+  const native = getNativeByTNode(hostTNode, lView);
+  const tView = getOrCreateComponentTView(def);
+  const rendererFactory = lView[ENVIRONMENT].rendererFactory;
+  const componentView = addToEndOfViewTree(lView, createLView(lView, tView, null, getInitialLViewFlagsFromDef(def), native, hostTNode, null, rendererFactory.createRenderer(native, def), null, null, null));
+  return lView[hostTNode.index] = componentView;
+}
+function getInitialLViewFlagsFromDef(def) {
+  let flags = 16;
+  if (def.signals) {
+    flags = 4096;
+  } else if (def.onPush) {
+    flags = 64;
+  }
+  return flags;
+}
+function allocExpando(tView, lView, numSlotsToAlloc, initialValue) {
+  if (numSlotsToAlloc === 0) return -1;
+  if (ngDevMode) {
+    assertFirstCreatePass(tView);
+    assertSame(tView, lView[TVIEW], "`LView` must be associated with `TView`!");
+    assertEqual(tView.data.length, lView.length, "Expecting LView to be same size as TView");
+    assertEqual(tView.data.length, tView.blueprint.length, "Expecting Blueprint to be same size as TView");
+    assertFirstUpdatePass(tView);
+  }
+  const allocIdx = lView.length;
+  for (let i = 0; i < numSlotsToAlloc; i++) {
+    lView.push(initialValue);
+    tView.blueprint.push(initialValue);
+    tView.data.push(null);
+  }
+  return allocIdx;
+}
+function addToEndOfViewTree(lView, lViewOrLContainer) {
+  if (lView[CHILD_HEAD]) {
+    lView[CHILD_TAIL][NEXT] = lViewOrLContainer;
+  } else {
+    lView[CHILD_HEAD] = lViewOrLContainer;
+  }
+  lView[CHILD_TAIL] = lViewOrLContainer;
+  return lViewOrLContainer;
+}
+function \u0275\u0275advance(delta = 1) {
+  ngDevMode && assertGreaterThan(delta, 0, "Can only advance forward");
+  selectIndexInternal(getTView(), getLView(), getSelectedIndex() + delta, !!ngDevMode && isInCheckNoChangesMode());
+}
+function selectIndexInternal(tView, lView, index, checkNoChangesMode) {
+  ngDevMode && assertIndexInDeclRange(lView[TVIEW], index);
+  if (!checkNoChangesMode) {
+    const hooksInitPhaseCompleted = (lView[FLAGS] & 3) === 3;
+    if (hooksInitPhaseCompleted) {
+      const preOrderCheckHooks = tView.preOrderCheckHooks;
+      if (preOrderCheckHooks !== null) {
+        executeCheckHooks(lView, preOrderCheckHooks, index);
+      }
+    } else {
+      const preOrderHooks = tView.preOrderHooks;
+      if (preOrderHooks !== null) {
+        executeInitAndCheckHooks(lView, preOrderHooks, 0, index);
+      }
+    }
+  }
+  setSelectedIndex(index);
+}
+var InputFlags;
+(function(InputFlags2) {
+  InputFlags2[InputFlags2["None"] = 0] = "None";
+  InputFlags2[InputFlags2["SignalBased"] = 1] = "SignalBased";
+  InputFlags2[InputFlags2["HasDecoratorInputTransform"] = 2] = "HasDecoratorInputTransform";
+})(InputFlags || (InputFlags = {}));
+function writeToDirectiveInput(def, instance, publicName, value) {
+  const prevConsumer = setActiveConsumer(null);
+  try {
+    if (ngDevMode) {
+      if (!def.inputs.hasOwnProperty(publicName)) {
+        throw new Error(`ASSERTION ERROR: Directive ${def.type.name} does not have an input with a public name of "${publicName}"`);
+      }
+      if (instance instanceof NodeInjectorFactory) {
+        throw new Error(`ASSERTION ERROR: Cannot write input to factory for type ${def.type.name}. Directive has not been created yet.`);
+      }
+    }
+    const [privateName, flags, transform] = def.inputs[publicName];
+    let inputSignalNode = null;
+    if ((flags & InputFlags.SignalBased) !== 0) {
+      const field = instance[privateName];
+      inputSignalNode = field[SIGNAL];
+    }
+    if (inputSignalNode !== null && inputSignalNode.transformFn !== void 0) {
+      value = inputSignalNode.transformFn(value);
+    } else if (transform !== null) {
+      value = transform.call(instance, value);
+    }
+    if (def.setInput !== null) {
+      def.setInput(instance, inputSignalNode, value, publicName, privateName);
+    } else {
+      applyValueToInputField(instance, inputSignalNode, privateName, value);
+    }
+  } finally {
+    setActiveConsumer(prevConsumer);
+  }
+}
+var RendererStyleFlags2;
+(function(RendererStyleFlags22) {
+  RendererStyleFlags22[RendererStyleFlags22["Important"] = 1] = "Important";
+  RendererStyleFlags22[RendererStyleFlags22["DashCase"] = 2] = "DashCase";
+})(RendererStyleFlags2 || (RendererStyleFlags2 = {}));
+var _icuContainerIterate;
+function icuContainerIterate(tIcuContainerNode, lView) {
+  return _icuContainerIterate(tIcuContainerNode, lView);
+}
+function ensureIcuContainerVisitorLoaded(loader) {
+  if (_icuContainerIterate === void 0) {
+    _icuContainerIterate = loader();
+  }
+}
+var ANIMATIONS_DISABLED = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "AnimationsDisabled" : "", {
+  factory: () => false
+});
+var MAX_ANIMATION_TIMEOUT = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "MaxAnimationTimeout" : "", {
+  factory: () => MAX_ANIMATION_TIMEOUT_DEFAULT
+});
+var MAX_ANIMATION_TIMEOUT_DEFAULT = 4e3;
+var DEFAULT_ANIMATIONS_DISABLED = false;
+var areAnimationSupported = typeof document !== "undefined" && typeof document?.documentElement?.getAnimations === "function";
+function areAnimationsDisabled(lView) {
+  const injector = lView[INJECTOR];
+  return injector.get(ANIMATIONS_DISABLED, DEFAULT_ANIMATIONS_DISABLED);
+}
+function assertAnimationTypes(value, instruction) {
+  if (value == null || typeof value !== "string" && typeof value !== "function") {
+    throw new RuntimeError(650, `'${instruction}' value must be a string of CSS classes or an animation function, got ${stringify(value)}`);
+  }
+}
+function assertElementNodes(nativeElement, instruction) {
+  if (nativeElement.nodeType !== Node.ELEMENT_NODE) {
+    throw new RuntimeError(650, `'${instruction}' can only be used on an element node, got ${stringify(nativeElement.nodeType)}`);
+  }
+}
+function trackEnterClasses(el, classList, cleanupFns) {
+  const elementData = enterClassMap.get(el);
+  if (elementData) {
+    for (const klass of classList) {
+      elementData.classList.push(klass);
+    }
+    for (const fn of cleanupFns) {
+      elementData.cleanupFns.push(fn);
+    }
+  } else {
+    enterClassMap.set(el, {
+      classList,
+      cleanupFns
+    });
+  }
+}
+function cleanupEnterClassData(element) {
+  const elementData = enterClassMap.get(element);
+  if (elementData) {
+    for (const fn of elementData.cleanupFns) {
+      fn();
+    }
+    enterClassMap.delete(element);
+  }
+  longestAnimations.delete(element);
+}
+var noOpAnimationComplete = () => {
+};
+var enterClassMap = /* @__PURE__ */ new WeakMap();
+var longestAnimations = /* @__PURE__ */ new WeakMap();
+var leavingNodes = /* @__PURE__ */ new WeakMap();
+var reusedNodes = /* @__PURE__ */ new WeakSet();
+function clearLeavingNodes(tNode, el) {
+  const nodes = leavingNodes.get(tNode);
+  if (nodes && nodes.length > 0) {
+    const ix = nodes.findIndex((node) => node === el);
+    if (ix > -1) nodes.splice(ix, 1);
+  }
+  if (nodes?.length === 0) {
+    leavingNodes.delete(tNode);
+  }
+}
+function cancelLeavingNodes(tNode, newElement) {
+  const nodes = leavingNodes.get(tNode);
+  if (!nodes || nodes.length === 0) return;
+  const newParent = newElement.parentNode;
+  const prevSibling = newElement.previousSibling;
+  for (let i = nodes.length - 1; i >= 0; i--) {
+    const leavingEl = nodes[i];
+    const leavingParent = leavingEl.parentNode;
+    if (leavingEl === newElement) {
+      nodes.splice(i, 1);
+      reusedNodes.add(leavingEl);
+      leavingEl.dispatchEvent(new CustomEvent("animationend", {
+        detail: {
+          cancel: true
+        }
+      }));
+    } else if (prevSibling && leavingEl === prevSibling || leavingParent && newParent && leavingParent !== newParent) {
+      nodes.splice(i, 1);
+      leavingEl.dispatchEvent(new CustomEvent("animationend", {
+        detail: {
+          cancel: true
+        }
+      }));
+      leavingEl.parentNode?.removeChild(leavingEl);
+    }
+  }
+}
+function trackLeavingNodes(tNode, el) {
+  const nodes = leavingNodes.get(tNode);
+  if (nodes) {
+    if (!nodes.includes(el)) {
+      nodes.push(el);
+    }
+  } else {
+    leavingNodes.set(tNode, [el]);
+  }
+}
+function getLViewEnterAnimations(lView) {
+  const animationData = lView[ANIMATIONS] ??= {};
+  return animationData.enter ??= /* @__PURE__ */ new Map();
+}
+function getLViewLeaveAnimations(lView) {
+  const animationData = lView[ANIMATIONS] ??= {};
+  return animationData.leave ??= /* @__PURE__ */ new Map();
+}
+function getClassListFromValue(value) {
+  const classes = typeof value === "function" ? value() : value;
+  let classList = Array.isArray(classes) ? classes : null;
+  if (typeof classes === "string") {
+    classList = classes.trim().split(/\s+/).filter((k) => k);
+  }
+  return classList;
+}
+function cancelAnimationsIfRunning(element, renderer) {
+  if (!areAnimationSupported) return;
+  const elementData = enterClassMap.get(element);
+  if (elementData && elementData.classList.length > 0 && elementHasClassList(element, elementData.classList)) {
+    for (const klass of elementData.classList) {
+      renderer.removeClass(element, klass);
+    }
+  }
+  cleanupEnterClassData(element);
+}
+function elementHasClassList(element, classList) {
+  for (const className of classList) {
+    if (element.classList.contains(className)) return true;
+  }
+  return false;
+}
+function getEventTarget(event) {
+  return event.composedPath ? event.composedPath()[0] : event.target;
+}
+function isLongestAnimation(event, nativeElement) {
+  const longestAnimation = longestAnimations.get(nativeElement);
+  if (longestAnimation === void 0) return true;
+  return nativeElement === getEventTarget(event) && (longestAnimation.animationName !== void 0 && event.animationName === longestAnimation.animationName || longestAnimation.propertyName !== void 0 && (longestAnimation.propertyName === "all" || event.propertyName === longestAnimation.propertyName));
+}
+function addAnimationToLView(animations, tNode, fn) {
+  const nodeAnimations = animations.get(tNode.index) ?? {
+    animateFns: []
+  };
+  nodeAnimations.animateFns.push(fn);
+  animations.set(tNode.index, nodeAnimations);
+}
+function cleanupAfterLeaveAnimations(resolvers, cleanupFns) {
+  if (resolvers) {
+    for (const fn of resolvers) {
+      fn();
+    }
+  }
+  for (const fn of cleanupFns) {
+    fn();
+  }
+}
+function clearLViewNodeAnimationResolvers(lView, tNode) {
+  const nodeAnimations = getLViewLeaveAnimations(lView).get(tNode.index);
+  if (nodeAnimations) nodeAnimations.resolvers = void 0;
+}
+function leaveAnimationFunctionCleanup(lView, tNode, nativeElement, resolvers, cleanupFns) {
+  clearLeavingNodes(tNode, nativeElement);
+  cleanupAfterLeaveAnimations(resolvers, cleanupFns);
+  clearLViewNodeAnimationResolvers(lView, tNode);
+}
+function parseCssTimeUnitsToMs(value) {
+  if (!value) return 0;
+  const multiplier = value.toLowerCase().indexOf("ms") > -1 ? 1 : 1e3;
+  return parseFloat(value) * multiplier;
+}
+function parseCssPropertyValue(computedStyle, name) {
+  const value = computedStyle.getPropertyValue(name);
+  return value.split(",").map((part) => part.trim());
+}
+function getLongestComputedTransition(computedStyle) {
+  const transitionedProperties = parseCssPropertyValue(computedStyle, "transition-property");
+  const rawDurations = parseCssPropertyValue(computedStyle, "transition-duration");
+  const rawDelays = parseCssPropertyValue(computedStyle, "transition-delay");
+  const longest = {
+    propertyName: "",
+    duration: 0,
+    animationName: void 0
+  };
+  for (let i = 0; i < transitionedProperties.length; i++) {
+    const duration = parseCssTimeUnitsToMs(rawDelays[i]) + parseCssTimeUnitsToMs(rawDurations[i]);
+    if (duration > longest.duration) {
+      longest.propertyName = transitionedProperties[i];
+      longest.duration = duration;
+    }
+  }
+  return longest;
+}
+function getLongestComputedAnimation(computedStyle) {
+  const rawNames = parseCssPropertyValue(computedStyle, "animation-name");
+  const rawDelays = parseCssPropertyValue(computedStyle, "animation-delay");
+  const rawDurations = parseCssPropertyValue(computedStyle, "animation-duration");
+  const rawIterationCounts = parseCssPropertyValue(computedStyle, "animation-iteration-count");
+  const longest = {
+    animationName: "",
+    propertyName: void 0,
+    duration: 0
+  };
+  for (let i = 0; i < rawNames.length; i++) {
+    const duration = parseCssTimeUnitsToMs(rawDelays[i]) + parseCssTimeUnitsToMs(rawDurations[i]);
+    const iterationCount = rawIterationCounts[i];
+    if (duration > longest.duration && iterationCount !== "infinite") {
+      longest.animationName = rawNames[i];
+      longest.duration = duration;
+    }
+  }
+  return longest;
+}
+function isShorterThanExistingAnimation(existing, longest) {
+  return existing !== void 0 && existing.duration > longest.duration;
+}
+function longestExists(longest) {
+  return (longest.animationName != void 0 || longest.propertyName != void 0) && longest.duration > 0;
+}
+function determineLongestAnimationFromComputedStyles(el, animationsMap) {
+  const computedStyle = getComputedStyle(el);
+  const longestAnimation = getLongestComputedAnimation(computedStyle);
+  const longestTransition = getLongestComputedTransition(computedStyle);
+  const longest = longestAnimation.duration > longestTransition.duration ? longestAnimation : longestTransition;
+  if (isShorterThanExistingAnimation(animationsMap.get(el), longest)) return;
+  if (longestExists(longest)) {
+    animationsMap.set(el, longest);
+  }
+}
+function determineLongestAnimation(el, animationsMap, areAnimationSupported2) {
+  if (!areAnimationSupported2) return;
+  const animations = el.getAnimations();
+  return animations.length === 0 ? determineLongestAnimationFromComputedStyles(el, animationsMap) : determineLongestAnimationFromElementAnimations(el, animationsMap, animations);
+}
+function determineLongestAnimationFromElementAnimations(el, animationsMap, animations) {
+  let longest = {
+    animationName: void 0,
+    propertyName: void 0,
+    duration: 0
+  };
+  for (const animation of animations) {
+    const timing = animation.effect?.getTiming();
+    if (timing?.iterations === Infinity) {
+      continue;
+    }
+    const animDuration = typeof timing?.duration === "number" ? timing.duration : 0;
+    let duration = (timing?.delay ?? 0) + animDuration;
+    const playbackRate = animation.playbackRate;
+    if (playbackRate !== void 0 && playbackRate !== 0 && playbackRate !== 1) {
+      duration /= Math.abs(playbackRate);
+    }
+    let propertyName;
+    let animationName;
+    if (animation.animationName) {
+      animationName = animation.animationName;
+    } else {
+      propertyName = animation.transitionProperty;
+    }
+    if (duration >= longest.duration) {
+      longest = {
+        animationName,
+        propertyName,
+        duration
+      };
+    }
+  }
+  if (isShorterThanExistingAnimation(animationsMap.get(el), longest)) return;
+  if (longestExists(longest)) {
+    animationsMap.set(el, longest);
+  }
+}
+var allLeavingAnimations = /* @__PURE__ */ new Set();
+var TracingAction;
+(function(TracingAction2) {
+  TracingAction2[TracingAction2["CHANGE_DETECTION"] = 0] = "CHANGE_DETECTION";
+  TracingAction2[TracingAction2["AFTER_NEXT_RENDER"] = 1] = "AFTER_NEXT_RENDER";
+})(TracingAction || (TracingAction = {}));
+var TracingService = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "TracingService" : "");
+var markedFeatures = /* @__PURE__ */ new Set();
+function performanceMarkFeature(feature) {
+  if (markedFeatures.has(feature)) {
+    return;
+  }
+  markedFeatures.add(feature);
+  performance?.mark?.("mark_feature_usage", {
+    detail: {
+      feature
+    }
+  });
+}
+var AfterRenderManager = class _AfterRenderManager {
+  impl = null;
+  execute() {
+    this.impl?.execute();
+  }
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _AfterRenderManager,
+    providedIn: "root",
+    factory: () => new _AfterRenderManager()
+  });
+};
+var AFTER_RENDER_PHASES = /* @__PURE__ */ (() => [0, 1, 2, 3])();
+var AfterRenderImpl = class _AfterRenderImpl {
+  ngZone = inject2(NgZone);
+  scheduler = inject2(ChangeDetectionScheduler);
+  errorHandler = inject2(ErrorHandler, {
+    optional: true
+  });
+  sequences = /* @__PURE__ */ new Set();
+  deferredRegistrations = /* @__PURE__ */ new Set();
+  executing = false;
+  constructor() {
+    inject2(TracingService, {
+      optional: true
+    });
+  }
+  execute() {
+    const hasSequencesToExecute = this.sequences.size > 0;
+    if (hasSequencesToExecute) {
+      profiler(ProfilerEvent.AfterRenderHooksStart);
+    }
+    this.executing = true;
+    for (const phase of AFTER_RENDER_PHASES) {
+      for (const sequence of this.sequences) {
+        if (sequence.erroredOrDestroyed || !sequence.hooks[phase]) {
+          continue;
+        }
+        try {
+          sequence.pipelinedValue = this.ngZone.runOutsideAngular(() => this.maybeTrace(() => {
+            const hookFn = sequence.hooks[phase];
+            const value = hookFn(sequence.pipelinedValue);
+            return value;
+          }, sequence.snapshot));
+        } catch (err) {
+          sequence.erroredOrDestroyed = true;
+          this.errorHandler?.handleError(err);
+        }
+      }
+    }
+    this.executing = false;
+    for (const sequence of this.sequences) {
+      sequence.afterRun();
+      if (sequence.once) {
+        this.sequences.delete(sequence);
+        sequence.destroy();
+      }
+    }
+    for (const sequence of this.deferredRegistrations) {
+      this.sequences.add(sequence);
+    }
+    if (this.deferredRegistrations.size > 0) {
+      this.scheduler.notify(7);
+    }
+    this.deferredRegistrations.clear();
+    if (hasSequencesToExecute) {
+      profiler(ProfilerEvent.AfterRenderHooksEnd);
+    }
+  }
+  register(sequence) {
+    const {
+      view
+    } = sequence;
+    if (view !== void 0) {
+      (view[AFTER_RENDER_SEQUENCES_TO_ADD] ??= []).push(sequence);
+      markAncestorsForTraversal(view);
+      view[FLAGS] |= 8192;
+    } else if (!this.executing) {
+      this.addSequence(sequence);
+    } else {
+      this.deferredRegistrations.add(sequence);
+    }
+  }
+  addSequence(sequence) {
+    this.sequences.add(sequence);
+    this.scheduler.notify(7);
+  }
+  unregister(sequence) {
+    if (this.executing && this.sequences.has(sequence)) {
+      sequence.erroredOrDestroyed = true;
+      sequence.pipelinedValue = void 0;
+      sequence.once = true;
+    } else {
+      this.sequences.delete(sequence);
+      this.deferredRegistrations.delete(sequence);
+    }
+  }
+  maybeTrace(fn, snapshot) {
+    return snapshot ? snapshot.run(TracingAction.AFTER_NEXT_RENDER, fn) : fn();
+  }
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _AfterRenderImpl,
+    providedIn: "root",
+    factory: () => new _AfterRenderImpl()
+  });
+};
+var AfterRenderSequence = class {
+  impl;
+  hooks;
+  view;
+  once;
+  snapshot;
+  erroredOrDestroyed = false;
+  pipelinedValue = void 0;
+  unregisterOnDestroy;
+  constructor(impl, hooks, view, once, destroyRef, snapshot = null) {
+    this.impl = impl;
+    this.hooks = hooks;
+    this.view = view;
+    this.once = once;
+    this.snapshot = snapshot;
+    this.unregisterOnDestroy = destroyRef?.onDestroy(() => this.destroy());
+  }
+  afterRun() {
+    this.erroredOrDestroyed = false;
+    this.pipelinedValue = void 0;
+    this.snapshot?.dispose();
+    this.snapshot = null;
+  }
+  destroy() {
+    this.impl.unregister(this);
+    this.unregisterOnDestroy?.();
+    const scheduled2 = this.view?.[AFTER_RENDER_SEQUENCES_TO_ADD];
+    if (scheduled2) {
+      this.view[AFTER_RENDER_SEQUENCES_TO_ADD] = scheduled2.filter((s) => s !== this);
+    }
+  }
+};
+function afterEveryRender(callbackOrSpec, options) {
+  ngDevMode && assertNotInReactiveContext(afterEveryRender, "Call `afterEveryRender` outside of a reactive context. For example, schedule the render callback inside the component constructor`.");
+  if (ngDevMode && !options?.injector) {
+    assertInInjectionContext(afterEveryRender);
+  }
+  const injector = options?.injector ?? inject2(Injector);
+  if (false) {
+    return NOOP_AFTER_RENDER_REF;
+  }
+  performanceMarkFeature("NgAfterRender");
+  return afterEveryRenderImpl(callbackOrSpec, injector, options, false);
+}
+function afterNextRender(callbackOrSpec, options) {
+  if (ngDevMode && !options?.injector) {
+    assertInInjectionContext(afterNextRender);
+  }
+  const injector = options?.injector ?? inject2(Injector);
+  if (false) {
+    return NOOP_AFTER_RENDER_REF;
+  }
+  performanceMarkFeature("NgAfterNextRender");
+  return afterEveryRenderImpl(callbackOrSpec, injector, options, true);
+}
+function getHooks(callbackOrSpec) {
+  if (callbackOrSpec instanceof Function) {
+    return [void 0, void 0, callbackOrSpec, void 0];
+  } else {
+    return [callbackOrSpec.earlyRead, callbackOrSpec.write, callbackOrSpec.mixedReadWrite, callbackOrSpec.read];
+  }
+}
+function afterEveryRenderImpl(callbackOrSpec, injector, options, once) {
+  const manager = injector.get(AfterRenderManager);
+  manager.impl ??= injector.get(AfterRenderImpl);
+  const tracing = injector.get(TracingService, null, {
+    optional: true
+  });
+  const destroyRef = options?.manualCleanup !== true ? injector.get(DestroyRef) : null;
+  const viewContext = injector.get(ViewContext, null, {
+    optional: true
+  });
+  const sequence = new AfterRenderSequence(manager.impl, getHooks(callbackOrSpec), viewContext?.view, once, destroyRef, tracing?.snapshot(null));
+  manager.impl.register(sequence);
+  return sequence;
+}
+var ANIMATION_QUEUE = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "AnimationQueue" : "", {
+  factory: () => {
+    return {
+      queue: /* @__PURE__ */ new Set(),
+      isScheduled: false,
+      scheduler: null,
+      injector: inject2(EnvironmentInjector)
+    };
+  }
+});
+function addToAnimationQueue(injector, animationFns, animationData) {
+  const animationQueue = injector.get(ANIMATION_QUEUE);
+  if (Array.isArray(animationFns)) {
+    for (const animateFn of animationFns) {
+      animationQueue.queue.add(animateFn);
+      animationData?.detachedLeaveAnimationFns?.push(animateFn);
+    }
+  } else {
+    animationQueue.queue.add(animationFns);
+    animationData?.detachedLeaveAnimationFns?.push(animationFns);
+  }
+  animationQueue.scheduler && animationQueue.scheduler(injector);
+}
+function removeFromAnimationQueue(injector, animationData) {
+  const animationQueue = injector.get(ANIMATION_QUEUE);
+  if (animationData.detachedLeaveAnimationFns) {
+    for (const animationFn of animationData.detachedLeaveAnimationFns) {
+      animationQueue.queue.delete(animationFn);
+    }
+    animationData.detachedLeaveAnimationFns = void 0;
+  }
+}
+function scheduleAnimationQueue(injector) {
+  const animationQueue = injector.get(ANIMATION_QUEUE);
+  if (!animationQueue.isScheduled) {
+    afterNextRender(() => {
+      animationQueue.isScheduled = false;
+      for (let animateFn of animationQueue.queue) {
+        animateFn();
+      }
+      animationQueue.queue.clear();
+    }, {
+      injector: animationQueue.injector
+    });
+    animationQueue.isScheduled = true;
+  }
+}
+function initializeAnimationQueueScheduler(injector) {
+  const animationQueue = injector.get(ANIMATION_QUEUE);
+  animationQueue.scheduler = scheduleAnimationQueue;
+  animationQueue.scheduler(injector);
+}
+function queueEnterAnimations(injector, enterAnimations) {
+  for (const [_, nodeAnimations] of enterAnimations) {
+    addToAnimationQueue(injector, nodeAnimations.animateFns);
+  }
+}
+function maybeQueueEnterAnimation(parentLView, parent, tNode, injector) {
+  const enterAnimations = parentLView?.[ANIMATIONS]?.enter;
+  if (parent !== null && enterAnimations && enterAnimations.has(tNode.index)) {
+    queueEnterAnimations(injector, enterAnimations);
+  }
+}
+function applyToElementOrContainer(action, renderer, injector, parent, lNodeToHandle, tNode, beforeNode, parentLView) {
+  if (lNodeToHandle != null) {
+    let lContainer;
+    let isComponent2 = false;
+    if (isLContainer(lNodeToHandle)) {
+      lContainer = lNodeToHandle;
+    } else if (isLView(lNodeToHandle)) {
+      isComponent2 = true;
+      ngDevMode && assertDefined(lNodeToHandle[HOST], "HOST must be defined for a component LView");
+      lNodeToHandle = lNodeToHandle[HOST];
+    }
+    const rNode = unwrapRNode(lNodeToHandle);
+    if (action === 0 && parent !== null) {
+      maybeQueueEnterAnimation(parentLView, parent, tNode, injector);
+      if (beforeNode == null) {
+        nativeAppendChild(renderer, parent, rNode);
+      } else {
+        nativeInsertBefore(renderer, parent, rNode, beforeNode || null, true);
+      }
+    } else if (action === 1 && parent !== null) {
+      maybeQueueEnterAnimation(parentLView, parent, tNode, injector);
+      nativeInsertBefore(renderer, parent, rNode, beforeNode || null, true);
+      cancelLeavingNodes(tNode, rNode);
+    } else if (action === 2) {
+      if (parentLView?.[ANIMATIONS]?.leave?.has(tNode.index)) {
+        trackLeavingNodes(tNode, rNode);
+      }
+      reusedNodes.delete(rNode);
+      runLeaveAnimationsWithCallback(parentLView, tNode, injector, (nodeHasLeaveAnimations) => {
+        if (reusedNodes.has(rNode)) {
+          reusedNodes.delete(rNode);
+          return;
+        }
+        nativeRemoveNode(renderer, rNode, isComponent2, nodeHasLeaveAnimations);
+      });
+    } else if (action === 3) {
+      reusedNodes.delete(rNode);
+      runLeaveAnimationsWithCallback(parentLView, tNode, injector, () => {
+        renderer.destroyNode(rNode);
+      });
+    }
+    if (lContainer != null) {
+      applyContainer(renderer, action, injector, lContainer, tNode, parent, beforeNode);
+    }
+  }
+}
+function removeViewFromDOM(tView, lView) {
+  detachViewFromDOM(tView, lView);
+  lView[HOST] = null;
+  lView[T_HOST] = null;
+}
+function addViewToDOM(tView, parentTNode, renderer, lView, parentNativeNode, beforeNode) {
+  lView[HOST] = parentNativeNode;
+  lView[T_HOST] = parentTNode;
+  applyView(tView, lView, renderer, 1, parentNativeNode, beforeNode);
+}
+function detachViewFromDOM(tView, lView) {
+  lView[ENVIRONMENT].changeDetectionScheduler?.notify(9);
+  applyView(tView, lView, lView[RENDERER], 2, null, null);
+}
+function destroyViewTree(rootView) {
+  let lViewOrLContainer = rootView[CHILD_HEAD];
+  if (!lViewOrLContainer) {
+    return cleanUpView(rootView[TVIEW], rootView);
+  }
+  while (lViewOrLContainer) {
+    let next = null;
+    if (isLView(lViewOrLContainer)) {
+      next = lViewOrLContainer[CHILD_HEAD];
+    } else {
+      ngDevMode && assertLContainer(lViewOrLContainer);
+      const firstView = lViewOrLContainer[CONTAINER_HEADER_OFFSET];
+      if (firstView) next = firstView;
+    }
+    if (!next) {
+      while (lViewOrLContainer && !lViewOrLContainer[NEXT] && lViewOrLContainer !== rootView) {
+        if (isLView(lViewOrLContainer)) {
+          cleanUpView(lViewOrLContainer[TVIEW], lViewOrLContainer);
+        }
+        lViewOrLContainer = lViewOrLContainer[PARENT];
+      }
+      if (lViewOrLContainer === null) lViewOrLContainer = rootView;
+      if (isLView(lViewOrLContainer)) {
+        cleanUpView(lViewOrLContainer[TVIEW], lViewOrLContainer);
+      }
+      next = lViewOrLContainer && lViewOrLContainer[NEXT];
+    }
+    lViewOrLContainer = next;
+  }
+}
+function detachMovedView(declarationContainer, lView) {
+  ngDevMode && assertLContainer(declarationContainer);
+  ngDevMode && assertDefined(declarationContainer[MOVED_VIEWS], "A projected view should belong to a non-empty projected views collection");
+  const movedViews = declarationContainer[MOVED_VIEWS];
+  const declarationViewIndex = movedViews.indexOf(lView);
+  movedViews.splice(declarationViewIndex, 1);
+}
+function destroyLView(tView, lView) {
+  if (isDestroyed(lView)) {
+    return;
+  }
+  const renderer = lView[RENDERER];
+  if (renderer.destroyNode) {
+    applyView(tView, lView, renderer, 3, null, null);
+  }
+  destroyViewTree(lView);
+}
+function cleanUpView(tView, lView) {
+  if (isDestroyed(lView)) {
+    return;
+  }
+  const prevConsumer = setActiveConsumer(null);
+  try {
+    lView[FLAGS] &= ~128;
+    lView[FLAGS] |= 256;
+    lView[REACTIVE_TEMPLATE_CONSUMER] && consumerDestroy(lView[REACTIVE_TEMPLATE_CONSUMER]);
+    executeOnDestroys(tView, lView);
+    processCleanups(tView, lView);
+    if (lView[TVIEW].type === 1) {
+      lView[RENDERER].destroy();
+    }
+    const declarationContainer = lView[DECLARATION_LCONTAINER];
+    if (declarationContainer !== null && isLContainer(lView[PARENT])) {
+      if (declarationContainer !== lView[PARENT]) {
+        detachMovedView(declarationContainer, lView);
+      }
+      const lQueries = lView[QUERIES];
+      if (lQueries !== null) {
+        lQueries.detachView(tView);
+      }
+    }
+    unregisterLView(lView);
+  } finally {
+    setActiveConsumer(prevConsumer);
+  }
+}
+function runLeaveAnimationsWithCallback(lView, tNode, injector, callback) {
+  const animations = lView?.[ANIMATIONS];
+  if (animations == null || animations.leave == void 0 || !animations.leave.has(tNode.index)) return callback(false);
+  if (lView) allLeavingAnimations.add(lView[ID]);
+  addToAnimationQueue(injector, () => {
+    if (animations.leave && animations.leave.has(tNode.index)) {
+      const leaveAnimationMap = animations.leave;
+      const leaveAnimations = leaveAnimationMap.get(tNode.index);
+      const runningAnimations = [];
+      if (leaveAnimations) {
+        for (let index = 0; index < leaveAnimations.animateFns.length; index++) {
+          const animationFn = leaveAnimations.animateFns[index];
+          const {
+            promise
+          } = animationFn();
+          runningAnimations.push(promise);
+        }
+        animations.detachedLeaveAnimationFns = void 0;
+      }
+      animations.running = Promise.allSettled(runningAnimations);
+      runAfterLeaveAnimations(lView, callback);
+    } else {
+      if (lView) allLeavingAnimations.delete(lView[ID]);
+      callback(false);
+    }
+  }, animations);
+}
+function runAfterLeaveAnimations(lView, callback) {
+  const runningAnimations = lView[ANIMATIONS]?.running;
+  if (runningAnimations) {
+    runningAnimations.then(() => {
+      lView[ANIMATIONS].running = void 0;
+      allLeavingAnimations.delete(lView[ID]);
+      callback(true);
+    });
+    return;
+  }
+  callback(false);
+}
+function processCleanups(tView, lView) {
+  ngDevMode && assertNotReactive(processCleanups.name);
+  const tCleanup = tView.cleanup;
+  const lCleanup = lView[CLEANUP];
+  if (tCleanup !== null) {
+    for (let i = 0; i < tCleanup.length - 1; i += 2) {
+      if (typeof tCleanup[i] === "string") {
+        const targetIdx = tCleanup[i + 3];
+        ngDevMode && assertNumber(targetIdx, "cleanup target must be a number");
+        if (targetIdx >= 0) {
+          lCleanup[targetIdx]();
+        } else {
+          lCleanup[-targetIdx].unsubscribe();
+        }
+        i += 2;
+      } else {
+        const context2 = lCleanup[tCleanup[i + 1]];
+        tCleanup[i].call(context2);
+      }
+    }
+  }
+  if (lCleanup !== null) {
+    lView[CLEANUP] = null;
+  }
+  const destroyHooks = lView[ON_DESTROY_HOOKS];
+  if (destroyHooks !== null) {
+    lView[ON_DESTROY_HOOKS] = null;
+    for (let i = 0; i < destroyHooks.length; i++) {
+      const destroyHooksFn = destroyHooks[i];
+      ngDevMode && assertFunction(destroyHooksFn, "Expecting destroy hook to be a function.");
+      destroyHooksFn();
+    }
+  }
+  const effects = lView[EFFECTS];
+  if (effects !== null) {
+    lView[EFFECTS] = null;
+    for (const effect2 of effects) {
+      effect2.destroy();
+    }
+  }
+}
+function executeOnDestroys(tView, lView) {
+  ngDevMode && assertNotReactive(executeOnDestroys.name);
+  let destroyHooks;
+  if (tView != null && (destroyHooks = tView.destroyHooks) != null) {
+    for (let i = 0; i < destroyHooks.length; i += 2) {
+      const context2 = lView[destroyHooks[i]];
+      if (!(context2 instanceof NodeInjectorFactory)) {
+        const toCall = destroyHooks[i + 1];
+        if (Array.isArray(toCall)) {
+          for (let j = 0; j < toCall.length; j += 2) {
+            const callContext = context2[toCall[j]];
+            const hook = toCall[j + 1];
+            profiler(ProfilerEvent.LifecycleHookStart, callContext, hook);
+            try {
+              hook.call(callContext);
+            } finally {
+              profiler(ProfilerEvent.LifecycleHookEnd, callContext, hook);
+            }
+          }
+        } else {
+          profiler(ProfilerEvent.LifecycleHookStart, context2, toCall);
+          try {
+            toCall.call(context2);
+          } finally {
+            profiler(ProfilerEvent.LifecycleHookEnd, context2, toCall);
+          }
+        }
+      }
+    }
+  }
+}
+function getParentRElement(tView, tNode, lView) {
+  return getClosestRElement(tView, tNode.parent, lView);
+}
+function getClosestRElement(tView, tNode, lView) {
+  let parentTNode = tNode;
+  while (parentTNode !== null && parentTNode.type & (8 | 32 | 128)) {
+    tNode = parentTNode;
+    parentTNode = tNode.parent;
+  }
+  if (parentTNode === null) {
+    return lView[HOST];
+  } else {
+    ngDevMode && assertTNodeType(parentTNode, 3 | 4);
+    if (isComponentHost(parentTNode)) {
+      ngDevMode && assertTNodeForLView(parentTNode, lView);
+      const {
+        encapsulation
+      } = tView.data[parentTNode.directiveStart + parentTNode.componentOffset];
+      if (encapsulation === ViewEncapsulation.None || encapsulation === ViewEncapsulation.Emulated) {
+        return null;
+      }
+    }
+    return getNativeByTNode(parentTNode, lView);
+  }
+}
+function getInsertInFrontOfRNode(parentTNode, currentTNode, lView) {
+  return _getInsertInFrontOfRNodeWithI18n(parentTNode, currentTNode, lView);
+}
+function getInsertInFrontOfRNodeWithNoI18n(parentTNode, currentTNode, lView) {
+  if (parentTNode.type & (8 | 32)) {
+    return getNativeByTNode(parentTNode, lView);
+  }
+  return null;
+}
+var _getInsertInFrontOfRNodeWithI18n = getInsertInFrontOfRNodeWithNoI18n;
+var _processI18nInsertBefore;
+function setI18nHandling(getInsertInFrontOfRNodeWithI18n2, processI18nInsertBefore2) {
+  _getInsertInFrontOfRNodeWithI18n = getInsertInFrontOfRNodeWithI18n2;
+  _processI18nInsertBefore = processI18nInsertBefore2;
+}
+function appendChild(tView, lView, childRNode, childTNode) {
+  const parentRNode = getParentRElement(tView, childTNode, lView);
+  const renderer = lView[RENDERER];
+  const parentTNode = childTNode.parent || lView[T_HOST];
+  const anchorNode = getInsertInFrontOfRNode(parentTNode, childTNode, lView);
+  if (parentRNode != null) {
+    if (Array.isArray(childRNode)) {
+      for (let i = 0; i < childRNode.length; i++) {
+        nativeAppendOrInsertBefore(renderer, parentRNode, childRNode[i], anchorNode, false);
+      }
+    } else {
+      nativeAppendOrInsertBefore(renderer, parentRNode, childRNode, anchorNode, false);
+    }
+  }
+  _processI18nInsertBefore !== void 0 && _processI18nInsertBefore(renderer, childTNode, lView, childRNode, parentRNode);
+}
+function getFirstNativeNode(lView, tNode) {
+  if (tNode !== null) {
+    ngDevMode && assertTNodeType(tNode, 3 | 12 | 32 | 16 | 128);
+    const tNodeType = tNode.type;
+    if (tNodeType & 3) {
+      return getNativeByTNode(tNode, lView);
+    } else if (tNodeType & 4) {
+      return getBeforeNodeForView(-1, lView[tNode.index]);
+    } else if (tNodeType & 8) {
+      const elIcuContainerChild = tNode.child;
+      if (elIcuContainerChild !== null) {
+        return getFirstNativeNode(lView, elIcuContainerChild);
+      } else {
+        const rNodeOrLContainer = lView[tNode.index];
+        if (isLContainer(rNodeOrLContainer)) {
+          return getBeforeNodeForView(-1, rNodeOrLContainer);
+        } else {
+          return unwrapRNode(rNodeOrLContainer);
+        }
+      }
+    } else if (tNodeType & 128) {
+      return getFirstNativeNode(lView, tNode.next);
+    } else if (tNodeType & 32) {
+      let nextRNode = icuContainerIterate(tNode, lView);
+      let rNode = nextRNode();
+      return rNode || unwrapRNode(lView[tNode.index]);
+    } else {
+      const projectionNodes = getProjectionNodes(lView, tNode);
+      if (projectionNodes !== null) {
+        if (Array.isArray(projectionNodes)) {
+          return projectionNodes[0];
+        }
+        const parentView = getLViewParent(lView[DECLARATION_COMPONENT_VIEW]);
+        ngDevMode && assertParentView(parentView);
+        return getFirstNativeNode(parentView, projectionNodes);
+      } else {
+        return getFirstNativeNode(lView, tNode.next);
+      }
+    }
+  }
+  return null;
+}
+function getProjectionNodes(lView, tNode) {
+  if (tNode !== null) {
+    const componentView = lView[DECLARATION_COMPONENT_VIEW];
+    const componentHost = componentView[T_HOST];
+    const slotIdx = tNode.projection;
+    ngDevMode && assertProjectionSlots(lView);
+    return componentHost.projection[slotIdx];
+  }
+  return null;
+}
+function getBeforeNodeForView(viewIndexInContainer, lContainer) {
+  const nextViewIndex = CONTAINER_HEADER_OFFSET + viewIndexInContainer + 1;
+  if (nextViewIndex < lContainer.length) {
+    const lView = lContainer[nextViewIndex];
+    const firstTNodeOfView = lView[TVIEW].firstChild;
+    if (firstTNodeOfView !== null) {
+      return getFirstNativeNode(lView, firstTNodeOfView);
+    }
+  }
+  return lContainer[NATIVE];
+}
+function applyNodes(renderer, action, tNode, lView, parentRElement, beforeNode, isProjection) {
+  while (tNode != null) {
+    ngDevMode && assertTNodeForLView(tNode, lView);
+    const injector = lView[INJECTOR];
+    if (tNode.type === 128) {
+      tNode = tNode.next;
+      continue;
+    }
+    ngDevMode && assertTNodeType(tNode, 3 | 12 | 16 | 32);
+    const rawSlotValue = lView[tNode.index];
+    const tNodeType = tNode.type;
+    if (isProjection) {
+      if (action === 0) {
+        rawSlotValue && attachPatchData(unwrapRNode(rawSlotValue), lView);
+        tNode.flags |= 2;
+      }
+    }
+    if (!isDetachedByI18n(tNode)) {
+      if (tNodeType & 8) {
+        applyNodes(renderer, action, tNode.child, lView, parentRElement, beforeNode, false);
+        applyToElementOrContainer(action, renderer, injector, parentRElement, rawSlotValue, tNode, beforeNode, lView);
+      } else if (tNodeType & 32) {
+        const nextRNode = icuContainerIterate(tNode, lView);
+        let rNode;
+        while (rNode = nextRNode()) {
+          applyToElementOrContainer(action, renderer, injector, parentRElement, rNode, tNode, beforeNode, lView);
+        }
+        applyToElementOrContainer(action, renderer, injector, parentRElement, rawSlotValue, tNode, beforeNode, lView);
+      } else if (tNodeType & 16) {
+        applyProjectionRecursive(renderer, action, lView, tNode, parentRElement, beforeNode);
+      } else {
+        ngDevMode && assertTNodeType(tNode, 3 | 4);
+        applyToElementOrContainer(action, renderer, injector, parentRElement, rawSlotValue, tNode, beforeNode, lView);
+      }
+    }
+    tNode = isProjection ? tNode.projectionNext : tNode.next;
+  }
+}
+function applyView(tView, lView, renderer, action, parentRElement, beforeNode) {
+  applyNodes(renderer, action, tView.firstChild, lView, parentRElement, beforeNode, false);
+}
+function applyProjection(tView, lView, tProjectionNode) {
+  const renderer = lView[RENDERER];
+  const parentRNode = getParentRElement(tView, tProjectionNode, lView);
+  const parentTNode = tProjectionNode.parent || lView[T_HOST];
+  let beforeNode = getInsertInFrontOfRNode(parentTNode, tProjectionNode, lView);
+  applyProjectionRecursive(renderer, 0, lView, tProjectionNode, parentRNode, beforeNode);
+}
+function applyProjectionRecursive(renderer, action, lView, tProjectionNode, parentRElement, beforeNode) {
+  const componentLView = lView[DECLARATION_COMPONENT_VIEW];
+  const componentNode = componentLView[T_HOST];
+  ngDevMode && assertEqual(typeof tProjectionNode.projection, "number", "expecting projection index");
+  const nodeToProjectOrRNodes = componentNode.projection[tProjectionNode.projection];
+  if (Array.isArray(nodeToProjectOrRNodes)) {
+    for (let i = 0; i < nodeToProjectOrRNodes.length; i++) {
+      const rNode = nodeToProjectOrRNodes[i];
+      applyToElementOrContainer(action, renderer, lView[INJECTOR], parentRElement, rNode, tProjectionNode, beforeNode, lView);
+    }
+  } else {
+    let nodeToProject = nodeToProjectOrRNodes;
+    const projectedComponentLView = componentLView[PARENT];
+    if (hasInSkipHydrationBlockFlag(tProjectionNode)) {
+      nodeToProject.flags |= 128;
+    }
+    applyNodes(renderer, action, nodeToProject, projectedComponentLView, parentRElement, beforeNode, true);
+  }
+}
+function applyContainer(renderer, action, injector, lContainer, tNode, parentRElement, beforeNode) {
+  ngDevMode && assertLContainer(lContainer);
+  const anchor = lContainer[NATIVE];
+  const native = unwrapRNode(lContainer);
+  if (anchor !== native) {
+    applyToElementOrContainer(action, renderer, injector, parentRElement, anchor, tNode, beforeNode);
+  }
+  for (let i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {
+    const lView = lContainer[i];
+    applyView(lView[TVIEW], lView, renderer, action, parentRElement, anchor);
+  }
+}
+function applyStyling(renderer, isClassBased, rNode, prop, value) {
+  if (isClassBased) {
+    if (!value) {
+      renderer.removeClass(rNode, prop);
+    } else {
+      renderer.addClass(rNode, prop);
+    }
+  } else {
+    let flags = prop.indexOf("-") === -1 ? void 0 : RendererStyleFlags2.DashCase;
+    if (value == null) {
+      renderer.removeStyle(rNode, prop, flags);
+    } else {
+      const isImportant = typeof value === "string" ? value.endsWith("!important") : false;
+      if (isImportant) {
+        value = value.slice(0, -10);
+        flags |= RendererStyleFlags2.Important;
+      }
+      renderer.setStyle(rNode, prop, value, flags);
+    }
+  }
+}
+function executeTemplate(tView, lView, templateFn, rf, context2) {
+  const prevSelectedIndex = getSelectedIndex();
+  const isUpdatePhase = rf & 2;
+  try {
+    setSelectedIndex(-1);
+    if (isUpdatePhase && lView.length > HEADER_OFFSET) {
+      selectIndexInternal(tView, lView, HEADER_OFFSET, !!ngDevMode && isInCheckNoChangesMode());
+    }
+    const preHookType = isUpdatePhase ? ProfilerEvent.TemplateUpdateStart : ProfilerEvent.TemplateCreateStart;
+    profiler(preHookType, context2, templateFn);
+    templateFn(rf, context2);
+  } finally {
+    setSelectedIndex(prevSelectedIndex);
+    const postHookType = isUpdatePhase ? ProfilerEvent.TemplateUpdateEnd : ProfilerEvent.TemplateCreateEnd;
+    profiler(postHookType, context2, templateFn);
+  }
+}
+function createDirectivesInstances(tView, lView, tNode) {
+  instantiateAllDirectives(tView, lView, tNode);
+  if ((tNode.flags & 64) === 64) {
+    invokeDirectivesHostBindings(tView, lView, tNode);
+  }
+}
+function saveResolvedLocalsInData(viewData, tNode, localRefExtractor = getNativeByTNode) {
+  const localNames = tNode.localNames;
+  if (localNames !== null) {
+    let localIndex = tNode.index + 1;
+    for (let i = 0; i < localNames.length; i += 2) {
+      const index = localNames[i + 1];
+      const value = index === -1 ? localRefExtractor(tNode, viewData) : viewData[index];
+      viewData[localIndex++] = value;
+    }
+  }
+}
+function locateHostElement(renderer, elementOrSelector, encapsulation, injector) {
+  const preserveHostContent = injector.get(PRESERVE_HOST_CONTENT, PRESERVE_HOST_CONTENT_DEFAULT);
+  const preserveContent = preserveHostContent || encapsulation === ViewEncapsulation.ShadowDom || encapsulation === ViewEncapsulation.ExperimentalIsolatedShadowDom;
+  const rootElement = renderer.selectRootElement(elementOrSelector, preserveContent);
+  if (rootElement.tagName.toLowerCase() === "script") {
+    throw new RuntimeError(905, ngDevMode && `"<script>" tag is not allowed as a component host element.`);
+  }
+  applyRootElementTransform(rootElement);
+  return rootElement;
+}
+function applyRootElementTransform(rootElement) {
+  _applyRootElementTransformImpl(rootElement);
+}
+var _applyRootElementTransformImpl = () => null;
+function mapPropName(name) {
+  if (name === "class") return "className";
+  if (name === "for") return "htmlFor";
+  if (name === "formaction") return "formAction";
+  if (name === "innerHtml") return "innerHTML";
+  if (name === "readonly") return "readOnly";
+  if (name === "tabindex") return "tabIndex";
+  return name;
+}
+function setPropertyAndInputs(tNode, lView, propName, value, renderer, sanitizer) {
+  ngDevMode && assertNotSame(value, NO_CHANGE, "Incoming value should never be NO_CHANGE.");
+  const tView = lView[TVIEW];
+  const hasSetInput = setAllInputsForProperty(tNode, tView, lView, propName, value);
+  if (hasSetInput) {
+    isComponentHost(tNode) && markDirtyIfOnPush(lView, tNode.index);
+    ngDevMode && setNgReflectProperties(lView, tView, tNode, propName, value);
+    return;
+  }
+  if (tNode.type & 3) {
+    propName = mapPropName(propName);
+  }
+  setDomProperty(tNode, lView, propName, value, renderer, sanitizer);
+}
+function setDomProperty(tNode, lView, propName, value, renderer, sanitizer) {
+  if (tNode.type & 3) {
+    const element = getNativeByTNode(tNode, lView);
+    if (ngDevMode) {
+      if (lView[TVIEW].firstUpdatePass) {
+        validateAgainstEventProperties(propName);
+      }
+      if (!isPropertyValid(element, propName, tNode.value, lView[TVIEW].schemas)) {
+        handleUnknownPropertyError(propName, tNode.value, tNode.type, lView);
+      }
+    }
+    value = sanitizer != null ? sanitizer(value, tNode.value || "", propName) : value;
+    renderer.setProperty(element, propName, value);
+  } else if (tNode.type & 12) {
+    if (ngDevMode && !matchingSchemas(lView[TVIEW].schemas, tNode.value)) {
+      handleUnknownPropertyError(propName, tNode.value, tNode.type, lView);
+    }
+  }
+}
+function markDirtyIfOnPush(lView, viewIndex) {
+  ngDevMode && assertLView(lView);
+  const childComponentLView = getComponentLViewByIndex(viewIndex, lView);
+  if (!(childComponentLView[FLAGS] & 16)) {
+    childComponentLView[FLAGS] |= 64;
+  }
+}
+function setNgReflectProperty(lView, tNode, attrName, value) {
+  const environment = lView[ENVIRONMENT];
+  if (!environment.ngReflect) {
+    return;
+  }
+  const element = getNativeByTNode(tNode, lView);
+  const renderer = lView[RENDERER];
+  attrName = normalizeDebugBindingName(attrName);
+  const debugValue = normalizeDebugBindingValue(value);
+  if (tNode.type & 3) {
+    if (value == null) {
+      renderer.removeAttribute(element, attrName);
+    } else {
+      renderer.setAttribute(element, attrName, debugValue);
+    }
+  } else {
+    const textContent = escapeCommentText(`bindings=${JSON.stringify({
+      [attrName]: debugValue
+    }, null, 2)}`);
+    renderer.setValue(element, textContent);
+  }
+}
+function setNgReflectProperties(lView, tView, tNode, publicName, value) {
+  const environment = lView[ENVIRONMENT];
+  if (!environment.ngReflect || !(tNode.type & (3 | 4))) {
+    return;
+  }
+  const inputConfig = tNode.inputs?.[publicName];
+  const hostInputConfig = tNode.hostDirectiveInputs?.[publicName];
+  if (hostInputConfig) {
+    for (let i = 0; i < hostInputConfig.length; i += 2) {
+      const index = hostInputConfig[i];
+      const publicName2 = hostInputConfig[i + 1];
+      const def = tView.data[index];
+      setNgReflectProperty(lView, tNode, def.inputs[publicName2][0], value);
+    }
+  }
+  if (inputConfig) {
+    for (const index of inputConfig) {
+      const def = tView.data[index];
+      setNgReflectProperty(lView, tNode, def.inputs[publicName][0], value);
+    }
+  }
+}
+function instantiateAllDirectives(tView, lView, tNode) {
+  const start = tNode.directiveStart;
+  const end = tNode.directiveEnd;
+  if (isComponentHost(tNode)) {
+    ngDevMode && assertTNodeType(tNode, 3);
+    createComponentLView(lView, tNode, tView.data[start + tNode.componentOffset]);
+  }
+  if (!tView.firstCreatePass) {
+    getOrCreateNodeInjectorForNode(tNode, lView);
+  }
+  const initialInputs = tNode.initialInputs;
+  for (let i = start; i < end; i++) {
+    const def = tView.data[i];
+    const directive = getNodeInjectable(lView, tView, i, tNode);
+    attachPatchData(directive, lView);
+    if (initialInputs !== null) {
+      setInputsFromAttrs(lView, i - start, directive, def, tNode, initialInputs);
+    }
+    if (isComponentDef(def)) {
+      const componentView = getComponentLViewByIndex(tNode.index, lView);
+      componentView[CONTEXT] = getNodeInjectable(lView, tView, i, tNode);
+    }
+  }
+}
+function invokeDirectivesHostBindings(tView, lView, tNode) {
+  const start = tNode.directiveStart;
+  const end = tNode.directiveEnd;
+  const elementIndex = tNode.index;
+  const currentDirectiveIndex = getCurrentDirectiveIndex();
+  try {
+    setSelectedIndex(elementIndex);
+    for (let dirIndex = start; dirIndex < end; dirIndex++) {
+      const def = tView.data[dirIndex];
+      const directive = lView[dirIndex];
+      setCurrentDirectiveIndex(dirIndex);
+      if (def.hostBindings !== null || def.hostVars !== 0 || def.hostAttrs !== null) {
+        invokeHostBindingsInCreationMode(def, directive);
+      }
+    }
+  } finally {
+    setSelectedIndex(-1);
+    setCurrentDirectiveIndex(currentDirectiveIndex);
+  }
+}
+function invokeHostBindingsInCreationMode(def, directive) {
+  if (def.hostBindings !== null) {
+    def.hostBindings(1, directive);
+  }
+}
+function findDirectiveDefMatches(tView, tNode) {
+  ngDevMode && assertFirstCreatePass(tView);
+  ngDevMode && assertTNodeType(tNode, 3 | 12);
+  const registry = tView.directiveRegistry;
+  let matches = null;
+  if (registry) {
+    for (let i = 0; i < registry.length; i++) {
+      const def = registry[i];
+      if (isNodeMatchingSelectorList(tNode, def.selectors, false)) {
+        matches ??= [];
+        if (isComponentDef(def)) {
+          if (ngDevMode) {
+            assertTNodeType(tNode, 2, `"${tNode.value}" tags cannot be used as component hosts. Please use a different tag to activate the ${stringify(def.type)} component.`);
+            if (matches.length && isComponentDef(matches[0])) {
+              throwMultipleComponentError(tNode, matches.find(isComponentDef).type, def.type);
+            }
+          }
+          matches.unshift(def);
+        } else {
+          matches.push(def);
+        }
+      }
+    }
+  }
+  return matches;
+}
+function elementAttributeInternal(tNode, lView, name, value, sanitizer, namespace) {
+  if (ngDevMode) {
+    assertNotSame(value, NO_CHANGE, "Incoming value should never be NO_CHANGE.");
+    assertTNodeType(tNode, 2, `Attempted to set attribute \`${name}\` on a container node. Host bindings are not valid on ng-container or ng-template.`);
+  }
+  const element = getNativeByTNode(tNode, lView);
+  setElementAttribute(lView[RENDERER], element, namespace, tNode.value, name, value, sanitizer);
+}
+function setElementAttribute(renderer, element, namespace, tagName, name, value, sanitizer) {
+  if (value == null) {
+    renderer.removeAttribute(element, name, namespace);
+  } else {
+    const strValue = sanitizer == null ? renderStringify(value) : sanitizer(value, tagName || "", name);
+    renderer.setAttribute(element, name, strValue, namespace);
+  }
+}
+function setInputsFromAttrs(lView, directiveIndex, instance, def, tNode, initialInputData) {
+  const initialInputs = initialInputData[directiveIndex];
+  if (initialInputs !== null) {
+    for (let i = 0; i < initialInputs.length; i += 2) {
+      const lookupName = initialInputs[i];
+      const value = initialInputs[i + 1];
+      writeToDirectiveInput(def, instance, lookupName, value);
+      if (ngDevMode) {
+        setNgReflectProperty(lView, tNode, def.inputs[lookupName][0], value);
+      }
+    }
+  }
+}
+function elementLikeStartShared(tNode, lView, index, name, locateOrCreateNativeNode) {
+  const adjustedIndex = HEADER_OFFSET + index;
+  const tView = lView[TVIEW];
+  const native = locateOrCreateNativeNode(tView, lView, tNode, name, index);
+  lView[adjustedIndex] = native;
+  setCurrentTNode(tNode, true);
+  const isElement = tNode.type === 2;
+  if (isElement) {
+    setupStaticAttributes(lView[RENDERER], native, tNode);
+    if (getElementDepthCount() === 0 || isDirectiveHost(tNode)) {
+      attachPatchData(native, lView);
+    }
+    increaseElementDepthCount();
+  } else {
+    attachPatchData(native, lView);
+  }
+  if (wasLastNodeCreated() && (!isElement || !isDetachedByI18n(tNode))) {
+    appendChild(tView, lView, native, tNode);
+  }
+  return tNode;
+}
+function elementLikeEndShared(tNode) {
+  let currentTNode = tNode;
+  if (isCurrentTNodeParent()) {
+    setCurrentTNodeAsNotParent();
+  } else {
+    ngDevMode && assertHasParent(getCurrentTNode());
+    currentTNode = currentTNode.parent;
+    setCurrentTNode(currentTNode, false);
+  }
+  return currentTNode;
+}
+function storePropertyBindingMetadata(tData, tNode, propertyName, bindingIndex, ...interpolationParts) {
+  if (tData[bindingIndex] === null) {
+    if (!tNode.inputs?.[propertyName] && !tNode.hostDirectiveInputs?.[propertyName]) {
+      const propBindingIdxs = tNode.propertyBindings || (tNode.propertyBindings = []);
+      propBindingIdxs.push(bindingIndex);
+      let bindingMetadata = propertyName;
+      if (interpolationParts.length > 0) {
+        bindingMetadata += INTERPOLATION_DELIMITER + interpolationParts.join(INTERPOLATION_DELIMITER);
+      }
+      tData[bindingIndex] = bindingMetadata;
+    }
+  }
+}
+function loadComponentRenderer(currentDef, tNode, lView) {
+  if (currentDef === null || isComponentDef(currentDef)) {
+    lView = unwrapLView(lView[tNode.index]);
+  }
+  return lView[RENDERER];
+}
+function handleUncaughtError(lView, error) {
+  const injector = lView[INJECTOR];
+  if (!injector) {
+    return;
+  }
+  let errorHandler2;
+  try {
+    errorHandler2 = injector.get(INTERNAL_APPLICATION_ERROR_HANDLER, null);
+  } catch {
+    errorHandler2 = null;
+  }
+  errorHandler2?.(error);
+}
+function setAllInputsForProperty(tNode, tView, lView, publicName, value) {
+  const inputs = tNode.inputs?.[publicName];
+  const hostDirectiveInputs = tNode.hostDirectiveInputs?.[publicName];
+  let hasMatch = false;
+  if (hostDirectiveInputs) {
+    for (let i = 0; i < hostDirectiveInputs.length; i += 2) {
+      const index = hostDirectiveInputs[i];
+      ngDevMode && assertIndexInRange(lView, index);
+      const publicName2 = hostDirectiveInputs[i + 1];
+      const def = tView.data[index];
+      writeToDirectiveInput(def, lView[index], publicName2, value);
+      hasMatch = true;
+    }
+  }
+  if (inputs) {
+    for (const index of inputs) {
+      ngDevMode && assertIndexInRange(lView, index);
+      const instance = lView[index];
+      const def = tView.data[index];
+      writeToDirectiveInput(def, instance, publicName, value);
+      hasMatch = true;
+    }
+  }
+  return hasMatch;
+}
+function renderComponent(hostLView, componentHostIdx) {
+  ngDevMode && assertEqual(isCreationMode(hostLView), true, "Should be run in creation mode");
+  const componentView = getComponentLViewByIndex(componentHostIdx, hostLView);
+  const componentTView = componentView[TVIEW];
+  syncViewWithBlueprint(componentTView, componentView);
+  const hostRNode = componentView[HOST];
+  if (hostRNode !== null && componentView[HYDRATION] === null) {
+    componentView[HYDRATION] = retrieveHydrationInfo(hostRNode, componentView[INJECTOR]);
+  }
+  profiler(ProfilerEvent.ComponentStart);
+  try {
+    renderView(componentTView, componentView, componentView[CONTEXT]);
+  } finally {
+    profiler(ProfilerEvent.ComponentEnd, componentView[CONTEXT]);
+  }
+}
+function syncViewWithBlueprint(tView, lView) {
+  for (let i = lView.length; i < tView.blueprint.length; i++) {
+    lView.push(tView.blueprint[i]);
+  }
+}
+function renderView(tView, lView, context2) {
+  ngDevMode && assertEqual(isCreationMode(lView), true, "Should be run in creation mode");
+  ngDevMode && assertNotReactive(renderView.name);
+  enterView(lView);
+  try {
+    const viewQuery = tView.viewQuery;
+    if (viewQuery !== null) {
+      executeViewQueryFn(1, viewQuery, context2);
+    }
+    const templateFn = tView.template;
+    if (templateFn !== null) {
+      executeTemplate(tView, lView, templateFn, 1, context2);
+    }
+    if (tView.firstCreatePass) {
+      tView.firstCreatePass = false;
+    }
+    lView[QUERIES]?.finishViewCreation(tView);
+    if (tView.staticContentQueries) {
+      refreshContentQueries(tView, lView);
+    }
+    if (tView.staticViewQueries) {
+      executeViewQueryFn(2, tView.viewQuery, context2);
+    }
+    const components = tView.components;
+    if (components !== null) {
+      renderChildComponents(lView, components);
+    }
+  } catch (error) {
+    if (tView.firstCreatePass) {
+      tView.incompleteFirstPass = true;
+      tView.firstCreatePass = false;
+    }
+    throw error;
+  } finally {
+    lView[FLAGS] &= -5;
+    leaveView();
+  }
+}
+function renderChildComponents(hostLView, components) {
+  for (let i = 0; i < components.length; i++) {
+    renderComponent(hostLView, components[i]);
+  }
+}
+function createAndRenderEmbeddedLView(declarationLView, templateTNode, context2, options) {
+  const prevConsumer = setActiveConsumer(null);
+  try {
+    const embeddedTView = templateTNode.tView;
+    ngDevMode && assertDefined(embeddedTView, "TView must be defined for a template node.");
+    ngDevMode && assertTNodeForLView(templateTNode, declarationLView);
+    const isSignalView = declarationLView[FLAGS] & 4096;
+    const viewFlags = isSignalView ? 4096 : 16;
+    const embeddedLView = createLView(declarationLView, embeddedTView, context2, viewFlags, null, templateTNode, null, null, options?.injector ?? null, options?.embeddedViewInjector ?? null, options?.dehydratedView ?? null);
+    const declarationLContainer = declarationLView[templateTNode.index];
+    ngDevMode && assertLContainer(declarationLContainer);
+    embeddedLView[DECLARATION_LCONTAINER] = declarationLContainer;
+    const declarationViewLQueries = declarationLView[QUERIES];
+    if (declarationViewLQueries !== null) {
+      embeddedLView[QUERIES] = declarationViewLQueries.createEmbeddedView(embeddedTView);
+    }
+    renderView(embeddedTView, embeddedLView, context2);
+    return embeddedLView;
+  } finally {
+    setActiveConsumer(prevConsumer);
+  }
+}
+function shouldAddViewToDom(tNode, dehydratedView) {
+  return !dehydratedView || dehydratedView.firstChild === null || hasInSkipHydrationBlockFlag(tNode);
+}
+var USE_EXHAUSTIVE_CHECK_NO_CHANGES_DEFAULT = false;
+var UseExhaustiveCheckNoChanges = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "exhaustive checkNoChanges" : "");
+function collectNativeNodes(tView, lView, tNode, result, isProjection = false) {
+  while (tNode !== null) {
+    if (tNode.type === 128) {
+      tNode = isProjection ? tNode.projectionNext : tNode.next;
+      continue;
+    }
+    ngDevMode && assertTNodeType(tNode, 3 | 12 | 16 | 32);
+    const lNode = lView[tNode.index];
+    if (lNode !== null) {
+      result.push(unwrapRNode(lNode));
+    }
+    if (isLContainer(lNode)) {
+      collectNativeNodesInLContainer(lNode, result);
+    }
+    const tNodeType = tNode.type;
+    if (tNodeType & 8) {
+      collectNativeNodes(tView, lView, tNode.child, result);
+    } else if (tNodeType & 32) {
+      const nextRNode = icuContainerIterate(tNode, lView);
+      let rNode;
+      while (rNode = nextRNode()) {
+        result.push(rNode);
+      }
+    } else if (tNodeType & 16) {
+      const nodesInSlot = getProjectionNodes(lView, tNode);
+      if (Array.isArray(nodesInSlot)) {
+        result.push(...nodesInSlot);
+      } else {
+        const parentView = getLViewParent(lView[DECLARATION_COMPONENT_VIEW]);
+        ngDevMode && assertParentView(parentView);
+        collectNativeNodes(parentView[TVIEW], parentView, nodesInSlot, result, true);
+      }
+    }
+    tNode = isProjection ? tNode.projectionNext : tNode.next;
+  }
+  return result;
+}
+function collectNativeNodesInLContainer(lContainer, result) {
+  for (let i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {
+    const lViewInAContainer = lContainer[i];
+    const lViewFirstChildTNode = lViewInAContainer[TVIEW].firstChild;
+    if (lViewFirstChildTNode !== null) {
+      collectNativeNodes(lViewInAContainer[TVIEW], lViewInAContainer, lViewFirstChildTNode, result);
+    }
+  }
+  if (lContainer[NATIVE] !== lContainer[HOST]) {
+    result.push(lContainer[NATIVE]);
+  }
+}
+function addAfterRenderSequencesForView(lView) {
+  if (lView[AFTER_RENDER_SEQUENCES_TO_ADD] !== null) {
+    for (const sequence of lView[AFTER_RENDER_SEQUENCES_TO_ADD]) {
+      sequence.impl.addSequence(sequence);
+    }
+    lView[AFTER_RENDER_SEQUENCES_TO_ADD].length = 0;
+  }
+}
+var freeConsumers = [];
+function getOrBorrowReactiveLViewConsumer(lView) {
+  return lView[REACTIVE_TEMPLATE_CONSUMER] ?? borrowReactiveLViewConsumer(lView);
+}
+function borrowReactiveLViewConsumer(lView) {
+  const consumer = freeConsumers.pop() ?? Object.create(REACTIVE_LVIEW_CONSUMER_NODE);
+  consumer.lView = lView;
+  return consumer;
+}
+function maybeReturnReactiveLViewConsumer(consumer) {
+  if (consumer.lView[REACTIVE_TEMPLATE_CONSUMER] === consumer) {
+    return;
+  }
+  consumer.lView = null;
+  freeConsumers.push(consumer);
+}
+var REACTIVE_LVIEW_CONSUMER_NODE = __spreadProps(__spreadValues({}, REACTIVE_NODE), {
+  consumerIsAlwaysLive: true,
+  kind: "template",
+  consumerMarkedDirty: (node) => {
+    markAncestorsForTraversal(node.lView);
+  },
+  consumerOnSignalRead() {
+    this.lView[REACTIVE_TEMPLATE_CONSUMER] = this;
+  }
+});
+function getOrCreateTemporaryConsumer(lView) {
+  const consumer = lView[REACTIVE_TEMPLATE_CONSUMER] ?? Object.create(TEMPORARY_CONSUMER_NODE);
+  consumer.lView = lView;
+  return consumer;
+}
+var TEMPORARY_CONSUMER_NODE = __spreadProps(__spreadValues({}, REACTIVE_NODE), {
+  consumerIsAlwaysLive: true,
+  kind: "template",
+  consumerMarkedDirty: (node) => {
+    let parent = getLViewParent(node.lView);
+    while (parent && !viewShouldHaveReactiveConsumer(parent[TVIEW])) {
+      parent = getLViewParent(parent);
+    }
+    if (!parent) {
+      return;
+    }
+    markViewForRefresh(parent);
+  },
+  consumerOnSignalRead() {
+    this.lView[REACTIVE_TEMPLATE_CONSUMER] = this;
+  }
+});
+function viewShouldHaveReactiveConsumer(tView) {
+  return tView.type !== 2;
+}
+function isReactiveLViewConsumer(node) {
+  return node.kind === "template";
+}
+function runEffectsInView(view) {
+  if (view[EFFECTS] === null) {
+    return;
+  }
+  let tryFlushEffects = true;
+  while (tryFlushEffects) {
+    let foundDirtyEffect = false;
+    for (const effect2 of view[EFFECTS]) {
+      if (!effect2.dirty) {
+        continue;
+      }
+      foundDirtyEffect = true;
+      if (effect2.zone === null || Zone.current === effect2.zone) {
+        effect2.run();
+      } else {
+        effect2.zone.run(() => effect2.run());
+      }
+    }
+    tryFlushEffects = foundDirtyEffect && !!(view[FLAGS] & 8192);
+  }
+}
+var MAXIMUM_REFRESH_RERUNS$1 = 100;
+function detectChangesInternal(lView, mode = 0) {
+  const environment = lView[ENVIRONMENT];
+  const rendererFactory = environment.rendererFactory;
+  const checkNoChangesMode = !!ngDevMode && isInCheckNoChangesMode();
+  if (!checkNoChangesMode) {
+    rendererFactory.begin?.();
+  }
+  try {
+    detectChangesInViewWhileDirty(lView, mode);
+  } finally {
+    if (!checkNoChangesMode) {
+      rendererFactory.end?.();
+    }
+  }
+}
+function detectChangesInViewWhileDirty(lView, mode) {
+  const lastIsRefreshingViewsValue = isRefreshingViews();
+  try {
+    setIsRefreshingViews(true);
+    detectChangesInView(lView, mode);
+    if (ngDevMode && isExhaustiveCheckNoChanges()) {
+      return;
+    }
+    let retries = 0;
+    while (requiresRefreshOrTraversal(lView)) {
+      if (retries === MAXIMUM_REFRESH_RERUNS$1) {
+        throw new RuntimeError(103, ngDevMode && "Infinite change detection while trying to refresh views. There may be components which each cause the other to require a refresh, causing an infinite loop.");
+      }
+      retries++;
+      detectChangesInView(lView, 1);
+    }
+  } finally {
+    setIsRefreshingViews(lastIsRefreshingViewsValue);
+  }
+}
+function checkNoChangesInternal(lView, exhaustive) {
+  setIsInCheckNoChangesMode(exhaustive ? CheckNoChangesMode.Exhaustive : CheckNoChangesMode.OnlyDirtyViews);
+  try {
+    detectChangesInternal(lView);
+  } finally {
+    setIsInCheckNoChangesMode(CheckNoChangesMode.Off);
+  }
+}
+function refreshView(tView, lView, templateFn, context2) {
+  ngDevMode && assertEqual(isCreationMode(lView), false, "Should be run in update mode");
+  if (isDestroyed(lView)) return;
+  const flags = lView[FLAGS];
+  const isInCheckNoChangesPass = ngDevMode && isInCheckNoChangesMode();
+  const isInExhaustiveCheckNoChangesPass = ngDevMode && isExhaustiveCheckNoChanges();
+  enterView(lView);
+  let returnConsumerToPool = true;
+  let prevConsumer = null;
+  let currentConsumer = null;
+  if (!isInCheckNoChangesPass) {
+    if (viewShouldHaveReactiveConsumer(tView)) {
+      currentConsumer = getOrBorrowReactiveLViewConsumer(lView);
+      prevConsumer = consumerBeforeComputation(currentConsumer);
+    } else if (getActiveConsumer() === null) {
+      returnConsumerToPool = false;
+      currentConsumer = getOrCreateTemporaryConsumer(lView);
+      prevConsumer = consumerBeforeComputation(currentConsumer);
+    } else if (lView[REACTIVE_TEMPLATE_CONSUMER]) {
+      consumerDestroy(lView[REACTIVE_TEMPLATE_CONSUMER]);
+      lView[REACTIVE_TEMPLATE_CONSUMER] = null;
+    }
+  }
+  try {
+    resetPreOrderHookFlags(lView);
+    setBindingIndex(tView.bindingStartIndex);
+    if (templateFn !== null) {
+      executeTemplate(tView, lView, templateFn, 2, context2);
+    }
+    const hooksInitPhaseCompleted = (flags & 3) === 3;
+    if (!isInCheckNoChangesPass) {
+      if (hooksInitPhaseCompleted) {
+        const preOrderCheckHooks = tView.preOrderCheckHooks;
+        if (preOrderCheckHooks !== null) {
+          executeCheckHooks(lView, preOrderCheckHooks, null);
+        }
+      } else {
+        const preOrderHooks = tView.preOrderHooks;
+        if (preOrderHooks !== null) {
+          executeInitAndCheckHooks(lView, preOrderHooks, 0, null);
+        }
+        incrementInitPhaseFlags(lView, 0);
+      }
+    }
+    if (!isInExhaustiveCheckNoChangesPass) {
+      markTransplantedViewsForRefresh(lView);
+    }
+    runEffectsInView(lView);
+    detectChangesInEmbeddedViews(lView, 0);
+    if (tView.contentQueries !== null) {
+      refreshContentQueries(tView, lView);
+    }
+    if (!isInCheckNoChangesPass) {
+      if (hooksInitPhaseCompleted) {
+        const contentCheckHooks = tView.contentCheckHooks;
+        if (contentCheckHooks !== null) {
+          executeCheckHooks(lView, contentCheckHooks);
+        }
+      } else {
+        const contentHooks = tView.contentHooks;
+        if (contentHooks !== null) {
+          executeInitAndCheckHooks(lView, contentHooks, 1);
+        }
+        incrementInitPhaseFlags(lView, 1);
+      }
+    }
+    processHostBindingOpCodes(tView, lView);
+    const components = tView.components;
+    if (components !== null) {
+      detectChangesInChildComponents(lView, components, 0);
+    }
+    const viewQuery = tView.viewQuery;
+    if (viewQuery !== null) {
+      executeViewQueryFn(2, viewQuery, context2);
+    }
+    if (!isInCheckNoChangesPass) {
+      if (hooksInitPhaseCompleted) {
+        const viewCheckHooks = tView.viewCheckHooks;
+        if (viewCheckHooks !== null) {
+          executeCheckHooks(lView, viewCheckHooks);
+        }
+      } else {
+        const viewHooks = tView.viewHooks;
+        if (viewHooks !== null) {
+          executeInitAndCheckHooks(lView, viewHooks, 2);
+        }
+        incrementInitPhaseFlags(lView, 2);
+      }
+    }
+    if (tView.firstUpdatePass === true) {
+      tView.firstUpdatePass = false;
+    }
+    if (lView[EFFECTS_TO_SCHEDULE]) {
+      for (const notifyEffect of lView[EFFECTS_TO_SCHEDULE]) {
+        notifyEffect();
+      }
+      lView[EFFECTS_TO_SCHEDULE] = null;
+    }
+    if (!isInCheckNoChangesPass) {
+      addAfterRenderSequencesForView(lView);
+      lView[FLAGS] &= ~(64 | 8);
+    }
+  } catch (e) {
+    if (!isInCheckNoChangesPass) {
+      markAncestorsForTraversal(lView);
+    }
+    throw e;
+  } finally {
+    if (currentConsumer !== null) {
+      consumerAfterComputation(currentConsumer, prevConsumer);
+      if (returnConsumerToPool) {
+        maybeReturnReactiveLViewConsumer(currentConsumer);
+      }
+    }
+    leaveView();
+  }
+}
+function detectChangesInEmbeddedViews(lView, mode) {
+  for (let lContainer = getFirstLContainer(lView); lContainer !== null; lContainer = getNextLContainer(lContainer)) {
+    for (let i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {
+      const embeddedLView = lContainer[i];
+      detectChangesInViewIfAttached(embeddedLView, mode);
+    }
+  }
+}
+function markTransplantedViewsForRefresh(lView) {
+  for (let lContainer = getFirstLContainer(lView); lContainer !== null; lContainer = getNextLContainer(lContainer)) {
+    if (!(lContainer[FLAGS] & 2)) continue;
+    const movedViews = lContainer[MOVED_VIEWS];
+    ngDevMode && assertDefined(movedViews, "Transplanted View flags set but missing MOVED_VIEWS");
+    for (let i = 0; i < movedViews.length; i++) {
+      const movedLView = movedViews[i];
+      markViewForRefresh(movedLView);
+    }
+  }
+}
+function detectChangesInComponent(hostLView, componentHostIdx, mode) {
+  ngDevMode && assertEqual(isCreationMode(hostLView), false, "Should be run in update mode");
+  profiler(ProfilerEvent.ComponentStart);
+  const componentView = getComponentLViewByIndex(componentHostIdx, hostLView);
+  try {
+    detectChangesInViewIfAttached(componentView, mode);
+  } finally {
+    profiler(ProfilerEvent.ComponentEnd, componentView[CONTEXT]);
+  }
+}
+function detectChangesInViewIfAttached(lView, mode) {
+  if (!viewAttachedToChangeDetector(lView)) {
+    return;
+  }
+  detectChangesInView(lView, mode);
+}
+function detectChangesInView(lView, mode) {
+  const isInCheckNoChangesPass = ngDevMode && isInCheckNoChangesMode();
+  const tView = lView[TVIEW];
+  const flags = lView[FLAGS];
+  const consumer = lView[REACTIVE_TEMPLATE_CONSUMER];
+  let shouldRefreshView = !!(mode === 0 && flags & 16);
+  shouldRefreshView ||= !!(flags & 64 && mode === 0 && !isInCheckNoChangesPass);
+  shouldRefreshView ||= !!(flags & 1024);
+  shouldRefreshView ||= !!(consumer?.dirty && consumerPollProducersForChange(consumer));
+  shouldRefreshView ||= !!(ngDevMode && isExhaustiveCheckNoChanges());
+  if (consumer) {
+    consumer.dirty = false;
+  }
+  lView[FLAGS] &= -9217;
+  if (shouldRefreshView) {
+    refreshView(tView, lView, tView.template, lView[CONTEXT]);
+  } else if (flags & 8192) {
+    const prevConsumer = setActiveConsumer(null);
+    try {
+      if (!isInCheckNoChangesPass) {
+        runEffectsInView(lView);
+      }
+      detectChangesInEmbeddedViews(lView, 1);
+      const components = tView.components;
+      if (components !== null) {
+        detectChangesInChildComponents(lView, components, 1);
+      }
+      if (!isInCheckNoChangesPass) {
+        addAfterRenderSequencesForView(lView);
+      }
+    } finally {
+      setActiveConsumer(prevConsumer);
+    }
+  }
+}
+function detectChangesInChildComponents(hostLView, components, mode) {
+  for (let i = 0; i < components.length; i++) {
+    detectChangesInComponent(hostLView, components[i], mode);
+  }
+}
+function processHostBindingOpCodes(tView, lView) {
+  const hostBindingOpCodes = tView.hostBindingOpCodes;
+  if (hostBindingOpCodes === null) return;
+  try {
+    for (let i = 0; i < hostBindingOpCodes.length; i++) {
+      const opCode = hostBindingOpCodes[i];
+      if (opCode < 0) {
+        setSelectedIndex(~opCode);
+      } else {
+        const directiveIdx = opCode;
+        const bindingRootIndx = hostBindingOpCodes[++i];
+        const hostBindingFn = hostBindingOpCodes[++i];
+        setBindingRootForHostBindings(bindingRootIndx, directiveIdx);
+        const context2 = lView[directiveIdx];
+        profiler(ProfilerEvent.HostBindingsUpdateStart, context2);
+        try {
+          hostBindingFn(2, context2);
+        } finally {
+          profiler(ProfilerEvent.HostBindingsUpdateEnd, context2);
+        }
+      }
+    }
+  } finally {
+    setSelectedIndex(-1);
+  }
+}
+function markViewDirty(lView, source) {
+  const dirtyBitsToUse = isRefreshingViews() ? 64 : 1024 | 64;
+  lView[ENVIRONMENT].changeDetectionScheduler?.notify(source);
+  while (lView) {
+    lView[FLAGS] |= dirtyBitsToUse;
+    const parent = getLViewParent(lView);
+    if (isRootView(lView) && !parent) {
+      return lView;
+    }
+    lView = parent;
+  }
+  return null;
+}
+function createLContainer(hostNative, currentView, native, tNode) {
+  ngDevMode && assertLView(currentView);
+  const lContainer = [hostNative, true, 0, currentView, null, tNode, null, native, null, null];
+  ngDevMode && assertEqual(lContainer.length, CONTAINER_HEADER_OFFSET, "Should allocate correct number of slots for LContainer header.");
+  return lContainer;
+}
+function getLViewFromLContainer(lContainer, index) {
+  const adjustedIndex = CONTAINER_HEADER_OFFSET + index;
+  if (adjustedIndex < lContainer.length) {
+    const lView = lContainer[adjustedIndex];
+    ngDevMode && assertLView(lView);
+    return lView;
+  }
+  return void 0;
+}
+function addLViewToLContainer(lContainer, lView, index, addToDOM = true) {
+  const tView = lView[TVIEW];
+  insertView(tView, lView, lContainer, index);
+  if (addToDOM) {
+    const beforeNode = getBeforeNodeForView(index, lContainer);
+    const renderer = lView[RENDERER];
+    const parentRNode = renderer.parentNode(lContainer[NATIVE]);
+    if (parentRNode !== null) {
+      addViewToDOM(tView, lContainer[T_HOST], renderer, lView, parentRNode, beforeNode);
+    }
+  }
+  const hydrationInfo = lView[HYDRATION];
+  if (hydrationInfo !== null && hydrationInfo.firstChild !== null) {
+    hydrationInfo.firstChild = null;
+  }
+}
+function removeLViewFromLContainer(lContainer, index) {
+  const lView = detachView(lContainer, index);
+  if (lView !== void 0) {
+    destroyLView(lView[TVIEW], lView);
+  }
+  return lView;
+}
+function detachView(lContainer, removeIndex) {
+  if (lContainer.length <= CONTAINER_HEADER_OFFSET) return;
+  const indexInContainer = CONTAINER_HEADER_OFFSET + removeIndex;
+  const viewToDetach = lContainer[indexInContainer];
+  if (viewToDetach) {
+    const declarationLContainer = viewToDetach[DECLARATION_LCONTAINER];
+    if (declarationLContainer !== null && declarationLContainer !== lContainer) {
+      detachMovedView(declarationLContainer, viewToDetach);
+    }
+    if (removeIndex > 0) {
+      lContainer[indexInContainer - 1][NEXT] = viewToDetach[NEXT];
+    }
+    const removedLView = removeFromArray(lContainer, CONTAINER_HEADER_OFFSET + removeIndex);
+    removeViewFromDOM(viewToDetach[TVIEW], viewToDetach);
+    const lQueries = removedLView[QUERIES];
+    if (lQueries !== null) {
+      lQueries.detachView(removedLView[TVIEW]);
+    }
+    viewToDetach[PARENT] = null;
+    viewToDetach[NEXT] = null;
+    viewToDetach[FLAGS] &= -129;
+  }
+  return viewToDetach;
+}
+function insertView(tView, lView, lContainer, index) {
+  ngDevMode && assertLView(lView);
+  ngDevMode && assertLContainer(lContainer);
+  const indexInContainer = CONTAINER_HEADER_OFFSET + index;
+  const containerLength = lContainer.length;
+  if (index > 0) {
+    lContainer[indexInContainer - 1][NEXT] = lView;
+  }
+  if (index < containerLength - CONTAINER_HEADER_OFFSET) {
+    lView[NEXT] = lContainer[indexInContainer];
+    addToArray(lContainer, CONTAINER_HEADER_OFFSET + index, lView);
+  } else {
+    lContainer.push(lView);
+    lView[NEXT] = null;
+  }
+  lView[PARENT] = lContainer;
+  const declarationLContainer = lView[DECLARATION_LCONTAINER];
+  if (declarationLContainer !== null && lContainer !== declarationLContainer) {
+    trackMovedView(declarationLContainer, lView);
+  }
+  const lQueries = lView[QUERIES];
+  if (lQueries !== null) {
+    lQueries.insertView(tView);
+  }
+  updateAncestorTraversalFlagsOnAttach(lView);
+  lView[FLAGS] |= 128;
+}
+function trackMovedView(declarationContainer, lView) {
+  ngDevMode && assertDefined(lView, "LView required");
+  ngDevMode && assertLContainer(declarationContainer);
+  const movedViews = declarationContainer[MOVED_VIEWS];
+  const parent = lView[PARENT];
+  ngDevMode && assertDefined(parent, "missing parent");
+  if (isLView(parent)) {
+    declarationContainer[FLAGS] |= 2;
+  } else {
+    const insertedComponentLView = parent[PARENT][DECLARATION_COMPONENT_VIEW];
+    ngDevMode && assertDefined(insertedComponentLView, "Missing insertedComponentLView");
+    const declaredComponentLView = lView[DECLARATION_COMPONENT_VIEW];
+    ngDevMode && assertDefined(declaredComponentLView, "Missing declaredComponentLView");
+    if (declaredComponentLView !== insertedComponentLView) {
+      declarationContainer[FLAGS] |= 2;
+    }
+  }
+  if (movedViews === null) {
+    declarationContainer[MOVED_VIEWS] = [lView];
+  } else {
+    movedViews.push(lView);
+  }
+}
+var ViewRef = class {
+  _lView;
+  _cdRefInjectingView;
+  _appRef = null;
+  _attachedToViewContainer = false;
+  exhaustive;
+  get rootNodes() {
+    const lView = this._lView;
+    const tView = lView[TVIEW];
+    return collectNativeNodes(tView, lView, tView.firstChild, []);
+  }
+  constructor(_lView, _cdRefInjectingView) {
+    this._lView = _lView;
+    this._cdRefInjectingView = _cdRefInjectingView;
+  }
+  get context() {
+    return this._lView[CONTEXT];
+  }
+  set context(value) {
+    if (ngDevMode) {
+      console.warn("Angular: Replacing the `context` object of an `EmbeddedViewRef` is deprecated.");
+    }
+    this._lView[CONTEXT] = value;
+  }
+  get destroyed() {
+    return isDestroyed(this._lView);
+  }
+  destroy() {
+    if (this._appRef) {
+      this._appRef.detachView(this);
+    } else if (this._attachedToViewContainer) {
+      const parent = this._lView[PARENT];
+      if (isLContainer(parent)) {
+        const viewRefs = parent[VIEW_REFS];
+        const index = viewRefs ? viewRefs.indexOf(this) : -1;
+        if (index > -1) {
+          ngDevMode && assertEqual(index, parent.indexOf(this._lView) - CONTAINER_HEADER_OFFSET, "An attached view should be in the same position within its container as its ViewRef in the VIEW_REFS array.");
+          detachView(parent, index);
+          removeFromArray(viewRefs, index);
+        }
+      }
+      this._attachedToViewContainer = false;
+    }
+    destroyLView(this._lView[TVIEW], this._lView);
+  }
+  onDestroy(callback) {
+    storeLViewOnDestroy(this._lView, callback);
+  }
+  markForCheck() {
+    markViewDirty(this._cdRefInjectingView || this._lView, 4);
+  }
+  detach() {
+    this._lView[FLAGS] &= -129;
+  }
+  reattach() {
+    updateAncestorTraversalFlagsOnAttach(this._lView);
+    this._lView[FLAGS] |= 128;
+  }
+  detectChanges() {
+    this._lView[FLAGS] |= 1024;
+    detectChangesInternal(this._lView);
+  }
+  checkNoChanges() {
+    if (ngDevMode) {
+      try {
+        this.exhaustive ??= this._lView[INJECTOR].get(UseExhaustiveCheckNoChanges, USE_EXHAUSTIVE_CHECK_NO_CHANGES_DEFAULT);
+      } catch {
+        this.exhaustive = USE_EXHAUSTIVE_CHECK_NO_CHANGES_DEFAULT;
+      }
+      checkNoChangesInternal(this._lView, this.exhaustive);
+    }
+  }
+  attachToViewContainerRef() {
+    if (this._appRef) {
+      throw new RuntimeError(902, ngDevMode && "This view is already attached directly to the ApplicationRef!");
+    }
+    this._attachedToViewContainer = true;
+  }
+  detachFromAppRef() {
+    this._appRef = null;
+    const isRoot = isRootView(this._lView);
+    const declarationContainer = this._lView[DECLARATION_LCONTAINER];
+    if (declarationContainer !== null && !isRoot) {
+      detachMovedView(declarationContainer, this._lView);
+    }
+    detachViewFromDOM(this._lView[TVIEW], this._lView);
+  }
+  attachToAppRef(appRef) {
+    if (this._attachedToViewContainer) {
+      throw new RuntimeError(902, ngDevMode && "This view is already attached to a ViewContainer!");
+    }
+    this._appRef = appRef;
+    const isRoot = isRootView(this._lView);
+    const declarationContainer = this._lView[DECLARATION_LCONTAINER];
+    if (declarationContainer !== null && !isRoot) {
+      trackMovedView(declarationContainer, this._lView);
+    }
+    updateAncestorTraversalFlagsOnAttach(this._lView);
+  }
+};
+var TemplateRef = class {
+  _declarationLView;
+  _declarationTContainer;
+  elementRef;
+  static __NG_ELEMENT_ID__ = injectTemplateRef;
+  constructor(_declarationLView, _declarationTContainer, elementRef) {
+    this._declarationLView = _declarationLView;
+    this._declarationTContainer = _declarationTContainer;
+    this.elementRef = elementRef;
+  }
+  get ssrId() {
+    return this._declarationTContainer.tView?.ssrId || null;
+  }
+  createEmbeddedView(context2, injector) {
+    return this.createEmbeddedViewImpl(context2, injector);
+  }
+  createEmbeddedViewImpl(context2, injector, dehydratedView) {
+    const embeddedLView = createAndRenderEmbeddedLView(this._declarationLView, this._declarationTContainer, context2, {
+      embeddedViewInjector: injector,
+      dehydratedView
+    });
+    return new ViewRef(embeddedLView);
+  }
+};
+function injectTemplateRef() {
+  return createTemplateRef(getCurrentTNode(), getLView());
+}
+function createTemplateRef(hostTNode, hostLView) {
+  if (hostTNode.type & 4) {
+    ngDevMode && assertDefined(hostTNode.tView, "TView must be allocated");
+    return new TemplateRef(hostLView, hostTNode, createElementRef(hostTNode, hostLView));
+  }
+  return null;
+}
+var AT_THIS_LOCATION = "<-- AT THIS LOCATION";
+var THIRD_PARTY_SCRIPTS_URL = `/guide/hydration#third-party-scripts-with-dom-manipulation`;
+function getFriendlyStringFromTNodeType(tNodeType) {
+  switch (tNodeType) {
+    case 4:
+      return "view container";
+    case 2:
+      return "element";
+    case 8:
+      return "ng-container";
+    case 32:
+      return "icu";
+    case 64:
+      return "i18n";
+    case 16:
+      return "projection";
+    case 1:
+      return "text";
+    case 128:
+      return "@let";
+    default:
+      return "<unknown>";
+  }
+}
+function validateSiblingNodeExists(node) {
+  validateNodeExists(node);
+  if (!node.nextSibling) {
+    const header = "During hydration Angular expected more sibling nodes to be present.\n\n";
+    const actual = `Actual DOM is:
+
+${describeDomFromNode(node)}
+
+`;
+    const footer = getHydrationErrorFooter();
+    const message = header + actual + footer;
+    markRNodeAsHavingHydrationMismatch(node, "", actual);
+    throw new RuntimeError(-501, message);
+  }
+}
+function validateNodeExists(node, lView = null, tNode = null) {
+  if (!node) {
+    const header = "During hydration, Angular expected an element to be present at this location.\n\n";
+    let expected = "";
+    let footer = "";
+    if (lView !== null && tNode !== null) {
+      expected = describeExpectedDom(lView, tNode, false);
+      footer = getHydrationErrorFooter();
+      markRNodeAsHavingHydrationMismatch(unwrapRNode(lView[HOST]), expected, "");
+    }
+    throw new RuntimeError(-502, `${header}${expected}
+
+${footer}`);
+  }
+}
+function stringifyTNodeAttrs(tNode) {
+  const results = [];
+  if (tNode.attrs) {
+    for (let i = 0; i < tNode.attrs.length; ) {
+      const attrName = tNode.attrs[i++];
+      if (typeof attrName == "number") {
+        break;
+      }
+      const attrValue = tNode.attrs[i++];
+      results.push(`${attrName}="${shorten(attrValue)}"`);
+    }
+  }
+  return results.join(" ");
+}
+var internalAttrs = /* @__PURE__ */ new Set(["ngh", "ng-version", "ng-server-context"]);
+function stringifyRNodeAttrs(rNode) {
+  const results = [];
+  for (let i = 0; i < rNode.attributes.length; i++) {
+    const attr = rNode.attributes[i];
+    if (internalAttrs.has(attr.name)) continue;
+    results.push(`${attr.name}="${shorten(attr.value)}"`);
+  }
+  return results.join(" ");
+}
+function describeTNode(tNode, innerContent = "\u2026") {
+  switch (tNode.type) {
+    case 1:
+      const content = tNode.value ? `(${tNode.value})` : "";
+      return `#text${content}`;
+    case 2:
+      const attrs = stringifyTNodeAttrs(tNode);
+      const tag = tNode.value.toLowerCase();
+      return `<${tag}${attrs ? " " + attrs : ""}>${innerContent}</${tag}>`;
+    case 8:
+      return "<!-- ng-container -->";
+    case 4:
+      return "<!-- container -->";
+    default:
+      const typeAsString = getFriendlyStringFromTNodeType(tNode.type);
+      return `#node(${typeAsString})`;
+  }
+}
+function describeRNode(rNode, innerContent = "\u2026") {
+  const node = rNode;
+  switch (node.nodeType) {
+    case Node.ELEMENT_NODE:
+      const tag = node.tagName.toLowerCase();
+      const attrs = stringifyRNodeAttrs(node);
+      return `<${tag}${attrs ? " " + attrs : ""}>${innerContent}</${tag}>`;
+    case Node.TEXT_NODE:
+      const content = node.textContent ? shorten(node.textContent) : "";
+      return `#text${content ? `(${content})` : ""}`;
+    case Node.COMMENT_NODE:
+      return `<!-- ${shorten(node.textContent ?? "")} -->`;
+    default:
+      return `#node(${node.nodeType})`;
+  }
+}
+function describeExpectedDom(lView, tNode, isViewContainerAnchor) {
+  const spacer = "  ";
+  let content = "";
+  if (tNode.prev) {
+    content += spacer + "\u2026\n";
+    content += spacer + describeTNode(tNode.prev) + "\n";
+  } else if (tNode.type && tNode.type & 12) {
+    content += spacer + "\u2026\n";
+  }
+  if (isViewContainerAnchor) {
+    content += spacer + describeTNode(tNode) + "\n";
+    content += spacer + `<!-- container -->  ${AT_THIS_LOCATION}
+`;
+  } else {
+    content += spacer + describeTNode(tNode) + `  ${AT_THIS_LOCATION}
+`;
+  }
+  content += spacer + "\u2026\n";
+  const parentRNode = tNode.type ? getParentRElement(lView[TVIEW], tNode, lView) : null;
+  if (parentRNode) {
+    content = describeRNode(parentRNode, "\n" + content);
+  }
+  return content;
+}
+function describeDomFromNode(node) {
+  const spacer = "  ";
+  let content = "";
+  const currentNode = node;
+  if (currentNode.previousSibling) {
+    content += spacer + "\u2026\n";
+    content += spacer + describeRNode(currentNode.previousSibling) + "\n";
+  }
+  content += spacer + describeRNode(currentNode) + `  ${AT_THIS_LOCATION}
+`;
+  if (node.nextSibling) {
+    content += spacer + "\u2026\n";
+  }
+  if (node.parentNode) {
+    content = describeRNode(currentNode.parentNode, "\n" + content);
+  }
+  return content;
+}
+function getHydrationErrorFooter(componentClassName) {
+  const componentInfo = componentClassName ? `the "${componentClassName}"` : "corresponding";
+  return `To fix this problem:
+  * check ${componentInfo} component for hydration-related issues
+  * check to see if your template has valid HTML structure
+  * check if there are any third-party scripts that manipulate the DOM. More info: ${DOC_PAGE_BASE_URL}${THIRD_PARTY_SCRIPTS_URL}
+  * or skip hydration by adding the \`ngSkipHydration\` attribute to its host node in a template
+
+`;
+}
+function stripNewlines(input2) {
+  return input2.replace(/\s+/gm, "");
+}
+function shorten(input2, maxLength = 50) {
+  if (!input2) {
+    return "";
+  }
+  input2 = stripNewlines(input2);
+  return input2.length > maxLength ? `${input2.substring(0, maxLength - 1)}\u2026` : input2;
+}
+function getInsertInFrontOfRNodeWithI18n(parentTNode, currentTNode, lView) {
+  const tNodeInsertBeforeIndex = currentTNode.insertBeforeIndex;
+  const insertBeforeIndex = Array.isArray(tNodeInsertBeforeIndex) ? tNodeInsertBeforeIndex[0] : tNodeInsertBeforeIndex;
+  if (insertBeforeIndex === null) {
+    return getInsertInFrontOfRNodeWithNoI18n(parentTNode, currentTNode, lView);
+  } else {
+    ngDevMode && assertIndexInRange(lView, insertBeforeIndex);
+    return unwrapRNode(lView[insertBeforeIndex]);
+  }
+}
+function processI18nInsertBefore(renderer, childTNode, lView, childRNode, parentRElement) {
+  const tNodeInsertBeforeIndex = childTNode.insertBeforeIndex;
+  if (Array.isArray(tNodeInsertBeforeIndex)) {
+    ngDevMode && assertDomNode(childRNode);
+    let i18nParent = childRNode;
+    let anchorRNode = null;
+    if (!(childTNode.type & 3)) {
+      anchorRNode = i18nParent;
+      i18nParent = parentRElement;
+    }
+    if (i18nParent !== null && childTNode.componentOffset === -1) {
+      for (let i = 1; i < tNodeInsertBeforeIndex.length; i++) {
+        const i18nChild = lView[tNodeInsertBeforeIndex[i]];
+        nativeInsertBefore(renderer, i18nParent, i18nChild, anchorRNode, false);
+      }
+    }
+  }
+}
+function getOrCreateTNode(tView, index, type, name, attrs) {
+  ngDevMode && index !== 0 && assertGreaterThanOrEqual(index, HEADER_OFFSET, "TNodes can't be in the LView header.");
+  ngDevMode && assertPureTNodeType(type);
+  let tNode = tView.data[index];
+  if (tNode === null) {
+    tNode = createTNodeAtIndex(tView, index, type, name, attrs);
+    if (isInI18nBlock()) {
+      tNode.flags |= 32;
+    }
+  } else if (tNode.type & 64) {
+    tNode.type = type;
+    tNode.value = name;
+    tNode.attrs = attrs;
+    const parent = getCurrentParentTNode();
+    tNode.injectorIndex = parent === null ? -1 : parent.injectorIndex;
+    ngDevMode && assertTNodeForTView(tNode, tView);
+    ngDevMode && assertEqual(index, tNode.index, "Expecting same index");
+  }
+  setCurrentTNode(tNode, true);
+  return tNode;
+}
+function createTNodeAtIndex(tView, index, type, name, attrs) {
+  const currentTNode = getCurrentTNodePlaceholderOk();
+  const isParent = isCurrentTNodeParent();
+  const parent = isParent ? currentTNode : currentTNode && currentTNode.parent;
+  const tNode = tView.data[index] = createTNode(tView, parent, type, index, name, attrs);
+  linkTNodeInTView(tView, tNode, currentTNode, isParent);
+  return tNode;
+}
+function linkTNodeInTView(tView, tNode, currentTNode, isParent) {
+  if (tView.firstChild === null) {
+    tView.firstChild = tNode;
+  }
+  if (currentTNode !== null) {
+    if (isParent) {
+      if (currentTNode.child == null && tNode.parent !== null) {
+        currentTNode.child = tNode;
+      }
+    } else {
+      if (currentTNode.next === null) {
+        currentTNode.next = tNode;
+        tNode.prev = currentTNode;
+      }
+    }
+  }
+}
+function createTNode(tView, tParent, type, index, value, attrs) {
+  ngDevMode && index !== 0 && assertGreaterThanOrEqual(index, HEADER_OFFSET, "TNodes can't be in the LView header.");
+  ngDevMode && assertNotSame(attrs, void 0, "'undefined' is not valid value for 'attrs'");
+  ngDevMode && tParent && assertTNodeForTView(tParent, tView);
+  let injectorIndex = tParent ? tParent.injectorIndex : -1;
+  let flags = 0;
+  if (isInSkipHydrationBlock()) {
+    flags |= 128;
+  }
+  const tNode = {
+    type,
+    index,
+    insertBeforeIndex: null,
+    injectorIndex,
+    directiveStart: -1,
+    directiveEnd: -1,
+    directiveStylingLast: -1,
+    componentOffset: -1,
+    controlDirectiveIndex: -1,
+    customControlIndex: -1,
+    propertyBindings: null,
+    flags,
+    providerIndexes: 0,
+    value,
+    namespace: getNamespace(),
+    attrs,
+    mergedAttrs: null,
+    localNames: null,
+    initialInputs: null,
+    inputs: null,
+    hostDirectiveInputs: null,
+    outputs: null,
+    hostDirectiveOutputs: null,
+    directiveToIndex: null,
+    tView: null,
+    next: null,
+    prev: null,
+    projectionNext: null,
+    child: null,
+    parent: tParent,
+    projection: null,
+    styles: null,
+    stylesWithoutHost: null,
+    residualStyles: void 0,
+    classes: null,
+    classesWithoutHost: null,
+    residualClasses: void 0,
+    classBindings: 0,
+    styleBindings: 0
+  };
+  if (ngDevMode) {
+    Object.seal(tNode);
+  }
+  return tNode;
+}
+function addTNodeAndUpdateInsertBeforeIndex(previousTNodes, newTNode) {
+  ngDevMode && assertEqual(newTNode.insertBeforeIndex, null, "We expect that insertBeforeIndex is not set");
+  previousTNodes.push(newTNode);
+  if (previousTNodes.length > 1) {
+    for (let i = previousTNodes.length - 2; i >= 0; i--) {
+      const existingTNode = previousTNodes[i];
+      if (!isI18nText(existingTNode)) {
+        if (isNewTNodeCreatedBefore(existingTNode, newTNode) && getInsertBeforeIndex(existingTNode) === null) {
+          setInsertBeforeIndex(existingTNode, newTNode.index);
+        }
+      }
+    }
+  }
+}
+function isI18nText(tNode) {
+  return !(tNode.type & 64);
+}
+function isNewTNodeCreatedBefore(existingTNode, newTNode) {
+  return isI18nText(newTNode) || existingTNode.index > newTNode.index;
+}
+function getInsertBeforeIndex(tNode) {
+  const index = tNode.insertBeforeIndex;
+  return Array.isArray(index) ? index[0] : index;
+}
+function setInsertBeforeIndex(tNode, value) {
+  const index = tNode.insertBeforeIndex;
+  if (Array.isArray(index)) {
+    index[0] = value;
+  } else {
+    setI18nHandling(getInsertInFrontOfRNodeWithI18n, processI18nInsertBefore);
+    tNode.insertBeforeIndex = value;
+  }
+}
+function getTIcu(tView, index) {
+  const value = tView.data[index];
+  if (value === null || typeof value === "string") return null;
+  if (ngDevMode && !(value.hasOwnProperty("tView") || value.hasOwnProperty("currentCaseLViewIndex"))) {
+    throwError2("We expect to get 'null'|'TIcu'|'TIcuContainer', but got: " + value);
+  }
+  const tIcu = value.hasOwnProperty("currentCaseLViewIndex") ? value : value.value;
+  ngDevMode && assertTIcu(tIcu);
+  return tIcu;
+}
+function setTIcu(tView, index, tIcu) {
+  const tNode = tView.data[index];
+  ngDevMode && assertEqual(tNode === null || tNode.hasOwnProperty("tView"), true, "We expect to get 'null'|'TIcuContainer'");
+  if (tNode === null) {
+    tView.data[index] = tIcu;
+  } else {
+    ngDevMode && assertTNodeType(tNode, 32);
+    tNode.value = tIcu;
+  }
+}
+function setTNodeInsertBeforeIndex(tNode, index) {
+  ngDevMode && assertTNode(tNode);
+  let insertBeforeIndex = tNode.insertBeforeIndex;
+  if (insertBeforeIndex === null) {
+    setI18nHandling(getInsertInFrontOfRNodeWithI18n, processI18nInsertBefore);
+    insertBeforeIndex = tNode.insertBeforeIndex = [null, index];
+  } else {
+    assertEqual(Array.isArray(insertBeforeIndex), true, "Expecting array here");
+    insertBeforeIndex.push(index);
+  }
+}
+function createTNodePlaceholder(tView, previousTNodes, index) {
+  const tNode = createTNodeAtIndex(tView, index, 64, null, null);
+  addTNodeAndUpdateInsertBeforeIndex(previousTNodes, tNode);
+  return tNode;
+}
+function getCurrentICUCaseIndex(tIcu, lView) {
+  const currentCase = lView[tIcu.currentCaseLViewIndex];
+  return currentCase === null ? currentCase : currentCase < 0 ? ~currentCase : currentCase;
+}
+function getParentFromIcuCreateOpCode(mergedCode) {
+  return mergedCode >>> 17;
+}
+function getRefFromIcuCreateOpCode(mergedCode) {
+  return (mergedCode & 131070) >>> 1;
+}
+function getInstructionFromIcuCreateOpCode(mergedCode) {
+  return mergedCode & 1;
+}
+function icuCreateOpCode(opCode, parentIdx, refIdx) {
+  ngDevMode && assertGreaterThanOrEqual(parentIdx, 0, "Missing parent index");
+  ngDevMode && assertGreaterThan(refIdx, 0, "Missing ref index");
+  return opCode | parentIdx << 17 | refIdx << 1;
+}
+function isRootTemplateMessage(subTemplateIndex) {
+  return subTemplateIndex === -1;
+}
+function enterIcu(state, tIcu, lView) {
+  state.index = 0;
+  const currentCase = getCurrentICUCaseIndex(tIcu, lView);
+  if (currentCase !== null) {
+    ngDevMode && assertNumberInRange(currentCase, 0, tIcu.cases.length - 1);
+    state.removes = tIcu.remove[currentCase];
+  } else {
+    state.removes = EMPTY_ARRAY;
+  }
+}
+function icuContainerIteratorNext(state) {
+  if (state.index < state.removes.length) {
+    const removeOpCode = state.removes[state.index++];
+    ngDevMode && assertNumber(removeOpCode, "Expecting OpCode number");
+    if (removeOpCode > 0) {
+      const rNode = state.lView[removeOpCode];
+      ngDevMode && assertDomNode(rNode);
+      return rNode;
+    } else {
+      state.stack.push(state.index, state.removes);
+      const tIcuIndex = ~removeOpCode;
+      const tIcu = state.lView[TVIEW].data[tIcuIndex];
+      ngDevMode && assertTIcu(tIcu);
+      enterIcu(state, tIcu, state.lView);
+      return icuContainerIteratorNext(state);
+    }
+  } else {
+    if (state.stack.length === 0) {
+      state.lView = void 0;
+      return null;
+    } else {
+      state.removes = state.stack.pop();
+      state.index = state.stack.pop();
+      return icuContainerIteratorNext(state);
+    }
+  }
+}
+function loadIcuContainerVisitor() {
+  const _state = {
+    stack: [],
+    index: -1
+  };
+  function icuContainerIteratorStart(tIcuContainerNode, lView) {
+    _state.lView = lView;
+    while (_state.stack.length) _state.stack.pop();
+    ngDevMode && assertTNodeForLView(tIcuContainerNode, lView);
+    enterIcu(_state, tIcuContainerNode.value, lView);
+    return icuContainerIteratorNext.bind(null, _state);
+  }
+  return icuContainerIteratorStart;
+}
+var _prepareI18nBlockForHydrationImpl = () => {
+};
+function prepareI18nBlockForHydration(lView, index, parentTNode, subTemplateIndex) {
+  _prepareI18nBlockForHydrationImpl(lView, index, parentTNode, subTemplateIndex);
+}
+var _claimDehydratedIcuCaseImpl = () => {
+};
+function claimDehydratedIcuCase(lView, icuIndex, caseIndex) {
+  _claimDehydratedIcuCaseImpl(lView, icuIndex, caseIndex);
+}
+function cleanupI18nHydrationData(lView) {
+  const hydrationInfo = lView[HYDRATION];
+  if (hydrationInfo) {
+    const {
+      i18nNodes,
+      dehydratedIcuData: dehydratedIcuDataMap
+    } = hydrationInfo;
+    if (i18nNodes && dehydratedIcuDataMap) {
+      const renderer = lView[RENDERER];
+      for (const dehydratedIcuData of dehydratedIcuDataMap.values()) {
+        cleanupDehydratedIcuData(renderer, i18nNodes, dehydratedIcuData);
+      }
+    }
+    hydrationInfo.i18nNodes = void 0;
+    hydrationInfo.dehydratedIcuData = void 0;
+  }
+}
+function cleanupDehydratedIcuData(renderer, i18nNodes, dehydratedIcuData) {
+  for (const node of dehydratedIcuData.node.cases[dehydratedIcuData.case]) {
+    const rNode = i18nNodes.get(node.index - HEADER_OFFSET);
+    if (rNode) {
+      nativeRemoveNode(renderer, rNode, false);
+    }
+  }
+}
+function removeDehydratedViews(lContainer) {
+  const views = lContainer[DEHYDRATED_VIEWS] ?? [];
+  const parentLView = lContainer[PARENT];
+  const renderer = parentLView[RENDERER];
+  const retainedViews = [];
+  for (const view of views) {
+    if (view.data[DEFER_BLOCK_ID] !== void 0) {
+      retainedViews.push(view);
+    } else {
+      removeDehydratedView(view, renderer);
+      ngDevMode && ngDevMode.dehydratedViewsRemoved++;
+    }
+  }
+  lContainer[DEHYDRATED_VIEWS] = retainedViews;
+}
+function removeDehydratedViewList(deferBlock) {
+  const {
+    lContainer
+  } = deferBlock;
+  const dehydratedViews = lContainer[DEHYDRATED_VIEWS];
+  if (dehydratedViews === null) return;
+  const parentLView = lContainer[PARENT];
+  const renderer = parentLView[RENDERER];
+  for (const view of dehydratedViews) {
+    removeDehydratedView(view, renderer);
+    ngDevMode && ngDevMode.dehydratedViewsRemoved++;
+  }
+}
+function removeDehydratedView(dehydratedView, renderer) {
+  let nodesRemoved = 0;
+  let currentRNode = dehydratedView.firstChild;
+  if (currentRNode) {
+    const numNodes = dehydratedView.data[NUM_ROOT_NODES];
+    while (nodesRemoved < numNodes) {
+      ngDevMode && validateSiblingNodeExists(currentRNode);
+      const nextSibling = currentRNode.nextSibling;
+      nativeRemoveNode(renderer, currentRNode, false);
+      currentRNode = nextSibling;
+      nodesRemoved++;
+    }
+  }
+}
+function cleanupLContainer(lContainer) {
+  removeDehydratedViews(lContainer);
+  const hostLView = lContainer[HOST];
+  if (isLView(hostLView)) {
+    cleanupLView(hostLView);
+  }
+  for (let i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {
+    cleanupLView(lContainer[i]);
+  }
+}
+function cleanupLView(lView) {
+  cleanupI18nHydrationData(lView);
+  const tView = lView[TVIEW];
+  for (let i = HEADER_OFFSET; i < tView.bindingStartIndex; i++) {
+    if (isLContainer(lView[i])) {
+      const lContainer = lView[i];
+      cleanupLContainer(lContainer);
+    } else if (isLView(lView[i])) {
+      cleanupLView(lView[i]);
+    }
+  }
+}
+function cleanupDehydratedViews(appRef) {
+  const viewRefs = appRef._views;
+  for (const viewRef of viewRefs) {
+    const lNode = getLNodeForHydration(viewRef);
+    if (lNode !== null && lNode[HOST] !== null) {
+      if (isLView(lNode)) {
+        cleanupLView(lNode);
+      } else {
+        cleanupLContainer(lNode);
+      }
+      ngDevMode && ngDevMode.dehydratedViewsCleanupRuns++;
+    }
+  }
+}
+function cleanupHydratedDeferBlocks(deferBlock, hydratedBlocks, registry, appRef) {
+  if (deferBlock !== null) {
+    registry.cleanup(hydratedBlocks);
+    cleanupLContainer(deferBlock.lContainer);
+    cleanupDehydratedViews(appRef);
+  }
+}
+var _findMatchingDehydratedViewImpl = () => null;
+var _findAndReconcileMatchingDehydratedViewsImpl = () => null;
+function findMatchingDehydratedView(lContainer, template) {
+  return _findMatchingDehydratedViewImpl(lContainer, template);
+}
+function findAndReconcileMatchingDehydratedViews(lContainer, templateTNode, hostLView) {
+  return _findAndReconcileMatchingDehydratedViewsImpl(lContainer, templateTNode, hostLView);
+}
+var ComponentRef$1 = class ComponentRef {
+};
+var ComponentFactory$1 = class ComponentFactory {
+};
+var _NullComponentFactoryResolver = class {
+  resolveComponentFactory(component) {
+    throw new RuntimeError(917, typeof ngDevMode !== "undefined" && ngDevMode && `No component factory found for ${stringify(component)}.`);
+  }
+};
+var ComponentFactoryResolver$1 = class ComponentFactoryResolver {
+  static NULL = new _NullComponentFactoryResolver();
+};
+var RendererFactory2 = class {
+};
+var Renderer2 = class {
+  destroyNode = null;
+  static __NG_ELEMENT_ID__ = () => injectRenderer2();
+};
+function injectRenderer2() {
+  const lView = getLView();
+  const tNode = getCurrentTNode();
+  const nodeAtIndex = getComponentLViewByIndex(tNode.index, lView);
+  return (isLView(nodeAtIndex) ? nodeAtIndex : lView)[RENDERER];
+}
+var Sanitizer = class _Sanitizer {
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _Sanitizer,
+    providedIn: "root",
+    factory: () => null
+  });
+};
+function isModuleWithProviders(value) {
+  return value.ngModule !== void 0;
+}
+function isNgModule(value) {
+  return !!getNgModuleDef(value);
+}
+function isPipe(value) {
+  return !!getPipeDef(value);
+}
+function isDirective(value) {
+  return !!getDirectiveDef(value);
+}
+function isComponent(value) {
+  return !!getComponentDef(value);
+}
+function getDependencyTypeForError(type) {
+  if (getComponentDef(type)) return "component";
+  if (getDirectiveDef(type)) return "directive";
+  if (getPipeDef(type)) return "pipe";
+  return "type";
+}
+function verifyStandaloneImport(depType, importingType) {
+  if (isForwardRef(depType)) {
+    depType = resolveForwardRef(depType);
+    if (!depType) {
+      throw new Error(`Expected forwardRef function, imported from "${stringifyForError(importingType)}", to return a standalone entity or NgModule but got "${stringifyForError(depType) || depType}".`);
+    }
+  }
+  if (getNgModuleDef(depType) == null) {
+    const def = getComponentDef(depType) || getDirectiveDef(depType) || getPipeDef(depType);
+    if (def != null) {
+      if (!def.standalone) {
+        const type = getDependencyTypeForError(depType);
+        throw new Error(`The "${stringifyForError(depType)}" ${type}, imported from "${stringifyForError(importingType)}", is not standalone. Does the ${type} have the standalone: false flag?`);
+      }
+    } else {
+      if (isModuleWithProviders(depType)) {
+        throw new Error(`A module with providers was imported from "${stringifyForError(importingType)}". Modules with providers are not supported in standalone components imports.`);
+      } else {
+        throw new Error(`The "${stringifyForError(depType)}" type, imported from "${stringifyForError(importingType)}", must be a standalone component / directive / pipe or an NgModule. Did you forget to add the required @Component / @Directive / @Pipe or @NgModule annotation?`);
+      }
+    }
+  }
+}
+var DepsTracker = class {
+  ownerNgModule = /* @__PURE__ */ new WeakMap();
+  ngModulesWithSomeUnresolvedDecls = /* @__PURE__ */ new Set();
+  ngModulesScopeCache = /* @__PURE__ */ new WeakMap();
+  standaloneComponentsScopeCache = /* @__PURE__ */ new WeakMap();
+  resolveNgModulesDecls() {
+    if (this.ngModulesWithSomeUnresolvedDecls.size === 0) {
+      return;
+    }
+    for (const moduleType of this.ngModulesWithSomeUnresolvedDecls) {
+      const def = getNgModuleDef(moduleType);
+      if (def?.declarations) {
+        for (const decl of maybeUnwrapFn(def.declarations)) {
+          if (isComponent(decl)) {
+            this.ownerNgModule.set(decl, moduleType);
+          }
+        }
+      }
+    }
+    this.ngModulesWithSomeUnresolvedDecls.clear();
+  }
+  getComponentDependencies(type, rawImports) {
+    this.resolveNgModulesDecls();
+    const def = getComponentDef(type);
+    if (def === null) {
+      throw new Error(`Attempting to get component dependencies for a type that is not a component: ${type}`);
+    }
+    if (def.standalone) {
+      const scope = this.getStandaloneComponentScope(type, rawImports);
+      if (scope.compilation.isPoisoned) {
+        return {
+          dependencies: []
+        };
+      }
+      return {
+        dependencies: [...scope.compilation.directives, ...scope.compilation.pipes, ...scope.compilation.ngModules]
+      };
+    } else {
+      if (!this.ownerNgModule.has(type)) {
+        return {
+          dependencies: []
+        };
+      }
+      const scope = this.getNgModuleScope(this.ownerNgModule.get(type));
+      if (scope.compilation.isPoisoned) {
+        return {
+          dependencies: []
+        };
+      }
+      return {
+        dependencies: [...scope.compilation.directives, ...scope.compilation.pipes]
+      };
+    }
+  }
+  registerNgModule(type, scopeInfo) {
+    if (!isNgModule(type)) {
+      throw new Error(`Attempting to register a Type which is not NgModule as NgModule: ${type}`);
+    }
+    this.ngModulesWithSomeUnresolvedDecls.add(type);
+  }
+  clearScopeCacheFor(type) {
+    this.ngModulesScopeCache.delete(type);
+    this.standaloneComponentsScopeCache.delete(type);
+  }
+  getNgModuleScope(type) {
+    if (this.ngModulesScopeCache.has(type)) {
+      return this.ngModulesScopeCache.get(type);
+    }
+    const scope = this.computeNgModuleScope(type);
+    this.ngModulesScopeCache.set(type, scope);
+    return scope;
+  }
+  computeNgModuleScope(type) {
+    const def = getNgModuleDefOrThrow(type);
+    const scope = {
+      exported: {
+        directives: /* @__PURE__ */ new Set(),
+        pipes: /* @__PURE__ */ new Set()
+      },
+      compilation: {
+        directives: /* @__PURE__ */ new Set(),
+        pipes: /* @__PURE__ */ new Set()
+      }
+    };
+    for (const imported of maybeUnwrapFn(def.imports)) {
+      if (isNgModule(imported)) {
+        const importedScope = this.getNgModuleScope(imported);
+        addSet(importedScope.exported.directives, scope.compilation.directives);
+        addSet(importedScope.exported.pipes, scope.compilation.pipes);
+      } else if (isStandalone(imported)) {
+        if (isDirective(imported) || isComponent(imported)) {
+          scope.compilation.directives.add(imported);
+        } else if (isPipe(imported)) {
+          scope.compilation.pipes.add(imported);
+        } else {
+          throw new RuntimeError(980, "The standalone imported type is neither a component nor a directive nor a pipe");
+        }
+      } else {
+        scope.compilation.isPoisoned = true;
+        break;
+      }
+    }
+    if (!scope.compilation.isPoisoned) {
+      for (const decl of maybeUnwrapFn(def.declarations)) {
+        if (isNgModule(decl) || isStandalone(decl)) {
+          scope.compilation.isPoisoned = true;
+          break;
+        }
+        if (isPipe(decl)) {
+          scope.compilation.pipes.add(decl);
+        } else {
+          scope.compilation.directives.add(decl);
+        }
+      }
+    }
+    for (const exported of maybeUnwrapFn(def.exports)) {
+      if (isNgModule(exported)) {
+        const exportedScope = this.getNgModuleScope(exported);
+        addSet(exportedScope.exported.directives, scope.exported.directives);
+        addSet(exportedScope.exported.pipes, scope.exported.pipes);
+        addSet(exportedScope.exported.directives, scope.compilation.directives);
+        addSet(exportedScope.exported.pipes, scope.compilation.pipes);
+      } else if (isPipe(exported)) {
+        scope.exported.pipes.add(exported);
+      } else {
+        scope.exported.directives.add(exported);
+      }
+    }
+    return scope;
+  }
+  getStandaloneComponentScope(type, rawImports) {
+    if (this.standaloneComponentsScopeCache.has(type)) {
+      return this.standaloneComponentsScopeCache.get(type);
+    }
+    const ans = this.computeStandaloneComponentScope(type, rawImports);
+    this.standaloneComponentsScopeCache.set(type, ans);
+    return ans;
+  }
+  computeStandaloneComponentScope(type, rawImports) {
+    const ans = {
+      compilation: {
+        directives: /* @__PURE__ */ new Set([type]),
+        pipes: /* @__PURE__ */ new Set(),
+        ngModules: /* @__PURE__ */ new Set()
+      }
+    };
+    for (const rawImport of flatten(rawImports ?? [])) {
+      const imported = resolveForwardRef(rawImport);
+      try {
+        verifyStandaloneImport(imported, type);
+      } catch (e) {
+        ans.compilation.isPoisoned = true;
+        return ans;
+      }
+      if (isNgModule(imported)) {
+        ans.compilation.ngModules.add(imported);
+        const importedScope = this.getNgModuleScope(imported);
+        if (importedScope.exported.isPoisoned) {
+          ans.compilation.isPoisoned = true;
+          return ans;
+        }
+        addSet(importedScope.exported.directives, ans.compilation.directives);
+        addSet(importedScope.exported.pipes, ans.compilation.pipes);
+      } else if (isPipe(imported)) {
+        ans.compilation.pipes.add(imported);
+      } else if (isDirective(imported) || isComponent(imported)) {
+        ans.compilation.directives.add(imported);
+      } else {
+        ans.compilation.isPoisoned = true;
+        return ans;
+      }
+    }
+    return ans;
+  }
+  isOrphanComponent(cmp) {
+    const def = getComponentDef(cmp);
+    if (!def || def.standalone) {
+      return false;
+    }
+    this.resolveNgModulesDecls();
+    return !this.ownerNgModule.has(cmp);
+  }
+};
+function addSet(sourceSet, targetSet) {
+  for (const m of sourceSet) {
+    targetSet.add(m);
+  }
+}
+var depsTracker = new DepsTracker();
+var NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR = {};
+var ChainedInjector = class {
+  injector;
+  parentInjector;
+  constructor(injector, parentInjector) {
+    this.injector = injector;
+    this.parentInjector = parentInjector;
+  }
+  get(token, notFoundValue, options) {
+    const value = this.injector.get(token, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR, options);
+    if (value !== NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR || notFoundValue === NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR) {
+      return value;
+    }
+    return this.parentInjector.get(token, notFoundValue, options);
+  }
+};
+function computeStaticStyling(tNode, attrs, writeToHost) {
+  ngDevMode && assertFirstCreatePass(getTView(), "Expecting to be called in first template pass only");
+  let styles = writeToHost ? tNode.styles : null;
+  let classes = writeToHost ? tNode.classes : null;
+  let mode = 0;
+  if (attrs !== null) {
+    for (let i = 0; i < attrs.length; i++) {
+      const value = attrs[i];
+      if (typeof value === "number") {
+        mode = value;
+      } else if (mode == 1) {
+        classes = concatStringsWithSpace(classes, value);
+      } else if (mode == 2) {
+        const style = value;
+        const styleValue = attrs[++i];
+        styles = concatStringsWithSpace(styles, style + ": " + styleValue + ";");
+      }
+    }
+  }
+  writeToHost ? tNode.styles = styles : tNode.stylesWithoutHost = styles;
+  writeToHost ? tNode.classes = classes : tNode.classesWithoutHost = classes;
+}
+function \u0275\u0275directiveInject(token, flags = 0) {
+  const lView = getLView();
+  if (lView === null) {
+    ngDevMode && assertInjectImplementationNotEqual(\u0275\u0275directiveInject);
+    return \u0275\u0275inject(token, flags);
+  }
+  const tNode = getCurrentTNode();
+  const value = getOrCreateInjectable(tNode, lView, resolveForwardRef(token), flags);
+  ngDevMode && emitInjectEvent(token, value, flags);
+  return value;
+}
+function \u0275\u0275invalidFactory() {
+  const msg = ngDevMode ? `This constructor was not compatible with Dependency Injection.` : "invalid";
+  throw new Error(msg);
+}
+function resolveDirectives(tView, lView, tNode, localRefs, directiveMatcher) {
+  ngDevMode && assertFirstCreatePass(tView);
+  const exportsMap = localRefs === null ? null : {
+    "": -1
+  };
+  const matchedDirectiveDefs = directiveMatcher(tView, tNode);
+  if (matchedDirectiveDefs !== null) {
+    let directiveDefs = matchedDirectiveDefs;
+    let hostDirectiveDefs = null;
+    let hostDirectiveRanges = null;
+    for (const def of matchedDirectiveDefs) {
+      if (def.resolveHostDirectives !== null) {
+        [directiveDefs, hostDirectiveDefs, hostDirectiveRanges] = def.resolveHostDirectives(matchedDirectiveDefs);
+        break;
+      }
+    }
+    ngDevMode && assertNoDuplicateDirectives(directiveDefs);
+    initializeDirectives(tView, lView, tNode, directiveDefs, exportsMap, hostDirectiveDefs, hostDirectiveRanges);
+  }
+  if (exportsMap !== null && localRefs !== null) {
+    cacheMatchingLocalNames(tNode, localRefs, exportsMap);
+  }
+}
+function cacheMatchingLocalNames(tNode, localRefs, exportsMap) {
+  const localNames = tNode.localNames = [];
+  for (let i = 0; i < localRefs.length; i += 2) {
+    const index = exportsMap[localRefs[i + 1]];
+    if (index == null) throw new RuntimeError(-301, ngDevMode && `Export of name '${localRefs[i + 1]}' not found!`);
+    localNames.push(localRefs[i], index);
+  }
+}
+function markAsComponentHost(tView, hostTNode, componentOffset) {
+  ngDevMode && assertFirstCreatePass(tView);
+  ngDevMode && assertGreaterThan(componentOffset, -1, "componentOffset must be great than -1");
+  hostTNode.componentOffset = componentOffset;
+  (tView.components ??= []).push(hostTNode.index);
+}
+function initializeDirectives(tView, lView, tNode, directives, exportsMap, hostDirectiveDefs, hostDirectiveRanges) {
+  ngDevMode && assertFirstCreatePass(tView);
+  const directivesLength = directives.length;
+  let componentDef = null;
+  for (let i = 0; i < directivesLength; i++) {
+    const def = directives[i];
+    if (componentDef === null && isComponentDef(def)) {
+      componentDef = def;
+      markAsComponentHost(tView, tNode, i);
+    }
+    diPublicInInjector(getOrCreateNodeInjectorForNode(tNode, lView), tView, def.type);
+  }
+  initTNodeFlags(tNode, tView.data.length, directivesLength);
+  if (componentDef?.viewProvidersResolver) {
+    componentDef.viewProvidersResolver(componentDef);
+  }
+  for (let i = 0; i < directivesLength; i++) {
+    const def = directives[i];
+    if (def.providersResolver) {
+      def.providersResolver(def);
+    }
+  }
+  let preOrderHooksFound = false;
+  let preOrderCheckHooksFound = false;
+  let directiveIdx = allocExpando(tView, lView, directivesLength, null);
+  ngDevMode && assertSame(directiveIdx, tNode.directiveStart, "TNode.directiveStart should point to just allocated space");
+  if (directivesLength > 0) {
+    tNode.directiveToIndex = /* @__PURE__ */ new Map();
+  }
+  for (let i = 0; i < directivesLength; i++) {
+    const def = directives[i];
+    tNode.mergedAttrs = mergeHostAttrs(tNode.mergedAttrs, def.hostAttrs);
+    configureViewWithDirective(tView, tNode, lView, directiveIdx, def);
+    saveNameToExportMap(directiveIdx, def, exportsMap);
+    if (hostDirectiveRanges !== null && hostDirectiveRanges.has(def)) {
+      const [start, end] = hostDirectiveRanges.get(def);
+      tNode.directiveToIndex.set(def.type, [directiveIdx, start + tNode.directiveStart, end + tNode.directiveStart]);
+    } else if (hostDirectiveDefs === null || !hostDirectiveDefs.has(def)) {
+      tNode.directiveToIndex.set(def.type, directiveIdx);
+    }
+    if (def.contentQueries !== null) tNode.flags |= 4;
+    if (def.hostBindings !== null || def.hostAttrs !== null || def.hostVars !== 0) tNode.flags |= 64;
+    const lifeCycleHooks = def.type.prototype;
+    if (!preOrderHooksFound && (lifeCycleHooks.ngOnChanges || lifeCycleHooks.ngOnInit || lifeCycleHooks.ngDoCheck)) {
+      (tView.preOrderHooks ??= []).push(tNode.index);
+      preOrderHooksFound = true;
+    }
+    if (!preOrderCheckHooksFound && (lifeCycleHooks.ngOnChanges || lifeCycleHooks.ngDoCheck)) {
+      (tView.preOrderCheckHooks ??= []).push(tNode.index);
+      preOrderCheckHooksFound = true;
+    }
+    directiveIdx++;
+  }
+  initializeInputAndOutputAliases(tView, tNode, hostDirectiveDefs);
+}
+function initializeInputAndOutputAliases(tView, tNode, hostDirectiveDefs) {
+  ngDevMode && assertFirstCreatePass(tView);
+  for (let index = tNode.directiveStart; index < tNode.directiveEnd; index++) {
+    const directiveDef = tView.data[index];
+    if (hostDirectiveDefs === null || !hostDirectiveDefs.has(directiveDef)) {
+      setupSelectorMatchedInputsOrOutputs(0, tNode, directiveDef, index);
+      setupSelectorMatchedInputsOrOutputs(1, tNode, directiveDef, index);
+      setupInitialInputs(tNode, index, false);
+    } else {
+      const hostDirectiveDef = hostDirectiveDefs.get(directiveDef);
+      setupHostDirectiveInputsOrOutputs(0, tNode, hostDirectiveDef, index);
+      setupHostDirectiveInputsOrOutputs(1, tNode, hostDirectiveDef, index);
+      setupInitialInputs(tNode, index, true);
+    }
+  }
+}
+function setupSelectorMatchedInputsOrOutputs(mode, tNode, def, directiveIndex) {
+  const aliasMap = mode === 0 ? def.inputs : def.outputs;
+  for (const publicName in aliasMap) {
+    if (aliasMap.hasOwnProperty(publicName)) {
+      let bindings;
+      if (mode === 0) {
+        bindings = tNode.inputs ??= {};
+      } else {
+        bindings = tNode.outputs ??= {};
+      }
+      bindings[publicName] ??= [];
+      bindings[publicName].push(directiveIndex);
+      setShadowStylingInputFlags(tNode, publicName);
+    }
+  }
+}
+function setupHostDirectiveInputsOrOutputs(mode, tNode, config2, directiveIndex) {
+  const aliasMap = mode === 0 ? config2.inputs : config2.outputs;
+  for (const initialName in aliasMap) {
+    if (aliasMap.hasOwnProperty(initialName)) {
+      const publicName = aliasMap[initialName];
+      let bindings;
+      if (mode === 0) {
+        bindings = tNode.hostDirectiveInputs ??= {};
+      } else {
+        bindings = tNode.hostDirectiveOutputs ??= {};
+      }
+      bindings[publicName] ??= [];
+      bindings[publicName].push(directiveIndex, initialName);
+      setShadowStylingInputFlags(tNode, publicName);
+    }
+  }
+}
+function setShadowStylingInputFlags(tNode, publicName) {
+  if (publicName === "class") {
+    tNode.flags |= 8;
+  } else if (publicName === "style") {
+    tNode.flags |= 16;
+  }
+}
+function setupInitialInputs(tNode, directiveIndex, isHostDirective) {
+  const {
+    attrs,
+    inputs,
+    hostDirectiveInputs
+  } = tNode;
+  if (attrs === null || !isHostDirective && inputs === null || isHostDirective && hostDirectiveInputs === null || isInlineTemplate(tNode)) {
+    tNode.initialInputs ??= [];
+    tNode.initialInputs.push(null);
+    return;
+  }
+  let inputsToStore = null;
+  let i = 0;
+  while (i < attrs.length) {
+    const attrName = attrs[i];
+    if (attrName === 0) {
+      i += 4;
+      continue;
+    } else if (attrName === 5) {
+      i += 2;
+      continue;
+    } else if (typeof attrName === "number") {
+      break;
+    }
+    if (!isHostDirective && inputs.hasOwnProperty(attrName)) {
+      const inputConfig = inputs[attrName];
+      for (const index of inputConfig) {
+        if (index === directiveIndex) {
+          inputsToStore ??= [];
+          inputsToStore.push(attrName, attrs[i + 1]);
+          break;
+        }
+      }
+    } else if (isHostDirective && hostDirectiveInputs.hasOwnProperty(attrName)) {
+      const config2 = hostDirectiveInputs[attrName];
+      for (let j = 0; j < config2.length; j += 2) {
+        if (config2[j] === directiveIndex) {
+          inputsToStore ??= [];
+          inputsToStore.push(config2[j + 1], attrs[i + 1]);
+          break;
+        }
+      }
+    }
+    i += 2;
+  }
+  tNode.initialInputs ??= [];
+  tNode.initialInputs.push(inputsToStore);
+}
+function configureViewWithDirective(tView, tNode, lView, directiveIndex, def) {
+  ngDevMode && assertGreaterThanOrEqual(directiveIndex, HEADER_OFFSET, "Must be in Expando section");
+  tView.data[directiveIndex] = def;
+  const directiveFactory = def.factory || (def.factory = getFactoryDef(def.type, true));
+  const nodeInjectorFactory = new NodeInjectorFactory(directiveFactory, isComponentDef(def), \u0275\u0275directiveInject, ngDevMode ? def.type.name : null);
+  tView.blueprint[directiveIndex] = nodeInjectorFactory;
+  lView[directiveIndex] = nodeInjectorFactory;
+  registerHostBindingOpCodes(tView, tNode, directiveIndex, allocExpando(tView, lView, def.hostVars, NO_CHANGE), def);
+}
+function registerHostBindingOpCodes(tView, tNode, directiveIdx, directiveVarsIdx, def) {
+  ngDevMode && assertFirstCreatePass(tView);
+  const hostBindings = def.hostBindings;
+  if (hostBindings) {
+    let hostBindingOpCodes = tView.hostBindingOpCodes;
+    if (hostBindingOpCodes === null) {
+      hostBindingOpCodes = tView.hostBindingOpCodes = [];
+    }
+    const elementIndx = ~tNode.index;
+    if (lastSelectedElementIdx(hostBindingOpCodes) != elementIndx) {
+      hostBindingOpCodes.push(elementIndx);
+    }
+    hostBindingOpCodes.push(directiveIdx, directiveVarsIdx, hostBindings);
+  }
+}
+function lastSelectedElementIdx(hostBindingOpCodes) {
+  let i = hostBindingOpCodes.length;
+  while (i > 0) {
+    const value = hostBindingOpCodes[--i];
+    if (typeof value === "number" && value < 0) {
+      return value;
+    }
+  }
+  return 0;
+}
+function saveNameToExportMap(directiveIdx, def, exportsMap) {
+  if (exportsMap) {
+    if (def.exportAs) {
+      for (let i = 0; i < def.exportAs.length; i++) {
+        exportsMap[def.exportAs[i]] = directiveIdx;
+      }
+    }
+    if (isComponentDef(def)) exportsMap[""] = directiveIdx;
+  }
+}
+function initTNodeFlags(tNode, index, numberOfDirectives) {
+  ngDevMode && assertNotEqual(numberOfDirectives, tNode.directiveEnd - tNode.directiveStart, "Reached the max number of directives");
+  tNode.flags |= 1;
+  tNode.directiveStart = index;
+  tNode.directiveEnd = index + numberOfDirectives;
+  tNode.providerIndexes = index;
+}
+function assertNoDuplicateDirectives(directives) {
+  if (directives.length < 2) {
+    return;
+  }
+  const seenDirectives = /* @__PURE__ */ new Set();
+  for (const current of directives) {
+    if (seenDirectives.has(current)) {
+      throw new RuntimeError(309, `Directive ${current.type.name} matches multiple times on the same element. Directives can only match an element once.`);
+    }
+    seenDirectives.add(current);
+  }
+}
+function directiveHostFirstCreatePass(index, lView, type, name, directiveMatcher, bindingsEnabled, attrsIndex, localRefsIndex) {
+  const tView = lView[TVIEW];
+  ngDevMode && assertFirstCreatePass(tView);
+  const tViewConsts = tView.consts;
+  const attrs = getConstant(tViewConsts, attrsIndex);
+  const tNode = getOrCreateTNode(tView, index, type, name, attrs);
+  if (bindingsEnabled) {
+    resolveDirectives(tView, lView, tNode, getConstant(tViewConsts, localRefsIndex), directiveMatcher);
+  }
+  tNode.mergedAttrs = mergeHostAttrs(tNode.mergedAttrs, tNode.attrs);
+  if (tNode.attrs !== null) {
+    computeStaticStyling(tNode, tNode.attrs, false);
+  }
+  if (tNode.mergedAttrs !== null) {
+    computeStaticStyling(tNode, tNode.mergedAttrs, true);
+  }
+  if (tView.queries !== null) {
+    tView.queries.elementStart(tView, tNode);
+  }
+  return tNode;
+}
+function directiveHostEndFirstCreatePass(tView, tNode) {
+  ngDevMode && assertFirstCreatePass(tView);
+  registerPostOrderHooks(tView, tNode);
+  if (isContentQueryHost(tNode)) {
+    tView.queries.elementEnd(tNode);
+  }
+}
+function domOnlyFirstCreatePass(index, tView, type, name, attrsIndex, localRefsIndex) {
+  ngDevMode && assertFirstCreatePass(tView);
+  const tViewConsts = tView.consts;
+  const attrs = getConstant(tViewConsts, attrsIndex);
+  const tNode = getOrCreateTNode(tView, index, type, name, attrs);
+  tNode.mergedAttrs = mergeHostAttrs(tNode.mergedAttrs, tNode.attrs);
+  if (localRefsIndex != null) {
+    const refs = getConstant(tViewConsts, localRefsIndex);
+    tNode.localNames = [];
+    for (let i = 0; i < refs.length; i += 2) {
+      tNode.localNames.push(refs[i], -1);
+    }
+  }
+  if (tNode.attrs !== null) {
+    computeStaticStyling(tNode, tNode.attrs, false);
+  }
+  if (tNode.mergedAttrs !== null) {
+    computeStaticStyling(tNode, tNode.mergedAttrs, true);
+  }
+  if (tView.queries !== null) {
+    tView.queries.elementStart(tView, tNode);
+  }
+  return tNode;
+}
+function isListLikeIterable(obj) {
+  if (!isJsObject(obj)) return false;
+  return Array.isArray(obj) || !(obj instanceof Map) && Symbol.iterator in obj;
+}
+function areIterablesEqual(a, b, comparator) {
+  const iterator1 = a[Symbol.iterator]();
+  const iterator2 = b[Symbol.iterator]();
+  while (true) {
+    const item1 = iterator1.next();
+    const item2 = iterator2.next();
+    if (item1.done && item2.done) return true;
+    if (item1.done || item2.done) return false;
+    if (!comparator(item1.value, item2.value)) return false;
+  }
+}
+function iterateListLike(obj, fn) {
+  if (Array.isArray(obj)) {
+    for (let i = 0; i < obj.length; i++) {
+      fn(obj[i]);
+    }
+  } else {
+    const iterator2 = obj[Symbol.iterator]();
+    let item;
+    while (!(item = iterator2.next()).done) {
+      fn(item.value);
+    }
+  }
+}
+function isJsObject(o) {
+  return o !== null && (typeof o === "function" || typeof o === "object");
+}
+function devModeEqual(a, b) {
+  const isListLikeIterableA = isListLikeIterable(a);
+  const isListLikeIterableB = isListLikeIterable(b);
+  if (isListLikeIterableA && isListLikeIterableB) {
+    return areIterablesEqual(a, b, devModeEqual);
+  } else {
+    const isAObject = a && (typeof a === "object" || typeof a === "function");
+    const isBObject = b && (typeof b === "object" || typeof b === "function");
+    if (!isListLikeIterableA && isAObject && !isListLikeIterableB && isBObject) {
+      return true;
+    } else {
+      return Object.is(a, b);
+    }
+  }
+}
+function updateBinding(lView, bindingIndex, value) {
+  return lView[bindingIndex] = value;
+}
+function getBinding(lView, bindingIndex) {
+  ngDevMode && assertIndexInRange(lView, bindingIndex);
+  ngDevMode && assertNotSame(lView[bindingIndex], NO_CHANGE, "Stored value should never be NO_CHANGE.");
+  return lView[bindingIndex];
+}
+function bindingUpdated(lView, bindingIndex, value) {
+  ngDevMode && assertLessThan(bindingIndex, lView.length, `Slot should have been initialized to NO_CHANGE`);
+  if (value === NO_CHANGE) {
+    return false;
+  }
+  const oldValue = lView[bindingIndex];
+  if (Object.is(oldValue, value)) {
+    return false;
+  } else {
+    if (ngDevMode && isInCheckNoChangesMode()) {
+      const oldValueToCompare = oldValue !== NO_CHANGE ? oldValue : void 0;
+      if (!devModeEqual(oldValueToCompare, value)) {
+        const details = getExpressionChangedErrorDetails(lView, bindingIndex, oldValueToCompare, value);
+        throwErrorIfNoChangesMode(oldValue === NO_CHANGE, details.oldValue, details.newValue, details.propName, lView);
+      }
+      return false;
+    }
+    lView[bindingIndex] = value;
+    return true;
+  }
+}
+function bindingUpdated2(lView, bindingIndex, exp1, exp2) {
+  const different = bindingUpdated(lView, bindingIndex, exp1);
+  return bindingUpdated(lView, bindingIndex + 1, exp2) || different;
+}
+function bindingUpdated3(lView, bindingIndex, exp1, exp2, exp3) {
+  const different = bindingUpdated2(lView, bindingIndex, exp1, exp2);
+  return bindingUpdated(lView, bindingIndex + 2, exp3) || different;
+}
+function bindingUpdated4(lView, bindingIndex, exp1, exp2, exp3, exp4) {
+  const different = bindingUpdated2(lView, bindingIndex, exp1, exp2);
+  return bindingUpdated2(lView, bindingIndex + 2, exp3, exp4) || different;
+}
+function wrapListener(tNode, lView, listenerFn) {
+  return function wrapListenerIn_markDirtyAndPreventDefault(event) {
+    const nativeEl = wrapListenerIn_markDirtyAndPreventDefault.__ngNativeEl__;
+    if (nativeEl !== void 0) {
+      markEventHandledForElement(event, nativeEl);
+    }
+    const startView = isComponentHost(tNode) ? getComponentLViewByIndex(tNode.index, lView) : lView;
+    markViewDirty(startView, 5);
+    const context2 = lView[CONTEXT];
+    let result = executeListenerWithErrorHandling(lView, context2, listenerFn, event);
+    let nextListenerFn = wrapListenerIn_markDirtyAndPreventDefault.__ngNextListenerFn__;
+    while (nextListenerFn) {
+      result = executeListenerWithErrorHandling(lView, context2, nextListenerFn, event) && result;
+      nextListenerFn = nextListenerFn.__ngNextListenerFn__;
+    }
+    return result;
+  };
+}
+function executeListenerWithErrorHandling(lView, context2, listenerFn, e) {
+  const prevConsumer = setActiveConsumer(null);
+  try {
+    profiler(ProfilerEvent.OutputStart, context2, listenerFn);
+    return listenerFn(e) !== false;
+  } catch (error) {
+    handleUncaughtError(lView, error);
+    return false;
+  } finally {
+    profiler(ProfilerEvent.OutputEnd, context2, listenerFn);
+    setActiveConsumer(prevConsumer);
+  }
+}
+function listenToDomEvent(tNode, tView, lView, eventTargetResolver, renderer, eventName, originalListener, wrappedListener) {
+  ngDevMode && assertNotSame(wrappedListener, originalListener, "Expected wrapped and original listeners to be different.");
+  const isTNodeDirectiveHost = isDirectiveHost(tNode);
+  let hasCoalesced = false;
+  let existingListener = null;
+  if (!eventTargetResolver && isTNodeDirectiveHost) {
+    existingListener = findExistingListener(tView, lView, eventName, tNode.index);
+  }
+  if (existingListener !== null) {
+    const lastListenerFn = existingListener.__ngLastListenerFn__ || existingListener;
+    lastListenerFn.__ngNextListenerFn__ = originalListener;
+    existingListener.__ngLastListenerFn__ = originalListener;
+    hasCoalesced = true;
+  } else {
+    const native = getNativeByTNode(tNode, lView);
+    const target = eventTargetResolver ? eventTargetResolver(native) : native;
+    stashEventListenerImpl(lView, target, eventName, wrappedListener);
+    if (!eventTargetResolver) {
+      wrappedListener.__ngNativeEl__ = native;
+    }
+    const cleanupFn = renderer.listen(target, eventName, wrappedListener);
+    if (!isAnimationEventType(eventName)) {
+      const idxOrTargetGetter = eventTargetResolver ? (_lView) => eventTargetResolver(unwrapRNode(_lView[tNode.index])) : tNode.index;
+      storeListenerCleanup(idxOrTargetGetter, tView, lView, eventName, wrappedListener, cleanupFn, false);
+    }
+  }
+  return hasCoalesced;
+}
+function isAnimationEventType(eventName) {
+  return eventName.startsWith("animation") || eventName.startsWith("transition");
+}
+function findExistingListener(tView, lView, eventName, tNodeIndex) {
+  const tCleanup = tView.cleanup;
+  if (tCleanup != null) {
+    for (let i = 0; i < tCleanup.length - 1; i += 2) {
+      const cleanupEventName = tCleanup[i];
+      if (cleanupEventName === eventName && tCleanup[i + 1] === tNodeIndex) {
+        const lCleanup = lView[CLEANUP];
+        const listenerIdxInLCleanup = tCleanup[i + 2];
+        return lCleanup && lCleanup.length > listenerIdxInLCleanup ? lCleanup[listenerIdxInLCleanup] : null;
+      }
+      if (typeof cleanupEventName === "string") {
+        i += 2;
+      }
+    }
+  }
+  return null;
+}
+function storeListenerCleanup(indexOrTargetGetter, tView, lView, eventName, listenerFn, cleanup, isOutput) {
+  const tCleanup = tView.firstCreatePass ? getOrCreateTViewCleanup(tView) : null;
+  const lCleanup = getOrCreateLViewCleanup(lView);
+  const index = lCleanup.length;
+  lCleanup.push(listenerFn, cleanup);
+  tCleanup && tCleanup.push(eventName, indexOrTargetGetter, index, (index + 1) * (isOutput ? -1 : 1));
+}
+function listenToOutput(tNode, lView, directiveIndex, lookupName, eventName, listenerFn) {
+  ngDevMode && assertIndexInRange(lView, directiveIndex);
+  const instance = lView[directiveIndex];
+  const tView = lView[TVIEW];
+  const def = tView.data[directiveIndex];
+  const propertyName = def.outputs[lookupName];
+  const output = instance[propertyName];
+  if (ngDevMode && !isOutputSubscribable(output)) {
+    throw new Error(`@Output ${propertyName} not initialized in '${instance.constructor.name}'.`);
+  }
+  const subscription = output.subscribe(listenerFn);
+  storeListenerCleanup(tNode.index, tView, lView, eventName, listenerFn, subscription, true);
+}
+function isOutputSubscribable(value) {
+  return value != null && typeof value.subscribe === "function";
+}
+function \u0275\u0275controlCreate() {
+  controlCreateInternal();
+}
+function controlCreateInternal() {
+  const lView = getLView();
+  const tView = getTView();
+  const tNode = getCurrentTNode();
+  if (tView.firstCreatePass) {
+    initializeControlFirstCreatePass(tView, tNode);
+  }
+  if (tNode.controlDirectiveIndex === -1) {
+    return;
+  }
+  performanceMarkFeature("NgSignalForms");
+  const instance = lView[tNode.controlDirectiveIndex];
+  const controlDef = tView.data[tNode.controlDirectiveIndex].controlDef;
+  controlDef.create(instance, new ControlDirectiveHostImpl(lView, tView, tNode));
+}
+function \u0275\u0275control() {
+  controlUpdateInternal();
+}
+function controlUpdateInternal() {
+  if (ngDevMode && isInCheckNoChangesMode()) {
+    return;
+  }
+  const lView = getLView();
+  const tView = getTView();
+  const tNode = getSelectedTNode();
+  if (tNode.controlDirectiveIndex === -1) {
+    return;
+  }
+  const controlDef = tView.data[tNode.controlDirectiveIndex].controlDef;
+  const instance = lView[tNode.controlDirectiveIndex];
+  controlDef.update(instance, new ControlDirectiveHostImpl(lView, tView, tNode));
+}
+var ControlDirectiveHostImpl = class {
+  lView;
+  tView;
+  tNode;
+  hasPassThrough;
+  constructor(lView, tView, tNode) {
+    this.lView = lView;
+    this.tView = tView;
+    this.tNode = tNode;
+    this.hasPassThrough = !!(tNode.flags & 4096);
+  }
+  get customControl() {
+    return this.tNode.customControlIndex !== -1 ? this.lView[this.tNode.customControlIndex] : void 0;
+  }
+  get descriptor() {
+    if (ngDevMode && isComponentHost(this.tNode)) {
+      const componentIndex = this.tNode.directiveStart + this.tNode.componentOffset;
+      const componentDef = this.tView.data[componentIndex];
+      return `Component ${debugStringifyTypeForError(componentDef.type)}`;
+    }
+    return `<${this.tNode.value}>`;
+  }
+  listenToCustomControlOutput(outputName, callback) {
+    if (!hasOutput(this.tView.data[this.tNode.customControlIndex], outputName)) {
+      return;
+    }
+    listenToOutput(this.tNode, this.lView, this.tNode.customControlIndex, outputName, outputName, wrapListener(this.tNode, this.lView, callback));
+  }
+  listenToCustomControlModel(listener) {
+    const modelName = this.tNode.flags & 1024 ? "valueChange" : "checkedChange";
+    listenToOutput(this.tNode, this.lView, this.tNode.customControlIndex, modelName, modelName, wrapListener(this.tNode, this.lView, listener));
+  }
+  listenToDom(eventName, listener) {
+    listenToDomEvent(this.tNode, this.tView, this.lView, void 0, this.lView[RENDERER], eventName, listener, wrapListener(this.tNode, this.lView, listener));
+  }
+  setInputOnDirectives(inputName, value) {
+    const directiveIndices = this.tNode.inputs?.[inputName];
+    const hostDirectiveInputs = this.tNode.hostDirectiveInputs?.[inputName];
+    if (!directiveIndices && !hostDirectiveInputs) {
+      return false;
+    }
+    if (directiveIndices) {
+      for (const index of directiveIndices) {
+        const directiveDef = this.tView.data[index];
+        const directive = this.lView[index];
+        writeToDirectiveInput(directiveDef, directive, inputName, value);
+      }
+    }
+    if (hostDirectiveInputs) {
+      for (let i = 0; i < hostDirectiveInputs.length; i += 2) {
+        const index = hostDirectiveInputs[i];
+        const internalName = hostDirectiveInputs[i + 1];
+        const directiveDef = this.tView.data[index];
+        const directive = this.lView[index];
+        writeToDirectiveInput(directiveDef, directive, internalName, value);
+      }
+    }
+    return true;
+  }
+  setCustomControlModelInput(value) {
+    const directive = this.lView[this.tNode.customControlIndex];
+    const directiveDef = this.tView.data[this.tNode.customControlIndex];
+    const modelName = this.tNode.flags & 1024 ? "value" : "checked";
+    writeToDirectiveInput(directiveDef, directive, modelName, value);
+  }
+  customControlHasInput(inputName) {
+    if (this.tNode.customControlIndex === -1) {
+      return false;
+    }
+    const directiveDef = this.tView.data[this.tNode.customControlIndex];
+    return directiveDef.inputs[inputName] != void 0;
+  }
+};
+function initializeControlFirstCreatePass(tView, tNode, lView) {
+  ngDevMode && assertFirstCreatePass(tView);
+  for (let i = tNode.directiveStart; i < tNode.directiveEnd; i++) {
+    const directiveDef = tView.data[i];
+    if (directiveDef.controlDef) {
+      tNode.controlDirectiveIndex = i;
+      break;
+    }
+  }
+  if (tNode.controlDirectiveIndex === -1) {
+    return;
+  }
+  const controlDef = tView.data[tNode.controlDirectiveIndex].controlDef;
+  if (controlDef.passThroughInput) {
+    if ((tNode.inputs?.[controlDef.passThroughInput]?.length ?? 0) > 1) {
+      tNode.flags |= 4096;
+      return;
+    }
+  }
+  initializeCustomControlStatus(tView, tNode);
+}
+function initializeCustomControlStatus(tView, tNode) {
+  for (let i = tNode.directiveStart; i < tNode.directiveEnd; i++) {
+    const directiveDef = tView.data[i];
+    if (hasModelInput(directiveDef, "value")) {
+      tNode.flags |= 1024;
+      tNode.customControlIndex = i;
+      return;
+    }
+    if (hasModelInput(directiveDef, "checked")) {
+      tNode.flags |= 2048;
+      tNode.customControlIndex = i;
+      return;
+    }
+  }
+}
+function hasModelInput(directiveDef, name) {
+  return hasInput(directiveDef, name) && hasOutput(directiveDef, name + "Change");
+}
+function hasInput(directiveDef, name) {
+  return name in directiveDef.inputs;
+}
+function hasOutput(directiveDef, name) {
+  return name in directiveDef.outputs;
+}
+var BINDING = /* @__PURE__ */ Symbol("BINDING");
+function getComponentName(def) {
+  return def.debugInfo?.className || def.type.name || null;
+}
+var ComponentFactoryResolver2 = class extends ComponentFactoryResolver$1 {
+  ngModule;
+  constructor(ngModule) {
+    super();
+    this.ngModule = ngModule;
+  }
+  resolveComponentFactory(component) {
+    ngDevMode && assertComponentType(component);
+    const componentDef = getComponentDef(component);
+    return new ComponentFactory2(componentDef, this.ngModule);
+  }
+};
+function toInputRefArray(map2) {
+  return Object.keys(map2).map((name) => {
+    const [propName, flags, transform] = map2[name];
+    const inputData = {
+      propName,
+      templateName: name,
+      isSignal: (flags & InputFlags.SignalBased) !== 0
+    };
+    if (transform) {
+      inputData.transform = transform;
+    }
+    return inputData;
+  });
+}
+function toOutputRefArray(map2) {
+  return Object.keys(map2).map((name) => ({
+    propName: map2[name],
+    templateName: name
+  }));
+}
+function verifyNotAnOrphanComponent(componentDef) {
+  if (false) {
+    if (depsTracker.isOrphanComponent(componentDef.type)) {
+      throw new RuntimeError(981, `Orphan component found! Trying to render the component ${debugStringifyTypeForError(componentDef.type)} without first loading the NgModule that declares it. It is recommended to make this component standalone in order to avoid this error. If this is not possible now, import the component's NgModule in the appropriate NgModule, or the standalone component in which you are trying to render this component. If this is a lazy import, load the NgModule lazily as well and use its module injector.`);
+    }
+  }
+}
+function createRootViewInjector(componentDef, environmentInjector, injector) {
+  let realEnvironmentInjector = environmentInjector instanceof EnvironmentInjector ? environmentInjector : environmentInjector?.injector;
+  if (realEnvironmentInjector && componentDef.getStandaloneInjector !== null) {
+    realEnvironmentInjector = componentDef.getStandaloneInjector(realEnvironmentInjector) || realEnvironmentInjector;
+  }
+  const rootViewInjector = realEnvironmentInjector ? new ChainedInjector(injector, realEnvironmentInjector) : injector;
+  return rootViewInjector;
+}
+function createRootLViewEnvironment(rootLViewInjector) {
+  const rendererFactory = rootLViewInjector.get(RendererFactory2, null);
+  if (rendererFactory === null) {
+    throw new RuntimeError(407, ngDevMode && "Angular was not able to inject a renderer (RendererFactory2). Likely this is due to a broken DI hierarchy. Make sure that any injector used to create this component has a correct parent.");
+  }
+  const sanitizer = rootLViewInjector.get(Sanitizer, null);
+  const changeDetectionScheduler = rootLViewInjector.get(ChangeDetectionScheduler, null);
+  const tracingService = rootLViewInjector.get(TracingService, null, {
+    optional: true
+  });
+  let ngReflect = false;
+  if (typeof ngDevMode === "undefined" || ngDevMode) {
+    ngReflect = rootLViewInjector.get(NG_REFLECT_ATTRS_FLAG, NG_REFLECT_ATTRS_FLAG_DEFAULT);
+  }
+  return {
+    rendererFactory,
+    sanitizer,
+    changeDetectionScheduler,
+    ngReflect,
+    tracingService
+  };
+}
+function createHostElement(componentDef, renderer) {
+  const tagName = inferTagNameFromDefinition(componentDef);
+  const namespace = tagName === "svg" ? SVG_NAMESPACE : tagName === "math" ? MATH_ML_NAMESPACE : null;
+  return createElementNode(renderer, tagName, namespace);
+}
+function inferTagNameFromDefinition(componentDef) {
+  return (componentDef.selectors[0][0] || "div").toLowerCase();
+}
+var ComponentFactory2 = class extends ComponentFactory$1 {
+  componentDef;
+  ngModule;
+  selector;
+  componentType;
+  ngContentSelectors;
+  isBoundToModule;
+  cachedInputs = null;
+  cachedOutputs = null;
+  get inputs() {
+    this.cachedInputs ??= toInputRefArray(this.componentDef.inputs);
+    return this.cachedInputs;
+  }
+  get outputs() {
+    this.cachedOutputs ??= toOutputRefArray(this.componentDef.outputs);
+    return this.cachedOutputs;
+  }
+  constructor(componentDef, ngModule) {
+    super();
+    this.componentDef = componentDef;
+    this.ngModule = ngModule;
+    this.componentType = componentDef.type;
+    this.selector = stringifyCSSSelectorList(componentDef.selectors);
+    this.ngContentSelectors = componentDef.ngContentSelectors ?? [];
+    this.isBoundToModule = !!ngModule;
+  }
+  create(injector, projectableNodes, rootSelectorOrNode, environmentInjector, directives, componentBindings) {
+    profiler(ProfilerEvent.DynamicComponentStart);
+    const prevConsumer = setActiveConsumer(null);
+    try {
+      const cmpDef = this.componentDef;
+      ngDevMode && verifyNotAnOrphanComponent(cmpDef);
+      const rootViewInjector = createRootViewInjector(cmpDef, environmentInjector || this.ngModule, injector);
+      const environment = createRootLViewEnvironment(rootViewInjector);
+      const tracingService = environment.tracingService;
+      if (tracingService && tracingService.componentCreate) {
+        return tracingService.componentCreate(getComponentName(cmpDef), () => this.createComponentRef(environment, rootViewInjector, projectableNodes, rootSelectorOrNode, directives, componentBindings));
+      } else {
+        return this.createComponentRef(environment, rootViewInjector, projectableNodes, rootSelectorOrNode, directives, componentBindings);
+      }
+    } finally {
+      setActiveConsumer(prevConsumer);
+    }
+  }
+  createComponentRef(environment, rootViewInjector, projectableNodes, rootSelectorOrNode, directives, componentBindings) {
+    const cmpDef = this.componentDef;
+    const rootTView = createRootTView(rootSelectorOrNode, cmpDef, componentBindings, directives);
+    const hostRenderer = environment.rendererFactory.createRenderer(null, cmpDef);
+    const hostElement = rootSelectorOrNode ? locateHostElement(hostRenderer, rootSelectorOrNode, cmpDef.encapsulation, rootViewInjector) : createHostElement(cmpDef, hostRenderer);
+    const hasInputBindings = componentBindings?.some(isInputBinding) || directives?.some((d) => typeof d !== "function" && d.bindings.some(isInputBinding));
+    const rootLView = createLView(null, rootTView, null, 512 | getInitialLViewFlagsFromDef(cmpDef), null, null, environment, hostRenderer, rootViewInjector, null, retrieveHydrationInfo(hostElement, rootViewInjector, true));
+    rootLView[HEADER_OFFSET] = hostElement;
+    enterView(rootLView);
+    let componentView = null;
+    try {
+      const hostTNode = directiveHostFirstCreatePass(HEADER_OFFSET, rootLView, 2, "#host", () => rootTView.directiveRegistry, true, 0);
+      setupStaticAttributes(hostRenderer, hostElement, hostTNode);
+      attachPatchData(hostElement, rootLView);
+      createDirectivesInstances(rootTView, rootLView, hostTNode);
+      executeContentQueries(rootTView, hostTNode, rootLView);
+      directiveHostEndFirstCreatePass(rootTView, hostTNode);
+      if (projectableNodes !== void 0) {
+        projectNodes(hostTNode, this.ngContentSelectors, projectableNodes);
+      }
+      componentView = getComponentLViewByIndex(hostTNode.index, rootLView);
+      rootLView[CONTEXT] = componentView[CONTEXT];
+      renderView(rootTView, rootLView, null);
+    } catch (e) {
+      if (componentView !== null) {
+        unregisterLView(componentView);
+      }
+      unregisterLView(rootLView);
+      throw e;
+    } finally {
+      profiler(ProfilerEvent.DynamicComponentEnd);
+      leaveView();
+    }
+    return new ComponentRef2(this.componentType, rootLView, !!hasInputBindings);
+  }
+};
+function createRootTView(rootSelectorOrNode, componentDef, componentBindings, directives) {
+  const tAttributes = rootSelectorOrNode ? ["ng-version", "21.2.17"] : extractAttrsAndClassesFromSelector(componentDef.selectors[0]);
+  let creationBindings = null;
+  let updateBindings = null;
+  let varsToAllocate = 0;
+  if (componentBindings) {
+    for (const binding of componentBindings) {
+      varsToAllocate += binding[BINDING].requiredVars;
+      if (binding.create) {
+        binding.targetIdx = 0;
+        (creationBindings ??= []).push(binding);
+      }
+      if (binding.update) {
+        binding.targetIdx = 0;
+        (updateBindings ??= []).push(binding);
+      }
+    }
+  }
+  if (directives) {
+    for (let i = 0; i < directives.length; i++) {
+      const directive = directives[i];
+      if (typeof directive !== "function") {
+        for (const binding of directive.bindings) {
+          varsToAllocate += binding[BINDING].requiredVars;
+          const targetDirectiveIdx = i + 1;
+          if (binding.create) {
+            binding.targetIdx = targetDirectiveIdx;
+            (creationBindings ??= []).push(binding);
+          }
+          if (binding.update) {
+            binding.targetIdx = targetDirectiveIdx;
+            (updateBindings ??= []).push(binding);
+          }
+        }
+      }
+    }
+  }
+  const directivesToApply = [componentDef];
+  if (directives) {
+    for (const directive of directives) {
+      const directiveType = typeof directive === "function" ? directive : directive.type;
+      const directiveDef = ngDevMode ? getDirectiveDefOrThrow(directiveType) : getDirectiveDef(directiveType);
+      if (ngDevMode && !directiveDef.standalone) {
+        throw new RuntimeError(907, `The ${stringifyForError(directiveType)} directive must be standalone in order to be applied to a dynamically-created component.`);
+      }
+      directivesToApply.push(directiveDef);
+    }
+  }
+  const rootTView = createTView(0, null, getRootTViewTemplate(creationBindings, updateBindings), 1, varsToAllocate, directivesToApply, null, null, null, [tAttributes], null);
+  return rootTView;
+}
+function getRootTViewTemplate(creationBindings, updateBindings) {
+  if (!creationBindings && !updateBindings) {
+    return null;
+  }
+  return (flags) => {
+    if (flags & 1 && creationBindings) {
+      for (const binding of creationBindings) {
+        binding.create();
+      }
+    }
+    if (flags & 2 && updateBindings) {
+      for (const binding of updateBindings) {
+        binding.update();
+      }
+    }
+  };
+}
+function isInputBinding(binding) {
+  const kind = binding[BINDING].kind;
+  return kind === "input" || kind === "twoWay";
+}
+var ComponentRef2 = class extends ComponentRef$1 {
+  _rootLView;
+  _hasInputBindings;
+  instance;
+  hostView;
+  changeDetectorRef;
+  componentType;
+  location;
+  previousInputValues = null;
+  _tNode;
+  constructor(componentType, _rootLView, _hasInputBindings) {
+    super();
+    this._rootLView = _rootLView;
+    this._hasInputBindings = _hasInputBindings;
+    this._tNode = getTNode(_rootLView[TVIEW], HEADER_OFFSET);
+    this.location = createElementRef(this._tNode, _rootLView);
+    this.instance = getComponentLViewByIndex(this._tNode.index, _rootLView)[CONTEXT];
+    this.hostView = this.changeDetectorRef = new ViewRef(_rootLView, void 0);
+    this.componentType = componentType;
+  }
+  setInput(name, value) {
+    if (this._hasInputBindings && ngDevMode) {
+      throw new RuntimeError(317, "Cannot call `setInput` on a component that is using the `inputBinding` or `twoWayBinding` functions.");
+    }
+    const tNode = this._tNode;
+    this.previousInputValues ??= /* @__PURE__ */ new Map();
+    if (this.previousInputValues.has(name) && Object.is(this.previousInputValues.get(name), value)) {
+      return;
+    }
+    const lView = this._rootLView;
+    const hasSetInput = setAllInputsForProperty(tNode, lView[TVIEW], lView, name, value);
+    this.previousInputValues.set(name, value);
+    const childComponentLView = getComponentLViewByIndex(tNode.index, lView);
+    markViewDirty(childComponentLView, 1);
+    if (ngDevMode && !hasSetInput) {
+      const cmpNameForError = stringifyForError(this.componentType);
+      let message = `Can't set value of the '${name}' input on the '${cmpNameForError}' component. `;
+      message += `Make sure that the '${name}' property is declared as an input using the input() or model() function or the @Input() decorator.`;
+      reportUnknownPropertyError(message);
+    }
+  }
+  get injector() {
+    return new NodeInjector(this._tNode, this._rootLView);
+  }
+  destroy() {
+    this.hostView.destroy();
+  }
+  onDestroy(callback) {
+    this.hostView.onDestroy(callback);
+  }
+};
+function projectNodes(tNode, ngContentSelectors, projectableNodes) {
+  const projection = tNode.projection = [];
+  for (let i = 0; i < ngContentSelectors.length; i++) {
+    const nodesforSlot = projectableNodes[i];
+    projection.push(nodesforSlot != null && nodesforSlot.length ? Array.from(nodesforSlot) : null);
+  }
+}
+var ViewContainerRef = class {
+  static __NG_ELEMENT_ID__ = injectViewContainerRef;
+};
+function injectViewContainerRef() {
+  const previousTNode = getCurrentTNode();
+  return createContainerRef(previousTNode, getLView());
+}
+var R3ViewContainerRef = class _R3ViewContainerRef extends ViewContainerRef {
+  _lContainer;
+  _hostTNode;
+  _hostLView;
+  constructor(_lContainer, _hostTNode, _hostLView) {
+    super();
+    this._lContainer = _lContainer;
+    this._hostTNode = _hostTNode;
+    this._hostLView = _hostLView;
+  }
+  get element() {
+    return createElementRef(this._hostTNode, this._hostLView);
+  }
+  get injector() {
+    return new NodeInjector(this._hostTNode, this._hostLView);
+  }
+  get parentInjector() {
+    const parentLocation = getParentInjectorLocation(this._hostTNode, this._hostLView);
+    if (hasParentInjector(parentLocation)) {
+      const parentView = getParentInjectorView(parentLocation, this._hostLView);
+      const injectorIndex = getParentInjectorIndex(parentLocation);
+      ngDevMode && assertNodeInjector(parentView, injectorIndex);
+      const parentTNode = parentView[TVIEW].data[injectorIndex + 8];
+      return new NodeInjector(parentTNode, parentView);
+    } else {
+      return new NodeInjector(null, this._hostLView);
+    }
+  }
+  clear() {
+    while (this.length > 0) {
+      this.remove(this.length - 1);
+    }
+  }
+  get(index) {
+    const viewRefs = getViewRefs(this._lContainer);
+    return viewRefs !== null && viewRefs[index] || null;
+  }
+  get length() {
+    return this._lContainer.length - CONTAINER_HEADER_OFFSET;
+  }
+  createEmbeddedView(templateRef, context2, indexOrOptions) {
+    let index;
+    let injector;
+    if (typeof indexOrOptions === "number") {
+      index = indexOrOptions;
+    } else if (indexOrOptions != null) {
+      index = indexOrOptions.index;
+      injector = indexOrOptions.injector;
+    }
+    const dehydratedView = findMatchingDehydratedView(this._lContainer, templateRef.ssrId);
+    const viewRef = templateRef.createEmbeddedViewImpl(context2 || {}, injector, dehydratedView);
+    this.insertImpl(viewRef, index, shouldAddViewToDom(this._hostTNode, dehydratedView));
+    return viewRef;
+  }
+  createComponent(componentFactoryOrType, indexOrOptions, injector, projectableNodes, environmentInjector, directives, bindings) {
+    const isComponentFactory = componentFactoryOrType && !isType(componentFactoryOrType);
+    let index;
+    if (isComponentFactory) {
+      if (ngDevMode) {
+        assertEqual(typeof indexOrOptions !== "object", true, "It looks like Component factory was provided as the first argument and an options object as the second argument. This combination of arguments is incompatible. You can either change the first argument to provide Component type or change the second argument to be a number (representing an index at which to insert the new component's host view into this container)");
+      }
+      index = indexOrOptions;
+    } else {
+      if (ngDevMode) {
+        assertDefined(getComponentDef(componentFactoryOrType), `Provided Component class doesn't contain Component definition. Please check whether provided class has @Component decorator.`);
+        assertEqual(typeof indexOrOptions !== "number", true, "It looks like Component type was provided as the first argument and a number (representing an index at which to insert the new component's host view into this container as the second argument. This combination of arguments is incompatible. Please use an object as the second argument instead.");
+      }
+      const options = indexOrOptions || {};
+      if (ngDevMode && options.environmentInjector && options.ngModuleRef) {
+        throwError2(`Cannot pass both environmentInjector and ngModuleRef options to createComponent().`);
+      }
+      index = options.index;
+      injector = options.injector;
+      projectableNodes = options.projectableNodes;
+      environmentInjector = options.environmentInjector || options.ngModuleRef;
+      directives = options.directives;
+      bindings = options.bindings;
+    }
+    const componentFactory = isComponentFactory ? componentFactoryOrType : new ComponentFactory2(getComponentDef(componentFactoryOrType));
+    const contextInjector = injector || this.parentInjector;
+    if (!environmentInjector && componentFactory.ngModule == null) {
+      const _injector = isComponentFactory ? contextInjector : this.parentInjector;
+      const result = _injector.get(EnvironmentInjector, null);
+      if (result) {
+        environmentInjector = result;
+      }
+    }
+    const componentDef = getComponentDef(componentFactory.componentType ?? {});
+    const dehydratedView = findMatchingDehydratedView(this._lContainer, componentDef?.id ?? null);
+    const rNode = dehydratedView?.firstChild ?? null;
+    const componentRef = componentFactory.create(contextInjector, projectableNodes, rNode, environmentInjector, directives, bindings);
+    this.insertImpl(componentRef.hostView, index, shouldAddViewToDom(this._hostTNode, dehydratedView));
+    return componentRef;
+  }
+  insert(viewRef, index) {
+    return this.insertImpl(viewRef, index, true);
+  }
+  insertImpl(viewRef, index, addToDOM) {
+    const lView = viewRef._lView;
+    if (ngDevMode && viewRef.destroyed) {
+      throw new RuntimeError(922, ngDevMode && "Cannot insert a destroyed View in a ViewContainer!");
+    }
+    if (viewAttachedToContainer(lView)) {
+      const prevIdx = this.indexOf(viewRef);
+      if (prevIdx !== -1) {
+        this.detach(prevIdx);
+      } else {
+        const prevLContainer = lView[PARENT];
+        ngDevMode && assertEqual(isLContainer(prevLContainer), true, "An attached view should have its PARENT point to a container.");
+        const prevVCRef = new _R3ViewContainerRef(prevLContainer, prevLContainer[T_HOST], prevLContainer[PARENT]);
+        prevVCRef.detach(prevVCRef.indexOf(viewRef));
+      }
+    }
+    const adjustedIdx = this._adjustIndex(index);
+    const lContainer = this._lContainer;
+    addLViewToLContainer(lContainer, lView, adjustedIdx, addToDOM);
+    viewRef.attachToViewContainerRef();
+    addToArray(getOrCreateViewRefs(lContainer), adjustedIdx, viewRef);
+    return viewRef;
+  }
+  move(viewRef, newIndex) {
+    if (ngDevMode && viewRef.destroyed) {
+      throw new RuntimeError(923, ngDevMode && "Cannot move a destroyed View in a ViewContainer!");
+    }
+    return this.insert(viewRef, newIndex);
+  }
+  indexOf(viewRef) {
+    const viewRefsArr = getViewRefs(this._lContainer);
+    return viewRefsArr !== null ? viewRefsArr.indexOf(viewRef) : -1;
+  }
+  remove(index) {
+    const adjustedIdx = this._adjustIndex(index, -1);
+    const detachedView = detachView(this._lContainer, adjustedIdx);
+    if (detachedView) {
+      removeFromArray(getOrCreateViewRefs(this._lContainer), adjustedIdx);
+      destroyLView(detachedView[TVIEW], detachedView);
+    }
+  }
+  detach(index) {
+    const adjustedIdx = this._adjustIndex(index, -1);
+    const view = detachView(this._lContainer, adjustedIdx);
+    const wasDetached = view && removeFromArray(getOrCreateViewRefs(this._lContainer), adjustedIdx) != null;
+    return wasDetached ? new ViewRef(view) : null;
+  }
+  _adjustIndex(index, shift = 0) {
+    if (index == null) {
+      return this.length + shift;
+    }
+    if (ngDevMode) {
+      assertGreaterThan(index, -1, `ViewRef index must be positive, got ${index}`);
+      assertLessThan(index, this.length + 1 + shift, "index");
+    }
+    return index;
+  }
+};
+function getViewRefs(lContainer) {
+  return lContainer[VIEW_REFS];
+}
+function getOrCreateViewRefs(lContainer) {
+  return lContainer[VIEW_REFS] || (lContainer[VIEW_REFS] = []);
+}
+function createContainerRef(hostTNode, hostLView) {
+  ngDevMode && assertTNodeType(hostTNode, 12 | 3);
+  let lContainer;
+  const slotValue = hostLView[hostTNode.index];
+  if (isLContainer(slotValue)) {
+    lContainer = slotValue;
+  } else {
+    lContainer = createLContainer(slotValue, hostLView, null, hostTNode);
+    hostLView[hostTNode.index] = lContainer;
+    addToEndOfViewTree(hostLView, lContainer);
+  }
+  _locateOrCreateAnchorNode(lContainer, hostLView, hostTNode, slotValue);
+  return new R3ViewContainerRef(lContainer, hostTNode, hostLView);
+}
+function insertAnchorNode(hostLView, hostTNode) {
+  const renderer = hostLView[RENDERER];
+  const commentNode = renderer.createComment(ngDevMode ? "container" : "");
+  const hostNative = getNativeByTNode(hostTNode, hostLView);
+  const parentOfHostNative = renderer.parentNode(hostNative);
+  nativeInsertBefore(renderer, parentOfHostNative, commentNode, renderer.nextSibling(hostNative), false);
+  return commentNode;
+}
+var _locateOrCreateAnchorNode = createAnchorNode;
+var _populateDehydratedViewsInLContainer = () => false;
+function populateDehydratedViewsInLContainer(lContainer, tNode, hostLView) {
+  return _populateDehydratedViewsInLContainer(lContainer, tNode, hostLView);
+}
+function createAnchorNode(lContainer, hostLView, hostTNode, slotValue) {
+  if (lContainer[NATIVE]) return;
+  let commentNode;
+  if (hostTNode.type & 8) {
+    commentNode = unwrapRNode(slotValue);
+  } else {
+    commentNode = insertAnchorNode(hostLView, hostTNode);
+  }
+  lContainer[NATIVE] = commentNode;
+}
+var LQuery_ = class _LQuery_ {
+  queryList;
+  matches = null;
+  constructor(queryList) {
+    this.queryList = queryList;
+  }
+  clone() {
+    return new _LQuery_(this.queryList);
+  }
+  setDirty() {
+    this.queryList.setDirty();
+  }
+};
+var LQueries_ = class _LQueries_ {
+  queries;
+  constructor(queries = []) {
+    this.queries = queries;
+  }
+  createEmbeddedView(tView) {
+    const tQueries = tView.queries;
+    if (tQueries !== null) {
+      const noOfInheritedQueries = tView.contentQueries !== null ? tView.contentQueries[0] : tQueries.length;
+      const viewLQueries = [];
+      for (let i = 0; i < noOfInheritedQueries; i++) {
+        const tQuery = tQueries.getByIndex(i);
+        const parentLQuery = this.queries[tQuery.indexInDeclarationView];
+        viewLQueries.push(parentLQuery.clone());
+      }
+      return new _LQueries_(viewLQueries);
+    }
+    return null;
+  }
+  insertView(tView) {
+    this.dirtyQueriesWithMatches(tView);
+  }
+  detachView(tView) {
+    this.dirtyQueriesWithMatches(tView);
+  }
+  finishViewCreation(tView) {
+    this.dirtyQueriesWithMatches(tView);
+  }
+  dirtyQueriesWithMatches(tView) {
+    for (let i = 0; i < this.queries.length; i++) {
+      if (getTQuery(tView, i).matches !== null) {
+        this.queries[i].setDirty();
+      }
+    }
+  }
+};
+var TQueryMetadata_ = class {
+  flags;
+  read;
+  predicate;
+  constructor(predicate, flags, read = null) {
+    this.flags = flags;
+    this.read = read;
+    if (typeof predicate === "string") {
+      this.predicate = splitQueryMultiSelectors(predicate);
+    } else {
+      this.predicate = predicate;
+    }
+  }
+};
+var TQueries_ = class _TQueries_ {
+  queries;
+  constructor(queries = []) {
+    this.queries = queries;
+  }
+  elementStart(tView, tNode) {
+    ngDevMode && assertFirstCreatePass(tView, "Queries should collect results on the first template pass only");
+    for (let i = 0; i < this.queries.length; i++) {
+      this.queries[i].elementStart(tView, tNode);
+    }
+  }
+  elementEnd(tNode) {
+    for (let i = 0; i < this.queries.length; i++) {
+      this.queries[i].elementEnd(tNode);
+    }
+  }
+  embeddedTView(tNode) {
+    let queriesForTemplateRef = null;
+    for (let i = 0; i < this.length; i++) {
+      const childQueryIndex = queriesForTemplateRef !== null ? queriesForTemplateRef.length : 0;
+      const tqueryClone = this.getByIndex(i).embeddedTView(tNode, childQueryIndex);
+      if (tqueryClone) {
+        tqueryClone.indexInDeclarationView = i;
+        if (queriesForTemplateRef !== null) {
+          queriesForTemplateRef.push(tqueryClone);
+        } else {
+          queriesForTemplateRef = [tqueryClone];
+        }
+      }
+    }
+    return queriesForTemplateRef !== null ? new _TQueries_(queriesForTemplateRef) : null;
+  }
+  template(tView, tNode) {
+    ngDevMode && assertFirstCreatePass(tView, "Queries should collect results on the first template pass only");
+    for (let i = 0; i < this.queries.length; i++) {
+      this.queries[i].template(tView, tNode);
+    }
+  }
+  getByIndex(index) {
+    ngDevMode && assertIndexInRange(this.queries, index);
+    return this.queries[index];
+  }
+  get length() {
+    return this.queries.length;
+  }
+  track(tquery) {
+    this.queries.push(tquery);
+  }
+};
+var TQuery_ = class _TQuery_ {
+  metadata;
+  matches = null;
+  indexInDeclarationView = -1;
+  crossesNgTemplate = false;
+  _declarationNodeIndex;
+  _appliesToNextNode = true;
+  constructor(metadata, nodeIndex = -1) {
+    this.metadata = metadata;
+    this._declarationNodeIndex = nodeIndex;
+  }
+  elementStart(tView, tNode) {
+    if (this.isApplyingToNode(tNode)) {
+      this.matchTNode(tView, tNode);
+    }
+  }
+  elementEnd(tNode) {
+    if (this._declarationNodeIndex === tNode.index) {
+      this._appliesToNextNode = false;
+    }
+  }
+  template(tView, tNode) {
+    this.elementStart(tView, tNode);
+  }
+  embeddedTView(tNode, childQueryIndex) {
+    if (this.isApplyingToNode(tNode)) {
+      this.crossesNgTemplate = true;
+      this.addMatch(-tNode.index, childQueryIndex);
+      return new _TQuery_(this.metadata);
+    }
+    return null;
+  }
+  isApplyingToNode(tNode) {
+    if (this._appliesToNextNode && (this.metadata.flags & 1) !== 1) {
+      const declarationNodeIdx = this._declarationNodeIndex;
+      let parent = tNode.parent;
+      while (parent !== null && parent.type & 8 && parent.index !== declarationNodeIdx) {
+        parent = parent.parent;
+      }
+      return declarationNodeIdx === (parent !== null ? parent.index : -1);
+    }
+    return this._appliesToNextNode;
+  }
+  matchTNode(tView, tNode) {
+    const predicate = this.metadata.predicate;
+    if (Array.isArray(predicate)) {
+      for (let i = 0; i < predicate.length; i++) {
+        const name = predicate[i];
+        this.matchTNodeWithReadOption(tView, tNode, getIdxOfMatchingSelector(tNode, name));
+        this.matchTNodeWithReadOption(tView, tNode, locateDirectiveOrProvider(tNode, tView, name, false, false));
+      }
+    } else {
+      if (predicate === TemplateRef) {
+        if (tNode.type & 4) {
+          this.matchTNodeWithReadOption(tView, tNode, -1);
+        }
+      } else {
+        this.matchTNodeWithReadOption(tView, tNode, locateDirectiveOrProvider(tNode, tView, predicate, false, false));
+      }
+    }
+  }
+  matchTNodeWithReadOption(tView, tNode, nodeMatchIdx) {
+    if (nodeMatchIdx !== null) {
+      const read = this.metadata.read;
+      if (read !== null) {
+        if (read === ElementRef || read === ViewContainerRef || read === TemplateRef && tNode.type & 4) {
+          this.addMatch(tNode.index, -2);
+        } else {
+          const directiveOrProviderIdx = locateDirectiveOrProvider(tNode, tView, read, false, false);
+          if (directiveOrProviderIdx !== null) {
+            this.addMatch(tNode.index, directiveOrProviderIdx);
+          }
+        }
+      } else {
+        this.addMatch(tNode.index, nodeMatchIdx);
+      }
+    }
+  }
+  addMatch(tNodeIdx, matchIdx) {
+    if (this.matches === null) {
+      this.matches = [tNodeIdx, matchIdx];
+    } else {
+      this.matches.push(tNodeIdx, matchIdx);
+    }
+  }
+};
+function getIdxOfMatchingSelector(tNode, selector) {
+  const localNames = tNode.localNames;
+  if (localNames !== null) {
+    for (let i = 0; i < localNames.length; i += 2) {
+      if (localNames[i] === selector) {
+        return localNames[i + 1];
+      }
+    }
+  }
+  return null;
+}
+function createResultByTNodeType(tNode, currentView) {
+  if (tNode.type & (3 | 8)) {
+    return createElementRef(tNode, currentView);
+  } else if (tNode.type & 4) {
+    return createTemplateRef(tNode, currentView);
+  }
+  return null;
+}
+function createResultForNode(lView, tNode, matchingIdx, read) {
+  if (matchingIdx === -1) {
+    return createResultByTNodeType(tNode, lView);
+  } else if (matchingIdx === -2) {
+    return createSpecialToken(lView, tNode, read);
+  } else {
+    return getNodeInjectable(lView, lView[TVIEW], matchingIdx, tNode);
+  }
+}
+function createSpecialToken(lView, tNode, read) {
+  if (read === ElementRef) {
+    return createElementRef(tNode, lView);
+  } else if (read === TemplateRef) {
+    return createTemplateRef(tNode, lView);
+  } else if (read === ViewContainerRef) {
+    ngDevMode && assertTNodeType(tNode, 3 | 12);
+    return createContainerRef(tNode, lView);
+  } else {
+    ngDevMode && throwError2(`Special token to read should be one of ElementRef, TemplateRef or ViewContainerRef but got ${stringify(read)}.`);
+  }
+}
+function materializeViewResults(tView, lView, tQuery, queryIndex) {
+  const lQuery = lView[QUERIES].queries[queryIndex];
+  if (lQuery.matches === null) {
+    const tViewData = tView.data;
+    const tQueryMatches = tQuery.matches;
+    const result = [];
+    for (let i = 0; tQueryMatches !== null && i < tQueryMatches.length; i += 2) {
+      const matchedNodeIdx = tQueryMatches[i];
+      if (matchedNodeIdx < 0) {
+        result.push(null);
+      } else {
+        ngDevMode && assertIndexInRange(tViewData, matchedNodeIdx);
+        const tNode = tViewData[matchedNodeIdx];
+        result.push(createResultForNode(lView, tNode, tQueryMatches[i + 1], tQuery.metadata.read));
+      }
+    }
+    lQuery.matches = result;
+  }
+  return lQuery.matches;
+}
+function collectQueryResults(tView, lView, queryIndex, result) {
+  const tQuery = tView.queries.getByIndex(queryIndex);
+  const tQueryMatches = tQuery.matches;
+  if (tQueryMatches !== null) {
+    const lViewResults = materializeViewResults(tView, lView, tQuery, queryIndex);
+    for (let i = 0; i < tQueryMatches.length; i += 2) {
+      const tNodeIdx = tQueryMatches[i];
+      if (tNodeIdx > 0) {
+        result.push(lViewResults[i / 2]);
+      } else {
+        const childQueryIndex = tQueryMatches[i + 1];
+        const declarationLContainer = lView[-tNodeIdx];
+        ngDevMode && assertLContainer(declarationLContainer);
+        for (let i2 = CONTAINER_HEADER_OFFSET; i2 < declarationLContainer.length; i2++) {
+          const embeddedLView = declarationLContainer[i2];
+          if (embeddedLView[DECLARATION_LCONTAINER] === embeddedLView[PARENT]) {
+            collectQueryResults(embeddedLView[TVIEW], embeddedLView, childQueryIndex, result);
+          }
+        }
+        if (declarationLContainer[MOVED_VIEWS] !== null) {
+          const embeddedLViews = declarationLContainer[MOVED_VIEWS];
+          for (let i2 = 0; i2 < embeddedLViews.length; i2++) {
+            const embeddedLView = embeddedLViews[i2];
+            collectQueryResults(embeddedLView[TVIEW], embeddedLView, childQueryIndex, result);
+          }
+        }
+      }
+    }
+  }
+  return result;
+}
+function loadQueryInternal(lView, queryIndex) {
+  ngDevMode && assertDefined(lView[QUERIES], "LQueries should be defined when trying to load a query");
+  ngDevMode && assertIndexInRange(lView[QUERIES].queries, queryIndex);
+  return lView[QUERIES].queries[queryIndex].queryList;
+}
+function createLQuery(tView, lView, flags) {
+  const queryList = new QueryList((flags & 4) === 4);
+  storeCleanupWithContext(tView, lView, queryList, queryList.destroy);
+  const lQueries = (lView[QUERIES] ??= new LQueries_()).queries;
+  return lQueries.push(new LQuery_(queryList)) - 1;
+}
+function createViewQuery(predicate, flags, read) {
+  ngDevMode && assertNumber(flags, "Expecting flags");
+  const tView = getTView();
+  if (tView.firstCreatePass) {
+    createTQuery(tView, new TQueryMetadata_(predicate, flags, read), -1);
+    if ((flags & 2) === 2) {
+      tView.staticViewQueries = true;
+    }
+  }
+  return createLQuery(tView, getLView(), flags);
+}
+function createContentQuery(directiveIndex, predicate, flags, read) {
+  ngDevMode && assertNumber(flags, "Expecting flags");
+  const tView = getTView();
+  if (tView.firstCreatePass) {
+    const tNode = getCurrentTNode();
+    createTQuery(tView, new TQueryMetadata_(predicate, flags, read), tNode.index);
+    saveContentQueryAndDirectiveIndex(tView, directiveIndex);
+    if ((flags & 2) === 2) {
+      tView.staticContentQueries = true;
+    }
+  }
+  return createLQuery(tView, getLView(), flags);
+}
+function splitQueryMultiSelectors(locator) {
+  return locator.split(",").map((s) => s.trim());
+}
+function createTQuery(tView, metadata, nodeIndex) {
+  if (tView.queries === null) tView.queries = new TQueries_();
+  tView.queries.track(new TQuery_(metadata, nodeIndex));
+}
+function saveContentQueryAndDirectiveIndex(tView, directiveIndex) {
+  const tViewContentQueries = tView.contentQueries || (tView.contentQueries = []);
+  const lastSavedDirectiveIndex = tViewContentQueries.length ? tViewContentQueries[tViewContentQueries.length - 1] : -1;
+  if (directiveIndex !== lastSavedDirectiveIndex) {
+    tViewContentQueries.push(tView.queries.length - 1, directiveIndex);
+  }
+}
+function getTQuery(tView, index) {
+  ngDevMode && assertDefined(tView.queries, "TQueries must be defined to retrieve a TQuery");
+  return tView.queries.getByIndex(index);
+}
+function getQueryResults(lView, queryIndex) {
+  const tView = lView[TVIEW];
+  const tQuery = getTQuery(tView, queryIndex);
+  return tQuery.crossesNgTemplate ? collectQueryResults(tView, lView, queryIndex, []) : materializeViewResults(tView, lView, tQuery, queryIndex);
+}
+function createQuerySignalFn(firstOnly, required, opts) {
+  let node;
+  const signalFn = createComputed(() => {
+    node._dirtyCounter();
+    const value = refreshSignalQuery(node, firstOnly);
+    if (required && value === void 0) {
+      throw new RuntimeError(-951, ngDevMode && "Child query result is required but no value is available.");
+    }
+    return value;
+  });
+  node = signalFn[SIGNAL];
+  node._dirtyCounter = signal(0);
+  node._flatValue = void 0;
+  if (ngDevMode) {
+    signalFn.toString = () => `[Query Signal]`;
+    node.debugName = opts?.debugName;
+  }
+  return signalFn;
+}
+function createSingleResultOptionalQuerySignalFn(opts) {
+  return createQuerySignalFn(true, false, opts);
+}
+function createSingleResultRequiredQuerySignalFn(opts) {
+  return createQuerySignalFn(true, true, opts);
+}
+function createMultiResultQuerySignalFn(opts) {
+  return createQuerySignalFn(false, false, opts);
+}
+function bindQueryToSignal(target, queryIndex) {
+  const node = target[SIGNAL];
+  node._lView = getLView();
+  node._queryIndex = queryIndex;
+  node._queryList = loadQueryInternal(node._lView, queryIndex);
+  node._queryList.onDirty(() => node._dirtyCounter.update((v) => v + 1));
+}
+function refreshSignalQuery(node, firstOnly) {
+  const lView = node._lView;
+  const queryIndex = node._queryIndex;
+  if (lView === void 0 || queryIndex === void 0 || lView[FLAGS] & 4) {
+    return firstOnly ? void 0 : EMPTY_ARRAY;
+  }
+  const queryList = loadQueryInternal(lView, queryIndex);
+  const results = getQueryResults(lView, queryIndex);
+  queryList.reset(results, unwrapElementRef);
+  if (firstOnly) {
+    return queryList.first;
+  } else {
+    const resultChanged = queryList._changesDetected;
+    if (resultChanged || node._flatValue === void 0) {
+      return node._flatValue = queryList.toArray();
+    }
+    return node._flatValue;
+  }
+}
+var componentResourceResolutionQueue = /* @__PURE__ */ new Map();
+var componentDefPendingResolution = /* @__PURE__ */ new Set();
+async function resolveComponentResources(resourceResolver) {
+  const currentQueue = componentResourceResolutionQueue;
+  componentResourceResolutionQueue = /* @__PURE__ */ new Map();
+  const urlCache = /* @__PURE__ */ new Map();
+  function cachedResourceResolve(url) {
+    const promiseCached = urlCache.get(url);
+    if (promiseCached) {
+      return promiseCached;
+    }
+    const promise = resourceResolver(url).then((response) => unwrapResponse(url, response));
+    urlCache.set(url, promise);
+    return promise;
+  }
+  const resolutionPromises = Array.from(currentQueue).map(async ([type, component]) => {
+    if (component.styleUrl && component.styleUrls?.length) {
+      throw new Error("@Component cannot define both `styleUrl` and `styleUrls`. Use `styleUrl` if the component has one stylesheet, or `styleUrls` if it has multiple");
+    }
+    const componentTasks = [];
+    if (component.templateUrl) {
+      componentTasks.push(cachedResourceResolve(component.templateUrl).then((template) => {
+        component.template = template;
+      }));
+    }
+    const styles = typeof component.styles === "string" ? [component.styles] : component.styles ?? [];
+    component.styles = styles;
+    let {
+      styleUrl,
+      styleUrls
+    } = component;
+    if (styleUrl) {
+      styleUrls = [styleUrl];
+      component.styleUrl = void 0;
+    }
+    if (styleUrls?.length) {
+      const allFetched = Promise.all(styleUrls.map((url) => cachedResourceResolve(url))).then((fetchedStyles) => {
+        styles.push(...fetchedStyles);
+        component.styleUrls = void 0;
+      });
+      componentTasks.push(allFetched);
+    }
+    await Promise.all(componentTasks);
+    componentDefPendingResolution.delete(type);
+  });
+  await Promise.all(resolutionPromises);
+}
+function maybeQueueResolutionOfComponentResources(type, metadata) {
+  if (componentNeedsResolution(metadata)) {
+    componentResourceResolutionQueue.set(type, metadata);
+    componentDefPendingResolution.add(type);
+  }
+}
+function componentNeedsResolution(component) {
+  return !!(component.templateUrl && !component.hasOwnProperty("template") || component.styleUrls?.length || component.styleUrl);
+}
+function isComponentResourceResolutionQueueEmpty() {
+  return componentResourceResolutionQueue.size === 0;
+}
+async function unwrapResponse(url, response) {
+  if (typeof response === "string") {
+    return response;
+  }
+  if (response.status !== void 0 && response.status !== 200) {
+    throw new RuntimeError(918, ngDevMode && `Could not load resource: ${url}. Response status: ${response.status}`);
+  }
+  return response.text();
+}
+var modules = /* @__PURE__ */ new Map();
+var checkForDuplicateNgModules = true;
+function assertSameOrNotExisting(id, type, incoming) {
+  if (type && type !== incoming && checkForDuplicateNgModules) {
+    throw new RuntimeError(921, ngDevMode && `Duplicate module registered for ${id} - ${stringify(type)} vs ${stringify(type.name)}`);
+  }
+}
+function registerNgModuleType(ngModuleType, id) {
+  const existing = modules.get(id) || null;
+  assertSameOrNotExisting(id, existing, ngModuleType);
+  modules.set(id, ngModuleType);
+}
+var NgModuleRef$1 = class NgModuleRef {
+};
+var NgModuleFactory$1 = class NgModuleFactory {
+};
+function createNgModule(ngModule, parentInjector) {
+  return new NgModuleRef2(ngModule, parentInjector ?? null, []);
+}
+var NgModuleRef2 = class extends NgModuleRef$1 {
+  ngModuleType;
+  _parent;
+  _bootstrapComponents = [];
+  _r3Injector;
+  instance;
+  destroyCbs = [];
+  componentFactoryResolver = new ComponentFactoryResolver2(this);
+  constructor(ngModuleType, _parent, additionalProviders, runInjectorInitializers = true) {
+    super();
+    this.ngModuleType = ngModuleType;
+    this._parent = _parent;
+    const ngModuleDef = getNgModuleDef(ngModuleType);
+    ngDevMode && assertDefined(ngModuleDef, `NgModule '${stringify(ngModuleType)}' is not a subtype of 'NgModuleType'.`);
+    this._bootstrapComponents = maybeUnwrapFn(ngModuleDef.bootstrap);
+    this._r3Injector = createInjectorWithoutInjectorInstances(ngModuleType, _parent, [{
+      provide: NgModuleRef$1,
+      useValue: this
+    }, {
+      provide: ComponentFactoryResolver$1,
+      useValue: this.componentFactoryResolver
+    }, ...additionalProviders], stringify(ngModuleType), /* @__PURE__ */ new Set(["environment"]));
+    if (runInjectorInitializers) {
+      this.resolveInjectorInitializers();
+    }
+  }
+  resolveInjectorInitializers() {
+    this._r3Injector.resolveInjectorInitializers();
+    this.instance = this._r3Injector.get(this.ngModuleType);
+  }
+  get injector() {
+    return this._r3Injector;
+  }
+  destroy() {
+    ngDevMode && assertDefined(this.destroyCbs, "NgModule already destroyed");
+    const injector = this._r3Injector;
+    !injector.destroyed && injector.destroy();
+    this.destroyCbs.forEach((fn) => fn());
+    this.destroyCbs = null;
+  }
+  onDestroy(callback) {
+    ngDevMode && assertDefined(this.destroyCbs, "NgModule already destroyed");
+    this.destroyCbs.push(callback);
+  }
+};
+var NgModuleFactory2 = class extends NgModuleFactory$1 {
+  moduleType;
+  constructor(moduleType) {
+    super();
+    this.moduleType = moduleType;
+  }
+  create(parentInjector) {
+    return new NgModuleRef2(this.moduleType, parentInjector, []);
+  }
+};
+function createNgModuleRefWithProviders(moduleType, parentInjector, additionalProviders) {
+  return new NgModuleRef2(moduleType, parentInjector, additionalProviders, false);
+}
+var EnvironmentNgModuleRefAdapter = class extends NgModuleRef$1 {
+  injector;
+  componentFactoryResolver = new ComponentFactoryResolver2(this);
+  instance = null;
+  constructor(config2) {
+    super();
+    const injector = new R3Injector([...config2.providers, {
+      provide: NgModuleRef$1,
+      useValue: this
+    }, {
+      provide: ComponentFactoryResolver$1,
+      useValue: this.componentFactoryResolver
+    }], config2.parent || getNullInjector(), config2.debugName, /* @__PURE__ */ new Set(["environment"]));
+    this.injector = injector;
+    if (config2.runEnvironmentInitializers) {
+      injector.resolveInjectorInitializers();
+    }
+  }
+  destroy() {
+    this.injector.destroy();
+  }
+  onDestroy(callback) {
+    this.injector.onDestroy(callback);
+  }
+};
+function createEnvironmentInjector(providers, parent, debugName = null) {
+  const adapter = new EnvironmentNgModuleRefAdapter({
+    providers,
+    parent,
+    debugName,
+    runEnvironmentInitializers: true
+  });
+  return adapter.injector;
+}
+var StandaloneService = class _StandaloneService {
+  _injector;
+  cachedInjectors = /* @__PURE__ */ new Map();
+  constructor(_injector) {
+    this._injector = _injector;
+  }
+  getOrCreateStandaloneInjector(componentDef) {
+    if (!componentDef.standalone) {
+      return null;
+    }
+    if (!this.cachedInjectors.has(componentDef)) {
+      const providers = internalImportProvidersFrom(false, componentDef.type);
+      const standaloneInjector = providers.length > 0 ? createEnvironmentInjector([providers], this._injector, typeof ngDevMode !== "undefined" && ngDevMode ? `Standalone[${componentDef.type.name}]` : "") : null;
+      this.cachedInjectors.set(componentDef, standaloneInjector);
+    }
+    return this.cachedInjectors.get(componentDef);
+  }
+  ngOnDestroy() {
+    try {
+      for (const injector of this.cachedInjectors.values()) {
+        if (injector !== null) {
+          injector.destroy();
+        }
+      }
+    } finally {
+      this.cachedInjectors.clear();
+    }
+  }
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _StandaloneService,
+    providedIn: "environment",
+    factory: () => new _StandaloneService(\u0275\u0275inject(EnvironmentInjector))
+  });
+};
+function \u0275\u0275defineComponent(componentDefinition) {
+  return noSideEffects(() => {
+    (typeof ngDevMode === "undefined" || ngDevMode) && initNgDevMode();
+    const baseDef = getNgDirectiveDef(componentDefinition);
+    const def = __spreadProps(__spreadValues({}, baseDef), {
+      decls: componentDefinition.decls,
+      vars: componentDefinition.vars,
+      template: componentDefinition.template,
+      consts: componentDefinition.consts || null,
+      ngContentSelectors: componentDefinition.ngContentSelectors,
+      onPush: componentDefinition.changeDetection === ChangeDetectionStrategy.OnPush,
+      directiveDefs: null,
+      pipeDefs: null,
+      dependencies: baseDef.standalone && componentDefinition.dependencies || null,
+      getStandaloneInjector: baseDef.standalone ? (parentInjector) => {
+        return parentInjector.get(StandaloneService).getOrCreateStandaloneInjector(def);
+      } : null,
+      getExternalStyles: null,
+      signals: componentDefinition.signals ?? false,
+      data: componentDefinition.data || {},
+      encapsulation: componentDefinition.encapsulation || ViewEncapsulation.Emulated,
+      styles: componentDefinition.styles || EMPTY_ARRAY,
+      _: null,
+      schemas: componentDefinition.schemas || null,
+      tView: null,
+      id: ""
+    });
+    if (baseDef.standalone) {
+      performanceMarkFeature("NgStandalone");
+    }
+    initFeatures(def);
+    const dependencies = componentDefinition.dependencies;
+    def.directiveDefs = extractDefListOrFactory(dependencies, extractDirectiveDef);
+    def.pipeDefs = extractDefListOrFactory(dependencies, getPipeDef);
+    def.id = getComponentId(def);
+    return def;
+  });
+}
+function extractDirectiveDef(type) {
+  return getComponentDef(type) || getDirectiveDef(type);
+}
+function \u0275\u0275defineNgModule(def) {
+  return noSideEffects(() => {
+    const res = {
+      type: def.type,
+      bootstrap: def.bootstrap || EMPTY_ARRAY,
+      declarations: def.declarations || EMPTY_ARRAY,
+      imports: def.imports || EMPTY_ARRAY,
+      exports: def.exports || EMPTY_ARRAY,
+      transitiveCompileScopes: null,
+      schemas: def.schemas || null,
+      id: def.id || null
+    };
+    return res;
+  });
+}
+function parseAndConvertInputsForDefinition(obj, declaredInputs) {
+  if (obj == null) return EMPTY_OBJ;
+  const newLookup = {};
+  for (const minifiedKey in obj) {
+    if (obj.hasOwnProperty(minifiedKey)) {
+      const value = obj[minifiedKey];
+      let publicName;
+      let declaredName;
+      let inputFlags;
+      let transform;
+      if (Array.isArray(value)) {
+        inputFlags = value[0];
+        publicName = value[1];
+        declaredName = value[2] ?? publicName;
+        transform = value[3] || null;
+      } else {
+        publicName = value;
+        declaredName = value;
+        inputFlags = InputFlags.None;
+        transform = null;
+      }
+      newLookup[publicName] = [minifiedKey, inputFlags, transform];
+      declaredInputs[publicName] = declaredName;
+    }
+  }
+  return newLookup;
+}
+function parseAndConvertOutputsForDefinition(obj) {
+  if (obj == null) return EMPTY_OBJ;
+  const newLookup = {};
+  for (const minifiedKey in obj) {
+    if (obj.hasOwnProperty(minifiedKey)) {
+      newLookup[obj[minifiedKey]] = minifiedKey;
+    }
+  }
+  return newLookup;
+}
+function \u0275\u0275defineDirective(directiveDefinition) {
+  return noSideEffects(() => {
+    const def = getNgDirectiveDef(directiveDefinition);
+    initFeatures(def);
+    return def;
+  });
+}
+function \u0275\u0275definePipe(pipeDef) {
+  return {
+    type: pipeDef.type,
+    name: pipeDef.name,
+    factory: null,
+    pure: pipeDef.pure !== false,
+    standalone: pipeDef.standalone ?? true,
+    onDestroy: pipeDef.type.prototype.ngOnDestroy || null
+  };
+}
+function getNgDirectiveDef(directiveDefinition) {
+  const declaredInputs = {};
+  return {
+    type: directiveDefinition.type,
+    providersResolver: null,
+    viewProvidersResolver: null,
+    factory: null,
+    hostBindings: directiveDefinition.hostBindings || null,
+    hostVars: directiveDefinition.hostVars || 0,
+    hostAttrs: directiveDefinition.hostAttrs || null,
+    contentQueries: directiveDefinition.contentQueries || null,
+    declaredInputs,
+    inputConfig: directiveDefinition.inputs || EMPTY_OBJ,
+    exportAs: directiveDefinition.exportAs || null,
+    standalone: directiveDefinition.standalone ?? true,
+    signals: directiveDefinition.signals === true,
+    selectors: directiveDefinition.selectors || EMPTY_ARRAY,
+    viewQuery: directiveDefinition.viewQuery || null,
+    features: directiveDefinition.features || null,
+    setInput: null,
+    resolveHostDirectives: null,
+    hostDirectives: null,
+    controlDef: null,
+    inputs: parseAndConvertInputsForDefinition(directiveDefinition.inputs, declaredInputs),
+    outputs: parseAndConvertOutputsForDefinition(directiveDefinition.outputs),
+    debugInfo: null
+  };
+}
+function initFeatures(definition) {
+  definition.features?.forEach((fn) => fn(definition));
+}
+function extractDefListOrFactory(dependencies, defExtractor) {
+  if (!dependencies) {
+    return null;
+  }
+  return () => {
+    const resolvedDependencies = typeof dependencies === "function" ? dependencies() : dependencies;
+    const result = [];
+    for (const dep of resolvedDependencies) {
+      const definition = defExtractor(dep);
+      if (definition !== null) {
+        result.push(definition);
+      }
+    }
+    return result;
+  };
+}
+var GENERATED_COMP_IDS = /* @__PURE__ */ new Map();
+function getComponentId(componentDef) {
+  let hash = 0;
+  const componentDefConsts = typeof componentDef.consts === "function" ? "" : componentDef.consts;
+  const hashSelectors = [componentDef.selectors, componentDef.ngContentSelectors, componentDef.hostVars, componentDef.hostAttrs, componentDefConsts, componentDef.vars, componentDef.decls, componentDef.encapsulation, componentDef.standalone, componentDef.signals, componentDef.exportAs, JSON.stringify(componentDef.inputs), JSON.stringify(componentDef.outputs), Object.getOwnPropertyNames(componentDef.type.prototype), !!componentDef.contentQueries, !!componentDef.viewQuery];
+  if (typeof ngDevMode === "undefined" || ngDevMode) {
+    for (const item of hashSelectors) {
+      assertNotEqual(typeof item, "function", "Internal error: attempting to use a function in component id computation logic.");
+    }
+  }
+  for (const char of hashSelectors.join("|")) {
+    hash = Math.imul(31, hash) + char.charCodeAt(0) << 0;
+  }
+  hash += 2147483647 + 1;
+  const compId = "c" + hash;
+  if ((typeof ngDevMode === "undefined" || ngDevMode) && true) {
+    if (GENERATED_COMP_IDS.has(compId)) {
+      const previousCompDefType = GENERATED_COMP_IDS.get(compId);
+      if (previousCompDefType !== componentDef.type) {
+        console.warn(formatRuntimeError(-912, `Component ID generation collision detected. Components '${previousCompDefType.name}' and '${componentDef.type.name}' with selector '${stringifyCSSSelectorList(componentDef.selectors)}' generated the same component ID. To fix this, you can change the selector of one of those components or add an extra host attribute to force a different ID.`));
+      }
+    } else {
+      GENERATED_COMP_IDS.set(compId, componentDef.type);
+    }
+  }
+  return compId;
+}
+function \u0275\u0275ControlFeature(passThroughInput) {
+  return (definition) => {
+    definition.controlDef = {
+      create: (inst, host) => {
+        inst?.\u0275ngControlCreate(host);
+      },
+      update: (inst, host) => {
+        inst?.\u0275ngControlUpdate?.(host);
+      },
+      passThroughInput
+    };
+  };
+}
+function \u0275\u0275HostDirectivesFeature(rawHostDirectives) {
+  const feature = (definition) => {
+    const isEager = Array.isArray(rawHostDirectives);
+    if (definition.hostDirectives === null) {
+      definition.resolveHostDirectives = resolveHostDirectives;
+      definition.hostDirectives = isEager ? rawHostDirectives.map(createHostDirectiveDef) : [rawHostDirectives];
+    } else if (isEager) {
+      definition.hostDirectives.unshift(...rawHostDirectives.map(createHostDirectiveDef));
+    } else {
+      definition.hostDirectives.unshift(rawHostDirectives);
+    }
+  };
+  feature.ngInherit = true;
+  return feature;
+}
+function resolveHostDirectives(matches) {
+  const allDirectiveDefs = [];
+  let hasComponent = false;
+  let hostDirectiveDefs = null;
+  let hostDirectiveRanges = null;
+  for (let i = 0; i < matches.length; i++) {
+    const def = matches[i];
+    if (def.hostDirectives !== null) {
+      const start = allDirectiveDefs.length;
+      hostDirectiveDefs ??= /* @__PURE__ */ new Map();
+      hostDirectiveRanges ??= /* @__PURE__ */ new Map();
+      findHostDirectiveDefs(def, allDirectiveDefs, hostDirectiveDefs);
+      hostDirectiveRanges.set(def, [start, allDirectiveDefs.length - 1]);
+    }
+    if (i === 0 && isComponentDef(def)) {
+      hasComponent = true;
+      allDirectiveDefs.push(def);
+    }
+  }
+  for (let i = hasComponent ? 1 : 0; i < matches.length; i++) {
+    allDirectiveDefs.push(matches[i]);
+  }
+  return [allDirectiveDefs, hostDirectiveDefs, hostDirectiveRanges];
+}
+function findHostDirectiveDefs(currentDef, matchedDefs, hostDirectiveDefs) {
+  if (currentDef.hostDirectives !== null) {
+    for (const configOrFn of currentDef.hostDirectives) {
+      if (typeof configOrFn === "function") {
+        const resolved = configOrFn();
+        for (const config2 of resolved) {
+          trackHostDirectiveDef(createHostDirectiveDef(config2), matchedDefs, hostDirectiveDefs);
+        }
+      } else {
+        trackHostDirectiveDef(configOrFn, matchedDefs, hostDirectiveDefs);
+      }
+    }
+  }
+}
+function trackHostDirectiveDef(def, matchedDefs, hostDirectiveDefs) {
+  const hostDirectiveDef = getDirectiveDef(def.directive);
+  if (typeof ngDevMode === "undefined" || ngDevMode) {
+    validateHostDirective(def, hostDirectiveDef);
+  }
+  patchDeclaredInputs(hostDirectiveDef.declaredInputs, def.inputs);
+  findHostDirectiveDefs(hostDirectiveDef, matchedDefs, hostDirectiveDefs);
+  hostDirectiveDefs.set(hostDirectiveDef, def);
+  matchedDefs.push(hostDirectiveDef);
+}
+function createHostDirectiveDef(config2) {
+  return typeof config2 === "function" ? {
+    directive: resolveForwardRef(config2),
+    inputs: EMPTY_OBJ,
+    outputs: EMPTY_OBJ
+  } : {
+    directive: resolveForwardRef(config2.directive),
+    inputs: bindingArrayToMap(config2.inputs),
+    outputs: bindingArrayToMap(config2.outputs)
+  };
+}
+function bindingArrayToMap(bindings) {
+  if (bindings === void 0 || bindings.length === 0) {
+    return EMPTY_OBJ;
+  }
+  const result = {};
+  for (let i = 0; i < bindings.length; i += 2) {
+    result[bindings[i]] = bindings[i + 1];
+  }
+  return result;
+}
+function patchDeclaredInputs(declaredInputs, exposedInputs) {
+  for (const publicName in exposedInputs) {
+    if (exposedInputs.hasOwnProperty(publicName)) {
+      const remappedPublicName = exposedInputs[publicName];
+      const privateName = declaredInputs[publicName];
+      if ((typeof ngDevMode === "undefined" || ngDevMode) && declaredInputs.hasOwnProperty(remappedPublicName)) {
+        assertEqual(declaredInputs[remappedPublicName], declaredInputs[publicName], `Conflicting host directive input alias ${publicName}.`);
+      }
+      declaredInputs[remappedPublicName] = privateName;
+    }
+  }
+}
+function validateHostDirective(hostDirectiveConfig, directiveDef) {
+  const type = hostDirectiveConfig.directive;
+  if (directiveDef === null) {
+    if (getComponentDef(type) !== null) {
+      throw new RuntimeError(310, `Host directive ${type.name} cannot be a component.`);
+    }
+    throw new RuntimeError(307, `Could not resolve metadata for host directive ${type.name}. Make sure that the ${type.name} class is annotated with an @Directive decorator.`);
+  }
+  if (!directiveDef.standalone) {
+    throw new RuntimeError(308, `Host directive ${directiveDef.type.name} must be standalone.`);
+  }
+  validateMappings("input", directiveDef, hostDirectiveConfig.inputs);
+  validateMappings("output", directiveDef, hostDirectiveConfig.outputs);
+}
+function validateMappings(bindingType, def, hostDirectiveBindings) {
+  const className = def.type.name;
+  const bindings = bindingType === "input" ? def.inputs : def.outputs;
+  for (const publicName in hostDirectiveBindings) {
+    if (hostDirectiveBindings.hasOwnProperty(publicName)) {
+      if (!bindings.hasOwnProperty(publicName)) {
+        throw new RuntimeError(311, `Directive ${className} does not have an ${bindingType} with a public name of ${publicName}.`);
+      }
+      const remappedPublicName = hostDirectiveBindings[publicName];
+      if (bindings.hasOwnProperty(remappedPublicName) && remappedPublicName !== publicName) {
+        throw new RuntimeError(312, `Cannot alias ${bindingType} ${publicName} of host directive ${className} to ${remappedPublicName}, because it already has a different ${bindingType} with the same public name.`);
+      }
+    }
+  }
+}
+function getSuperType(type) {
+  return Object.getPrototypeOf(type.prototype).constructor;
+}
+function \u0275\u0275InheritDefinitionFeature(definition) {
+  let superType = getSuperType(definition.type);
+  let shouldInheritFields = true;
+  const inheritanceChain = [definition];
+  while (superType && superType !== Function.prototype && superType !== Object.prototype) {
+    let superDef = void 0;
+    const cmpDef = Object.hasOwn(superType, NG_COMP_DEF) ? superType[NG_COMP_DEF] : void 0;
+    const dirDef = Object.hasOwn(superType, NG_DIR_DEF) ? superType[NG_DIR_DEF] : void 0;
+    if (isComponentDef(definition)) {
+      superDef = cmpDef ?? dirDef;
+    } else {
+      if (cmpDef) {
+        throw new RuntimeError(903, ngDevMode && `Directives cannot inherit Components. Directive ${stringifyForError(definition.type)} is attempting to extend component ${stringifyForError(superType)}`);
+      }
+      superDef = dirDef;
+    }
+    if (superDef) {
+      if (shouldInheritFields) {
+        inheritanceChain.push(superDef);
+        const writeableDef = definition;
+        writeableDef.inputs = maybeUnwrapEmpty(definition.inputs);
+        writeableDef.declaredInputs = maybeUnwrapEmpty(definition.declaredInputs);
+        writeableDef.outputs = maybeUnwrapEmpty(definition.outputs);
+        const superHostBindings = superDef.hostBindings;
+        superHostBindings && inheritHostBindings(definition, superHostBindings);
+        const superViewQuery = superDef.viewQuery;
+        const superContentQueries = superDef.contentQueries;
+        superViewQuery && inheritViewQuery(definition, superViewQuery);
+        superContentQueries && inheritContentQueries(definition, superContentQueries);
+        mergeInputsWithTransforms(definition, superDef);
+        fillProperties(definition.outputs, superDef.outputs);
+        if (isComponentDef(superDef) && superDef.data.animation) {
+          const defData = definition.data;
+          defData.animation = (defData.animation || []).concat(superDef.data.animation);
+        }
+      }
+      const features = superDef.features;
+      if (features) {
+        for (let i = 0; i < features.length; i++) {
+          const feature = features[i];
+          if (feature && feature.ngInherit) {
+            feature(definition);
+          }
+          if (feature === \u0275\u0275InheritDefinitionFeature) {
+            shouldInheritFields = false;
+          }
+        }
+      }
+    }
+    superType = Object.getPrototypeOf(superType);
+  }
+  mergeHostAttrsAcrossInheritance(inheritanceChain);
+}
+function mergeInputsWithTransforms(target, source) {
+  for (const key in source.inputs) {
+    if (!source.inputs.hasOwnProperty(key)) {
+      continue;
+    }
+    if (target.inputs.hasOwnProperty(key)) {
+      continue;
+    }
+    const value = source.inputs[key];
+    if (value !== void 0) {
+      target.inputs[key] = value;
+      target.declaredInputs[key] = source.declaredInputs[key];
+    }
+  }
+}
+function mergeHostAttrsAcrossInheritance(inheritanceChain) {
+  let hostVars = 0;
+  let hostAttrs = null;
+  for (let i = inheritanceChain.length - 1; i >= 0; i--) {
+    const def = inheritanceChain[i];
+    def.hostVars = hostVars += def.hostVars;
+    def.hostAttrs = mergeHostAttrs(def.hostAttrs, hostAttrs = mergeHostAttrs(hostAttrs, def.hostAttrs));
+  }
+}
+function maybeUnwrapEmpty(value) {
+  if (value === EMPTY_OBJ) {
+    return {};
+  } else if (value === EMPTY_ARRAY) {
+    return [];
+  } else {
+    return value;
+  }
+}
+function inheritViewQuery(definition, superViewQuery) {
+  const prevViewQuery = definition.viewQuery;
+  if (prevViewQuery) {
+    definition.viewQuery = (rf, ctx) => {
+      superViewQuery(rf, ctx);
+      prevViewQuery(rf, ctx);
+    };
+  } else {
+    definition.viewQuery = superViewQuery;
+  }
+}
+function inheritContentQueries(definition, superContentQueries) {
+  const prevContentQueries = definition.contentQueries;
+  if (prevContentQueries) {
+    definition.contentQueries = (rf, ctx, directiveIndex) => {
+      superContentQueries(rf, ctx, directiveIndex);
+      prevContentQueries(rf, ctx, directiveIndex);
+    };
+  } else {
+    definition.contentQueries = superContentQueries;
+  }
+}
+function inheritHostBindings(definition, superHostBindings) {
+  const prevHostBindings = definition.hostBindings;
+  if (prevHostBindings) {
+    definition.hostBindings = (rf, ctx) => {
+      superHostBindings(rf, ctx);
+      prevHostBindings(rf, ctx);
+    };
+  } else {
+    definition.hostBindings = superHostBindings;
+  }
+}
+function templateCreate(tNode, declarationLView, declarationTView, index, templateFn, decls, vars, flags) {
+  if (declarationTView.firstCreatePass) {
+    tNode.mergedAttrs = mergeHostAttrs(tNode.mergedAttrs, tNode.attrs);
+    const embeddedTView = tNode.tView = createTView(2, tNode, templateFn, decls, vars, declarationTView.directiveRegistry, declarationTView.pipeRegistry, null, declarationTView.schemas, declarationTView.consts, null);
+    if (declarationTView.queries !== null) {
+      declarationTView.queries.template(declarationTView, tNode);
+      embeddedTView.queries = declarationTView.queries.embeddedTView(tNode);
+    }
+  }
+  if (flags) {
+    tNode.flags |= flags;
+  }
+  setCurrentTNode(tNode, false);
+  const comment = _locateOrCreateContainerAnchor(declarationTView, declarationLView, tNode, index);
+  if (wasLastNodeCreated()) {
+    appendChild(declarationTView, declarationLView, comment, tNode);
+  }
+  attachPatchData(comment, declarationLView);
+  const lContainer = createLContainer(comment, declarationLView, comment, tNode);
+  declarationLView[index + HEADER_OFFSET] = lContainer;
+  addToEndOfViewTree(declarationLView, lContainer);
+  populateDehydratedViewsInLContainer(lContainer, tNode, declarationLView);
+}
+function declareDirectiveHostTemplate(declarationLView, declarationTView, index, templateFn, decls, vars, tagName, attrs, flags, localRefsIndex, localRefExtractor) {
+  const adjustedIndex = index + HEADER_OFFSET;
+  let tNode;
+  if (declarationTView.firstCreatePass) {
+    tNode = getOrCreateTNode(declarationTView, adjustedIndex, 4, tagName || null, attrs || null);
+    if (getBindingsEnabled()) {
+      resolveDirectives(declarationTView, declarationLView, tNode, getConstant(declarationTView.consts, localRefsIndex), findDirectiveDefMatches);
+    }
+    registerPostOrderHooks(declarationTView, tNode);
+  } else {
+    tNode = declarationTView.data[adjustedIndex];
+  }
+  templateCreate(tNode, declarationLView, declarationTView, index, templateFn, decls, vars, flags);
+  if (isDirectiveHost(tNode)) {
+    createDirectivesInstances(declarationTView, declarationLView, tNode);
+  }
+  if (localRefsIndex != null) {
+    saveResolvedLocalsInData(declarationLView, tNode, localRefExtractor);
+  }
+  return tNode;
+}
+function declareNoDirectiveHostTemplate(declarationLView, declarationTView, index, templateFn, decls, vars, tagName, attrs, flags, localRefsIndex, localRefExtractor) {
+  const adjustedIndex = index + HEADER_OFFSET;
+  let tNode;
+  if (declarationTView.firstCreatePass) {
+    tNode = getOrCreateTNode(declarationTView, adjustedIndex, 4, tagName || null, attrs || null);
+    if (localRefsIndex != null) {
+      const refs = getConstant(declarationTView.consts, localRefsIndex);
+      tNode.localNames = [];
+      for (let i = 0; i < refs.length; i += 2) {
+        tNode.localNames.push(refs[i], -1);
+      }
+    }
+  } else {
+    tNode = declarationTView.data[adjustedIndex];
+  }
+  templateCreate(tNode, declarationLView, declarationTView, index, templateFn, decls, vars, flags);
+  if (localRefsIndex != null) {
+    saveResolvedLocalsInData(declarationLView, tNode, localRefExtractor);
+  }
+  return tNode;
+}
+function \u0275\u0275template(index, templateFn, decls, vars, tagName, attrsIndex, localRefsIndex, localRefExtractor) {
+  const lView = getLView();
+  const tView = getTView();
+  const attrs = getConstant(tView.consts, attrsIndex);
+  declareDirectiveHostTemplate(lView, tView, index, templateFn, decls, vars, tagName, attrs, void 0, localRefsIndex, localRefExtractor);
+  return \u0275\u0275template;
+}
+function \u0275\u0275domTemplate(index, templateFn, decls, vars, tagName, attrsIndex, localRefsIndex, localRefExtractor) {
+  const lView = getLView();
+  const tView = getTView();
+  const attrs = getConstant(tView.consts, attrsIndex);
+  declareNoDirectiveHostTemplate(lView, tView, index, templateFn, decls, vars, tagName, attrs, void 0, localRefsIndex, localRefExtractor);
+  return \u0275\u0275domTemplate;
+}
+var _locateOrCreateContainerAnchor = createContainerAnchorImpl;
+function createContainerAnchorImpl(tView, lView, tNode, index) {
+  lastNodeWasCreated(true);
+  return lView[RENDERER].createComment(ngDevMode ? "container" : "");
+}
+var DeferDependenciesLoadingState;
+(function(DeferDependenciesLoadingState2) {
+  DeferDependenciesLoadingState2[DeferDependenciesLoadingState2["NOT_STARTED"] = 0] = "NOT_STARTED";
+  DeferDependenciesLoadingState2[DeferDependenciesLoadingState2["IN_PROGRESS"] = 1] = "IN_PROGRESS";
+  DeferDependenciesLoadingState2[DeferDependenciesLoadingState2["COMPLETE"] = 2] = "COMPLETE";
+  DeferDependenciesLoadingState2[DeferDependenciesLoadingState2["FAILED"] = 3] = "FAILED";
+})(DeferDependenciesLoadingState || (DeferDependenciesLoadingState = {}));
+var MINIMUM_SLOT = 0;
+var LOADING_AFTER_SLOT = 1;
+var DeferBlockState;
+(function(DeferBlockState2) {
+  DeferBlockState2[DeferBlockState2["Placeholder"] = 0] = "Placeholder";
+  DeferBlockState2[DeferBlockState2["Loading"] = 1] = "Loading";
+  DeferBlockState2[DeferBlockState2["Complete"] = 2] = "Complete";
+  DeferBlockState2[DeferBlockState2["Error"] = 3] = "Error";
+})(DeferBlockState || (DeferBlockState = {}));
+var DeferBlockInternalState;
+(function(DeferBlockInternalState2) {
+  DeferBlockInternalState2[DeferBlockInternalState2["Initial"] = -1] = "Initial";
+})(DeferBlockInternalState || (DeferBlockInternalState = {}));
+var NEXT_DEFER_BLOCK_STATE = 0;
+var DEFER_BLOCK_STATE = 1;
+var STATE_IS_FROZEN_UNTIL = 2;
+var LOADING_AFTER_CLEANUP_FN = 3;
+var TRIGGER_CLEANUP_FNS = 4;
+var PREFETCH_TRIGGER_CLEANUP_FNS = 5;
+var SSR_UNIQUE_ID = 6;
+var SSR_BLOCK_STATE = 7;
+var ON_COMPLETE_FNS = 8;
+var HYDRATE_TRIGGER_CLEANUP_FNS = 9;
+var DeferBlockBehavior;
+(function(DeferBlockBehavior2) {
+  DeferBlockBehavior2[DeferBlockBehavior2["Manual"] = 0] = "Manual";
+  DeferBlockBehavior2[DeferBlockBehavior2["Playthrough"] = 1] = "Playthrough";
+})(DeferBlockBehavior || (DeferBlockBehavior = {}));
+function storeTriggerCleanupFn(type, lDetails, cleanupFn) {
+  const key = getCleanupFnKeyByType(type);
+  if (lDetails[key] === null) {
+    lDetails[key] = [];
+  }
+  lDetails[key].push(cleanupFn);
+}
+function invokeTriggerCleanupFns(type, lDetails) {
+  const key = getCleanupFnKeyByType(type);
+  const cleanupFns = lDetails[key];
+  if (cleanupFns !== null) {
+    for (const cleanupFn of cleanupFns) {
+      cleanupFn();
+    }
+    lDetails[key] = null;
+  }
+}
+function invokeAllTriggerCleanupFns(lDetails) {
+  invokeTriggerCleanupFns(1, lDetails);
+  invokeTriggerCleanupFns(0, lDetails);
+  invokeTriggerCleanupFns(2, lDetails);
+}
+function getCleanupFnKeyByType(type) {
+  let key = TRIGGER_CLEANUP_FNS;
+  if (type === 1) {
+    key = PREFETCH_TRIGGER_CLEANUP_FNS;
+  } else if (type === 2) {
+    key = HYDRATE_TRIGGER_CLEANUP_FNS;
+  }
+  return key;
+}
+function getDeferBlockDataIndex(deferBlockIndex) {
+  return deferBlockIndex + 1;
+}
+function getLDeferBlockDetails(lView, tNode) {
+  const tView = lView[TVIEW];
+  const slotIndex = getDeferBlockDataIndex(tNode.index);
+  ngDevMode && assertIndexInDeclRange(tView, slotIndex);
+  return lView[slotIndex];
+}
+function setLDeferBlockDetails(lView, deferBlockIndex, lDetails) {
+  const tView = lView[TVIEW];
+  const slotIndex = getDeferBlockDataIndex(deferBlockIndex);
+  ngDevMode && assertIndexInDeclRange(tView, slotIndex);
+  lView[slotIndex] = lDetails;
+}
+function getTDeferBlockDetails(tView, tNode) {
+  const slotIndex = getDeferBlockDataIndex(tNode.index);
+  ngDevMode && assertIndexInDeclRange(tView, slotIndex);
+  return tView.data[slotIndex];
+}
+function setTDeferBlockDetails(tView, deferBlockIndex, deferBlockConfig) {
+  const slotIndex = getDeferBlockDataIndex(deferBlockIndex);
+  ngDevMode && assertIndexInDeclRange(tView, slotIndex);
+  tView.data[slotIndex] = deferBlockConfig;
+}
+function getTemplateIndexForState(newState, hostLView, tNode) {
+  const tView = hostLView[TVIEW];
+  const tDetails = getTDeferBlockDetails(tView, tNode);
+  switch (newState) {
+    case DeferBlockState.Complete:
+      return tDetails.primaryTmplIndex;
+    case DeferBlockState.Loading:
+      return tDetails.loadingTmplIndex;
+    case DeferBlockState.Error:
+      return tDetails.errorTmplIndex;
+    case DeferBlockState.Placeholder:
+      return tDetails.placeholderTmplIndex;
+    default:
+      ngDevMode && throwError2(`Unexpected defer block state: ${newState}`);
+      return null;
+  }
+}
+function getMinimumDurationForState(tDetails, currentState) {
+  if (currentState === DeferBlockState.Placeholder) {
+    return tDetails.placeholderBlockConfig?.[MINIMUM_SLOT] ?? null;
+  } else if (currentState === DeferBlockState.Loading) {
+    return tDetails.loadingBlockConfig?.[MINIMUM_SLOT] ?? null;
+  }
+  return null;
+}
+function getLoadingBlockAfter(tDetails) {
+  return tDetails.loadingBlockConfig?.[LOADING_AFTER_SLOT] ?? null;
+}
+function addDepsToRegistry(currentDeps, newDeps) {
+  if (!currentDeps || currentDeps.length === 0) {
+    return newDeps;
+  }
+  const currentDepSet = new Set(currentDeps);
+  for (const dep of newDeps) {
+    currentDepSet.add(dep);
+  }
+  return currentDeps.length === currentDepSet.size ? currentDeps : Array.from(currentDepSet);
+}
+function getPrimaryBlockTNode(tView, tDetails) {
+  const adjustedIndex = tDetails.primaryTmplIndex + HEADER_OFFSET;
+  return getTNode(tView, adjustedIndex);
+}
+function assertDeferredDependenciesLoaded(tDetails) {
+  assertEqual(tDetails.loadingState, DeferDependenciesLoadingState.COMPLETE, "Expecting all deferred dependencies to be loaded.");
+}
+function isTDeferBlockDetails(value) {
+  return value !== null && typeof value === "object" && typeof value.primaryTmplIndex === "number";
+}
+function trackTriggerForDebugging(tView, tNode, textRepresentation) {
+  const tDetails = getTDeferBlockDetails(tView, tNode);
+  tDetails.debug ??= {};
+  tDetails.debug.triggers ??= /* @__PURE__ */ new Set();
+  tDetails.debug.triggers.add(textRepresentation);
+}
+function onViewportWrapper(trigger, callback, injector, wrapperOptions) {
+  const ngZone = injector.get(NgZone);
+  return onViewport(trigger, () => ngZone.run(callback), (options) => ngZone.runOutsideAngular(() => createIntersectionObserver(options)), wrapperOptions);
+}
+function getTriggerLView(deferredHostLView, deferredTNode, walkUpTimes) {
+  if (walkUpTimes == null) {
+    return deferredHostLView;
+  }
+  if (walkUpTimes >= 0) {
+    return walkUpViews(walkUpTimes, deferredHostLView);
+  }
+  const deferredContainer = deferredHostLView[deferredTNode.index];
+  ngDevMode && assertLContainer(deferredContainer);
+  const triggerLView = deferredContainer[CONTAINER_HEADER_OFFSET] ?? null;
+  if (ngDevMode && triggerLView !== null) {
+    const lDetails = getLDeferBlockDetails(deferredHostLView, deferredTNode);
+    const renderedState = lDetails[DEFER_BLOCK_STATE];
+    assertEqual(renderedState, DeferBlockState.Placeholder, "Expected a placeholder to be rendered in this defer block.");
+    assertLView(triggerLView);
+  }
+  return triggerLView;
+}
+function getTriggerElement(triggerLView, triggerIndex) {
+  const element = getNativeByIndex(HEADER_OFFSET + triggerIndex, triggerLView);
+  ngDevMode && assertElement(element);
+  return element;
+}
+function registerDomTrigger(initialLView, tNode, triggerIndex, walkUpTimes, registerFn, callback, type, options) {
+  const injector = initialLView[INJECTOR];
+  const zone = injector.get(NgZone);
+  let poll;
+  function pollDomTrigger() {
+    if (isDestroyed(initialLView)) {
+      poll.destroy();
+      return;
+    }
+    const lDetails = getLDeferBlockDetails(initialLView, tNode);
+    const renderedState = lDetails[DEFER_BLOCK_STATE];
+    if (renderedState !== DeferBlockInternalState.Initial && renderedState !== DeferBlockState.Placeholder) {
+      poll.destroy();
+      return;
+    }
+    const triggerLView = getTriggerLView(initialLView, tNode, walkUpTimes);
+    if (!triggerLView) {
+      return;
+    }
+    poll.destroy();
+    if (isDestroyed(triggerLView)) {
+      return;
+    }
+    const element = getTriggerElement(triggerLView, triggerIndex);
+    const cleanup = registerFn(element, () => {
+      zone.run(() => {
+        if (initialLView !== triggerLView) {
+          removeLViewOnDestroy(triggerLView, cleanup);
+        }
+        callback();
+      });
+    }, injector, options);
+    if (initialLView !== triggerLView) {
+      storeLViewOnDestroy(triggerLView, cleanup);
+    }
+    storeTriggerCleanupFn(type, lDetails, cleanup);
+  }
+  poll = afterEveryRender({
+    read: pollDomTrigger
+  }, {
+    injector
+  });
+}
+function onIdle(callback, injector) {
+  const scheduler = injector.get(IdleScheduler);
+  const cleanupFn = () => scheduler.remove(callback);
+  scheduler.add(callback);
+  return cleanupFn;
+}
+var _requestIdleCallback = () => typeof requestIdleCallback !== "undefined" ? requestIdleCallback : setTimeout;
+var _cancelIdleCallback = () => typeof requestIdleCallback !== "undefined" ? cancelIdleCallback : clearTimeout;
+var IdleScheduler = class _IdleScheduler {
+  executingCallbacks = false;
+  idleId = null;
+  current = /* @__PURE__ */ new Set();
+  deferred = /* @__PURE__ */ new Set();
+  ngZone = inject2(NgZone);
+  requestIdleCallbackFn = _requestIdleCallback().bind(globalThis);
+  cancelIdleCallbackFn = _cancelIdleCallback().bind(globalThis);
+  add(callback) {
+    const target = this.executingCallbacks ? this.deferred : this.current;
+    target.add(callback);
+    if (this.idleId === null) {
+      this.scheduleIdleCallback();
+    }
+  }
+  remove(callback) {
+    const {
+      current,
+      deferred
+    } = this;
+    current.delete(callback);
+    deferred.delete(callback);
+    if (current.size === 0 && deferred.size === 0) {
+      this.cancelIdleCallback();
+    }
+  }
+  scheduleIdleCallback() {
+    const callback = () => {
+      this.cancelIdleCallback();
+      this.executingCallbacks = true;
+      for (const callback2 of this.current) {
+        callback2();
+      }
+      this.current.clear();
+      this.executingCallbacks = false;
+      if (this.deferred.size > 0) {
+        for (const callback2 of this.deferred) {
+          this.current.add(callback2);
+        }
+        this.deferred.clear();
+        this.scheduleIdleCallback();
+      }
+    };
+    this.idleId = this.requestIdleCallbackFn(() => this.ngZone.run(callback));
+  }
+  cancelIdleCallback() {
+    if (this.idleId !== null) {
+      this.cancelIdleCallbackFn(this.idleId);
+      this.idleId = null;
+    }
+  }
+  ngOnDestroy() {
+    this.cancelIdleCallback();
+    this.current.clear();
+    this.deferred.clear();
+  }
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _IdleScheduler,
+    providedIn: "root",
+    factory: () => new _IdleScheduler()
+  });
+};
+function onTimer(delay) {
+  return (callback, injector) => scheduleTimerTrigger(delay, callback, injector);
+}
+function scheduleTimerTrigger(delay, callback, injector) {
+  const scheduler = injector.get(TimerScheduler);
+  const ngZone = injector.get(NgZone);
+  const cleanupFn = () => scheduler.remove(callback);
+  scheduler.add(delay, callback, ngZone);
+  return cleanupFn;
+}
+var TimerScheduler = class _TimerScheduler {
+  executingCallbacks = false;
+  timeoutId = null;
+  invokeTimerAt = null;
+  current = [];
+  deferred = [];
+  add(delay, callback, ngZone) {
+    const target = this.executingCallbacks ? this.deferred : this.current;
+    this.addToQueue(target, Date.now() + delay, callback);
+    this.scheduleTimer(ngZone);
+  }
+  remove(callback) {
+    const {
+      current,
+      deferred
+    } = this;
+    const callbackIndex = this.removeFromQueue(current, callback);
+    if (callbackIndex === -1) {
+      this.removeFromQueue(deferred, callback);
+    }
+    if (current.length === 0 && deferred.length === 0) {
+      this.clearTimeout();
+    }
+  }
+  addToQueue(target, invokeAt, callback) {
+    let insertAtIndex = target.length;
+    for (let i = 0; i < target.length; i += 2) {
+      const invokeQueuedCallbackAt = target[i];
+      if (invokeQueuedCallbackAt > invokeAt) {
+        insertAtIndex = i;
+        break;
+      }
+    }
+    arrayInsert2(target, insertAtIndex, invokeAt, callback);
+  }
+  removeFromQueue(target, callback) {
+    let index = -1;
+    for (let i = 0; i < target.length; i += 2) {
+      const queuedCallback = target[i + 1];
+      if (queuedCallback === callback) {
+        index = i;
+        break;
+      }
+    }
+    if (index > -1) {
+      arraySplice(target, index, 2);
+    }
+    return index;
+  }
+  scheduleTimer(ngZone) {
+    const callback = () => {
+      this.clearTimeout();
+      this.executingCallbacks = true;
+      const current = [...this.current];
+      const now = Date.now();
+      for (let i = 0; i < current.length; i += 2) {
+        const invokeAt = current[i];
+        const callback2 = current[i + 1];
+        if (invokeAt <= now) {
+          callback2();
+        } else {
+          break;
+        }
+      }
+      let lastCallbackIndex = -1;
+      for (let i = 0; i < this.current.length; i += 2) {
+        const invokeAt = this.current[i];
+        if (invokeAt <= now) {
+          lastCallbackIndex = i + 1;
+        } else {
+          break;
+        }
+      }
+      if (lastCallbackIndex >= 0) {
+        arraySplice(this.current, 0, lastCallbackIndex + 1);
+      }
+      this.executingCallbacks = false;
+      if (this.deferred.length > 0) {
+        for (let i = 0; i < this.deferred.length; i += 2) {
+          const invokeAt = this.deferred[i];
+          const callback2 = this.deferred[i + 1];
+          this.addToQueue(this.current, invokeAt, callback2);
+        }
+        this.deferred.length = 0;
+      }
+      this.scheduleTimer(ngZone);
+    };
+    const FRAME_DURATION_MS = 16;
+    if (this.current.length > 0) {
+      const now = Date.now();
+      const invokeAt = this.current[0];
+      if (this.timeoutId === null || this.invokeTimerAt && this.invokeTimerAt - invokeAt > FRAME_DURATION_MS) {
+        this.clearTimeout();
+        const timeout2 = Math.max(invokeAt - now, FRAME_DURATION_MS);
+        this.invokeTimerAt = invokeAt;
+        this.timeoutId = ngZone.runOutsideAngular(() => {
+          return setTimeout(() => ngZone.run(callback), timeout2);
+        });
+      }
+    }
+  }
+  clearTimeout() {
+    if (this.timeoutId !== null) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = null;
+    }
+  }
+  ngOnDestroy() {
+    this.clearTimeout();
+    this.current.length = 0;
+    this.deferred.length = 0;
+  }
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _TimerScheduler,
+    providedIn: "root",
+    factory: () => new _TimerScheduler()
+  });
+};
+var CachedInjectorService = class _CachedInjectorService {
+  cachedInjectors = /* @__PURE__ */ new Map();
+  getOrCreateInjector(key, parentInjector, providers, debugName) {
+    if (!this.cachedInjectors.has(key)) {
+      const injector = providers.length > 0 ? createEnvironmentInjector(providers, parentInjector, debugName) : null;
+      this.cachedInjectors.set(key, injector);
+    }
+    return this.cachedInjectors.get(key);
+  }
+  ngOnDestroy() {
+    try {
+      for (const injector of this.cachedInjectors.values()) {
+        if (injector !== null) {
+          injector.destroy();
+        }
+      }
+    } finally {
+      this.cachedInjectors.clear();
+    }
+  }
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _CachedInjectorService,
+    providedIn: "environment",
+    factory: () => new _CachedInjectorService()
+  });
+};
+var DEFER_BLOCK_DEPENDENCY_INTERCEPTOR = /* @__PURE__ */ new InjectionToken("DEFER_BLOCK_DEPENDENCY_INTERCEPTOR");
+var DEFER_BLOCK_CONFIG = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "DEFER_BLOCK_CONFIG" : "");
+function getOrCreateEnvironmentInjector(parentInjector, tDetails, providers) {
+  return parentInjector.get(CachedInjectorService).getOrCreateInjector(tDetails, parentInjector, providers, ngDevMode ? "DeferBlock Injector" : "");
+}
+function createDeferBlockInjector(parentInjector, tDetails, providers) {
+  if (parentInjector instanceof ChainedInjector) {
+    const origInjector = parentInjector.injector;
+    const parentEnvInjector2 = parentInjector.parentInjector;
+    const envInjector = getOrCreateEnvironmentInjector(parentEnvInjector2, tDetails, providers);
+    return new ChainedInjector(origInjector, envInjector);
+  }
+  const parentEnvInjector = parentInjector.get(EnvironmentInjector);
+  if (parentEnvInjector !== parentInjector) {
+    const envInjector = getOrCreateEnvironmentInjector(parentEnvInjector, tDetails, providers);
+    return new ChainedInjector(parentInjector, envInjector);
+  }
+  return getOrCreateEnvironmentInjector(parentInjector, tDetails, providers);
+}
+function renderDeferBlockState(newState, tNode, lContainer, skipTimerScheduling = false) {
+  const hostLView = lContainer[PARENT];
+  const hostTView = hostLView[TVIEW];
+  if (isDestroyed(hostLView)) return;
+  ngDevMode && assertTNodeForLView(tNode, hostLView);
+  const lDetails = getLDeferBlockDetails(hostLView, tNode);
+  ngDevMode && assertDefined(lDetails, "Expected a defer block state defined");
+  const currentState = lDetails[DEFER_BLOCK_STATE];
+  const ssrState = lDetails[SSR_BLOCK_STATE];
+  if (ssrState !== null && newState < ssrState) {
+    return;
+  }
+  if (isValidStateChange(currentState, newState) && isValidStateChange(lDetails[NEXT_DEFER_BLOCK_STATE] ?? -1, newState)) {
+    const tDetails = getTDeferBlockDetails(hostTView, tNode);
+    const needsScheduling = !skipTimerScheduling && true && (getLoadingBlockAfter(tDetails) !== null || getMinimumDurationForState(tDetails, DeferBlockState.Loading) !== null || getMinimumDurationForState(tDetails, DeferBlockState.Placeholder));
+    if (ngDevMode && needsScheduling) {
+      assertDefined(applyDeferBlockStateWithSchedulingImpl, "Expected scheduling function to be defined");
+    }
+    const applyStateFn = needsScheduling ? applyDeferBlockStateWithSchedulingImpl : applyDeferBlockState;
+    try {
+      applyStateFn(newState, lDetails, lContainer, tNode, hostLView);
+    } catch (error) {
+      handleUncaughtError(hostLView, error);
+    }
+  }
+}
+function findMatchingDehydratedViewForDeferBlock(lContainer, lDetails) {
+  const dehydratedViewIx = lContainer[DEHYDRATED_VIEWS]?.findIndex((view) => view.data[DEFER_BLOCK_STATE$1] === lDetails[DEFER_BLOCK_STATE]) ?? -1;
+  const dehydratedView = dehydratedViewIx > -1 ? lContainer[DEHYDRATED_VIEWS][dehydratedViewIx] : null;
+  return {
+    dehydratedView,
+    dehydratedViewIx
+  };
+}
+function applyDeferBlockState(newState, lDetails, lContainer, tNode, hostLView) {
+  profiler(ProfilerEvent.DeferBlockStateStart);
+  const stateTmplIndex = getTemplateIndexForState(newState, hostLView, tNode);
+  if (stateTmplIndex !== null) {
+    lDetails[DEFER_BLOCK_STATE] = newState;
+    const hostTView = hostLView[TVIEW];
+    const adjustedIndex = stateTmplIndex + HEADER_OFFSET;
+    const activeBlockTNode = getTNode(hostTView, adjustedIndex);
+    const viewIndex = 0;
+    removeLViewFromLContainer(lContainer, viewIndex);
+    let injector;
+    if (newState === DeferBlockState.Complete) {
+      const tDetails = getTDeferBlockDetails(hostTView, tNode);
+      const providers = tDetails.providers;
+      if (providers && providers.length > 0) {
+        injector = createDeferBlockInjector(hostLView[INJECTOR], tDetails, providers);
+      }
+    }
+    const {
+      dehydratedView,
+      dehydratedViewIx
+    } = findMatchingDehydratedViewForDeferBlock(lContainer, lDetails);
+    const embeddedLView = createAndRenderEmbeddedLView(hostLView, activeBlockTNode, null, {
+      injector,
+      dehydratedView
+    });
+    addLViewToLContainer(lContainer, embeddedLView, viewIndex, shouldAddViewToDom(activeBlockTNode, dehydratedView));
+    markViewDirty(embeddedLView, 2);
+    if (dehydratedViewIx > -1) {
+      lContainer[DEHYDRATED_VIEWS]?.splice(dehydratedViewIx, 1);
+    }
+    if ((newState === DeferBlockState.Complete || newState === DeferBlockState.Error) && Array.isArray(lDetails[ON_COMPLETE_FNS])) {
+      for (const callback of lDetails[ON_COMPLETE_FNS]) {
+        callback();
+      }
+      lDetails[ON_COMPLETE_FNS] = null;
+    }
+  }
+  profiler(ProfilerEvent.DeferBlockStateEnd);
+}
+function applyDeferBlockStateWithScheduling(newState, lDetails, lContainer, tNode, hostLView) {
+  const now = Date.now();
+  const hostTView = hostLView[TVIEW];
+  const tDetails = getTDeferBlockDetails(hostTView, tNode);
+  if (lDetails[STATE_IS_FROZEN_UNTIL] === null || lDetails[STATE_IS_FROZEN_UNTIL] <= now) {
+    lDetails[STATE_IS_FROZEN_UNTIL] = null;
+    const loadingAfter = getLoadingBlockAfter(tDetails);
+    const inLoadingAfterPhase = lDetails[LOADING_AFTER_CLEANUP_FN] !== null;
+    if (newState === DeferBlockState.Loading && loadingAfter !== null && !inLoadingAfterPhase) {
+      lDetails[NEXT_DEFER_BLOCK_STATE] = newState;
+      const cleanupFn = scheduleDeferBlockUpdate(loadingAfter, lDetails, tNode, lContainer, hostLView);
+      lDetails[LOADING_AFTER_CLEANUP_FN] = cleanupFn;
+    } else {
+      if (newState > DeferBlockState.Loading && inLoadingAfterPhase) {
+        lDetails[LOADING_AFTER_CLEANUP_FN]();
+        lDetails[LOADING_AFTER_CLEANUP_FN] = null;
+        lDetails[NEXT_DEFER_BLOCK_STATE] = null;
+      }
+      applyDeferBlockState(newState, lDetails, lContainer, tNode, hostLView);
+      const duration = getMinimumDurationForState(tDetails, newState);
+      if (duration !== null) {
+        lDetails[STATE_IS_FROZEN_UNTIL] = now + duration;
+        scheduleDeferBlockUpdate(duration, lDetails, tNode, lContainer, hostLView);
+      }
+    }
+  } else {
+    lDetails[NEXT_DEFER_BLOCK_STATE] = newState;
+  }
+}
+function scheduleDeferBlockUpdate(timeout2, lDetails, tNode, lContainer, hostLView) {
+  const callback = () => {
+    const nextState = lDetails[NEXT_DEFER_BLOCK_STATE];
+    lDetails[STATE_IS_FROZEN_UNTIL] = null;
+    lDetails[NEXT_DEFER_BLOCK_STATE] = null;
+    if (nextState !== null) {
+      renderDeferBlockState(nextState, tNode, lContainer);
+    }
+  };
+  return scheduleTimerTrigger(timeout2, callback, hostLView[INJECTOR]);
+}
+function isValidStateChange(currentState, newState) {
+  return currentState < newState;
+}
+function renderPlaceholder(lView, tNode) {
+  const lContainer = lView[tNode.index];
+  ngDevMode && assertLContainer(lContainer);
+  renderDeferBlockState(DeferBlockState.Placeholder, tNode, lContainer);
+}
+function renderDeferStateAfterResourceLoading(tDetails, tNode, lContainer) {
+  ngDevMode && assertDefined(tDetails.loadingPromise, "Expected loading Promise to exist on this defer block");
+  tDetails.loadingPromise.then(() => {
+    if (tDetails.loadingState === DeferDependenciesLoadingState.COMPLETE) {
+      ngDevMode && assertDeferredDependenciesLoaded(tDetails);
+      renderDeferBlockState(DeferBlockState.Complete, tNode, lContainer);
+    } else if (tDetails.loadingState === DeferDependenciesLoadingState.FAILED) {
+      renderDeferBlockState(DeferBlockState.Error, tNode, lContainer);
+    }
+  });
+}
+var applyDeferBlockStateWithSchedulingImpl = null;
+function \u0275\u0275deferEnableTimerScheduling(tView, tDetails, placeholderConfigIndex, loadingConfigIndex) {
+  const tViewConsts = tView.consts;
+  if (placeholderConfigIndex != null) {
+    tDetails.placeholderBlockConfig = getConstant(tViewConsts, placeholderConfigIndex);
+  }
+  if (loadingConfigIndex != null) {
+    tDetails.loadingBlockConfig = getConstant(tViewConsts, loadingConfigIndex);
+  }
+  if (applyDeferBlockStateWithSchedulingImpl === null) {
+    applyDeferBlockStateWithSchedulingImpl = applyDeferBlockStateWithScheduling;
+  }
+}
+function setClassMetadata(type, decorators, ctorParameters, propDecorators) {
+  return noSideEffects(() => {
+    const clazz = type;
+    if (decorators !== null) {
+      if (clazz.hasOwnProperty("decorators") && clazz.decorators !== void 0) {
+        clazz.decorators.push(...decorators);
+      } else {
+        clazz.decorators = decorators;
+      }
+    }
+    if (ctorParameters !== null) {
+      clazz.ctorParameters = ctorParameters;
+    }
+    if (propDecorators !== null) {
+      if (clazz.hasOwnProperty("propDecorators") && clazz.propDecorators !== void 0) {
+        clazz.propDecorators = __spreadValues(__spreadValues({}, clazz.propDecorators), propDecorators);
+      } else {
+        clazz.propDecorators = propDecorators;
+      }
+    }
+  });
+}
+var Console = class _Console {
+  log(message) {
+    console.log(message);
+  }
+  warn(message) {
+    console.warn(message);
+  }
+  static \u0275fac = function Console_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _Console)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _Console,
+    factory: _Console.\u0275fac,
+    providedIn: "platform"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(Console, [{
+    type: Injectable,
+    args: [{
+      providedIn: "platform"
+    }]
+  }], null, null);
+})();
+var DIDebugData = class {
+  resolverToTokenToDependencies = /* @__PURE__ */ new WeakMap();
+  resolverToProviders = /* @__PURE__ */ new WeakMap();
+  resolverToEffects = /* @__PURE__ */ new WeakMap();
+  standaloneInjectorToComponent = /* @__PURE__ */ new WeakMap();
+  reset() {
+    this.resolverToTokenToDependencies = /* @__PURE__ */ new WeakMap();
+    this.resolverToProviders = /* @__PURE__ */ new WeakMap();
+    this.standaloneInjectorToComponent = /* @__PURE__ */ new WeakMap();
+  }
+};
+var frameworkDIDebugData = new DIDebugData();
+function getFrameworkDIDebugData() {
+  return frameworkDIDebugData;
+}
+function setupFrameworkInjectorProfiler() {
+  frameworkDIDebugData.reset();
+  setInjectorProfiler(injectorProfilerEventHandler);
+}
+function injectorProfilerEventHandler(injectorProfilerEvent) {
+  const {
+    context: context2,
+    type
+  } = injectorProfilerEvent;
+  if (type === 0) {
+    handleInjectEvent(context2, injectorProfilerEvent.service);
+  } else if (type === 1) {
+    handleInstanceCreatedByInjectorEvent(context2, injectorProfilerEvent.instance);
+  } else if (type === 2) {
+    handleProviderConfiguredEvent(context2, injectorProfilerEvent.providerRecord);
+  } else if (type === 3) {
+    handleEffectCreatedEvent(context2, injectorProfilerEvent.effect);
+  } else if (type === 4) {
+    handleEffectCreatedEvent(context2, injectorProfilerEvent.effectPhase);
+  }
+}
+function handleEffectCreatedEvent(context2, effect2) {
+  const diResolver = getDIResolver(context2.injector);
+  if (diResolver === null) {
+    throwError2("An EffectCreated event must be run within an injection context.");
+  }
+  const {
+    resolverToEffects
+  } = frameworkDIDebugData;
+  const cleanupContainer = effect2 instanceof EffectRefImpl ? effect2[SIGNAL] : effect2.sequence;
+  let trackedEffects = resolverToEffects.get(diResolver);
+  if (!trackedEffects) {
+    trackedEffects = [];
+    resolverToEffects.set(diResolver, trackedEffects);
+  }
+  trackedEffects.push(effect2);
+  cleanupContainer.onDestroyFns ??= [];
+  cleanupContainer.onDestroyFns.push(() => {
+    const index = trackedEffects.indexOf(effect2);
+    if (index > -1) {
+      trackedEffects.splice(index, 1);
+    }
+  });
+}
+function handleInjectEvent(context2, data) {
+  const diResolver = getDIResolver(context2.injector);
+  if (diResolver === null) {
+    throwError2("An Inject event must be run within an injection context.");
+  }
+  const diResolverToInstantiatedToken = frameworkDIDebugData.resolverToTokenToDependencies;
+  if (!diResolverToInstantiatedToken.has(diResolver)) {
+    diResolverToInstantiatedToken.set(diResolver, /* @__PURE__ */ new WeakMap());
+  }
+  if (!canBeHeldWeakly(context2.token)) {
+    return;
+  }
+  const instantiatedTokenToDependencies = diResolverToInstantiatedToken.get(diResolver);
+  if (!instantiatedTokenToDependencies.has(context2.token)) {
+    instantiatedTokenToDependencies.set(context2.token, []);
+  }
+  const {
+    token,
+    value,
+    flags
+  } = data;
+  assertDefined(context2.token, "Injector profiler context token is undefined.");
+  const dependencies = instantiatedTokenToDependencies.get(context2.token);
+  assertDefined(dependencies, "Could not resolve dependencies for token.");
+  if (context2.injector instanceof NodeInjector) {
+    dependencies.push({
+      token,
+      value,
+      flags,
+      injectedIn: getNodeInjectorContext(context2.injector)
+    });
+  } else {
+    dependencies.push({
+      token,
+      value,
+      flags
+    });
+  }
+}
+function getNodeInjectorContext(injector) {
+  if (!(injector instanceof NodeInjector)) {
+    throwError2("getNodeInjectorContext must be called with a NodeInjector");
+  }
+  const lView = getNodeInjectorLView(injector);
+  const tNode = getNodeInjectorTNode(injector);
+  if (tNode === null) {
+    return;
+  }
+  assertTNodeForLView(tNode, lView);
+  return {
+    lView,
+    tNode
+  };
+}
+function handleInstanceCreatedByInjectorEvent(context2, data) {
+  const {
+    value
+  } = data;
+  if (data.value == null) {
+    return;
+  }
+  if (getDIResolver(context2.injector) === null) {
+    throwError2("An InjectorCreatedInstance event must be run within an injection context.");
+  }
+  let standaloneComponent = void 0;
+  if (typeof value === "object") {
+    standaloneComponent = value?.constructor;
+  }
+  if (standaloneComponent == void 0 || !isStandaloneComponent(standaloneComponent)) {
+    return;
+  }
+  const environmentInjector = context2.injector.get(EnvironmentInjector, null, {
+    optional: true
+  });
+  if (environmentInjector === null) {
+    return;
+  }
+  const {
+    standaloneInjectorToComponent
+  } = frameworkDIDebugData;
+  if (standaloneInjectorToComponent.has(environmentInjector)) {
+    return;
+  }
+  standaloneInjectorToComponent.set(environmentInjector, standaloneComponent);
+}
+function isStandaloneComponent(value) {
+  const def = getComponentDef(value);
+  return !!def?.standalone;
+}
+function handleProviderConfiguredEvent(context2, data) {
+  const {
+    resolverToProviders
+  } = frameworkDIDebugData;
+  let diResolver;
+  if (context2?.injector instanceof NodeInjector) {
+    diResolver = getNodeInjectorTNode(context2.injector);
+  } else {
+    diResolver = context2.injector;
+  }
+  if (diResolver === null) {
+    throwError2("A ProviderConfigured event must be run within an injection context.");
+  }
+  if (!resolverToProviders.has(diResolver)) {
+    resolverToProviders.set(diResolver, []);
+  }
+  resolverToProviders.get(diResolver).push(data);
+}
+function getDIResolver(injector) {
+  let diResolver = null;
+  if (injector === void 0) {
+    return diResolver;
+  }
+  if (injector instanceof NodeInjector) {
+    diResolver = getNodeInjectorLView(injector);
+  } else {
+    diResolver = injector;
+  }
+  return diResolver;
+}
+function canBeHeldWeakly(value) {
+  return value !== null && (typeof value === "object" || typeof value === "function" || typeof value === "symbol");
+}
+function isSignal2(value) {
+  return typeof value === "function" && value[SIGNAL] !== void 0;
+}
+function isWritableSignal(value) {
+  return isSignal2(value) && typeof value.set === "function";
+}
+function applyChanges(component) {
+  ngDevMode && assertDefined(component, "component");
+  markViewDirty(getComponentViewByInstance(component), 3);
+  getRootComponents(component).forEach((rootComponent) => detectChanges(rootComponent));
+}
+function detectChanges(component) {
+  const view = getComponentViewByInstance(component);
+  view[FLAGS] |= 1024;
+  detectChangesInternal(view);
+}
+function getDeferBlocks$1(lView, deferBlocks) {
+  const tView = lView[TVIEW];
+  for (let i = HEADER_OFFSET; i < tView.bindingStartIndex; i++) {
+    if (isLContainer(lView[i])) {
+      const lContainer = lView[i];
+      const isLast = i === tView.bindingStartIndex - 1;
+      if (!isLast) {
+        const tNode = tView.data[i];
+        const tDetails = getTDeferBlockDetails(tView, tNode);
+        if (isTDeferBlockDetails(tDetails)) {
+          deferBlocks.push({
+            lContainer,
+            lView,
+            tNode,
+            tDetails
+          });
+          continue;
+        }
+      }
+      if (isLView(lContainer[HOST])) {
+        getDeferBlocks$1(lContainer[HOST], deferBlocks);
+      }
+      for (let j = CONTAINER_HEADER_OFFSET; j < lContainer.length; j++) {
+        getDeferBlocks$1(lContainer[j], deferBlocks);
+      }
+    } else if (isLView(lView[i])) {
+      getDeferBlocks$1(lView[i], deferBlocks);
+    }
+  }
+}
+function getDeferBlocks(node) {
+  const results = [];
+  const lView = getLContext(node)?.lView;
+  if (lView) {
+    findDeferBlocks(node, lView, results);
+  }
+  return results;
+}
+function findDeferBlocks(node, lView, results) {
+  const viewInjector = lView[INJECTOR];
+  const registry = viewInjector.get(DEHYDRATED_BLOCK_REGISTRY, null, {
+    optional: true
+  });
+  const blocks = [];
+  getDeferBlocks$1(lView, blocks);
+  const transferState = viewInjector.get(TransferState);
+  const deferBlockParents = transferState.get(NGH_DEFER_BLOCKS_KEY, {});
+  for (const details of blocks) {
+    const native = getNativeByTNode(details.tNode, details.lView);
+    const lDetails = getLDeferBlockDetails(details.lView, details.tNode);
+    if (!node.contains(native)) {
+      continue;
+    }
+    const tDetails = details.tDetails;
+    const renderedLView = getRendererLView(details);
+    const rootNodes = [];
+    const hydrationState = inferHydrationState(tDetails, lDetails, registry);
+    if (renderedLView !== null) {
+      collectNativeNodes(renderedLView[TVIEW], renderedLView, renderedLView[TVIEW].firstChild, rootNodes);
+    } else if (hydrationState === "dehydrated") {
+      const deferId = lDetails[SSR_UNIQUE_ID];
+      const deferData = deferBlockParents[deferId];
+      const numberOfRootNodes = deferData[NUM_ROOT_NODES];
+      let collectedNodeCount = 0;
+      const deferBlockCommentNode = details.lContainer[NATIVE];
+      let currentNode = deferBlockCommentNode.previousSibling;
+      while (collectedNodeCount < numberOfRootNodes && currentNode) {
+        rootNodes.unshift(currentNode);
+        currentNode = currentNode.previousSibling;
+        collectedNodeCount++;
+      }
+    }
+    const data = {
+      state: stringifyState(lDetails[DEFER_BLOCK_STATE]),
+      incrementalHydrationState: hydrationState,
+      hasErrorBlock: tDetails.errorTmplIndex !== null,
+      loadingBlock: {
+        exists: tDetails.loadingTmplIndex !== null,
+        minimumTime: tDetails.loadingBlockConfig?.[MINIMUM_SLOT] ?? null,
+        afterTime: tDetails.loadingBlockConfig?.[LOADING_AFTER_SLOT] ?? null
+      },
+      placeholderBlock: {
+        exists: tDetails.placeholderTmplIndex !== null,
+        minimumTime: tDetails.placeholderBlockConfig?.[MINIMUM_SLOT] ?? null
+      },
+      triggers: tDetails.debug?.triggers ? Array.from(tDetails.debug.triggers).sort() : [],
+      hostNode: details.lContainer[HOST],
+      rootNodes
+    };
+    results.push(data);
+    if (renderedLView !== null) {
+      findDeferBlocks(node, renderedLView, results);
+    }
+  }
+}
+function stringifyState(state) {
+  switch (state) {
+    case DeferBlockState.Complete:
+      return "complete";
+    case DeferBlockState.Loading:
+      return "loading";
+    case DeferBlockState.Placeholder:
+      return "placeholder";
+    case DeferBlockState.Error:
+      return "error";
+    case DeferBlockInternalState.Initial:
+      return "initial";
+    default:
+      throw new Error(`Unrecognized state ${state}`);
+  }
+}
+function inferHydrationState(tDetails, lDetails, registry) {
+  if (registry === null || lDetails[SSR_UNIQUE_ID] === null || tDetails.hydrateTriggers === null || tDetails.hydrateTriggers.has(7)) {
+    return "not-configured";
+  }
+  return registry.has(lDetails[SSR_UNIQUE_ID]) ? "dehydrated" : "hydrated";
+}
+function getRendererLView(details) {
+  if (details.lContainer.length <= CONTAINER_HEADER_OFFSET) {
+    return null;
+  }
+  const lView = details.lContainer[CONTAINER_HEADER_OFFSET];
+  ngDevMode && assertLView(lView);
+  return lView;
+}
+function getDependenciesFromInjectable(injector, token) {
+  const instance = injector.get(token, null, {
+    self: true,
+    optional: true
+  });
+  if (instance === null) {
+    throw new Error(`Unable to determine instance of ${token} in given injector`);
+  }
+  const unformattedDependencies = getDependenciesForTokenInInjector(token, injector);
+  const resolutionPath = getInjectorResolutionPath(injector);
+  const dependencies = unformattedDependencies.map((dep) => {
+    const formattedDependency = {
+      value: dep.value
+    };
+    const flags = dep.flags;
+    formattedDependency.flags = {
+      optional: (8 & flags) === 8,
+      host: (1 & flags) === 1,
+      self: (2 & flags) === 2,
+      skipSelf: (4 & flags) === 4
+    };
+    for (let i = 0; i < resolutionPath.length; i++) {
+      const injectorToCheck = resolutionPath[i];
+      if (i === 0 && formattedDependency.flags.skipSelf) {
+        continue;
+      }
+      if (formattedDependency.flags.host && injectorToCheck instanceof EnvironmentInjector) {
+        break;
+      }
+      const instance2 = injectorToCheck.get(dep.token, null, {
+        self: true,
+        optional: true
+      });
+      if (instance2 !== null) {
+        if (formattedDependency.flags.host) {
+          const firstInjector = resolutionPath[0];
+          const lookupFromFirstInjector = firstInjector.get(dep.token, null, __spreadProps(__spreadValues({}, formattedDependency.flags), {
+            optional: true
+          }));
+          if (lookupFromFirstInjector !== null) {
+            formattedDependency.providedIn = injectorToCheck;
+          }
+          break;
+        }
+        formattedDependency.providedIn = injectorToCheck;
+        break;
+      }
+      if (i === 0 && formattedDependency.flags.self) {
+        break;
+      }
+    }
+    if (dep.token) formattedDependency.token = dep.token;
+    return formattedDependency;
+  });
+  return {
+    instance,
+    dependencies
+  };
+}
+function getDependenciesForTokenInInjector(token, injector) {
+  const {
+    resolverToTokenToDependencies
+  } = getFrameworkDIDebugData();
+  if (!(injector instanceof NodeInjector)) {
+    return resolverToTokenToDependencies.get(injector)?.get?.(token) ?? [];
+  }
+  const lView = getNodeInjectorLView(injector);
+  const tokenDependencyMap = resolverToTokenToDependencies.get(lView);
+  const dependencies = tokenDependencyMap?.get(token) ?? [];
+  return dependencies.filter((dependency) => {
+    const dependencyNode = dependency.injectedIn?.tNode;
+    if (dependencyNode === void 0) {
+      return false;
+    }
+    const instanceNode = getNodeInjectorTNode(injector);
+    assertTNode(dependencyNode);
+    assertTNode(instanceNode);
+    return dependencyNode === instanceNode;
+  });
+}
+function getProviderImportsContainer(injector) {
+  const {
+    standaloneInjectorToComponent
+  } = getFrameworkDIDebugData();
+  if (standaloneInjectorToComponent.has(injector)) {
+    return standaloneInjectorToComponent.get(injector);
+  }
+  const defTypeRef = injector.get(NgModuleRef$1, null, {
+    self: true,
+    optional: true
+  });
+  if (defTypeRef === null) {
+    return null;
+  }
+  if (defTypeRef.instance === null) {
+    return null;
+  }
+  return defTypeRef.instance.constructor;
+}
+function getNodeInjectorProviders(injector) {
+  const diResolver = getNodeInjectorTNode(injector);
+  const {
+    resolverToProviders
+  } = getFrameworkDIDebugData();
+  return resolverToProviders.get(diResolver) ?? [];
+}
+function getProviderImportPaths(providerImportsContainer) {
+  const providerToPath = /* @__PURE__ */ new Map();
+  const visitedContainers = /* @__PURE__ */ new Set();
+  const visitor = walkProviderTreeToDiscoverImportPaths(providerToPath, visitedContainers);
+  walkProviderTree(providerImportsContainer, visitor, [], /* @__PURE__ */ new Set());
+  return providerToPath;
+}
+function walkProviderTreeToDiscoverImportPaths(providerToPath, visitedContainers) {
+  return (provider, container) => {
+    if (!providerToPath.has(provider)) {
+      providerToPath.set(provider, [container]);
+    }
+    if (!visitedContainers.has(container)) {
+      for (const prov of providerToPath.keys()) {
+        const existingImportPath = providerToPath.get(prov);
+        let containerDef = getInjectorDef(container);
+        if (!containerDef) {
+          const ngModule = container.ngModule;
+          containerDef = getInjectorDef(ngModule);
+        }
+        if (!containerDef) {
+          return;
+        }
+        const lastContainerAddedToPath = existingImportPath[0];
+        let isNextStepInPath = false;
+        deepForEach(containerDef.imports, (moduleImport) => {
+          if (isNextStepInPath) {
+            return;
+          }
+          isNextStepInPath = moduleImport.ngModule === lastContainerAddedToPath || moduleImport === lastContainerAddedToPath;
+          if (isNextStepInPath) {
+            providerToPath.get(prov)?.unshift(container);
+          }
+        });
+      }
+    }
+    visitedContainers.add(container);
+  };
+}
+function getEnvironmentInjectorProviders(injector) {
+  const providerRecordsWithoutImportPaths = getFrameworkDIDebugData().resolverToProviders.get(injector) ?? [];
+  if (isPlatformInjector(injector)) {
+    return providerRecordsWithoutImportPaths;
+  }
+  const providerImportsContainer = getProviderImportsContainer(injector);
+  if (providerImportsContainer === null) {
+    return providerRecordsWithoutImportPaths;
+  }
+  const providerToPath = getProviderImportPaths(providerImportsContainer);
+  const providerRecords = [];
+  for (const providerRecord of providerRecordsWithoutImportPaths) {
+    const provider = providerRecord.provider;
+    const token = provider.provide;
+    if (token === ENVIRONMENT_INITIALIZER || token === INJECTOR_DEF_TYPES) {
+      continue;
+    }
+    let importPath = providerToPath.get(provider) ?? [];
+    const def = getComponentDef(providerImportsContainer);
+    const isStandaloneComponent2 = !!def?.standalone;
+    if (isStandaloneComponent2) {
+      importPath = [providerImportsContainer, ...importPath];
+    }
+    providerRecords.push(__spreadProps(__spreadValues({}, providerRecord), {
+      importPath
+    }));
+  }
+  return providerRecords;
+}
+function isPlatformInjector(injector) {
+  return injector instanceof R3Injector && injector.scopes.has("platform");
+}
+function getInjectorProviders(injector) {
+  if (injector instanceof NodeInjector) {
+    return getNodeInjectorProviders(injector);
+  } else if (injector instanceof EnvironmentInjector) {
+    return getEnvironmentInjectorProviders(injector);
+  }
+  throwError2("getInjectorProviders only supports NodeInjector and EnvironmentInjector");
+}
+function getInjectorMetadata(injector) {
+  if (injector instanceof NodeInjector) {
+    const lView = getNodeInjectorLView(injector);
+    const tNode = getNodeInjectorTNode(injector);
+    assertTNodeForLView(tNode, lView);
+    return {
+      type: "element",
+      source: getNativeByTNode(tNode, lView)
+    };
+  }
+  if (injector instanceof R3Injector) {
+    return {
+      type: "environment",
+      source: injector.source ?? null
+    };
+  }
+  if (injector instanceof NullInjector) {
+    return {
+      type: "null",
+      source: null
+    };
+  }
+  return null;
+}
+function getInjectorResolutionPath(injector) {
+  const resolutionPath = [injector];
+  getInjectorResolutionPathHelper(injector, resolutionPath);
+  return resolutionPath;
+}
+function getInjectorResolutionPathHelper(injector, resolutionPath) {
+  const parent = getInjectorParent(injector);
+  if (parent === null) {
+    if (injector instanceof NodeInjector) {
+      const firstInjector = resolutionPath[0];
+      if (firstInjector instanceof NodeInjector) {
+        const moduleInjector = getModuleInjectorOfNodeInjector(firstInjector);
+        if (moduleInjector === null) {
+          throwError2("NodeInjector must have some connection to the module injector tree");
+        }
+        resolutionPath.push(moduleInjector);
+        getInjectorResolutionPathHelper(moduleInjector, resolutionPath);
+      }
+      return resolutionPath;
+    }
+  } else {
+    resolutionPath.push(parent);
+    getInjectorResolutionPathHelper(parent, resolutionPath);
+  }
+  return resolutionPath;
+}
+function getInjectorParent(injector) {
+  if (injector instanceof R3Injector) {
+    return injector.parent;
+  }
+  let tNode;
+  let lView;
+  if (injector instanceof NodeInjector) {
+    tNode = getNodeInjectorTNode(injector);
+    lView = getNodeInjectorLView(injector);
+  } else if (injector instanceof NullInjector) {
+    return null;
+  } else if (injector instanceof ChainedInjector) {
+    return injector.parentInjector;
+  } else {
+    throwError2("getInjectorParent only support injectors of type R3Injector, NodeInjector, NullInjector");
+  }
+  const parentLocation = getParentInjectorLocation(tNode, lView);
+  if (hasParentInjector(parentLocation)) {
+    const parentInjectorIndex = getParentInjectorIndex(parentLocation);
+    const parentLView = getParentInjectorView(parentLocation, lView);
+    const parentTView = parentLView[TVIEW];
+    const parentTNode = parentTView.data[parentInjectorIndex + 8];
+    return new NodeInjector(parentTNode, parentLView);
+  } else {
+    const chainedInjector = lView[INJECTOR];
+    const injectorParent = chainedInjector.injector?.parent;
+    if (injectorParent instanceof NodeInjector) {
+      return injectorParent;
+    }
+  }
+  return null;
+}
+function getModuleInjectorOfNodeInjector(injector) {
+  let lView;
+  if (injector instanceof NodeInjector) {
+    lView = getNodeInjectorLView(injector);
+  } else {
+    throwError2("getModuleInjectorOfNodeInjector must be called with a NodeInjector");
+  }
+  const inj = lView[INJECTOR];
+  const moduleInjector = inj instanceof ChainedInjector ? inj.parentInjector : inj.parent;
+  if (!moduleInjector) {
+    throwError2("NodeInjector must have some connection to the module injector tree");
+  }
+  return moduleInjector;
+}
+function isComputedNode(node) {
+  return node.kind === "computed";
+}
+function isTemplateEffectNode(node) {
+  return node.kind === "template";
+}
+function isSignalNode(node) {
+  return node.kind === "signal";
+}
+function getTemplateConsumer(injector) {
+  const tNode = getNodeInjectorTNode(injector);
+  assertTNode(tNode);
+  const lView = getNodeInjectorLView(injector);
+  assertLView(lView);
+  const templateLView = lView[tNode.index];
+  if (isLView(templateLView)) {
+    return templateLView[REACTIVE_TEMPLATE_CONSUMER] ?? null;
+  }
+  return null;
+}
+var signalDebugMap = /* @__PURE__ */ new WeakMap();
+var counter$1 = 0;
+function getNodesAndEdgesFromSignalMap(signalMap) {
+  const nodes = Array.from(signalMap.keys());
+  const debugSignalGraphNodes = [];
+  const edges = [];
+  for (const [consumer, producers] of signalMap.entries()) {
+    const consumerIndex = nodes.indexOf(consumer);
+    let id = signalDebugMap.get(consumer);
+    if (!id) {
+      counter$1++;
+      id = counter$1.toString();
+      signalDebugMap.set(consumer, id);
+    }
+    if (isComputedNode(consumer)) {
+      debugSignalGraphNodes.push({
+        label: consumer.debugName,
+        value: consumer.value,
+        kind: consumer.kind,
+        epoch: consumer.version,
+        debuggableFn: consumer.computation,
+        id
+      });
+    } else if (isSignalNode(consumer)) {
+      debugSignalGraphNodes.push({
+        label: consumer.debugName,
+        value: consumer.value,
+        kind: consumer.kind,
+        epoch: consumer.version,
+        id
+      });
+    } else if (isTemplateEffectNode(consumer)) {
+      debugSignalGraphNodes.push({
+        label: consumer.debugName ?? consumer.lView?.[HOST]?.tagName?.toLowerCase?.(),
+        kind: consumer.kind,
+        epoch: consumer.version,
+        debuggableFn: consumer.lView?.[CONTEXT]?.constructor,
+        id
+      });
+    } else {
+      debugSignalGraphNodes.push({
+        label: consumer.debugName,
+        kind: consumer.kind,
+        epoch: consumer.version,
+        id
+      });
+    }
+    for (const producer of producers) {
+      edges.push({
+        consumer: consumerIndex,
+        producer: nodes.indexOf(producer)
+      });
+    }
+  }
+  return {
+    nodes: debugSignalGraphNodes,
+    edges
+  };
+}
+function extractEffectsFromInjector(injector) {
+  let diResolver = injector;
+  if (injector instanceof NodeInjector) {
+    const lView = getNodeInjectorLView(injector);
+    diResolver = lView;
+  }
+  const resolverToEffects = getFrameworkDIDebugData().resolverToEffects;
+  const effects = resolverToEffects.get(diResolver) ?? [];
+  return effects.map((effect2) => {
+    if (effect2 instanceof EffectRefImpl) {
+      return effect2[SIGNAL];
+    } else {
+      return effect2.signal[SIGNAL];
+    }
+  });
+}
+function extractSignalNodesAndEdgesFromRoots(nodes, signalDependenciesMap = /* @__PURE__ */ new Map()) {
+  for (const node of nodes) {
+    if (signalDependenciesMap.has(node)) {
+      continue;
+    }
+    const producerNodes = [];
+    for (let link = node.producers; link !== void 0; link = link.nextProducer) {
+      const producer = link.producer;
+      producerNodes.push(producer);
+    }
+    signalDependenciesMap.set(node, producerNodes);
+    extractSignalNodesAndEdgesFromRoots(producerNodes, signalDependenciesMap);
+  }
+  return signalDependenciesMap;
+}
+function getSignalGraph(injector) {
+  let templateConsumer = null;
+  if (!(injector instanceof NodeInjector) && !(injector instanceof R3Injector)) {
+    return throwError2("getSignalGraph must be called with a NodeInjector or R3Injector");
+  }
+  if (injector instanceof NodeInjector) {
+    templateConsumer = getTemplateConsumer(injector);
+  }
+  const nonTemplateEffectNodes = extractEffectsFromInjector(injector);
+  const signalNodes = templateConsumer ? [templateConsumer, ...nonTemplateEffectNodes] : nonTemplateEffectNodes;
+  const signalDependenciesMap = extractSignalNodesAndEdgesFromRoots(signalNodes);
+  return getNodesAndEdgesFromSignalMap(signalDependenciesMap);
+}
+var changeDetectionRuns = 0;
+var changeDetectionSyncRuns = 0;
+var counter = 0;
+var eventsStack = [];
+function measureStart(startEvent) {
+  eventsStack.push([startEvent, counter]);
+  console.timeStamp("Event_" + startEvent + "_" + counter++);
+}
+function measureEnd(startEvent, entryName, color) {
+  let top;
+  do {
+    top = eventsStack.pop();
+    assertDefined(top, "Profiling error: could not find start event entry " + startEvent);
+  } while (top[0] !== startEvent);
+  console.timeStamp(entryName, "Event_" + top[0] + "_" + top[1], void 0, "\u{1F170}\uFE0F Angular", void 0, color);
+}
+var chromeDevToolsInjectorProfiler = (event) => {
+  const eventType = event.type;
+  if (eventType === 5) {
+    measureStart(100);
+  } else if (eventType === 1) {
+    const token = event.context.token;
+    measureEnd(100, getProviderTokenMeasureName(token), "tertiary-dark");
+  }
+};
+var devToolsProfiler = (event, instance, eventFn) => {
+  switch (event) {
+    case ProfilerEvent.BootstrapApplicationStart:
+    case ProfilerEvent.BootstrapComponentStart:
+    case ProfilerEvent.ChangeDetectionStart:
+    case ProfilerEvent.ChangeDetectionSyncStart:
+    case ProfilerEvent.AfterRenderHooksStart:
+    case ProfilerEvent.ComponentStart:
+    case ProfilerEvent.DeferBlockStateStart:
+    case ProfilerEvent.DynamicComponentStart:
+    case ProfilerEvent.TemplateCreateStart:
+    case ProfilerEvent.LifecycleHookStart:
+    case ProfilerEvent.TemplateUpdateStart:
+    case ProfilerEvent.HostBindingsUpdateStart:
+    case ProfilerEvent.OutputStart: {
+      measureStart(event);
+      break;
+    }
+    case ProfilerEvent.BootstrapApplicationEnd: {
+      measureEnd(ProfilerEvent.BootstrapApplicationStart, "Bootstrap application", "primary-dark");
+      break;
+    }
+    case ProfilerEvent.BootstrapComponentEnd: {
+      measureEnd(ProfilerEvent.BootstrapComponentStart, "Bootstrap component", "primary-dark");
+      break;
+    }
+    case ProfilerEvent.ChangeDetectionEnd: {
+      changeDetectionSyncRuns = 0;
+      measureEnd(ProfilerEvent.ChangeDetectionStart, "Change detection " + changeDetectionRuns++, "primary-dark");
+      break;
+    }
+    case ProfilerEvent.ChangeDetectionSyncEnd: {
+      measureEnd(ProfilerEvent.ChangeDetectionSyncStart, "Synchronization " + changeDetectionSyncRuns++, "primary");
+      break;
+    }
+    case ProfilerEvent.AfterRenderHooksEnd: {
+      measureEnd(ProfilerEvent.AfterRenderHooksStart, "After render hooks", "primary");
+      break;
+    }
+    case ProfilerEvent.ComponentEnd: {
+      const typeName = getComponentMeasureName(instance);
+      measureEnd(ProfilerEvent.ComponentStart, typeName, "primary-light");
+      break;
+    }
+    case ProfilerEvent.DeferBlockStateEnd: {
+      measureEnd(ProfilerEvent.DeferBlockStateStart, "Defer block", "primary-dark");
+      break;
+    }
+    case ProfilerEvent.DynamicComponentEnd: {
+      measureEnd(ProfilerEvent.DynamicComponentStart, "Dynamic component creation", "primary-dark");
+      break;
+    }
+    case ProfilerEvent.TemplateUpdateEnd: {
+      measureEnd(ProfilerEvent.TemplateUpdateStart, stringifyForError(eventFn) + " (update)", "secondary-dark");
+      break;
+    }
+    case ProfilerEvent.TemplateCreateEnd: {
+      measureEnd(ProfilerEvent.TemplateCreateStart, stringifyForError(eventFn) + " (create)", "secondary");
+      break;
+    }
+    case ProfilerEvent.HostBindingsUpdateEnd: {
+      measureEnd(ProfilerEvent.HostBindingsUpdateStart, "HostBindings", "secondary-dark");
+      break;
+    }
+    case ProfilerEvent.LifecycleHookEnd: {
+      const typeName = getComponentMeasureName(instance);
+      measureEnd(ProfilerEvent.LifecycleHookStart, `${typeName}:${stringifyForError(eventFn)}`, "tertiary");
+      break;
+    }
+    case ProfilerEvent.OutputEnd: {
+      measureEnd(ProfilerEvent.OutputStart, stringifyForError(eventFn), "tertiary-light");
+      break;
+    }
+    default: {
+      throw new Error("Unexpected profiling event type: " + event);
+    }
+  }
+};
+function getComponentMeasureName(instance) {
+  return instance.constructor.name;
+}
+function getProviderTokenMeasureName(token) {
+  if (isTypeProvider(token)) {
+    return token.name;
+  } else if (token.provide != null) {
+    return getProviderTokenMeasureName(token.provide);
+  }
+  return token.toString();
+}
+function enableProfiling() {
+  performanceMarkFeature("Chrome DevTools profiling");
+  if (typeof ngDevMode !== "undefined" && ngDevMode) {
+    const removeInjectorProfiler = setInjectorProfiler(chromeDevToolsInjectorProfiler);
+    const removeProfiler3 = setProfiler(devToolsProfiler);
+    return () => {
+      removeInjectorProfiler();
+      removeProfiler3();
+    };
+  }
+  return () => {
+  };
+}
+function getTransferState(injector) {
+  const doc = injector.get(DOCUMENT);
+  const appId = injector.get(APP_ID);
+  const transferState = retrieveTransferredState(doc, appId);
+  const filteredEntries = {};
+  for (const [key, value] of Object.entries(transferState)) {
+    if (!isInternalHydrationTransferStateKey(key)) {
+      filteredEntries[key] = value;
+    }
+  }
+  return filteredEntries;
+}
+var GLOBAL_PUBLISH_EXPANDO_KEY = "ng";
+var globalUtilsFunctions = {
+  "\u0275getDependenciesFromInjectable": getDependenciesFromInjectable,
+  "\u0275getInjectorProviders": getInjectorProviders,
+  "\u0275getInjectorResolutionPath": getInjectorResolutionPath,
+  "\u0275getInjectorMetadata": getInjectorMetadata,
+  "\u0275setProfiler": setProfiler,
+  "\u0275getSignalGraph": getSignalGraph,
+  "\u0275getDeferBlocks": getDeferBlocks,
+  "\u0275getTransferState": getTransferState,
+  "getDirectiveMetadata": getDirectiveMetadata$1,
+  "getComponent": getComponent,
+  "getContext": getContext,
+  "getListeners": getListeners,
+  "getOwningComponent": getOwningComponent,
+  "getHostElement": getHostElement,
+  "getInjector": getInjector,
+  "getRootComponents": getRootComponents,
+  "getDirectives": getDirectives,
+  "applyChanges": applyChanges,
+  "isSignal": isSignal2,
+  "enableProfiling": enableProfiling
+};
+var _published = false;
+function publishDefaultGlobalUtils$1() {
+  if (!_published) {
+    _published = true;
+    if (typeof window !== "undefined") {
+      setupFrameworkInjectorProfiler();
+    }
+    for (const [methodName, method] of Object.entries(globalUtilsFunctions)) {
+      publishGlobalUtil(methodName, method);
+    }
+  }
+}
+function publishGlobalUtil(name, fn) {
+  publishUtil(name, fn);
+}
+function publishExternalGlobalUtil(name, fn) {
+  publishUtil(name, fn);
+}
+function publishUtil(name, fn) {
+  if (typeof COMPILED === "undefined" || !COMPILED) {
+    const w = _global;
+    ngDevMode && assertDefined(fn, "function not defined");
+    w[GLOBAL_PUBLISH_EXPANDO_KEY] ??= {};
+    w[GLOBAL_PUBLISH_EXPANDO_KEY][name] = fn;
+  }
+}
+var TESTABILITY = new InjectionToken("");
+var TESTABILITY_GETTER = new InjectionToken("");
+var Testability = class _Testability {
+  _ngZone;
+  registry;
+  _isZoneStable = true;
+  _callbacks = [];
+  _taskTrackingZone = null;
+  _destroyRef;
+  constructor(_ngZone, registry, testabilityGetter) {
+    this._ngZone = _ngZone;
+    this.registry = registry;
+    if (isInInjectionContext()) {
+      this._destroyRef = inject2(DestroyRef, {
+        optional: true
+      }) ?? void 0;
+    }
+    if (!_testabilityGetter) {
+      setTestabilityGetter(testabilityGetter);
+      testabilityGetter.addToWindow(registry);
+    }
+    this._watchAngularEvents();
+    _ngZone.run(() => {
+      this._taskTrackingZone = typeof Zone == "undefined" ? null : Zone.current.get("TaskTrackingZone");
+    });
+  }
+  _watchAngularEvents() {
+    const onUnstableSubscription = this._ngZone.onUnstable.subscribe({
+      next: () => {
+        this._isZoneStable = false;
+      }
+    });
+    const onStableSubscription = this._ngZone.runOutsideAngular(() => this._ngZone.onStable.subscribe({
+      next: () => {
+        NgZone.assertNotInAngularZone();
+        queueMicrotask(() => {
+          this._isZoneStable = true;
+          this._runCallbacksIfReady();
+        });
+      }
+    }));
+    this._destroyRef?.onDestroy(() => {
+      onUnstableSubscription.unsubscribe();
+      onStableSubscription.unsubscribe();
+    });
+  }
+  isStable() {
+    return this._isZoneStable && !this._ngZone.hasPendingMacrotasks;
+  }
+  _runCallbacksIfReady() {
+    if (this.isStable()) {
+      queueMicrotask(() => {
+        while (this._callbacks.length !== 0) {
+          let cb = this._callbacks.pop();
+          clearTimeout(cb.timeoutId);
+          cb.doneCb();
+        }
+      });
+    } else {
+      let pending = this.getPendingTasks();
+      this._callbacks = this._callbacks.filter((cb) => {
+        if (cb.updateCb && cb.updateCb(pending)) {
+          clearTimeout(cb.timeoutId);
+          return false;
+        }
+        return true;
+      });
+    }
+  }
+  getPendingTasks() {
+    if (!this._taskTrackingZone) {
+      return [];
+    }
+    return this._taskTrackingZone.macroTasks.map((t) => {
+      return {
+        source: t.source,
+        creationLocation: t.creationLocation,
+        data: t.data
+      };
+    });
+  }
+  addCallback(cb, timeout2, updateCb) {
+    let timeoutId = -1;
+    if (timeout2 && timeout2 > 0) {
+      timeoutId = setTimeout(() => {
+        this._callbacks = this._callbacks.filter((cb2) => cb2.timeoutId !== timeoutId);
+        cb();
+      }, timeout2);
+    }
+    this._callbacks.push({
+      doneCb: cb,
+      timeoutId,
+      updateCb
+    });
+  }
+  whenStable(doneCb, timeout2, updateCb) {
+    if (updateCb && !this._taskTrackingZone) {
+      throw new Error('Task tracking zone is required when passing an update callback to whenStable(). Is "zone.js/plugins/task-tracking" loaded?');
+    }
+    this.addCallback(doneCb, timeout2, updateCb);
+    this._runCallbacksIfReady();
+  }
+  registerApplication(token) {
+    this.registry.registerApplication(token, this);
+  }
+  unregisterApplication(token) {
+    this.registry.unregisterApplication(token);
+  }
+  findProviders(using, provider, exactMatch) {
+    return [];
+  }
+  static \u0275fac = function Testability_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _Testability)(\u0275\u0275inject(NgZone), \u0275\u0275inject(TestabilityRegistry), \u0275\u0275inject(TESTABILITY_GETTER));
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _Testability,
+    factory: _Testability.\u0275fac
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(Testability, [{
+    type: Injectable
+  }], () => [{
+    type: NgZone
+  }, {
+    type: TestabilityRegistry
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Inject,
+      args: [TESTABILITY_GETTER]
+    }]
+  }], null);
+})();
+var TestabilityRegistry = class _TestabilityRegistry {
+  _applications = /* @__PURE__ */ new Map();
+  registerApplication(token, testability) {
+    this._applications.set(token, testability);
+  }
+  unregisterApplication(token) {
+    this._applications.delete(token);
+  }
+  unregisterAllApplications() {
+    this._applications.clear();
+  }
+  getTestability(elem) {
+    return this._applications.get(elem) || null;
+  }
+  getAllTestabilities() {
+    return Array.from(this._applications.values());
+  }
+  getAllRootElements() {
+    return Array.from(this._applications.keys());
+  }
+  findTestabilityInTree(elem, findInAncestors = true) {
+    return _testabilityGetter?.findTestabilityInTree(this, elem, findInAncestors) ?? null;
+  }
+  static \u0275fac = function TestabilityRegistry_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _TestabilityRegistry)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _TestabilityRegistry,
+    factory: _TestabilityRegistry.\u0275fac,
+    providedIn: "platform"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(TestabilityRegistry, [{
+    type: Injectable,
+    args: [{
+      providedIn: "platform"
+    }]
+  }], null, null);
+})();
+function setTestabilityGetter(getter) {
+  _testabilityGetter = getter;
+}
+var _testabilityGetter;
+function isPromise2(obj) {
+  return !!obj && typeof obj.then === "function";
+}
+function isSubscribable(obj) {
+  return !!obj && typeof obj.subscribe === "function";
+}
+var APP_INITIALIZER = new InjectionToken(ngDevMode ? "Application Initializer" : "");
+function provideAppInitializer(initializerFn) {
+  return makeEnvironmentProviders([{
+    provide: APP_INITIALIZER,
+    multi: true,
+    useValue: initializerFn
+  }]);
+}
+var ApplicationInitStatus = class _ApplicationInitStatus {
+  resolve;
+  reject;
+  initialized = false;
+  done = false;
+  donePromise = new Promise((res, rej) => {
+    this.resolve = res;
+    this.reject = rej;
+  });
+  appInits = inject2(APP_INITIALIZER, {
+    optional: true
+  }) ?? [];
+  injector = inject2(Injector);
+  constructor() {
+    if ((typeof ngDevMode === "undefined" || ngDevMode) && !Array.isArray(this.appInits)) {
+      throw new RuntimeError(-209, `Unexpected type of the \`APP_INITIALIZER\` token value (expected an array, but got ${typeof this.appInits}). Please check that the \`APP_INITIALIZER\` token is configured as a \`multi: true\` provider.`);
+    }
+  }
+  runInitializers() {
+    if (this.initialized) {
+      return;
+    }
+    const asyncInitPromises = [];
+    for (const appInits of this.appInits) {
+      const initResult = runInInjectionContext(this.injector, appInits);
+      if (isPromise2(initResult)) {
+        asyncInitPromises.push(initResult);
+      } else if (isSubscribable(initResult)) {
+        const observableAsPromise = new Promise((resolve, reject) => {
+          initResult.subscribe({
+            complete: resolve,
+            error: reject
+          });
+        });
+        asyncInitPromises.push(observableAsPromise);
+      }
+    }
+    const complete = () => {
+      this.done = true;
+      this.resolve();
+    };
+    Promise.all(asyncInitPromises).then(() => {
+      complete();
+    }).catch((e) => {
+      this.reject(e);
+    });
+    if (asyncInitPromises.length === 0) {
+      complete();
+    }
+    this.initialized = true;
+  }
+  static \u0275fac = function ApplicationInitStatus_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _ApplicationInitStatus)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _ApplicationInitStatus,
+    factory: _ApplicationInitStatus.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ApplicationInitStatus, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], () => [], null);
+})();
+var APP_BOOTSTRAP_LISTENER = new InjectionToken(ngDevMode ? "appBootstrapListener" : "");
+function publishDefaultGlobalUtils() {
+  ngDevMode && publishDefaultGlobalUtils$1();
+}
+function publishSignalConfiguration() {
+  setThrowInvalidWriteToSignalError(() => {
+    let errorMessage = "";
+    if (ngDevMode) {
+      const activeConsumer2 = getActiveConsumer();
+      errorMessage = activeConsumer2 && isReactiveLViewConsumer(activeConsumer2) ? "Writing to signals is not allowed while Angular renders the template (eg. interpolations)" : "Writing to signals is not allowed in a `computed`";
+    }
+    throw new RuntimeError(600, errorMessage);
+  });
+}
+function isBoundToModule(cf) {
+  return cf.isBoundToModule;
+}
+var MAXIMUM_REFRESH_RERUNS = 10;
+function optionsReducer(dst, objs) {
+  if (Array.isArray(objs)) {
+    return objs.reduce(optionsReducer, dst);
+  }
+  return __spreadValues(__spreadValues({}, dst), objs);
+}
+var ApplicationRef = class _ApplicationRef {
+  _runningTick = false;
+  _destroyed = false;
+  _destroyListeners = [];
+  _views = [];
+  internalErrorHandler = inject2(INTERNAL_APPLICATION_ERROR_HANDLER);
+  afterRenderManager = inject2(AfterRenderManager);
+  zonelessEnabled = inject2(ZONELESS_ENABLED);
+  rootEffectScheduler = inject2(EffectScheduler);
+  dirtyFlags = 0;
+  tracingSnapshot = null;
+  allTestViews = /* @__PURE__ */ new Set();
+  autoDetectTestViews = /* @__PURE__ */ new Set();
+  includeAllTestViews = false;
+  afterTick = new Subject();
+  get allViews() {
+    return [...(this.includeAllTestViews ? this.allTestViews : this.autoDetectTestViews).keys(), ...this._views];
+  }
+  get destroyed() {
+    return this._destroyed;
+  }
+  componentTypes = [];
+  components = [];
+  internalPendingTask = inject2(PendingTasksInternal);
+  get isStable() {
+    return this.internalPendingTask.hasPendingTasksObservable.pipe(map((pending) => !pending));
+  }
+  constructor() {
+    inject2(TracingService, {
+      optional: true
+    });
+  }
+  whenStable() {
+    let subscription;
+    return new Promise((resolve) => {
+      subscription = this.isStable.subscribe({
+        next: (stable) => {
+          if (stable) {
+            resolve();
+          }
+        }
+      });
+    }).finally(() => {
+      subscription.unsubscribe();
+    });
+  }
+  _injector = inject2(EnvironmentInjector);
+  _rendererFactory = null;
+  get injector() {
+    return this._injector;
+  }
+  bootstrap(componentOrFactory, rootSelectorOrNode) {
+    return this.bootstrapImpl(componentOrFactory, rootSelectorOrNode);
+  }
+  bootstrapImpl(componentOrFactory, rootSelectorOrNode, injector = Injector.NULL) {
+    const ngZone = this._injector.get(NgZone);
+    return ngZone.run(() => {
+      profiler(ProfilerEvent.BootstrapComponentStart);
+      (typeof ngDevMode === "undefined" || ngDevMode) && warnIfDestroyed(this._destroyed);
+      const isComponentFactory = componentOrFactory instanceof ComponentFactory$1;
+      const initStatus = this._injector.get(ApplicationInitStatus);
+      if (!initStatus.done) {
+        let errorMessage = "";
+        if (typeof ngDevMode === "undefined" || ngDevMode) {
+          const standalone = !isComponentFactory && isStandalone(componentOrFactory);
+          errorMessage = "Cannot bootstrap as there are still asynchronous initializers running." + (standalone ? "" : " Bootstrap components in the `ngDoBootstrap` method of the root module.");
+        }
+        throw new RuntimeError(405, errorMessage);
+      }
+      let componentFactory;
+      if (isComponentFactory) {
+        componentFactory = componentOrFactory;
+      } else {
+        const resolver = this._injector.get(ComponentFactoryResolver$1);
+        componentFactory = resolver.resolveComponentFactory(componentOrFactory);
+      }
+      this.componentTypes.push(componentFactory.componentType);
+      const ngModule = isBoundToModule(componentFactory) ? void 0 : this._injector.get(NgModuleRef$1);
+      const selectorOrNode = rootSelectorOrNode || componentFactory.selector;
+      const compRef = componentFactory.create(injector, [], selectorOrNode, ngModule);
+      const nativeElement = compRef.location.nativeElement;
+      const testability = compRef.injector.get(TESTABILITY, null);
+      testability?.registerApplication(nativeElement);
+      compRef.onDestroy(() => {
+        this.detachView(compRef.hostView);
+        remove(this.components, compRef);
+        testability?.unregisterApplication(nativeElement);
+      });
+      this._loadComponent(compRef);
+      if (typeof ngDevMode === "undefined" || ngDevMode) {
+        const _console = this._injector.get(Console);
+        _console.log(`Angular is running in development mode.`);
+      }
+      profiler(ProfilerEvent.BootstrapComponentEnd, compRef);
+      return compRef;
+    });
+  }
+  tick() {
+    if (!this.zonelessEnabled) {
+      this.dirtyFlags |= 1;
+    }
+    this._tick();
+  }
+  _tick() {
+    profiler(ProfilerEvent.ChangeDetectionStart);
+    if (this.tracingSnapshot !== null) {
+      this.tracingSnapshot.run(TracingAction.CHANGE_DETECTION, this.tickImpl);
+    } else {
+      this.tickImpl();
+    }
+  }
+  tickImpl = () => {
+    (typeof ngDevMode === "undefined" || ngDevMode) && warnIfDestroyed(this._destroyed);
+    if (this._runningTick) {
+      profiler(ProfilerEvent.ChangeDetectionEnd);
+      throw new RuntimeError(101, ngDevMode && "ApplicationRef.tick is called recursively");
+    }
+    const prevConsumer = setActiveConsumer(null);
+    try {
+      this._runningTick = true;
+      this.synchronize();
+      if (typeof ngDevMode === "undefined" || ngDevMode) {
+        for (let view of this.allViews) {
+          view.checkNoChanges();
+        }
+      }
+    } finally {
+      this._runningTick = false;
+      this.tracingSnapshot?.dispose();
+      this.tracingSnapshot = null;
+      setActiveConsumer(prevConsumer);
+      this.afterTick.next();
+      profiler(ProfilerEvent.ChangeDetectionEnd);
+    }
+  };
+  synchronize() {
+    if (this._rendererFactory === null && !this._injector.destroyed) {
+      this._rendererFactory = this._injector.get(RendererFactory2, null, {
+        optional: true
+      });
+    }
+    let runs = 0;
+    while (this.dirtyFlags !== 0 && runs++ < MAXIMUM_REFRESH_RERUNS) {
+      profiler(ProfilerEvent.ChangeDetectionSyncStart);
+      try {
+        this.synchronizeOnce();
+      } finally {
+        profiler(ProfilerEvent.ChangeDetectionSyncEnd);
+      }
+    }
+    if ((typeof ngDevMode === "undefined" || ngDevMode) && runs >= MAXIMUM_REFRESH_RERUNS) {
+      throw new RuntimeError(103, ngDevMode && "Infinite change detection while refreshing application views. Ensure views are not calling `markForCheck` on every template execution or that afterRender hooks always mark views for check.");
+    }
+  }
+  synchronizeOnce() {
+    if (this.dirtyFlags & 16) {
+      this.dirtyFlags &= -17;
+      this.rootEffectScheduler.flush();
+    }
+    let ranDetectChanges = false;
+    if (this.dirtyFlags & 7) {
+      const useGlobalCheck = Boolean(this.dirtyFlags & 1);
+      this.dirtyFlags &= -8;
+      this.dirtyFlags |= 8;
+      for (let {
+        _lView
+      } of this.allViews) {
+        if (!useGlobalCheck && !requiresRefreshOrTraversal(_lView)) {
+          continue;
+        }
+        const mode = useGlobalCheck && !this.zonelessEnabled ? 0 : 1;
+        detectChangesInternal(_lView, mode);
+        ranDetectChanges = true;
+      }
+      this.dirtyFlags &= -5;
+      this.syncDirtyFlagsWithViews();
+      if (this.dirtyFlags & (7 | 16)) {
+        return;
+      }
+    }
+    if (!ranDetectChanges) {
+      this._rendererFactory?.begin?.();
+      this._rendererFactory?.end?.();
+    }
+    if (this.dirtyFlags & 8) {
+      this.dirtyFlags &= -9;
+      this.afterRenderManager.execute();
+    }
+    this.syncDirtyFlagsWithViews();
+  }
+  syncDirtyFlagsWithViews() {
+    if (this.allViews.some(({
+      _lView
+    }) => requiresRefreshOrTraversal(_lView))) {
+      this.dirtyFlags |= 2;
+      return;
+    } else {
+      this.dirtyFlags &= -8;
+    }
+  }
+  attachView(viewRef) {
+    (typeof ngDevMode === "undefined" || ngDevMode) && warnIfDestroyed(this._destroyed);
+    const view = viewRef;
+    this._views.push(view);
+    view.attachToAppRef(this);
+  }
+  detachView(viewRef) {
+    (typeof ngDevMode === "undefined" || ngDevMode) && warnIfDestroyed(this._destroyed);
+    const view = viewRef;
+    remove(this._views, view);
+    view.detachFromAppRef();
+  }
+  _loadComponent(componentRef) {
+    this.attachView(componentRef.hostView);
+    try {
+      this.tick();
+    } catch (e) {
+      this.internalErrorHandler(e);
+    }
+    this.components.push(componentRef);
+    const listeners = this._injector.get(APP_BOOTSTRAP_LISTENER, []);
+    if (ngDevMode && !Array.isArray(listeners)) {
+      throw new RuntimeError(-209, `Unexpected type of the \`APP_BOOTSTRAP_LISTENER\` token value (expected an array, but got ${typeof listeners}). Please check that the \`APP_BOOTSTRAP_LISTENER\` token is configured as a \`multi: true\` provider.`);
+    }
+    listeners.forEach((listener) => listener(componentRef));
+  }
+  ngOnDestroy() {
+    if (this._destroyed) return;
+    try {
+      this._destroyListeners.forEach((listener) => listener());
+      this._views.slice().forEach((view) => view.destroy());
+    } finally {
+      this._destroyed = true;
+      this._views = [];
+      this._destroyListeners = [];
+    }
+  }
+  onDestroy(callback) {
+    (typeof ngDevMode === "undefined" || ngDevMode) && warnIfDestroyed(this._destroyed);
+    this._destroyListeners.push(callback);
+    return () => remove(this._destroyListeners, callback);
+  }
+  destroy() {
+    if (this._destroyed) {
+      throw new RuntimeError(406, ngDevMode && "This instance of the `ApplicationRef` has already been destroyed.");
+    }
+    const injector = this._injector;
+    if (injector.destroy && !injector.destroyed) {
+      injector.destroy();
+    }
+  }
+  get viewCount() {
+    return this._views.length;
+  }
+  static \u0275fac = function ApplicationRef_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _ApplicationRef)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _ApplicationRef,
+    factory: _ApplicationRef.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ApplicationRef, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], () => [], null);
+})();
+function warnIfDestroyed(destroyed) {
+  if (destroyed) {
+    console.warn(formatRuntimeError(406, "This instance of the `ApplicationRef` has already been destroyed."));
+  }
+}
+function remove(list, el) {
+  const index = list.indexOf(el);
+  if (index > -1) {
+    list.splice(index, 1);
+  }
+}
+function promiseWithResolvers() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return {
+    promise,
+    resolve,
+    reject
+  };
+}
+function scheduleDelayedTrigger(scheduleFn) {
+  const lView = getLView();
+  const tNode = getCurrentTNode();
+  renderPlaceholder(lView, tNode);
+  if (!shouldTriggerDeferBlock(0, lView)) return;
+  const injector = lView[INJECTOR];
+  const lDetails = getLDeferBlockDetails(lView, tNode);
+  const cleanupFn = scheduleFn(() => triggerDeferBlock(0, lView, tNode), injector);
+  storeTriggerCleanupFn(0, lDetails, cleanupFn);
+}
+function scheduleDelayedPrefetching(scheduleFn) {
+  if (false) return;
+  const lView = getLView();
+  const injector = lView[INJECTOR];
+  const tNode = getCurrentTNode();
+  const tView = lView[TVIEW];
+  const tDetails = getTDeferBlockDetails(tView, tNode);
+  if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
+    const lDetails = getLDeferBlockDetails(lView, tNode);
+    const prefetch = () => triggerPrefetching(tDetails, lView, tNode);
+    const cleanupFn = scheduleFn(prefetch, injector);
+    storeTriggerCleanupFn(1, lDetails, cleanupFn);
+  }
+}
+function scheduleDelayedHydrating(scheduleFn, lView, tNode) {
+  if (false) return;
+  const injector = lView[INJECTOR];
+  const lDetails = getLDeferBlockDetails(lView, tNode);
+  const ssrUniqueId = lDetails[SSR_UNIQUE_ID];
+  ngDevMode && assertSsrIdDefined(ssrUniqueId);
+  const cleanupFn = scheduleFn(() => triggerHydrationFromBlockName(injector, ssrUniqueId), injector);
+  storeTriggerCleanupFn(2, lDetails, cleanupFn);
+}
+function triggerPrefetching(tDetails, lView, tNode) {
+  triggerResourceLoading(tDetails, lView, tNode);
+}
+function triggerResourceLoading(tDetails, lView, tNode) {
+  const injector = lView[INJECTOR];
+  const tView = lView[TVIEW];
+  if (tDetails.loadingState !== DeferDependenciesLoadingState.NOT_STARTED) {
+    return tDetails.loadingPromise ?? Promise.resolve();
+  }
+  const lDetails = getLDeferBlockDetails(lView, tNode);
+  const primaryBlockTNode = getPrimaryBlockTNode(tView, tDetails);
+  tDetails.loadingState = DeferDependenciesLoadingState.IN_PROGRESS;
+  invokeTriggerCleanupFns(1, lDetails);
+  let dependenciesFn = tDetails.dependencyResolverFn;
+  if (ngDevMode) {
+    const deferDependencyInterceptor = injector.get(DEFER_BLOCK_DEPENDENCY_INTERCEPTOR, null, {
+      optional: true
+    });
+    if (deferDependencyInterceptor) {
+      dependenciesFn = deferDependencyInterceptor.intercept(dependenciesFn);
+    }
+  }
+  const removeTask = injector.get(PendingTasks).add();
+  if (!dependenciesFn) {
+    tDetails.loadingPromise = Promise.resolve().then(() => {
+      tDetails.loadingPromise = null;
+      tDetails.loadingState = DeferDependenciesLoadingState.COMPLETE;
+      removeTask();
+    });
+    return tDetails.loadingPromise;
+  }
+  tDetails.loadingPromise = Promise.allSettled(dependenciesFn()).then((results) => {
+    let failed = false;
+    let failedReason = null;
+    const directiveDefs = [];
+    const pipeDefs = [];
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i];
+      if (result.status === "fulfilled") {
+        const dependency = result.value;
+        const directiveDef = getComponentDef(dependency) || getDirectiveDef(dependency);
+        if (directiveDef) {
+          directiveDefs.push(directiveDef);
+        } else {
+          const pipeDef = getPipeDef(dependency);
+          if (pipeDef) {
+            pipeDefs.push(pipeDef);
+          }
+        }
+      } else {
+        failed = true;
+        failedReason = result.reason instanceof Error ? result.reason : new Error(String(result.reason));
+        break;
+      }
+    }
+    if (failed) {
+      tDetails.loadingState = DeferDependenciesLoadingState.FAILED;
+      if (tDetails.errorTmplIndex === null) {
+        const templateLocation = ngDevMode ? getTemplateLocationDetails(lView) : "";
+        let errorMsg = "";
+        if (ngDevMode) {
+          errorMsg = `Loading dependencies for \`@defer\` block failed, but no \`@error\` block was configured${templateLocation}. Consider using the \`@error\` block to render an error state.`;
+          const depsFn = tDetails.dependencyResolverFn;
+          const errorReason = failedReason?.message;
+          if (depsFn) {
+            errorMsg += `
+
+Angular tried to invoke the following dependency function (compiler-generated):
+\`\`\`
+${depsFn.toString()}
+\`\`\``;
+          }
+          if (errorReason) {
+            errorMsg += depsFn ? `
+
+but it resulted in the following error:
+
+${errorReason}` : `
+
+The loading resulted in the following error:
+
+${errorReason}`;
+          }
+        }
+        const error = new RuntimeError(-750, errorMsg);
+        handleUncaughtError(lView, error);
+      }
+    } else {
+      tDetails.loadingState = DeferDependenciesLoadingState.COMPLETE;
+      const primaryBlockTView = primaryBlockTNode.tView;
+      if (directiveDefs.length > 0) {
+        primaryBlockTView.directiveRegistry = addDepsToRegistry(primaryBlockTView.directiveRegistry, directiveDefs);
+        const directiveTypes = directiveDefs.map((def) => def.type);
+        const providers = internalImportProvidersFrom(false, ...directiveTypes);
+        tDetails.providers = providers;
+      }
+      if (pipeDefs.length > 0) {
+        primaryBlockTView.pipeRegistry = addDepsToRegistry(primaryBlockTView.pipeRegistry, pipeDefs);
+      }
+    }
+  });
+  return tDetails.loadingPromise.finally(() => {
+    tDetails.loadingPromise = null;
+    removeTask();
+  });
+}
+function shouldTriggerDeferBlock(triggerType, lView) {
+  if (triggerType === 0 && true && false) {
+    return false;
+  }
+  const injector = lView[INJECTOR];
+  const config2 = injector.get(DEFER_BLOCK_CONFIG, null, {
+    optional: true
+  });
+  if (config2?.behavior === DeferBlockBehavior.Manual) {
+    return false;
+  }
+  return true;
+}
+function triggerDeferBlock(triggerType, lView, tNode) {
+  const tView = lView[TVIEW];
+  const lContainer = lView[tNode.index];
+  ngDevMode && assertLContainer(lContainer);
+  if (!shouldTriggerDeferBlock(triggerType, lView)) return;
+  const lDetails = getLDeferBlockDetails(lView, tNode);
+  const tDetails = getTDeferBlockDetails(tView, tNode);
+  invokeAllTriggerCleanupFns(lDetails);
+  switch (tDetails.loadingState) {
+    case DeferDependenciesLoadingState.NOT_STARTED:
+      renderDeferBlockState(DeferBlockState.Loading, tNode, lContainer);
+      triggerResourceLoading(tDetails, lView, tNode);
+      if (tDetails.loadingState === DeferDependenciesLoadingState.IN_PROGRESS) {
+        renderDeferStateAfterResourceLoading(tDetails, tNode, lContainer);
+      }
+      break;
+    case DeferDependenciesLoadingState.IN_PROGRESS:
+      renderDeferBlockState(DeferBlockState.Loading, tNode, lContainer);
+      renderDeferStateAfterResourceLoading(tDetails, tNode, lContainer);
+      break;
+    case DeferDependenciesLoadingState.COMPLETE:
+      ngDevMode && assertDeferredDependenciesLoaded(tDetails);
+      renderDeferBlockState(DeferBlockState.Complete, tNode, lContainer);
+      break;
+    case DeferDependenciesLoadingState.FAILED:
+      renderDeferBlockState(DeferBlockState.Error, tNode, lContainer);
+      break;
+    default:
+      if (ngDevMode) {
+        throwError2("Unknown defer block state");
+      }
+  }
+}
+async function triggerHydrationFromBlockName(injector, blockName, replayQueuedEventsFn) {
+  const dehydratedBlockRegistry = injector.get(DEHYDRATED_BLOCK_REGISTRY);
+  const blocksBeingHydrated = dehydratedBlockRegistry.hydrating;
+  if (blocksBeingHydrated.has(blockName)) {
+    return;
+  }
+  const {
+    parentBlockPromise,
+    hydrationQueue
+  } = getParentBlockHydrationQueue(blockName, injector);
+  if (hydrationQueue.length === 0) return;
+  if (parentBlockPromise !== null) {
+    hydrationQueue.shift();
+  }
+  populateHydratingStateForQueue(dehydratedBlockRegistry, hydrationQueue);
+  if (parentBlockPromise !== null) {
+    await parentBlockPromise;
+  }
+  const topmostParentBlock = hydrationQueue[0];
+  if (dehydratedBlockRegistry.has(topmostParentBlock)) {
+    await triggerHydrationForBlockQueue(injector, hydrationQueue, replayQueuedEventsFn);
+  } else {
+    dehydratedBlockRegistry.awaitParentBlock(topmostParentBlock, async () => await triggerHydrationForBlockQueue(injector, hydrationQueue, replayQueuedEventsFn));
+  }
+}
+async function triggerHydrationForBlockQueue(injector, hydrationQueue, replayQueuedEventsFn) {
+  const dehydratedBlockRegistry = injector.get(DEHYDRATED_BLOCK_REGISTRY);
+  const blocksBeingHydrated = dehydratedBlockRegistry.hydrating;
+  const pendingTasks = injector.get(PendingTasksInternal);
+  const taskId = pendingTasks.add();
+  for (let blockQueueIdx = 0; blockQueueIdx < hydrationQueue.length; blockQueueIdx++) {
+    const dehydratedBlockId = hydrationQueue[blockQueueIdx];
+    const dehydratedDeferBlock = dehydratedBlockRegistry.get(dehydratedBlockId);
+    if (dehydratedDeferBlock != null) {
+      await triggerResourceLoadingForHydration(dehydratedDeferBlock);
+      await nextRender(injector);
+      if (deferBlockHasErrored(dehydratedDeferBlock)) {
+        removeDehydratedViewList(dehydratedDeferBlock);
+        cleanupRemainingHydrationQueue(hydrationQueue.slice(blockQueueIdx), dehydratedBlockRegistry);
+        break;
+      }
+      blocksBeingHydrated.get(dehydratedBlockId).resolve();
+    } else {
+      cleanupParentContainer(blockQueueIdx, hydrationQueue, dehydratedBlockRegistry);
+      cleanupRemainingHydrationQueue(hydrationQueue.slice(blockQueueIdx), dehydratedBlockRegistry);
+      break;
+    }
+  }
+  const lastBlockName = hydrationQueue[hydrationQueue.length - 1];
+  await blocksBeingHydrated.get(lastBlockName)?.promise;
+  pendingTasks.remove(taskId);
+  if (replayQueuedEventsFn) {
+    replayQueuedEventsFn(hydrationQueue);
+  }
+  cleanupHydratedDeferBlocks(dehydratedBlockRegistry.get(lastBlockName), hydrationQueue, dehydratedBlockRegistry, injector.get(ApplicationRef));
+}
+function deferBlockHasErrored(deferBlock) {
+  return getLDeferBlockDetails(deferBlock.lView, deferBlock.tNode)[DEFER_BLOCK_STATE] === DeferBlockState.Error;
+}
+function cleanupParentContainer(currentBlockIdx, hydrationQueue, dehydratedBlockRegistry) {
+  const parentDeferBlockIdx = currentBlockIdx - 1;
+  const parentDeferBlock = parentDeferBlockIdx > -1 ? dehydratedBlockRegistry.get(hydrationQueue[parentDeferBlockIdx]) : null;
+  if (parentDeferBlock) {
+    cleanupLContainer(parentDeferBlock.lContainer);
+  }
+}
+function cleanupRemainingHydrationQueue(hydrationQueue, dehydratedBlockRegistry) {
+  const blocksBeingHydrated = dehydratedBlockRegistry.hydrating;
+  for (const dehydratedBlockId in hydrationQueue) {
+    blocksBeingHydrated.get(dehydratedBlockId)?.reject();
+  }
+  dehydratedBlockRegistry.cleanup(hydrationQueue);
+}
+function populateHydratingStateForQueue(registry, queue) {
+  for (let blockId of queue) {
+    registry.hydrating.set(blockId, promiseWithResolvers());
+  }
+}
+function nextRender(injector) {
+  return new Promise((resolveFn) => afterNextRender(resolveFn, {
+    injector
+  }));
+}
+async function triggerResourceLoadingForHydration(dehydratedBlock) {
+  const {
+    tNode,
+    lView
+  } = dehydratedBlock;
+  const lDetails = getLDeferBlockDetails(lView, tNode);
+  return new Promise((resolve) => {
+    onDeferBlockCompletion(lDetails, resolve);
+    triggerDeferBlock(2, lView, tNode);
+  });
+}
+function onDeferBlockCompletion(lDetails, callback) {
+  if (!Array.isArray(lDetails[ON_COMPLETE_FNS])) {
+    lDetails[ON_COMPLETE_FNS] = [];
+  }
+  lDetails[ON_COMPLETE_FNS].push(callback);
+}
+function shouldAttachTrigger(triggerType, lView, tNode) {
+  if (triggerType === 0) {
+    return shouldAttachRegularTrigger(lView, tNode);
+  } else if (triggerType === 2) {
+    return !shouldAttachRegularTrigger(lView, tNode);
+  }
+  return true;
+}
+function hasHydrateTriggers(flags) {
+  return flags != null && (flags & 1) === 1;
+}
+function shouldAttachRegularTrigger(lView, tNode) {
+  const injector = lView[INJECTOR];
+  const tDetails = getTDeferBlockDetails(lView[TVIEW], tNode);
+  const incrementalHydrationEnabled = isIncrementalHydrationEnabled(injector);
+  const _hasHydrateTriggers = hasHydrateTriggers(tDetails.flags);
+  if (false) {
+    return !incrementalHydrationEnabled || !_hasHydrateTriggers;
+  }
+  const lDetails = getLDeferBlockDetails(lView, tNode);
+  const wasServerSideRendered = lDetails[SSR_UNIQUE_ID] !== null;
+  if (_hasHydrateTriggers && wasServerSideRendered && incrementalHydrationEnabled) {
+    return false;
+  }
+  return true;
+}
+function getHydrateTriggers(tView, tNode) {
+  const tDetails = getTDeferBlockDetails(tView, tNode);
+  return tDetails.hydrateTriggers ??= /* @__PURE__ */ new Map();
+}
+function \u0275\u0275defer(index, primaryTmplIndex, dependencyResolverFn, loadingTmplIndex, placeholderTmplIndex, errorTmplIndex, loadingConfigIndex, placeholderConfigIndex, enableTimerScheduling, flags) {
+  const lView = getLView();
+  const tView = getTView();
+  const adjustedIndex = index + HEADER_OFFSET;
+  const tNode = declareNoDirectiveHostTemplate(lView, tView, index, null, 0, 0);
+  const injector = lView[INJECTOR];
+  const incrementalHydrationEnabled = isIncrementalHydrationEnabled(injector);
+  if (tView.firstCreatePass) {
+    performanceMarkFeature("NgDefer");
+    if (ngDevMode) {
+      if (false) {
+        logHmrWarning(injector);
+      }
+      if (hasHydrateTriggers(flags) && !incrementalHydrationEnabled) {
+        warnIncrementalHydrationNotConfigured();
+      }
+    }
+    const tDetails = {
+      primaryTmplIndex,
+      loadingTmplIndex: loadingTmplIndex ?? null,
+      placeholderTmplIndex: placeholderTmplIndex ?? null,
+      errorTmplIndex: errorTmplIndex ?? null,
+      placeholderBlockConfig: null,
+      loadingBlockConfig: null,
+      dependencyResolverFn: dependencyResolverFn ?? null,
+      loadingState: DeferDependenciesLoadingState.NOT_STARTED,
+      loadingPromise: null,
+      providers: null,
+      hydrateTriggers: null,
+      debug: null,
+      flags: flags ?? 0
+    };
+    enableTimerScheduling?.(tView, tDetails, placeholderConfigIndex, loadingConfigIndex);
+    setTDeferBlockDetails(tView, adjustedIndex, tDetails);
+  }
+  const lContainer = lView[adjustedIndex];
+  populateDehydratedViewsInLContainer(lContainer, tNode, lView);
+  let ssrBlockState = null;
+  let ssrUniqueId = null;
+  if (lContainer[DEHYDRATED_VIEWS]?.length > 0) {
+    const info = lContainer[DEHYDRATED_VIEWS][0].data;
+    ssrUniqueId = info[DEFER_BLOCK_ID] ?? null;
+    ssrBlockState = info[DEFER_BLOCK_STATE$1];
+  }
+  const lDetails = [null, DeferBlockInternalState.Initial, null, null, null, null, ssrUniqueId, ssrBlockState, null, null];
+  setLDeferBlockDetails(lView, adjustedIndex, lDetails);
+  let registry = null;
+  if (ssrUniqueId !== null && incrementalHydrationEnabled) {
+    registry = injector.get(DEHYDRATED_BLOCK_REGISTRY);
+    registry.add(ssrUniqueId, {
+      lView,
+      tNode,
+      lContainer
+    });
+  }
+  const onLViewDestroy = () => {
+    invokeAllTriggerCleanupFns(lDetails);
+    if (ssrUniqueId !== null) {
+      registry?.cleanup([ssrUniqueId]);
+    }
+  };
+  storeTriggerCleanupFn(0, lDetails, () => removeLViewOnDestroy(lView, onLViewDestroy));
+  storeLViewOnDestroy(lView, onLViewDestroy);
+}
+function \u0275\u0275deferWhen(rawValue) {
+  const lView = getLView();
+  const tNode = getSelectedTNode();
+  if (ngDevMode) {
+    trackTriggerForDebugging(lView[TVIEW], tNode, "when <expression>");
+  }
+  if (!shouldAttachTrigger(0, lView, tNode)) return;
+  const bindingIndex = nextBindingIndex();
+  if (bindingUpdated(lView, bindingIndex, rawValue)) {
+    const prevConsumer = setActiveConsumer(null);
+    try {
+      const value = Boolean(rawValue);
+      const lDetails = getLDeferBlockDetails(lView, tNode);
+      const renderedState = lDetails[DEFER_BLOCK_STATE];
+      if (value === false && renderedState === DeferBlockInternalState.Initial) {
+        renderPlaceholder(lView, tNode);
+      } else if (value === true && (renderedState === DeferBlockInternalState.Initial || renderedState === DeferBlockState.Placeholder)) {
+        triggerDeferBlock(0, lView, tNode);
+      }
+    } finally {
+      setActiveConsumer(prevConsumer);
+    }
+  }
+}
+function \u0275\u0275deferPrefetchWhen(rawValue) {
+  const lView = getLView();
+  const tNode = getSelectedTNode();
+  if (ngDevMode) {
+    trackTriggerForDebugging(lView[TVIEW], tNode, "prefetch when <expression>");
+  }
+  if (!shouldAttachTrigger(1, lView, tNode)) return;
+  const bindingIndex = nextBindingIndex();
+  if (bindingUpdated(lView, bindingIndex, rawValue)) {
+    const prevConsumer = setActiveConsumer(null);
+    try {
+      const value = Boolean(rawValue);
+      const tView = lView[TVIEW];
+      const tDetails = getTDeferBlockDetails(tView, tNode);
+      if (value === true && tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
+        triggerPrefetching(tDetails, lView, tNode);
+      }
+    } finally {
+      setActiveConsumer(prevConsumer);
+    }
+  }
+}
+function \u0275\u0275deferHydrateWhen(rawValue) {
+  const lView = getLView();
+  const tNode = getSelectedTNode();
+  if (ngDevMode) {
+    trackTriggerForDebugging(lView[TVIEW], tNode, "hydrate when <expression>");
+  }
+  if (!shouldAttachTrigger(2, lView, tNode)) return;
+  const bindingIndex = nextBindingIndex();
+  const tView = getTView();
+  const hydrateTriggers = getHydrateTriggers(tView, tNode);
+  hydrateTriggers.set(6, null);
+  if (bindingUpdated(lView, bindingIndex, rawValue)) {
+    if (false) {
+      triggerDeferBlock(2, lView, tNode);
+    } else {
+      const injector = lView[INJECTOR];
+      const prevConsumer = setActiveConsumer(null);
+      try {
+        const value = Boolean(rawValue);
+        if (value === true) {
+          const lDetails = getLDeferBlockDetails(lView, tNode);
+          const ssrUniqueId = lDetails[SSR_UNIQUE_ID];
+          ngDevMode && assertSsrIdDefined(ssrUniqueId);
+          triggerHydrationFromBlockName(injector, ssrUniqueId);
+        }
+      } finally {
+        setActiveConsumer(prevConsumer);
+      }
+    }
+  }
+}
+function \u0275\u0275deferHydrateNever() {
+  const lView = getLView();
+  const tNode = getCurrentTNode();
+  if (ngDevMode) {
+    trackTriggerForDebugging(lView[TVIEW], tNode, "hydrate never");
+  }
+  if (!shouldAttachTrigger(2, lView, tNode)) return;
+  const hydrateTriggers = getHydrateTriggers(getTView(), tNode);
+  hydrateTriggers.set(7, null);
+  if (false) {
+    triggerDeferBlock(2, lView, tNode);
+  }
+}
+function \u0275\u0275deferOnIdle() {
+  const lView = getLView();
+  const tNode = getCurrentTNode();
+  if (ngDevMode) {
+    trackTriggerForDebugging(lView[TVIEW], tNode, "on idle");
+  }
+  if (!shouldAttachTrigger(0, lView, tNode)) return;
+  scheduleDelayedTrigger(onIdle);
+}
+function \u0275\u0275deferPrefetchOnIdle() {
+  const lView = getLView();
+  const tNode = getCurrentTNode();
+  if (ngDevMode) {
+    trackTriggerForDebugging(lView[TVIEW], tNode, "prefetch on idle");
+  }
+  if (!shouldAttachTrigger(1, lView, tNode)) return;
+  scheduleDelayedPrefetching(onIdle);
+}
+function \u0275\u0275deferHydrateOnIdle() {
+  const lView = getLView();
+  const tNode = getCurrentTNode();
+  if (ngDevMode) {
+    trackTriggerForDebugging(lView[TVIEW], tNode, "hydrate on idle");
+  }
+  if (!shouldAttachTrigger(2, lView, tNode)) return;
+  const hydrateTriggers = getHydrateTriggers(getTView(), tNode);
+  hydrateTriggers.set(0, null);
+  if (false) {
+    triggerDeferBlock(2, lView, tNode);
+  } else {
+    scheduleDelayedHydrating(onIdle, lView, tNode);
+  }
+}
+function \u0275\u0275deferOnImmediate() {
+  const lView = getLView();
+  const tNode = getCurrentTNode();
+  if (ngDevMode) {
+    trackTriggerForDebugging(lView[TVIEW], tNode, "on immediate");
+  }
+  if (!shouldAttachTrigger(0, lView, tNode)) return;
+  const tDetails = getTDeferBlockDetails(lView[TVIEW], tNode);
+  if (tDetails.loadingTmplIndex === null) {
+    renderPlaceholder(lView, tNode);
+  }
+  triggerDeferBlock(0, lView, tNode);
+}
+function \u0275\u0275deferPrefetchOnImmediate() {
+  const lView = getLView();
+  const tNode = getCurrentTNode();
+  if (ngDevMode) {
+    trackTriggerForDebugging(lView[TVIEW], tNode, "prefetch on immediate");
+  }
+  if (!shouldAttachTrigger(1, lView, tNode)) return;
+  const tView = lView[TVIEW];
+  const tDetails = getTDeferBlockDetails(tView, tNode);
+  if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
+    triggerResourceLoading(tDetails, lView, tNode);
+  }
+}
+function \u0275\u0275deferHydrateOnImmediate() {
+  const lView = getLView();
+  const tNode = getCurrentTNode();
+  if (ngDevMode) {
+    trackTriggerForDebugging(lView[TVIEW], tNode, "hydrate on immediate");
+  }
+  if (!shouldAttachTrigger(2, lView, tNode)) return;
+  const hydrateTriggers = getHydrateTriggers(getTView(), tNode);
+  hydrateTriggers.set(1, null);
+  if (false) {
+    triggerDeferBlock(2, lView, tNode);
+  } else {
+    const injector = lView[INJECTOR];
+    const lDetails = getLDeferBlockDetails(lView, tNode);
+    const ssrUniqueId = lDetails[SSR_UNIQUE_ID];
+    ngDevMode && assertSsrIdDefined(ssrUniqueId);
+    triggerHydrationFromBlockName(injector, ssrUniqueId);
+  }
+}
+function \u0275\u0275deferOnTimer(delay) {
+  const lView = getLView();
+  const tNode = getCurrentTNode();
+  if (ngDevMode) {
+    trackTriggerForDebugging(lView[TVIEW], tNode, `on timer(${delay}ms)`);
+  }
+  if (!shouldAttachTrigger(0, lView, tNode)) return;
+  scheduleDelayedTrigger(onTimer(delay));
+}
+function \u0275\u0275deferPrefetchOnTimer(delay) {
+  const lView = getLView();
+  const tNode = getCurrentTNode();
+  if (ngDevMode) {
+    trackTriggerForDebugging(lView[TVIEW], tNode, `prefetch on timer(${delay}ms)`);
+  }
+  if (!shouldAttachTrigger(1, lView, tNode)) return;
+  scheduleDelayedPrefetching(onTimer(delay));
+}
+function \u0275\u0275deferHydrateOnTimer(delay) {
+  const lView = getLView();
+  const tNode = getCurrentTNode();
+  if (ngDevMode) {
+    trackTriggerForDebugging(lView[TVIEW], tNode, `hydrate on timer(${delay}ms)`);
+  }
+  if (!shouldAttachTrigger(2, lView, tNode)) return;
+  const hydrateTriggers = getHydrateTriggers(getTView(), tNode);
+  hydrateTriggers.set(5, {
+    type: 5,
+    delay
+  });
+  if (false) {
+    triggerDeferBlock(2, lView, tNode);
+  } else {
+    scheduleDelayedHydrating(onTimer(delay), lView, tNode);
+  }
+}
+function \u0275\u0275deferOnHover(triggerIndex, walkUpTimes) {
+  const lView = getLView();
+  const tNode = getCurrentTNode();
+  if (ngDevMode) {
+    trackTriggerForDebugging(lView[TVIEW], tNode, `on hover${walkUpTimes === -1 ? "" : "(<target>)"}`);
+  }
+  if (!shouldAttachTrigger(0, lView, tNode)) return;
+  renderPlaceholder(lView, tNode);
+  if (true) {
+    registerDomTrigger(lView, tNode, triggerIndex, walkUpTimes, onHover, () => triggerDeferBlock(0, lView, tNode), 0);
+  }
+}
+function \u0275\u0275deferPrefetchOnHover(triggerIndex, walkUpTimes) {
+  const lView = getLView();
+  const tNode = getCurrentTNode();
+  if (ngDevMode) {
+    trackTriggerForDebugging(lView[TVIEW], tNode, `prefetch on hover${walkUpTimes === -1 ? "" : "(<target>)"}`);
+  }
+  if (!shouldAttachTrigger(1, lView, tNode)) return;
+  const tView = lView[TVIEW];
+  const tDetails = getTDeferBlockDetails(tView, tNode);
+  if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
+    registerDomTrigger(lView, tNode, triggerIndex, walkUpTimes, onHover, () => triggerPrefetching(tDetails, lView, tNode), 1);
+  }
+}
+function \u0275\u0275deferHydrateOnHover() {
+  const lView = getLView();
+  const tNode = getCurrentTNode();
+  if (ngDevMode) {
+    trackTriggerForDebugging(lView[TVIEW], tNode, "hydrate on hover");
+  }
+  if (!shouldAttachTrigger(2, lView, tNode)) return;
+  const hydrateTriggers = getHydrateTriggers(getTView(), tNode);
+  hydrateTriggers.set(4, null);
+  if (false) {
+    triggerDeferBlock(2, lView, tNode);
+  }
+}
+function \u0275\u0275deferOnInteraction(triggerIndex, walkUpTimes) {
+  const lView = getLView();
+  const tNode = getCurrentTNode();
+  if (ngDevMode) {
+    trackTriggerForDebugging(lView[TVIEW], tNode, `on interaction${walkUpTimes === -1 ? "" : "(<target>)"}`);
+  }
+  if (!shouldAttachTrigger(0, lView, tNode)) return;
+  renderPlaceholder(lView, tNode);
+  if (true) {
+    registerDomTrigger(lView, tNode, triggerIndex, walkUpTimes, onInteraction, () => triggerDeferBlock(0, lView, tNode), 0);
+  }
+}
+function \u0275\u0275deferPrefetchOnInteraction(triggerIndex, walkUpTimes) {
+  const lView = getLView();
+  const tNode = getCurrentTNode();
+  if (ngDevMode) {
+    trackTriggerForDebugging(lView[TVIEW], tNode, `prefetch on interaction${walkUpTimes === -1 ? "" : "(<target>)"}`);
+  }
+  if (!shouldAttachTrigger(1, lView, tNode)) return;
+  const tView = lView[TVIEW];
+  const tDetails = getTDeferBlockDetails(tView, tNode);
+  if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
+    registerDomTrigger(lView, tNode, triggerIndex, walkUpTimes, onInteraction, () => triggerPrefetching(tDetails, lView, tNode), 1);
+  }
+}
+function \u0275\u0275deferHydrateOnInteraction() {
+  const lView = getLView();
+  const tNode = getCurrentTNode();
+  if (ngDevMode) {
+    trackTriggerForDebugging(lView[TVIEW], tNode, "hydrate on interaction");
+  }
+  if (!shouldAttachTrigger(2, lView, tNode)) return;
+  const hydrateTriggers = getHydrateTriggers(getTView(), tNode);
+  hydrateTriggers.set(3, null);
+  if (false) {
+    triggerDeferBlock(2, lView, tNode);
+  }
+}
+function \u0275\u0275deferOnViewport(triggerIndex, walkUpTimes, options) {
+  const lView = getLView();
+  const tNode = getCurrentTNode();
+  if (ngDevMode) {
+    const args = [];
+    if (walkUpTimes !== void 0 && walkUpTimes !== -1) {
+      args.push("<target>");
+    }
+    if (options) {
+      args.push(JSON.stringify(options));
+    }
+    trackTriggerForDebugging(lView[TVIEW], tNode, `on viewport${args.length === 0 ? "" : `(${args.join(", ")})`}`);
+  }
+  if (!shouldAttachTrigger(0, lView, tNode)) return;
+  renderPlaceholder(lView, tNode);
+  if (true) {
+    registerDomTrigger(lView, tNode, triggerIndex, walkUpTimes, onViewportWrapper, () => triggerDeferBlock(0, lView, tNode), 0, options);
+  }
+}
+function \u0275\u0275deferPrefetchOnViewport(triggerIndex, walkUpTimes, options) {
+  const lView = getLView();
+  const tNode = getCurrentTNode();
+  if (ngDevMode) {
+    const args = [];
+    if (walkUpTimes !== void 0 && walkUpTimes !== -1) {
+      args.push("<target>");
+    }
+    if (options) {
+      args.push(JSON.stringify(options));
+    }
+    trackTriggerForDebugging(lView[TVIEW], tNode, `prefetch on viewport${args.length === 0 ? "" : `(${args.join(", ")})`}`);
+  }
+  if (!shouldAttachTrigger(1, lView, tNode)) return;
+  const tView = lView[TVIEW];
+  const tDetails = getTDeferBlockDetails(tView, tNode);
+  if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
+    registerDomTrigger(lView, tNode, triggerIndex, walkUpTimes, onViewportWrapper, () => triggerPrefetching(tDetails, lView, tNode), 1, options);
+  }
+}
+function \u0275\u0275deferHydrateOnViewport(options) {
+  const lView = getLView();
+  const tNode = getCurrentTNode();
+  if (ngDevMode) {
+    trackTriggerForDebugging(lView[TVIEW], tNode, `hydrate on viewport${options ? `(${JSON.stringify(options)})` : ""}`);
+  }
+  if (!shouldAttachTrigger(2, lView, tNode)) return;
+  const hydrateTriggers = getHydrateTriggers(getTView(), tNode);
+  hydrateTriggers.set(2, options ? {
+    type: 2,
+    intersectionObserverOptions: options
+  } : null);
+  if (false) {
+    triggerDeferBlock(2, lView, tNode);
+  }
+}
+function \u0275\u0275ariaProperty(name, value) {
+  const lView = getLView();
+  const bindingIndex = nextBindingIndex();
+  if (bindingUpdated(lView, bindingIndex, value)) {
+    const tView = getTView();
+    const tNode = getSelectedTNode();
+    const hasSetInput = setAllInputsForProperty(tNode, tView, lView, name, value);
+    if (hasSetInput) {
+      isComponentHost(tNode) && markDirtyIfOnPush(lView, tNode.index);
+      ngDevMode && setNgReflectProperties(lView, tView, tNode, name, value);
+    } else {
+      ngDevMode && assertTNodeType(tNode, 2);
+      const element = getNativeByTNode(tNode, lView);
+      setElementAttribute(lView[RENDERER], element, null, tNode.value, name, value, null);
+    }
+    ngDevMode && storePropertyBindingMetadata(tView.data, tNode, name, bindingIndex);
+  }
+  return \u0275\u0275ariaProperty;
+}
+function \u0275\u0275attribute(name, value, sanitizer, namespace) {
+  const lView = getLView();
+  const bindingIndex = nextBindingIndex();
+  if (bindingUpdated(lView, bindingIndex, value)) {
+    const tView = getTView();
+    const tNode = getSelectedTNode();
+    elementAttributeInternal(tNode, lView, name, value, sanitizer, namespace);
+    ngDevMode && storePropertyBindingMetadata(tView.data, tNode, "attr." + name, bindingIndex);
+  }
+  return \u0275\u0275attribute;
+}
+function \u0275\u0275animateEnter(value) {
+  performanceMarkFeature("NgAnimateEnter");
+  if (!areAnimationSupported) {
+    return \u0275\u0275animateEnter;
+  }
+  ngDevMode && assertAnimationTypes(value, "animate.enter");
+  const lView = getLView();
+  if (areAnimationsDisabled(lView)) {
+    return \u0275\u0275animateEnter;
+  }
+  const tNode = getCurrentTNode();
+  const ngZone = lView[INJECTOR].get(NgZone);
+  addAnimationToLView(getLViewEnterAnimations(lView), tNode, () => runEnterAnimation(lView, tNode, value, ngZone));
+  initializeAnimationQueueScheduler(lView[INJECTOR]);
+  queueEnterAnimations(lView[INJECTOR], getLViewEnterAnimations(lView));
+  return \u0275\u0275animateEnter;
+}
+function runEnterAnimation(lView, tNode, value, ngZone) {
+  const nativeElement = getNativeByTNode(tNode, lView);
+  ngDevMode && assertElementNodes(nativeElement, "animate.enter");
+  const renderer = lView[RENDERER];
+  const activeClasses = getClassListFromValue(value);
+  const cleanupFns = [];
+  let hasCompleted = false;
+  const handleEnterAnimationStart = (event) => {
+    if (getEventTarget(event) !== nativeElement) return;
+    const eventName = event instanceof AnimationEvent ? "animationend" : "transitionend";
+    ngZone.runOutsideAngular(() => {
+      renderer.listen(nativeElement, eventName, handleEnterAnimationEnd);
+    });
+  };
+  const handleEnterAnimationEnd = (event) => {
+    if (getEventTarget(event) !== nativeElement) return;
+    if (isLongestAnimation(event, nativeElement)) {
+      hasCompleted = true;
+    }
+    enterAnimationEnd(event, nativeElement, renderer);
+  };
+  if (activeClasses && activeClasses.length > 0) {
+    ngZone.runOutsideAngular(() => {
+      cleanupFns.push(renderer.listen(nativeElement, "animationstart", handleEnterAnimationStart));
+      cleanupFns.push(renderer.listen(nativeElement, "transitionstart", handleEnterAnimationStart));
+    });
+    trackEnterClasses(nativeElement, activeClasses, cleanupFns);
+    for (const klass of activeClasses) {
+      renderer.addClass(nativeElement, klass);
+    }
+    ngZone.runOutsideAngular(() => {
+      requestAnimationFrame(() => {
+        if (hasCompleted) return;
+        determineLongestAnimation(nativeElement, longestAnimations, areAnimationSupported);
+        if (!longestAnimations.has(nativeElement)) {
+          for (const klass of activeClasses) {
+            renderer.removeClass(nativeElement, klass);
+          }
+          cleanupEnterClassData(nativeElement);
+        }
+      });
+    });
+  }
+}
+function enterAnimationEnd(event, nativeElement, renderer) {
+  const elementData = enterClassMap.get(nativeElement);
+  if (getEventTarget(event) !== nativeElement || !elementData) return;
+  if (isLongestAnimation(event, nativeElement)) {
+    event.stopPropagation();
+    for (const klass of elementData.classList) {
+      renderer.removeClass(nativeElement, klass);
+    }
+    cleanupEnterClassData(nativeElement);
+  }
+}
+function \u0275\u0275animateEnterListener(value) {
+  performanceMarkFeature("NgAnimateEnter");
+  if (!areAnimationSupported) {
+    return \u0275\u0275animateEnterListener;
+  }
+  ngDevMode && assertAnimationTypes(value, "animate.enter");
+  const lView = getLView();
+  if (areAnimationsDisabled(lView)) {
+    return \u0275\u0275animateEnterListener;
+  }
+  const tNode = getCurrentTNode();
+  addAnimationToLView(getLViewEnterAnimations(lView), tNode, () => runEnterAnimationFunction(lView, tNode, value));
+  initializeAnimationQueueScheduler(lView[INJECTOR]);
+  queueEnterAnimations(lView[INJECTOR], getLViewEnterAnimations(lView));
+  return \u0275\u0275animateEnterListener;
+}
+function runEnterAnimationFunction(lView, tNode, value) {
+  const nativeElement = getNativeByTNode(tNode, lView);
+  ngDevMode && assertElementNodes(nativeElement, "animate.enter");
+  value.call(lView[CONTEXT], {
+    target: nativeElement,
+    animationComplete: noOpAnimationComplete
+  });
+}
+function \u0275\u0275animateLeave(value) {
+  performanceMarkFeature("NgAnimateLeave");
+  if (!areAnimationSupported) {
+    return \u0275\u0275animateLeave;
+  }
+  ngDevMode && assertAnimationTypes(value, "animate.leave");
+  const lView = getLView();
+  const animationsDisabled = areAnimationsDisabled(lView);
+  if (animationsDisabled) {
+    return \u0275\u0275animateLeave;
+  }
+  const tNode = getCurrentTNode();
+  const ngZone = lView[INJECTOR].get(NgZone);
+  addAnimationToLView(getLViewLeaveAnimations(lView), tNode, () => runLeaveAnimations(lView, tNode, value, ngZone));
+  initializeAnimationQueueScheduler(lView[INJECTOR]);
+  return \u0275\u0275animateLeave;
+}
+function runLeaveAnimations(lView, tNode, value, ngZone) {
+  const {
+    promise,
+    resolve
+  } = promiseWithResolvers();
+  const nativeElement = getNativeByTNode(tNode, lView);
+  ngDevMode && assertElementNodes(nativeElement, "animate.leave");
+  const renderer = lView[RENDERER];
+  allLeavingAnimations.add(lView[ID]);
+  (getLViewLeaveAnimations(lView).get(tNode.index).resolvers ??= []).push(resolve);
+  const activeClasses = getClassListFromValue(value);
+  if (activeClasses && activeClasses.length > 0) {
+    animateLeaveClassRunner(nativeElement, tNode, lView, activeClasses, renderer, ngZone);
+  } else {
+    resolve();
+  }
+  return {
+    promise,
+    resolve
+  };
+}
+function animateLeaveClassRunner(el, tNode, lView, classList, renderer, ngZone) {
+  cancelAnimationsIfRunning(el, renderer);
+  const cleanupFns = [];
+  const componentResolvers = getLViewLeaveAnimations(lView).get(tNode.index)?.resolvers;
+  let fallbackTimeoutId;
+  let hasCompleted = false;
+  const handleOutAnimationEnd = (event) => {
+    const target = getEventTarget(event);
+    if (target !== el && event.type !== "animation-fallback") return;
+    if (event.type === "animation-fallback" || isLongestAnimation(event, el)) {
+      hasCompleted = true;
+      if (fallbackTimeoutId) clearTimeout(fallbackTimeoutId);
+      if (event.type !== "animation-fallback") event.stopPropagation();
+      longestAnimations.delete(el);
+      clearLeavingNodes(tNode, el);
+      if (Array.isArray(tNode.projection)) {
+        for (const item of classList) {
+          renderer.removeClass(el, item);
+        }
+      }
+      cleanupAfterLeaveAnimations(componentResolvers, cleanupFns);
+      clearLViewNodeAnimationResolvers(lView, tNode);
+    }
+  };
+  ngZone.runOutsideAngular(() => {
+    cleanupFns.push(renderer.listen(el, "animationend", handleOutAnimationEnd));
+    cleanupFns.push(renderer.listen(el, "transitionend", handleOutAnimationEnd));
+  });
+  trackLeavingNodes(tNode, el);
+  for (const item of classList) {
+    renderer.addClass(el, item);
+  }
+  ngZone.runOutsideAngular(() => {
+    requestAnimationFrame(() => {
+      if (hasCompleted) return;
+      determineLongestAnimation(el, longestAnimations, areAnimationSupported);
+      const longest = longestAnimations.get(el);
+      if (!longest) {
+        clearLeavingNodes(tNode, el);
+        cleanupAfterLeaveAnimations(componentResolvers, cleanupFns);
+        clearLViewNodeAnimationResolvers(lView, tNode);
+      } else {
+        fallbackTimeoutId = setTimeout(() => {
+          handleOutAnimationEnd(new CustomEvent("animation-fallback"));
+        }, longest.duration + 50);
+        cleanupFns.push(() => clearTimeout(fallbackTimeoutId));
+      }
+    });
+  });
+}
+function \u0275\u0275animateLeaveListener(value) {
+  performanceMarkFeature("NgAnimateLeave");
+  if (!areAnimationSupported) {
+    return \u0275\u0275animateLeaveListener;
+  }
+  ngDevMode && assertAnimationTypes(value, "animate.leave");
+  const lView = getLView();
+  const tNode = getCurrentTNode();
+  allLeavingAnimations.add(lView[ID]);
+  const ngZone = lView[INJECTOR].get(NgZone);
+  const maxAnimationTimeout = lView[INJECTOR].get(MAX_ANIMATION_TIMEOUT);
+  addAnimationToLView(getLViewLeaveAnimations(lView), tNode, () => runLeaveAnimationFunction(lView, tNode, value, ngZone, maxAnimationTimeout));
+  initializeAnimationQueueScheduler(lView[INJECTOR]);
+  return \u0275\u0275animateLeaveListener;
+}
+function runLeaveAnimationFunction(lView, tNode, value, ngZone, maxAnimationTimeout) {
+  const {
+    promise,
+    resolve
+  } = promiseWithResolvers();
+  const nativeElement = getNativeByTNode(tNode, lView);
+  ngDevMode && assertElementNodes(nativeElement, "animate.leave");
+  const cleanupFns = [];
+  const renderer = lView[RENDERER];
+  const animationsDisabled = areAnimationsDisabled(lView);
+  (getLViewLeaveAnimations(lView).get(tNode.index).resolvers ??= []).push(resolve);
+  const resolvers = getLViewLeaveAnimations(lView).get(tNode.index)?.resolvers;
+  if (animationsDisabled) {
+    leaveAnimationFunctionCleanup(lView, tNode, nativeElement, resolvers, cleanupFns);
+  } else {
+    const timeoutId = setTimeout(() => leaveAnimationFunctionCleanup(lView, tNode, nativeElement, resolvers, cleanupFns), maxAnimationTimeout);
+    const event = {
+      target: nativeElement,
+      animationComplete: () => {
+        leaveAnimationFunctionCleanup(lView, tNode, nativeElement, resolvers, cleanupFns);
+        clearTimeout(timeoutId);
+      }
+    };
+    trackLeavingNodes(tNode, nativeElement);
+    ngZone.runOutsideAngular(() => {
+      cleanupFns.push(renderer.listen(nativeElement, "animationend", () => {
+        leaveAnimationFunctionCleanup(lView, tNode, nativeElement, resolvers, cleanupFns);
+        clearTimeout(timeoutId);
+      }, {
+        once: true
+      }));
+    });
+    value.call(lView[CONTEXT], event);
+  }
+  return {
+    promise,
+    resolve
+  };
+}
+function \u0275\u0275componentInstance() {
+  const instance = getLView()[DECLARATION_COMPONENT_VIEW][CONTEXT];
+  ngDevMode && assertDefined(instance, "Expected component instance to be defined");
+  return instance;
+}
+var LiveCollection = class {
+  destroy(item) {
+  }
+  updateValue(index, value) {
+  }
+  swap(index1, index2) {
+    const startIdx = Math.min(index1, index2);
+    const endIdx = Math.max(index1, index2);
+    const endItem = this.detach(endIdx);
+    if (endIdx - startIdx > 1) {
+      const startItem = this.detach(startIdx);
+      this.attach(startIdx, endItem);
+      this.attach(endIdx, startItem);
+    } else {
+      this.attach(startIdx, endItem);
+    }
+  }
+  move(prevIndex, newIdx) {
+    this.attach(newIdx, this.detach(prevIndex));
+  }
+};
+function valuesMatching(liveIdx, liveValue, newIdx, newValue, trackBy) {
+  if (liveIdx === newIdx && Object.is(liveValue, newValue)) {
+    return 1;
+  } else if (Object.is(trackBy(liveIdx, liveValue), trackBy(newIdx, newValue))) {
+    return -1;
+  }
+  return 0;
+}
+function recordDuplicateKeys(keyToIdx, key, idx) {
+  const idxSoFar = keyToIdx.get(key);
+  if (idxSoFar !== void 0) {
+    idxSoFar.add(idx);
+  } else {
+    keyToIdx.set(key, /* @__PURE__ */ new Set([idx]));
+  }
+}
+function reconcile(liveCollection, newCollection, trackByFn, reactiveConsumer) {
+  let detachedItems = void 0;
+  let liveKeysInTheFuture = void 0;
+  let liveStartIdx = 0;
+  let liveEndIdx = liveCollection.length - 1;
+  const duplicateKeys = ngDevMode ? /* @__PURE__ */ new Map() : void 0;
+  if (Array.isArray(newCollection)) {
+    setActiveConsumer(reactiveConsumer);
+    let newEndIdx = newCollection.length - 1;
+    setActiveConsumer(null);
+    while (liveStartIdx <= liveEndIdx && liveStartIdx <= newEndIdx) {
+      const liveStartValue = liveCollection.at(liveStartIdx);
+      const newStartValue = newCollection[liveStartIdx];
+      if (ngDevMode) {
+        recordDuplicateKeys(duplicateKeys, trackByFn(liveStartIdx, newStartValue), liveStartIdx);
+      }
+      const isStartMatching = valuesMatching(liveStartIdx, liveStartValue, liveStartIdx, newStartValue, trackByFn);
+      if (isStartMatching !== 0) {
+        if (isStartMatching < 0) {
+          liveCollection.updateValue(liveStartIdx, newStartValue);
+        }
+        liveStartIdx++;
+        continue;
+      }
+      const liveEndValue = liveCollection.at(liveEndIdx);
+      const newEndValue = newCollection[newEndIdx];
+      if (ngDevMode) {
+        recordDuplicateKeys(duplicateKeys, trackByFn(newEndIdx, newEndValue), newEndIdx);
+      }
+      const isEndMatching = valuesMatching(liveEndIdx, liveEndValue, newEndIdx, newEndValue, trackByFn);
+      if (isEndMatching !== 0) {
+        if (isEndMatching < 0) {
+          liveCollection.updateValue(liveEndIdx, newEndValue);
+        }
+        liveEndIdx--;
+        newEndIdx--;
+        continue;
+      }
+      const liveStartKey = trackByFn(liveStartIdx, liveStartValue);
+      const liveEndKey = trackByFn(liveEndIdx, liveEndValue);
+      const newStartKey = trackByFn(liveStartIdx, newStartValue);
+      if (Object.is(newStartKey, liveEndKey)) {
+        const newEndKey = trackByFn(newEndIdx, newEndValue);
+        if (Object.is(newEndKey, liveStartKey)) {
+          liveCollection.swap(liveStartIdx, liveEndIdx);
+          liveCollection.updateValue(liveEndIdx, newEndValue);
+          newEndIdx--;
+          liveEndIdx--;
+        } else {
+          liveCollection.move(liveEndIdx, liveStartIdx);
+        }
+        liveCollection.updateValue(liveStartIdx, newStartValue);
+        liveStartIdx++;
+        continue;
+      }
+      detachedItems ??= new UniqueValueMultiKeyMap();
+      liveKeysInTheFuture ??= initLiveItemsInTheFuture(liveCollection, liveStartIdx, liveEndIdx, trackByFn);
+      if (attachPreviouslyDetached(liveCollection, detachedItems, liveStartIdx, newStartKey)) {
+        liveCollection.updateValue(liveStartIdx, newStartValue);
+        liveStartIdx++;
+        liveEndIdx++;
+      } else if (!liveKeysInTheFuture.has(newStartKey)) {
+        const newItem = liveCollection.create(liveStartIdx, newCollection[liveStartIdx]);
+        liveCollection.attach(liveStartIdx, newItem);
+        liveStartIdx++;
+        liveEndIdx++;
+      } else {
+        detachedItems.set(liveStartKey, liveCollection.detach(liveStartIdx));
+        liveEndIdx--;
+      }
+    }
+    while (liveStartIdx <= newEndIdx) {
+      createOrAttach(liveCollection, detachedItems, trackByFn, liveStartIdx, newCollection[liveStartIdx]);
+      liveStartIdx++;
+    }
+  } else if (newCollection != null) {
+    setActiveConsumer(reactiveConsumer);
+    const newCollectionIterator = newCollection[Symbol.iterator]();
+    setActiveConsumer(null);
+    let newIterationResult = newCollectionIterator.next();
+    while (!newIterationResult.done && liveStartIdx <= liveEndIdx) {
+      const liveValue = liveCollection.at(liveStartIdx);
+      const newValue = newIterationResult.value;
+      if (ngDevMode) {
+        recordDuplicateKeys(duplicateKeys, trackByFn(liveStartIdx, newValue), liveStartIdx);
+      }
+      const isStartMatching = valuesMatching(liveStartIdx, liveValue, liveStartIdx, newValue, trackByFn);
+      if (isStartMatching !== 0) {
+        if (isStartMatching < 0) {
+          liveCollection.updateValue(liveStartIdx, newValue);
+        }
+        liveStartIdx++;
+        newIterationResult = newCollectionIterator.next();
+      } else {
+        detachedItems ??= new UniqueValueMultiKeyMap();
+        liveKeysInTheFuture ??= initLiveItemsInTheFuture(liveCollection, liveStartIdx, liveEndIdx, trackByFn);
+        const newKey = trackByFn(liveStartIdx, newValue);
+        if (attachPreviouslyDetached(liveCollection, detachedItems, liveStartIdx, newKey)) {
+          liveCollection.updateValue(liveStartIdx, newValue);
+          liveStartIdx++;
+          liveEndIdx++;
+          newIterationResult = newCollectionIterator.next();
+        } else if (!liveKeysInTheFuture.has(newKey)) {
+          liveCollection.attach(liveStartIdx, liveCollection.create(liveStartIdx, newValue));
+          liveStartIdx++;
+          liveEndIdx++;
+          newIterationResult = newCollectionIterator.next();
+        } else {
+          const liveKey = trackByFn(liveStartIdx, liveValue);
+          detachedItems.set(liveKey, liveCollection.detach(liveStartIdx));
+          liveEndIdx--;
+        }
+      }
+    }
+    while (!newIterationResult.done) {
+      createOrAttach(liveCollection, detachedItems, trackByFn, liveCollection.length, newIterationResult.value);
+      newIterationResult = newCollectionIterator.next();
+    }
+  }
+  while (liveStartIdx <= liveEndIdx) {
+    liveCollection.destroy(liveCollection.detach(liveEndIdx--));
+  }
+  detachedItems?.forEach((item) => {
+    liveCollection.destroy(item);
+  });
+  if (ngDevMode) {
+    let duplicatedKeysMsg = [];
+    for (const [key, idxSet] of duplicateKeys) {
+      if (idxSet.size > 1) {
+        const idx = [...idxSet].sort((a, b) => a - b);
+        for (let i = 1; i < idx.length; i++) {
+          duplicatedKeysMsg.push(`key "${stringifyForError(key)}" at index "${idx[i - 1]}" and "${idx[i]}"`);
+        }
+      }
+    }
+    if (duplicatedKeysMsg.length > 0) {
+      const message = formatRuntimeError(-955, "The provided track expression resulted in duplicated keys for a given collection. Adjust the tracking expression such that it uniquely identifies all the items in the collection. Duplicated keys were: \n" + duplicatedKeysMsg.join(", \n") + ".");
+      console.warn(message);
+    }
+  }
+}
+function attachPreviouslyDetached(prevCollection, detachedItems, index, key) {
+  if (detachedItems !== void 0 && detachedItems.has(key)) {
+    prevCollection.attach(index, detachedItems.get(key));
+    detachedItems.delete(key);
+    return true;
+  }
+  return false;
+}
+function createOrAttach(liveCollection, detachedItems, trackByFn, index, value) {
+  if (!attachPreviouslyDetached(liveCollection, detachedItems, index, trackByFn(index, value))) {
+    const newItem = liveCollection.create(index, value);
+    liveCollection.attach(index, newItem);
+  } else {
+    liveCollection.updateValue(index, value);
+  }
+}
+function initLiveItemsInTheFuture(liveCollection, start, end, trackByFn) {
+  const keys = /* @__PURE__ */ new Set();
+  for (let i = start; i <= end; i++) {
+    keys.add(trackByFn(i, liveCollection.at(i)));
+  }
+  return keys;
+}
+var UniqueValueMultiKeyMap = class {
+  kvMap = /* @__PURE__ */ new Map();
+  _vMap = void 0;
+  has(key) {
+    return this.kvMap.has(key);
+  }
+  delete(key) {
+    if (!this.has(key)) return false;
+    const value = this.kvMap.get(key);
+    if (this._vMap !== void 0 && this._vMap.has(value)) {
+      this.kvMap.set(key, this._vMap.get(value));
+      this._vMap.delete(value);
+    } else {
+      this.kvMap.delete(key);
+    }
+    return true;
+  }
+  get(key) {
+    return this.kvMap.get(key);
+  }
+  set(key, value) {
+    if (this.kvMap.has(key)) {
+      let prevValue = this.kvMap.get(key);
+      if (ngDevMode && prevValue === value) {
+        throw new Error(`Detected a duplicated value ${value} for the key ${key}`);
+      }
+      if (this._vMap === void 0) {
+        this._vMap = /* @__PURE__ */ new Map();
+      }
+      const vMap = this._vMap;
+      while (vMap.has(prevValue)) {
+        prevValue = vMap.get(prevValue);
+      }
+      vMap.set(prevValue, value);
+    } else {
+      this.kvMap.set(key, value);
+    }
+  }
+  forEach(cb) {
+    for (let [key, value] of this.kvMap) {
+      cb(value, key);
+      if (this._vMap !== void 0) {
+        const vMap = this._vMap;
+        while (vMap.has(value)) {
+          value = vMap.get(value);
+          cb(value, key);
+        }
+      }
+    }
+  }
+};
+function \u0275\u0275conditionalCreate(index, templateFn, decls, vars, tagName, attrsIndex, localRefsIndex, localRefExtractor) {
+  performanceMarkFeature("NgControlFlow");
+  const lView = getLView();
+  const tView = getTView();
+  const attrs = getConstant(tView.consts, attrsIndex);
+  declareNoDirectiveHostTemplate(lView, tView, index, templateFn, decls, vars, tagName, attrs, 256, localRefsIndex, localRefExtractor);
+  return \u0275\u0275conditionalBranchCreate;
+}
+function \u0275\u0275conditionalBranchCreate(index, templateFn, decls, vars, tagName, attrsIndex, localRefsIndex, localRefExtractor) {
+  performanceMarkFeature("NgControlFlow");
+  const lView = getLView();
+  const tView = getTView();
+  const attrs = getConstant(tView.consts, attrsIndex);
+  declareNoDirectiveHostTemplate(lView, tView, index, templateFn, decls, vars, tagName, attrs, 512, localRefsIndex, localRefExtractor);
+  return \u0275\u0275conditionalBranchCreate;
+}
+function \u0275\u0275conditional(matchingTemplateIndex, contextValue) {
+  performanceMarkFeature("NgControlFlow");
+  const hostLView = getLView();
+  const bindingIndex = nextBindingIndex();
+  const prevMatchingTemplateIndex = hostLView[bindingIndex] !== NO_CHANGE ? hostLView[bindingIndex] : -1;
+  const prevContainer = prevMatchingTemplateIndex !== -1 ? getLContainer(hostLView, HEADER_OFFSET + prevMatchingTemplateIndex) : void 0;
+  const viewInContainerIdx = 0;
+  if (bindingUpdated(hostLView, bindingIndex, matchingTemplateIndex)) {
+    const prevConsumer = setActiveConsumer(null);
+    try {
+      if (prevContainer !== void 0) {
+        removeLViewFromLContainer(prevContainer, viewInContainerIdx);
+      }
+      if (matchingTemplateIndex !== -1) {
+        const nextLContainerIndex = HEADER_OFFSET + matchingTemplateIndex;
+        const nextContainer = getLContainer(hostLView, nextLContainerIndex);
+        const templateTNode = getExistingTNode(hostLView[TVIEW], nextLContainerIndex);
+        const dehydratedView = findAndReconcileMatchingDehydratedViews(nextContainer, templateTNode, hostLView);
+        const embeddedLView = createAndRenderEmbeddedLView(hostLView, templateTNode, contextValue, {
+          dehydratedView
+        });
+        addLViewToLContainer(nextContainer, embeddedLView, viewInContainerIdx, shouldAddViewToDom(templateTNode, dehydratedView));
+      }
+    } finally {
+      setActiveConsumer(prevConsumer);
+    }
+  } else if (prevContainer !== void 0) {
+    const lView = getLViewFromLContainer(prevContainer, viewInContainerIdx);
+    if (lView !== void 0) {
+      lView[CONTEXT] = contextValue;
+    }
+  }
+}
+var RepeaterContext = class {
+  lContainer;
+  $implicit;
+  $index;
+  constructor(lContainer, $implicit, $index) {
+    this.lContainer = lContainer;
+    this.$implicit = $implicit;
+    this.$index = $index;
+  }
+  get $count() {
+    return this.lContainer.length - CONTAINER_HEADER_OFFSET;
+  }
+};
+function \u0275\u0275repeaterTrackByIndex(index) {
+  return index;
+}
+function \u0275\u0275repeaterTrackByIdentity(_, value) {
+  return value;
+}
+var RepeaterMetadata = class {
+  hasEmptyBlock;
+  trackByFn;
+  liveCollection;
+  constructor(hasEmptyBlock, trackByFn, liveCollection) {
+    this.hasEmptyBlock = hasEmptyBlock;
+    this.trackByFn = trackByFn;
+    this.liveCollection = liveCollection;
+  }
+};
+function \u0275\u0275repeaterCreate(index, templateFn, decls, vars, tagName, attrsIndex, trackByFn, trackByUsesComponentInstance, emptyTemplateFn, emptyDecls, emptyVars, emptyTagName, emptyAttrsIndex) {
+  performanceMarkFeature("NgControlFlow");
+  ngDevMode && assertFunction(trackByFn, `A track expression must be a function, was ${typeof trackByFn} instead.`);
+  const lView = getLView();
+  const tView = getTView();
+  const hasEmptyBlock = emptyTemplateFn !== void 0;
+  const hostLView = getLView();
+  const boundTrackBy = trackByUsesComponentInstance ? trackByFn.bind(hostLView[DECLARATION_COMPONENT_VIEW][CONTEXT]) : trackByFn;
+  const metadata = new RepeaterMetadata(hasEmptyBlock, boundTrackBy);
+  hostLView[HEADER_OFFSET + index] = metadata;
+  declareNoDirectiveHostTemplate(lView, tView, index + 1, templateFn, decls, vars, tagName, getConstant(tView.consts, attrsIndex), 256);
+  if (hasEmptyBlock) {
+    ngDevMode && assertDefined(emptyDecls, "Missing number of declarations for the empty repeater block.");
+    ngDevMode && assertDefined(emptyVars, "Missing number of bindings for the empty repeater block.");
+    declareNoDirectiveHostTemplate(lView, tView, index + 2, emptyTemplateFn, emptyDecls, emptyVars, emptyTagName, getConstant(tView.consts, emptyAttrsIndex), 512);
+  }
+}
+function isViewExpensiveToRecreate(lView) {
+  return lView.length - HEADER_OFFSET > 2;
+}
+var OperationsCounter = class {
+  created = 0;
+  destroyed = 0;
+  reset() {
+    this.created = 0;
+    this.destroyed = 0;
+  }
+  recordCreate() {
+    this.created++;
+  }
+  recordDestroy() {
+    this.destroyed++;
+  }
+  wasReCreated(collectionLen) {
+    return collectionLen > 0 && this.created === this.destroyed && this.created === collectionLen;
+  }
+};
+var LiveCollectionLContainerImpl = class extends LiveCollection {
+  lContainer;
+  hostLView;
+  templateTNode;
+  operationsCounter = ngDevMode ? new OperationsCounter() : void 0;
+  needsIndexUpdate = false;
+  constructor(lContainer, hostLView, templateTNode) {
+    super();
+    this.lContainer = lContainer;
+    this.hostLView = hostLView;
+    this.templateTNode = templateTNode;
+  }
+  get length() {
+    return this.lContainer.length - CONTAINER_HEADER_OFFSET;
+  }
+  at(index) {
+    return this.getLView(index)[CONTEXT].$implicit;
+  }
+  attach(index, lView) {
+    const dehydratedView = lView[HYDRATION];
+    this.needsIndexUpdate ||= index !== this.length;
+    addLViewToLContainer(this.lContainer, lView, index, shouldAddViewToDom(this.templateTNode, dehydratedView));
+    clearDetachAnimationList(this.lContainer, index);
+  }
+  detach(index) {
+    this.needsIndexUpdate ||= index !== this.length - 1;
+    maybeInitDetachAnimationList(this.lContainer, index);
+    return detachExistingView(this.lContainer, index);
+  }
+  create(index, value) {
+    const dehydratedView = findMatchingDehydratedView(this.lContainer, this.templateTNode.tView.ssrId);
+    const embeddedLView = createAndRenderEmbeddedLView(this.hostLView, this.templateTNode, new RepeaterContext(this.lContainer, value, index), {
+      dehydratedView
+    });
+    ngDevMode && this.operationsCounter?.recordCreate();
+    return embeddedLView;
+  }
+  destroy(lView) {
+    destroyLView(lView[TVIEW], lView);
+    ngDevMode && this.operationsCounter?.recordDestroy();
+  }
+  updateValue(index, value) {
+    this.getLView(index)[CONTEXT].$implicit = value;
+  }
+  reset() {
+    this.needsIndexUpdate = false;
+    ngDevMode && this.operationsCounter?.reset();
+  }
+  updateIndexes() {
+    if (this.needsIndexUpdate) {
+      for (let i = 0; i < this.length; i++) {
+        this.getLView(i)[CONTEXT].$index = i;
+      }
+    }
+  }
+  getLView(index) {
+    return getExistingLViewFromLContainer(this.lContainer, index);
+  }
+};
+function \u0275\u0275repeater(collection) {
+  const prevConsumer = setActiveConsumer(null);
+  const metadataSlotIdx = getSelectedIndex();
+  try {
+    const hostLView = getLView();
+    const hostTView = hostLView[TVIEW];
+    const metadata = hostLView[metadataSlotIdx];
+    const containerIndex = metadataSlotIdx + 1;
+    const lContainer = getLContainer(hostLView, containerIndex);
+    if (metadata.liveCollection === void 0) {
+      const itemTemplateTNode = getExistingTNode(hostTView, containerIndex);
+      metadata.liveCollection = new LiveCollectionLContainerImpl(lContainer, hostLView, itemTemplateTNode);
+    } else {
+      metadata.liveCollection.reset();
+    }
+    const liveCollection = metadata.liveCollection;
+    reconcile(liveCollection, collection, metadata.trackByFn, prevConsumer);
+    if (ngDevMode && metadata.trackByFn === \u0275\u0275repeaterTrackByIdentity && liveCollection.operationsCounter?.wasReCreated(liveCollection.length) && isViewExpensiveToRecreate(getExistingLViewFromLContainer(lContainer, 0))) {
+      const message = formatRuntimeError(-956, `The configured tracking expression (track by identity) caused re-creation of the entire collection of size ${liveCollection.length}. This is an expensive operation requiring destruction and subsequent creation of DOM nodes, directives, components etc. Please review the "track expression" and make sure that it uniquely identifies items in a collection.`);
+      console.warn(message);
+    }
+    liveCollection.updateIndexes();
+    if (metadata.hasEmptyBlock) {
+      const bindingIndex = nextBindingIndex();
+      const isCollectionEmpty = liveCollection.length === 0;
+      if (bindingUpdated(hostLView, bindingIndex, isCollectionEmpty)) {
+        const emptyTemplateIndex = metadataSlotIdx + 2;
+        const lContainerForEmpty = getLContainer(hostLView, emptyTemplateIndex);
+        if (isCollectionEmpty) {
+          const emptyTemplateTNode = getExistingTNode(hostTView, emptyTemplateIndex);
+          const dehydratedView = findAndReconcileMatchingDehydratedViews(lContainerForEmpty, emptyTemplateTNode, hostLView);
+          const embeddedLView = createAndRenderEmbeddedLView(hostLView, emptyTemplateTNode, void 0, {
+            dehydratedView
+          });
+          addLViewToLContainer(lContainerForEmpty, embeddedLView, 0, shouldAddViewToDom(emptyTemplateTNode, dehydratedView));
+        } else {
+          if (hostTView.firstUpdatePass) {
+            removeDehydratedViews(lContainerForEmpty);
+          }
+          removeLViewFromLContainer(lContainerForEmpty, 0);
+        }
+      }
+    }
+  } finally {
+    setActiveConsumer(prevConsumer);
+  }
+}
+function getLContainer(lView, index) {
+  const lContainer = lView[index];
+  ngDevMode && assertLContainer(lContainer);
+  return lContainer;
+}
+function clearDetachAnimationList(lContainer, index) {
+  if (lContainer.length <= CONTAINER_HEADER_OFFSET) return;
+  const indexInContainer = CONTAINER_HEADER_OFFSET + index;
+  const viewToDetach = lContainer[indexInContainer];
+  const animations = viewToDetach ? viewToDetach[ANIMATIONS] : void 0;
+  if (viewToDetach && animations && animations.detachedLeaveAnimationFns && animations.detachedLeaveAnimationFns.length > 0) {
+    const injector = viewToDetach[INJECTOR];
+    removeFromAnimationQueue(injector, animations);
+    allLeavingAnimations.delete(viewToDetach[ID]);
+    animations.detachedLeaveAnimationFns = void 0;
+  }
+}
+function maybeInitDetachAnimationList(lContainer, index) {
+  if (lContainer.length <= CONTAINER_HEADER_OFFSET) return;
+  const indexInContainer = CONTAINER_HEADER_OFFSET + index;
+  const viewToDetach = lContainer[indexInContainer];
+  const animations = viewToDetach ? viewToDetach[ANIMATIONS] : void 0;
+  if (animations && animations.leave && animations.leave.size > 0) {
+    animations.detachedLeaveAnimationFns = [];
+  }
+}
+function detachExistingView(lContainer, index) {
+  const existingLView = detachView(lContainer, index);
+  ngDevMode && assertLView(existingLView);
+  return existingLView;
+}
+function getExistingLViewFromLContainer(lContainer, index) {
+  const existingLView = getLViewFromLContainer(lContainer, index);
+  ngDevMode && assertLView(existingLView);
+  return existingLView;
+}
+function getExistingTNode(tView, index) {
+  const tNode = getTNode(tView, index);
+  ngDevMode && assertTNode(tNode);
+  return tNode;
+}
+function \u0275\u0275property(propName, value, sanitizer) {
+  const lView = getLView();
+  const bindingIndex = nextBindingIndex();
+  if (bindingUpdated(lView, bindingIndex, value)) {
+    const tView = getTView();
+    const tNode = getSelectedTNode();
+    setPropertyAndInputs(tNode, lView, propName, value, lView[RENDERER], sanitizer);
+    ngDevMode && storePropertyBindingMetadata(tView.data, tNode, propName, bindingIndex);
+  }
+  return \u0275\u0275property;
+}
+function setDirectiveInputsWhichShadowsStyling(tView, tNode, lView, value, isClassBased) {
+  setAllInputsForProperty(tNode, tView, lView, isClassBased ? "class" : "style", value);
+}
+function \u0275\u0275elementStart(index, name, attrsIndex, localRefsIndex) {
+  const lView = getLView();
+  ngDevMode && assertTNodeCreationIndex(lView, index);
+  const tView = lView[TVIEW];
+  const adjustedIndex = index + HEADER_OFFSET;
+  const tNode = tView.firstCreatePass ? directiveHostFirstCreatePass(adjustedIndex, lView, 2, name, findDirectiveDefMatches, getBindingsEnabled(), attrsIndex, localRefsIndex) : tView.data[adjustedIndex];
+  if (isComponentHost(tNode)) {
+    const tracingService = lView[ENVIRONMENT].tracingService;
+    if (tracingService && tracingService.componentCreate) {
+      const def = tView.data[tNode.directiveStart + tNode.componentOffset];
+      return tracingService.componentCreate(getComponentName(def), () => {
+        initializeElement(index, name, lView, tNode, localRefsIndex);
+        return \u0275\u0275elementStart;
+      });
+    }
+  }
+  initializeElement(index, name, lView, tNode, localRefsIndex);
+  return \u0275\u0275elementStart;
+}
+function initializeElement(index, name, lView, tNode, localRefsIndex) {
+  elementLikeStartShared(tNode, lView, index, name, _locateOrCreateElementNode);
+  if (isDirectiveHost(tNode)) {
+    const tView = lView[TVIEW];
+    createDirectivesInstances(tView, lView, tNode);
+    executeContentQueries(tView, tNode, lView);
+  }
+  if (localRefsIndex != null) {
+    saveResolvedLocalsInData(lView, tNode);
+  }
+  if (ngDevMode && lView[TVIEW].firstCreatePass) {
+    validateElementIsKnown(lView, tNode);
+  }
+}
+function \u0275\u0275elementEnd() {
+  const tView = getTView();
+  const initialTNode = getCurrentTNode();
+  ngDevMode && assertDefined(initialTNode, "No parent node to close.");
+  const currentTNode = elementLikeEndShared(initialTNode);
+  ngDevMode && assertTNodeType(currentTNode, 3);
+  if (tView.firstCreatePass) {
+    directiveHostEndFirstCreatePass(tView, currentTNode);
+  }
+  if (isSkipHydrationRootTNode(currentTNode)) {
+    leaveSkipHydrationBlock();
+  }
+  decreaseElementDepthCount();
+  if (currentTNode.classesWithoutHost != null && hasClassInput(currentTNode)) {
+    setDirectiveInputsWhichShadowsStyling(tView, currentTNode, getLView(), currentTNode.classesWithoutHost, true);
+  }
+  if (currentTNode.stylesWithoutHost != null && hasStyleInput(currentTNode)) {
+    setDirectiveInputsWhichShadowsStyling(tView, currentTNode, getLView(), currentTNode.stylesWithoutHost, false);
+  }
+  return \u0275\u0275elementEnd;
+}
+function \u0275\u0275element(index, name, attrsIndex, localRefsIndex) {
+  \u0275\u0275elementStart(index, name, attrsIndex, localRefsIndex);
+  \u0275\u0275elementEnd();
+  return \u0275\u0275element;
+}
+function \u0275\u0275domElementStart(index, name, attrsIndex, localRefsIndex) {
+  const lView = getLView();
+  ngDevMode && assertTNodeCreationIndex(lView, index);
+  const tView = lView[TVIEW];
+  const adjustedIndex = index + HEADER_OFFSET;
+  const tNode = tView.firstCreatePass ? domOnlyFirstCreatePass(adjustedIndex, tView, 2, name, attrsIndex, localRefsIndex) : tView.data[adjustedIndex];
+  elementLikeStartShared(tNode, lView, index, name, _locateOrCreateElementNode);
+  if (localRefsIndex != null) {
+    saveResolvedLocalsInData(lView, tNode);
+  }
+  if (ngDevMode && lView[TVIEW].firstCreatePass) {
+    validateElementIsKnown(lView, tNode);
+  }
+  return \u0275\u0275domElementStart;
+}
+function \u0275\u0275domElementEnd() {
+  const initialTNode = getCurrentTNode();
+  ngDevMode && assertDefined(initialTNode, "No parent node to close.");
+  const currentTNode = elementLikeEndShared(initialTNode);
+  ngDevMode && assertTNodeType(currentTNode, 3);
+  if (isSkipHydrationRootTNode(currentTNode)) {
+    leaveSkipHydrationBlock();
+  }
+  decreaseElementDepthCount();
+  return \u0275\u0275domElementEnd;
+}
+function \u0275\u0275domElement(index, name, attrsIndex, localRefsIndex) {
+  \u0275\u0275domElementStart(index, name, attrsIndex, localRefsIndex);
+  \u0275\u0275domElementEnd();
+  return \u0275\u0275domElement;
+}
+var _locateOrCreateElementNode = (tView, lView, tNode, name, index) => {
+  lastNodeWasCreated(true);
+  return createElementNode(lView[RENDERER], name, getNamespace());
+};
+function \u0275\u0275elementContainerStart(index, attrsIndex, localRefsIndex) {
+  const lView = getLView();
+  ngDevMode && assertTNodeCreationIndex(lView, index);
+  const tView = lView[TVIEW];
+  const adjustedIndex = index + HEADER_OFFSET;
+  const tNode = tView.firstCreatePass ? directiveHostFirstCreatePass(adjustedIndex, lView, 8, "ng-container", findDirectiveDefMatches, getBindingsEnabled(), attrsIndex, localRefsIndex) : tView.data[adjustedIndex];
+  elementLikeStartShared(tNode, lView, index, "ng-container", _locateOrCreateElementContainerNode);
+  if (isDirectiveHost(tNode)) {
+    const tView2 = lView[TVIEW];
+    createDirectivesInstances(tView2, lView, tNode);
+    executeContentQueries(tView2, tNode, lView);
+  }
+  if (localRefsIndex != null) {
+    saveResolvedLocalsInData(lView, tNode);
+  }
+  return \u0275\u0275elementContainerStart;
+}
+function \u0275\u0275elementContainerEnd() {
+  const tView = getTView();
+  const initialTNode = getCurrentTNode();
+  ngDevMode && assertDefined(initialTNode, "No parent node to close.");
+  const currentTNode = elementLikeEndShared(initialTNode);
+  if (tView.firstCreatePass) {
+    directiveHostEndFirstCreatePass(tView, currentTNode);
+  }
+  ngDevMode && assertTNodeType(currentTNode, 8);
+  return \u0275\u0275elementContainerEnd;
+}
+function \u0275\u0275elementContainer(index, attrsIndex, localRefsIndex) {
+  \u0275\u0275elementContainerStart(index, attrsIndex, localRefsIndex);
+  \u0275\u0275elementContainerEnd();
+  return \u0275\u0275elementContainer;
+}
+function \u0275\u0275domElementContainerStart(index, attrsIndex, localRefsIndex) {
+  const lView = getLView();
+  ngDevMode && assertTNodeCreationIndex(lView, index);
+  const tView = lView[TVIEW];
+  const adjustedIndex = index + HEADER_OFFSET;
+  const tNode = tView.firstCreatePass ? domOnlyFirstCreatePass(adjustedIndex, tView, 8, "ng-container", attrsIndex, localRefsIndex) : tView.data[adjustedIndex];
+  elementLikeStartShared(tNode, lView, index, "ng-container", _locateOrCreateElementContainerNode);
+  if (localRefsIndex != null) {
+    saveResolvedLocalsInData(lView, tNode);
+  }
+  return \u0275\u0275domElementContainerStart;
+}
+function \u0275\u0275domElementContainerEnd() {
+  const initialTNode = getCurrentTNode();
+  ngDevMode && assertDefined(initialTNode, "No parent node to close.");
+  const currentTNode = elementLikeEndShared(initialTNode);
+  ngDevMode && assertTNodeType(currentTNode, 8);
+  return \u0275\u0275elementContainerEnd;
+}
+function \u0275\u0275domElementContainer(index, attrsIndex, localRefsIndex) {
+  \u0275\u0275domElementContainerStart(index, attrsIndex, localRefsIndex);
+  \u0275\u0275domElementContainerEnd();
+  return \u0275\u0275domElementContainer;
+}
+var _locateOrCreateElementContainerNode = (tView, lView, tNode, commentText, index) => {
+  lastNodeWasCreated(true);
+  return createCommentNode(lView[RENDERER], ngDevMode ? commentText : "");
+};
+function \u0275\u0275getCurrentView() {
+  return getLView();
+}
+function \u0275\u0275domProperty(propName, value, sanitizer) {
+  const lView = getLView();
+  const bindingIndex = nextBindingIndex();
+  if (bindingUpdated(lView, bindingIndex, value)) {
+    const tView = getTView();
+    const tNode = getSelectedTNode();
+    setDomProperty(tNode, lView, propName, value, lView[RENDERER], sanitizer);
+    ngDevMode && storePropertyBindingMetadata(tView.data, tNode, propName, bindingIndex);
+  }
+  return \u0275\u0275domProperty;
+}
+function \u0275\u0275syntheticHostProperty(propName, value, sanitizer) {
+  const lView = getLView();
+  const bindingIndex = nextBindingIndex();
+  if (bindingUpdated(lView, bindingIndex, value)) {
+    const tView = getTView();
+    const tNode = getSelectedTNode();
+    const currentDef = getCurrentDirectiveDef(tView.data);
+    const renderer = loadComponentRenderer(currentDef, tNode, lView);
+    setDomProperty(tNode, lView, propName, value, renderer, sanitizer);
+    ngDevMode && storePropertyBindingMetadata(tView.data, tNode, propName, bindingIndex);
+  }
+  return \u0275\u0275syntheticHostProperty;
+}
+var u = void 0;
+function plural(val) {
+  const i = Math.floor(Math.abs(val)), v = val.toString().replace(/^[^.]*\.?/, "").length;
+  if (i === 1 && v === 0) return 1;
+  return 5;
+}
+var localeEn = ["en", [["a", "p"], ["AM", "PM"]], [["AM", "PM"]], [["S", "M", "T", "W", "T", "F", "S"], ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"]], u, [["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"], ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]], u, [["B", "A"], ["BC", "AD"], ["Before Christ", "Anno Domini"]], 0, [6, 0], ["M/d/yy", "MMM d, y", "MMMM d, y", "EEEE, MMMM d, y"], ["h:mm\u202Fa", "h:mm:ss\u202Fa", "h:mm:ss\u202Fa z", "h:mm:ss\u202Fa zzzz"], ["{1}, {0}", u, u, u], [".", ",", ";", "%", "+", "-", "E", "\xD7", "\u2030", "\u221E", "NaN", ":"], ["#,##0.###", "#,##0%", "\xA4#,##0.00", "#E0"], "USD", "$", "US Dollar", {}, "ltr", plural];
+var LOCALE_DATA = /* @__PURE__ */ Object.create(null);
+function findLocaleData(locale) {
+  const normalizedLocale = normalizeLocale(locale);
+  let match2 = getLocaleData(normalizedLocale);
+  if (match2) {
+    return match2;
+  }
+  const parentLocale = normalizedLocale.split("-")[0];
+  match2 = getLocaleData(parentLocale);
+  if (match2) {
+    return match2;
+  }
+  if (parentLocale === "en") {
+    return localeEn;
+  }
+  throw new RuntimeError(701, ngDevMode && `Missing locale data for the locale "${locale}".`);
+}
+function getLocalePluralCase(locale) {
+  const data = findLocaleData(locale);
+  return data[LocaleDataIndex.PluralCase];
+}
+function getLocaleData(normalizedLocale) {
+  if (!(normalizedLocale in LOCALE_DATA)) {
+    LOCALE_DATA[normalizedLocale] = _global.ng && _global.ng.common && _global.ng.common.locales && _global.ng.common.locales[normalizedLocale];
+  }
+  return LOCALE_DATA[normalizedLocale];
+}
+var LocaleDataIndex;
+(function(LocaleDataIndex2) {
+  LocaleDataIndex2[LocaleDataIndex2["LocaleId"] = 0] = "LocaleId";
+  LocaleDataIndex2[LocaleDataIndex2["DayPeriodsFormat"] = 1] = "DayPeriodsFormat";
+  LocaleDataIndex2[LocaleDataIndex2["DayPeriodsStandalone"] = 2] = "DayPeriodsStandalone";
+  LocaleDataIndex2[LocaleDataIndex2["DaysFormat"] = 3] = "DaysFormat";
+  LocaleDataIndex2[LocaleDataIndex2["DaysStandalone"] = 4] = "DaysStandalone";
+  LocaleDataIndex2[LocaleDataIndex2["MonthsFormat"] = 5] = "MonthsFormat";
+  LocaleDataIndex2[LocaleDataIndex2["MonthsStandalone"] = 6] = "MonthsStandalone";
+  LocaleDataIndex2[LocaleDataIndex2["Eras"] = 7] = "Eras";
+  LocaleDataIndex2[LocaleDataIndex2["FirstDayOfWeek"] = 8] = "FirstDayOfWeek";
+  LocaleDataIndex2[LocaleDataIndex2["WeekendRange"] = 9] = "WeekendRange";
+  LocaleDataIndex2[LocaleDataIndex2["DateFormat"] = 10] = "DateFormat";
+  LocaleDataIndex2[LocaleDataIndex2["TimeFormat"] = 11] = "TimeFormat";
+  LocaleDataIndex2[LocaleDataIndex2["DateTimeFormat"] = 12] = "DateTimeFormat";
+  LocaleDataIndex2[LocaleDataIndex2["NumberSymbols"] = 13] = "NumberSymbols";
+  LocaleDataIndex2[LocaleDataIndex2["NumberFormats"] = 14] = "NumberFormats";
+  LocaleDataIndex2[LocaleDataIndex2["CurrencyCode"] = 15] = "CurrencyCode";
+  LocaleDataIndex2[LocaleDataIndex2["CurrencySymbol"] = 16] = "CurrencySymbol";
+  LocaleDataIndex2[LocaleDataIndex2["CurrencyName"] = 17] = "CurrencyName";
+  LocaleDataIndex2[LocaleDataIndex2["Currencies"] = 18] = "Currencies";
+  LocaleDataIndex2[LocaleDataIndex2["Directionality"] = 19] = "Directionality";
+  LocaleDataIndex2[LocaleDataIndex2["PluralCase"] = 20] = "PluralCase";
+  LocaleDataIndex2[LocaleDataIndex2["ExtraData"] = 21] = "ExtraData";
+})(LocaleDataIndex || (LocaleDataIndex = {}));
+function normalizeLocale(locale) {
+  return locale.toLowerCase().replace(/_/g, "-");
+}
+var pluralMapping = ["zero", "one", "two", "few", "many"];
+function getPluralCase(value, locale) {
+  const plural2 = getLocalePluralCase(locale)(parseInt(value, 10));
+  const result = pluralMapping[plural2];
+  return result !== void 0 ? result : "other";
+}
+var DEFAULT_LOCALE_ID = "en-US";
+var USD_CURRENCY_CODE = "USD";
+var ELEMENT_MARKER = {
+  marker: "element"
+};
+var ICU_MARKER = {
+  marker: "ICU"
+};
+var I18nCreateOpCode;
+(function(I18nCreateOpCode2) {
+  I18nCreateOpCode2[I18nCreateOpCode2["SHIFT"] = 2] = "SHIFT";
+  I18nCreateOpCode2[I18nCreateOpCode2["APPEND_EAGERLY"] = 1] = "APPEND_EAGERLY";
+  I18nCreateOpCode2[I18nCreateOpCode2["COMMENT"] = 2] = "COMMENT";
+})(I18nCreateOpCode || (I18nCreateOpCode = {}));
+var LOCALE_ID$1 = DEFAULT_LOCALE_ID;
+function setLocaleId(localeId) {
+  ngDevMode && assertDefined(localeId, `Expected localeId to be defined`);
+  if (typeof localeId === "string") {
+    LOCALE_ID$1 = localeId.toLowerCase().replace(/_/g, "-");
+  }
+}
+function getLocaleId() {
+  return LOCALE_ID$1;
+}
+var changeMask = 0;
+var changeMaskCounter = 0;
+function setMaskBit(hasChange) {
+  if (hasChange) {
+    changeMask = changeMask | 1 << Math.min(changeMaskCounter, 31);
+  }
+  changeMaskCounter++;
+}
+function applyI18n(tView, lView, index) {
+  try {
+    if (changeMaskCounter > 0) {
+      ngDevMode && assertDefined(tView, `tView should be defined`);
+      const tI18n = tView.data[index];
+      const updateOpCodes = Array.isArray(tI18n) ? tI18n : tI18n.update;
+      const bindingsStartIndex = getBindingIndex() - changeMaskCounter - 1;
+      applyUpdateOpCodes(tView, lView, updateOpCodes, bindingsStartIndex, changeMask);
+    }
+  } finally {
+    changeMask = 0;
+    changeMaskCounter = 0;
+  }
+}
+function createNodeWithoutHydration(lView, textOrName, nodeType) {
+  const renderer = lView[RENDERER];
+  switch (nodeType) {
+    case Node.COMMENT_NODE:
+      return createCommentNode(renderer, textOrName);
+    case Node.TEXT_NODE:
+      return createTextNode(renderer, textOrName);
+    case Node.ELEMENT_NODE:
+      return createElementNode(renderer, textOrName, null);
+  }
+}
+var _locateOrCreateNode = (lView, index, textOrName, nodeType) => {
+  lastNodeWasCreated(true);
+  return createNodeWithoutHydration(lView, textOrName, nodeType);
+};
+function applyCreateOpCodes(lView, createOpCodes, parentRNode, insertInFrontOf) {
+  const renderer = lView[RENDERER];
+  for (let i = 0; i < createOpCodes.length; i++) {
+    const opCode = createOpCodes[i++];
+    const text = createOpCodes[i];
+    const isComment = (opCode & I18nCreateOpCode.COMMENT) === I18nCreateOpCode.COMMENT;
+    const appendNow = (opCode & I18nCreateOpCode.APPEND_EAGERLY) === I18nCreateOpCode.APPEND_EAGERLY;
+    const index = opCode >>> I18nCreateOpCode.SHIFT;
+    let rNode = lView[index];
+    let lastNodeWasCreated2 = false;
+    if (rNode === null) {
+      rNode = lView[index] = _locateOrCreateNode(lView, index, text, isComment ? Node.COMMENT_NODE : Node.TEXT_NODE);
+      lastNodeWasCreated2 = wasLastNodeCreated();
+    }
+    if (appendNow && parentRNode !== null && lastNodeWasCreated2) {
+      nativeInsertBefore(renderer, parentRNode, rNode, insertInFrontOf, false);
+    }
+  }
+}
+function applyMutableOpCodes(tView, mutableOpCodes, lView, anchorRNode) {
+  ngDevMode && assertDomNode(anchorRNode);
+  const renderer = lView[RENDERER];
+  let rootIdx = null;
+  let rootRNode;
+  for (let i = 0; i < mutableOpCodes.length; i++) {
+    const opCode = mutableOpCodes[i];
+    if (typeof opCode == "string") {
+      const textNodeIndex = mutableOpCodes[++i];
+      if (lView[textNodeIndex] === null) {
+        ngDevMode && assertIndexInRange(lView, textNodeIndex);
+        lView[textNodeIndex] = _locateOrCreateNode(lView, textNodeIndex, opCode, Node.TEXT_NODE);
+      }
+    } else if (typeof opCode == "number") {
+      switch (opCode & 1) {
+        case 0:
+          const parentIdx = getParentFromIcuCreateOpCode(opCode);
+          if (rootIdx === null) {
+            rootIdx = parentIdx;
+            rootRNode = renderer.parentNode(anchorRNode);
+          }
+          let insertInFrontOf;
+          let parentRNode;
+          if (parentIdx === rootIdx) {
+            insertInFrontOf = anchorRNode;
+            parentRNode = rootRNode;
+          } else {
+            insertInFrontOf = null;
+            parentRNode = unwrapRNode(lView[parentIdx]);
+          }
+          if (parentRNode !== null) {
+            ngDevMode && assertDomNode(parentRNode);
+            const refIdx = getRefFromIcuCreateOpCode(opCode);
+            ngDevMode && assertGreaterThan(refIdx, HEADER_OFFSET, "Missing ref");
+            const child = lView[refIdx];
+            ngDevMode && assertDomNode(child);
+            nativeInsertBefore(renderer, parentRNode, child, insertInFrontOf, false);
+            const tIcu = getTIcu(tView, refIdx);
+            if (tIcu !== null && typeof tIcu === "object") {
+              ngDevMode && assertTIcu(tIcu);
+              const caseIndex = getCurrentICUCaseIndex(tIcu, lView);
+              if (caseIndex !== null) {
+                applyMutableOpCodes(tView, tIcu.create[caseIndex], lView, lView[tIcu.anchorIdx]);
+              }
+            }
+          }
+          break;
+        case 1:
+          const elementNodeIndex = opCode >>> 1;
+          const attrName = mutableOpCodes[++i];
+          const attrValue = mutableOpCodes[++i];
+          setElementAttribute(renderer, getNativeByIndex(elementNodeIndex, lView), null, null, attrName, attrValue, null);
+          break;
+        default:
+          if (ngDevMode) {
+            throw new RuntimeError(700, `Unable to determine the type of mutate operation for "${opCode}"`);
+          }
+      }
+    } else {
+      switch (opCode) {
+        case ICU_MARKER:
+          const commentValue = mutableOpCodes[++i];
+          const commentNodeIndex = mutableOpCodes[++i];
+          if (lView[commentNodeIndex] === null) {
+            ngDevMode && assertEqual(typeof commentValue, "string", `Expected "${commentValue}" to be a comment node value`);
+            ngDevMode && assertIndexInExpandoRange(lView, commentNodeIndex);
+            const commentRNode = lView[commentNodeIndex] = _locateOrCreateNode(lView, commentNodeIndex, commentValue, Node.COMMENT_NODE);
+            attachPatchData(commentRNode, lView);
+          }
+          break;
+        case ELEMENT_MARKER:
+          const tagName = mutableOpCodes[++i];
+          const elementNodeIndex = mutableOpCodes[++i];
+          if (lView[elementNodeIndex] === null) {
+            ngDevMode && assertEqual(typeof tagName, "string", `Expected "${tagName}" to be an element node tag name`);
+            ngDevMode && assertIndexInExpandoRange(lView, elementNodeIndex);
+            const elementRNode = lView[elementNodeIndex] = _locateOrCreateNode(lView, elementNodeIndex, tagName, Node.ELEMENT_NODE);
+            attachPatchData(elementRNode, lView);
+          }
+          break;
+        default:
+          ngDevMode && throwError2(`Unable to determine the type of mutate operation for "${opCode}"`);
+      }
+    }
+  }
+}
+function applyUpdateOpCodes(tView, lView, updateOpCodes, bindingsStartIndex, changeMask2) {
+  for (let i = 0; i < updateOpCodes.length; i++) {
+    const checkBit = updateOpCodes[i];
+    const skipCodes = updateOpCodes[++i];
+    if (checkBit & changeMask2) {
+      let value = "";
+      for (let j = i + 1; j <= i + skipCodes; j++) {
+        const opCode = updateOpCodes[j];
+        if (typeof opCode == "string") {
+          value += opCode;
+        } else if (typeof opCode == "number") {
+          if (opCode < 0) {
+            value += renderStringify(lView[bindingsStartIndex - opCode]);
+          } else {
+            const nodeIndex = opCode >>> 2;
+            switch (opCode & 3) {
+              case 1:
+                const propName = updateOpCodes[++j];
+                const sanitizeFn = updateOpCodes[++j];
+                const tNodeOrTagName = tView.data[nodeIndex];
+                ngDevMode && assertDefined(tNodeOrTagName, "Experting TNode or string");
+                if (typeof tNodeOrTagName === "string") {
+                  setElementAttribute(lView[RENDERER], lView[nodeIndex], null, tNodeOrTagName, propName, value, sanitizeFn);
+                } else {
+                  const prevSelectedIndex = getSelectedIndex();
+                  setSelectedIndex(nodeIndex);
+                  try {
+                    setPropertyAndInputs(tNodeOrTagName, lView, propName, value, lView[RENDERER], sanitizeFn);
+                  } finally {
+                    setSelectedIndex(prevSelectedIndex);
+                  }
+                }
+                break;
+              case 0:
+                const rText = lView[nodeIndex];
+                rText !== null && updateTextNode(lView[RENDERER], rText, value);
+                break;
+              case 2:
+                applyIcuSwitchCase(tView, getTIcu(tView, nodeIndex), lView, value);
+                break;
+              case 3:
+                applyIcuUpdateCase(tView, getTIcu(tView, nodeIndex), bindingsStartIndex, lView);
+                break;
+            }
+          }
+        }
+      }
+    } else {
+      const opCode = updateOpCodes[i + 1];
+      if (opCode > 0 && (opCode & 3) === 3) {
+        const nodeIndex = opCode >>> 2;
+        const tIcu = getTIcu(tView, nodeIndex);
+        const currentIndex = lView[tIcu.currentCaseLViewIndex];
+        if (currentIndex < 0) {
+          applyIcuUpdateCase(tView, tIcu, bindingsStartIndex, lView);
+        }
+      }
+    }
+    i += skipCodes;
+  }
+}
+function applyIcuUpdateCase(tView, tIcu, bindingsStartIndex, lView) {
+  ngDevMode && assertIndexInRange(lView, tIcu.currentCaseLViewIndex);
+  let activeCaseIndex = lView[tIcu.currentCaseLViewIndex];
+  if (activeCaseIndex !== null) {
+    let mask = changeMask;
+    if (activeCaseIndex < 0) {
+      activeCaseIndex = lView[tIcu.currentCaseLViewIndex] = ~activeCaseIndex;
+      mask = -1;
+    }
+    applyUpdateOpCodes(tView, lView, tIcu.update[activeCaseIndex], bindingsStartIndex, mask);
+  }
+}
+function applyIcuSwitchCase(tView, tIcu, lView, value) {
+  const caseIndex = getCaseIndex(tIcu, value);
+  let activeCaseIndex = getCurrentICUCaseIndex(tIcu, lView);
+  if (activeCaseIndex !== caseIndex) {
+    applyIcuSwitchCaseRemove(tView, tIcu, lView);
+    lView[tIcu.currentCaseLViewIndex] = caseIndex === null ? null : ~caseIndex;
+    if (caseIndex !== null) {
+      const anchorRNode = lView[tIcu.anchorIdx];
+      if (anchorRNode) {
+        ngDevMode && assertDomNode(anchorRNode);
+        applyMutableOpCodes(tView, tIcu.create[caseIndex], lView, anchorRNode);
+      }
+      claimDehydratedIcuCase(lView, tIcu.anchorIdx, caseIndex);
+    }
+  }
+}
+function applyIcuSwitchCaseRemove(tView, tIcu, lView) {
+  let activeCaseIndex = getCurrentICUCaseIndex(tIcu, lView);
+  if (activeCaseIndex !== null) {
+    const removeCodes = tIcu.remove[activeCaseIndex];
+    for (let i = 0; i < removeCodes.length; i++) {
+      const nodeOrIcuIndex = removeCodes[i];
+      if (nodeOrIcuIndex > 0) {
+        const rNode = getNativeByIndex(nodeOrIcuIndex, lView);
+        rNode !== null && nativeRemoveNode(lView[RENDERER], rNode);
+      } else {
+        applyIcuSwitchCaseRemove(tView, getTIcu(tView, ~nodeOrIcuIndex), lView);
+      }
+    }
+  }
+}
+function getCaseIndex(icuExpression, bindingValue) {
+  let index = icuExpression.cases.indexOf(bindingValue);
+  if (index === -1) {
+    switch (icuExpression.type) {
+      case 1: {
+        const resolvedCase = getPluralCase(bindingValue, getLocaleId());
+        index = icuExpression.cases.indexOf(resolvedCase);
+        if (index === -1 && resolvedCase !== "other") {
+          index = icuExpression.cases.indexOf("other");
+        }
+        break;
+      }
+      case 0: {
+        index = icuExpression.cases.indexOf("other");
+        break;
+      }
+    }
+  }
+  return index === -1 ? null : index;
+}
+function i18nCreateOpCodesToString(opcodes) {
+  const createOpCodes = opcodes || (Array.isArray(this) ? this : []);
+  let lines = [];
+  for (let i = 0; i < createOpCodes.length; i++) {
+    const opCode = createOpCodes[i++];
+    const text = createOpCodes[i];
+    const isComment = (opCode & I18nCreateOpCode.COMMENT) === I18nCreateOpCode.COMMENT;
+    const appendNow = (opCode & I18nCreateOpCode.APPEND_EAGERLY) === I18nCreateOpCode.APPEND_EAGERLY;
+    const index = opCode >>> I18nCreateOpCode.SHIFT;
+    lines.push(`lView[${index}] = document.${isComment ? "createComment" : "createText"}(${JSON.stringify(text)});`);
+    if (appendNow) {
+      lines.push(`parent.appendChild(lView[${index}]);`);
+    }
+  }
+  return lines;
+}
+function i18nUpdateOpCodesToString(opcodes) {
+  const parser = new OpCodeParser(opcodes || (Array.isArray(this) ? this : []));
+  let lines = [];
+  function consumeOpCode(value) {
+    const ref = value >>> 2;
+    const opCode = value & 3;
+    switch (opCode) {
+      case 0:
+        return `(lView[${ref}] as Text).textContent = $$$`;
+      case 1:
+        const attrName = parser.consumeString();
+        const sanitizationFn = parser.consumeFunction();
+        const value2 = sanitizationFn ? `(${sanitizationFn})($$$)` : "$$$";
+        return `(lView[${ref}] as Element).setAttribute('${attrName}', ${value2})`;
+      case 2:
+        return `icuSwitchCase(${ref}, $$$)`;
+      case 3:
+        return `icuUpdateCase(${ref})`;
+    }
+    throw new Error("unexpected OpCode");
+  }
+  while (parser.hasMore()) {
+    let mask = parser.consumeNumber();
+    let size = parser.consumeNumber();
+    const end = parser.i + size;
+    const statements = [];
+    let statement = "";
+    while (parser.i < end) {
+      let value = parser.consumeNumberOrString();
+      if (typeof value === "string") {
+        statement += value;
+      } else if (value < 0) {
+        statement += "${lView[i" + value + "]}";
+      } else {
+        const opCodeText = consumeOpCode(value);
+        statements.push(opCodeText.replace("$$$", "`" + statement + "`") + ";");
+        statement = "";
+      }
+    }
+    lines.push(`if (mask & 0b${mask.toString(2)}) { ${statements.join(" ")} }`);
+  }
+  return lines;
+}
+function icuCreateOpCodesToString(opcodes) {
+  const parser = new OpCodeParser(opcodes || (Array.isArray(this) ? this : []));
+  let lines = [];
+  function consumeOpCode(opCode) {
+    const parent = getParentFromIcuCreateOpCode(opCode);
+    const ref = getRefFromIcuCreateOpCode(opCode);
+    switch (getInstructionFromIcuCreateOpCode(opCode)) {
+      case 0:
+        return `(lView[${parent}] as Element).appendChild(lView[${lastRef}])`;
+      case 1:
+        return `(lView[${ref}] as Element).setAttribute("${parser.consumeString()}", "${parser.consumeString()}")`;
+    }
+    throw new Error("Unexpected OpCode: " + getInstructionFromIcuCreateOpCode(opCode));
+  }
+  let lastRef = -1;
+  while (parser.hasMore()) {
+    let value = parser.consumeNumberStringOrMarker();
+    if (value === ICU_MARKER) {
+      const text = parser.consumeString();
+      lastRef = parser.consumeNumber();
+      lines.push(`lView[${lastRef}] = document.createComment("${text}")`);
+    } else if (value === ELEMENT_MARKER) {
+      const text = parser.consumeString();
+      lastRef = parser.consumeNumber();
+      lines.push(`lView[${lastRef}] = document.createElement("${text}")`);
+    } else if (typeof value === "string") {
+      lastRef = parser.consumeNumber();
+      lines.push(`lView[${lastRef}] = document.createTextNode("${value}")`);
+    } else if (typeof value === "number") {
+      const line = consumeOpCode(value);
+      line && lines.push(line);
+    } else {
+      throw new Error("Unexpected value");
+    }
+  }
+  return lines;
+}
+function i18nRemoveOpCodesToString(opcodes) {
+  const removeCodes = opcodes || (Array.isArray(this) ? this : []);
+  let lines = [];
+  for (let i = 0; i < removeCodes.length; i++) {
+    const nodeOrIcuIndex = removeCodes[i];
+    if (nodeOrIcuIndex > 0) {
+      lines.push(`remove(lView[${nodeOrIcuIndex}])`);
+    } else {
+      lines.push(`removeNestedICU(${~nodeOrIcuIndex})`);
+    }
+  }
+  return lines;
+}
+var OpCodeParser = class {
+  i = 0;
+  codes;
+  constructor(codes) {
+    this.codes = codes;
+  }
+  hasMore() {
+    return this.i < this.codes.length;
+  }
+  consumeNumber() {
+    let value = this.codes[this.i++];
+    assertNumber(value, "expecting number in OpCode");
+    return value;
+  }
+  consumeString() {
+    let value = this.codes[this.i++];
+    assertString(value, "expecting string in OpCode");
+    return value;
+  }
+  consumeFunction() {
+    let value = this.codes[this.i++];
+    if (value === null || typeof value === "function") {
+      return value;
+    }
+    throw new Error("expecting function in OpCode");
+  }
+  consumeNumberOrString() {
+    let value = this.codes[this.i++];
+    if (typeof value === "string") {
+      return value;
+    }
+    assertNumber(value, "expecting number or string in OpCode");
+    return value;
+  }
+  consumeNumberStringOrMarker() {
+    let value = this.codes[this.i++];
+    if (typeof value === "string" || typeof value === "number" || value == ICU_MARKER || value == ELEMENT_MARKER) {
+      return value;
+    }
+    assertNumber(value, "expecting number, string, ICU_MARKER or ELEMENT_MARKER in OpCode");
+    return value;
+  }
+};
+var BINDING_REGEXP = /�(\d+):?\d*�/gi;
+var ICU_REGEXP = /({\s*�\d+:?\d*�\s*,\s*\S{6}\s*,[\s\S]*})/gi;
+var NESTED_ICU = /�(\d+)�/;
+var ICU_BLOCK_REGEXP = /^\s*(�\d+:?\d*�)\s*,\s*(select|plural)\s*,/;
+var MARKER = `\uFFFD`;
+var SUBTEMPLATE_REGEXP = /�\/?\*(\d+:\d+)�/gi;
+var PH_REGEXP = /�(\/?[#*]\d+):?\d*�/gi;
+var NGSP_UNICODE_REGEXP = /\uE500/g;
+function replaceNgsp(value) {
+  return value.replace(NGSP_UNICODE_REGEXP, " ");
+}
+function attachDebugGetter(obj, debugGetter) {
+  if (ngDevMode) {
+    Object.defineProperty(obj, "debug", {
+      get: debugGetter,
+      enumerable: false
+    });
+  } else {
+    throw new Error("This method should be guarded with `ngDevMode` so that it can be tree shaken in production!");
+  }
+}
+function i18nStartFirstCreatePass(tView, parentTNodeIndex, lView, index, message, subTemplateIndex) {
+  const rootTNode = getCurrentParentTNode();
+  const createOpCodes = [];
+  const updateOpCodes = [];
+  const existingTNodeStack = [[]];
+  const astStack = [[]];
+  if (ngDevMode) {
+    attachDebugGetter(createOpCodes, i18nCreateOpCodesToString);
+    attachDebugGetter(updateOpCodes, i18nUpdateOpCodesToString);
+  }
+  message = getTranslationForTemplate(message, subTemplateIndex);
+  const msgParts = replaceNgsp(message).split(PH_REGEXP);
+  for (let i = 0; i < msgParts.length; i++) {
+    let value = msgParts[i];
+    if ((i & 1) === 0) {
+      const parts = i18nParseTextIntoPartsAndICU(value);
+      for (let j = 0; j < parts.length; j++) {
+        let part = parts[j];
+        if ((j & 1) === 0) {
+          const text = part;
+          ngDevMode && assertString(text, "Parsed ICU part should be string");
+          if (text !== "") {
+            i18nStartFirstCreatePassProcessTextNode(astStack[0], tView, rootTNode, existingTNodeStack[0], createOpCodes, updateOpCodes, lView, text);
+          }
+        } else {
+          const icuExpression = part;
+          if (typeof icuExpression !== "object") {
+            throw new Error(`Unable to parse ICU expression in "${message}" message.`);
+          }
+          const icuContainerTNode = createTNodeAndAddOpCode(tView, rootTNode, existingTNodeStack[0], lView, createOpCodes, ngDevMode ? `ICU ${index}:${icuExpression.mainBinding}` : "", true);
+          const icuNodeIndex = icuContainerTNode.index;
+          ngDevMode && assertGreaterThanOrEqual(icuNodeIndex, HEADER_OFFSET, "Index must be in absolute LView offset");
+          icuStart(astStack[0], tView, lView, updateOpCodes, parentTNodeIndex, icuExpression, icuNodeIndex);
+        }
+      }
+    } else {
+      const isClosing = value.charCodeAt(0) === 47;
+      const type = value.charCodeAt(isClosing ? 1 : 0);
+      ngDevMode && assertOneOf(type, 42, 35);
+      const index2 = HEADER_OFFSET + Number.parseInt(value.substring(isClosing ? 2 : 1));
+      if (isClosing) {
+        existingTNodeStack.shift();
+        astStack.shift();
+        setCurrentTNode(getCurrentParentTNode(), false);
+      } else {
+        const tNode = createTNodePlaceholder(tView, existingTNodeStack[0], index2);
+        existingTNodeStack.unshift([]);
+        setCurrentTNode(tNode, true);
+        const placeholderNode = {
+          kind: 2,
+          index: index2,
+          children: [],
+          type: type === 35 ? 0 : 1
+        };
+        astStack[0].push(placeholderNode);
+        astStack.unshift(placeholderNode.children);
+      }
+    }
+  }
+  tView.data[index] = {
+    create: createOpCodes,
+    update: updateOpCodes,
+    ast: astStack[0],
+    parentTNodeIndex
+  };
+}
+function createTNodeAndAddOpCode(tView, rootTNode, existingTNodes, lView, createOpCodes, text, isICU) {
+  const i18nNodeIdx = allocExpando(tView, lView, 1, null);
+  let opCode = i18nNodeIdx << I18nCreateOpCode.SHIFT;
+  let parentTNode = getCurrentParentTNode();
+  if (rootTNode === parentTNode) {
+    parentTNode = null;
+  }
+  if (parentTNode === null) {
+    opCode |= I18nCreateOpCode.APPEND_EAGERLY;
+  }
+  if (isICU) {
+    opCode |= I18nCreateOpCode.COMMENT;
+    ensureIcuContainerVisitorLoaded(loadIcuContainerVisitor);
+  }
+  createOpCodes.push(opCode, text === null ? "" : text);
+  const tNode = createTNodeAtIndex(tView, i18nNodeIdx, isICU ? 32 : 1, text === null ? ngDevMode ? "{{?}}" : "" : text, null);
+  addTNodeAndUpdateInsertBeforeIndex(existingTNodes, tNode);
+  const tNodeIdx = tNode.index;
+  setCurrentTNode(tNode, false);
+  if (parentTNode !== null && rootTNode !== parentTNode) {
+    setTNodeInsertBeforeIndex(parentTNode, tNodeIdx);
+  }
+  return tNode;
+}
+function i18nStartFirstCreatePassProcessTextNode(ast, tView, rootTNode, existingTNodes, createOpCodes, updateOpCodes, lView, text) {
+  const hasBinding = text.match(BINDING_REGEXP);
+  const tNode = createTNodeAndAddOpCode(tView, rootTNode, existingTNodes, lView, createOpCodes, hasBinding ? null : text, false);
+  const index = tNode.index;
+  if (hasBinding) {
+    generateBindingUpdateOpCodes(updateOpCodes, text, index, null, 0, null);
+  }
+  ast.push({
+    kind: 0,
+    index
+  });
+}
+function i18nAttributesFirstPass(tView, index, values) {
+  const previousElement = getCurrentTNode();
+  const previousElementIndex = previousElement.index;
+  const updateOpCodes = [];
+  if (ngDevMode) {
+    attachDebugGetter(updateOpCodes, i18nUpdateOpCodesToString);
+  }
+  if (tView.firstCreatePass && tView.data[index] === null) {
+    for (let i = 0; i < values.length; i += 2) {
+      const attrName = values[i];
+      const message = values[i + 1];
+      if (message !== "") {
+        if (ICU_REGEXP.test(message)) {
+          throw new Error(`ICU expressions are not supported in attributes. Message: "${message}".`);
+        }
+        const tagName = previousElement.namespace ? `:${previousElement.namespace}:${previousElement.value}` : previousElement.value;
+        generateBindingUpdateOpCodes(updateOpCodes, message, previousElementIndex, attrName, countBindings(updateOpCodes), i18nResolveSanitizer(attrName, tagName));
+      }
+    }
+    tView.data[index] = updateOpCodes;
+  }
+}
+function generateBindingUpdateOpCodes(updateOpCodes, str, destinationNode, attrName, bindingStart, sanitizeFn) {
+  ngDevMode && assertGreaterThanOrEqual(destinationNode, HEADER_OFFSET, "Index must be in absolute LView offset");
+  const maskIndex = updateOpCodes.length;
+  const sizeIndex = maskIndex + 1;
+  updateOpCodes.push(null, null);
+  const startIndex = maskIndex + 2;
+  if (ngDevMode) {
+    attachDebugGetter(updateOpCodes, i18nUpdateOpCodesToString);
+  }
+  const textParts = str.split(BINDING_REGEXP);
+  let mask = 0;
+  for (let j = 0; j < textParts.length; j++) {
+    const textValue = textParts[j];
+    if (j & 1) {
+      const bindingIndex = bindingStart + parseInt(textValue, 10);
+      updateOpCodes.push(-1 - bindingIndex);
+      mask = mask | toMaskBit(bindingIndex);
+    } else if (textValue !== "") {
+      updateOpCodes.push(textValue);
+    }
+  }
+  updateOpCodes.push(destinationNode << 2 | (attrName ? 1 : 0));
+  if (attrName) {
+    updateOpCodes.push(attrName, sanitizeFn);
+  }
+  updateOpCodes[maskIndex] = mask;
+  updateOpCodes[sizeIndex] = updateOpCodes.length - startIndex;
+  return mask;
+}
+function countBindings(opCodes) {
+  let count = 0;
+  for (let i = 0; i < opCodes.length; i++) {
+    const opCode = opCodes[i];
+    if (typeof opCode === "number" && opCode < 0) {
+      count++;
+    }
+  }
+  return count;
+}
+function toMaskBit(bindingIndex) {
+  return 1 << Math.min(bindingIndex, 31);
+}
+function removeInnerTemplateTranslation(message) {
+  let match2;
+  let res = "";
+  let index = 0;
+  let inTemplate = false;
+  let tagMatched;
+  while ((match2 = SUBTEMPLATE_REGEXP.exec(message)) !== null) {
+    if (!inTemplate) {
+      res += message.substring(index, match2.index + match2[0].length);
+      tagMatched = match2[1];
+      inTemplate = true;
+    } else {
+      if (match2[0] === `${MARKER}/*${tagMatched}${MARKER}`) {
+        index = match2.index;
+        inTemplate = false;
+      }
+    }
+  }
+  ngDevMode && assertEqual(inTemplate, false, `Tag mismatch: unable to find the end of the sub-template in the translation "${message}"`);
+  res += message.slice(index);
+  return res;
+}
+function getTranslationForTemplate(message, subTemplateIndex) {
+  if (isRootTemplateMessage(subTemplateIndex)) {
+    return removeInnerTemplateTranslation(message);
+  } else {
+    const start = message.indexOf(`:${subTemplateIndex}${MARKER}`) + 2 + subTemplateIndex.toString().length;
+    const end = message.search(new RegExp(`${MARKER}\\/\\*\\d+:${subTemplateIndex}${MARKER}`));
+    return removeInnerTemplateTranslation(message.substring(start, end));
+  }
+}
+function icuStart(ast, tView, lView, updateOpCodes, parentIdx, icuExpression, anchorIdx) {
+  ngDevMode && assertDefined(icuExpression, "ICU expression must be defined");
+  let bindingMask = 0;
+  const tIcu = {
+    type: icuExpression.type,
+    currentCaseLViewIndex: allocExpando(tView, lView, 1, null),
+    anchorIdx,
+    cases: [],
+    create: [],
+    remove: [],
+    update: []
+  };
+  addUpdateIcuSwitch(updateOpCodes, icuExpression, anchorIdx);
+  setTIcu(tView, anchorIdx, tIcu);
+  const values = icuExpression.values;
+  const cases = [];
+  for (let i = 0; i < values.length; i++) {
+    const valueArr = values[i];
+    const nestedIcus = [];
+    for (let j = 0; j < valueArr.length; j++) {
+      const value = valueArr[j];
+      if (typeof value !== "string") {
+        const icuIndex = nestedIcus.push(value) - 1;
+        valueArr[j] = `<!--\uFFFD${icuIndex}\uFFFD-->`;
+      }
+    }
+    const caseAst = [];
+    cases.push(caseAst);
+    bindingMask = parseIcuCase(caseAst, tView, tIcu, lView, updateOpCodes, parentIdx, icuExpression.cases[i], valueArr.join(""), nestedIcus) | bindingMask;
+  }
+  if (bindingMask) {
+    addUpdateIcuUpdate(updateOpCodes, bindingMask, anchorIdx);
+  }
+  ast.push({
+    kind: 3,
+    index: anchorIdx,
+    cases,
+    currentCaseLViewIndex: tIcu.currentCaseLViewIndex
+  });
+}
+function parseICUBlock(pattern) {
+  const cases = [];
+  const values = [];
+  let icuType = 1;
+  let mainBinding = 0;
+  pattern = pattern.replace(ICU_BLOCK_REGEXP, function(str, binding, type) {
+    if (type === "select") {
+      icuType = 0;
+    } else {
+      icuType = 1;
+    }
+    mainBinding = parseInt(binding.slice(1), 10);
+    return "";
+  });
+  const parts = i18nParseTextIntoPartsAndICU(pattern);
+  for (let pos = 0; pos < parts.length; ) {
+    let key = parts[pos++].trim();
+    if (icuType === 1) {
+      key = key.replace(/\s*(?:=)?(\w+)\s*/, "$1");
+    }
+    if (key.length) {
+      cases.push(key);
+    }
+    const blocks = i18nParseTextIntoPartsAndICU(parts[pos++]);
+    if (cases.length > values.length) {
+      values.push(blocks);
+    }
+  }
+  return {
+    type: icuType,
+    mainBinding,
+    cases,
+    values
+  };
+}
+function i18nParseTextIntoPartsAndICU(pattern) {
+  if (!pattern) {
+    return [];
+  }
+  let prevPos = 0;
+  const braceStack = [];
+  const results = [];
+  const braces = /[{}]/g;
+  braces.lastIndex = 0;
+  let match2;
+  while (match2 = braces.exec(pattern)) {
+    const pos = match2.index;
+    if (match2[0] == "}") {
+      braceStack.pop();
+      if (braceStack.length == 0) {
+        const block = pattern.substring(prevPos, pos);
+        if (ICU_BLOCK_REGEXP.test(block)) {
+          results.push(parseICUBlock(block));
+        } else {
+          results.push(block);
+        }
+        prevPos = pos + 1;
+      }
+    } else {
+      if (braceStack.length == 0) {
+        const substring2 = pattern.substring(prevPos, pos);
+        results.push(substring2);
+        prevPos = pos + 1;
+      }
+      braceStack.push("{");
+    }
+  }
+  const substring = pattern.substring(prevPos);
+  results.push(substring);
+  return results;
+}
+function parseIcuCase(ast, tView, tIcu, lView, updateOpCodes, parentIdx, caseName, unsafeCaseHtml, nestedIcus) {
+  const create = [];
+  const remove2 = [];
+  const update = [];
+  if (ngDevMode) {
+    attachDebugGetter(create, icuCreateOpCodesToString);
+    attachDebugGetter(remove2, i18nRemoveOpCodesToString);
+    attachDebugGetter(update, i18nUpdateOpCodesToString);
+  }
+  tIcu.cases.push(caseName);
+  tIcu.create.push(create);
+  tIcu.remove.push(remove2);
+  tIcu.update.push(update);
+  const inertBodyHelper2 = getInertBodyHelper(getDocument());
+  const inertBodyElement = inertBodyHelper2.getInertBodyElement(unsafeCaseHtml);
+  ngDevMode && assertDefined(inertBodyElement, "Unable to generate inert body element");
+  const inertRootNode = getTemplateContent(inertBodyElement) || inertBodyElement;
+  if (inertRootNode) {
+    return walkIcuTree(ast, tView, tIcu, lView, updateOpCodes, create, remove2, update, inertRootNode, parentIdx, nestedIcus, 0);
+  } else {
+    return 0;
+  }
+}
+function walkIcuTree(ast, tView, tIcu, lView, sharedUpdateOpCodes, create, remove2, update, parentNode, parentIdx, nestedIcus, depth) {
+  let bindingMask = 0;
+  let currentNode = parentNode.firstChild;
+  while (currentNode) {
+    const newIndex = allocExpando(tView, lView, 1, null);
+    switch (currentNode.nodeType) {
+      case Node.ELEMENT_NODE:
+        const element = currentNode;
+        const tagName = element.tagName.toLowerCase();
+        if (VALID_ELEMENTS.hasOwnProperty(tagName)) {
+          addCreateNodeAndAppend(create, ELEMENT_MARKER, tagName, parentIdx, newIndex);
+          tView.data[newIndex] = tagName;
+          const elAttrs = element.attributes;
+          for (let i = 0; i < elAttrs.length; i++) {
+            const attr = elAttrs.item(i);
+            const lowerAttrName = attr.name.toLowerCase();
+            const hasBinding2 = !!attr.value.match(BINDING_REGEXP);
+            const elementNS = element.namespaceURI;
+            const tagNameWithNamespace = elementNS === "http://www.w3.org/2000/svg" ? `:svg:${tagName}` : elementNS === "http://www.w3.org/1998/Math/MathML" ? `:math:${tagName}` : tagName;
+            if (hasBinding2) {
+              if (VALID_ATTRS.hasOwnProperty(lowerAttrName)) {
+                generateBindingUpdateOpCodes(update, attr.value, newIndex, attr.name, 0, i18nResolveSanitizer(lowerAttrName, tagNameWithNamespace));
+              } else {
+                ngDevMode && console.warn(`WARNING: ignoring unsafe attribute value ${lowerAttrName} on element ${tagName} (see ${XSS_SECURITY_URL})`);
+              }
+            } else if (VALID_ATTRS[lowerAttrName]) {
+              let val = attr.value;
+              const sanitizer = i18nResolveSanitizer(lowerAttrName, tagNameWithNamespace);
+              if (sanitizer) {
+                if (typeof ngDevMode !== "undefined" && ngDevMode) {
+                  console.warn(`WARNING: ignoring unsafe attribute ${lowerAttrName} on element ${tagName} (see ${XSS_SECURITY_URL})`);
+                }
+                addCreateAttribute(create, newIndex, attr.name, "unsafe:blocked");
+              } else {
+                addCreateAttribute(create, newIndex, attr.name, val);
+              }
+            } else {
+              if (typeof ngDevMode !== "undefined" && ngDevMode) {
+                console.warn(`WARNING: ignoring unknown attribute name ${lowerAttrName} on element ${tagName} (see ${XSS_SECURITY_URL})`);
+              }
+            }
+          }
+          const elementNode = {
+            kind: 1,
+            index: newIndex,
+            children: []
+          };
+          ast.push(elementNode);
+          bindingMask = walkIcuTree(elementNode.children, tView, tIcu, lView, sharedUpdateOpCodes, create, remove2, update, currentNode, newIndex, nestedIcus, depth + 1) | bindingMask;
+          addRemoveNode(remove2, newIndex, depth);
+        }
+        break;
+      case Node.TEXT_NODE:
+        const value = currentNode.textContent || "";
+        const hasBinding = value.match(BINDING_REGEXP);
+        addCreateNodeAndAppend(create, null, hasBinding ? "" : value, parentIdx, newIndex);
+        addRemoveNode(remove2, newIndex, depth);
+        if (hasBinding) {
+          bindingMask = generateBindingUpdateOpCodes(update, value, newIndex, null, 0, null) | bindingMask;
+        }
+        ast.push({
+          kind: 0,
+          index: newIndex
+        });
+        break;
+      case Node.COMMENT_NODE:
+        const isNestedIcu = NESTED_ICU.exec(currentNode.textContent || "");
+        if (isNestedIcu) {
+          const nestedIcuIndex = parseInt(isNestedIcu[1], 10);
+          const icuExpression = nestedIcus[nestedIcuIndex];
+          addCreateNodeAndAppend(create, ICU_MARKER, ngDevMode ? `nested ICU ${nestedIcuIndex}` : "", parentIdx, newIndex);
+          icuStart(ast, tView, lView, sharedUpdateOpCodes, parentIdx, icuExpression, newIndex);
+          addRemoveNestedIcu(remove2, newIndex, depth);
+        }
+        break;
+    }
+    currentNode = currentNode.nextSibling;
+  }
+  return bindingMask;
+}
+function addRemoveNode(remove2, index, depth) {
+  if (depth === 0) {
+    remove2.push(index);
+  }
+}
+function addRemoveNestedIcu(remove2, index, depth) {
+  if (depth === 0) {
+    remove2.push(~index);
+    remove2.push(index);
+  }
+}
+function addUpdateIcuSwitch(update, icuExpression, index) {
+  update.push(toMaskBit(icuExpression.mainBinding), 2, -1 - icuExpression.mainBinding, index << 2 | 2);
+}
+function addUpdateIcuUpdate(update, bindingMask, index) {
+  update.push(bindingMask, 1, index << 2 | 3);
+}
+function addCreateNodeAndAppend(create, marker, text, appendToParentIdx, createAtIdx) {
+  if (marker !== null) {
+    create.push(marker);
+  }
+  create.push(text, createAtIdx, icuCreateOpCode(0, appendToParentIdx, createAtIdx));
+}
+function addCreateAttribute(create, newIndex, attrName, attrValue) {
+  create.push(newIndex << 1 | 1, attrName, attrValue);
+}
+function splitNsName(elementName, fatal = true) {
+  if (elementName[0] != ":") {
+    return [null, elementName];
+  }
+  const colonIndex = elementName.indexOf(":", 1);
+  if (colonIndex === -1) {
+    if (fatal) {
+      throw new Error(`Unsupported format "${elementName}" expecting ":namespace:name"`);
+    } else {
+      return [null, elementName];
+    }
+  }
+  return [elementName.slice(1, colonIndex), elementName.slice(colonIndex + 1)];
+}
+function normalizeTagName(tagName) {
+  const tagNameLower = tagName.toLowerCase();
+  const [ns, name] = splitNsName(tagNameLower, false);
+  return ns === SVG_NAMESPACE || ns === MATH_ML_NAMESPACE ? `:${ns}:${name}` : name;
+}
+function i18nResolveSanitizer(attrName, tagName) {
+  const lowerAttrName = attrName.toLowerCase();
+  const lowerTagName = tagName ? normalizeTagName(tagName) : "*";
+  const schema = SECURITY_SCHEMA();
+  const schemaContext = schema[`${lowerTagName}|${lowerAttrName}`] || schema[`*|${lowerAttrName}`] || SecurityContext.NONE;
+  switch (schemaContext) {
+    case SecurityContext.HTML:
+      return \u0275\u0275sanitizeHtml;
+    case SecurityContext.STYLE:
+      return \u0275\u0275sanitizeStyle;
+    case SecurityContext.SCRIPT:
+      return \u0275\u0275sanitizeScript;
+    case SecurityContext.URL:
+      return _sanitizeUrl;
+    case SecurityContext.RESOURCE_URL:
+      return \u0275\u0275sanitizeResourceUrl;
+    case SecurityContext.ATTRIBUTE_NO_BINDING:
+      return \u0275\u0275validateAttribute;
+    default:
+      return null;
+  }
+}
+var ROOT_TEMPLATE_ID = 0;
+var PP_MULTI_VALUE_PLACEHOLDERS_REGEXP = /\[(�.+?�?)\]/;
+var PP_PLACEHOLDERS_REGEXP = /\[(�.+?�?)\]|(�\/?\*\d+:\d+�)/g;
+var PP_ICU_VARS_REGEXP = /({\s*)(VAR_(PLURAL|SELECT)(_\d+)?)(\s*,)/g;
+var PP_ICU_PLACEHOLDERS_REGEXP = /{([A-Z0-9_]+)}/g;
+var PP_ICUS_REGEXP = /�I18N_EXP_(ICU(_\d+)?)�/g;
+var PP_CLOSE_TEMPLATE_REGEXP = /\/\*/;
+var PP_TEMPLATE_ID_REGEXP = /\d+\:(\d+)/;
+function i18nPostprocess(message, replacements = {}) {
+  let result = message;
+  if (PP_MULTI_VALUE_PLACEHOLDERS_REGEXP.test(message)) {
+    const matches = {};
+    const templateIdsStack = [ROOT_TEMPLATE_ID];
+    result = result.replace(PP_PLACEHOLDERS_REGEXP, (m, phs, tmpl) => {
+      const content = phs || tmpl;
+      const placeholders = matches[content] || [];
+      if (!placeholders.length) {
+        content.split("|").forEach((placeholder2) => {
+          const match2 = placeholder2.match(PP_TEMPLATE_ID_REGEXP);
+          const templateId2 = match2 ? parseInt(match2[1], 10) : ROOT_TEMPLATE_ID;
+          const isCloseTemplateTag2 = PP_CLOSE_TEMPLATE_REGEXP.test(placeholder2);
+          placeholders.push([templateId2, isCloseTemplateTag2, placeholder2]);
+        });
+        matches[content] = placeholders;
+      }
+      if (!placeholders.length) {
+        throw new Error(`i18n postprocess: unmatched placeholder - ${content}`);
+      }
+      const currentTemplateId = templateIdsStack[templateIdsStack.length - 1];
+      let idx = 0;
+      for (let i = 0; i < placeholders.length; i++) {
+        if (placeholders[i][0] === currentTemplateId) {
+          idx = i;
+          break;
+        }
+      }
+      const [templateId, isCloseTemplateTag, placeholder] = placeholders[idx];
+      if (isCloseTemplateTag) {
+        templateIdsStack.pop();
+      } else if (currentTemplateId !== templateId) {
+        templateIdsStack.push(templateId);
+      }
+      placeholders.splice(idx, 1);
+      return placeholder;
+    });
+  }
+  if (!Object.keys(replacements).length) {
+    return result;
+  }
+  result = result.replace(PP_ICU_VARS_REGEXP, (match2, start, key, _type, _idx, end) => {
+    return replacements.hasOwnProperty(key) ? `${start}${replacements[key]}${end}` : match2;
+  });
+  result = result.replace(PP_ICU_PLACEHOLDERS_REGEXP, (match2, key) => {
+    return replacements.hasOwnProperty(key) ? replacements[key] : match2;
+  });
+  result = result.replace(PP_ICUS_REGEXP, (match2, key) => {
+    if (replacements.hasOwnProperty(key)) {
+      const list = replacements[key];
+      if (!list.length) {
+        throw new Error(`i18n postprocess: unmatched ICU - ${match2} with key: ${key}`);
+      }
+      return list.shift();
+    }
+    return match2;
+  });
+  return result;
+}
+function \u0275\u0275i18nStart(index, messageIndex, subTemplateIndex = -1) {
+  const tView = getTView();
+  const lView = getLView();
+  const adjustedIndex = HEADER_OFFSET + index;
+  ngDevMode && assertDefined(tView, `tView should be defined`);
+  const message = getConstant(tView.consts, messageIndex);
+  const parentTNode = getCurrentParentTNode();
+  if (tView.firstCreatePass) {
+    i18nStartFirstCreatePass(tView, parentTNode === null ? 0 : parentTNode.index, lView, adjustedIndex, message, subTemplateIndex);
+  }
+  if (tView.type === 2) {
+    const componentLView = lView[DECLARATION_COMPONENT_VIEW];
+    componentLView[FLAGS] |= 32;
+  } else {
+    lView[FLAGS] |= 32;
+  }
+  const tI18n = tView.data[adjustedIndex];
+  const sameViewParentTNode = parentTNode === lView[T_HOST] ? null : parentTNode;
+  const parentRNode = getClosestRElement(tView, sameViewParentTNode, lView);
+  const insertInFrontOf = parentTNode && parentTNode.type & 8 ? lView[parentTNode.index] : null;
+  prepareI18nBlockForHydration(lView, adjustedIndex, parentTNode, subTemplateIndex);
+  applyCreateOpCodes(lView, tI18n.create, parentRNode, insertInFrontOf);
+  setInI18nBlock(true);
+}
+function \u0275\u0275i18nEnd() {
+  setInI18nBlock(false);
+}
+function \u0275\u0275i18n(index, messageIndex, subTemplateIndex) {
+  \u0275\u0275i18nStart(index, messageIndex, subTemplateIndex);
+  \u0275\u0275i18nEnd();
+}
+function \u0275\u0275i18nAttributes(index, attrsIndex) {
+  const tView = getTView();
+  ngDevMode && assertDefined(tView, `tView should be defined`);
+  const attrs = getConstant(tView.consts, attrsIndex);
+  i18nAttributesFirstPass(tView, index + HEADER_OFFSET, attrs);
+}
+function \u0275\u0275i18nExp(value) {
+  const lView = getLView();
+  setMaskBit(bindingUpdated(lView, nextBindingIndex(), value));
+  return \u0275\u0275i18nExp;
+}
+function \u0275\u0275i18nApply(index) {
+  applyI18n(getTView(), getLView(), index + HEADER_OFFSET);
+}
+function \u0275\u0275i18nPostprocess(message, replacements = {}) {
+  return i18nPostprocess(message, replacements);
+}
+function \u0275\u0275listener(eventName, listenerFn, eventTargetResolver) {
+  const lView = getLView();
+  const tView = getTView();
+  const tNode = getCurrentTNode();
+  listenerInternal(tView, lView, lView[RENDERER], tNode, eventName, listenerFn, eventTargetResolver);
+  return \u0275\u0275listener;
+}
+function \u0275\u0275syntheticHostListener(eventName, listenerFn) {
+  const tNode = getCurrentTNode();
+  const lView = getLView();
+  const tView = getTView();
+  const currentDef = getCurrentDirectiveDef(tView.data);
+  const renderer = loadComponentRenderer(currentDef, tNode, lView);
+  listenerInternal(tView, lView, renderer, tNode, eventName, listenerFn);
+  return \u0275\u0275syntheticHostListener;
+}
+function \u0275\u0275domListener(eventName, listenerFn, eventTargetResolver) {
+  const lView = getLView();
+  const tView = getTView();
+  const tNode = getCurrentTNode();
+  if (tNode.type & 3 || eventTargetResolver) {
+    listenToDomEvent(tNode, tView, lView, eventTargetResolver, lView[RENDERER], eventName, listenerFn, wrapListener(tNode, lView, listenerFn));
+  }
+  return \u0275\u0275domListener;
+}
+function listenerInternal(tView, lView, renderer, tNode, eventName, listenerFn, eventTargetResolver) {
+  ngDevMode && assertTNodeType(tNode, 3 | 12);
+  let processOutputs = true;
+  let wrappedListener = null;
+  if (tNode.type & 3 || eventTargetResolver) {
+    wrappedListener ??= wrapListener(tNode, lView, listenerFn);
+    const hasCoalescedDomEvent = listenToDomEvent(tNode, tView, lView, eventTargetResolver, renderer, eventName, listenerFn, wrappedListener);
+    if (hasCoalescedDomEvent) {
+      processOutputs = false;
+    }
+  }
+  if (processOutputs) {
+    const outputConfig = tNode.outputs?.[eventName];
+    const hostDirectiveOutputConfig = tNode.hostDirectiveOutputs?.[eventName];
+    if (hostDirectiveOutputConfig && hostDirectiveOutputConfig.length) {
+      for (let i = 0; i < hostDirectiveOutputConfig.length; i += 2) {
+        const index = hostDirectiveOutputConfig[i];
+        const lookupName = hostDirectiveOutputConfig[i + 1];
+        wrappedListener ??= wrapListener(tNode, lView, listenerFn);
+        listenToOutput(tNode, lView, index, lookupName, eventName, wrappedListener);
+      }
+    }
+    if (outputConfig && outputConfig.length) {
+      for (const index of outputConfig) {
+        wrappedListener ??= wrapListener(tNode, lView, listenerFn);
+        listenToOutput(tNode, lView, index, eventName, eventName, wrappedListener);
+      }
+    }
+  }
+}
+function \u0275\u0275nextContext(level = 1) {
+  return nextContextImpl(level);
+}
+function matchingProjectionSlotIndex(tNode, projectionSlots) {
+  let wildcardNgContentIndex = null;
+  const ngProjectAsAttrVal = getProjectAsAttrValue(tNode);
+  for (let i = 0; i < projectionSlots.length; i++) {
+    const slotValue = projectionSlots[i];
+    if (slotValue === "*") {
+      wildcardNgContentIndex = i;
+      continue;
+    }
+    if (ngProjectAsAttrVal === null ? isNodeMatchingSelectorList(tNode, slotValue, true) : isSelectorInSelectorList(ngProjectAsAttrVal, slotValue)) {
+      return i;
+    }
+  }
+  return wildcardNgContentIndex;
+}
+function \u0275\u0275projectionDef(projectionSlots) {
+  const componentNode = getLView()[DECLARATION_COMPONENT_VIEW][T_HOST];
+  if (!componentNode.projection) {
+    const numProjectionSlots = projectionSlots ? projectionSlots.length : 1;
+    const projectionHeads = componentNode.projection = newArray(numProjectionSlots, null);
+    const tails = projectionHeads.slice();
+    let componentChild = componentNode.child;
+    while (componentChild !== null) {
+      if (componentChild.type !== 128) {
+        const slotIndex = projectionSlots ? matchingProjectionSlotIndex(componentChild, projectionSlots) : 0;
+        if (slotIndex !== null) {
+          if (tails[slotIndex]) {
+            tails[slotIndex].projectionNext = componentChild;
+          } else {
+            projectionHeads[slotIndex] = componentChild;
+          }
+          tails[slotIndex] = componentChild;
+        }
+      }
+      componentChild = componentChild.next;
+    }
+  }
+}
+function \u0275\u0275projection(nodeIndex, selectorIndex = 0, attrs, fallbackTemplateFn, fallbackDecls, fallbackVars) {
+  const lView = getLView();
+  const tView = getTView();
+  const fallbackIndex = fallbackTemplateFn ? nodeIndex + 1 : null;
+  if (fallbackIndex !== null) {
+    declareNoDirectiveHostTemplate(lView, tView, fallbackIndex, fallbackTemplateFn, fallbackDecls, fallbackVars, null, attrs);
+  }
+  const tProjectionNode = getOrCreateTNode(tView, HEADER_OFFSET + nodeIndex, 16, null, attrs || null);
+  if (tProjectionNode.projection === null) {
+    tProjectionNode.projection = selectorIndex;
+  }
+  setCurrentTNodeAsNotParent();
+  const hydrationInfo = lView[HYDRATION];
+  const isNodeCreationMode = !hydrationInfo || isInSkipHydrationBlock();
+  const componentHostNode = lView[DECLARATION_COMPONENT_VIEW][T_HOST];
+  const isEmpty = componentHostNode.projection[tProjectionNode.projection] === null;
+  if (isEmpty && fallbackIndex !== null) {
+    insertFallbackContent(lView, tView, fallbackIndex);
+  } else if (isNodeCreationMode && !isDetachedByI18n(tProjectionNode)) {
+    applyProjection(tView, lView, tProjectionNode);
+  }
+}
+function insertFallbackContent(lView, tView, fallbackIndex) {
+  const adjustedIndex = HEADER_OFFSET + fallbackIndex;
+  const fallbackTNode = tView.data[adjustedIndex];
+  const fallbackLContainer = lView[adjustedIndex];
+  ngDevMode && assertTNode(fallbackTNode);
+  ngDevMode && assertLContainer(fallbackLContainer);
+  const dehydratedView = findMatchingDehydratedView(fallbackLContainer, fallbackTNode.tView.ssrId);
+  const fallbackLView = createAndRenderEmbeddedLView(lView, fallbackTNode, void 0, {
+    dehydratedView
+  });
+  addLViewToLContainer(fallbackLContainer, fallbackLView, 0, shouldAddViewToDom(fallbackTNode, dehydratedView));
+}
+function \u0275\u0275contentQuery(directiveIndex, predicate, flags, read) {
+  createContentQuery(directiveIndex, predicate, flags, read);
+  return \u0275\u0275contentQuery;
+}
+function \u0275\u0275viewQuery(predicate, flags, read) {
+  createViewQuery(predicate, flags, read);
+  return \u0275\u0275viewQuery;
+}
+function \u0275\u0275queryRefresh(queryList) {
+  const lView = getLView();
+  const tView = getTView();
+  const queryIndex = getCurrentQueryIndex();
+  setCurrentQueryIndex(queryIndex + 1);
+  const tQuery = getTQuery(tView, queryIndex);
+  if (queryList.dirty && isCreationMode(lView) === ((tQuery.metadata.flags & 2) === 2)) {
+    if (tQuery.matches === null) {
+      queryList.reset([]);
+    } else {
+      const result = getQueryResults(lView, queryIndex);
+      queryList.reset(result, unwrapElementRef);
+      queryList.notifyOnChanges();
+    }
+    return true;
+  }
+  return false;
+}
+function \u0275\u0275loadQuery() {
+  return loadQueryInternal(getLView(), getCurrentQueryIndex());
+}
+function \u0275\u0275contentQuerySignal(directiveIndex, target, predicate, flags, read) {
+  bindQueryToSignal(target, createContentQuery(directiveIndex, predicate, flags, read));
+  return \u0275\u0275contentQuerySignal;
+}
+function \u0275\u0275viewQuerySignal(target, predicate, flags, read) {
+  bindQueryToSignal(target, createViewQuery(predicate, flags, read));
+  return \u0275\u0275viewQuerySignal;
+}
+function \u0275\u0275queryAdvance(indexOffset = 1) {
+  setCurrentQueryIndex(getCurrentQueryIndex() + indexOffset);
+}
+function \u0275\u0275reference(index) {
+  const contextLView = getContextLView();
+  return load(contextLView, HEADER_OFFSET + index);
+}
+function toTStylingRange(prev, next) {
+  ngDevMode && assertNumberInRange(prev, 0, 32767);
+  ngDevMode && assertNumberInRange(next, 0, 32767);
+  return prev << 17 | next << 2;
+}
+function getTStylingRangePrev(tStylingRange) {
+  ngDevMode && assertNumber(tStylingRange, "expected number");
+  return tStylingRange >> 17 & 32767;
+}
+function getTStylingRangePrevDuplicate(tStylingRange) {
+  ngDevMode && assertNumber(tStylingRange, "expected number");
+  return (tStylingRange & 2) == 2;
+}
+function setTStylingRangePrev(tStylingRange, previous) {
+  ngDevMode && assertNumber(tStylingRange, "expected number");
+  ngDevMode && assertNumberInRange(previous, 0, 32767);
+  return tStylingRange & 131071 | previous << 17;
+}
+function setTStylingRangePrevDuplicate(tStylingRange) {
+  ngDevMode && assertNumber(tStylingRange, "expected number");
+  return tStylingRange | 2;
+}
+function getTStylingRangeNext(tStylingRange) {
+  ngDevMode && assertNumber(tStylingRange, "expected number");
+  return (tStylingRange & 131068) >> 2;
+}
+function setTStylingRangeNext(tStylingRange, next) {
+  ngDevMode && assertNumber(tStylingRange, "expected number");
+  ngDevMode && assertNumberInRange(next, 0, 32767);
+  return tStylingRange & -131069 | next << 2;
+}
+function getTStylingRangeNextDuplicate(tStylingRange) {
+  ngDevMode && assertNumber(tStylingRange, "expected number");
+  return (tStylingRange & 1) === 1;
+}
+function setTStylingRangeNextDuplicate(tStylingRange) {
+  ngDevMode && assertNumber(tStylingRange, "expected number");
+  return tStylingRange | 1;
+}
+function insertTStylingBinding(tData, tNode, tStylingKeyWithStatic, index, isHostBinding, isClassBinding) {
+  ngDevMode && assertFirstUpdatePass(getTView());
+  let tBindings = isClassBinding ? tNode.classBindings : tNode.styleBindings;
+  let tmplHead = getTStylingRangePrev(tBindings);
+  let tmplTail = getTStylingRangeNext(tBindings);
+  tData[index] = tStylingKeyWithStatic;
+  let isKeyDuplicateOfStatic = false;
+  let tStylingKey;
+  if (Array.isArray(tStylingKeyWithStatic)) {
+    const staticKeyValueArray = tStylingKeyWithStatic;
+    tStylingKey = staticKeyValueArray[1];
+    if (tStylingKey === null || keyValueArrayIndexOf(staticKeyValueArray, tStylingKey) > 0) {
+      isKeyDuplicateOfStatic = true;
+    }
+  } else {
+    tStylingKey = tStylingKeyWithStatic;
+  }
+  if (isHostBinding) {
+    const hasTemplateBindings = tmplTail !== 0;
+    if (hasTemplateBindings) {
+      const previousNode = getTStylingRangePrev(tData[tmplHead + 1]);
+      tData[index + 1] = toTStylingRange(previousNode, tmplHead);
+      if (previousNode !== 0) {
+        tData[previousNode + 1] = setTStylingRangeNext(tData[previousNode + 1], index);
+      }
+      tData[tmplHead + 1] = setTStylingRangePrev(tData[tmplHead + 1], index);
+    } else {
+      tData[index + 1] = toTStylingRange(tmplHead, 0);
+      if (tmplHead !== 0) {
+        tData[tmplHead + 1] = setTStylingRangeNext(tData[tmplHead + 1], index);
+      }
+      tmplHead = index;
+    }
+  } else {
+    tData[index + 1] = toTStylingRange(tmplTail, 0);
+    ngDevMode && assertEqual(tmplHead !== 0 && tmplTail === 0, false, "Adding template bindings after hostBindings is not allowed.");
+    if (tmplHead === 0) {
+      tmplHead = index;
+    } else {
+      tData[tmplTail + 1] = setTStylingRangeNext(tData[tmplTail + 1], index);
+    }
+    tmplTail = index;
+  }
+  if (isKeyDuplicateOfStatic) {
+    tData[index + 1] = setTStylingRangePrevDuplicate(tData[index + 1]);
+  }
+  markDuplicates(tData, tStylingKey, index, true);
+  markDuplicates(tData, tStylingKey, index, false);
+  markDuplicateOfResidualStyling(tNode, tStylingKey, tData, index, isClassBinding);
+  tBindings = toTStylingRange(tmplHead, tmplTail);
+  if (isClassBinding) {
+    tNode.classBindings = tBindings;
+  } else {
+    tNode.styleBindings = tBindings;
+  }
+}
+function markDuplicateOfResidualStyling(tNode, tStylingKey, tData, index, isClassBinding) {
+  const residual = isClassBinding ? tNode.residualClasses : tNode.residualStyles;
+  if (residual != null && typeof tStylingKey == "string" && keyValueArrayIndexOf(residual, tStylingKey) >= 0) {
+    tData[index + 1] = setTStylingRangeNextDuplicate(tData[index + 1]);
+  }
+}
+function markDuplicates(tData, tStylingKey, index, isPrevDir) {
+  const tStylingAtIndex = tData[index + 1];
+  const isMap = tStylingKey === null;
+  let cursor = isPrevDir ? getTStylingRangePrev(tStylingAtIndex) : getTStylingRangeNext(tStylingAtIndex);
+  let foundDuplicate = false;
+  while (cursor !== 0 && (foundDuplicate === false || isMap)) {
+    ngDevMode && assertIndexInRange(tData, cursor);
+    const tStylingValueAtCursor = tData[cursor];
+    const tStyleRangeAtCursor = tData[cursor + 1];
+    if (isStylingMatch(tStylingValueAtCursor, tStylingKey)) {
+      foundDuplicate = true;
+      tData[cursor + 1] = isPrevDir ? setTStylingRangeNextDuplicate(tStyleRangeAtCursor) : setTStylingRangePrevDuplicate(tStyleRangeAtCursor);
+    }
+    cursor = isPrevDir ? getTStylingRangePrev(tStyleRangeAtCursor) : getTStylingRangeNext(tStyleRangeAtCursor);
+  }
+  if (foundDuplicate) {
+    tData[index + 1] = isPrevDir ? setTStylingRangePrevDuplicate(tStylingAtIndex) : setTStylingRangeNextDuplicate(tStylingAtIndex);
+  }
+}
+function isStylingMatch(tStylingKeyCursor, tStylingKey) {
+  ngDevMode && assertNotEqual(Array.isArray(tStylingKey), true, "Expected that 'tStylingKey' has been unwrapped");
+  if (tStylingKeyCursor === null || tStylingKey == null || (Array.isArray(tStylingKeyCursor) ? tStylingKeyCursor[1] : tStylingKeyCursor) === tStylingKey) {
+    return true;
+  } else if (Array.isArray(tStylingKeyCursor) && typeof tStylingKey === "string") {
+    return keyValueArrayIndexOf(tStylingKeyCursor, tStylingKey) >= 0;
+  }
+  return false;
+}
+var parserState = {
+  textEnd: 0,
+  key: 0,
+  keyEnd: 0,
+  value: 0,
+  valueEnd: 0
+};
+function getLastParsedKey(text) {
+  return text.substring(parserState.key, parserState.keyEnd);
+}
+function getLastParsedValue(text) {
+  return text.substring(parserState.value, parserState.valueEnd);
+}
+function parseClassName(text) {
+  resetParserState(text);
+  return parseClassNameNext(text, consumeWhitespace(text, 0, parserState.textEnd));
+}
+function parseClassNameNext(text, index) {
+  const end = parserState.textEnd;
+  if (end === index) {
+    return -1;
+  }
+  index = parserState.keyEnd = consumeClassToken(text, parserState.key = index, end);
+  return consumeWhitespace(text, index, end);
+}
+function parseStyle(text) {
+  resetParserState(text);
+  return parseStyleNext(text, consumeWhitespace(text, 0, parserState.textEnd));
+}
+function parseStyleNext(text, startIndex) {
+  const end = parserState.textEnd;
+  let index = parserState.key = consumeWhitespace(text, startIndex, end);
+  if (end === index) {
+    return -1;
+  }
+  index = parserState.keyEnd = consumeStyleKey(text, index, end);
+  index = consumeSeparator(text, index, end, 58);
+  index = parserState.value = consumeWhitespace(text, index, end);
+  index = parserState.valueEnd = consumeStyleValue(text, index, end);
+  return consumeSeparator(text, index, end, 59);
+}
+function resetParserState(text) {
+  parserState.key = 0;
+  parserState.keyEnd = 0;
+  parserState.value = 0;
+  parserState.valueEnd = 0;
+  parserState.textEnd = text.length;
+}
+function consumeWhitespace(text, startIndex, endIndex) {
+  while (startIndex < endIndex && text.charCodeAt(startIndex) <= 32) {
+    startIndex++;
+  }
+  return startIndex;
+}
+function consumeClassToken(text, startIndex, endIndex) {
+  while (startIndex < endIndex && text.charCodeAt(startIndex) > 32) {
+    startIndex++;
+  }
+  return startIndex;
+}
+function consumeStyleKey(text, startIndex, endIndex) {
+  let ch;
+  while (startIndex < endIndex && ((ch = text.charCodeAt(startIndex)) === 45 || ch === 95 || (ch & -33) >= 65 && (ch & -33) <= 90 || ch >= 48 && ch <= 57)) {
+    startIndex++;
+  }
+  return startIndex;
+}
+function consumeSeparator(text, startIndex, endIndex, separator) {
+  startIndex = consumeWhitespace(text, startIndex, endIndex);
+  if (startIndex < endIndex) {
+    if (ngDevMode && text.charCodeAt(startIndex) !== separator) {
+      malformedStyleError(text, String.fromCharCode(separator), startIndex);
+    }
+    startIndex++;
+  }
+  return startIndex;
+}
+function consumeStyleValue(text, startIndex, endIndex) {
+  let ch1 = -1;
+  let ch2 = -1;
+  let ch3 = -1;
+  let i = startIndex;
+  let lastChIndex = i;
+  while (i < endIndex) {
+    const ch = text.charCodeAt(i++);
+    if (ch === 59) {
+      return lastChIndex;
+    } else if (ch === 34 || ch === 39) {
+      lastChIndex = i = consumeQuotedText(text, ch, i, endIndex);
+    } else if (startIndex === i - 4 && ch3 === 85 && ch2 === 82 && ch1 === 76 && ch === 40) {
+      lastChIndex = i = consumeQuotedText(text, 41, i, endIndex);
+    } else if (ch > 32) {
+      lastChIndex = i;
+    }
+    ch3 = ch2;
+    ch2 = ch1;
+    ch1 = ch & -33;
+  }
+  return lastChIndex;
+}
+function consumeQuotedText(text, quoteCharCode, startIndex, endIndex) {
+  let ch1 = -1;
+  let index = startIndex;
+  while (index < endIndex) {
+    const ch = text.charCodeAt(index++);
+    if (ch == quoteCharCode && ch1 !== 92) {
+      return index;
+    }
+    if (ch == 92 && ch1 === 92) {
+      ch1 = 0;
+    } else {
+      ch1 = ch;
+    }
+  }
+  throw ngDevMode ? malformedStyleError(text, String.fromCharCode(quoteCharCode), endIndex) : new Error();
+}
+function malformedStyleError(text, expecting, index) {
+  ngDevMode && assertEqual(typeof text === "string", true, "String expected here");
+  throw throwError2(`Malformed style at location ${index} in string '` + text.substring(0, index) + "[>>" + text.substring(index, index + 1) + "<<]" + text.slice(index + 1) + `'. Expecting '${expecting}'.`);
+}
+function \u0275\u0275styleProp(prop, value, suffix) {
+  checkStylingProperty(prop, value, suffix, false);
+  return \u0275\u0275styleProp;
+}
+function \u0275\u0275classProp(className, value) {
+  checkStylingProperty(className, value, null, true);
+  return \u0275\u0275classProp;
+}
+function \u0275\u0275styleMap(styles) {
+  checkStylingMap(styleKeyValueArraySet, styleStringParser, styles, false);
+}
+function styleStringParser(keyValueArray, text) {
+  for (let i = parseStyle(text); i >= 0; i = parseStyleNext(text, i)) {
+    styleKeyValueArraySet(keyValueArray, getLastParsedKey(text), getLastParsedValue(text));
+  }
+}
+function \u0275\u0275classMap(classes) {
+  checkStylingMap(classKeyValueArraySet, classStringParser, classes, true);
+}
+function classStringParser(keyValueArray, text) {
+  for (let i = parseClassName(text); i >= 0; i = parseClassNameNext(text, i)) {
+    keyValueArraySet(keyValueArray, getLastParsedKey(text), true);
+  }
+}
+function checkStylingProperty(prop, value, suffix, isClassBased) {
+  const lView = getLView();
+  const tView = getTView();
+  const bindingIndex = incrementBindingIndex(2);
+  if (tView.firstUpdatePass) {
+    stylingFirstUpdatePass(tView, prop, bindingIndex, isClassBased);
+  }
+  if (value !== NO_CHANGE && bindingUpdated(lView, bindingIndex, value)) {
+    const tNode = tView.data[getSelectedIndex()];
+    updateStyling(tView, tNode, lView, lView[RENDERER], prop, lView[bindingIndex + 1] = normalizeSuffix(value, suffix), isClassBased, bindingIndex);
+  }
+}
+function checkStylingMap(keyValueArraySet2, stringParser, value, isClassBased) {
+  const tView = getTView();
+  const bindingIndex = incrementBindingIndex(2);
+  if (tView.firstUpdatePass) {
+    stylingFirstUpdatePass(tView, null, bindingIndex, isClassBased);
+  }
+  const lView = getLView();
+  if (value !== NO_CHANGE && bindingUpdated(lView, bindingIndex, value)) {
+    const tNode = tView.data[getSelectedIndex()];
+    if (hasStylingInputShadow(tNode, isClassBased) && !isInHostBindings(tView, bindingIndex)) {
+      if (ngDevMode) {
+        const tStylingKey = tView.data[bindingIndex];
+        assertEqual(Array.isArray(tStylingKey) ? tStylingKey[1] : tStylingKey, false, "Styling linked list shadow input should be marked as 'false'");
+      }
+      let staticPrefix = isClassBased ? tNode.classesWithoutHost : tNode.stylesWithoutHost;
+      ngDevMode && isClassBased === false && staticPrefix !== null && assertEqual(staticPrefix.endsWith(";"), true, "Expecting static portion to end with ';'");
+      if (staticPrefix !== null) {
+        value = concatStringsWithSpace(staticPrefix, value ? value : "");
+      }
+      setDirectiveInputsWhichShadowsStyling(tView, tNode, lView, value, isClassBased);
+    } else {
+      updateStylingMap(tView, tNode, lView, lView[RENDERER], lView[bindingIndex + 1], lView[bindingIndex + 1] = toStylingKeyValueArray(keyValueArraySet2, stringParser, value), isClassBased, bindingIndex);
+    }
+  }
+}
+function isInHostBindings(tView, bindingIndex) {
+  return bindingIndex >= tView.expandoStartIndex;
+}
+function stylingFirstUpdatePass(tView, tStylingKey, bindingIndex, isClassBased) {
+  ngDevMode && assertFirstUpdatePass(tView);
+  const tData = tView.data;
+  if (tData[bindingIndex + 1] === null) {
+    const tNode = tData[getSelectedIndex()];
+    ngDevMode && assertDefined(tNode, "TNode expected");
+    const isHostBindings = isInHostBindings(tView, bindingIndex);
+    if (hasStylingInputShadow(tNode, isClassBased) && tStylingKey === null && !isHostBindings) {
+      tStylingKey = false;
+    }
+    tStylingKey = wrapInStaticStylingKey(tData, tNode, tStylingKey, isClassBased);
+    insertTStylingBinding(tData, tNode, tStylingKey, bindingIndex, isHostBindings, isClassBased);
+  }
+}
+function wrapInStaticStylingKey(tData, tNode, stylingKey, isClassBased) {
+  const hostDirectiveDef = getCurrentDirectiveDef(tData);
+  let residual = isClassBased ? tNode.residualClasses : tNode.residualStyles;
+  if (hostDirectiveDef === null) {
+    const isFirstStylingInstructionInTemplate = (isClassBased ? tNode.classBindings : tNode.styleBindings) === 0;
+    if (isFirstStylingInstructionInTemplate) {
+      stylingKey = collectStylingFromDirectives(null, tData, tNode, stylingKey, isClassBased);
+      stylingKey = collectStylingFromTAttrs(stylingKey, tNode.attrs, isClassBased);
+      residual = null;
+    }
+  } else {
+    const directiveStylingLast = tNode.directiveStylingLast;
+    const isFirstStylingInstructionInHostBinding = directiveStylingLast === -1 || tData[directiveStylingLast] !== hostDirectiveDef;
+    if (isFirstStylingInstructionInHostBinding) {
+      stylingKey = collectStylingFromDirectives(hostDirectiveDef, tData, tNode, stylingKey, isClassBased);
+      if (residual === null) {
+        let templateStylingKey = getTemplateHeadTStylingKey(tData, tNode, isClassBased);
+        if (templateStylingKey !== void 0 && Array.isArray(templateStylingKey)) {
+          templateStylingKey = collectStylingFromDirectives(null, tData, tNode, templateStylingKey[1], isClassBased);
+          templateStylingKey = collectStylingFromTAttrs(templateStylingKey, tNode.attrs, isClassBased);
+          setTemplateHeadTStylingKey(tData, tNode, isClassBased, templateStylingKey);
+        }
+      } else {
+        residual = collectResidual(tData, tNode, isClassBased);
+      }
+    }
+  }
+  if (residual !== void 0) {
+    isClassBased ? tNode.residualClasses = residual : tNode.residualStyles = residual;
+  }
+  return stylingKey;
+}
+function getTemplateHeadTStylingKey(tData, tNode, isClassBased) {
+  const bindings = isClassBased ? tNode.classBindings : tNode.styleBindings;
+  if (getTStylingRangeNext(bindings) === 0) {
+    return void 0;
+  }
+  return tData[getTStylingRangePrev(bindings)];
+}
+function setTemplateHeadTStylingKey(tData, tNode, isClassBased, tStylingKey) {
+  const bindings = isClassBased ? tNode.classBindings : tNode.styleBindings;
+  ngDevMode && assertNotEqual(getTStylingRangeNext(bindings), 0, "Expecting to have at least one template styling binding.");
+  tData[getTStylingRangePrev(bindings)] = tStylingKey;
+}
+function collectResidual(tData, tNode, isClassBased) {
+  let residual = void 0;
+  const directiveEnd = tNode.directiveEnd;
+  ngDevMode && assertNotEqual(tNode.directiveStylingLast, -1, "By the time this function gets called at least one hostBindings-node styling instruction must have executed.");
+  for (let i = 1 + tNode.directiveStylingLast; i < directiveEnd; i++) {
+    const attrs = tData[i].hostAttrs;
+    residual = collectStylingFromTAttrs(residual, attrs, isClassBased);
+  }
+  return collectStylingFromTAttrs(residual, tNode.attrs, isClassBased);
+}
+function collectStylingFromDirectives(hostDirectiveDef, tData, tNode, stylingKey, isClassBased) {
+  let currentDirective = null;
+  const directiveEnd = tNode.directiveEnd;
+  let directiveStylingLast = tNode.directiveStylingLast;
+  if (directiveStylingLast === -1) {
+    directiveStylingLast = tNode.directiveStart;
+  } else {
+    directiveStylingLast++;
+  }
+  while (directiveStylingLast < directiveEnd) {
+    currentDirective = tData[directiveStylingLast];
+    ngDevMode && assertDefined(currentDirective, "expected to be defined");
+    stylingKey = collectStylingFromTAttrs(stylingKey, currentDirective.hostAttrs, isClassBased);
+    if (currentDirective === hostDirectiveDef) break;
+    directiveStylingLast++;
+  }
+  if (hostDirectiveDef !== null) {
+    tNode.directiveStylingLast = directiveStylingLast;
+  }
+  return stylingKey;
+}
+function collectStylingFromTAttrs(stylingKey, attrs, isClassBased) {
+  const desiredMarker = isClassBased ? 1 : 2;
+  let currentMarker = -1;
+  if (attrs !== null) {
+    for (let i = 0; i < attrs.length; i++) {
+      const item = attrs[i];
+      if (typeof item === "number") {
+        currentMarker = item;
+      } else {
+        if (currentMarker === desiredMarker) {
+          if (!Array.isArray(stylingKey)) {
+            stylingKey = stylingKey === void 0 ? [] : ["", stylingKey];
+          }
+          keyValueArraySet(stylingKey, item, isClassBased ? true : attrs[++i]);
+        }
+      }
+    }
+  }
+  return stylingKey === void 0 ? null : stylingKey;
+}
+function toStylingKeyValueArray(keyValueArraySet2, stringParser, value) {
+  if (value == null || value === "") return EMPTY_ARRAY;
+  const styleKeyValueArray = [];
+  const unwrappedValue = unwrapSafeValue(value);
+  if (Array.isArray(unwrappedValue)) {
+    for (let i = 0; i < unwrappedValue.length; i++) {
+      keyValueArraySet2(styleKeyValueArray, unwrappedValue[i], true);
+    }
+  } else if (unwrappedValue instanceof Set) {
+    for (const current of unwrappedValue) {
+      keyValueArraySet2(styleKeyValueArray, current, true);
+    }
+  } else if (typeof unwrappedValue === "object") {
+    for (const key in unwrappedValue) {
+      if (unwrappedValue.hasOwnProperty(key)) {
+        keyValueArraySet2(styleKeyValueArray, key, unwrappedValue[key]);
+      }
+    }
+  } else if (typeof unwrappedValue === "string") {
+    stringParser(styleKeyValueArray, unwrappedValue);
+  } else {
+    ngDevMode && throwError2("Unsupported styling type: " + typeof unwrappedValue + " (" + unwrappedValue + ")");
+  }
+  return styleKeyValueArray;
+}
+function styleKeyValueArraySet(keyValueArray, key, value) {
+  keyValueArraySet(keyValueArray, key, unwrapSafeValue(value));
+}
+function classKeyValueArraySet(keyValueArray, key, value) {
+  const stringKey = String(key);
+  if (stringKey !== "" && !stringKey.includes(" ")) {
+    keyValueArraySet(keyValueArray, stringKey, value);
+  }
+}
+function updateStylingMap(tView, tNode, lView, renderer, oldKeyValueArray, newKeyValueArray, isClassBased, bindingIndex) {
+  if (oldKeyValueArray === NO_CHANGE) {
+    oldKeyValueArray = EMPTY_ARRAY;
+  }
+  let oldIndex = 0;
+  let newIndex = 0;
+  let oldKey = 0 < oldKeyValueArray.length ? oldKeyValueArray[0] : null;
+  let newKey = 0 < newKeyValueArray.length ? newKeyValueArray[0] : null;
+  while (oldKey !== null || newKey !== null) {
+    ngDevMode && assertLessThan(oldIndex, 999, "Are we stuck in infinite loop?");
+    ngDevMode && assertLessThan(newIndex, 999, "Are we stuck in infinite loop?");
+    const oldValue = oldIndex < oldKeyValueArray.length ? oldKeyValueArray[oldIndex + 1] : void 0;
+    const newValue = newIndex < newKeyValueArray.length ? newKeyValueArray[newIndex + 1] : void 0;
+    let setKey = null;
+    let setValue = void 0;
+    if (oldKey === newKey) {
+      oldIndex += 2;
+      newIndex += 2;
+      if (oldValue !== newValue) {
+        setKey = newKey;
+        setValue = newValue;
+      }
+    } else if (newKey === null || oldKey !== null && oldKey < newKey) {
+      oldIndex += 2;
+      setKey = oldKey;
+    } else {
+      ngDevMode && assertDefined(newKey, "Expecting to have a valid key");
+      newIndex += 2;
+      setKey = newKey;
+      setValue = newValue;
+    }
+    if (setKey !== null) {
+      updateStyling(tView, tNode, lView, renderer, setKey, setValue, isClassBased, bindingIndex);
+    }
+    oldKey = oldIndex < oldKeyValueArray.length ? oldKeyValueArray[oldIndex] : null;
+    newKey = newIndex < newKeyValueArray.length ? newKeyValueArray[newIndex] : null;
+  }
+}
+function updateStyling(tView, tNode, lView, renderer, prop, value, isClassBased, bindingIndex) {
+  if (!(tNode.type & 3)) {
+    return;
+  }
+  const tData = tView.data;
+  const tRange = tData[bindingIndex + 1];
+  const higherPriorityValue = getTStylingRangeNextDuplicate(tRange) ? findStylingValue(tData, tNode, lView, prop, getTStylingRangeNext(tRange), isClassBased) : void 0;
+  if (!isStylingValuePresent(higherPriorityValue)) {
+    if (!isStylingValuePresent(value)) {
+      if (getTStylingRangePrevDuplicate(tRange)) {
+        value = findStylingValue(tData, null, lView, prop, bindingIndex, isClassBased);
+      }
+    }
+    const rNode = getNativeByIndex(getSelectedIndex(), lView);
+    applyStyling(renderer, isClassBased, rNode, prop, value);
+  }
+}
+function findStylingValue(tData, tNode, lView, prop, index, isClassBased) {
+  const isPrevDirection = tNode === null;
+  let value = void 0;
+  while (index > 0) {
+    const rawKey = tData[index];
+    const containsStatics = Array.isArray(rawKey);
+    const key = containsStatics ? rawKey[1] : rawKey;
+    const isStylingMap = key === null;
+    let valueAtLViewIndex = lView[index + 1];
+    if (valueAtLViewIndex === NO_CHANGE) {
+      valueAtLViewIndex = isStylingMap ? EMPTY_ARRAY : void 0;
+    }
+    let currentValue = isStylingMap ? keyValueArrayGet(valueAtLViewIndex, prop) : key === prop ? valueAtLViewIndex : void 0;
+    if (containsStatics && !isStylingValuePresent(currentValue)) {
+      currentValue = keyValueArrayGet(rawKey, prop);
+    }
+    if (isStylingValuePresent(currentValue)) {
+      value = currentValue;
+      if (isPrevDirection) {
+        return value;
+      }
+    }
+    const tRange = tData[index + 1];
+    index = isPrevDirection ? getTStylingRangePrev(tRange) : getTStylingRangeNext(tRange);
+  }
+  if (tNode !== null) {
+    let residual = isClassBased ? tNode.residualClasses : tNode.residualStyles;
+    if (residual != null) {
+      value = keyValueArrayGet(residual, prop);
+    }
+  }
+  return value;
+}
+function isStylingValuePresent(value) {
+  return value !== void 0;
+}
+function normalizeSuffix(value, suffix) {
+  if (value == null || value === "") ;
+  else if (typeof suffix === "string") {
+    value = value + suffix;
+  } else if (typeof value === "object") {
+    value = stringify(unwrapSafeValue(value));
+  }
+  return value;
+}
+function hasStylingInputShadow(tNode, isClassBased) {
+  return (tNode.flags & (isClassBased ? 8 : 16)) !== 0;
+}
+function \u0275\u0275text(index, value = "") {
+  const lView = getLView();
+  const tView = getTView();
+  const adjustedIndex = index + HEADER_OFFSET;
+  ngDevMode && assertTNodeCreationIndex(lView, index);
+  const tNode = tView.firstCreatePass ? getOrCreateTNode(tView, adjustedIndex, 1, value, null) : tView.data[adjustedIndex];
+  const textNative = _locateOrCreateTextNode(tView, lView, tNode, value);
+  lView[adjustedIndex] = textNative;
+  if (wasLastNodeCreated()) {
+    appendChild(tView, lView, textNative, tNode);
+  }
+  setCurrentTNode(tNode, false);
+}
+var _locateOrCreateTextNode = (tView, lView, tNode, value) => {
+  lastNodeWasCreated(true);
+  return createTextNode(lView[RENDERER], value);
+};
+function interpolationV(lView, values) {
+  ngDevMode && assertLessThan(2, values.length, "should have at least 3 values");
+  let isBindingUpdated = false;
+  let bindingIndex = getBindingIndex();
+  for (let i = 1; i < values.length; i += 2) {
+    isBindingUpdated = bindingUpdated(lView, bindingIndex++, values[i]) || isBindingUpdated;
+  }
+  setBindingIndex(bindingIndex);
+  if (!isBindingUpdated) {
+    return NO_CHANGE;
+  }
+  let content = values[0];
+  for (let i = 1; i < values.length; i += 2) {
+    content += renderStringify(values[i]) + (i + 1 !== values.length ? values[i + 1] : "");
+  }
+  return content;
+}
+function interpolation1(lView, prefix, v0, suffix = "") {
+  const different = bindingUpdated(lView, nextBindingIndex(), v0);
+  return different ? prefix + renderStringify(v0) + suffix : NO_CHANGE;
+}
+function interpolation2(lView, prefix, v0, i0, v1, suffix = "") {
+  const bindingIndex = getBindingIndex();
+  const different = bindingUpdated2(lView, bindingIndex, v0, v1);
+  incrementBindingIndex(2);
+  return different ? prefix + renderStringify(v0) + i0 + renderStringify(v1) + suffix : NO_CHANGE;
+}
+function interpolation3(lView, prefix, v0, i0, v1, i1, v2, suffix = "") {
+  const bindingIndex = getBindingIndex();
+  const different = bindingUpdated3(lView, bindingIndex, v0, v1, v2);
+  incrementBindingIndex(3);
+  return different ? prefix + renderStringify(v0) + i0 + renderStringify(v1) + i1 + renderStringify(v2) + suffix : NO_CHANGE;
+}
+function interpolation4(lView, prefix, v0, i0, v1, i1, v2, i2, v3, suffix = "") {
+  const bindingIndex = getBindingIndex();
+  const different = bindingUpdated4(lView, bindingIndex, v0, v1, v2, v3);
+  incrementBindingIndex(4);
+  return different ? prefix + renderStringify(v0) + i0 + renderStringify(v1) + i1 + renderStringify(v2) + i2 + renderStringify(v3) + suffix : NO_CHANGE;
+}
+function interpolation5(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, suffix = "") {
+  const bindingIndex = getBindingIndex();
+  let different = bindingUpdated4(lView, bindingIndex, v0, v1, v2, v3);
+  different = bindingUpdated(lView, bindingIndex + 4, v4) || different;
+  incrementBindingIndex(5);
+  return different ? prefix + renderStringify(v0) + i0 + renderStringify(v1) + i1 + renderStringify(v2) + i2 + renderStringify(v3) + i3 + renderStringify(v4) + suffix : NO_CHANGE;
+}
+function interpolation6(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, suffix = "") {
+  const bindingIndex = getBindingIndex();
+  let different = bindingUpdated4(lView, bindingIndex, v0, v1, v2, v3);
+  different = bindingUpdated2(lView, bindingIndex + 4, v4, v5) || different;
+  incrementBindingIndex(6);
+  return different ? prefix + renderStringify(v0) + i0 + renderStringify(v1) + i1 + renderStringify(v2) + i2 + renderStringify(v3) + i3 + renderStringify(v4) + i4 + renderStringify(v5) + suffix : NO_CHANGE;
+}
+function interpolation7(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, i5, v6, suffix = "") {
+  const bindingIndex = getBindingIndex();
+  let different = bindingUpdated4(lView, bindingIndex, v0, v1, v2, v3);
+  different = bindingUpdated3(lView, bindingIndex + 4, v4, v5, v6) || different;
+  incrementBindingIndex(7);
+  return different ? prefix + renderStringify(v0) + i0 + renderStringify(v1) + i1 + renderStringify(v2) + i2 + renderStringify(v3) + i3 + renderStringify(v4) + i4 + renderStringify(v5) + i5 + renderStringify(v6) + suffix : NO_CHANGE;
+}
+function interpolation8(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, i5, v6, i6, v7, suffix = "") {
+  const bindingIndex = getBindingIndex();
+  let different = bindingUpdated4(lView, bindingIndex, v0, v1, v2, v3);
+  different = bindingUpdated4(lView, bindingIndex + 4, v4, v5, v6, v7) || different;
+  incrementBindingIndex(8);
+  return different ? prefix + renderStringify(v0) + i0 + renderStringify(v1) + i1 + renderStringify(v2) + i2 + renderStringify(v3) + i3 + renderStringify(v4) + i4 + renderStringify(v5) + i5 + renderStringify(v6) + i6 + renderStringify(v7) + suffix : NO_CHANGE;
+}
+function \u0275\u0275textInterpolate(v0) {
+  \u0275\u0275textInterpolate1("", v0);
+  return \u0275\u0275textInterpolate;
+}
+function \u0275\u0275textInterpolate1(prefix, v0, suffix) {
+  const lView = getLView();
+  const interpolated = interpolation1(lView, prefix, v0, suffix);
+  if (interpolated !== NO_CHANGE) {
+    textBindingInternal(lView, getSelectedIndex(), interpolated);
+  }
+  return \u0275\u0275textInterpolate1;
+}
+function \u0275\u0275textInterpolate2(prefix, v0, i0, v1, suffix) {
+  const lView = getLView();
+  const interpolated = interpolation2(lView, prefix, v0, i0, v1, suffix);
+  if (interpolated !== NO_CHANGE) {
+    textBindingInternal(lView, getSelectedIndex(), interpolated);
+  }
+  return \u0275\u0275textInterpolate2;
+}
+function \u0275\u0275textInterpolate3(prefix, v0, i0, v1, i1, v2, suffix) {
+  const lView = getLView();
+  const interpolated = interpolation3(lView, prefix, v0, i0, v1, i1, v2, suffix);
+  if (interpolated !== NO_CHANGE) {
+    textBindingInternal(lView, getSelectedIndex(), interpolated);
+  }
+  return \u0275\u0275textInterpolate3;
+}
+function \u0275\u0275textInterpolate4(prefix, v0, i0, v1, i1, v2, i2, v3, suffix) {
+  const lView = getLView();
+  const interpolated = interpolation4(lView, prefix, v0, i0, v1, i1, v2, i2, v3, suffix);
+  if (interpolated !== NO_CHANGE) {
+    textBindingInternal(lView, getSelectedIndex(), interpolated);
+  }
+  return \u0275\u0275textInterpolate4;
+}
+function \u0275\u0275textInterpolate5(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, suffix) {
+  const lView = getLView();
+  const interpolated = interpolation5(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, suffix);
+  if (interpolated !== NO_CHANGE) {
+    textBindingInternal(lView, getSelectedIndex(), interpolated);
+  }
+  return \u0275\u0275textInterpolate5;
+}
+function \u0275\u0275textInterpolate6(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, suffix) {
+  const lView = getLView();
+  const interpolated = interpolation6(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, suffix);
+  if (interpolated !== NO_CHANGE) {
+    textBindingInternal(lView, getSelectedIndex(), interpolated);
+  }
+  return \u0275\u0275textInterpolate6;
+}
+function \u0275\u0275textInterpolate7(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, i5, v6, suffix) {
+  const lView = getLView();
+  const interpolated = interpolation7(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, i5, v6, suffix);
+  if (interpolated !== NO_CHANGE) {
+    textBindingInternal(lView, getSelectedIndex(), interpolated);
+  }
+  return \u0275\u0275textInterpolate7;
+}
+function \u0275\u0275textInterpolate8(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, i5, v6, i6, v7, suffix) {
+  const lView = getLView();
+  const interpolated = interpolation8(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, i5, v6, i6, v7, suffix);
+  if (interpolated !== NO_CHANGE) {
+    textBindingInternal(lView, getSelectedIndex(), interpolated);
+  }
+  return \u0275\u0275textInterpolate8;
+}
+function \u0275\u0275textInterpolateV(values) {
+  const lView = getLView();
+  const interpolated = interpolationV(lView, values);
+  if (interpolated !== NO_CHANGE) {
+    textBindingInternal(lView, getSelectedIndex(), interpolated);
+  }
+  return \u0275\u0275textInterpolateV;
+}
+function textBindingInternal(lView, index, value) {
+  ngDevMode && assertString(value, "Value should be a string");
+  ngDevMode && assertNotSame(value, NO_CHANGE, "value should not be NO_CHANGE");
+  ngDevMode && assertIndexInRange(lView, index);
+  const element = getNativeByIndex(index, lView);
+  ngDevMode && assertDefined(element, "native element should exist");
+  updateTextNode(lView[RENDERER], element, value);
+}
+function \u0275\u0275twoWayProperty(propName, value, sanitizer) {
+  if (isWritableSignal(value)) {
+    value = value();
+  }
+  const lView = getLView();
+  const bindingIndex = nextBindingIndex();
+  if (bindingUpdated(lView, bindingIndex, value)) {
+    const tView = getTView();
+    const tNode = getSelectedTNode();
+    setPropertyAndInputs(tNode, lView, propName, value, lView[RENDERER], sanitizer);
+    ngDevMode && storePropertyBindingMetadata(tView.data, tNode, propName, bindingIndex);
+  }
+  return \u0275\u0275twoWayProperty;
+}
+function \u0275\u0275twoWayBindingSet(target, value) {
+  const canWrite = isWritableSignal(target);
+  canWrite && target.set(value);
+  return canWrite;
+}
+function \u0275\u0275twoWayListener(eventName, listenerFn) {
+  const lView = getLView();
+  const tView = getTView();
+  const tNode = getCurrentTNode();
+  listenerInternal(tView, lView, lView[RENDERER], tNode, eventName, listenerFn);
+  return \u0275\u0275twoWayListener;
+}
+var UNINITIALIZED_LET = {};
+function \u0275\u0275declareLet(index) {
+  performanceMarkFeature("NgLet");
+  const tView = getTView();
+  const lView = getLView();
+  const adjustedIndex = index + HEADER_OFFSET;
+  const tNode = getOrCreateTNode(tView, adjustedIndex, 128, null, null);
+  setCurrentTNode(tNode, false);
+  store(tView, lView, adjustedIndex, UNINITIALIZED_LET);
+  return \u0275\u0275declareLet;
+}
+function \u0275\u0275storeLet(value) {
+  const tView = getTView();
+  const lView = getLView();
+  const index = getSelectedIndex();
+  store(tView, lView, index, value);
+  return value;
+}
+function \u0275\u0275readContextLet(index) {
+  const contextLView = getContextLView();
+  const value = load(contextLView, HEADER_OFFSET + index);
+  if (value === UNINITIALIZED_LET) {
+    throw new RuntimeError(314, ngDevMode && "Attempting to access a @let declaration whose value is not available yet");
+  }
+  return value;
+}
+function \u0275\u0275attachSourceLocations(templatePath, locations) {
+  const tView = getTView();
+  const lView = getLView();
+  const renderer = lView[RENDERER];
+  const attributeName = "data-ng-source-location";
+  for (const [index, offset, line, column] of locations) {
+    const tNode = getTNode(tView, index + HEADER_OFFSET);
+    ngDevMode && assertTNodeType(tNode, 2);
+    const node = getNativeByIndex(index + HEADER_OFFSET, lView);
+    if (!node.hasAttribute(attributeName)) {
+      const attributeValue = `${templatePath}@o:${offset},l:${line},c:${column}`;
+      renderer.setAttribute(node, attributeName, attributeValue);
+    }
+  }
+}
+function \u0275\u0275interpolate(v0) {
+  return bindingUpdated(getLView(), nextBindingIndex(), v0) ? renderStringify(v0) : NO_CHANGE;
+}
+function \u0275\u0275interpolate1(prefix, v0, suffix = "") {
+  return interpolation1(getLView(), prefix, v0, suffix);
+}
+function \u0275\u0275interpolate2(prefix, v0, i0, v1, suffix = "") {
+  return interpolation2(getLView(), prefix, v0, i0, v1, suffix);
+}
+function \u0275\u0275interpolate3(prefix, v0, i0, v1, i1, v2, suffix = "") {
+  return interpolation3(getLView(), prefix, v0, i0, v1, i1, v2, suffix);
+}
+function \u0275\u0275interpolate4(prefix, v0, i0, v1, i1, v2, i2, v3, suffix = "") {
+  return interpolation4(getLView(), prefix, v0, i0, v1, i1, v2, i2, v3, suffix);
+}
+function \u0275\u0275interpolate5(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, suffix = "") {
+  return interpolation5(getLView(), prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, suffix);
+}
+function \u0275\u0275interpolate6(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, suffix = "") {
+  return interpolation6(getLView(), prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, suffix);
+}
+function \u0275\u0275interpolate7(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, i5, v6, suffix = "") {
+  return interpolation7(getLView(), prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, i5, v6, suffix);
+}
+function \u0275\u0275interpolate8(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, i5, v6, i6, v7, suffix = "") {
+  return interpolation8(getLView(), prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, i5, v6, i6, v7, suffix);
+}
+function \u0275\u0275interpolateV(values) {
+  return interpolationV(getLView(), values);
+}
+function \u0275\u0275arrowFunction(slotOffset, factory, context2) {
+  const bindingIndex = getBindingRoot() + slotOffset;
+  const lView = getLView();
+  return lView[bindingIndex] === NO_CHANGE ? updateBinding(lView, bindingIndex, factory(context2, lView)) : getBinding(lView, bindingIndex);
+}
+function providersResolver(def, providers, isViewProviders) {
+  const tView = getTView();
+  if (tView.firstCreatePass) {
+    resolveProvider(providers, tView.data, tView.blueprint, isComponentDef(def), isViewProviders);
+  }
+}
+function resolveProvider(provider, tInjectables, lInjectablesBlueprint, isComponent2, isViewProvider) {
+  provider = resolveForwardRef(provider);
+  if (Array.isArray(provider)) {
+    for (let i = 0; i < provider.length; i++) {
+      resolveProvider(provider[i], tInjectables, lInjectablesBlueprint, isComponent2, isViewProvider);
+    }
+  } else {
+    const tView = getTView();
+    const lView = getLView();
+    const tNode = getCurrentTNode();
+    let token = isTypeProvider(provider) ? provider : resolveForwardRef(provider.provide);
+    const providerFactory = providerToFactory(provider);
+    if (ngDevMode) {
+      const injector = new NodeInjector(tNode, lView);
+      runInInjectorProfilerContext(injector, token, () => {
+        emitProviderConfiguredEvent(provider, isViewProvider);
+      });
+    }
+    const beginIndex = tNode.providerIndexes & 1048575;
+    const endIndex = tNode.directiveStart;
+    const cptViewProvidersCount = tNode.providerIndexes >> 20;
+    if (isTypeProvider(provider) || !provider.multi) {
+      const factory = new NodeInjectorFactory(providerFactory, isViewProvider, \u0275\u0275directiveInject, ngDevMode ? providerName(provider) : null);
+      const existingFactoryIndex = indexOf(token, tInjectables, isViewProvider ? beginIndex : beginIndex + cptViewProvidersCount, endIndex);
+      if (existingFactoryIndex === -1) {
+        diPublicInInjector(getOrCreateNodeInjectorForNode(tNode, lView), tView, token);
+        registerDestroyHooksIfSupported(tView, provider, tInjectables.length);
+        tInjectables.push(token);
+        tNode.directiveStart++;
+        tNode.directiveEnd++;
+        if (isViewProvider) {
+          tNode.providerIndexes += 1048576;
+        }
+        lInjectablesBlueprint.push(factory);
+        lView.push(factory);
+      } else {
+        lInjectablesBlueprint[existingFactoryIndex] = factory;
+        lView[existingFactoryIndex] = factory;
+      }
+    } else {
+      const existingProvidersFactoryIndex = indexOf(token, tInjectables, beginIndex + cptViewProvidersCount, endIndex);
+      const existingViewProvidersFactoryIndex = indexOf(token, tInjectables, beginIndex, beginIndex + cptViewProvidersCount);
+      const doesProvidersFactoryExist = existingProvidersFactoryIndex >= 0 && lInjectablesBlueprint[existingProvidersFactoryIndex];
+      const doesViewProvidersFactoryExist = existingViewProvidersFactoryIndex >= 0 && lInjectablesBlueprint[existingViewProvidersFactoryIndex];
+      if (isViewProvider && !doesViewProvidersFactoryExist || !isViewProvider && !doesProvidersFactoryExist) {
+        diPublicInInjector(getOrCreateNodeInjectorForNode(tNode, lView), tView, token);
+        const factory = multiFactory(isViewProvider ? multiViewProvidersFactoryResolver : multiProvidersFactoryResolver, lInjectablesBlueprint.length, isViewProvider, isComponent2, providerFactory, provider);
+        if (!isViewProvider && doesViewProvidersFactoryExist) {
+          lInjectablesBlueprint[existingViewProvidersFactoryIndex].providerFactory = factory;
+        }
+        registerDestroyHooksIfSupported(tView, provider, tInjectables.length, 0);
+        tInjectables.push(token);
+        tNode.directiveStart++;
+        tNode.directiveEnd++;
+        if (isViewProvider) {
+          tNode.providerIndexes += 1048576;
+        }
+        lInjectablesBlueprint.push(factory);
+        lView.push(factory);
+      } else {
+        const indexInFactory = multiFactoryAdd(lInjectablesBlueprint[isViewProvider ? existingViewProvidersFactoryIndex : existingProvidersFactoryIndex], providerFactory, !isViewProvider && isComponent2);
+        registerDestroyHooksIfSupported(tView, provider, existingProvidersFactoryIndex > -1 ? existingProvidersFactoryIndex : existingViewProvidersFactoryIndex, indexInFactory);
+      }
+      if (!isViewProvider && isComponent2 && doesViewProvidersFactoryExist) {
+        lInjectablesBlueprint[existingViewProvidersFactoryIndex].componentProviders++;
+      }
+    }
+  }
+}
+function registerDestroyHooksIfSupported(tView, provider, contextIndex, indexInFactory) {
+  const providerIsTypeProvider = isTypeProvider(provider);
+  const providerIsClassProvider = isClassProvider(provider);
+  if (providerIsTypeProvider || providerIsClassProvider) {
+    const classToken = providerIsClassProvider ? resolveForwardRef(provider.useClass) : provider;
+    const prototype = classToken.prototype;
+    const ngOnDestroy = prototype.ngOnDestroy;
+    if (ngOnDestroy) {
+      const hooks = tView.destroyHooks || (tView.destroyHooks = []);
+      if (!providerIsTypeProvider && provider.multi) {
+        ngDevMode && assertDefined(indexInFactory, "indexInFactory when registering multi factory destroy hook");
+        const existingCallbacksIndex = hooks.indexOf(contextIndex);
+        if (existingCallbacksIndex === -1) {
+          hooks.push(contextIndex, [indexInFactory, ngOnDestroy]);
+        } else {
+          hooks[existingCallbacksIndex + 1].push(indexInFactory, ngOnDestroy);
+        }
+      } else {
+        hooks.push(contextIndex, ngOnDestroy);
+      }
+    }
+  }
+}
+function multiFactoryAdd(multiFactory2, factory, isComponentProvider) {
+  if (isComponentProvider) {
+    multiFactory2.componentProviders++;
+  }
+  return multiFactory2.multi.push(factory) - 1;
+}
+function indexOf(item, arr, begin, end) {
+  for (let i = begin; i < end; i++) {
+    if (arr[i] === item) return i;
+  }
+  return -1;
+}
+function multiProvidersFactoryResolver(_, flags, tData, lData, tNode) {
+  return multiResolve(this.multi, []);
+}
+function multiViewProvidersFactoryResolver(_, _flags, _tData, lView, tNode) {
+  const factories = this.multi;
+  let result;
+  if (this.providerFactory) {
+    const componentCount = this.providerFactory.componentProviders;
+    const multiProviders = getNodeInjectable(lView, lView[TVIEW], this.providerFactory.index, tNode);
+    result = multiProviders.slice(0, componentCount);
+    multiResolve(factories, result);
+    for (let i = componentCount; i < multiProviders.length; i++) {
+      result.push(multiProviders[i]);
+    }
+  } else {
+    result = [];
+    multiResolve(factories, result);
+  }
+  return result;
+}
+function multiResolve(factories, result) {
+  for (let i = 0; i < factories.length; i++) {
+    const factory = factories[i];
+    result.push(factory());
+  }
+  return result;
+}
+function multiFactory(factoryFn, index, isViewProvider, isComponent2, f, provider) {
+  const factory = new NodeInjectorFactory(factoryFn, isViewProvider, \u0275\u0275directiveInject, ngDevMode ? providerName(provider) : null);
+  factory.multi = [];
+  factory.index = index;
+  factory.componentProviders = 0;
+  multiFactoryAdd(factory, f, isComponent2 && !isViewProvider);
+  return factory;
+}
+function providerName(provider) {
+  if (Array.isArray(provider)) {
+    return null;
+  }
+  if (isTypeProvider(provider)) {
+    return provider.name;
+  } else if (isClassProvider(provider)) {
+    if (provider.provide instanceof InjectionToken) {
+      return `('${provider.provide.toString()}':${provider.useClass.name})`;
+    }
+    return provider.useClass.name;
+  } else if (provider.provide instanceof InjectionToken) {
+    return provider.provide.toString();
+  } else if (typeof provider.provide === "string") {
+    return provider.provide;
+  } else {
+    return null;
+  }
+}
+function \u0275\u0275ProvidersFeature(providers, viewProviders) {
+  return (definition) => {
+    definition.providersResolver = (def, processProvidersFn) => providersResolver(def, processProvidersFn ? processProvidersFn(providers) : providers, false);
+    if (viewProviders) {
+      definition.viewProvidersResolver = (def, processProvidersFn) => providersResolver(def, processProvidersFn ? processProvidersFn(viewProviders) : viewProviders, true);
+    }
+  };
+}
+function \u0275\u0275ExternalStylesFeature(styleUrls) {
+  return (definition) => {
+    if (styleUrls.length < 1) {
+      return;
+    }
+    definition.getExternalStyles = (encapsulationId) => {
+      const urls = styleUrls.map((value) => value + "?ngcomp" + (encapsulationId ? "=" + encodeURIComponent(encapsulationId) : "") + "&e=" + definition.encapsulation);
+      return urls;
+    };
+  };
+}
+function \u0275\u0275setComponentScope(type, directives, pipes) {
+  const def = type.\u0275cmp;
+  def.directiveDefs = extractDefListOrFactory(directives, extractDirectiveDef);
+  def.pipeDefs = extractDefListOrFactory(pipes, getPipeDef);
+}
+function \u0275\u0275setNgModuleScope(type, scope) {
+  return noSideEffects(() => {
+    const ngModuleDef = getNgModuleDefOrThrow(type);
+    ngModuleDef.declarations = convertToTypeArray(scope.declarations || EMPTY_ARRAY);
+    ngModuleDef.imports = convertToTypeArray(scope.imports || EMPTY_ARRAY);
+    ngModuleDef.exports = convertToTypeArray(scope.exports || EMPTY_ARRAY);
+    if (scope.bootstrap) {
+      ngModuleDef.bootstrap = convertToTypeArray(scope.bootstrap);
+    }
+    depsTracker.registerNgModule(type, scope);
+  });
+}
+function convertToTypeArray(values) {
+  if (typeof values === "function") {
+    return values;
+  }
+  const flattenValues = flatten(values);
+  if (flattenValues.some(isForwardRef)) {
+    return () => flattenValues.map(resolveForwardRef).map(maybeUnwrapModuleWithProviders);
+  } else {
+    return flattenValues.map(maybeUnwrapModuleWithProviders);
+  }
+}
+function maybeUnwrapModuleWithProviders(value) {
+  return isModuleWithProviders(value) ? value.ngModule : value;
+}
+function \u0275\u0275pureFunction0(slotOffset, pureFn) {
+  const bindingIndex = getBindingRoot() + slotOffset;
+  const lView = getLView();
+  return lView[bindingIndex] === NO_CHANGE ? updateBinding(lView, bindingIndex, pureFn()) : getBinding(lView, bindingIndex);
+}
+function \u0275\u0275pureFunction1(slotOffset, pureFn, exp) {
+  return pureFunction1Internal(getLView(), getBindingRoot(), slotOffset, pureFn, exp);
+}
+function \u0275\u0275pureFunction2(slotOffset, pureFn, exp1, exp2) {
+  return pureFunction2Internal(getLView(), getBindingRoot(), slotOffset, pureFn, exp1, exp2);
+}
+function \u0275\u0275pureFunction3(slotOffset, pureFn, exp1, exp2, exp3) {
+  return pureFunction3Internal(getLView(), getBindingRoot(), slotOffset, pureFn, exp1, exp2, exp3);
+}
+function \u0275\u0275pureFunction4(slotOffset, pureFn, exp1, exp2, exp3, exp4, thisArg) {
+  return pureFunction4Internal(getLView(), getBindingRoot(), slotOffset, pureFn, exp1, exp2, exp3, exp4);
+}
+function \u0275\u0275pureFunction5(slotOffset, pureFn, exp1, exp2, exp3, exp4, exp5) {
+  const bindingIndex = getBindingRoot() + slotOffset;
+  const lView = getLView();
+  const different = bindingUpdated4(lView, bindingIndex, exp1, exp2, exp3, exp4);
+  return bindingUpdated(lView, bindingIndex + 4, exp5) || different ? updateBinding(lView, bindingIndex + 5, pureFn(exp1, exp2, exp3, exp4, exp5)) : getBinding(lView, bindingIndex + 5);
+}
+function \u0275\u0275pureFunction6(slotOffset, pureFn, exp1, exp2, exp3, exp4, exp5, exp6) {
+  const bindingIndex = getBindingRoot() + slotOffset;
+  const lView = getLView();
+  const different = bindingUpdated4(lView, bindingIndex, exp1, exp2, exp3, exp4);
+  return bindingUpdated2(lView, bindingIndex + 4, exp5, exp6) || different ? updateBinding(lView, bindingIndex + 6, pureFn(exp1, exp2, exp3, exp4, exp5, exp6)) : getBinding(lView, bindingIndex + 6);
+}
+function \u0275\u0275pureFunction7(slotOffset, pureFn, exp1, exp2, exp3, exp4, exp5, exp6, exp7) {
+  const bindingIndex = getBindingRoot() + slotOffset;
+  const lView = getLView();
+  let different = bindingUpdated4(lView, bindingIndex, exp1, exp2, exp3, exp4);
+  return bindingUpdated3(lView, bindingIndex + 4, exp5, exp6, exp7) || different ? updateBinding(lView, bindingIndex + 7, pureFn(exp1, exp2, exp3, exp4, exp5, exp6, exp7)) : getBinding(lView, bindingIndex + 7);
+}
+function \u0275\u0275pureFunction8(slotOffset, pureFn, exp1, exp2, exp3, exp4, exp5, exp6, exp7, exp8) {
+  const bindingIndex = getBindingRoot() + slotOffset;
+  const lView = getLView();
+  const different = bindingUpdated4(lView, bindingIndex, exp1, exp2, exp3, exp4);
+  return bindingUpdated4(lView, bindingIndex + 4, exp5, exp6, exp7, exp8) || different ? updateBinding(lView, bindingIndex + 8, pureFn(exp1, exp2, exp3, exp4, exp5, exp6, exp7, exp8)) : getBinding(lView, bindingIndex + 8);
+}
+function \u0275\u0275pureFunctionV(slotOffset, pureFn, exps) {
+  return pureFunctionVInternal(getLView(), getBindingRoot(), slotOffset, pureFn, exps);
+}
+function getPureFunctionReturnValue(lView, returnValueIndex) {
+  ngDevMode && assertIndexInRange(lView, returnValueIndex);
+  const lastReturnValue = lView[returnValueIndex];
+  return lastReturnValue === NO_CHANGE ? void 0 : lastReturnValue;
+}
+function pureFunction1Internal(lView, bindingRoot, slotOffset, pureFn, exp, thisArg) {
+  const bindingIndex = bindingRoot + slotOffset;
+  return bindingUpdated(lView, bindingIndex, exp) ? updateBinding(lView, bindingIndex + 1, thisArg ? pureFn.call(thisArg, exp) : pureFn(exp)) : getPureFunctionReturnValue(lView, bindingIndex + 1);
+}
+function pureFunction2Internal(lView, bindingRoot, slotOffset, pureFn, exp1, exp2, thisArg) {
+  const bindingIndex = bindingRoot + slotOffset;
+  return bindingUpdated2(lView, bindingIndex, exp1, exp2) ? updateBinding(lView, bindingIndex + 2, thisArg ? pureFn.call(thisArg, exp1, exp2) : pureFn(exp1, exp2)) : getPureFunctionReturnValue(lView, bindingIndex + 2);
+}
+function pureFunction3Internal(lView, bindingRoot, slotOffset, pureFn, exp1, exp2, exp3, thisArg) {
+  const bindingIndex = bindingRoot + slotOffset;
+  return bindingUpdated3(lView, bindingIndex, exp1, exp2, exp3) ? updateBinding(lView, bindingIndex + 3, thisArg ? pureFn.call(thisArg, exp1, exp2, exp3) : pureFn(exp1, exp2, exp3)) : getPureFunctionReturnValue(lView, bindingIndex + 3);
+}
+function pureFunction4Internal(lView, bindingRoot, slotOffset, pureFn, exp1, exp2, exp3, exp4, thisArg) {
+  const bindingIndex = bindingRoot + slotOffset;
+  return bindingUpdated4(lView, bindingIndex, exp1, exp2, exp3, exp4) ? updateBinding(lView, bindingIndex + 4, thisArg ? pureFn.call(thisArg, exp1, exp2, exp3, exp4) : pureFn(exp1, exp2, exp3, exp4)) : getPureFunctionReturnValue(lView, bindingIndex + 4);
+}
+function pureFunctionVInternal(lView, bindingRoot, slotOffset, pureFn, exps, thisArg) {
+  let bindingIndex = bindingRoot + slotOffset;
+  let different = false;
+  for (let i = 0; i < exps.length; i++) {
+    bindingUpdated(lView, bindingIndex++, exps[i]) && (different = true);
+  }
+  return different ? updateBinding(lView, bindingIndex, pureFn.apply(thisArg, exps)) : getPureFunctionReturnValue(lView, bindingIndex);
+}
+function \u0275\u0275pipe(index, pipeName) {
+  const tView = getTView();
+  let pipeDef;
+  const adjustedIndex = index + HEADER_OFFSET;
+  if (tView.firstCreatePass) {
+    pipeDef = getPipeDef2(pipeName, tView.pipeRegistry);
+    tView.data[adjustedIndex] = pipeDef;
+    if (pipeDef.onDestroy) {
+      (tView.destroyHooks ??= []).push(adjustedIndex, pipeDef.onDestroy);
+    }
+  } else {
+    pipeDef = tView.data[adjustedIndex];
+  }
+  const pipeFactory = pipeDef.factory || (pipeDef.factory = getFactoryDef(pipeDef.type, true));
+  let previousInjectorProfilerContext;
+  if (ngDevMode) {
+    previousInjectorProfilerContext = setInjectorProfilerContext({
+      injector: new NodeInjector(getCurrentTNode(), getLView()),
+      token: pipeDef.type
+    });
+  }
+  const previousInjectImplementation = setInjectImplementation(\u0275\u0275directiveInject);
+  try {
+    const previousIncludeViewProviders = setIncludeViewProviders(false);
+    const pipeInstance = pipeFactory();
+    setIncludeViewProviders(previousIncludeViewProviders);
+    store(tView, getLView(), adjustedIndex, pipeInstance);
+    return pipeInstance;
+  } finally {
+    setInjectImplementation(previousInjectImplementation);
+    ngDevMode && setInjectorProfilerContext(previousInjectorProfilerContext);
+  }
+}
+function getPipeDef2(name, registry) {
+  if (registry) {
+    if (ngDevMode) {
+      const pipes = registry.filter((pipe2) => pipe2.name === name);
+      if (pipes.length > 1) {
+        console.warn(formatRuntimeError(313, getMultipleMatchingPipesMessage(name)));
+      }
+    }
+    for (let i = registry.length - 1; i >= 0; i--) {
+      const pipeDef = registry[i];
+      if (name === pipeDef.name) {
+        return pipeDef;
+      }
+    }
+  }
+  if (ngDevMode) {
+    throw new RuntimeError(-302, getPipeNotFoundErrorMessage(name));
+  }
+  return;
+}
+function getMultipleMatchingPipesMessage(name) {
+  const lView = getLView();
+  const declarationLView = lView[DECLARATION_COMPONENT_VIEW];
+  const context2 = declarationLView[CONTEXT];
+  const hostIsStandalone = isHostComponentStandalone(lView);
+  const componentInfoMessage = context2 ? ` in the '${context2.constructor.name}' component` : "";
+  const verifyMessage = `check ${hostIsStandalone ? "'@Component.imports' of this component" : "the imports of this module"}`;
+  const errorMessage = `Multiple pipes match the name \`${name}\`${componentInfoMessage}. ${verifyMessage}`;
+  return errorMessage;
+}
+function getPipeNotFoundErrorMessage(name) {
+  const lView = getLView();
+  const declarationLView = lView[DECLARATION_COMPONENT_VIEW];
+  const context2 = declarationLView[CONTEXT];
+  const hostIsStandalone = isHostComponentStandalone(lView);
+  const componentInfoMessage = context2 ? ` in the '${context2.constructor.name}' component` : "";
+  const verifyMessage = `Verify that it is ${hostIsStandalone ? "included in the '@Component.imports' of this component" : "declared or imported in this module"}`;
+  const errorMessage = `The pipe '${name}' could not be found${componentInfoMessage}. ${verifyMessage}`;
+  return errorMessage;
+}
+function \u0275\u0275pipeBind1(index, offset, v1) {
+  const adjustedIndex = index + HEADER_OFFSET;
+  const lView = getLView();
+  const pipeInstance = load(lView, adjustedIndex);
+  return isPure(lView, adjustedIndex) ? pureFunction1Internal(lView, getBindingRoot(), offset, pipeInstance.transform, v1, pipeInstance) : pipeInstance.transform(v1);
+}
+function \u0275\u0275pipeBind2(index, slotOffset, v1, v2) {
+  const adjustedIndex = index + HEADER_OFFSET;
+  const lView = getLView();
+  const pipeInstance = load(lView, adjustedIndex);
+  return isPure(lView, adjustedIndex) ? pureFunction2Internal(lView, getBindingRoot(), slotOffset, pipeInstance.transform, v1, v2, pipeInstance) : pipeInstance.transform(v1, v2);
+}
+function \u0275\u0275pipeBind3(index, slotOffset, v1, v2, v3) {
+  const adjustedIndex = index + HEADER_OFFSET;
+  const lView = getLView();
+  const pipeInstance = load(lView, adjustedIndex);
+  return isPure(lView, adjustedIndex) ? pureFunction3Internal(lView, getBindingRoot(), slotOffset, pipeInstance.transform, v1, v2, v3, pipeInstance) : pipeInstance.transform(v1, v2, v3);
+}
+function \u0275\u0275pipeBind4(index, slotOffset, v1, v2, v3, v4) {
+  const adjustedIndex = index + HEADER_OFFSET;
+  const lView = getLView();
+  const pipeInstance = load(lView, adjustedIndex);
+  return isPure(lView, adjustedIndex) ? pureFunction4Internal(lView, getBindingRoot(), slotOffset, pipeInstance.transform, v1, v2, v3, v4, pipeInstance) : pipeInstance.transform(v1, v2, v3, v4);
+}
+function \u0275\u0275pipeBindV(index, slotOffset, values) {
+  const adjustedIndex = index + HEADER_OFFSET;
+  const lView = getLView();
+  const pipeInstance = load(lView, adjustedIndex);
+  return isPure(lView, adjustedIndex) ? pureFunctionVInternal(lView, getBindingRoot(), slotOffset, pipeInstance.transform, values, pipeInstance) : pipeInstance.transform.apply(pipeInstance, values);
+}
+function isPure(lView, index) {
+  return lView[TVIEW].data[index].pure;
+}
+function \u0275\u0275templateRefExtractor(tNode, lView) {
+  return createTemplateRef(tNode, lView);
+}
+function \u0275\u0275getComponentDepsFactory(type, rawImports) {
+  return () => {
+    try {
+      return depsTracker.getComponentDependencies(type, rawImports).dependencies;
+    } catch (e) {
+      console.error(`Computing dependencies in local compilation mode for the component "${type.name}" failed with the exception:`, e);
+      throw e;
+    }
+  };
+}
+function \u0275setClassDebugInfo(type, debugInfo) {
+  const def = getComponentDef(type);
+  if (def !== null) {
+    def.debugInfo = debugInfo;
+  }
+}
+function \u0275\u0275getReplaceMetadataURL(id, timestamp, base) {
+  const url = `./@ng/component?c=${id}&t=${encodeURIComponent(timestamp)}`;
+  return new URL(url, base).href;
+}
+function \u0275\u0275replaceMetadata(type, applyMetadata, namespaces, locals, importMeta = null, id = null) {
+  ngDevMode && assertComponentDef(type);
+  const currentDef = getComponentDef(type);
+  applyMetadata.apply(null, [type, namespaces, ...locals]);
+  const {
+    newDef,
+    oldDef
+  } = mergeWithExistingDefinition(currentDef, getComponentDef(type));
+  type[NG_COMP_DEF] = newDef;
+  if (oldDef.tView) {
+    const trackedViews = getTrackedLViews().values();
+    for (const root of trackedViews) {
+      if (isRootView(root) && root[PARENT] === null) {
+        recreateMatchingLViews(importMeta, id, newDef, oldDef, root);
+      }
+    }
+  }
+}
+function mergeWithExistingDefinition(currentDef, newDef) {
+  const clone = __spreadValues({}, currentDef);
+  const replacement = Object.assign(currentDef, newDef, {
+    directiveDefs: clone.directiveDefs,
+    pipeDefs: clone.pipeDefs,
+    setInput: clone.setInput,
+    type: clone.type
+  });
+  ngDevMode && assertEqual(replacement, currentDef, "Expected definition to be merged in place");
+  return {
+    newDef: replacement,
+    oldDef: clone
+  };
+}
+function recreateMatchingLViews(importMeta, id, newDef, oldDef, rootLView) {
+  ngDevMode && assertDefined(oldDef.tView, "Expected a component definition that has been instantiated at least once");
+  const tView = rootLView[TVIEW];
+  if (tView === oldDef.tView) {
+    ngDevMode && assertComponentDef(oldDef.type);
+    recreateLView(importMeta, id, newDef, oldDef, rootLView);
+    return;
+  }
+  for (let i = HEADER_OFFSET; i < tView.bindingStartIndex; i++) {
+    const current = rootLView[i];
+    if (isLContainer(current)) {
+      if (isLView(current[HOST])) {
+        recreateMatchingLViews(importMeta, id, newDef, oldDef, current[HOST]);
+      }
+      for (let j = CONTAINER_HEADER_OFFSET; j < current.length; j++) {
+        recreateMatchingLViews(importMeta, id, newDef, oldDef, current[j]);
+      }
+    } else if (isLView(current)) {
+      recreateMatchingLViews(importMeta, id, newDef, oldDef, current);
+    }
+  }
+}
+function clearRendererCache(factory, def) {
+  factory.componentReplaced?.(def.id);
+}
+function recreateLView(importMeta, id, newDef, oldDef, lView) {
+  const instance = lView[CONTEXT];
+  let host = lView[HOST];
+  const parentLView = lView[PARENT];
+  ngDevMode && assertLView(parentLView);
+  const tNode = lView[T_HOST];
+  ngDevMode && assertTNodeType(tNode, 2);
+  ngDevMode && assertNotEqual(newDef, oldDef, "Expected different component definition");
+  const zone = lView[INJECTOR].get(NgZone, null);
+  const recreate = () => {
+    if (oldDef.encapsulation === ViewEncapsulation.ShadowDom || oldDef.encapsulation === ViewEncapsulation.ExperimentalIsolatedShadowDom) {
+      const newHost = host.cloneNode(false);
+      host.replaceWith(newHost);
+      host = newHost;
+    }
+    const newTView = getOrCreateComponentTView(newDef);
+    const newLView = createLView(parentLView, newTView, instance, getInitialLViewFlagsFromDef(newDef), host, tNode, null, null, null, null, null);
+    replaceLViewInTree(parentLView, lView, newLView, tNode.index);
+    destroyLView(lView[TVIEW], lView);
+    cleanupLView(lView);
+    const rendererFactory = lView[ENVIRONMENT].rendererFactory;
+    clearRendererCache(rendererFactory, oldDef);
+    newLView[RENDERER] = rendererFactory.createRenderer(host, newDef);
+    removeViewFromDOM(lView[TVIEW], lView);
+    resetProjectionState(tNode);
+    renderView(newTView, newLView, instance);
+    refreshView(newTView, newLView, newTView.template, instance);
+  };
+  if (zone === null) {
+    executeWithInvalidateFallback(importMeta, id, recreate);
+  } else {
+    zone.run(() => executeWithInvalidateFallback(importMeta, id, recreate));
+  }
+}
+function executeWithInvalidateFallback(importMeta, id, callback) {
+  try {
+    callback();
+  } catch (e) {
+    const error = e;
+    if (id !== null && error.message) {
+      const toLog = error.message + (error.stack ? "\n" + error.stack : "");
+      importMeta?.hot?.send?.("angular:invalidate", {
+        id,
+        message: toLog,
+        error: true
+      });
+    }
+    throw e;
+  }
+}
+function replaceLViewInTree(parentLView, oldLView, newLView, index) {
+  for (let i = HEADER_OFFSET; i < parentLView[TVIEW].bindingStartIndex; i++) {
+    const current = parentLView[i];
+    if ((isLView(current) || isLContainer(current)) && current[NEXT] === oldLView) {
+      current[NEXT] = newLView;
+      break;
+    }
+  }
+  if (parentLView[CHILD_HEAD] === oldLView) {
+    parentLView[CHILD_HEAD] = newLView;
+  }
+  if (parentLView[CHILD_TAIL] === oldLView) {
+    parentLView[CHILD_TAIL] = newLView;
+  }
+  newLView[NEXT] = oldLView[NEXT];
+  oldLView[NEXT] = null;
+  parentLView[index] = newLView;
+}
+function resetProjectionState(tNode) {
+  if (tNode.projection !== null) {
+    for (const current of tNode.projection) {
+      if (isTNodeShape(current)) {
+        current.projectionNext = null;
+        current.flags &= -3;
+      }
+    }
+    tNode.projection = null;
+  }
+}
+var angularCoreEnv = /* @__PURE__ */ (() => ({
+  "\u0275\u0275animateEnter": \u0275\u0275animateEnter,
+  "\u0275\u0275animateEnterListener": \u0275\u0275animateEnterListener,
+  "\u0275\u0275animateLeave": \u0275\u0275animateLeave,
+  "\u0275\u0275animateLeaveListener": \u0275\u0275animateLeaveListener,
+  "\u0275\u0275attribute": \u0275\u0275attribute,
+  "\u0275\u0275defineComponent": \u0275\u0275defineComponent,
+  "\u0275\u0275defineDirective": \u0275\u0275defineDirective,
+  "\u0275\u0275defineInjectable": \u0275\u0275defineInjectable,
+  "\u0275\u0275defineInjector": \u0275\u0275defineInjector,
+  "\u0275\u0275defineNgModule": \u0275\u0275defineNgModule,
+  "\u0275\u0275definePipe": \u0275\u0275definePipe,
+  "\u0275\u0275directiveInject": \u0275\u0275directiveInject,
+  "\u0275\u0275getInheritedFactory": \u0275\u0275getInheritedFactory,
+  "\u0275\u0275inject": \u0275\u0275inject,
+  "\u0275\u0275injectAttribute": \u0275\u0275injectAttribute,
+  "\u0275\u0275invalidFactory": \u0275\u0275invalidFactory,
+  "\u0275\u0275invalidFactoryDep": \u0275\u0275invalidFactoryDep,
+  "\u0275\u0275templateRefExtractor": \u0275\u0275templateRefExtractor,
+  "\u0275\u0275resetView": \u0275\u0275resetView,
+  "\u0275\u0275HostDirectivesFeature": \u0275\u0275HostDirectivesFeature,
+  "\u0275\u0275NgOnChangesFeature": \u0275\u0275NgOnChangesFeature,
+  "\u0275\u0275ControlFeature": \u0275\u0275ControlFeature,
+  "\u0275\u0275ProvidersFeature": \u0275\u0275ProvidersFeature,
+  "\u0275\u0275InheritDefinitionFeature": \u0275\u0275InheritDefinitionFeature,
+  "\u0275\u0275ExternalStylesFeature": \u0275\u0275ExternalStylesFeature,
+  "\u0275\u0275nextContext": \u0275\u0275nextContext,
+  "\u0275\u0275namespaceHTML": \u0275\u0275namespaceHTML,
+  "\u0275\u0275namespaceMathML": \u0275\u0275namespaceMathML,
+  "\u0275\u0275namespaceSVG": \u0275\u0275namespaceSVG,
+  "\u0275\u0275enableBindings": \u0275\u0275enableBindings,
+  "\u0275\u0275disableBindings": \u0275\u0275disableBindings,
+  "\u0275\u0275elementStart": \u0275\u0275elementStart,
+  "\u0275\u0275elementEnd": \u0275\u0275elementEnd,
+  "\u0275\u0275element": \u0275\u0275element,
+  "\u0275\u0275elementContainerStart": \u0275\u0275elementContainerStart,
+  "\u0275\u0275elementContainerEnd": \u0275\u0275elementContainerEnd,
+  "\u0275\u0275domElement": \u0275\u0275domElement,
+  "\u0275\u0275domElementStart": \u0275\u0275domElementStart,
+  "\u0275\u0275domElementEnd": \u0275\u0275domElementEnd,
+  "\u0275\u0275domElementContainer": \u0275\u0275domElementContainer,
+  "\u0275\u0275domElementContainerStart": \u0275\u0275domElementContainerStart,
+  "\u0275\u0275domElementContainerEnd": \u0275\u0275domElementContainerEnd,
+  "\u0275\u0275domTemplate": \u0275\u0275domTemplate,
+  "\u0275\u0275domListener": \u0275\u0275domListener,
+  "\u0275\u0275elementContainer": \u0275\u0275elementContainer,
+  "\u0275\u0275pureFunction0": \u0275\u0275pureFunction0,
+  "\u0275\u0275pureFunction1": \u0275\u0275pureFunction1,
+  "\u0275\u0275pureFunction2": \u0275\u0275pureFunction2,
+  "\u0275\u0275pureFunction3": \u0275\u0275pureFunction3,
+  "\u0275\u0275pureFunction4": \u0275\u0275pureFunction4,
+  "\u0275\u0275pureFunction5": \u0275\u0275pureFunction5,
+  "\u0275\u0275pureFunction6": \u0275\u0275pureFunction6,
+  "\u0275\u0275pureFunction7": \u0275\u0275pureFunction7,
+  "\u0275\u0275pureFunction8": \u0275\u0275pureFunction8,
+  "\u0275\u0275pureFunctionV": \u0275\u0275pureFunctionV,
+  "\u0275\u0275getCurrentView": \u0275\u0275getCurrentView,
+  "\u0275\u0275restoreView": \u0275\u0275restoreView,
+  "\u0275\u0275listener": \u0275\u0275listener,
+  "\u0275\u0275projection": \u0275\u0275projection,
+  "\u0275\u0275syntheticHostProperty": \u0275\u0275syntheticHostProperty,
+  "\u0275\u0275syntheticHostListener": \u0275\u0275syntheticHostListener,
+  "\u0275\u0275pipeBind1": \u0275\u0275pipeBind1,
+  "\u0275\u0275pipeBind2": \u0275\u0275pipeBind2,
+  "\u0275\u0275pipeBind3": \u0275\u0275pipeBind3,
+  "\u0275\u0275pipeBind4": \u0275\u0275pipeBind4,
+  "\u0275\u0275pipeBindV": \u0275\u0275pipeBindV,
+  "\u0275\u0275projectionDef": \u0275\u0275projectionDef,
+  "\u0275\u0275domProperty": \u0275\u0275domProperty,
+  "\u0275\u0275ariaProperty": \u0275\u0275ariaProperty,
+  "\u0275\u0275property": \u0275\u0275property,
+  "\u0275\u0275control": \u0275\u0275control,
+  "\u0275\u0275controlCreate": \u0275\u0275controlCreate,
+  "\u0275\u0275pipe": \u0275\u0275pipe,
+  "\u0275\u0275queryRefresh": \u0275\u0275queryRefresh,
+  "\u0275\u0275queryAdvance": \u0275\u0275queryAdvance,
+  "\u0275\u0275viewQuery": \u0275\u0275viewQuery,
+  "\u0275\u0275viewQuerySignal": \u0275\u0275viewQuerySignal,
+  "\u0275\u0275loadQuery": \u0275\u0275loadQuery,
+  "\u0275\u0275contentQuery": \u0275\u0275contentQuery,
+  "\u0275\u0275contentQuerySignal": \u0275\u0275contentQuerySignal,
+  "\u0275\u0275reference": \u0275\u0275reference,
+  "\u0275\u0275classMap": \u0275\u0275classMap,
+  "\u0275\u0275styleMap": \u0275\u0275styleMap,
+  "\u0275\u0275styleProp": \u0275\u0275styleProp,
+  "\u0275\u0275classProp": \u0275\u0275classProp,
+  "\u0275\u0275advance": \u0275\u0275advance,
+  "\u0275\u0275template": \u0275\u0275template,
+  "\u0275\u0275conditional": \u0275\u0275conditional,
+  "\u0275\u0275conditionalCreate": \u0275\u0275conditionalCreate,
+  "\u0275\u0275conditionalBranchCreate": \u0275\u0275conditionalBranchCreate,
+  "\u0275\u0275defer": \u0275\u0275defer,
+  "\u0275\u0275deferWhen": \u0275\u0275deferWhen,
+  "\u0275\u0275deferOnIdle": \u0275\u0275deferOnIdle,
+  "\u0275\u0275deferOnImmediate": \u0275\u0275deferOnImmediate,
+  "\u0275\u0275deferOnTimer": \u0275\u0275deferOnTimer,
+  "\u0275\u0275deferOnHover": \u0275\u0275deferOnHover,
+  "\u0275\u0275deferOnInteraction": \u0275\u0275deferOnInteraction,
+  "\u0275\u0275deferOnViewport": \u0275\u0275deferOnViewport,
+  "\u0275\u0275deferPrefetchWhen": \u0275\u0275deferPrefetchWhen,
+  "\u0275\u0275deferPrefetchOnIdle": \u0275\u0275deferPrefetchOnIdle,
+  "\u0275\u0275deferPrefetchOnImmediate": \u0275\u0275deferPrefetchOnImmediate,
+  "\u0275\u0275deferPrefetchOnTimer": \u0275\u0275deferPrefetchOnTimer,
+  "\u0275\u0275deferPrefetchOnHover": \u0275\u0275deferPrefetchOnHover,
+  "\u0275\u0275deferPrefetchOnInteraction": \u0275\u0275deferPrefetchOnInteraction,
+  "\u0275\u0275deferPrefetchOnViewport": \u0275\u0275deferPrefetchOnViewport,
+  "\u0275\u0275deferHydrateWhen": \u0275\u0275deferHydrateWhen,
+  "\u0275\u0275deferHydrateNever": \u0275\u0275deferHydrateNever,
+  "\u0275\u0275deferHydrateOnIdle": \u0275\u0275deferHydrateOnIdle,
+  "\u0275\u0275deferHydrateOnImmediate": \u0275\u0275deferHydrateOnImmediate,
+  "\u0275\u0275deferHydrateOnTimer": \u0275\u0275deferHydrateOnTimer,
+  "\u0275\u0275deferHydrateOnHover": \u0275\u0275deferHydrateOnHover,
+  "\u0275\u0275deferHydrateOnInteraction": \u0275\u0275deferHydrateOnInteraction,
+  "\u0275\u0275deferHydrateOnViewport": \u0275\u0275deferHydrateOnViewport,
+  "\u0275\u0275deferEnableTimerScheduling": \u0275\u0275deferEnableTimerScheduling,
+  "\u0275\u0275repeater": \u0275\u0275repeater,
+  "\u0275\u0275repeaterCreate": \u0275\u0275repeaterCreate,
+  "\u0275\u0275repeaterTrackByIndex": \u0275\u0275repeaterTrackByIndex,
+  "\u0275\u0275repeaterTrackByIdentity": \u0275\u0275repeaterTrackByIdentity,
+  "\u0275\u0275componentInstance": \u0275\u0275componentInstance,
+  "\u0275\u0275text": \u0275\u0275text,
+  "\u0275\u0275textInterpolate": \u0275\u0275textInterpolate,
+  "\u0275\u0275textInterpolate1": \u0275\u0275textInterpolate1,
+  "\u0275\u0275textInterpolate2": \u0275\u0275textInterpolate2,
+  "\u0275\u0275textInterpolate3": \u0275\u0275textInterpolate3,
+  "\u0275\u0275textInterpolate4": \u0275\u0275textInterpolate4,
+  "\u0275\u0275textInterpolate5": \u0275\u0275textInterpolate5,
+  "\u0275\u0275textInterpolate6": \u0275\u0275textInterpolate6,
+  "\u0275\u0275textInterpolate7": \u0275\u0275textInterpolate7,
+  "\u0275\u0275textInterpolate8": \u0275\u0275textInterpolate8,
+  "\u0275\u0275textInterpolateV": \u0275\u0275textInterpolateV,
+  "\u0275\u0275i18n": \u0275\u0275i18n,
+  "\u0275\u0275i18nAttributes": \u0275\u0275i18nAttributes,
+  "\u0275\u0275i18nExp": \u0275\u0275i18nExp,
+  "\u0275\u0275i18nStart": \u0275\u0275i18nStart,
+  "\u0275\u0275i18nEnd": \u0275\u0275i18nEnd,
+  "\u0275\u0275i18nApply": \u0275\u0275i18nApply,
+  "\u0275\u0275i18nPostprocess": \u0275\u0275i18nPostprocess,
+  "\u0275\u0275resolveWindow": \u0275\u0275resolveWindow,
+  "\u0275\u0275resolveDocument": \u0275\u0275resolveDocument,
+  "\u0275\u0275resolveBody": \u0275\u0275resolveBody,
+  "\u0275\u0275setComponentScope": \u0275\u0275setComponentScope,
+  "\u0275\u0275setNgModuleScope": \u0275\u0275setNgModuleScope,
+  "\u0275\u0275registerNgModuleType": registerNgModuleType,
+  "\u0275\u0275getComponentDepsFactory": \u0275\u0275getComponentDepsFactory,
+  "\u0275setClassDebugInfo": \u0275setClassDebugInfo,
+  "\u0275\u0275declareLet": \u0275\u0275declareLet,
+  "\u0275\u0275storeLet": \u0275\u0275storeLet,
+  "\u0275\u0275arrowFunction": \u0275\u0275arrowFunction,
+  "\u0275\u0275readContextLet": \u0275\u0275readContextLet,
+  "\u0275\u0275attachSourceLocations": \u0275\u0275attachSourceLocations,
+  "\u0275\u0275interpolate": \u0275\u0275interpolate,
+  "\u0275\u0275interpolate1": \u0275\u0275interpolate1,
+  "\u0275\u0275interpolate2": \u0275\u0275interpolate2,
+  "\u0275\u0275interpolate3": \u0275\u0275interpolate3,
+  "\u0275\u0275interpolate4": \u0275\u0275interpolate4,
+  "\u0275\u0275interpolate5": \u0275\u0275interpolate5,
+  "\u0275\u0275interpolate6": \u0275\u0275interpolate6,
+  "\u0275\u0275interpolate7": \u0275\u0275interpolate7,
+  "\u0275\u0275interpolate8": \u0275\u0275interpolate8,
+  "\u0275\u0275interpolateV": \u0275\u0275interpolateV,
+  "\u0275\u0275sanitizeHtml": \u0275\u0275sanitizeHtml,
+  "\u0275\u0275sanitizeStyle": \u0275\u0275sanitizeStyle,
+  "\u0275\u0275sanitizeResourceUrl": \u0275\u0275sanitizeResourceUrl,
+  "\u0275\u0275sanitizeScript": \u0275\u0275sanitizeScript,
+  "\u0275\u0275validateAttribute": \u0275\u0275validateAttribute,
+  "\u0275\u0275sanitizeUrl": \u0275\u0275sanitizeUrl,
+  "\u0275\u0275sanitizeUrlOrResourceUrl": \u0275\u0275sanitizeUrlOrResourceUrl,
+  "\u0275\u0275trustConstantHtml": \u0275\u0275trustConstantHtml,
+  "\u0275\u0275trustConstantResourceUrl": \u0275\u0275trustConstantResourceUrl,
+  "forwardRef": forwardRef,
+  "resolveForwardRef": resolveForwardRef,
+  "\u0275\u0275twoWayProperty": \u0275\u0275twoWayProperty,
+  "\u0275\u0275twoWayBindingSet": \u0275\u0275twoWayBindingSet,
+  "\u0275\u0275twoWayListener": \u0275\u0275twoWayListener,
+  "\u0275\u0275replaceMetadata": \u0275\u0275replaceMetadata,
+  "\u0275\u0275getReplaceMetadataURL": \u0275\u0275getReplaceMetadataURL
+}))();
+var jitOptions = null;
+function setJitOptions(options) {
+  if (jitOptions !== null) {
+    if (options.defaultEncapsulation !== jitOptions.defaultEncapsulation) {
+      ngDevMode && console.error("Provided value for `defaultEncapsulation` can not be changed once it has been set.");
+      return;
+    }
+    if (options.preserveWhitespaces !== jitOptions.preserveWhitespaces) {
+      ngDevMode && console.error("Provided value for `preserveWhitespaces` can not be changed once it has been set.");
+      return;
+    }
+  }
+  jitOptions = options;
+}
+function getJitOptions() {
+  return jitOptions;
+}
+var moduleQueue = [];
+function enqueueModuleForDelayedScoping(moduleType, ngModule) {
+  moduleQueue.push({
+    moduleType,
+    ngModule
+  });
+}
+var flushingModuleQueue = false;
+function flushModuleScopingQueueAsMuchAsPossible() {
+  if (!flushingModuleQueue) {
+    flushingModuleQueue = true;
+    try {
+      for (let i = moduleQueue.length - 1; i >= 0; i--) {
+        const {
+          moduleType,
+          ngModule
+        } = moduleQueue[i];
+        if (ngModule.declarations && ngModule.declarations.every(isResolvedDeclaration)) {
+          moduleQueue.splice(i, 1);
+          setScopeOnDeclaredComponents(moduleType, ngModule);
+        }
+      }
+    } finally {
+      flushingModuleQueue = false;
+    }
+  }
+}
+function isResolvedDeclaration(declaration) {
+  if (Array.isArray(declaration)) {
+    return declaration.every(isResolvedDeclaration);
+  }
+  return !!resolveForwardRef(declaration);
+}
+function compileNgModule(moduleType, ngModule = {}) {
+  compileNgModuleDefs(moduleType, ngModule);
+  if (ngModule.id !== void 0) {
+    registerNgModuleType(moduleType, ngModule.id);
+  }
+  enqueueModuleForDelayedScoping(moduleType, ngModule);
+}
+function compileNgModuleDefs(moduleType, ngModule, allowDuplicateDeclarationsInRoot = false) {
+  ngDevMode && assertDefined(moduleType, "Required value moduleType");
+  ngDevMode && assertDefined(ngModule, "Required value ngModule");
+  const declarations = flatten(ngModule.declarations || EMPTY_ARRAY);
+  let ngModuleDef = null;
+  Object.defineProperty(moduleType, NG_MOD_DEF, {
+    configurable: true,
+    get: () => {
+      if (ngModuleDef === null) {
+        if (ngDevMode && ngModule.imports && ngModule.imports.indexOf(moduleType) > -1) {
+          throw new Error(`'${stringifyForError(moduleType)}' module can't import itself`);
+        }
+        const compiler = getCompilerFacade({
+          usage: 0,
+          kind: "NgModule",
+          type: moduleType
+        });
+        ngModuleDef = compiler.compileNgModule(angularCoreEnv, `ng:///${moduleType.name}/\u0275mod.js`, {
+          type: moduleType,
+          bootstrap: flatten(ngModule.bootstrap || EMPTY_ARRAY).map(resolveForwardRef),
+          declarations: declarations.map(resolveForwardRef),
+          imports: flatten(ngModule.imports || EMPTY_ARRAY).map(resolveForwardRef).map(expandModuleWithProviders),
+          exports: flatten(ngModule.exports || EMPTY_ARRAY).map(resolveForwardRef).map(expandModuleWithProviders),
+          schemas: ngModule.schemas ? flatten(ngModule.schemas) : null,
+          id: ngModule.id || null
+        });
+        if (!ngModuleDef.schemas) {
+          ngModuleDef.schemas = [];
+        }
+      }
+      return ngModuleDef;
+    }
+  });
+  let ngFactoryDef = null;
+  Object.defineProperty(moduleType, NG_FACTORY_DEF, {
+    get: () => {
+      if (ngFactoryDef === null) {
+        const compiler = getCompilerFacade({
+          usage: 0,
+          kind: "NgModule",
+          type: moduleType
+        });
+        ngFactoryDef = compiler.compileFactory(angularCoreEnv, `ng:///${moduleType.name}/\u0275fac.js`, {
+          name: moduleType.name,
+          type: moduleType,
+          deps: reflectDependencies(moduleType),
+          target: compiler.FactoryTarget.NgModule,
+          typeArgumentCount: 0
+        });
+      }
+      return ngFactoryDef;
+    },
+    configurable: !!ngDevMode
+  });
+  let ngInjectorDef = null;
+  Object.defineProperty(moduleType, NG_INJ_DEF, {
+    get: () => {
+      if (ngInjectorDef === null) {
+        ngDevMode && verifySemanticsOfNgModuleDef(moduleType, allowDuplicateDeclarationsInRoot);
+        const meta = {
+          name: moduleType.name,
+          type: moduleType,
+          providers: ngModule.providers || EMPTY_ARRAY,
+          imports: [(ngModule.imports || EMPTY_ARRAY).map(resolveForwardRef), (ngModule.exports || EMPTY_ARRAY).map(resolveForwardRef)]
+        };
+        const compiler = getCompilerFacade({
+          usage: 0,
+          kind: "NgModule",
+          type: moduleType
+        });
+        ngInjectorDef = compiler.compileInjector(angularCoreEnv, `ng:///${moduleType.name}/\u0275inj.js`, meta);
+      }
+      return ngInjectorDef;
+    },
+    configurable: !!ngDevMode
+  });
+}
+function generateStandaloneInDeclarationsError(type, location2) {
+  const prefix = `Unexpected "${stringifyForError(type)}" found in the "declarations" array of the`;
+  const suffix = `"${stringifyForError(type)}" is marked as standalone and can't be declared in any NgModule - did you intend to import it instead (by adding it to the "imports" array)?`;
+  return `${prefix} ${location2}, ${suffix}`;
+}
+function verifySemanticsOfNgModuleDef(moduleType, allowDuplicateDeclarationsInRoot, importingModule) {
+  if (verifiedNgModule.get(moduleType)) return;
+  if (isStandalone(moduleType)) return;
+  verifiedNgModule.set(moduleType, true);
+  moduleType = resolveForwardRef(moduleType);
+  let ngModuleDef;
+  if (importingModule) {
+    ngModuleDef = getNgModuleDef(moduleType);
+    if (!ngModuleDef) {
+      throw new Error(`Unexpected value '${moduleType.name}' imported by the module '${importingModule.name}'. Please add an @NgModule annotation.`);
+    }
+  } else {
+    ngModuleDef = getNgModuleDefOrThrow(moduleType);
+  }
+  const errors = [];
+  const declarations = maybeUnwrapFn(ngModuleDef.declarations);
+  const imports = maybeUnwrapFn(ngModuleDef.imports);
+  flatten(imports).map(unwrapModuleWithProvidersImports).forEach((modOrStandaloneCmpt) => {
+    verifySemanticsOfNgModuleImport(modOrStandaloneCmpt, moduleType);
+    verifySemanticsOfNgModuleDef(modOrStandaloneCmpt, false, moduleType);
+  });
+  const exports$1 = maybeUnwrapFn(ngModuleDef.exports);
+  declarations.forEach(verifyDeclarationsHaveDefinitions);
+  declarations.forEach(verifyDirectivesHaveSelector);
+  declarations.forEach((declarationType) => verifyNotStandalone(declarationType, moduleType));
+  const combinedDeclarations = [...declarations.map(resolveForwardRef), ...flatten(imports.map(computeCombinedExports)).map(resolveForwardRef)];
+  exports$1.forEach(verifyExportsAreDeclaredOrReExported);
+  declarations.forEach((decl) => verifyDeclarationIsUnique(decl, allowDuplicateDeclarationsInRoot));
+  const ngModule = getAnnotation(moduleType, "NgModule");
+  if (ngModule) {
+    ngModule.imports && flatten(ngModule.imports).map(unwrapModuleWithProvidersImports).forEach((mod) => {
+      verifySemanticsOfNgModuleImport(mod, moduleType);
+      verifySemanticsOfNgModuleDef(mod, false, moduleType);
+    });
+    ngModule.bootstrap && deepForEach(ngModule.bootstrap, verifyCorrectBootstrapType);
+    ngModule.bootstrap && deepForEach(ngModule.bootstrap, verifyComponentIsPartOfNgModule);
+  }
+  if (errors.length) {
+    throw new Error(errors.join("\n"));
+  }
+  function verifyDeclarationsHaveDefinitions(type) {
+    type = resolveForwardRef(type);
+    const def = getComponentDef(type) || getDirectiveDef(type) || getPipeDef(type);
+    if (!def) {
+      errors.push(`Unexpected value '${stringifyForError(type)}' declared by the module '${stringifyForError(moduleType)}'. Please add a @Pipe/@Directive/@Component annotation.`);
+    }
+  }
+  function verifyDirectivesHaveSelector(type) {
+    type = resolveForwardRef(type);
+    const def = getDirectiveDef(type);
+    if (!getComponentDef(type) && def && def.selectors.length == 0) {
+      errors.push(`Directive ${stringifyForError(type)} has no selector, please add it!`);
+    }
+  }
+  function verifyNotStandalone(type, moduleType2) {
+    type = resolveForwardRef(type);
+    const def = getComponentDef(type) || getDirectiveDef(type) || getPipeDef(type);
+    if (def?.standalone) {
+      const location2 = `"${stringifyForError(moduleType2)}" NgModule`;
+      errors.push(generateStandaloneInDeclarationsError(type, location2));
+    }
+  }
+  function verifyExportsAreDeclaredOrReExported(type) {
+    type = resolveForwardRef(type);
+    const kind = getComponentDef(type) && "component" || getDirectiveDef(type) && "directive" || getPipeDef(type) && "pipe";
+    if (kind) {
+      if (combinedDeclarations.lastIndexOf(type) === -1) {
+        errors.push(`Can't export ${kind} ${stringifyForError(type)} from ${stringifyForError(moduleType)} as it was neither declared nor imported!`);
+      }
+    }
+  }
+  function verifyDeclarationIsUnique(type, suppressErrors) {
+    type = resolveForwardRef(type);
+    const existingModule = ownerNgModule.get(type);
+    if (existingModule && existingModule !== moduleType) {
+      if (!suppressErrors) {
+        const modules2 = [existingModule, moduleType].map(stringifyForError).sort();
+        errors.push(`Type ${stringifyForError(type)} is part of the declarations of 2 modules: ${modules2[0]} and ${modules2[1]}! Please consider moving ${stringifyForError(type)} to a higher module that imports ${modules2[0]} and ${modules2[1]}. You can also create a new NgModule that exports and includes ${stringifyForError(type)} then import that NgModule in ${modules2[0]} and ${modules2[1]}.`);
+      }
+    } else {
+      ownerNgModule.set(type, moduleType);
+    }
+  }
+  function verifyComponentIsPartOfNgModule(type) {
+    type = resolveForwardRef(type);
+    const existingModule = ownerNgModule.get(type);
+    if (!existingModule && !isStandalone(type)) {
+      errors.push(`Component ${stringifyForError(type)} is not part of any NgModule or the module has not been imported into your module.`);
+    }
+  }
+  function verifyCorrectBootstrapType(type) {
+    type = resolveForwardRef(type);
+    if (!getComponentDef(type)) {
+      errors.push(`${stringifyForError(type)} cannot be used as an entry component.`);
+    }
+    if (isStandalone(type)) {
+      errors.push(`The \`${stringifyForError(type)}\` class is a standalone component, which can not be used in the \`@NgModule.bootstrap\` array. Use the \`bootstrapApplication\` function for bootstrap instead.`);
+    }
+  }
+  function verifySemanticsOfNgModuleImport(type, importingModule2) {
+    type = resolveForwardRef(type);
+    const directiveDef = getComponentDef(type) || getDirectiveDef(type);
+    if (directiveDef !== null && !directiveDef.standalone) {
+      throw new Error(`Unexpected directive '${type.name}' imported by the module '${importingModule2.name}'. Please add an @NgModule annotation.`);
+    }
+    const pipeDef = getPipeDef(type);
+    if (pipeDef !== null && !pipeDef.standalone) {
+      throw new Error(`Unexpected pipe '${type.name}' imported by the module '${importingModule2.name}'. Please add an @NgModule annotation.`);
+    }
+  }
+}
+function unwrapModuleWithProvidersImports(typeOrWithProviders) {
+  typeOrWithProviders = resolveForwardRef(typeOrWithProviders);
+  return typeOrWithProviders.ngModule || typeOrWithProviders;
+}
+function getAnnotation(type, name) {
+  let annotation = null;
+  collect(type.__annotations__);
+  collect(type.decorators);
+  return annotation;
+  function collect(annotations) {
+    if (annotations) {
+      annotations.forEach(readAnnotation);
+    }
+  }
+  function readAnnotation(decorator) {
+    if (!annotation) {
+      const proto = Object.getPrototypeOf(decorator);
+      if (proto.ngMetadataName == name) {
+        annotation = decorator;
+      } else if (decorator.type) {
+        const proto2 = Object.getPrototypeOf(decorator.type);
+        if (proto2.ngMetadataName == name) {
+          annotation = decorator.args[0];
+        }
+      }
+    }
+  }
+}
+var ownerNgModule = /* @__PURE__ */ new WeakMap();
+var verifiedNgModule = /* @__PURE__ */ new WeakMap();
+function computeCombinedExports(type) {
+  type = resolveForwardRef(type);
+  const ngModuleDef = getNgModuleDef(type);
+  if (ngModuleDef === null) {
+    return [type];
+  }
+  return flatten(maybeUnwrapFn(ngModuleDef.exports).map((type2) => {
+    const ngModuleDef2 = getNgModuleDef(type2);
+    if (ngModuleDef2) {
+      verifySemanticsOfNgModuleDef(type2, false);
+      return computeCombinedExports(type2);
+    } else {
+      return type2;
+    }
+  }));
+}
+function setScopeOnDeclaredComponents(moduleType, ngModule) {
+  const declarations = flatten(ngModule.declarations || EMPTY_ARRAY);
+  const transitiveScopes = transitiveScopesFor(moduleType);
+  declarations.forEach((declaration) => {
+    declaration = resolveForwardRef(declaration);
+    if (declaration.hasOwnProperty(NG_COMP_DEF)) {
+      const component = declaration;
+      const componentDef = getComponentDef(component);
+      patchComponentDefWithScope(componentDef, transitiveScopes);
+    } else if (!declaration.hasOwnProperty(NG_DIR_DEF) && !declaration.hasOwnProperty(NG_PIPE_DEF)) {
+      declaration.ngSelectorScope = moduleType;
+    }
+  });
+}
+function patchComponentDefWithScope(componentDef, transitiveScopes) {
+  componentDef.directiveDefs = () => Array.from(transitiveScopes.compilation.directives).map((dir) => dir.hasOwnProperty(NG_COMP_DEF) ? getComponentDef(dir) : getDirectiveDef(dir)).filter((def) => !!def);
+  componentDef.pipeDefs = () => Array.from(transitiveScopes.compilation.pipes).map((pipe2) => getPipeDef(pipe2));
+  componentDef.schemas = transitiveScopes.schemas;
+  componentDef.tView = null;
+}
+function transitiveScopesFor(type) {
+  if (isNgModule(type)) {
+    const scope = depsTracker.getNgModuleScope(type);
+    const def = getNgModuleDefOrThrow(type);
+    return __spreadValues({
+      schemas: def.schemas || null
+    }, scope);
+  } else if (isStandalone(type)) {
+    const directiveDef = getComponentDef(type) || getDirectiveDef(type);
+    if (directiveDef !== null) {
+      return {
+        schemas: null,
+        compilation: {
+          directives: /* @__PURE__ */ new Set(),
+          pipes: /* @__PURE__ */ new Set()
+        },
+        exported: {
+          directives: /* @__PURE__ */ new Set([type]),
+          pipes: /* @__PURE__ */ new Set()
+        }
+      };
+    }
+    const pipeDef = getPipeDef(type);
+    if (pipeDef !== null) {
+      return {
+        schemas: null,
+        compilation: {
+          directives: /* @__PURE__ */ new Set(),
+          pipes: /* @__PURE__ */ new Set()
+        },
+        exported: {
+          directives: /* @__PURE__ */ new Set(),
+          pipes: /* @__PURE__ */ new Set([type])
+        }
+      };
+    }
+  }
+  throw new Error(`${type.name} does not have a module def (\u0275mod property)`);
+}
+function expandModuleWithProviders(value) {
+  if (isModuleWithProviders(value)) {
+    return value.ngModule;
+  }
+  return value;
+}
+var compilationDepth = 0;
+function compileComponent(type, metadata) {
+  (typeof ngDevMode === "undefined" || ngDevMode) && initNgDevMode();
+  let ngComponentDef = null;
+  maybeQueueResolutionOfComponentResources(type, metadata);
+  addDirectiveFactoryDef(type, metadata);
+  Object.defineProperty(type, NG_COMP_DEF, {
+    get: () => {
+      if (ngComponentDef === null) {
+        const compiler = getCompilerFacade({
+          usage: 0,
+          kind: "component",
+          type
+        });
+        if (componentNeedsResolution(metadata)) {
+          const error = [`Component '${type.name}' is not resolved:`];
+          if (metadata.templateUrl) {
+            error.push(` - templateUrl: ${metadata.templateUrl}`);
+          }
+          if (metadata.styleUrls && metadata.styleUrls.length) {
+            error.push(` - styleUrls: ${JSON.stringify(metadata.styleUrls)}`);
+          }
+          if (metadata.styleUrl) {
+            error.push(` - styleUrl: ${metadata.styleUrl}`);
+          }
+          error.push(`Did you run and wait for 'resolveComponentResources()'?`);
+          throw new Error(error.join("\n"));
+        }
+        const options = getJitOptions();
+        let preserveWhitespaces = metadata.preserveWhitespaces;
+        if (preserveWhitespaces === void 0) {
+          if (options !== null && options.preserveWhitespaces !== void 0) {
+            preserveWhitespaces = options.preserveWhitespaces;
+          } else {
+            preserveWhitespaces = false;
+          }
+        }
+        let encapsulation = metadata.encapsulation;
+        if (encapsulation === void 0) {
+          if (options !== null && options.defaultEncapsulation !== void 0) {
+            encapsulation = options.defaultEncapsulation;
+          } else {
+            encapsulation = ViewEncapsulation.Emulated;
+          }
+        }
+        const templateUrl = metadata.templateUrl || `ng:///${type.name}/template.html`;
+        const baseMeta = directiveMetadata(type, metadata);
+        const meta = __spreadProps(__spreadValues({}, baseMeta), {
+          typeSourceSpan: compiler.createParseSourceSpan("Component", type.name, templateUrl),
+          template: metadata.template || "",
+          preserveWhitespaces,
+          styles: typeof metadata.styles === "string" ? [metadata.styles] : metadata.styles || EMPTY_ARRAY,
+          animations: metadata.animations,
+          declarations: [],
+          changeDetection: metadata.changeDetection,
+          encapsulation,
+          viewProviders: metadata.viewProviders || null,
+          hasDirectiveDependencies: !baseMeta.isStandalone || metadata.imports != null && metadata.imports.length > 0
+        });
+        compilationDepth++;
+        try {
+          if (meta.usesInheritance) {
+            addDirectiveDefToUndecoratedParents(type);
+          }
+          ngComponentDef = compiler.compileComponent(angularCoreEnv, templateUrl, meta);
+          if (meta.isStandalone) {
+            const imports = flatten(metadata.imports || EMPTY_ARRAY);
+            const {
+              directiveDefs,
+              pipeDefs
+            } = getStandaloneDefFunctions(type, imports);
+            ngComponentDef.directiveDefs = directiveDefs;
+            ngComponentDef.pipeDefs = pipeDefs;
+            ngComponentDef.dependencies = () => imports.map(resolveForwardRef);
+          }
+        } finally {
+          compilationDepth--;
+        }
+        if (compilationDepth === 0) {
+          flushModuleScopingQueueAsMuchAsPossible();
+        }
+        if (hasSelectorScope(type)) {
+          const scopes = transitiveScopesFor(type.ngSelectorScope);
+          patchComponentDefWithScope(ngComponentDef, scopes);
+        }
+        if (metadata.schemas) {
+          if (meta.isStandalone) {
+            ngComponentDef.schemas = metadata.schemas;
+          } else {
+            throw new Error(`The 'schemas' was specified for the ${stringifyForError(type)} but is only valid on a component that is standalone.`);
+          }
+        } else if (meta.isStandalone) {
+          ngComponentDef.schemas = [];
+        }
+      }
+      return ngComponentDef;
+    },
+    set: (def) => {
+      ngComponentDef = def;
+    },
+    configurable: !!ngDevMode
+  });
+}
+function getStandaloneDefFunctions(type, imports) {
+  const directiveDefs = () => {
+    if (ngDevMode) {
+      for (const rawDep of imports) {
+        verifyStandaloneImport(rawDep, type);
+      }
+    }
+    if (!isComponent(type)) {
+      return [];
+    }
+    const scope = depsTracker.getStandaloneComponentScope(type, imports);
+    return [...scope.compilation.directives].map((p) => getComponentDef(p) || getDirectiveDef(p)).filter((d) => d !== null);
+  };
+  const pipeDefs = () => {
+    if (ngDevMode) {
+      for (const rawDep of imports) {
+        verifyStandaloneImport(rawDep, type);
+      }
+    }
+    if (!isComponent(type)) {
+      return [];
+    }
+    const scope = depsTracker.getStandaloneComponentScope(type, imports);
+    return [...scope.compilation.pipes].map((p) => getPipeDef(p)).filter((d) => d !== null);
+  };
+  return {
+    directiveDefs,
+    pipeDefs
+  };
+}
+function hasSelectorScope(component) {
+  return component.ngSelectorScope !== void 0;
+}
+function compileDirective(type, directive) {
+  let ngDirectiveDef = null;
+  addDirectiveFactoryDef(type, directive || {});
+  Object.defineProperty(type, NG_DIR_DEF, {
+    get: () => {
+      if (ngDirectiveDef === null) {
+        const meta = getDirectiveMetadata(type, directive || {});
+        const compiler = getCompilerFacade({
+          usage: 0,
+          kind: "directive",
+          type
+        });
+        ngDirectiveDef = compiler.compileDirective(angularCoreEnv, meta.sourceMapUrl, meta.metadata);
+      }
+      return ngDirectiveDef;
+    },
+    configurable: !!ngDevMode
+  });
+}
+function getDirectiveMetadata(type, metadata) {
+  const name = type && type.name;
+  const sourceMapUrl = `ng:///${name}/\u0275dir.js`;
+  const compiler = getCompilerFacade({
+    usage: 0,
+    kind: "directive",
+    type
+  });
+  const facade = directiveMetadata(type, metadata);
+  facade.typeSourceSpan = compiler.createParseSourceSpan("Directive", name, sourceMapUrl);
+  if (facade.usesInheritance) {
+    addDirectiveDefToUndecoratedParents(type);
+  }
+  return {
+    metadata: facade,
+    sourceMapUrl
+  };
+}
+function addDirectiveFactoryDef(type, metadata) {
+  let ngFactoryDef = null;
+  Object.defineProperty(type, NG_FACTORY_DEF, {
+    get: () => {
+      if (ngFactoryDef === null) {
+        const meta = getDirectiveMetadata(type, metadata);
+        const compiler = getCompilerFacade({
+          usage: 0,
+          kind: "directive",
+          type
+        });
+        ngFactoryDef = compiler.compileFactory(angularCoreEnv, `ng:///${type.name}/\u0275fac.js`, {
+          name: meta.metadata.name,
+          type: meta.metadata.type,
+          typeArgumentCount: 0,
+          deps: reflectDependencies(type),
+          target: compiler.FactoryTarget.Directive
+        });
+      }
+      return ngFactoryDef;
+    },
+    configurable: !!ngDevMode
+  });
+}
+function extendsDirectlyFromObject(type) {
+  return Object.getPrototypeOf(type.prototype) === Object.prototype;
+}
+function directiveMetadata(type, metadata) {
+  const reflect = getReflect();
+  const propMetadata = reflect.ownPropMetadata(type);
+  return {
+    name: type.name,
+    type,
+    selector: metadata.selector !== void 0 ? metadata.selector : null,
+    host: metadata.host || EMPTY_OBJ,
+    propMetadata,
+    inputs: metadata.inputs || EMPTY_ARRAY,
+    outputs: metadata.outputs || EMPTY_ARRAY,
+    queries: extractQueriesMetadata(type, propMetadata, isContentQuery),
+    lifecycle: {
+      usesOnChanges: reflect.hasLifecycleHook(type, "ngOnChanges")
+    },
+    controlCreate: null,
+    typeSourceSpan: null,
+    usesInheritance: !extendsDirectlyFromObject(type),
+    exportAs: extractExportAs(metadata.exportAs),
+    providers: metadata.providers || null,
+    viewQueries: extractQueriesMetadata(type, propMetadata, isViewQuery),
+    isStandalone: metadata.standalone === void 0 ? true : !!metadata.standalone,
+    isSignal: !!metadata.signals,
+    hostDirectives: metadata.hostDirectives?.map((directive) => typeof directive === "function" ? {
+      directive
+    } : directive) || null
+  };
+}
+function addDirectiveDefToUndecoratedParents(type) {
+  const objPrototype = Object.prototype;
+  let parent = Object.getPrototypeOf(type.prototype).constructor;
+  while (parent && parent !== objPrototype) {
+    if (!getDirectiveDef(parent) && !getComponentDef(parent) && shouldAddAbstractDirective(parent)) {
+      compileDirective(parent, null);
+    }
+    parent = Object.getPrototypeOf(parent);
+  }
+}
+function convertToR3QueryPredicate(selector) {
+  return typeof selector === "string" ? splitByComma(selector) : resolveForwardRef(selector);
+}
+function convertToR3QueryMetadata(propertyName, ann) {
+  return {
+    propertyName,
+    predicate: convertToR3QueryPredicate(ann.selector),
+    descendants: ann.descendants,
+    first: ann.first,
+    read: ann.read ? ann.read : null,
+    static: !!ann.static,
+    emitDistinctChangesOnly: !!ann.emitDistinctChangesOnly,
+    isSignal: !!ann.isSignal
+  };
+}
+function extractQueriesMetadata(type, propMetadata, isQueryAnn) {
+  const signalQueriesMeta = [];
+  const decoratorQueriesMeta = [];
+  for (const field in propMetadata) {
+    if (propMetadata.hasOwnProperty(field)) {
+      const annotations = propMetadata[field];
+      annotations.forEach((ann) => {
+        if (isQueryAnn(ann)) {
+          if (!ann.selector) {
+            throw new Error(`Can't construct a query for the property "${field}" of "${stringifyForError(type)}" since the query selector wasn't defined.`);
+          }
+          if (annotations.some(isInputAnnotation)) {
+            throw new Error(`Cannot combine @Input decorators with query decorators`);
+          }
+          const queryMeta = convertToR3QueryMetadata(field, ann);
+          if (queryMeta.isSignal) {
+            signalQueriesMeta.push(queryMeta);
+          } else {
+            decoratorQueriesMeta.push(queryMeta);
+          }
+        }
+      });
+    }
+  }
+  return [...signalQueriesMeta, ...decoratorQueriesMeta];
+}
+function extractExportAs(exportAs) {
+  return exportAs === void 0 ? null : splitByComma(exportAs);
+}
+function isContentQuery(value) {
+  const name = value.ngMetadataName;
+  return name === "ContentChild" || name === "ContentChildren";
+}
+function isViewQuery(value) {
+  const name = value.ngMetadataName;
+  return name === "ViewChild" || name === "ViewChildren";
+}
+function isInputAnnotation(value) {
+  return value.ngMetadataName === "Input";
+}
+function splitByComma(value) {
+  return value.split(",").map((piece) => piece.trim());
+}
+var LIFECYCLE_HOOKS = ["ngOnChanges", "ngOnInit", "ngOnDestroy", "ngDoCheck", "ngAfterViewInit", "ngAfterViewChecked", "ngAfterContentInit", "ngAfterContentChecked"];
+function shouldAddAbstractDirective(type) {
+  const reflect = getReflect();
+  if (LIFECYCLE_HOOKS.some((hookName) => reflect.hasLifecycleHook(type, hookName))) {
+    return true;
+  }
+  const propMetadata = reflect.propMetadata(type);
+  for (const field in propMetadata) {
+    const annotations = propMetadata[field];
+    for (let i = 0; i < annotations.length; i++) {
+      const current = annotations[i];
+      const metadataName = current.ngMetadataName;
+      if (isInputAnnotation(current) || isContentQuery(current) || isViewQuery(current) || metadataName === "Output" || metadataName === "HostBinding" || metadataName === "HostListener") {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function compilePipe(type, meta) {
+  let ngPipeDef = null;
+  let ngFactoryDef = null;
+  Object.defineProperty(type, NG_FACTORY_DEF, {
+    get: () => {
+      if (ngFactoryDef === null) {
+        const metadata = getPipeMetadata(type, meta);
+        const compiler = getCompilerFacade({
+          usage: 0,
+          kind: "pipe",
+          type: metadata.type
+        });
+        ngFactoryDef = compiler.compileFactory(angularCoreEnv, `ng:///${metadata.name}/\u0275fac.js`, {
+          name: metadata.name,
+          type: metadata.type,
+          typeArgumentCount: 0,
+          deps: reflectDependencies(type),
+          target: compiler.FactoryTarget.Pipe
+        });
+      }
+      return ngFactoryDef;
+    },
+    configurable: !!ngDevMode
+  });
+  Object.defineProperty(type, NG_PIPE_DEF, {
+    get: () => {
+      if (ngPipeDef === null) {
+        const metadata = getPipeMetadata(type, meta);
+        const compiler = getCompilerFacade({
+          usage: 0,
+          kind: "pipe",
+          type: metadata.type
+        });
+        ngPipeDef = compiler.compilePipe(angularCoreEnv, `ng:///${metadata.name}/\u0275pipe.js`, metadata);
+      }
+      return ngPipeDef;
+    },
+    configurable: !!ngDevMode
+  });
+}
+function getPipeMetadata(type, meta) {
+  return {
+    type,
+    name: type.name,
+    pipeName: meta.name,
+    pure: meta.pure !== void 0 ? meta.pure : true,
+    isStandalone: meta.standalone === void 0 ? true : !!meta.standalone
+  };
+}
+var Directive = makeDecorator("Directive", (dir = {}) => dir, void 0, void 0, (type, meta) => compileDirective(type, meta));
+var Component = makeDecorator("Component", (c = {}) => __spreadValues({
+  changeDetection: ChangeDetectionStrategy.Eager
+}, c), Directive, void 0, (type, meta) => compileComponent(type, meta));
+var Pipe = makeDecorator("Pipe", (p) => __spreadValues({
+  pure: true
+}, p), void 0, void 0, (type, meta) => compilePipe(type, meta));
+var Input = makePropDecorator("Input", (arg) => {
+  if (!arg) {
+    return {};
+  }
+  return typeof arg === "string" ? {
+    alias: arg
+  } : arg;
+});
+var Output = makePropDecorator("Output", (alias) => ({
+  alias
+}));
+var HostBinding = makePropDecorator("HostBinding", (hostPropertyName) => ({
+  hostPropertyName
+}));
+var HostListener = makePropDecorator("HostListener", (eventName, args) => ({
+  eventName,
+  args
+}));
+var NgModule = makeDecorator("NgModule", (ngModule) => ngModule, void 0, void 0, (type, meta) => compileNgModule(type, meta));
+var ModuleWithComponentFactories = class {
+  ngModuleFactory;
+  componentFactories;
+  constructor(ngModuleFactory, componentFactories) {
+    this.ngModuleFactory = ngModuleFactory;
+    this.componentFactories = componentFactories;
+  }
+};
+var Compiler = class _Compiler {
+  compileModuleSync(moduleType) {
+    return new NgModuleFactory2(moduleType);
+  }
+  compileModuleAsync(moduleType) {
+    return Promise.resolve(this.compileModuleSync(moduleType));
+  }
+  compileModuleAndAllComponentsSync(moduleType) {
+    const ngModuleFactory = this.compileModuleSync(moduleType);
+    const moduleDef = getNgModuleDef(moduleType);
+    const componentFactories = maybeUnwrapFn(moduleDef.declarations).reduce((factories, declaration) => {
+      const componentDef = getComponentDef(declaration);
+      componentDef && factories.push(new ComponentFactory2(componentDef));
+      return factories;
+    }, []);
+    return new ModuleWithComponentFactories(ngModuleFactory, componentFactories);
+  }
+  compileModuleAndAllComponentsAsync(moduleType) {
+    return Promise.resolve(this.compileModuleAndAllComponentsSync(moduleType));
+  }
+  clearCache() {
+  }
+  clearCacheFor(type) {
+  }
+  getModuleId(moduleType) {
+    return void 0;
+  }
+  static \u0275fac = function Compiler_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _Compiler)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _Compiler,
+    factory: _Compiler.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(Compiler, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], null, null);
+})();
+var COMPILER_OPTIONS = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "compilerOptions" : "");
+var CONSECUTIVE_MICROTASK_NOTIFICATION_LIMIT = 100;
+var consecutiveMicrotaskNotifications = 0;
+var stackFromLastFewNotifications = [];
+function trackMicrotaskNotificationForDebugging() {
+  consecutiveMicrotaskNotifications++;
+  if (CONSECUTIVE_MICROTASK_NOTIFICATION_LIMIT - consecutiveMicrotaskNotifications < 5) {
+    const stack = new Error().stack;
+    if (stack) {
+      stackFromLastFewNotifications.push(stack);
+    }
+  }
+  if (consecutiveMicrotaskNotifications === CONSECUTIVE_MICROTASK_NOTIFICATION_LIMIT) {
+    throw new RuntimeError(103, "Angular could not stabilize because there were endless change notifications within the browser event loop. The stack from the last several notifications: \n" + stackFromLastFewNotifications.join("\n"));
+  }
+}
+var ChangeDetectionSchedulerImpl = class _ChangeDetectionSchedulerImpl {
+  applicationErrorHandler = inject2(INTERNAL_APPLICATION_ERROR_HANDLER);
+  appRef = inject2(ApplicationRef);
+  taskService = inject2(PendingTasksInternal);
+  ngZone = inject2(NgZone);
+  zonelessEnabled = inject2(ZONELESS_ENABLED);
+  tracing = inject2(TracingService, {
+    optional: true
+  });
+  zoneIsDefined = typeof Zone !== "undefined" && !!Zone.root.run;
+  schedulerTickApplyArgs = [{
+    data: {
+      "__scheduler_tick__": true
+    }
+  }];
+  subscriptions = new Subscription();
+  angularZoneId = this.zoneIsDefined ? this.ngZone._inner?.get(angularZoneInstanceIdProperty) : null;
+  scheduleInRootZone = !this.zonelessEnabled && this.zoneIsDefined && (inject2(SCHEDULE_IN_ROOT_ZONE, {
+    optional: true
+  }) ?? false);
+  cancelScheduledCallback = null;
+  useMicrotaskScheduler = false;
+  runningTick = false;
+  pendingRenderTaskId = null;
+  constructor() {
+    this.subscriptions.add(this.appRef.afterTick.subscribe(() => {
+      const task = this.taskService.add();
+      if (!this.runningTick) {
+        this.cleanup();
+        if (!this.zonelessEnabled || this.appRef.includeAllTestViews) {
+          this.taskService.remove(task);
+          return;
+        }
+      }
+      this.switchToMicrotaskScheduler();
+      this.taskService.remove(task);
+    }));
+    this.subscriptions.add(this.ngZone.onUnstable.subscribe(() => {
+      if (!this.runningTick) {
+        this.cleanup();
+      }
+    }));
+  }
+  switchToMicrotaskScheduler() {
+    this.ngZone.runOutsideAngular(() => {
+      const task = this.taskService.add();
+      this.useMicrotaskScheduler = true;
+      queueMicrotask(() => {
+        this.useMicrotaskScheduler = false;
+        this.taskService.remove(task);
+      });
+    });
+  }
+  notify(source) {
+    if (!this.zonelessEnabled && source === 5) {
+      return;
+    }
+    switch (source) {
+      case 0: {
+        this.appRef.dirtyFlags |= 2;
+        break;
+      }
+      case 3:
+      case 2:
+      case 4:
+      case 5:
+      case 1: {
+        this.appRef.dirtyFlags |= 4;
+        break;
+      }
+      case 6: {
+        this.appRef.dirtyFlags |= 2;
+        break;
+      }
+      case 12: {
+        this.appRef.dirtyFlags |= 16;
+        break;
+      }
+      case 13: {
+        this.appRef.dirtyFlags |= 2;
+        break;
+      }
+      case 11: {
+        break;
+      }
+      case 9:
+      case 8:
+      case 7:
+      case 10:
+      default: {
+        this.appRef.dirtyFlags |= 8;
+      }
+    }
+    this.appRef.tracingSnapshot = this.tracing?.snapshot(this.appRef.tracingSnapshot) ?? null;
+    if (!this.shouldScheduleTick()) {
+      return;
+    }
+    if (typeof ngDevMode === "undefined" || ngDevMode) {
+      if (this.useMicrotaskScheduler) {
+        trackMicrotaskNotificationForDebugging();
+      } else {
+        consecutiveMicrotaskNotifications = 0;
+        stackFromLastFewNotifications.length = 0;
+      }
+    }
+    const scheduleCallback = this.useMicrotaskScheduler ? scheduleCallbackWithMicrotask : scheduleCallbackWithRafRace;
+    this.pendingRenderTaskId = this.taskService.add();
+    if (this.scheduleInRootZone) {
+      this.cancelScheduledCallback = Zone.root.run(() => scheduleCallback(() => this.tick()));
+    } else {
+      this.cancelScheduledCallback = this.ngZone.runOutsideAngular(() => scheduleCallback(() => this.tick()));
+    }
+  }
+  shouldScheduleTick() {
+    if (this.appRef.destroyed) {
+      return false;
+    }
+    if (this.pendingRenderTaskId !== null || this.runningTick || this.appRef._runningTick) {
+      return false;
+    }
+    if (!this.zonelessEnabled && this.zoneIsDefined && Zone.current.get(angularZoneInstanceIdProperty + this.angularZoneId)) {
+      return false;
+    }
+    return true;
+  }
+  tick() {
+    if (this.runningTick || this.appRef.destroyed) {
+      return;
+    }
+    if (this.appRef.dirtyFlags === 0) {
+      this.cleanup();
+      return;
+    }
+    if (!this.zonelessEnabled && this.appRef.dirtyFlags & 7) {
+      this.appRef.dirtyFlags |= 1;
+    }
+    const task = this.taskService.add();
+    try {
+      this.ngZone.run(() => {
+        this.runningTick = true;
+        this.appRef._tick();
+      }, void 0, this.schedulerTickApplyArgs);
+    } catch (e) {
+      this.applicationErrorHandler(e);
+    } finally {
+      this.taskService.remove(task);
+      this.cleanup();
+    }
+  }
+  ngOnDestroy() {
+    this.subscriptions.unsubscribe();
+    this.cleanup();
+  }
+  cleanup() {
+    this.runningTick = false;
+    this.cancelScheduledCallback?.();
+    this.cancelScheduledCallback = null;
+    if (this.pendingRenderTaskId !== null) {
+      const taskId = this.pendingRenderTaskId;
+      this.pendingRenderTaskId = null;
+      this.taskService.remove(taskId);
+    }
+  }
+  static \u0275fac = function ChangeDetectionSchedulerImpl_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _ChangeDetectionSchedulerImpl)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _ChangeDetectionSchedulerImpl,
+    factory: _ChangeDetectionSchedulerImpl.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ChangeDetectionSchedulerImpl, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], () => [], null);
+})();
+function provideZonelessChangeDetectionInternal() {
+  return [{
+    provide: ChangeDetectionScheduler,
+    useExisting: ChangeDetectionSchedulerImpl
+  }, {
+    provide: NgZone,
+    useClass: NoopNgZone
+  }, {
+    provide: ZONELESS_ENABLED,
+    useValue: true
+  }];
+}
+function getGlobalLocale() {
+  if (false) {
+    return goog.LOCALE;
+  } else {
+    return typeof $localize !== "undefined" && $localize.locale || DEFAULT_LOCALE_ID;
+  }
+}
+var LOCALE_ID = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "LocaleId" : "", {
+  factory: () => inject2(LOCALE_ID, {
+    optional: true,
+    skipSelf: true
+  }) || getGlobalLocale()
+});
+var DEFAULT_CURRENCY_CODE = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "DefaultCurrencyCode" : "", {
+  factory: () => USD_CURRENCY_CODE
+});
+var TRANSLATIONS = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "Translations" : "");
+var TRANSLATIONS_FORMAT = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "TranslationsFormat" : "");
+var MissingTranslationStrategy;
+(function(MissingTranslationStrategy2) {
+  MissingTranslationStrategy2[MissingTranslationStrategy2["Error"] = 0] = "Error";
+  MissingTranslationStrategy2[MissingTranslationStrategy2["Warning"] = 1] = "Warning";
+  MissingTranslationStrategy2[MissingTranslationStrategy2["Ignore"] = 2] = "Ignore";
+})(MissingTranslationStrategy || (MissingTranslationStrategy = {}));
+
+// node_modules/@angular/core/fesm2022/_resource-chunk.mjs
+/**
+ * @license Angular v21.2.17
+ * (c) 2010-2026 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+var OutputEmitterRef = class {
+  destroyed = false;
+  listeners = null;
+  errorHandler = inject2(ErrorHandler, {
+    optional: true
+  });
+  destroyRef = inject2(DestroyRef);
+  constructor() {
+    this.destroyRef.onDestroy(() => {
+      this.destroyed = true;
+      this.listeners = null;
+    });
+  }
+  subscribe(callback) {
+    if (this.destroyed) {
+      throw new RuntimeError(953, ngDevMode && "Unexpected subscription to destroyed `OutputRef`. The owning directive/component is destroyed.");
+    }
+    (this.listeners ??= []).push(callback);
+    return {
+      unsubscribe: () => {
+        const idx = this.listeners?.indexOf(callback);
+        if (idx !== void 0 && idx !== -1) {
+          this.listeners?.splice(idx, 1);
+        }
+      }
+    };
+  }
+  emit(value) {
+    if (this.destroyed) {
+      console.warn(formatRuntimeError(953, ngDevMode && "Unexpected emit for destroyed `OutputRef`. The owning directive/component is destroyed."));
+      return;
+    }
+    if (this.listeners === null) {
+      return;
+    }
+    const previousConsumer = setActiveConsumer(null);
+    try {
+      for (const listenerFn of this.listeners) {
+        try {
+          listenerFn(value);
+        } catch (err) {
+          this.errorHandler?.handleError(err);
+        }
+      }
+    } finally {
+      setActiveConsumer(previousConsumer);
+    }
+  }
+};
+function untracked2(nonReactiveReadsFn) {
+  return untracked(nonReactiveReadsFn);
+}
+function computed(computation, options) {
+  const getter = createComputed(computation, options?.equal);
+  if (typeof ngDevMode !== "undefined" && ngDevMode) {
+    const debugName = options?.debugName;
+    getter[SIGNAL].debugName = debugName;
+    getter.toString = () => `[Computed${debugName ? " (" + debugName + ")" : ""}: ${getter()}]`;
+  }
+  return getter;
+}
+var identityFn = (v) => v;
+function linkedSignal(optionsOrComputation, options) {
+  if (typeof optionsOrComputation === "function") {
+    const getter = createLinkedSignal(optionsOrComputation, identityFn, options?.equal);
+    return upgradeLinkedSignalGetter(getter, options?.debugName);
+  } else {
+    const getter = createLinkedSignal(optionsOrComputation.source, optionsOrComputation.computation, optionsOrComputation.equal);
+    return upgradeLinkedSignalGetter(getter, optionsOrComputation.debugName);
+  }
+}
+function upgradeLinkedSignalGetter(getter, debugName) {
+  if (typeof ngDevMode !== "undefined" && ngDevMode) {
+    getter[SIGNAL].debugName = debugName;
+    getter.toString = () => `[LinkedSignal${debugName ? " (" + debugName + ")" : ""}: ${getter()}]`;
+  }
+  const node = getter[SIGNAL];
+  const upgradedGetter = getter;
+  upgradedGetter.set = (newValue) => linkedSignalSetFn(node, newValue);
+  upgradedGetter.update = (updateFn) => linkedSignalUpdateFn(node, updateFn);
+  upgradedGetter.asReadonly = signalAsReadonlyFn.bind(getter);
+  return upgradedGetter;
+}
+var BaseWritableResource = class {
+  value;
+  isLoading;
+  constructor(value, debugName) {
+    this.value = value;
+    this.value.set = this.set.bind(this);
+    this.value.update = this.update.bind(this);
+    this.value.asReadonly = signalAsReadonlyFn;
+    this.isLoading = computed(() => this.status() === "loading" || this.status() === "reloading", ngDevMode ? createDebugNameObject(debugName, "isLoading") : void 0);
+  }
+  isError = computed(() => this.status() === "error");
+  update(updateFn) {
+    this.set(updateFn(untracked2(this.value)));
+  }
+  isValueDefined = computed(() => {
+    if (this.isError()) {
+      return false;
+    }
+    return this.value() !== void 0;
+  });
+  _snapshot;
+  get snapshot() {
+    return this._snapshot ??= computed(() => {
+      const status = this.status();
+      if (status === "error") {
+        return {
+          status: "error",
+          error: this.error()
+        };
+      } else {
+        return {
+          status,
+          value: this.value()
+        };
+      }
+    });
+  }
+  hasValue() {
+    return this.isValueDefined();
+  }
+  asReadonly() {
+    return this;
+  }
+};
+var ResourceImpl = class extends BaseWritableResource {
+  loaderFn;
+  equal;
+  debugName;
+  pendingTasks;
+  state;
+  extRequest;
+  effectRef;
+  pendingController;
+  resolvePendingTask = void 0;
+  destroyed = false;
+  unregisterOnDestroy;
+  status;
+  error;
+  constructor(request, loaderFn, defaultValue, equal, debugName, injector, getInitialStream) {
+    super(computed(() => {
+      const streamValue = this.state().stream?.();
+      if (!streamValue) {
+        return defaultValue;
+      }
+      if (this.state().status === "loading" && this.error()) {
+        return defaultValue;
+      }
+      if (!isResolved(streamValue)) {
+        throw new ResourceValueError(this.error());
+      }
+      return streamValue.value;
+    }, __spreadValues({
+      equal
+    }, ngDevMode ? createDebugNameObject(debugName, "value") : void 0)), debugName);
+    this.loaderFn = loaderFn;
+    this.equal = equal;
+    this.debugName = debugName;
+    this.extRequest = linkedSignal(__spreadValues({
+      source: request,
+      computation: (request2) => ({
+        request: request2,
+        reload: 0
+      })
+    }, ngDevMode ? createDebugNameObject(debugName, "extRequest") : void 0));
+    this.state = linkedSignal(__spreadValues({
+      source: this.extRequest,
+      computation: (extRequest, previous) => {
+        if (!previous) {
+          const initialStream = getInitialStream?.(extRequest.request);
+          getInitialStream = void 0;
+          const status = extRequest.request === void 0 ? "idle" : initialStream ? "resolved" : "loading";
+          return {
+            extRequest,
+            status,
+            previousStatus: "idle",
+            stream: initialStream
+          };
+        } else {
+          const status = extRequest.request === void 0 ? "idle" : "loading";
+          return {
+            extRequest,
+            status,
+            previousStatus: projectStatusOfState(previous.value),
+            stream: previous.value.extRequest.request === extRequest.request ? previous.value.stream : void 0
+          };
+        }
+      }
+    }, ngDevMode ? createDebugNameObject(debugName, "state") : void 0));
+    this.effectRef = effect(this.loadEffect.bind(this), __spreadValues({
+      injector,
+      manualCleanup: true
+    }, ngDevMode ? createDebugNameObject(debugName, "loadEffect") : void 0));
+    this.pendingTasks = injector.get(PendingTasks);
+    this.unregisterOnDestroy = injector.get(DestroyRef).onDestroy(() => this.destroy());
+    this.status = computed(() => projectStatusOfState(this.state()), ngDevMode ? createDebugNameObject(debugName, "status") : void 0);
+    this.error = computed(() => {
+      const stream = this.state().stream?.();
+      return stream && !isResolved(stream) ? stream.error : void 0;
+    }, ngDevMode ? createDebugNameObject(debugName, "error") : void 0);
+  }
+  set(value) {
+    if (this.destroyed) {
+      return;
+    }
+    const error = untracked2(this.error);
+    const state = untracked2(this.state);
+    if (!error) {
+      const current = untracked2(this.value);
+      if (state.status === "local" && (this.equal ? this.equal(current, value) : current === value)) {
+        return;
+      }
+    }
+    this.state.set({
+      extRequest: state.extRequest,
+      status: "local",
+      previousStatus: "local",
+      stream: signal({
+        value
+      }, ngDevMode ? createDebugNameObject(this.debugName, "stream") : void 0)
+    });
+    this.abortInProgressLoad();
+  }
+  reload() {
+    const {
+      status
+    } = untracked2(this.state);
+    if (status === "idle" || status === "loading") {
+      return false;
+    }
+    this.extRequest.update(({
+      request,
+      reload
+    }) => ({
+      request,
+      reload: reload + 1
+    }));
+    return true;
+  }
+  destroy() {
+    this.destroyed = true;
+    this.unregisterOnDestroy();
+    this.effectRef.destroy();
+    this.abortInProgressLoad();
+    this.state.set({
+      extRequest: {
+        request: void 0,
+        reload: 0
+      },
+      status: "idle",
+      previousStatus: "idle",
+      stream: void 0
+    });
+  }
+  async loadEffect() {
+    const extRequest = this.extRequest();
+    const {
+      status: currentStatus,
+      previousStatus
+    } = untracked2(this.state);
+    if (extRequest.request === void 0) {
+      return;
+    } else if (currentStatus !== "loading") {
+      return;
+    }
+    this.abortInProgressLoad();
+    let resolvePendingTask = this.resolvePendingTask = this.pendingTasks.add();
+    const {
+      signal: abortSignal
+    } = this.pendingController = new AbortController();
+    try {
+      const stream = await untracked2(() => {
+        return this.loaderFn({
+          params: extRequest.request,
+          abortSignal,
+          previous: {
+            status: previousStatus
+          }
+        });
+      });
+      if (abortSignal.aborted || untracked2(this.extRequest) !== extRequest) {
+        return;
+      }
+      this.state.set({
+        extRequest,
+        status: "resolved",
+        previousStatus: "resolved",
+        stream
+      });
+    } catch (err) {
+      if (abortSignal.aborted || untracked2(this.extRequest) !== extRequest) {
+        return;
+      }
+      this.state.set({
+        extRequest,
+        status: "resolved",
+        previousStatus: "error",
+        stream: signal({
+          error: encapsulateResourceError(err)
+        }, ngDevMode ? createDebugNameObject(this.debugName, "stream") : void 0)
+      });
+    } finally {
+      resolvePendingTask?.();
+      resolvePendingTask = void 0;
+    }
+  }
+  abortInProgressLoad() {
+    untracked2(() => this.pendingController?.abort());
+    this.pendingController = void 0;
+    this.resolvePendingTask?.();
+    this.resolvePendingTask = void 0;
+  }
+};
+function projectStatusOfState(state) {
+  switch (state.status) {
+    case "loading":
+      return state.extRequest.reload === 0 ? "loading" : "reloading";
+    case "resolved":
+      return isResolved(state.stream()) ? "resolved" : "error";
+    default:
+      return state.status;
+  }
+}
+function isResolved(state) {
+  return state.error === void 0;
+}
+function createDebugNameObject(resourceDebugName, internalSignalDebugName) {
+  return {
+    debugName: `Resource${resourceDebugName ? "#" + resourceDebugName : ""}.${internalSignalDebugName}`
+  };
+}
+function encapsulateResourceError(error) {
+  if (isErrorLike(error)) {
+    return error;
+  }
+  return new ResourceWrappedError(error);
+}
+function isErrorLike(error) {
+  return error instanceof Error || typeof error === "object" && typeof error.name === "string" && typeof error.message === "string";
+}
+var ResourceValueError = class extends Error {
+  constructor(error) {
+    super(ngDevMode ? `Resource is currently in an error state (see Error.cause for details): ${error.message}` : error.message, {
+      cause: error
+    });
+  }
+};
+var ResourceWrappedError = class extends Error {
+  constructor(error) {
+    super(ngDevMode ? `Resource returned an error that's not an Error instance: ${String(error)}. Check this error's .cause for the actual error.` : String(error), {
+      cause: error
+    });
+  }
+};
+
+// node_modules/@angular/core/fesm2022/core.mjs
+/**
+ * @license Angular v21.2.17
+ * (c) 2010-2026 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+var REQUIRED_UNSET_VALUE = /* @__PURE__ */ Symbol("InputSignalNode#UNSET");
+var INPUT_SIGNAL_NODE = /* @__PURE__ */ (() => {
+  return __spreadProps(__spreadValues({}, SIGNAL_NODE), {
+    transformFn: void 0,
+    applyValueToInputSignal(node, value) {
+      signalSetFn(node, value);
+    }
+  });
+})();
+function createInputSignal(initialValue, options) {
+  const node = Object.create(INPUT_SIGNAL_NODE);
+  node.value = initialValue;
+  node.transformFn = options?.transform;
+  function inputValueFn() {
+    producerAccessed(node);
+    if (node.value === REQUIRED_UNSET_VALUE) {
+      let message = null;
+      if (ngDevMode) {
+        const name = options?.debugName ?? options?.alias;
+        message = `Input${name ? ` "${name}"` : ""} is required but no value is available yet.`;
+      }
+      throw new RuntimeError(-950, message);
+    }
+    return node.value;
+  }
+  inputValueFn[SIGNAL] = node;
+  if (ngDevMode) {
+    inputValueFn.toString = () => `[Input Signal: ${inputValueFn()}]`;
+    node.debugName = options?.debugName;
+  }
+  return inputValueFn;
+}
+var FactoryTarget;
+(function(FactoryTarget2) {
+  FactoryTarget2[FactoryTarget2["Directive"] = 0] = "Directive";
+  FactoryTarget2[FactoryTarget2["Component"] = 1] = "Component";
+  FactoryTarget2[FactoryTarget2["Injectable"] = 2] = "Injectable";
+  FactoryTarget2[FactoryTarget2["Pipe"] = 3] = "Pipe";
+  FactoryTarget2[FactoryTarget2["NgModule"] = 4] = "NgModule";
+})(FactoryTarget || (FactoryTarget = {}));
+var R3TemplateDependencyKind;
+(function(R3TemplateDependencyKind2) {
+  R3TemplateDependencyKind2[R3TemplateDependencyKind2["Directive"] = 0] = "Directive";
+  R3TemplateDependencyKind2[R3TemplateDependencyKind2["Pipe"] = 1] = "Pipe";
+  R3TemplateDependencyKind2[R3TemplateDependencyKind2["NgModule"] = 2] = "NgModule";
+})(R3TemplateDependencyKind || (R3TemplateDependencyKind = {}));
+var ViewEncapsulation2;
+(function(ViewEncapsulation3) {
+  ViewEncapsulation3[ViewEncapsulation3["Emulated"] = 0] = "Emulated";
+  ViewEncapsulation3[ViewEncapsulation3["None"] = 2] = "None";
+  ViewEncapsulation3[ViewEncapsulation3["ShadowDom"] = 3] = "ShadowDom";
+  ViewEncapsulation3[ViewEncapsulation3["ExperimentalIsolatedShadowDom"] = 4] = "ExperimentalIsolatedShadowDom";
+})(ViewEncapsulation2 || (ViewEncapsulation2 = {}));
+var Framework;
+(function(Framework2) {
+  Framework2["Angular"] = "angular";
+  Framework2["ACX"] = "acx";
+  Framework2["Wiz"] = "wiz";
+})(Framework || (Framework = {}));
+var HostAttributeToken = class {
+  attributeName;
+  constructor(attributeName) {
+    this.attributeName = attributeName;
+  }
+  __NG_ELEMENT_ID__ = () => \u0275\u0275injectAttribute(this.attributeName);
+  toString() {
+    return `HostAttributeToken ${this.attributeName}`;
+  }
+};
+function inputFunction(initialValue, opts) {
+  ngDevMode && assertInInjectionContext(input);
+  return createInputSignal(initialValue, opts);
+}
+function inputRequiredFunction(opts) {
+  ngDevMode && assertInInjectionContext(input);
+  return createInputSignal(REQUIRED_UNSET_VALUE, opts);
+}
+var input = (() => {
+  inputFunction.required = inputRequiredFunction;
+  return inputFunction;
+})();
+function viewChildFn(locator, opts) {
+  ngDevMode && assertInInjectionContext(viewChild);
+  return createSingleResultOptionalQuerySignalFn(opts);
+}
+function viewChildRequiredFn(locator, opts) {
+  ngDevMode && assertInInjectionContext(viewChild);
+  return createSingleResultRequiredQuerySignalFn(opts);
+}
+var viewChild = (() => {
+  viewChildFn.required = viewChildRequiredFn;
+  return viewChildFn;
+})();
+function contentChildFn(locator, opts) {
+  ngDevMode && assertInInjectionContext(contentChild);
+  return createSingleResultOptionalQuerySignalFn(opts);
+}
+function contentChildRequiredFn(locator, opts) {
+  ngDevMode && assertInInjectionContext(contentChildren);
+  return createSingleResultRequiredQuerySignalFn(opts);
+}
+var contentChild = (() => {
+  contentChildFn.required = contentChildRequiredFn;
+  return contentChildFn;
+})();
+function contentChildren(locator, opts) {
+  return createMultiResultQuerySignalFn(opts);
+}
+function createModelSignal(initialValue, opts) {
+  const node = Object.create(INPUT_SIGNAL_NODE);
+  const emitterRef = new OutputEmitterRef();
+  node.value = initialValue;
+  function getter() {
+    producerAccessed(node);
+    assertModelSet(node.value);
+    return node.value;
+  }
+  getter[SIGNAL] = node;
+  getter.asReadonly = signalAsReadonlyFn.bind(getter);
+  getter.set = (newValue) => {
+    if (!node.equal(node.value, newValue)) {
+      signalSetFn(node, newValue);
+      emitterRef.emit(newValue);
+    }
+  };
+  getter.update = (updateFn) => {
+    assertModelSet(node.value);
+    getter.set(updateFn(node.value));
+  };
+  getter.subscribe = emitterRef.subscribe.bind(emitterRef);
+  getter.destroyRef = emitterRef.destroyRef;
+  if (ngDevMode) {
+    getter.toString = () => `[Model Signal: ${getter()}]`;
+    node.debugName = opts?.debugName;
+  }
+  return getter;
+}
+function assertModelSet(value) {
+  if (value === REQUIRED_UNSET_VALUE) {
+    throw new RuntimeError(952, ngDevMode && "Model is required but no value is available yet.");
+  }
+}
+function modelFunction(initialValue, opts) {
+  ngDevMode && assertInInjectionContext(model);
+  return createModelSignal(initialValue, opts);
+}
+function modelRequiredFunction(opts) {
+  ngDevMode && assertInInjectionContext(model);
+  return createModelSignal(REQUIRED_UNSET_VALUE, opts);
+}
+var model = (() => {
+  modelFunction.required = modelRequiredFunction;
+  return modelFunction;
+})();
+var emitDistinctChangesOnlyDefaultValue = true;
+var Query = class {
+};
+var ContentChildren = makePropDecorator("ContentChildren", (selector, opts = {}) => __spreadValues({
+  selector,
+  first: false,
+  isViewQuery: false,
+  descendants: false,
+  emitDistinctChangesOnly: emitDistinctChangesOnlyDefaultValue
+}, opts), Query);
+var ContentChild = makePropDecorator("ContentChild", (selector, opts = {}) => __spreadValues({
+  selector,
+  first: true,
+  isViewQuery: false,
+  descendants: true
+}, opts), Query);
+var ViewChildren = makePropDecorator("ViewChildren", (selector, opts = {}) => __spreadValues({
+  selector,
+  first: false,
+  isViewQuery: true,
+  descendants: true,
+  emitDistinctChangesOnly: emitDistinctChangesOnlyDefaultValue
+}, opts), Query);
+var ViewChild = makePropDecorator("ViewChild", (selector, opts) => __spreadValues({
+  selector,
+  first: true,
+  isViewQuery: true,
+  descendants: true
+}, opts), Query);
+function compileNgModuleFactory(injector, options, moduleType) {
+  ngDevMode && assertNgModuleType(moduleType);
+  const moduleFactory = new NgModuleFactory2(moduleType);
+  if (true) {
+    return Promise.resolve(moduleFactory);
+  }
+  const compilerOptions = injector.get(COMPILER_OPTIONS, []).concat(options);
+  setJitOptions({
+    defaultEncapsulation: _lastDefined(compilerOptions.map((opts) => opts.defaultEncapsulation)),
+    preserveWhitespaces: _lastDefined(compilerOptions.map((opts) => opts.preserveWhitespaces))
+  });
+  if (isComponentResourceResolutionQueueEmpty()) {
+    return Promise.resolve(moduleFactory);
+  }
+  const compilerProviders = compilerOptions.flatMap((option) => option.providers ?? []);
+  if (compilerProviders.length === 0) {
+    return Promise.resolve(moduleFactory);
+  }
+  const compiler = getCompilerFacade({
+    usage: 0,
+    kind: "NgModule",
+    type: moduleType
+  });
+  const compilerInjector = Injector.create({
+    providers: compilerProviders
+  });
+  const resourceLoader = compilerInjector.get(compiler.ResourceLoader);
+  return resolveComponentResources((url) => Promise.resolve(resourceLoader.get(url))).then(() => moduleFactory);
+}
+function _lastDefined(args) {
+  for (let i = args.length - 1; i >= 0; i--) {
+    if (args[i] !== void 0) {
+      return args[i];
+    }
+  }
+  return void 0;
+}
+var NgZoneChangeDetectionScheduler = class _NgZoneChangeDetectionScheduler {
+  zone = inject2(NgZone);
+  changeDetectionScheduler = inject2(ChangeDetectionScheduler);
+  applicationRef = inject2(ApplicationRef);
+  applicationErrorHandler = inject2(INTERNAL_APPLICATION_ERROR_HANDLER);
+  _onMicrotaskEmptySubscription;
+  initialize() {
+    if (this._onMicrotaskEmptySubscription) {
+      return;
+    }
+    this._onMicrotaskEmptySubscription = this.zone.onMicrotaskEmpty.subscribe({
+      next: () => {
+        if (this.changeDetectionScheduler.runningTick) {
+          return;
+        }
+        this.zone.run(() => {
+          try {
+            this.applicationRef.dirtyFlags |= 1;
+            this.applicationRef._tick();
+          } catch (e) {
+            this.applicationErrorHandler(e);
+          }
+        });
+      }
+    });
+  }
+  ngOnDestroy() {
+    this._onMicrotaskEmptySubscription?.unsubscribe();
+  }
+  static \u0275fac = function NgZoneChangeDetectionScheduler_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _NgZoneChangeDetectionScheduler)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _NgZoneChangeDetectionScheduler,
+    factory: _NgZoneChangeDetectionScheduler.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgZoneChangeDetectionScheduler, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], null, null);
+})();
+var PROVIDED_NG_ZONE = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "provideZoneChangeDetection token" : "", {
+  factory: () => false
+});
+var ZoneStablePendingTask = class _ZoneStablePendingTask {
+  subscription = new Subscription();
+  initialized = false;
+  zone = inject2(NgZone);
+  pendingTasks = inject2(PendingTasksInternal);
+  initialize() {
+    if (this.initialized) {
+      return;
+    }
+    this.initialized = true;
+    let task = null;
+    if (!this.zone.isStable && !this.zone.hasPendingMacrotasks && !this.zone.hasPendingMicrotasks) {
+      task = this.pendingTasks.add();
+    }
+    this.zone.runOutsideAngular(() => {
+      this.subscription.add(this.zone.onStable.subscribe(() => {
+        NgZone.assertNotInAngularZone();
+        queueMicrotask(() => {
+          if (task !== null && !this.zone.hasPendingMacrotasks && !this.zone.hasPendingMicrotasks) {
+            this.pendingTasks.remove(task);
+            task = null;
+          }
+        });
+      }));
+    });
+    this.subscription.add(this.zone.onUnstable.subscribe(() => {
+      NgZone.assertInAngularZone();
+      task ??= this.pendingTasks.add();
+    }));
+  }
+  ngOnDestroy() {
+    this.subscription.unsubscribe();
+  }
+  static \u0275fac = function ZoneStablePendingTask_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _ZoneStablePendingTask)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _ZoneStablePendingTask,
+    factory: _ZoneStablePendingTask.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ZoneStablePendingTask, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], null, null);
+})();
+var SCAN_DELAY = 200;
+var OVERSIZED_IMAGE_TOLERANCE = 1200;
+var ImagePerformanceWarning = class _ImagePerformanceWarning {
+  window = null;
+  observer = null;
+  options = inject2(IMAGE_CONFIG);
+  lcpImageUrl;
+  start() {
+    if (typeof PerformanceObserver === "undefined" || this.options?.disableImageSizeWarning && this.options?.disableImageLazyLoadWarning) {
+      return;
+    }
+    this.observer = this.initPerformanceObserver();
+    const doc = getDocument();
+    const win = doc.defaultView;
+    if (win) {
+      this.window = win;
+      const waitToScan = () => {
+        setTimeout(this.scanImages.bind(this), SCAN_DELAY);
+      };
+      const setup = () => {
+        if (doc.readyState === "complete") {
+          waitToScan();
+        } else {
+          this.window?.addEventListener("load", waitToScan, {
+            once: true
+          });
+        }
+      };
+      if (typeof Zone !== "undefined") {
+        Zone.root.run(() => setup());
+      } else {
+        setup();
+      }
+    }
+  }
+  ngOnDestroy() {
+    this.observer?.disconnect();
+  }
+  initPerformanceObserver() {
+    if (typeof PerformanceObserver === "undefined") {
+      return null;
+    }
+    const observer = new PerformanceObserver((entryList) => {
+      const entries = entryList.getEntries();
+      if (entries.length === 0) return;
+      const lcpElement = entries[entries.length - 1];
+      const imgSrc = lcpElement.element?.src ?? "";
+      if (imgSrc.startsWith("data:") || imgSrc.startsWith("blob:")) return;
+      this.lcpImageUrl = imgSrc;
+    });
+    observer.observe({
+      type: "largest-contentful-paint",
+      buffered: true
+    });
+    return observer;
+  }
+  scanImages() {
+    const images = getDocument().querySelectorAll("img");
+    let lcpElementFound, lcpElementLoadedCorrectly = false;
+    for (let index = 0; index < images.length; index++) {
+      const image = images[index];
+      if (!image) {
+        continue;
+      }
+      if (!this.options?.disableImageSizeWarning) {
+        if (!image.getAttribute("ng-img") && this.isOversized(image)) {
+          logOversizedImageWarning(image.src);
+        }
+      }
+      if (!this.options?.disableImageLazyLoadWarning && this.lcpImageUrl) {
+        if (image.src === this.lcpImageUrl) {
+          lcpElementFound = true;
+          if (image.loading !== "lazy" || image.getAttribute("ng-img")) {
+            lcpElementLoadedCorrectly = true;
+          }
+        }
+      }
+    }
+    if (lcpElementFound && !lcpElementLoadedCorrectly && this.lcpImageUrl && !this.options?.disableImageLazyLoadWarning) {
+      logLazyLCPWarning(this.lcpImageUrl);
+    }
+  }
+  isOversized(image) {
+    if (!this.window) {
+      return false;
+    }
+    const nonOversizedImageExtentions = [".svg"];
+    const imageSource = (image.src || "").toLowerCase();
+    if (nonOversizedImageExtentions.some((extension) => imageSource.endsWith(extension))) {
+      return false;
+    }
+    const computedStyle = this.window.getComputedStyle(image);
+    let renderedWidth = parseFloat(computedStyle.getPropertyValue("width"));
+    let renderedHeight = parseFloat(computedStyle.getPropertyValue("height"));
+    const boxSizing = computedStyle.getPropertyValue("box-sizing");
+    const objectFit = computedStyle.getPropertyValue("object-fit");
+    if (objectFit === `cover`) {
+      return false;
+    }
+    if (boxSizing === "border-box") {
+      const paddingTop = computedStyle.getPropertyValue("padding-top");
+      const paddingRight = computedStyle.getPropertyValue("padding-right");
+      const paddingBottom = computedStyle.getPropertyValue("padding-bottom");
+      const paddingLeft = computedStyle.getPropertyValue("padding-left");
+      renderedWidth -= parseFloat(paddingRight) + parseFloat(paddingLeft);
+      renderedHeight -= parseFloat(paddingTop) + parseFloat(paddingBottom);
+    }
+    const intrinsicWidth = image.naturalWidth;
+    const intrinsicHeight = image.naturalHeight;
+    const recommendedWidth = this.window.devicePixelRatio * renderedWidth;
+    const recommendedHeight = this.window.devicePixelRatio * renderedHeight;
+    const oversizedWidth = intrinsicWidth - recommendedWidth >= OVERSIZED_IMAGE_TOLERANCE;
+    const oversizedHeight = intrinsicHeight - recommendedHeight >= OVERSIZED_IMAGE_TOLERANCE;
+    return oversizedWidth || oversizedHeight;
+  }
+  static \u0275fac = function ImagePerformanceWarning_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _ImagePerformanceWarning)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _ImagePerformanceWarning,
+    factory: _ImagePerformanceWarning.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ImagePerformanceWarning, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], null, null);
+})();
+function logLazyLCPWarning(src) {
+  console.warn(formatRuntimeError(-913, `An image with src ${src} is the Largest Contentful Paint (LCP) element but was given a "loading" value of "lazy", which can negatively impact application loading performance. This warning can be addressed by changing the loading value of the LCP image to "eager", or by using the NgOptimizedImage directive's prioritization utilities. For more information about addressing or disabling this warning, see ${ERROR_DETAILS_PAGE_BASE_URL}/NG0913`));
+}
+function logOversizedImageWarning(src) {
+  console.warn(formatRuntimeError(-913, `An image with src ${src} has intrinsic file dimensions much larger than its rendered size. This can negatively impact application loading performance. For more information about addressing or disabling this warning, see ${ERROR_DETAILS_PAGE_BASE_URL}/NG0913`));
+}
+var PLATFORM_DESTROY_LISTENERS = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "PlatformDestroyListeners" : "");
+var ENABLE_ROOT_COMPONENT_BOOTSTRAP = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "ENABLE_ROOT_COMPONENT_BOOTSTRAP" : "");
+function isApplicationBootstrapConfig(config2) {
+  return !config2.moduleRef;
+}
+function bootstrap(config2) {
+  const envInjector = isApplicationBootstrapConfig(config2) ? config2.r3Injector : config2.moduleRef.injector;
+  const ngZone = envInjector.get(NgZone);
+  return ngZone.run(() => {
+    if (isApplicationBootstrapConfig(config2)) {
+      config2.r3Injector.resolveInjectorInitializers();
+    } else {
+      config2.moduleRef.resolveInjectorInitializers();
+    }
+    const exceptionHandler = envInjector.get(INTERNAL_APPLICATION_ERROR_HANDLER);
+    if (typeof ngDevMode === "undefined" || ngDevMode) {
+      if (envInjector.get(PROVIDED_ZONELESS) && envInjector.get(PROVIDED_NG_ZONE)) {
+        console.warn(formatRuntimeError(408, "Both provideZoneChangeDetection and provideZonelessChangeDetection are provided. This is likely a mistake. Update the application providers to use only one of the two."));
+      }
+    }
+    let onErrorSubscription;
+    ngZone.runOutsideAngular(() => {
+      onErrorSubscription = ngZone.onError.subscribe({
+        next: exceptionHandler
+      });
+    });
+    if (isApplicationBootstrapConfig(config2)) {
+      const destroyListener = () => envInjector.destroy();
+      const onPlatformDestroyListeners = config2.platformInjector.get(PLATFORM_DESTROY_LISTENERS);
+      onPlatformDestroyListeners.add(destroyListener);
+      envInjector.onDestroy(() => {
+        onErrorSubscription.unsubscribe();
+        onPlatformDestroyListeners.delete(destroyListener);
+      });
+    } else {
+      const destroyListener = () => config2.moduleRef.destroy();
+      const onPlatformDestroyListeners = config2.platformInjector.get(PLATFORM_DESTROY_LISTENERS);
+      onPlatformDestroyListeners.add(destroyListener);
+      config2.moduleRef.onDestroy(() => {
+        remove(config2.allPlatformModules, config2.moduleRef);
+        onErrorSubscription.unsubscribe();
+        onPlatformDestroyListeners.delete(destroyListener);
+      });
+    }
+    return _callAndReportToErrorHandler(exceptionHandler, ngZone, () => {
+      const pendingTasks = envInjector.get(PendingTasksInternal);
+      const taskId = pendingTasks.add();
+      const initStatus = envInjector.get(ApplicationInitStatus);
+      initStatus.runInitializers();
+      return initStatus.donePromise.then(() => {
+        const localeId = envInjector.get(LOCALE_ID, DEFAULT_LOCALE_ID);
+        setLocaleId(localeId || DEFAULT_LOCALE_ID);
+        const enableRootComponentbootstrap = envInjector.get(ENABLE_ROOT_COMPONENT_BOOTSTRAP, true);
+        if (!enableRootComponentbootstrap) {
+          if (isApplicationBootstrapConfig(config2)) {
+            return envInjector.get(ApplicationRef);
+          }
+          config2.allPlatformModules.push(config2.moduleRef);
+          return config2.moduleRef;
+        }
+        if (typeof ngDevMode === "undefined" || ngDevMode) {
+          const imagePerformanceService = envInjector.get(ImagePerformanceWarning);
+          imagePerformanceService.start();
+        }
+        if (isApplicationBootstrapConfig(config2)) {
+          const appRef = envInjector.get(ApplicationRef);
+          if (config2.rootComponent !== void 0) {
+            appRef.bootstrap(config2.rootComponent);
+          }
+          return appRef;
+        } else {
+          moduleBootstrapImpl?.(config2.moduleRef, config2.allPlatformModules);
+          return config2.moduleRef;
+        }
+      }).finally(() => void pendingTasks.remove(taskId));
+    });
+  });
+}
+var moduleBootstrapImpl;
+function setModuleBootstrapImpl() {
+  moduleBootstrapImpl = _moduleDoBootstrap;
+}
+function _moduleDoBootstrap(moduleRef, allPlatformModules) {
+  const appRef = moduleRef.injector.get(ApplicationRef);
+  if (moduleRef._bootstrapComponents.length > 0) {
+    moduleRef._bootstrapComponents.forEach((f) => appRef.bootstrap(f));
+  } else if (moduleRef.instance.ngDoBootstrap) {
+    moduleRef.instance.ngDoBootstrap(appRef);
+  } else {
+    throw new RuntimeError(-403, ngDevMode && `The module ${stringify(moduleRef.instance.constructor)} was bootstrapped, but it does not declare "@NgModule.bootstrap" components nor a "ngDoBootstrap" method. Please define one of these.`);
+  }
+  allPlatformModules.push(moduleRef);
+}
+function _callAndReportToErrorHandler(errorHandler2, ngZone, callback) {
+  try {
+    const result = callback();
+    if (isPromise2(result)) {
+      return result.catch((e) => {
+        ngZone.runOutsideAngular(() => errorHandler2(e));
+        throw e;
+      });
+    }
+    return result;
+  } catch (e) {
+    ngZone.runOutsideAngular(() => errorHandler2(e));
+    throw e;
+  }
+}
+var PlatformRef = class _PlatformRef {
+  _injector;
+  _modules = [];
+  _destroyListeners = [];
+  _destroyed = false;
+  constructor(_injector) {
+    this._injector = _injector;
+  }
+  bootstrapModuleFactory(moduleFactory, options) {
+    const allAppProviders = [provideZonelessChangeDetectionInternal(), ...options?.applicationProviders ?? [], errorHandlerEnvironmentInitializer, ...ngDevMode ? [validAppIdInitializer] : []];
+    const moduleRef = createNgModuleRefWithProviders(moduleFactory.moduleType, this.injector, allAppProviders);
+    setModuleBootstrapImpl();
+    return bootstrap({
+      moduleRef,
+      allPlatformModules: this._modules,
+      platformInjector: this.injector
+    });
+  }
+  bootstrapModule(moduleType, compilerOptions = []) {
+    const options = optionsReducer({}, compilerOptions);
+    setModuleBootstrapImpl();
+    return compileNgModuleFactory(this.injector, options, moduleType).then((moduleFactory) => this.bootstrapModuleFactory(moduleFactory, options));
+  }
+  onDestroy(callback) {
+    this._destroyListeners.push(callback);
+  }
+  get injector() {
+    return this._injector;
+  }
+  destroy() {
+    if (this._destroyed) {
+      throw new RuntimeError(404, ngDevMode && "The platform has already been destroyed!");
+    }
+    this._modules.slice().forEach((module) => module.destroy());
+    this._destroyListeners.forEach((listener) => listener());
+    const destroyListeners = this._injector.get(PLATFORM_DESTROY_LISTENERS, null);
+    if (destroyListeners) {
+      destroyListeners.forEach((listener) => listener());
+      destroyListeners.clear();
+    }
+    this._destroyed = true;
+  }
+  get destroyed() {
+    return this._destroyed;
+  }
+  static \u0275fac = function PlatformRef_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _PlatformRef)(\u0275\u0275inject(Injector));
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _PlatformRef,
+    factory: _PlatformRef.\u0275fac,
+    providedIn: "platform"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(PlatformRef, [{
+    type: Injectable,
+    args: [{
+      providedIn: "platform"
+    }]
+  }], () => [{
+    type: Injector
+  }], null);
+})();
+var _platformInjector = null;
+function createPlatform(injector) {
+  if (getPlatform()) {
+    throw new RuntimeError(400, ngDevMode && "There can be only one platform. Destroy the previous one to create a new one.");
+  }
+  publishDefaultGlobalUtils();
+  publishSignalConfiguration();
+  _platformInjector = true ? injector : null;
+  const platform = injector.get(PlatformRef);
+  runPlatformInitializers(injector);
+  return platform;
+}
+function createPlatformFactory(parentPlatformFactory, name, providers = []) {
+  const desc = `Platform: ${name}`;
+  const marker = new InjectionToken(desc);
+  return (extraProviders = []) => {
+    let platform = getPlatform();
+    if (!platform) {
+      const platformProviders = [...providers, ...extraProviders, {
+        provide: marker,
+        useValue: true
+      }];
+      platform = parentPlatformFactory?.(platformProviders) ?? createPlatform(createPlatformInjector(platformProviders, desc));
+    }
+    return false ? platform : assertPlatform(marker);
+  };
+}
+function createPlatformInjector(providers = [], name) {
+  return Injector.create({
+    name,
+    providers: [{
+      provide: INJECTOR_SCOPE,
+      useValue: "platform"
+    }, {
+      provide: PLATFORM_DESTROY_LISTENERS,
+      useValue: /* @__PURE__ */ new Set([() => _platformInjector = null])
+    }, ...providers]
+  });
+}
+function assertPlatform(requiredToken) {
+  const platform = getPlatform();
+  if (!platform) {
+    throw new RuntimeError(-401, ngDevMode && "No platform exists!");
+  }
+  if ((typeof ngDevMode === "undefined" || ngDevMode) && !platform.injector.get(requiredToken, null)) {
+    throw new RuntimeError(400, "A platform with a different configuration has been created. Please destroy it first.");
+  }
+  return platform;
+}
+function getPlatform() {
+  if (false) {
+    return null;
+  }
+  return _platformInjector?.get(PlatformRef) ?? null;
+}
+function createOrReusePlatformInjector(providers = []) {
+  if (_platformInjector) return _platformInjector;
+  publishDefaultGlobalUtils();
+  const injector = createPlatformInjector(providers);
+  if (true) {
+    _platformInjector = injector;
+  }
+  publishSignalConfiguration();
+  runPlatformInitializers(injector);
+  return injector;
+}
+function runPlatformInitializers(injector) {
+  const inits = injector.get(PLATFORM_INITIALIZER, null);
+  runInInjectionContext(injector, () => {
+    inits?.forEach((init) => init());
+  });
+}
+var APPLICATION_IS_STABLE_TIMEOUT = 1e4;
+var STABILITY_WARNING_THRESHOLD = APPLICATION_IS_STABLE_TIMEOUT - 1e3;
+var ChangeDetectorRef = class {
+  static __NG_ELEMENT_ID__ = injectChangeDetectorRef;
+};
+function injectChangeDetectorRef(flags) {
+  return createViewRef(getCurrentTNode(), getLView(), (flags & 16) === 16);
+}
+function createViewRef(tNode, lView, isPipe2) {
+  if (isComponentHost(tNode) && !isPipe2) {
+    const componentView = getComponentLViewByIndex(tNode.index, lView);
+    return new ViewRef(componentView, componentView);
+  } else if (tNode.type & (3 | 12 | 32 | 128)) {
+    const hostComponentView = lView[DECLARATION_COMPONENT_VIEW];
+    return new ViewRef(hostComponentView, lView);
+  }
+  return null;
+}
+var DefaultIterableDifferFactory = class {
+  supports(obj) {
+    return isListLikeIterable(obj);
+  }
+  create(trackByFn) {
+    return new DefaultIterableDiffer(trackByFn);
+  }
+};
+var trackByIdentity = (index, item) => item;
+var DefaultIterableDiffer = class {
+  length = 0;
+  collection;
+  _linkedRecords = null;
+  _unlinkedRecords = null;
+  _previousItHead = null;
+  _itHead = null;
+  _itTail = null;
+  _additionsHead = null;
+  _additionsTail = null;
+  _movesHead = null;
+  _movesTail = null;
+  _removalsHead = null;
+  _removalsTail = null;
+  _identityChangesHead = null;
+  _identityChangesTail = null;
+  _trackByFn;
+  constructor(trackByFn) {
+    this._trackByFn = trackByFn || trackByIdentity;
+  }
+  forEachItem(fn) {
+    let record;
+    for (record = this._itHead; record !== null; record = record._next) {
+      fn(record);
+    }
+  }
+  forEachOperation(fn) {
+    let nextIt = this._itHead;
+    let nextRemove = this._removalsHead;
+    let addRemoveOffset = 0;
+    let moveOffsets = null;
+    while (nextIt || nextRemove) {
+      const record = !nextRemove || nextIt && nextIt.currentIndex < getPreviousIndex(nextRemove, addRemoveOffset, moveOffsets) ? nextIt : nextRemove;
+      const adjPreviousIndex = getPreviousIndex(record, addRemoveOffset, moveOffsets);
+      const currentIndex = record.currentIndex;
+      if (record === nextRemove) {
+        addRemoveOffset--;
+        nextRemove = nextRemove._nextRemoved;
+      } else {
+        nextIt = nextIt._next;
+        if (record.previousIndex == null) {
+          addRemoveOffset++;
+        } else {
+          if (!moveOffsets) moveOffsets = [];
+          const localMovePreviousIndex = adjPreviousIndex - addRemoveOffset;
+          const localCurrentIndex = currentIndex - addRemoveOffset;
+          if (localMovePreviousIndex != localCurrentIndex) {
+            for (let i = 0; i < localMovePreviousIndex; i++) {
+              const offset = i < moveOffsets.length ? moveOffsets[i] : moveOffsets[i] = 0;
+              const index = offset + i;
+              if (localCurrentIndex <= index && index < localMovePreviousIndex) {
+                moveOffsets[i] = offset + 1;
+              }
+            }
+            const previousIndex = record.previousIndex;
+            moveOffsets[previousIndex] = localCurrentIndex - localMovePreviousIndex;
+          }
+        }
+      }
+      if (adjPreviousIndex !== currentIndex) {
+        fn(record, adjPreviousIndex, currentIndex);
+      }
+    }
+  }
+  forEachPreviousItem(fn) {
+    let record;
+    for (record = this._previousItHead; record !== null; record = record._nextPrevious) {
+      fn(record);
+    }
+  }
+  forEachAddedItem(fn) {
+    let record;
+    for (record = this._additionsHead; record !== null; record = record._nextAdded) {
+      fn(record);
+    }
+  }
+  forEachMovedItem(fn) {
+    let record;
+    for (record = this._movesHead; record !== null; record = record._nextMoved) {
+      fn(record);
+    }
+  }
+  forEachRemovedItem(fn) {
+    let record;
+    for (record = this._removalsHead; record !== null; record = record._nextRemoved) {
+      fn(record);
+    }
+  }
+  forEachIdentityChange(fn) {
+    let record;
+    for (record = this._identityChangesHead; record !== null; record = record._nextIdentityChange) {
+      fn(record);
+    }
+  }
+  diff(collection) {
+    if (collection == null) collection = [];
+    if (!isListLikeIterable(collection)) {
+      throw new RuntimeError(900, ngDevMode && `Error trying to diff '${stringify(collection)}'. Only arrays and iterables are allowed`);
+    }
+    if (this.check(collection)) {
+      return this;
+    } else {
+      return null;
+    }
+  }
+  onDestroy() {
+  }
+  check(collection) {
+    this._reset();
+    let record = this._itHead;
+    let mayBeDirty = false;
+    let index;
+    let item;
+    let itemTrackBy;
+    if (Array.isArray(collection)) {
+      this.length = collection.length;
+      for (let index2 = 0; index2 < this.length; index2++) {
+        item = collection[index2];
+        itemTrackBy = this._trackByFn(index2, item);
+        if (record === null || !Object.is(record.trackById, itemTrackBy)) {
+          record = this._mismatch(record, item, itemTrackBy, index2);
+          mayBeDirty = true;
+        } else {
+          if (mayBeDirty) {
+            record = this._verifyReinsertion(record, item, itemTrackBy, index2);
+          }
+          if (!Object.is(record.item, item)) this._addIdentityChange(record, item);
+        }
+        record = record._next;
+      }
+    } else {
+      index = 0;
+      iterateListLike(collection, (item2) => {
+        itemTrackBy = this._trackByFn(index, item2);
+        if (record === null || !Object.is(record.trackById, itemTrackBy)) {
+          record = this._mismatch(record, item2, itemTrackBy, index);
+          mayBeDirty = true;
+        } else {
+          if (mayBeDirty) {
+            record = this._verifyReinsertion(record, item2, itemTrackBy, index);
+          }
+          if (!Object.is(record.item, item2)) this._addIdentityChange(record, item2);
+        }
+        record = record._next;
+        index++;
+      });
+      this.length = index;
+    }
+    this._truncate(record);
+    this.collection = collection;
+    return this.isDirty;
+  }
+  get isDirty() {
+    return this._additionsHead !== null || this._movesHead !== null || this._removalsHead !== null || this._identityChangesHead !== null;
+  }
+  _reset() {
+    if (this.isDirty) {
+      let record;
+      for (record = this._previousItHead = this._itHead; record !== null; record = record._next) {
+        record._nextPrevious = record._next;
+      }
+      for (record = this._additionsHead; record !== null; record = record._nextAdded) {
+        record.previousIndex = record.currentIndex;
+      }
+      this._additionsHead = this._additionsTail = null;
+      for (record = this._movesHead; record !== null; record = record._nextMoved) {
+        record.previousIndex = record.currentIndex;
+      }
+      this._movesHead = this._movesTail = null;
+      this._removalsHead = this._removalsTail = null;
+      this._identityChangesHead = this._identityChangesTail = null;
+    }
+  }
+  _mismatch(record, item, itemTrackBy, index) {
+    let previousRecord;
+    if (record === null) {
+      previousRecord = this._itTail;
+    } else {
+      previousRecord = record._prev;
+      this._remove(record);
+    }
+    record = this._unlinkedRecords === null ? null : this._unlinkedRecords.get(itemTrackBy, null);
+    if (record !== null) {
+      if (!Object.is(record.item, item)) this._addIdentityChange(record, item);
+      this._reinsertAfter(record, previousRecord, index);
+    } else {
+      record = this._linkedRecords === null ? null : this._linkedRecords.get(itemTrackBy, index);
+      if (record !== null) {
+        if (!Object.is(record.item, item)) this._addIdentityChange(record, item);
+        this._moveAfter(record, previousRecord, index);
+      } else {
+        record = this._addAfter(new IterableChangeRecord_(item, itemTrackBy), previousRecord, index);
+      }
+    }
+    return record;
+  }
+  _verifyReinsertion(record, item, itemTrackBy, index) {
+    let reinsertRecord = this._unlinkedRecords === null ? null : this._unlinkedRecords.get(itemTrackBy, null);
+    if (reinsertRecord !== null) {
+      record = this._reinsertAfter(reinsertRecord, record._prev, index);
+    } else if (record.currentIndex != index) {
+      record.currentIndex = index;
+      this._addToMoves(record, index);
+    }
+    return record;
+  }
+  _truncate(record) {
+    while (record !== null) {
+      const nextRecord = record._next;
+      this._addToRemovals(this._unlink(record));
+      record = nextRecord;
+    }
+    if (this._unlinkedRecords !== null) {
+      this._unlinkedRecords.clear();
+    }
+    if (this._additionsTail !== null) {
+      this._additionsTail._nextAdded = null;
+    }
+    if (this._movesTail !== null) {
+      this._movesTail._nextMoved = null;
+    }
+    if (this._itTail !== null) {
+      this._itTail._next = null;
+    }
+    if (this._removalsTail !== null) {
+      this._removalsTail._nextRemoved = null;
+    }
+    if (this._identityChangesTail !== null) {
+      this._identityChangesTail._nextIdentityChange = null;
+    }
+  }
+  _reinsertAfter(record, prevRecord, index) {
+    if (this._unlinkedRecords !== null) {
+      this._unlinkedRecords.remove(record);
+    }
+    const prev = record._prevRemoved;
+    const next = record._nextRemoved;
+    if (prev === null) {
+      this._removalsHead = next;
+    } else {
+      prev._nextRemoved = next;
+    }
+    if (next === null) {
+      this._removalsTail = prev;
+    } else {
+      next._prevRemoved = prev;
+    }
+    this._insertAfter(record, prevRecord, index);
+    this._addToMoves(record, index);
+    return record;
+  }
+  _moveAfter(record, prevRecord, index) {
+    this._unlink(record);
+    this._insertAfter(record, prevRecord, index);
+    this._addToMoves(record, index);
+    return record;
+  }
+  _addAfter(record, prevRecord, index) {
+    this._insertAfter(record, prevRecord, index);
+    if (this._additionsTail === null) {
+      this._additionsTail = this._additionsHead = record;
+    } else {
+      this._additionsTail = this._additionsTail._nextAdded = record;
+    }
+    return record;
+  }
+  _insertAfter(record, prevRecord, index) {
+    const next = prevRecord === null ? this._itHead : prevRecord._next;
+    record._next = next;
+    record._prev = prevRecord;
+    if (next === null) {
+      this._itTail = record;
+    } else {
+      next._prev = record;
+    }
+    if (prevRecord === null) {
+      this._itHead = record;
+    } else {
+      prevRecord._next = record;
+    }
+    if (this._linkedRecords === null) {
+      this._linkedRecords = new _DuplicateMap();
+    }
+    this._linkedRecords.put(record);
+    record.currentIndex = index;
+    return record;
+  }
+  _remove(record) {
+    return this._addToRemovals(this._unlink(record));
+  }
+  _unlink(record) {
+    if (this._linkedRecords !== null) {
+      this._linkedRecords.remove(record);
+    }
+    const prev = record._prev;
+    const next = record._next;
+    if (prev === null) {
+      this._itHead = next;
+    } else {
+      prev._next = next;
+    }
+    if (next === null) {
+      this._itTail = prev;
+    } else {
+      next._prev = prev;
+    }
+    return record;
+  }
+  _addToMoves(record, toIndex) {
+    if (record.previousIndex === toIndex) {
+      return record;
+    }
+    if (this._movesTail === null) {
+      this._movesTail = this._movesHead = record;
+    } else {
+      this._movesTail = this._movesTail._nextMoved = record;
+    }
+    return record;
+  }
+  _addToRemovals(record) {
+    if (this._unlinkedRecords === null) {
+      this._unlinkedRecords = new _DuplicateMap();
+    }
+    this._unlinkedRecords.put(record);
+    record.currentIndex = null;
+    record._nextRemoved = null;
+    if (this._removalsTail === null) {
+      this._removalsTail = this._removalsHead = record;
+      record._prevRemoved = null;
+    } else {
+      record._prevRemoved = this._removalsTail;
+      this._removalsTail = this._removalsTail._nextRemoved = record;
+    }
+    return record;
+  }
+  _addIdentityChange(record, item) {
+    record.item = item;
+    if (this._identityChangesTail === null) {
+      this._identityChangesTail = this._identityChangesHead = record;
+    } else {
+      this._identityChangesTail = this._identityChangesTail._nextIdentityChange = record;
+    }
+    return record;
+  }
+};
+var IterableChangeRecord_ = class {
+  item;
+  trackById;
+  currentIndex = null;
+  previousIndex = null;
+  _nextPrevious = null;
+  _prev = null;
+  _next = null;
+  _prevDup = null;
+  _nextDup = null;
+  _prevRemoved = null;
+  _nextRemoved = null;
+  _nextAdded = null;
+  _nextMoved = null;
+  _nextIdentityChange = null;
+  constructor(item, trackById) {
+    this.item = item;
+    this.trackById = trackById;
+  }
+};
+var _DuplicateItemRecordList = class {
+  _head = null;
+  _tail = null;
+  add(record) {
+    if (this._head === null) {
+      this._head = this._tail = record;
+      record._nextDup = null;
+      record._prevDup = null;
+    } else {
+      this._tail._nextDup = record;
+      record._prevDup = this._tail;
+      record._nextDup = null;
+      this._tail = record;
+    }
+  }
+  get(trackById, atOrAfterIndex) {
+    let record;
+    for (record = this._head; record !== null; record = record._nextDup) {
+      if ((atOrAfterIndex === null || atOrAfterIndex <= record.currentIndex) && Object.is(record.trackById, trackById)) {
+        return record;
+      }
+    }
+    return null;
+  }
+  remove(record) {
+    const prev = record._prevDup;
+    const next = record._nextDup;
+    if (prev === null) {
+      this._head = next;
+    } else {
+      prev._nextDup = next;
+    }
+    if (next === null) {
+      this._tail = prev;
+    } else {
+      next._prevDup = prev;
+    }
+    return this._head === null;
+  }
+};
+var _DuplicateMap = class {
+  map = /* @__PURE__ */ new Map();
+  put(record) {
+    const key = record.trackById;
+    let duplicates = this.map.get(key);
+    if (!duplicates) {
+      duplicates = new _DuplicateItemRecordList();
+      this.map.set(key, duplicates);
+    }
+    duplicates.add(record);
+  }
+  get(trackById, atOrAfterIndex) {
+    const key = trackById;
+    const recordList = this.map.get(key);
+    return recordList ? recordList.get(trackById, atOrAfterIndex) : null;
+  }
+  remove(record) {
+    const key = record.trackById;
+    const recordList = this.map.get(key);
+    if (recordList.remove(record)) {
+      this.map.delete(key);
+    }
+    return record;
+  }
+  get isEmpty() {
+    return this.map.size === 0;
+  }
+  clear() {
+    this.map.clear();
+  }
+};
+function getPreviousIndex(item, addRemoveOffset, moveOffsets) {
+  const previousIndex = item.previousIndex;
+  if (previousIndex === null) return previousIndex;
+  let moveOffset = 0;
+  if (moveOffsets && previousIndex < moveOffsets.length) {
+    moveOffset = moveOffsets[previousIndex];
+  }
+  return previousIndex + addRemoveOffset + moveOffset;
+}
+var DefaultKeyValueDifferFactory = class {
+  supports(obj) {
+    return obj instanceof Map || isJsObject(obj);
+  }
+  create() {
+    return new DefaultKeyValueDiffer();
+  }
+};
+var DefaultKeyValueDiffer = class {
+  _records = /* @__PURE__ */ new Map();
+  _mapHead = null;
+  _appendAfter = null;
+  _previousMapHead = null;
+  _changesHead = null;
+  _changesTail = null;
+  _additionsHead = null;
+  _additionsTail = null;
+  _removalsHead = null;
+  get isDirty() {
+    return this._additionsHead !== null || this._changesHead !== null || this._removalsHead !== null;
+  }
+  forEachItem(fn) {
+    let record;
+    for (record = this._mapHead; record !== null; record = record._next) {
+      fn(record);
+    }
+  }
+  forEachPreviousItem(fn) {
+    let record;
+    for (record = this._previousMapHead; record !== null; record = record._nextPrevious) {
+      fn(record);
+    }
+  }
+  forEachChangedItem(fn) {
+    let record;
+    for (record = this._changesHead; record !== null; record = record._nextChanged) {
+      fn(record);
+    }
+  }
+  forEachAddedItem(fn) {
+    let record;
+    for (record = this._additionsHead; record !== null; record = record._nextAdded) {
+      fn(record);
+    }
+  }
+  forEachRemovedItem(fn) {
+    let record;
+    for (record = this._removalsHead; record !== null; record = record._nextRemoved) {
+      fn(record);
+    }
+  }
+  diff(map2) {
+    if (!map2) {
+      map2 = /* @__PURE__ */ new Map();
+    } else if (!(map2 instanceof Map || isJsObject(map2))) {
+      throw new RuntimeError(900, ngDevMode && `Error trying to diff '${stringify(map2)}'. Only maps and objects are allowed`);
+    }
+    return this.check(map2) ? this : null;
+  }
+  check(map2) {
+    this._reset();
+    let insertBefore = this._mapHead;
+    this._appendAfter = null;
+    this._forEach(map2, (value, key) => {
+      if (insertBefore && insertBefore.key === key) {
+        this._maybeAddToChanges(insertBefore, value);
+        this._appendAfter = insertBefore;
+        insertBefore = insertBefore._next;
+      } else {
+        const record = this._getOrCreateRecordForKey(key, value);
+        insertBefore = this._insertBeforeOrAppend(insertBefore, record);
+      }
+    });
+    if (insertBefore) {
+      if (insertBefore._prev) {
+        insertBefore._prev._next = null;
+      }
+      this._removalsHead = insertBefore;
+      for (let record = insertBefore; record !== null; record = record._nextRemoved) {
+        if (record === this._mapHead) {
+          this._mapHead = null;
+        }
+        this._records.delete(record.key);
+        record._nextRemoved = record._next;
+        record.previousValue = record.currentValue;
+        record.currentValue = null;
+        record._prev = null;
+        record._next = null;
+      }
+    }
+    if (this._changesTail) this._changesTail._nextChanged = null;
+    if (this._additionsTail) this._additionsTail._nextAdded = null;
+    return this.isDirty;
+  }
+  _insertBeforeOrAppend(before, record) {
+    if (before) {
+      const prev = before._prev;
+      record._next = before;
+      record._prev = prev;
+      before._prev = record;
+      if (prev) {
+        prev._next = record;
+      }
+      if (before === this._mapHead) {
+        this._mapHead = record;
+      }
+      this._appendAfter = before;
+      return before;
+    }
+    if (this._appendAfter) {
+      this._appendAfter._next = record;
+      record._prev = this._appendAfter;
+    } else {
+      this._mapHead = record;
+    }
+    this._appendAfter = record;
+    return null;
+  }
+  _getOrCreateRecordForKey(key, value) {
+    if (this._records.has(key)) {
+      const record2 = this._records.get(key);
+      this._maybeAddToChanges(record2, value);
+      const prev = record2._prev;
+      const next = record2._next;
+      if (prev) {
+        prev._next = next;
+      }
+      if (next) {
+        next._prev = prev;
+      }
+      record2._next = null;
+      record2._prev = null;
+      return record2;
+    }
+    const record = new KeyValueChangeRecord_(key);
+    this._records.set(key, record);
+    record.currentValue = value;
+    this._addToAdditions(record);
+    return record;
+  }
+  _reset() {
+    if (this.isDirty) {
+      let record;
+      this._previousMapHead = this._mapHead;
+      for (record = this._previousMapHead; record !== null; record = record._next) {
+        record._nextPrevious = record._next;
+      }
+      for (record = this._changesHead; record !== null; record = record._nextChanged) {
+        record.previousValue = record.currentValue;
+      }
+      for (record = this._additionsHead; record != null; record = record._nextAdded) {
+        record.previousValue = record.currentValue;
+      }
+      this._changesHead = this._changesTail = null;
+      this._additionsHead = this._additionsTail = null;
+      this._removalsHead = null;
+    }
+  }
+  _maybeAddToChanges(record, newValue) {
+    if (!Object.is(newValue, record.currentValue)) {
+      record.previousValue = record.currentValue;
+      record.currentValue = newValue;
+      this._addToChanges(record);
+    }
+  }
+  _addToAdditions(record) {
+    if (this._additionsHead === null) {
+      this._additionsHead = this._additionsTail = record;
+    } else {
+      this._additionsTail._nextAdded = record;
+      this._additionsTail = record;
+    }
+  }
+  _addToChanges(record) {
+    if (this._changesHead === null) {
+      this._changesHead = this._changesTail = record;
+    } else {
+      this._changesTail._nextChanged = record;
+      this._changesTail = record;
+    }
+  }
+  _forEach(obj, fn) {
+    if (obj instanceof Map) {
+      obj.forEach(fn);
+    } else {
+      Object.keys(obj).forEach((k) => fn(obj[k], k));
+    }
+  }
+};
+var KeyValueChangeRecord_ = class {
+  key;
+  previousValue = null;
+  currentValue = null;
+  _nextPrevious = null;
+  _next = null;
+  _prev = null;
+  _nextAdded = null;
+  _nextRemoved = null;
+  _nextChanged = null;
+  constructor(key) {
+    this.key = key;
+  }
+};
+function defaultIterableDiffersFactory() {
+  return new IterableDiffers([new DefaultIterableDifferFactory()]);
+}
+var IterableDiffers = class _IterableDiffers {
+  factories;
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _IterableDiffers,
+    providedIn: "root",
+    factory: defaultIterableDiffersFactory
+  });
+  constructor(factories) {
+    this.factories = factories;
+  }
+  static create(factories, parent) {
+    if (parent != null) {
+      const copied = parent.factories.slice();
+      factories = factories.concat(copied);
+    }
+    return new _IterableDiffers(factories);
+  }
+  static extend(factories) {
+    return {
+      provide: _IterableDiffers,
+      useFactory: () => {
+        const parent = inject2(_IterableDiffers, {
+          optional: true,
+          skipSelf: true
+        });
+        return _IterableDiffers.create(factories, parent || defaultIterableDiffersFactory());
+      }
+    };
+  }
+  find(iterable) {
+    const factory = this.factories.find((f) => f.supports(iterable));
+    if (factory != null) {
+      return factory;
+    } else {
+      throw new RuntimeError(901, ngDevMode && `Cannot find a differ supporting object '${iterable}' of type '${getTypeNameForDebugging(iterable)}'`);
+    }
+  }
+};
+function getTypeNameForDebugging(type) {
+  return type["name"] || typeof type;
+}
+function defaultKeyValueDiffersFactory() {
+  return new KeyValueDiffers([new DefaultKeyValueDifferFactory()]);
+}
+var KeyValueDiffers = class _KeyValueDiffers {
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _KeyValueDiffers,
+    providedIn: "root",
+    factory: defaultKeyValueDiffersFactory
+  });
+  factories;
+  constructor(factories) {
+    this.factories = factories;
+  }
+  static create(factories, parent) {
+    if (parent) {
+      const copied = parent.factories.slice();
+      factories = factories.concat(copied);
+    }
+    return new _KeyValueDiffers(factories);
+  }
+  static extend(factories) {
+    return {
+      provide: _KeyValueDiffers,
+      useFactory: () => {
+        const parent = inject2(_KeyValueDiffers, {
+          optional: true,
+          skipSelf: true
+        });
+        return _KeyValueDiffers.create(factories, parent || defaultKeyValueDiffersFactory());
+      }
+    };
+  }
+  find(kv) {
+    const factory = this.factories.find((f) => f.supports(kv));
+    if (factory) {
+      return factory;
+    }
+    throw new RuntimeError(901, ngDevMode && `Cannot find a differ supporting object '${kv}'`);
+  }
+};
+var keyValDiff = [new DefaultKeyValueDifferFactory()];
+var iterableDiff = [new DefaultIterableDifferFactory()];
+var defaultIterableDiffers = new IterableDiffers(iterableDiff);
+var defaultKeyValueDiffers = new KeyValueDiffers(keyValDiff);
+var platformCore = createPlatformFactory(null, "core", []);
+var ApplicationModule = class _ApplicationModule {
+  constructor(appRef) {
+  }
+  static \u0275fac = function ApplicationModule_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _ApplicationModule)(\u0275\u0275inject(ApplicationRef));
+  };
+  static \u0275mod = /* @__PURE__ */ \u0275\u0275defineNgModule({
+    type: _ApplicationModule
+  });
+  static \u0275inj = /* @__PURE__ */ \u0275\u0275defineInjector({});
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ApplicationModule, [{
+    type: NgModule
+  }], () => [{
+    type: ApplicationRef
+  }], null);
+})();
+function internalCreateApplication(config2) {
+  const {
+    rootComponent,
+    appProviders,
+    platformProviders,
+    platformRef
+  } = config2;
+  profiler(ProfilerEvent.BootstrapApplicationStart);
+  if (false) {
+    throw new RuntimeError(-401, ngDevMode && "Missing Platform: This may be due to using `bootstrapApplication` on the server without passing a `BootstrapContext`. Please make sure that `bootstrapApplication` is called with a `context` argument.");
+  }
+  try {
+    const platformInjector = platformRef?.injector ?? createOrReusePlatformInjector(platformProviders);
+    if ((typeof ngDevMode === "undefined" || ngDevMode) && rootComponent !== void 0) {
+      assertStandaloneComponentType(rootComponent);
+    }
+    const allAppProviders = [provideZonelessChangeDetectionInternal(), errorHandlerEnvironmentInitializer, ...ngDevMode ? [validAppIdInitializer] : [], ...appProviders || []];
+    const adapter = new EnvironmentNgModuleRefAdapter({
+      providers: allAppProviders,
+      parent: platformInjector,
+      debugName: typeof ngDevMode === "undefined" || ngDevMode ? "Environment Injector" : "",
+      runEnvironmentInitializers: false
+    });
+    return bootstrap({
+      r3Injector: adapter.injector,
+      platformInjector,
+      rootComponent
+    });
+  } catch (e) {
+    return Promise.reject(e);
+  } finally {
+    profiler(ProfilerEvent.BootstrapApplicationEnd);
+  }
+}
+function booleanAttribute(value) {
+  return typeof value === "boolean" ? value : value != null && value !== "false";
+}
+function numberAttribute(value, fallbackValue = NaN) {
+  const isNumberValue = !isNaN(parseFloat(value)) && !isNaN(Number(value));
+  return isNumberValue ? Number(value) : fallbackValue;
+}
+function reflectComponentType(component) {
+  const componentDef = getComponentDef(component);
+  if (!componentDef) return null;
+  const factory = new ComponentFactory2(componentDef);
+  return {
+    get selector() {
+      return factory.selector;
+    },
+    get type() {
+      return factory.componentType;
+    },
+    get inputs() {
+      return factory.inputs;
+    },
+    get outputs() {
+      return factory.outputs;
+    },
+    get ngContentSelectors() {
+      return factory.ngContentSelectors;
+    },
+    get isStandalone() {
+      return componentDef.standalone;
+    },
+    get isSignal() {
+      return componentDef.signals;
+    }
+  };
+}
+var REQUEST = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "REQUEST" : "", {
+  providedIn: "platform",
+  factory: () => null
+});
+var RESPONSE_INIT = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "RESPONSE_INIT" : "", {
+  providedIn: "platform",
+  factory: () => null
+});
+var REQUEST_CONTEXT = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "REQUEST_CONTEXT" : "", {
+  providedIn: "platform",
+  factory: () => null
+});
+
+// node_modules/@angular/common/fesm2022/_platform_location-chunk.mjs
+/**
+ * @license Angular v21.2.17
+ * (c) 2010-2026 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+var _DOM = null;
+function getDOM() {
+  return _DOM;
+}
+function setRootDomAdapter(adapter) {
+  _DOM ??= adapter;
+}
+var DomAdapter = class {
+};
+var PlatformLocation = class _PlatformLocation {
+  historyGo(relativePosition) {
+    throw new Error(ngDevMode ? "Not implemented" : "");
+  }
+  static \u0275fac = function PlatformLocation_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _PlatformLocation)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _PlatformLocation,
+    factory: () => (() => inject2(BrowserPlatformLocation))(),
+    providedIn: "platform"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(PlatformLocation, [{
+    type: Injectable,
+    args: [{
+      providedIn: "platform",
+      useFactory: () => inject2(BrowserPlatformLocation)
+    }]
+  }], null, null);
+})();
+var LOCATION_INITIALIZED = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "Location Initialized" : "");
+var BrowserPlatformLocation = class _BrowserPlatformLocation extends PlatformLocation {
+  _location;
+  _history;
+  _doc = inject2(DOCUMENT);
+  constructor() {
+    super();
+    this._location = window.location;
+    this._history = window.history;
+  }
+  getBaseHrefFromDOM() {
+    return getDOM().getBaseHref(this._doc);
+  }
+  onPopState(fn) {
+    const window2 = getDOM().getGlobalEventTarget(this._doc, "window");
+    window2.addEventListener("popstate", fn, false);
+    return () => window2.removeEventListener("popstate", fn);
+  }
+  onHashChange(fn) {
+    const window2 = getDOM().getGlobalEventTarget(this._doc, "window");
+    window2.addEventListener("hashchange", fn, false);
+    return () => window2.removeEventListener("hashchange", fn);
+  }
+  get href() {
+    return this._location.href;
+  }
+  get protocol() {
+    return this._location.protocol;
+  }
+  get hostname() {
+    return this._location.hostname;
+  }
+  get port() {
+    return this._location.port;
+  }
+  get pathname() {
+    return this._location.pathname;
+  }
+  get search() {
+    return this._location.search;
+  }
+  get hash() {
+    return this._location.hash;
+  }
+  set pathname(newPath) {
+    this._location.pathname = newPath;
+  }
+  pushState(state, title, url) {
+    this._history.pushState(state, title, url);
+  }
+  replaceState(state, title, url) {
+    this._history.replaceState(state, title, url);
+  }
+  forward() {
+    this._history.forward();
+  }
+  back() {
+    this._history.back();
+  }
+  historyGo(relativePosition = 0) {
+    this._history.go(relativePosition);
+  }
+  getState() {
+    return this._history.state;
+  }
+  static \u0275fac = function BrowserPlatformLocation_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _BrowserPlatformLocation)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _BrowserPlatformLocation,
+    factory: () => (() => new _BrowserPlatformLocation())(),
+    providedIn: "platform"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(BrowserPlatformLocation, [{
+    type: Injectable,
+    args: [{
+      providedIn: "platform",
+      useFactory: () => new BrowserPlatformLocation()
+    }]
+  }], () => [], null);
+})();
+
+// node_modules/@angular/common/fesm2022/_location-chunk.mjs
+/**
+ * @license Angular v21.2.17
+ * (c) 2010-2026 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+function joinWithSlash(start, end) {
+  if (!start) return end;
+  if (!end) return start;
+  if (start.endsWith("/")) {
+    return end.startsWith("/") ? start + end.slice(1) : start + end;
+  }
+  return end.startsWith("/") ? start + end : `${start}/${end}`;
+}
+function stripTrailingSlash(url) {
+  const pathEndIdx = url.search(/#|\?|$/);
+  return url[pathEndIdx - 1] === "/" ? url.slice(0, pathEndIdx - 1) + url.slice(pathEndIdx) : url;
+}
+function normalizeQueryParams(params) {
+  return params && params[0] !== "?" ? `?${params}` : params;
+}
+var LocationStrategy = class _LocationStrategy {
+  historyGo(relativePosition) {
+    throw new Error(ngDevMode ? "Not implemented" : "");
+  }
+  static \u0275fac = function LocationStrategy_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _LocationStrategy)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _LocationStrategy,
+    factory: () => (() => inject2(PathLocationStrategy))(),
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(LocationStrategy, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root",
+      useFactory: () => inject2(PathLocationStrategy)
+    }]
+  }], null, null);
+})();
+var APP_BASE_HREF = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "appBaseHref" : "");
+var PathLocationStrategy = class _PathLocationStrategy extends LocationStrategy {
+  _platformLocation;
+  _baseHref;
+  _removeListenerFns = [];
+  constructor(_platformLocation, href) {
+    super();
+    this._platformLocation = _platformLocation;
+    this._baseHref = href ?? this._platformLocation.getBaseHrefFromDOM() ?? inject2(DOCUMENT).location?.origin ?? "";
+  }
+  ngOnDestroy() {
+    while (this._removeListenerFns.length) {
+      this._removeListenerFns.pop()();
+    }
+  }
+  onPopState(fn) {
+    this._removeListenerFns.push(this._platformLocation.onPopState(fn), this._platformLocation.onHashChange(fn));
+  }
+  getBaseHref() {
+    return this._baseHref;
+  }
+  prepareExternalUrl(internal) {
+    return joinWithSlash(this._baseHref, internal);
+  }
+  path(includeHash = false) {
+    const pathname = this._platformLocation.pathname + normalizeQueryParams(this._platformLocation.search);
+    const hash = this._platformLocation.hash;
+    return hash && includeHash ? `${pathname}${hash}` : pathname;
+  }
+  pushState(state, title, url, queryParams) {
+    const externalUrl = this.prepareExternalUrl(url + normalizeQueryParams(queryParams));
+    this._platformLocation.pushState(state, title, externalUrl);
+  }
+  replaceState(state, title, url, queryParams) {
+    const externalUrl = this.prepareExternalUrl(url + normalizeQueryParams(queryParams));
+    this._platformLocation.replaceState(state, title, externalUrl);
+  }
+  forward() {
+    this._platformLocation.forward();
+  }
+  back() {
+    this._platformLocation.back();
+  }
+  getState() {
+    return this._platformLocation.getState();
+  }
+  historyGo(relativePosition = 0) {
+    this._platformLocation.historyGo?.(relativePosition);
+  }
+  static \u0275fac = function PathLocationStrategy_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _PathLocationStrategy)(\u0275\u0275inject(PlatformLocation), \u0275\u0275inject(APP_BASE_HREF, 8));
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _PathLocationStrategy,
+    factory: _PathLocationStrategy.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(PathLocationStrategy, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], () => [{
+    type: PlatformLocation
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Inject,
+      args: [APP_BASE_HREF]
+    }]
+  }], null);
+})();
+var NoTrailingSlashPathLocationStrategy = class _NoTrailingSlashPathLocationStrategy extends PathLocationStrategy {
+  prepareExternalUrl(internal) {
+    const path = extractUrlPath(internal);
+    if (path.endsWith("/") && path.length > 1) {
+      internal = path.slice(0, -1) + internal.slice(path.length);
+    }
+    return super.prepareExternalUrl(internal);
+  }
+  static \u0275fac = /* @__PURE__ */ (() => {
+    let \u0275NoTrailingSlashPathLocationStrategy_BaseFactory;
+    return function NoTrailingSlashPathLocationStrategy_Factory(__ngFactoryType__) {
+      return (\u0275NoTrailingSlashPathLocationStrategy_BaseFactory || (\u0275NoTrailingSlashPathLocationStrategy_BaseFactory = \u0275\u0275getInheritedFactory(_NoTrailingSlashPathLocationStrategy)))(__ngFactoryType__ || _NoTrailingSlashPathLocationStrategy);
+    };
+  })();
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _NoTrailingSlashPathLocationStrategy,
+    factory: _NoTrailingSlashPathLocationStrategy.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NoTrailingSlashPathLocationStrategy, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], null, null);
+})();
+var TrailingSlashPathLocationStrategy = class _TrailingSlashPathLocationStrategy extends PathLocationStrategy {
+  prepareExternalUrl(internal) {
+    const path = extractUrlPath(internal);
+    if (!path.endsWith("/")) {
+      internal = path + "/" + internal.slice(path.length);
+    }
+    return super.prepareExternalUrl(internal);
+  }
+  static \u0275fac = /* @__PURE__ */ (() => {
+    let \u0275TrailingSlashPathLocationStrategy_BaseFactory;
+    return function TrailingSlashPathLocationStrategy_Factory(__ngFactoryType__) {
+      return (\u0275TrailingSlashPathLocationStrategy_BaseFactory || (\u0275TrailingSlashPathLocationStrategy_BaseFactory = \u0275\u0275getInheritedFactory(_TrailingSlashPathLocationStrategy)))(__ngFactoryType__ || _TrailingSlashPathLocationStrategy);
+    };
+  })();
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _TrailingSlashPathLocationStrategy,
+    factory: _TrailingSlashPathLocationStrategy.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(TrailingSlashPathLocationStrategy, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], null, null);
+})();
+function extractUrlPath(url) {
+  const questionMarkOrHashIndex = url.search(/[?#]/);
+  const pathEnd = questionMarkOrHashIndex > -1 ? questionMarkOrHashIndex : url.length;
+  return url.slice(0, pathEnd);
+}
+var Location = class _Location {
+  _subject = new Subject();
+  _basePath;
+  _locationStrategy;
+  _urlChangeListeners = [];
+  _urlChangeSubscription = null;
+  constructor(locationStrategy) {
+    this._locationStrategy = locationStrategy;
+    const baseHref = this._locationStrategy.getBaseHref();
+    this._basePath = _stripOrigin(stripTrailingSlash(_stripIndexHtml(baseHref)));
+    this._locationStrategy.onPopState((ev) => {
+      this._subject.next({
+        "url": this.path(true),
+        "pop": true,
+        "state": ev.state,
+        "type": ev.type
+      });
+    });
+  }
+  ngOnDestroy() {
+    this._urlChangeSubscription?.unsubscribe();
+    this._urlChangeListeners = [];
+  }
+  path(includeHash = false) {
+    return this.normalize(this._locationStrategy.path(includeHash));
+  }
+  getState() {
+    return this._locationStrategy.getState();
+  }
+  isCurrentPathEqualTo(path, query = "") {
+    return this.path() == this.normalize(path + normalizeQueryParams(query));
+  }
+  normalize(url) {
+    return _Location.stripTrailingSlash(_stripBasePath(this._basePath, _stripIndexHtml(url)));
+  }
+  prepareExternalUrl(url) {
+    if (url && url[0] !== "/") {
+      url = "/" + url;
+    }
+    return this._locationStrategy.prepareExternalUrl(url);
+  }
+  go(path, query = "", state = null) {
+    this._locationStrategy.pushState(state, "", path, query);
+    this._notifyUrlChangeListeners(this.prepareExternalUrl(path + normalizeQueryParams(query)), state);
+  }
+  replaceState(path, query = "", state = null) {
+    this._locationStrategy.replaceState(state, "", path, query);
+    this._notifyUrlChangeListeners(this.prepareExternalUrl(path + normalizeQueryParams(query)), state);
+  }
+  forward() {
+    this._locationStrategy.forward();
+  }
+  back() {
+    this._locationStrategy.back();
+  }
+  historyGo(relativePosition = 0) {
+    this._locationStrategy.historyGo?.(relativePosition);
+  }
+  onUrlChange(fn) {
+    this._urlChangeListeners.push(fn);
+    this._urlChangeSubscription ??= this.subscribe((v) => {
+      this._notifyUrlChangeListeners(v.url, v.state);
+    });
+    return () => {
+      const fnIndex = this._urlChangeListeners.indexOf(fn);
+      this._urlChangeListeners.splice(fnIndex, 1);
+      if (this._urlChangeListeners.length === 0) {
+        this._urlChangeSubscription?.unsubscribe();
+        this._urlChangeSubscription = null;
+      }
+    };
+  }
+  _notifyUrlChangeListeners(url = "", state) {
+    this._urlChangeListeners.forEach((fn) => fn(url, state));
+  }
+  subscribe(onNext, onThrow, onReturn) {
+    return this._subject.subscribe({
+      next: onNext,
+      error: onThrow ?? void 0,
+      complete: onReturn ?? void 0
+    });
+  }
+  static normalizeQueryParams = normalizeQueryParams;
+  static joinWithSlash = joinWithSlash;
+  static stripTrailingSlash = stripTrailingSlash;
+  static \u0275fac = function Location_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _Location)(\u0275\u0275inject(LocationStrategy));
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _Location,
+    factory: () => createLocation(),
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(Location, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root",
+      useFactory: createLocation
+    }]
+  }], () => [{
+    type: LocationStrategy
+  }], null);
+})();
+function createLocation() {
+  return new Location(\u0275\u0275inject(LocationStrategy));
+}
+function _stripBasePath(basePath, url) {
+  if (!basePath || !url.startsWith(basePath)) {
+    return url;
+  }
+  const strippedUrl = url.substring(basePath.length);
+  if (strippedUrl === "" || ["/", ";", "?", "#"].includes(strippedUrl[0])) {
+    return strippedUrl;
+  }
+  return url;
+}
+function _stripIndexHtml(url) {
+  return url.replace(/\/index\.html$/, "");
+}
+function _stripOrigin(baseHref) {
+  const isAbsoluteUrl2 = new RegExp("^(https?:)?//").test(baseHref);
+  if (isAbsoluteUrl2) {
+    const [, pathname] = baseHref.split(/\/\/[^\/]+/);
+    return pathname;
+  }
+  return baseHref;
+}
+
+// node_modules/@angular/common/fesm2022/_common_module-chunk.mjs
+/**
+ * @license Angular v21.2.17
+ * (c) 2010-2026 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+var HashLocationStrategy = class _HashLocationStrategy extends LocationStrategy {
+  _platformLocation;
+  _baseHref = "";
+  _removeListenerFns = [];
+  constructor(_platformLocation, _baseHref) {
+    super();
+    this._platformLocation = _platformLocation;
+    if (_baseHref != null) {
+      this._baseHref = _baseHref;
+    }
+  }
+  ngOnDestroy() {
+    while (this._removeListenerFns.length) {
+      this._removeListenerFns.pop()();
+    }
+  }
+  onPopState(fn) {
+    this._removeListenerFns.push(this._platformLocation.onPopState(fn), this._platformLocation.onHashChange(fn));
+  }
+  getBaseHref() {
+    return this._baseHref;
+  }
+  path(includeHash = false) {
+    const path = this._platformLocation.hash ?? "#";
+    return path.length > 0 ? path.substring(1) : path;
+  }
+  prepareExternalUrl(internal) {
+    const url = joinWithSlash(this._baseHref, internal);
+    return url.length > 0 ? "#" + url : url;
+  }
+  pushState(state, title, path, queryParams) {
+    const url = this.prepareExternalUrl(path + normalizeQueryParams(queryParams)) || this._platformLocation.pathname;
+    this._platformLocation.pushState(state, title, url);
+  }
+  replaceState(state, title, path, queryParams) {
+    const url = this.prepareExternalUrl(path + normalizeQueryParams(queryParams)) || this._platformLocation.pathname;
+    this._platformLocation.replaceState(state, title, url);
+  }
+  forward() {
+    this._platformLocation.forward();
+  }
+  back() {
+    this._platformLocation.back();
+  }
+  getState() {
+    return this._platformLocation.getState();
+  }
+  historyGo(relativePosition = 0) {
+    this._platformLocation.historyGo?.(relativePosition);
+  }
+  static \u0275fac = function HashLocationStrategy_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _HashLocationStrategy)(\u0275\u0275inject(PlatformLocation), \u0275\u0275inject(APP_BASE_HREF, 8));
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _HashLocationStrategy,
+    factory: _HashLocationStrategy.\u0275fac
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HashLocationStrategy, [{
+    type: Injectable
+  }], () => [{
+    type: PlatformLocation
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Inject,
+      args: [APP_BASE_HREF]
+    }]
+  }], null);
+})();
+var CURRENCIES_EN = {
+  "ADP": [void 0, void 0, 0],
+  "AFN": [void 0, "\u060B", 0],
+  "ALL": [void 0, void 0, 0],
+  "AMD": [void 0, "\u058F", 2],
+  "AOA": [void 0, "Kz"],
+  "ARS": [void 0, "$"],
+  "AUD": ["A$", "$"],
+  "AZN": [void 0, "\u20BC"],
+  "BAM": [void 0, "KM"],
+  "BBD": [void 0, "$"],
+  "BDT": [void 0, "\u09F3"],
+  "BHD": [void 0, void 0, 3],
+  "BIF": [void 0, void 0, 0],
+  "BMD": [void 0, "$"],
+  "BND": [void 0, "$"],
+  "BOB": [void 0, "Bs"],
+  "BRL": ["R$"],
+  "BSD": [void 0, "$"],
+  "BWP": [void 0, "P"],
+  "BYN": [void 0, void 0, 2],
+  "BYR": [void 0, void 0, 0],
+  "BZD": [void 0, "$"],
+  "CAD": ["CA$", "$", 2],
+  "CHF": [void 0, void 0, 2],
+  "CLF": [void 0, void 0, 4],
+  "CLP": [void 0, "$", 0],
+  "CNY": ["CN\xA5", "\xA5"],
+  "COP": [void 0, "$", 2],
+  "CRC": [void 0, "\u20A1", 2],
+  "CUC": [void 0, "$"],
+  "CUP": [void 0, "$"],
+  "CZK": [void 0, "K\u010D", 2],
+  "DJF": [void 0, void 0, 0],
+  "DKK": [void 0, "kr", 2],
+  "DOP": [void 0, "$"],
+  "EGP": [void 0, "E\xA3"],
+  "ESP": [void 0, "\u20A7", 0],
+  "EUR": ["\u20AC"],
+  "FJD": [void 0, "$"],
+  "FKP": [void 0, "\xA3"],
+  "GBP": ["\xA3"],
+  "GEL": [void 0, "\u20BE"],
+  "GHS": [void 0, "GH\u20B5"],
+  "GIP": [void 0, "\xA3"],
+  "GNF": [void 0, "FG", 0],
+  "GTQ": [void 0, "Q"],
+  "GYD": [void 0, "$", 2],
+  "HKD": ["HK$", "$"],
+  "HNL": [void 0, "L"],
+  "HRK": [void 0, "kn"],
+  "HUF": [void 0, "Ft", 2],
+  "IDR": [void 0, "Rp", 2],
+  "ILS": ["\u20AA"],
+  "INR": ["\u20B9"],
+  "IQD": [void 0, void 0, 0],
+  "IRR": [void 0, void 0, 0],
+  "ISK": [void 0, "kr", 0],
+  "ITL": [void 0, void 0, 0],
+  "JMD": [void 0, "$"],
+  "JOD": [void 0, void 0, 3],
+  "JPY": ["\xA5", void 0, 0],
+  "KGS": [void 0, "\u20C0"],
+  "KHR": [void 0, "\u17DB"],
+  "KMF": [void 0, "CF", 0],
+  "KPW": [void 0, "\u20A9", 0],
+  "KRW": ["\u20A9", void 0, 0],
+  "KWD": [void 0, void 0, 3],
+  "KYD": [void 0, "$"],
+  "KZT": [void 0, "\u20B8"],
+  "LAK": [void 0, "\u20AD", 0],
+  "LBP": [void 0, "L\xA3", 0],
+  "LKR": [void 0, "Rs"],
+  "LRD": [void 0, "$"],
+  "LTL": [void 0, "Lt"],
+  "LUF": [void 0, void 0, 0],
+  "LVL": [void 0, "Ls"],
+  "LYD": [void 0, void 0, 3],
+  "MGA": [void 0, "Ar", 0],
+  "MGF": [void 0, void 0, 0],
+  "MMK": [void 0, "K", 0],
+  "MNT": [void 0, "\u20AE", 2],
+  "MRO": [void 0, void 0, 0],
+  "MUR": [void 0, "Rs", 2],
+  "MXN": ["MX$", "$"],
+  "MYR": [void 0, "RM"],
+  "NAD": [void 0, "$"],
+  "NGN": [void 0, "\u20A6"],
+  "NIO": [void 0, "C$"],
+  "NOK": [void 0, "kr", 2],
+  "NPR": [void 0, "Rs"],
+  "NZD": ["NZ$", "$"],
+  "OMR": [void 0, void 0, 3],
+  "PHP": ["\u20B1"],
+  "PKR": [void 0, "Rs", 2],
+  "PLN": [void 0, "z\u0142"],
+  "PYG": [void 0, "\u20B2", 0],
+  "RON": [void 0, "lei"],
+  "RSD": [void 0, void 0, 0],
+  "RUB": [void 0, "\u20BD"],
+  "RWF": [void 0, "RF", 0],
+  "SBD": [void 0, "$"],
+  "SEK": [void 0, "kr", 2],
+  "SGD": [void 0, "$"],
+  "SHP": [void 0, "\xA3"],
+  "SLE": [void 0, void 0, 2],
+  "SLL": [void 0, void 0, 0],
+  "SOS": [void 0, void 0, 0],
+  "SRD": [void 0, "$"],
+  "SSP": [void 0, "\xA3"],
+  "STD": [void 0, void 0, 0],
+  "STN": [void 0, "Db"],
+  "SYP": [void 0, "\xA3", 0],
+  "THB": [void 0, "\u0E3F"],
+  "TMM": [void 0, void 0, 0],
+  "TND": [void 0, void 0, 3],
+  "TOP": [void 0, "T$"],
+  "TRL": [void 0, void 0, 0],
+  "TRY": [void 0, "\u20BA"],
+  "TTD": [void 0, "$"],
+  "TWD": ["NT$", "$", 2],
+  "TZS": [void 0, void 0, 2],
+  "UAH": [void 0, "\u20B4"],
+  "UGX": [void 0, void 0, 0],
+  "USD": ["$"],
+  "UYI": [void 0, void 0, 0],
+  "UYU": [void 0, "$"],
+  "UYW": [void 0, void 0, 4],
+  "UZS": [void 0, void 0, 2],
+  "VEF": [void 0, "Bs", 2],
+  "VND": ["\u20AB", void 0, 0],
+  "VUV": [void 0, void 0, 0],
+  "XAF": ["FCFA", void 0, 0],
+  "XCD": ["EC$", "$"],
+  "XCG": ["Cg."],
+  "XOF": ["F\u202FCFA", void 0, 0],
+  "XPF": ["CFPF", void 0, 0],
+  "XXX": ["\xA4"],
+  "YER": [void 0, void 0, 0],
+  "ZAR": [void 0, "R"],
+  "ZMK": [void 0, void 0, 0],
+  "ZMW": [void 0, "ZK"],
+  "ZWD": [void 0, void 0, 0]
+};
+var NumberFormatStyle;
+(function(NumberFormatStyle2) {
+  NumberFormatStyle2[NumberFormatStyle2["Decimal"] = 0] = "Decimal";
+  NumberFormatStyle2[NumberFormatStyle2["Percent"] = 1] = "Percent";
+  NumberFormatStyle2[NumberFormatStyle2["Currency"] = 2] = "Currency";
+  NumberFormatStyle2[NumberFormatStyle2["Scientific"] = 3] = "Scientific";
+})(NumberFormatStyle || (NumberFormatStyle = {}));
+var Plural;
+(function(Plural2) {
+  Plural2[Plural2["Zero"] = 0] = "Zero";
+  Plural2[Plural2["One"] = 1] = "One";
+  Plural2[Plural2["Two"] = 2] = "Two";
+  Plural2[Plural2["Few"] = 3] = "Few";
+  Plural2[Plural2["Many"] = 4] = "Many";
+  Plural2[Plural2["Other"] = 5] = "Other";
+})(Plural || (Plural = {}));
+var FormStyle;
+(function(FormStyle2) {
+  FormStyle2[FormStyle2["Format"] = 0] = "Format";
+  FormStyle2[FormStyle2["Standalone"] = 1] = "Standalone";
+})(FormStyle || (FormStyle = {}));
+var TranslationWidth;
+(function(TranslationWidth2) {
+  TranslationWidth2[TranslationWidth2["Narrow"] = 0] = "Narrow";
+  TranslationWidth2[TranslationWidth2["Abbreviated"] = 1] = "Abbreviated";
+  TranslationWidth2[TranslationWidth2["Wide"] = 2] = "Wide";
+  TranslationWidth2[TranslationWidth2["Short"] = 3] = "Short";
+})(TranslationWidth || (TranslationWidth = {}));
+var FormatWidth;
+(function(FormatWidth2) {
+  FormatWidth2[FormatWidth2["Short"] = 0] = "Short";
+  FormatWidth2[FormatWidth2["Medium"] = 1] = "Medium";
+  FormatWidth2[FormatWidth2["Long"] = 2] = "Long";
+  FormatWidth2[FormatWidth2["Full"] = 3] = "Full";
+})(FormatWidth || (FormatWidth = {}));
+var NumberSymbol = {
+  Decimal: 0,
+  Group: 1,
+  List: 2,
+  PercentSign: 3,
+  PlusSign: 4,
+  MinusSign: 5,
+  Exponential: 6,
+  SuperscriptingExponent: 7,
+  PerMille: 8,
+  Infinity: 9,
+  NaN: 10,
+  TimeSeparator: 11,
+  CurrencyDecimal: 12,
+  CurrencyGroup: 13
+};
+var WeekDay;
+(function(WeekDay2) {
+  WeekDay2[WeekDay2["Sunday"] = 0] = "Sunday";
+  WeekDay2[WeekDay2["Monday"] = 1] = "Monday";
+  WeekDay2[WeekDay2["Tuesday"] = 2] = "Tuesday";
+  WeekDay2[WeekDay2["Wednesday"] = 3] = "Wednesday";
+  WeekDay2[WeekDay2["Thursday"] = 4] = "Thursday";
+  WeekDay2[WeekDay2["Friday"] = 5] = "Friday";
+  WeekDay2[WeekDay2["Saturday"] = 6] = "Saturday";
+})(WeekDay || (WeekDay = {}));
+function getLocaleId2(locale) {
+  return findLocaleData(locale)[LocaleDataIndex.LocaleId];
+}
+function getLocaleDayPeriods(locale, formStyle, width) {
+  const data = findLocaleData(locale);
+  const amPmData = [data[LocaleDataIndex.DayPeriodsFormat], data[LocaleDataIndex.DayPeriodsStandalone]];
+  const amPm = getLastDefinedValue(amPmData, formStyle);
+  return getLastDefinedValue(amPm, width);
+}
+function getLocaleDayNames(locale, formStyle, width) {
+  const data = findLocaleData(locale);
+  const daysData = [data[LocaleDataIndex.DaysFormat], data[LocaleDataIndex.DaysStandalone]];
+  const days = getLastDefinedValue(daysData, formStyle);
+  return getLastDefinedValue(days, width);
+}
+function getLocaleMonthNames(locale, formStyle, width) {
+  const data = findLocaleData(locale);
+  const monthsData = [data[LocaleDataIndex.MonthsFormat], data[LocaleDataIndex.MonthsStandalone]];
+  const months = getLastDefinedValue(monthsData, formStyle);
+  return getLastDefinedValue(months, width);
+}
+function getLocaleEraNames(locale, width) {
+  const data = findLocaleData(locale);
+  const erasData = data[LocaleDataIndex.Eras];
+  return getLastDefinedValue(erasData, width);
+}
+function getLocaleDateFormat(locale, width) {
+  const data = findLocaleData(locale);
+  return getLastDefinedValue(data[LocaleDataIndex.DateFormat], width);
+}
+function getLocaleTimeFormat(locale, width) {
+  const data = findLocaleData(locale);
+  return getLastDefinedValue(data[LocaleDataIndex.TimeFormat], width);
+}
+function getLocaleDateTimeFormat(locale, width) {
+  const data = findLocaleData(locale);
+  const dateTimeFormatData = data[LocaleDataIndex.DateTimeFormat];
+  return getLastDefinedValue(dateTimeFormatData, width);
+}
+function getLocaleNumberSymbol(locale, symbol) {
+  const data = findLocaleData(locale);
+  const res = data[LocaleDataIndex.NumberSymbols][symbol];
+  if (typeof res === "undefined") {
+    if (symbol === NumberSymbol.CurrencyDecimal) {
+      return data[LocaleDataIndex.NumberSymbols][NumberSymbol.Decimal];
+    } else if (symbol === NumberSymbol.CurrencyGroup) {
+      return data[LocaleDataIndex.NumberSymbols][NumberSymbol.Group];
+    }
+  }
+  return res;
+}
+function getLocaleNumberFormat(locale, type) {
+  const data = findLocaleData(locale);
+  return data[LocaleDataIndex.NumberFormats][type];
+}
+function getLocaleCurrencies(locale) {
+  const data = findLocaleData(locale);
+  return data[LocaleDataIndex.Currencies];
+}
+var getLocalePluralCase2 = getLocalePluralCase;
+function checkFullData(data) {
+  if (!data[LocaleDataIndex.ExtraData]) {
+    throw new RuntimeError(2303, ngDevMode && `Missing extra locale data for the locale "${data[LocaleDataIndex.LocaleId]}". Use "registerLocaleData" to load new data. See the "I18n guide" on angular.io to know more.`);
+  }
+}
+function getLocaleExtraDayPeriodRules(locale) {
+  const data = findLocaleData(locale);
+  checkFullData(data);
+  const rules = data[LocaleDataIndex.ExtraData][2] || [];
+  return rules.map((rule) => {
+    if (typeof rule === "string") {
+      return extractTime(rule);
+    }
+    return [extractTime(rule[0]), extractTime(rule[1])];
+  });
+}
+function getLocaleExtraDayPeriods(locale, formStyle, width) {
+  const data = findLocaleData(locale);
+  checkFullData(data);
+  const dayPeriodsData = [data[LocaleDataIndex.ExtraData][0], data[LocaleDataIndex.ExtraData][1]];
+  const dayPeriods = getLastDefinedValue(dayPeriodsData, formStyle) || [];
+  return getLastDefinedValue(dayPeriods, width) || [];
+}
+function getLastDefinedValue(data, index) {
+  for (let i = index; i > -1; i--) {
+    if (typeof data[i] !== "undefined") {
+      return data[i];
+    }
+  }
+  throw new RuntimeError(2304, ngDevMode && "Locale data API: locale data undefined");
+}
+function extractTime(time) {
+  const [h, m] = time.split(":");
+  return {
+    hours: +h,
+    minutes: +m
+  };
+}
+function getCurrencySymbol(code, format, locale = "en") {
+  const currency = getLocaleCurrencies(locale)[code] || CURRENCIES_EN[code] || [];
+  const symbolNarrow = currency[1];
+  if (format === "narrow" && typeof symbolNarrow === "string") {
+    return symbolNarrow;
+  }
+  return currency[0] || code;
+}
+var DEFAULT_NB_OF_CURRENCY_DIGITS = 2;
+function getNumberOfCurrencyDigits(code) {
+  let digits;
+  const currency = CURRENCIES_EN[code];
+  if (currency) {
+    digits = currency[2];
+  }
+  return typeof digits === "number" ? digits : DEFAULT_NB_OF_CURRENCY_DIGITS;
+}
+var ISO8601_DATE_REGEX = /^(\d{4,})-?(\d\d)-?(\d\d)(?:T(\d\d)(?::?(\d\d)(?::?(\d\d)(?:\.(\d+))?)?)?(Z|([+-])(\d\d):?(\d\d))?)?$/;
+var NAMED_FORMATS = {};
+var DATE_FORMATS_SPLIT = /((?:[^BEGHLMOSWYZabcdhmswyz']+)|(?:'(?:[^']|'')*')|(?:G{1,5}|y{1,4}|Y{1,4}|M{1,5}|L{1,5}|w{1,2}|W{1}|d{1,2}|E{1,6}|c{1,6}|a{1,5}|b{1,5}|B{1,5}|h{1,2}|H{1,2}|m{1,2}|s{1,2}|S{1,3}|z{1,4}|Z{1,5}|O{1,4}))([\s\S]*)/;
+var MAX_DATE_FORMAT_LENGTH = 256;
+function formatDate(value, format, locale, timezone) {
+  let date = toDate(value);
+  assertValidDateFormatLength(format);
+  const namedFormat = getNamedFormat(locale, format);
+  format = namedFormat || format;
+  let parts = [];
+  let match2;
+  while (format) {
+    match2 = DATE_FORMATS_SPLIT.exec(format);
+    if (match2) {
+      parts = parts.concat(match2.slice(1));
+      const part = parts.pop();
+      if (!part) {
+        break;
+      }
+      format = part;
+    } else {
+      parts.push(format);
+      break;
+    }
+  }
+  if (typeof ngDevMode === "undefined" || ngDevMode) {
+    assertValidDateFormat(parts);
+  }
+  let dateTimezoneOffset = date.getTimezoneOffset();
+  if (timezone) {
+    dateTimezoneOffset = timezoneToOffset(timezone, dateTimezoneOffset);
+    date = convertTimezoneToLocal(date, timezone);
+  }
+  let text = "";
+  parts.forEach((value2) => {
+    const dateFormatter = getDateFormatter(value2);
+    text += dateFormatter ? dateFormatter(date, locale, dateTimezoneOffset) : value2 === "''" ? "'" : value2.replace(/(^'|'$)/g, "").replace(/''/g, "'");
+  });
+  return text;
+}
+function assertValidDateFormatLength(format) {
+  if (format.length > MAX_DATE_FORMAT_LENGTH) {
+    throw new RuntimeError(2300, ngDevMode && `Date format is too long. Exceeded maximum length of ${MAX_DATE_FORMAT_LENGTH} characters.`);
+  }
+}
+function assertValidDateFormat(parts) {
+  if (parts.some((part) => /^Y+$/.test(part)) && !parts.some((part) => /^w+$/.test(part))) {
+    const message = `Suspicious use of week-based year "Y" in date pattern "${parts.join("")}". Did you mean to use calendar year "y" instead?`;
+    if (parts.length === 1) {
+      console.error(formatRuntimeError(2300, message));
+    } else {
+      throw new RuntimeError(2300, message);
+    }
+  }
+}
+function createDate(year, month, date) {
+  const newDate = /* @__PURE__ */ new Date(0);
+  newDate.setFullYear(year, month, date);
+  newDate.setHours(0, 0, 0);
+  return newDate;
+}
+function getNamedFormat(locale, format) {
+  const localeId = getLocaleId2(locale);
+  NAMED_FORMATS[localeId] ??= {};
+  if (NAMED_FORMATS[localeId][format]) {
+    return NAMED_FORMATS[localeId][format];
+  }
+  let formatValue2 = "";
+  switch (format) {
+    case "shortDate":
+      formatValue2 = getLocaleDateFormat(locale, FormatWidth.Short);
+      break;
+    case "mediumDate":
+      formatValue2 = getLocaleDateFormat(locale, FormatWidth.Medium);
+      break;
+    case "longDate":
+      formatValue2 = getLocaleDateFormat(locale, FormatWidth.Long);
+      break;
+    case "fullDate":
+      formatValue2 = getLocaleDateFormat(locale, FormatWidth.Full);
+      break;
+    case "shortTime":
+      formatValue2 = getLocaleTimeFormat(locale, FormatWidth.Short);
+      break;
+    case "mediumTime":
+      formatValue2 = getLocaleTimeFormat(locale, FormatWidth.Medium);
+      break;
+    case "longTime":
+      formatValue2 = getLocaleTimeFormat(locale, FormatWidth.Long);
+      break;
+    case "fullTime":
+      formatValue2 = getLocaleTimeFormat(locale, FormatWidth.Full);
+      break;
+    case "short":
+      const shortTime = getNamedFormat(locale, "shortTime");
+      const shortDate = getNamedFormat(locale, "shortDate");
+      formatValue2 = formatDateTime(getLocaleDateTimeFormat(locale, FormatWidth.Short), [shortTime, shortDate]);
+      break;
+    case "medium":
+      const mediumTime = getNamedFormat(locale, "mediumTime");
+      const mediumDate = getNamedFormat(locale, "mediumDate");
+      formatValue2 = formatDateTime(getLocaleDateTimeFormat(locale, FormatWidth.Medium), [mediumTime, mediumDate]);
+      break;
+    case "long":
+      const longTime = getNamedFormat(locale, "longTime");
+      const longDate = getNamedFormat(locale, "longDate");
+      formatValue2 = formatDateTime(getLocaleDateTimeFormat(locale, FormatWidth.Long), [longTime, longDate]);
+      break;
+    case "full":
+      const fullTime = getNamedFormat(locale, "fullTime");
+      const fullDate = getNamedFormat(locale, "fullDate");
+      formatValue2 = formatDateTime(getLocaleDateTimeFormat(locale, FormatWidth.Full), [fullTime, fullDate]);
+      break;
+  }
+  if (formatValue2) {
+    NAMED_FORMATS[localeId][format] = formatValue2;
+  }
+  return formatValue2;
+}
+function formatDateTime(str, opt_values) {
+  if (opt_values) {
+    str = str.replace(/\{([^}]+)}/g, function(match2, key) {
+      return opt_values != null && key in opt_values ? opt_values[key] : match2;
+    });
+  }
+  return str;
+}
+function padNumber(num, digits, minusSign = "-", trim, negWrap) {
+  let neg = "";
+  if (num < 0 || negWrap && num <= 0) {
+    if (negWrap) {
+      num = -num + 1;
+    } else {
+      num = -num;
+      neg = minusSign;
+    }
+  }
+  let strNum = String(num);
+  while (strNum.length < digits) {
+    strNum = "0" + strNum;
+  }
+  if (trim) {
+    strNum = strNum.slice(strNum.length - digits);
+  }
+  return neg + strNum;
+}
+function formatFractionalSeconds(milliseconds, digits) {
+  const strMs = padNumber(milliseconds, 3);
+  return strMs.substring(0, digits);
+}
+function dateGetter(name, size, offset = 0, trim = false, negWrap = false) {
+  return function(date, locale) {
+    let part = getDatePart(name, date);
+    if (offset > 0 || part > -offset) {
+      part += offset;
+    }
+    if (name === 3) {
+      if (part === 0 && offset === -12) {
+        part = 12;
+      }
+    } else if (name === 6) {
+      return formatFractionalSeconds(part, size);
+    }
+    const localeMinus = getLocaleNumberSymbol(locale, NumberSymbol.MinusSign);
+    return padNumber(part, size, localeMinus, trim, negWrap);
+  };
+}
+function getDatePart(part, date) {
+  switch (part) {
+    case 0:
+      return date.getFullYear();
+    case 1:
+      return date.getMonth();
+    case 2:
+      return date.getDate();
+    case 3:
+      return date.getHours();
+    case 4:
+      return date.getMinutes();
+    case 5:
+      return date.getSeconds();
+    case 6:
+      return date.getMilliseconds();
+    case 7:
+      return date.getDay();
+    default:
+      throw new RuntimeError(2301, ngDevMode && `Unknown DateType value "${part}".`);
+  }
+}
+function dateStrGetter(name, width, form = FormStyle.Format, extended = false) {
+  return function(date, locale) {
+    return getDateTranslation(date, locale, name, width, form, extended);
+  };
+}
+function getDateTranslation(date, locale, name, width, form, extended) {
+  switch (name) {
+    case 2:
+      return getLocaleMonthNames(locale, form, width)[date.getMonth()];
+    case 1:
+      return getLocaleDayNames(locale, form, width)[date.getDay()];
+    case 0:
+      const currentHours = date.getHours();
+      const currentMinutes = date.getMinutes();
+      if (extended) {
+        const rules = getLocaleExtraDayPeriodRules(locale);
+        const dayPeriods = getLocaleExtraDayPeriods(locale, form, width);
+        const index = rules.findIndex((rule) => {
+          if (Array.isArray(rule)) {
+            const [from2, to] = rule;
+            const afterFrom = currentHours >= from2.hours && currentMinutes >= from2.minutes;
+            const beforeTo = currentHours < to.hours || currentHours === to.hours && currentMinutes < to.minutes;
+            if (from2.hours < to.hours) {
+              if (afterFrom && beforeTo) {
+                return true;
+              }
+            } else if (afterFrom || beforeTo) {
+              return true;
+            }
+          } else {
+            if (rule.hours === currentHours && rule.minutes === currentMinutes) {
+              return true;
+            }
+          }
+          return false;
+        });
+        if (index !== -1) {
+          return dayPeriods[index];
+        }
+      }
+      return getLocaleDayPeriods(locale, form, width)[currentHours < 12 ? 0 : 1];
+    case 3:
+      return getLocaleEraNames(locale, width)[date.getFullYear() <= 0 ? 0 : 1];
+    default:
+      const unexpected = name;
+      throw new RuntimeError(2302, ngDevMode && `unexpected translation type ${unexpected}`);
+  }
+}
+function timeZoneGetter(width) {
+  return function(date, locale, offset) {
+    const zone = -1 * offset;
+    const minusSign = getLocaleNumberSymbol(locale, NumberSymbol.MinusSign);
+    const hours = zone > 0 ? Math.floor(zone / 60) : Math.ceil(zone / 60);
+    switch (width) {
+      case 0:
+        return (zone >= 0 ? "+" : "") + padNumber(hours, 2, minusSign) + padNumber(Math.abs(zone % 60), 2, minusSign);
+      case 1:
+        return "GMT" + (zone >= 0 ? "+" : "") + padNumber(hours, 1, minusSign);
+      case 2:
+        return "GMT" + (zone >= 0 ? "+" : "") + padNumber(hours, 2, minusSign) + ":" + padNumber(Math.abs(zone % 60), 2, minusSign);
+      case 3:
+        if (offset === 0) {
+          return "Z";
+        } else {
+          return (zone >= 0 ? "+" : "") + padNumber(hours, 2, minusSign) + ":" + padNumber(Math.abs(zone % 60), 2, minusSign);
+        }
+      default:
+        throw new RuntimeError(2310, ngDevMode && `Unknown zone width "${width}"`);
+    }
+  };
+}
+var JANUARY = 0;
+var THURSDAY = 4;
+function getFirstThursdayOfYear(year) {
+  const firstDayOfYear = createDate(year, JANUARY, 1).getDay();
+  return createDate(year, 0, 1 + (firstDayOfYear <= THURSDAY ? THURSDAY : THURSDAY + 7) - firstDayOfYear);
+}
+function getThursdayThisIsoWeek(datetime) {
+  const currentDay = datetime.getDay();
+  const deltaToThursday = currentDay === 0 ? -3 : THURSDAY - currentDay;
+  return createDate(datetime.getFullYear(), datetime.getMonth(), datetime.getDate() + deltaToThursday);
+}
+function weekGetter(size, monthBased = false) {
+  return function(date, locale) {
+    let result;
+    if (monthBased) {
+      const nbDaysBefore1stDayOfMonth = new Date(date.getFullYear(), date.getMonth(), 1).getDay() - 1;
+      const today = date.getDate();
+      result = 1 + Math.floor((today + nbDaysBefore1stDayOfMonth) / 7);
+    } else {
+      const thisThurs = getThursdayThisIsoWeek(date);
+      const firstThurs = getFirstThursdayOfYear(thisThurs.getFullYear());
+      const diff = thisThurs.getTime() - firstThurs.getTime();
+      result = 1 + Math.round(diff / 6048e5);
+    }
+    return padNumber(result, size, getLocaleNumberSymbol(locale, NumberSymbol.MinusSign));
+  };
+}
+function weekNumberingYearGetter(size, trim = false) {
+  return function(date, locale) {
+    const thisThurs = getThursdayThisIsoWeek(date);
+    const weekNumberingYear = thisThurs.getFullYear();
+    return padNumber(weekNumberingYear, size, getLocaleNumberSymbol(locale, NumberSymbol.MinusSign), trim);
+  };
+}
+var DATE_FORMATS = {};
+function getDateFormatter(format) {
+  if (DATE_FORMATS[format]) {
+    return DATE_FORMATS[format];
+  }
+  let formatter2;
+  switch (format) {
+    case "G":
+    case "GG":
+    case "GGG":
+      formatter2 = dateStrGetter(3, TranslationWidth.Abbreviated);
+      break;
+    case "GGGG":
+      formatter2 = dateStrGetter(3, TranslationWidth.Wide);
+      break;
+    case "GGGGG":
+      formatter2 = dateStrGetter(3, TranslationWidth.Narrow);
+      break;
+    case "y":
+      formatter2 = dateGetter(0, 1, 0, false, true);
+      break;
+    case "yy":
+      formatter2 = dateGetter(0, 2, 0, true, true);
+      break;
+    case "yyy":
+      formatter2 = dateGetter(0, 3, 0, false, true);
+      break;
+    case "yyyy":
+      formatter2 = dateGetter(0, 4, 0, false, true);
+      break;
+    case "Y":
+      formatter2 = weekNumberingYearGetter(1);
+      break;
+    case "YY":
+      formatter2 = weekNumberingYearGetter(2, true);
+      break;
+    case "YYY":
+      formatter2 = weekNumberingYearGetter(3);
+      break;
+    case "YYYY":
+      formatter2 = weekNumberingYearGetter(4);
+      break;
+    case "M":
+    case "L":
+      formatter2 = dateGetter(1, 1, 1);
+      break;
+    case "MM":
+    case "LL":
+      formatter2 = dateGetter(1, 2, 1);
+      break;
+    case "MMM":
+      formatter2 = dateStrGetter(2, TranslationWidth.Abbreviated);
+      break;
+    case "MMMM":
+      formatter2 = dateStrGetter(2, TranslationWidth.Wide);
+      break;
+    case "MMMMM":
+      formatter2 = dateStrGetter(2, TranslationWidth.Narrow);
+      break;
+    case "LLL":
+      formatter2 = dateStrGetter(2, TranslationWidth.Abbreviated, FormStyle.Standalone);
+      break;
+    case "LLLL":
+      formatter2 = dateStrGetter(2, TranslationWidth.Wide, FormStyle.Standalone);
+      break;
+    case "LLLLL":
+      formatter2 = dateStrGetter(2, TranslationWidth.Narrow, FormStyle.Standalone);
+      break;
+    case "w":
+      formatter2 = weekGetter(1);
+      break;
+    case "ww":
+      formatter2 = weekGetter(2);
+      break;
+    case "W":
+      formatter2 = weekGetter(1, true);
+      break;
+    case "d":
+      formatter2 = dateGetter(2, 1);
+      break;
+    case "dd":
+      formatter2 = dateGetter(2, 2);
+      break;
+    case "c":
+    case "cc":
+      formatter2 = dateGetter(7, 1);
+      break;
+    case "ccc":
+      formatter2 = dateStrGetter(1, TranslationWidth.Abbreviated, FormStyle.Standalone);
+      break;
+    case "cccc":
+      formatter2 = dateStrGetter(1, TranslationWidth.Wide, FormStyle.Standalone);
+      break;
+    case "ccccc":
+      formatter2 = dateStrGetter(1, TranslationWidth.Narrow, FormStyle.Standalone);
+      break;
+    case "cccccc":
+      formatter2 = dateStrGetter(1, TranslationWidth.Short, FormStyle.Standalone);
+      break;
+    case "E":
+    case "EE":
+    case "EEE":
+      formatter2 = dateStrGetter(1, TranslationWidth.Abbreviated);
+      break;
+    case "EEEE":
+      formatter2 = dateStrGetter(1, TranslationWidth.Wide);
+      break;
+    case "EEEEE":
+      formatter2 = dateStrGetter(1, TranslationWidth.Narrow);
+      break;
+    case "EEEEEE":
+      formatter2 = dateStrGetter(1, TranslationWidth.Short);
+      break;
+    case "a":
+    case "aa":
+    case "aaa":
+      formatter2 = dateStrGetter(0, TranslationWidth.Abbreviated);
+      break;
+    case "aaaa":
+      formatter2 = dateStrGetter(0, TranslationWidth.Wide);
+      break;
+    case "aaaaa":
+      formatter2 = dateStrGetter(0, TranslationWidth.Narrow);
+      break;
+    case "b":
+    case "bb":
+    case "bbb":
+      formatter2 = dateStrGetter(0, TranslationWidth.Abbreviated, FormStyle.Standalone, true);
+      break;
+    case "bbbb":
+      formatter2 = dateStrGetter(0, TranslationWidth.Wide, FormStyle.Standalone, true);
+      break;
+    case "bbbbb":
+      formatter2 = dateStrGetter(0, TranslationWidth.Narrow, FormStyle.Standalone, true);
+      break;
+    case "B":
+    case "BB":
+    case "BBB":
+      formatter2 = dateStrGetter(0, TranslationWidth.Abbreviated, FormStyle.Format, true);
+      break;
+    case "BBBB":
+      formatter2 = dateStrGetter(0, TranslationWidth.Wide, FormStyle.Format, true);
+      break;
+    case "BBBBB":
+      formatter2 = dateStrGetter(0, TranslationWidth.Narrow, FormStyle.Format, true);
+      break;
+    case "h":
+      formatter2 = dateGetter(3, 1, -12);
+      break;
+    case "hh":
+      formatter2 = dateGetter(3, 2, -12);
+      break;
+    case "H":
+      formatter2 = dateGetter(3, 1);
+      break;
+    case "HH":
+      formatter2 = dateGetter(3, 2);
+      break;
+    case "m":
+      formatter2 = dateGetter(4, 1);
+      break;
+    case "mm":
+      formatter2 = dateGetter(4, 2);
+      break;
+    case "s":
+      formatter2 = dateGetter(5, 1);
+      break;
+    case "ss":
+      formatter2 = dateGetter(5, 2);
+      break;
+    case "S":
+      formatter2 = dateGetter(6, 1);
+      break;
+    case "SS":
+      formatter2 = dateGetter(6, 2);
+      break;
+    case "SSS":
+      formatter2 = dateGetter(6, 3);
+      break;
+    case "Z":
+    case "ZZ":
+    case "ZZZ":
+      formatter2 = timeZoneGetter(0);
+      break;
+    case "ZZZZZ":
+      formatter2 = timeZoneGetter(3);
+      break;
+    case "O":
+    case "OO":
+    case "OOO":
+    case "z":
+    case "zz":
+    case "zzz":
+      formatter2 = timeZoneGetter(1);
+      break;
+    case "OOOO":
+    case "ZZZZ":
+    case "zzzz":
+      formatter2 = timeZoneGetter(2);
+      break;
+    default:
+      return null;
+  }
+  DATE_FORMATS[format] = formatter2;
+  return formatter2;
+}
+function timezoneToOffset(timezone, fallback) {
+  timezone = timezone.replace(/:/g, "");
+  const requestedTimezoneOffset = Date.parse("Jan 01, 1970 00:00:00 " + timezone) / 6e4;
+  return isNaN(requestedTimezoneOffset) ? fallback : requestedTimezoneOffset;
+}
+function addDateMinutes(date, minutes) {
+  date = new Date(date.getTime());
+  date.setMinutes(date.getMinutes() + minutes);
+  return date;
+}
+function convertTimezoneToLocal(date, timezone, reverse) {
+  const reverseValue = -1;
+  const dateTimezoneOffset = date.getTimezoneOffset();
+  const timezoneOffset = timezoneToOffset(timezone, dateTimezoneOffset);
+  return addDateMinutes(date, reverseValue * (timezoneOffset - dateTimezoneOffset));
+}
+function toDate(value) {
+  if (isDate(value)) {
+    return value;
+  }
+  if (typeof value === "number" && !isNaN(value)) {
+    return new Date(value);
+  }
+  if (typeof value === "string") {
+    value = value.trim();
+    if (/^(\d{4}(-\d{1,2}(-\d{1,2})?)?)$/.test(value)) {
+      const [y, m = 1, d = 1] = value.split("-").map((val) => +val);
+      return createDate(y, m - 1, d);
+    }
+    const parsedNb = parseFloat(value);
+    if (!isNaN(value - parsedNb)) {
+      return new Date(parsedNb);
+    }
+    let match2;
+    if (match2 = value.match(ISO8601_DATE_REGEX)) {
+      return isoStringToDate(match2);
+    }
+  }
+  const date = new Date(value);
+  if (!isDate(date)) {
+    throw new RuntimeError(2311, ngDevMode && `Unable to convert "${value}" into a date`);
+  }
+  return date;
+}
+function isoStringToDate(match2) {
+  const date = /* @__PURE__ */ new Date(0);
+  let tzHour = 0;
+  let tzMin = 0;
+  const dateSetter = match2[8] ? date.setUTCFullYear : date.setFullYear;
+  const timeSetter = match2[8] ? date.setUTCHours : date.setHours;
+  if (match2[9]) {
+    tzHour = Number(match2[9] + match2[10]);
+    tzMin = Number(match2[9] + match2[11]);
+  }
+  dateSetter.call(date, Number(match2[1]), Number(match2[2]) - 1, Number(match2[3]));
+  const h = Number(match2[4] || 0) - tzHour;
+  const m = Number(match2[5] || 0) - tzMin;
+  const s = Number(match2[6] || 0);
+  const ms = Math.floor(parseFloat("0." + (match2[7] || 0)) * 1e3);
+  timeSetter.call(date, h, m, s, ms);
+  return date;
+}
+function isDate(value) {
+  return value instanceof Date && !isNaN(value.valueOf());
+}
+var NUMBER_FORMAT_REGEXP = /^(\d+)?\.((\d+)(-(\d+))?)?$/;
+var MAX_DIGITS = 22;
+var DECIMAL_SEP = ".";
+var ZERO_CHAR = "0";
+var PATTERN_SEP = ";";
+var GROUP_SEP = ",";
+var DIGIT_CHAR = "#";
+var CURRENCY_CHAR = "\xA4";
+var PERCENT_CHAR = "%";
+function formatNumberToLocaleString(value, pattern, locale, groupSymbol, decimalSymbol, digitsInfo, isPercent = false) {
+  let formattedText = "";
+  let isZero = false;
+  if (!isFinite(value)) {
+    formattedText = getLocaleNumberSymbol(locale, NumberSymbol.Infinity);
+  } else {
+    let parsedNumber = parseNumber(value);
+    if (isPercent) {
+      parsedNumber = toPercent(parsedNumber);
+    }
+    let minInt = pattern.minInt;
+    let minFraction = pattern.minFrac;
+    let maxFraction = pattern.maxFrac;
+    if (digitsInfo) {
+      const parts = digitsInfo.match(NUMBER_FORMAT_REGEXP);
+      if (parts === null) {
+        throw new RuntimeError(2306, ngDevMode && `${digitsInfo} is not a valid digit info`);
+      }
+      const minIntPart = parts[1];
+      const minFractionPart = parts[3];
+      const maxFractionPart = parts[5];
+      if (minIntPart != null) {
+        minInt = parseIntAutoRadix(minIntPart);
+      }
+      if (minFractionPart != null) {
+        minFraction = parseIntAutoRadix(minFractionPart);
+      }
+      if (maxFractionPart != null) {
+        maxFraction = parseIntAutoRadix(maxFractionPart);
+      } else if (minFractionPart != null && minFraction > maxFraction) {
+        maxFraction = minFraction;
+      }
+      const MAX_ALLOWED_DIGITS = 100;
+      if (minInt > MAX_ALLOWED_DIGITS || minFraction > MAX_ALLOWED_DIGITS || maxFraction > MAX_ALLOWED_DIGITS) {
+        throw new RuntimeError(2306, ngDevMode && `${digitsInfo} is not a valid digit info. Exceeded maximum limits of ${MAX_ALLOWED_DIGITS} digits.`);
+      }
+    }
+    roundNumber(parsedNumber, minFraction, maxFraction);
+    let digits = parsedNumber.digits;
+    let integerLen = parsedNumber.integerLen;
+    const exponent = parsedNumber.exponent;
+    let decimals = [];
+    isZero = digits.every((d) => !d);
+    for (; integerLen < minInt; integerLen++) {
+      digits.unshift(0);
+    }
+    for (; integerLen < 0; integerLen++) {
+      digits.unshift(0);
+    }
+    if (integerLen > 0) {
+      decimals = digits.splice(integerLen, digits.length);
+    } else {
+      decimals = digits;
+      digits = [0];
+    }
+    const groups = [];
+    if (digits.length >= pattern.lgSize) {
+      groups.unshift(digits.splice(-pattern.lgSize, digits.length).join(""));
+    }
+    while (digits.length > pattern.gSize) {
+      groups.unshift(digits.splice(-pattern.gSize, digits.length).join(""));
+    }
+    if (digits.length) {
+      groups.unshift(digits.join(""));
+    }
+    formattedText = groups.join(getLocaleNumberSymbol(locale, groupSymbol));
+    if (decimals.length) {
+      formattedText += getLocaleNumberSymbol(locale, decimalSymbol) + decimals.join("");
+    }
+    if (exponent) {
+      formattedText += getLocaleNumberSymbol(locale, NumberSymbol.Exponential) + "+" + exponent;
+    }
+  }
+  if (value < 0 && !isZero) {
+    formattedText = pattern.negPre + formattedText + pattern.negSuf;
+  } else {
+    formattedText = pattern.posPre + formattedText + pattern.posSuf;
+  }
+  return formattedText;
+}
+function formatCurrency(value, locale, currency, currencyCode, digitsInfo) {
+  const format = getLocaleNumberFormat(locale, NumberFormatStyle.Currency);
+  const pattern = parseNumberFormat(format, getLocaleNumberSymbol(locale, NumberSymbol.MinusSign));
+  pattern.minFrac = getNumberOfCurrencyDigits(currencyCode);
+  pattern.maxFrac = pattern.minFrac;
+  const res = formatNumberToLocaleString(value, pattern, locale, NumberSymbol.CurrencyGroup, NumberSymbol.CurrencyDecimal, digitsInfo);
+  return res.replace(CURRENCY_CHAR, currency).replace(CURRENCY_CHAR, "").trim();
+}
+function formatPercent(value, locale, digitsInfo) {
+  const format = getLocaleNumberFormat(locale, NumberFormatStyle.Percent);
+  const pattern = parseNumberFormat(format, getLocaleNumberSymbol(locale, NumberSymbol.MinusSign));
+  const res = formatNumberToLocaleString(value, pattern, locale, NumberSymbol.Group, NumberSymbol.Decimal, digitsInfo, true);
+  return res.replace(new RegExp(PERCENT_CHAR, "g"), getLocaleNumberSymbol(locale, NumberSymbol.PercentSign));
+}
+function formatNumber(value, locale, digitsInfo) {
+  const format = getLocaleNumberFormat(locale, NumberFormatStyle.Decimal);
+  const pattern = parseNumberFormat(format, getLocaleNumberSymbol(locale, NumberSymbol.MinusSign));
+  return formatNumberToLocaleString(value, pattern, locale, NumberSymbol.Group, NumberSymbol.Decimal, digitsInfo);
+}
+function parseNumberFormat(format, minusSign = "-") {
+  const p = {
+    minInt: 1,
+    minFrac: 0,
+    maxFrac: 0,
+    posPre: "",
+    posSuf: "",
+    negPre: "",
+    negSuf: "",
+    gSize: 0,
+    lgSize: 0
+  };
+  const patternParts = format.split(PATTERN_SEP);
+  const positive = patternParts[0];
+  const negative = patternParts[1];
+  const positiveParts = positive.indexOf(DECIMAL_SEP) !== -1 ? positive.split(DECIMAL_SEP) : [positive.substring(0, positive.lastIndexOf(ZERO_CHAR) + 1), positive.substring(positive.lastIndexOf(ZERO_CHAR) + 1)], integer = positiveParts[0], fraction = positiveParts[1] || "";
+  p.posPre = integer.substring(0, integer.indexOf(DIGIT_CHAR));
+  for (let i = 0; i < fraction.length; i++) {
+    const ch = fraction.charAt(i);
+    if (ch === ZERO_CHAR) {
+      p.minFrac = p.maxFrac = i + 1;
+    } else if (ch === DIGIT_CHAR) {
+      p.maxFrac = i + 1;
+    } else {
+      p.posSuf += ch;
+    }
+  }
+  const groups = integer.split(GROUP_SEP);
+  p.gSize = groups[1] ? groups[1].length : 0;
+  p.lgSize = groups[2] || groups[1] ? (groups[2] || groups[1]).length : 0;
+  if (negative) {
+    const trunkLen = positive.length - p.posPre.length - p.posSuf.length, pos = negative.indexOf(DIGIT_CHAR);
+    p.negPre = negative.substring(0, pos).replace(/'/g, "");
+    p.negSuf = negative.slice(pos + trunkLen).replace(/'/g, "");
+  } else {
+    p.negPre = minusSign + p.posPre;
+    p.negSuf = p.posSuf;
+  }
+  return p;
+}
+function toPercent(parsedNumber) {
+  if (parsedNumber.digits[0] === 0) {
+    return parsedNumber;
+  }
+  const fractionLen = parsedNumber.digits.length - parsedNumber.integerLen;
+  if (parsedNumber.exponent) {
+    parsedNumber.exponent += 2;
+  } else {
+    if (fractionLen === 0) {
+      parsedNumber.digits.push(0, 0);
+    } else if (fractionLen === 1) {
+      parsedNumber.digits.push(0);
+    }
+    parsedNumber.integerLen += 2;
+  }
+  return parsedNumber;
+}
+function parseNumber(num) {
+  let numStr = Math.abs(num) + "";
+  let exponent = 0, digits, integerLen;
+  let i, j, zeros;
+  if ((integerLen = numStr.indexOf(DECIMAL_SEP)) > -1) {
+    numStr = numStr.replace(DECIMAL_SEP, "");
+  }
+  if ((i = numStr.search(/e/i)) > 0) {
+    if (integerLen < 0) integerLen = i;
+    integerLen += +numStr.slice(i + 1);
+    numStr = numStr.substring(0, i);
+  } else if (integerLen < 0) {
+    integerLen = numStr.length;
+  }
+  for (i = 0; numStr.charAt(i) === ZERO_CHAR; i++) {
+  }
+  if (i === (zeros = numStr.length)) {
+    digits = [0];
+    integerLen = 1;
+  } else {
+    zeros--;
+    while (numStr.charAt(zeros) === ZERO_CHAR) zeros--;
+    integerLen -= i;
+    digits = [];
+    for (j = 0; i <= zeros; i++, j++) {
+      digits[j] = Number(numStr.charAt(i));
+    }
+  }
+  if (integerLen > MAX_DIGITS) {
+    digits = digits.splice(0, MAX_DIGITS - 1);
+    exponent = integerLen - 1;
+    integerLen = 1;
+  }
+  return {
+    digits,
+    exponent,
+    integerLen
+  };
+}
+function roundNumber(parsedNumber, minFrac, maxFrac) {
+  if (minFrac > maxFrac) {
+    throw new RuntimeError(2307, ngDevMode && `The minimum number of digits after fraction (${minFrac}) is higher than the maximum (${maxFrac}).`);
+  }
+  let digits = parsedNumber.digits;
+  let fractionLen = digits.length - parsedNumber.integerLen;
+  const fractionSize = Math.min(Math.max(minFrac, fractionLen), maxFrac);
+  let roundAt = fractionSize + parsedNumber.integerLen;
+  let digit = digits[roundAt];
+  if (roundAt > 0) {
+    digits.splice(Math.max(parsedNumber.integerLen, roundAt));
+    for (let j = roundAt; j < digits.length; j++) {
+      digits[j] = 0;
+    }
+  } else {
+    fractionLen = Math.max(0, fractionLen);
+    parsedNumber.integerLen = 1;
+    digits.length = Math.max(1, roundAt = fractionSize + 1);
+    digits[0] = 0;
+    for (let i = 1; i < roundAt; i++) digits[i] = 0;
+  }
+  if (digit >= 5) {
+    if (roundAt - 1 < 0) {
+      for (let k = 0; k > roundAt; k--) {
+        digits.unshift(0);
+        parsedNumber.integerLen++;
+      }
+      digits.unshift(1);
+      parsedNumber.integerLen++;
+    } else {
+      digits[roundAt - 1]++;
+    }
+  }
+  for (; fractionLen < Math.max(0, fractionSize); fractionLen++) digits.push(0);
+  let dropTrailingZeros = fractionSize !== 0;
+  const minLen = minFrac + parsedNumber.integerLen;
+  const carry = digits.reduceRight(function(carry2, d, i, digits2) {
+    d = d + carry2;
+    digits2[i] = d < 10 ? d : d - 10;
+    if (dropTrailingZeros) {
+      if (digits2[i] === 0 && i >= minLen) {
+        digits2.pop();
+      } else {
+        dropTrailingZeros = false;
+      }
+    }
+    return d >= 10 ? 1 : 0;
+  }, 0);
+  if (carry) {
+    digits.unshift(carry);
+    parsedNumber.integerLen++;
+  }
+}
+function parseIntAutoRadix(text) {
+  const result = parseInt(text);
+  if (isNaN(result)) {
+    throw new RuntimeError(2305, ngDevMode && "Invalid integer literal when parsing " + text);
+  }
+  return result;
+}
+var NgLocalization = class _NgLocalization {
+  static \u0275fac = function NgLocalization_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _NgLocalization)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _NgLocalization,
+    factory: () => (() => new NgLocaleLocalization(inject2(LOCALE_ID)))(),
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgLocalization, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root",
+      useFactory: () => new NgLocaleLocalization(inject2(LOCALE_ID))
+    }]
+  }], null, null);
+})();
+function getPluralCategory(value, cases, ngLocalization, locale) {
+  let key = `=${value}`;
+  if (cases.indexOf(key) > -1) {
+    return key;
+  }
+  key = ngLocalization.getPluralCategory(value, locale);
+  if (cases.indexOf(key) > -1) {
+    return key;
+  }
+  if (cases.indexOf("other") > -1) {
+    return "other";
+  }
+  throw new RuntimeError(2308, ngDevMode && `No plural message found for value "${value}"`);
+}
+var NgLocaleLocalization = class _NgLocaleLocalization extends NgLocalization {
+  locale;
+  constructor(locale) {
+    super();
+    this.locale = locale;
+  }
+  getPluralCategory(value, locale) {
+    const plural2 = getLocalePluralCase2(locale || this.locale)(value);
+    switch (plural2) {
+      case Plural.Zero:
+        return "zero";
+      case Plural.One:
+        return "one";
+      case Plural.Two:
+        return "two";
+      case Plural.Few:
+        return "few";
+      case Plural.Many:
+        return "many";
+      default:
+        return "other";
+    }
+  }
+  static \u0275fac = function NgLocaleLocalization_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _NgLocaleLocalization)(\u0275\u0275inject(LOCALE_ID));
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _NgLocaleLocalization,
+    factory: _NgLocaleLocalization.\u0275fac
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgLocaleLocalization, [{
+    type: Injectable
+  }], () => [{
+    type: void 0,
+    decorators: [{
+      type: Inject,
+      args: [LOCALE_ID]
+    }]
+  }], null);
+})();
+var WS_REGEXP = /\s+/;
+var EMPTY_ARRAY2 = [];
+var NgClass = class _NgClass {
+  _ngEl;
+  _renderer;
+  initialClasses = EMPTY_ARRAY2;
+  rawClass;
+  stateMap = /* @__PURE__ */ new Map();
+  constructor(_ngEl, _renderer) {
+    this._ngEl = _ngEl;
+    this._renderer = _renderer;
+  }
+  set klass(value) {
+    this.initialClasses = value != null ? value.trim().split(WS_REGEXP) : EMPTY_ARRAY2;
+  }
+  set ngClass(value) {
+    this.rawClass = typeof value === "string" ? value.trim().split(WS_REGEXP) : value;
+  }
+  ngDoCheck() {
+    for (const klass of this.initialClasses) {
+      this._updateState(klass, true);
+    }
+    const rawClass = this.rawClass;
+    if (Array.isArray(rawClass) || rawClass instanceof Set) {
+      for (const klass of rawClass) {
+        this._updateState(klass, true);
+      }
+    } else if (rawClass != null) {
+      for (const klass of Object.keys(rawClass)) {
+        this._updateState(klass, Boolean(rawClass[klass]));
+      }
+    }
+    this._applyStateDiff();
+  }
+  _updateState(klass, nextEnabled) {
+    const state = this.stateMap.get(klass);
+    if (state !== void 0) {
+      if (state.enabled !== nextEnabled) {
+        state.changed = true;
+        state.enabled = nextEnabled;
+      }
+      state.touched = true;
+    } else {
+      this.stateMap.set(klass, {
+        enabled: nextEnabled,
+        changed: true,
+        touched: true
+      });
+    }
+  }
+  _applyStateDiff() {
+    for (const stateEntry of this.stateMap) {
+      const klass = stateEntry[0];
+      const state = stateEntry[1];
+      if (state.changed) {
+        this._toggleClass(klass, state.enabled);
+        state.changed = false;
+      } else if (!state.touched) {
+        if (state.enabled) {
+          this._toggleClass(klass, false);
+        }
+        this.stateMap.delete(klass);
+      }
+      state.touched = false;
+    }
+  }
+  _toggleClass(klass, enabled) {
+    if (ngDevMode) {
+      if (typeof klass !== "string") {
+        throw new Error(`NgClass can only toggle CSS classes expressed as strings, got ${stringify(klass)}`);
+      }
+    }
+    klass = klass.trim();
+    if (klass.length > 0) {
+      klass.split(WS_REGEXP).forEach((klass2) => {
+        if (enabled) {
+          this._renderer.addClass(this._ngEl.nativeElement, klass2);
+        } else {
+          this._renderer.removeClass(this._ngEl.nativeElement, klass2);
+        }
+      });
+    }
+  }
+  static \u0275fac = function NgClass_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _NgClass)(\u0275\u0275directiveInject(ElementRef), \u0275\u0275directiveInject(Renderer2));
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _NgClass,
+    selectors: [["", "ngClass", ""]],
+    inputs: {
+      klass: [0, "class", "klass"],
+      ngClass: "ngClass"
+    }
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgClass, [{
+    type: Directive,
+    args: [{
+      selector: "[ngClass]"
+    }]
+  }], () => [{
+    type: ElementRef
+  }, {
+    type: Renderer2
+  }], {
+    klass: [{
+      type: Input,
+      args: ["class"]
+    }],
+    ngClass: [{
+      type: Input,
+      args: ["ngClass"]
+    }]
+  });
+})();
+var NgComponentOutlet = class _NgComponentOutlet {
+  _viewContainerRef;
+  ngComponentOutlet = null;
+  ngComponentOutletInputs;
+  ngComponentOutletInjector;
+  ngComponentOutletEnvironmentInjector;
+  ngComponentOutletContent;
+  ngComponentOutletNgModule;
+  _componentRef;
+  _moduleRef;
+  _inputsUsed = /* @__PURE__ */ new Map();
+  get componentInstance() {
+    return this._componentRef?.instance ?? null;
+  }
+  constructor(_viewContainerRef) {
+    this._viewContainerRef = _viewContainerRef;
+  }
+  _needToReCreateNgModuleInstance(changes) {
+    return changes["ngComponentOutletNgModule"] !== void 0;
+  }
+  _needToReCreateComponentInstance(changes) {
+    return changes["ngComponentOutlet"] !== void 0 || changes["ngComponentOutletContent"] !== void 0 || changes["ngComponentOutletInjector"] !== void 0 || changes["ngComponentOutletEnvironmentInjector"] !== void 0 || this._needToReCreateNgModuleInstance(changes);
+  }
+  ngOnChanges(changes) {
+    if (this._needToReCreateComponentInstance(changes)) {
+      this._viewContainerRef.clear();
+      this._inputsUsed.clear();
+      this._componentRef = void 0;
+      if (this.ngComponentOutlet) {
+        const injector = this.ngComponentOutletInjector || this._viewContainerRef.parentInjector;
+        if (this._needToReCreateNgModuleInstance(changes)) {
+          this._moduleRef?.destroy();
+          if (this.ngComponentOutletNgModule) {
+            this._moduleRef = createNgModule(this.ngComponentOutletNgModule, getParentInjector(injector));
+          } else {
+            this._moduleRef = void 0;
+          }
+        }
+        this._componentRef = this._viewContainerRef.createComponent(this.ngComponentOutlet, {
+          injector,
+          ngModuleRef: this._moduleRef,
+          projectableNodes: this.ngComponentOutletContent,
+          environmentInjector: this.ngComponentOutletEnvironmentInjector
+        });
+      }
+    }
+  }
+  ngDoCheck() {
+    if (this._componentRef) {
+      if (this.ngComponentOutletInputs) {
+        for (const inputName of Object.keys(this.ngComponentOutletInputs)) {
+          this._inputsUsed.set(inputName, true);
+        }
+      }
+      this._applyInputStateDiff(this._componentRef);
+    }
+  }
+  ngOnDestroy() {
+    this._moduleRef?.destroy();
+  }
+  _applyInputStateDiff(componentRef) {
+    for (const [inputName, touched] of this._inputsUsed) {
+      if (!touched) {
+        componentRef.setInput(inputName, void 0);
+        this._inputsUsed.delete(inputName);
+      } else {
+        componentRef.setInput(inputName, this.ngComponentOutletInputs[inputName]);
+        this._inputsUsed.set(inputName, false);
+      }
+    }
+  }
+  static \u0275fac = function NgComponentOutlet_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _NgComponentOutlet)(\u0275\u0275directiveInject(ViewContainerRef));
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _NgComponentOutlet,
+    selectors: [["", "ngComponentOutlet", ""]],
+    inputs: {
+      ngComponentOutlet: "ngComponentOutlet",
+      ngComponentOutletInputs: "ngComponentOutletInputs",
+      ngComponentOutletInjector: "ngComponentOutletInjector",
+      ngComponentOutletEnvironmentInjector: "ngComponentOutletEnvironmentInjector",
+      ngComponentOutletContent: "ngComponentOutletContent",
+      ngComponentOutletNgModule: "ngComponentOutletNgModule"
+    },
+    exportAs: ["ngComponentOutlet"],
+    features: [\u0275\u0275NgOnChangesFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgComponentOutlet, [{
+    type: Directive,
+    args: [{
+      selector: "[ngComponentOutlet]",
+      exportAs: "ngComponentOutlet"
+    }]
+  }], () => [{
+    type: ViewContainerRef
+  }], {
+    ngComponentOutlet: [{
+      type: Input
+    }],
+    ngComponentOutletInputs: [{
+      type: Input
+    }],
+    ngComponentOutletInjector: [{
+      type: Input
+    }],
+    ngComponentOutletEnvironmentInjector: [{
+      type: Input
+    }],
+    ngComponentOutletContent: [{
+      type: Input
+    }],
+    ngComponentOutletNgModule: [{
+      type: Input
+    }]
+  });
+})();
+function getParentInjector(injector) {
+  const parentNgModule = injector.get(NgModuleRef$1);
+  return parentNgModule.injector;
+}
+var NgForOfContext = class {
+  $implicit;
+  ngForOf;
+  index;
+  count;
+  constructor($implicit, ngForOf, index, count) {
+    this.$implicit = $implicit;
+    this.ngForOf = ngForOf;
+    this.index = index;
+    this.count = count;
+  }
+  get first() {
+    return this.index === 0;
+  }
+  get last() {
+    return this.index === this.count - 1;
+  }
+  get even() {
+    return this.index % 2 === 0;
+  }
+  get odd() {
+    return !this.even;
+  }
+};
+var NgForOf = class _NgForOf {
+  _viewContainer;
+  _template;
+  _differs;
+  set ngForOf(ngForOf) {
+    this._ngForOf = ngForOf;
+    this._ngForOfDirty = true;
+  }
+  set ngForTrackBy(fn) {
+    if ((typeof ngDevMode === "undefined" || ngDevMode) && fn != null && typeof fn !== "function") {
+      console.warn(`trackBy must be a function, but received ${JSON.stringify(fn)}. See https://angular.dev/api/common/NgForOf#change-propagation for more information.`);
+    }
+    this._trackByFn = fn;
+  }
+  get ngForTrackBy() {
+    return this._trackByFn;
+  }
+  _ngForOf = null;
+  _ngForOfDirty = true;
+  _differ = null;
+  _trackByFn;
+  constructor(_viewContainer, _template, _differs) {
+    this._viewContainer = _viewContainer;
+    this._template = _template;
+    this._differs = _differs;
+  }
+  set ngForTemplate(value) {
+    if (value) {
+      this._template = value;
+    }
+  }
+  ngDoCheck() {
+    if (this._ngForOfDirty) {
+      this._ngForOfDirty = false;
+      const value = this._ngForOf;
+      if (!this._differ && value) {
+        if (typeof ngDevMode === "undefined" || ngDevMode) {
+          try {
+            this._differ = this._differs.find(value).create(this.ngForTrackBy);
+          } catch {
+            let errorMessage = `Cannot find a differ supporting object '${value}' of type '${getTypeName(value)}'. NgFor only supports binding to Iterables, such as Arrays.`;
+            if (typeof value === "object") {
+              errorMessage += " Did you mean to use the keyvalue pipe?";
+            }
+            throw new RuntimeError(-2200, errorMessage);
+          }
+        } else {
+          this._differ = this._differs.find(value).create(this.ngForTrackBy);
+        }
+      }
+    }
+    if (this._differ) {
+      const changes = this._differ.diff(this._ngForOf);
+      if (changes) this._applyChanges(changes);
+    }
+  }
+  _applyChanges(changes) {
+    const viewContainer = this._viewContainer;
+    changes.forEachOperation((item, adjustedPreviousIndex, currentIndex) => {
+      if (item.previousIndex == null) {
+        viewContainer.createEmbeddedView(this._template, new NgForOfContext(item.item, this._ngForOf, -1, -1), currentIndex === null ? void 0 : currentIndex);
+      } else if (currentIndex == null) {
+        viewContainer.remove(adjustedPreviousIndex === null ? void 0 : adjustedPreviousIndex);
+      } else if (adjustedPreviousIndex !== null) {
+        const view = viewContainer.get(adjustedPreviousIndex);
+        viewContainer.move(view, currentIndex);
+        applyViewChange(view, item);
+      }
+    });
+    for (let i = 0, ilen = viewContainer.length; i < ilen; i++) {
+      const viewRef = viewContainer.get(i);
+      const context2 = viewRef.context;
+      context2.index = i;
+      context2.count = ilen;
+      context2.ngForOf = this._ngForOf;
+    }
+    changes.forEachIdentityChange((record) => {
+      const viewRef = viewContainer.get(record.currentIndex);
+      applyViewChange(viewRef, record);
+    });
+  }
+  static ngTemplateContextGuard(dir, ctx) {
+    return true;
+  }
+  static \u0275fac = function NgForOf_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _NgForOf)(\u0275\u0275directiveInject(ViewContainerRef), \u0275\u0275directiveInject(TemplateRef), \u0275\u0275directiveInject(IterableDiffers));
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _NgForOf,
+    selectors: [["", "ngFor", "", "ngForOf", ""]],
+    inputs: {
+      ngForOf: "ngForOf",
+      ngForTrackBy: "ngForTrackBy",
+      ngForTemplate: "ngForTemplate"
+    }
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgForOf, [{
+    type: Directive,
+    args: [{
+      selector: "[ngFor][ngForOf]"
+    }]
+  }], () => [{
+    type: ViewContainerRef
+  }, {
+    type: TemplateRef
+  }, {
+    type: IterableDiffers
+  }], {
+    ngForOf: [{
+      type: Input
+    }],
+    ngForTrackBy: [{
+      type: Input
+    }],
+    ngForTemplate: [{
+      type: Input
+    }]
+  });
+})();
+function applyViewChange(view, record) {
+  view.context.$implicit = record.item;
+}
+function getTypeName(type) {
+  return type["name"] || typeof type;
+}
+var NgIf = class _NgIf {
+  _viewContainer;
+  _context = new NgIfContext();
+  _thenTemplateRef = null;
+  _elseTemplateRef = null;
+  _thenViewRef = null;
+  _elseViewRef = null;
+  constructor(_viewContainer, templateRef) {
+    this._viewContainer = _viewContainer;
+    this._thenTemplateRef = templateRef;
+  }
+  set ngIf(condition) {
+    this._context.$implicit = this._context.ngIf = condition;
+    this._updateView();
+  }
+  set ngIfThen(templateRef) {
+    assertTemplate(templateRef, (typeof ngDevMode === "undefined" || ngDevMode) && "ngIfThen");
+    this._thenTemplateRef = templateRef;
+    this._thenViewRef = null;
+    this._updateView();
+  }
+  set ngIfElse(templateRef) {
+    assertTemplate(templateRef, (typeof ngDevMode === "undefined" || ngDevMode) && "ngIfElse");
+    this._elseTemplateRef = templateRef;
+    this._elseViewRef = null;
+    this._updateView();
+  }
+  _updateView() {
+    if (this._context.$implicit) {
+      if (!this._thenViewRef) {
+        this._viewContainer.clear();
+        this._elseViewRef = null;
+        if (this._thenTemplateRef) {
+          this._thenViewRef = this._viewContainer.createEmbeddedView(this._thenTemplateRef, this._context);
+        }
+      }
+    } else {
+      if (!this._elseViewRef) {
+        this._viewContainer.clear();
+        this._thenViewRef = null;
+        if (this._elseTemplateRef) {
+          this._elseViewRef = this._viewContainer.createEmbeddedView(this._elseTemplateRef, this._context);
+        }
+      }
+    }
+  }
+  static ngIfUseIfTypeGuard;
+  static ngTemplateGuard_ngIf;
+  static ngTemplateContextGuard(dir, ctx) {
+    return true;
+  }
+  static \u0275fac = function NgIf_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _NgIf)(\u0275\u0275directiveInject(ViewContainerRef), \u0275\u0275directiveInject(TemplateRef));
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _NgIf,
+    selectors: [["", "ngIf", ""]],
+    inputs: {
+      ngIf: "ngIf",
+      ngIfThen: "ngIfThen",
+      ngIfElse: "ngIfElse"
+    }
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgIf, [{
+    type: Directive,
+    args: [{
+      selector: "[ngIf]"
+    }]
+  }], () => [{
+    type: ViewContainerRef
+  }, {
+    type: TemplateRef
+  }], {
+    ngIf: [{
+      type: Input
+    }],
+    ngIfThen: [{
+      type: Input
+    }],
+    ngIfElse: [{
+      type: Input
+    }]
+  });
+})();
+var NgIfContext = class {
+  $implicit = null;
+  ngIf = null;
+};
+function assertTemplate(templateRef, property) {
+  if (templateRef && !templateRef.createEmbeddedView) {
+    throw new RuntimeError(2020, (typeof ngDevMode === "undefined" || ngDevMode) && `${property} must be a TemplateRef, but received '${stringify(templateRef)}'.`);
+  }
+}
+var SwitchView = class {
+  _viewContainerRef;
+  _templateRef;
+  _created = false;
+  constructor(_viewContainerRef, _templateRef) {
+    this._viewContainerRef = _viewContainerRef;
+    this._templateRef = _templateRef;
+  }
+  create() {
+    this._created = true;
+    this._viewContainerRef.createEmbeddedView(this._templateRef);
+  }
+  destroy() {
+    this._created = false;
+    this._viewContainerRef.clear();
+  }
+  enforceState(created) {
+    if (created && !this._created) {
+      this.create();
+    } else if (!created && this._created) {
+      this.destroy();
+    }
+  }
+};
+var NgSwitch = class _NgSwitch {
+  _defaultViews = [];
+  _defaultUsed = false;
+  _caseCount = 0;
+  _lastCaseCheckIndex = 0;
+  _lastCasesMatched = false;
+  _ngSwitch;
+  set ngSwitch(newValue) {
+    this._ngSwitch = newValue;
+    if (this._caseCount === 0) {
+      this._updateDefaultCases(true);
+    }
+  }
+  _addCase() {
+    return this._caseCount++;
+  }
+  _addDefault(view) {
+    this._defaultViews.push(view);
+  }
+  _matchCase(value) {
+    const matched = value === this._ngSwitch;
+    this._lastCasesMatched ||= matched;
+    this._lastCaseCheckIndex++;
+    if (this._lastCaseCheckIndex === this._caseCount) {
+      this._updateDefaultCases(!this._lastCasesMatched);
+      this._lastCaseCheckIndex = 0;
+      this._lastCasesMatched = false;
+    }
+    return matched;
+  }
+  _updateDefaultCases(useDefault) {
+    if (this._defaultViews.length > 0 && useDefault !== this._defaultUsed) {
+      this._defaultUsed = useDefault;
+      for (const defaultView of this._defaultViews) {
+        defaultView.enforceState(useDefault);
+      }
+    }
+  }
+  static \u0275fac = function NgSwitch_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _NgSwitch)();
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _NgSwitch,
+    selectors: [["", "ngSwitch", ""]],
+    inputs: {
+      ngSwitch: "ngSwitch"
+    }
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgSwitch, [{
+    type: Directive,
+    args: [{
+      selector: "[ngSwitch]"
+    }]
+  }], null, {
+    ngSwitch: [{
+      type: Input
+    }]
+  });
+})();
+var NgSwitchCase = class _NgSwitchCase {
+  ngSwitch;
+  _view;
+  ngSwitchCase;
+  constructor(viewContainer, templateRef, ngSwitch) {
+    this.ngSwitch = ngSwitch;
+    if ((typeof ngDevMode === "undefined" || ngDevMode) && !ngSwitch) {
+      throwNgSwitchProviderNotFoundError("ngSwitchCase", "NgSwitchCase");
+    }
+    ngSwitch._addCase();
+    this._view = new SwitchView(viewContainer, templateRef);
+  }
+  ngDoCheck() {
+    this._view.enforceState(this.ngSwitch._matchCase(this.ngSwitchCase));
+  }
+  static \u0275fac = function NgSwitchCase_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _NgSwitchCase)(\u0275\u0275directiveInject(ViewContainerRef), \u0275\u0275directiveInject(TemplateRef), \u0275\u0275directiveInject(NgSwitch, 9));
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _NgSwitchCase,
+    selectors: [["", "ngSwitchCase", ""]],
+    inputs: {
+      ngSwitchCase: "ngSwitchCase"
+    }
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgSwitchCase, [{
+    type: Directive,
+    args: [{
+      selector: "[ngSwitchCase]"
+    }]
+  }], () => [{
+    type: ViewContainerRef
+  }, {
+    type: TemplateRef
+  }, {
+    type: NgSwitch,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Host
+    }]
+  }], {
+    ngSwitchCase: [{
+      type: Input
+    }]
+  });
+})();
+var NgSwitchDefault = class _NgSwitchDefault {
+  constructor(viewContainer, templateRef, ngSwitch) {
+    if ((typeof ngDevMode === "undefined" || ngDevMode) && !ngSwitch) {
+      throwNgSwitchProviderNotFoundError("ngSwitchDefault", "NgSwitchDefault");
+    }
+    ngSwitch._addDefault(new SwitchView(viewContainer, templateRef));
+  }
+  static \u0275fac = function NgSwitchDefault_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _NgSwitchDefault)(\u0275\u0275directiveInject(ViewContainerRef), \u0275\u0275directiveInject(TemplateRef), \u0275\u0275directiveInject(NgSwitch, 9));
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _NgSwitchDefault,
+    selectors: [["", "ngSwitchDefault", ""]]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgSwitchDefault, [{
+    type: Directive,
+    args: [{
+      selector: "[ngSwitchDefault]"
+    }]
+  }], () => [{
+    type: ViewContainerRef
+  }, {
+    type: TemplateRef
+  }, {
+    type: NgSwitch,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Host
+    }]
+  }], null);
+})();
+function throwNgSwitchProviderNotFoundError(attrName, directiveName) {
+  throw new RuntimeError(2e3, `An element with the "${attrName}" attribute (matching the "${directiveName}" directive) must be located inside an element with the "ngSwitch" attribute (matching "NgSwitch" directive)`);
+}
+var NgPlural = class _NgPlural {
+  _localization;
+  _activeView;
+  _caseViews = {};
+  constructor(_localization) {
+    this._localization = _localization;
+  }
+  set ngPlural(value) {
+    this._updateView(value);
+  }
+  addCase(value, switchView) {
+    this._caseViews[value] = switchView;
+  }
+  _updateView(switchValue) {
+    this._clearViews();
+    const cases = Object.keys(this._caseViews);
+    const key = getPluralCategory(switchValue, cases, this._localization);
+    this._activateView(this._caseViews[key]);
+  }
+  _clearViews() {
+    if (this._activeView) this._activeView.destroy();
+  }
+  _activateView(view) {
+    if (view) {
+      this._activeView = view;
+      this._activeView.create();
+    }
+  }
+  static \u0275fac = function NgPlural_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _NgPlural)(\u0275\u0275directiveInject(NgLocalization));
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _NgPlural,
+    selectors: [["", "ngPlural", ""]],
+    inputs: {
+      ngPlural: "ngPlural"
+    }
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgPlural, [{
+    type: Directive,
+    args: [{
+      selector: "[ngPlural]"
+    }]
+  }], () => [{
+    type: NgLocalization
+  }], {
+    ngPlural: [{
+      type: Input
+    }]
+  });
+})();
+var NgPluralCase = class _NgPluralCase {
+  value;
+  constructor(value, template, viewContainer, ngPlural) {
+    this.value = value;
+    const isANumber = !isNaN(Number(value));
+    ngPlural.addCase(isANumber ? `=${value}` : value, new SwitchView(viewContainer, template));
+  }
+  static \u0275fac = function NgPluralCase_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _NgPluralCase)(\u0275\u0275injectAttribute("ngPluralCase"), \u0275\u0275directiveInject(TemplateRef), \u0275\u0275directiveInject(ViewContainerRef), \u0275\u0275directiveInject(NgPlural, 1));
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _NgPluralCase,
+    selectors: [["", "ngPluralCase", ""]]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgPluralCase, [{
+    type: Directive,
+    args: [{
+      selector: "[ngPluralCase]"
+    }]
+  }], () => [{
+    type: void 0,
+    decorators: [{
+      type: Attribute,
+      args: ["ngPluralCase"]
+    }]
+  }, {
+    type: TemplateRef
+  }, {
+    type: ViewContainerRef
+  }, {
+    type: NgPlural,
+    decorators: [{
+      type: Host
+    }]
+  }], null);
+})();
+var NgStyle = class _NgStyle {
+  _ngEl;
+  _differs;
+  _renderer;
+  _ngStyle = null;
+  _differ = null;
+  constructor(_ngEl, _differs, _renderer) {
+    this._ngEl = _ngEl;
+    this._differs = _differs;
+    this._renderer = _renderer;
+  }
+  set ngStyle(values) {
+    this._ngStyle = values;
+    if (!this._differ && values) {
+      this._differ = this._differs.find(values).create();
+    }
+  }
+  ngDoCheck() {
+    if (this._differ) {
+      const changes = this._differ.diff(this._ngStyle);
+      if (changes) {
+        this._applyChanges(changes);
+      }
+    }
+  }
+  _setStyle(nameAndUnit, value) {
+    const [name, unit] = nameAndUnit.split(".");
+    const flags = name.indexOf("-") === -1 ? void 0 : RendererStyleFlags2.DashCase;
+    if (value != null) {
+      this._renderer.setStyle(this._ngEl.nativeElement, name, unit ? `${value}${unit}` : value, flags);
+    } else {
+      this._renderer.removeStyle(this._ngEl.nativeElement, name, flags);
+    }
+  }
+  _applyChanges(changes) {
+    changes.forEachRemovedItem((record) => this._setStyle(record.key, null));
+    changes.forEachAddedItem((record) => this._setStyle(record.key, record.currentValue));
+    changes.forEachChangedItem((record) => this._setStyle(record.key, record.currentValue));
+  }
+  static \u0275fac = function NgStyle_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _NgStyle)(\u0275\u0275directiveInject(ElementRef), \u0275\u0275directiveInject(KeyValueDiffers), \u0275\u0275directiveInject(Renderer2));
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _NgStyle,
+    selectors: [["", "ngStyle", ""]],
+    inputs: {
+      ngStyle: "ngStyle"
+    }
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgStyle, [{
+    type: Directive,
+    args: [{
+      selector: "[ngStyle]"
+    }]
+  }], () => [{
+    type: ElementRef
+  }, {
+    type: KeyValueDiffers
+  }, {
+    type: Renderer2
+  }], {
+    ngStyle: [{
+      type: Input,
+      args: ["ngStyle"]
+    }]
+  });
+})();
+var NgTemplateOutlet = class _NgTemplateOutlet {
+  _viewContainerRef;
+  _viewRef = null;
+  ngTemplateOutletContext = null;
+  ngTemplateOutlet = null;
+  ngTemplateOutletInjector = null;
+  injector = inject2(Injector);
+  constructor(_viewContainerRef) {
+    this._viewContainerRef = _viewContainerRef;
+  }
+  ngOnChanges(changes) {
+    if (this._shouldRecreateView(changes)) {
+      const viewContainerRef = this._viewContainerRef;
+      if (this._viewRef) {
+        viewContainerRef.remove(viewContainerRef.indexOf(this._viewRef));
+      }
+      if (!this.ngTemplateOutlet) {
+        this._viewRef = null;
+        return;
+      }
+      const viewContext = this._createContextForwardProxy();
+      this._viewRef = viewContainerRef.createEmbeddedView(this.ngTemplateOutlet, viewContext, {
+        injector: this._getInjector()
+      });
+    }
+  }
+  _getInjector() {
+    if (this.ngTemplateOutletInjector === "outlet") {
+      return this.injector;
+    }
+    return this.ngTemplateOutletInjector ?? void 0;
+  }
+  _shouldRecreateView(changes) {
+    return !!changes["ngTemplateOutlet"] || !!changes["ngTemplateOutletInjector"];
+  }
+  _createContextForwardProxy() {
+    return new Proxy({}, {
+      set: (_target, prop, newValue) => {
+        if (!this.ngTemplateOutletContext) {
+          return false;
+        }
+        return Reflect.set(this.ngTemplateOutletContext, prop, newValue);
+      },
+      get: (_target, prop, receiver) => {
+        if (!this.ngTemplateOutletContext) {
+          return void 0;
+        }
+        return Reflect.get(this.ngTemplateOutletContext, prop, receiver);
+      }
+    });
+  }
+  static \u0275fac = function NgTemplateOutlet_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _NgTemplateOutlet)(\u0275\u0275directiveInject(ViewContainerRef));
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _NgTemplateOutlet,
+    selectors: [["", "ngTemplateOutlet", ""]],
+    inputs: {
+      ngTemplateOutletContext: "ngTemplateOutletContext",
+      ngTemplateOutlet: "ngTemplateOutlet",
+      ngTemplateOutletInjector: "ngTemplateOutletInjector"
+    },
+    features: [\u0275\u0275NgOnChangesFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgTemplateOutlet, [{
+    type: Directive,
+    args: [{
+      selector: "[ngTemplateOutlet]"
+    }]
+  }], () => [{
+    type: ViewContainerRef
+  }], {
+    ngTemplateOutletContext: [{
+      type: Input
+    }],
+    ngTemplateOutlet: [{
+      type: Input
+    }],
+    ngTemplateOutletInjector: [{
+      type: Input
+    }]
+  });
+})();
+var COMMON_DIRECTIVES = [NgClass, NgComponentOutlet, NgForOf, NgIf, NgTemplateOutlet, NgStyle, NgSwitch, NgSwitchCase, NgSwitchDefault, NgPlural, NgPluralCase];
+function invalidPipeArgumentError(type, value) {
+  return new RuntimeError(2100, ngDevMode && `InvalidPipeArgument: '${value}' for pipe '${stringify(type)}'`);
+}
+function warnIfSignal(pipeName, value) {
+  if (isSignal2(value)) {
+    console.warn(`The ${pipeName} does not unwrap signals. Received a signal with value:`, value());
+  }
+}
+var SubscribableStrategy = class {
+  createSubscription(async, updateLatestValue, onError) {
+    return untracked2(() => async.subscribe({
+      next: updateLatestValue,
+      error: onError
+    }));
+  }
+  dispose(subscription) {
+    untracked2(() => subscription.unsubscribe());
+  }
+};
+var PromiseStrategy = class {
+  createSubscription(async, updateLatestValue, onError) {
+    async.then((v) => updateLatestValue?.(v), (e) => onError?.(e));
+    return {
+      unsubscribe: () => {
+        updateLatestValue = null;
+        onError = null;
+      }
+    };
+  }
+  dispose(subscription) {
+    subscription.unsubscribe();
+  }
+};
+var _promiseStrategy = new PromiseStrategy();
+var _subscribableStrategy = new SubscribableStrategy();
+var AsyncPipe = class _AsyncPipe {
+  _ref;
+  _latestValue = null;
+  markForCheckOnValueUpdate = true;
+  _subscription = null;
+  _obj = null;
+  _strategy = null;
+  applicationErrorHandler = inject2(INTERNAL_APPLICATION_ERROR_HANDLER);
+  constructor(ref) {
+    this._ref = ref;
+  }
+  ngOnDestroy() {
+    if (this._subscription) {
+      this._dispose();
+    }
+    this._ref = null;
+  }
+  transform(obj) {
+    if (!this._obj) {
+      if (obj) {
+        try {
+          this.markForCheckOnValueUpdate = false;
+          this._subscribe(obj);
+        } finally {
+          this.markForCheckOnValueUpdate = true;
+        }
+      }
+      return this._latestValue;
+    }
+    if (obj !== this._obj) {
+      this._dispose();
+      return this.transform(obj);
+    }
+    return this._latestValue;
+  }
+  _subscribe(obj) {
+    this._obj = obj;
+    this._strategy = this._selectStrategy(obj);
+    this._subscription = this._strategy.createSubscription(obj, (value) => this._updateLatestValue(obj, value), (e) => this.applicationErrorHandler(e));
+  }
+  _selectStrategy(obj) {
+    if (isPromise2(obj)) {
+      return _promiseStrategy;
+    }
+    if (isSubscribable(obj)) {
+      return _subscribableStrategy;
+    }
+    throw invalidPipeArgumentError(_AsyncPipe, obj);
+  }
+  _dispose() {
+    this._strategy.dispose(this._subscription);
+    this._latestValue = null;
+    this._subscription = null;
+    this._obj = null;
+  }
+  _updateLatestValue(async, value) {
+    if (async === this._obj) {
+      this._latestValue = value;
+      if (this.markForCheckOnValueUpdate) {
+        this._ref?.markForCheck();
+      }
+    }
+  }
+  static \u0275fac = function AsyncPipe_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _AsyncPipe)(\u0275\u0275directiveInject(ChangeDetectorRef, 16));
+  };
+  static \u0275pipe = /* @__PURE__ */ \u0275\u0275definePipe({
+    name: "async",
+    type: _AsyncPipe,
+    pure: false
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(AsyncPipe, [{
+    type: Pipe,
+    args: [{
+      name: "async",
+      pure: false
+    }]
+  }], () => [{
+    type: ChangeDetectorRef
+  }], null);
+})();
+var LowerCasePipe = class _LowerCasePipe {
+  transform(value) {
+    if (value == null) return null;
+    assertPipeArgument(_LowerCasePipe, value);
+    return value.toLowerCase();
+  }
+  static \u0275fac = function LowerCasePipe_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _LowerCasePipe)();
+  };
+  static \u0275pipe = /* @__PURE__ */ \u0275\u0275definePipe({
+    name: "lowercase",
+    type: _LowerCasePipe,
+    pure: true
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(LowerCasePipe, [{
+    type: Pipe,
+    args: [{
+      name: "lowercase"
+    }]
+  }], null, null);
+})();
+var unicodeWordMatch = /(?:[0-9A-Za-z\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u05D0-\u05EA\u05EF-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u0870-\u0887\u0889-\u088E\u08A0-\u08C9\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C5D\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16F1-\u16F8\u1700-\u1711\u171F-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1878\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4C\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1C90-\u1CBA\u1CBD-\u1CBF\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2183\u2184\u2C00-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005\u3006\u3031-\u3035\u303B\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u31A0-\u31BF\u31F0-\u31FF\u3400-\u4DBF\u4E00-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6E5\uA717-\uA71F\uA722-\uA788\uA78B-\uA7CA\uA7D0\uA7D1\uA7D3\uA7D5-\uA7D9\uA7F2-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF2D-\uDF40\uDF42-\uDF49\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF]|\uD801[\uDC00-\uDC9D\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDD70-\uDD7A\uDD7C-\uDD8A\uDD8C-\uDD92\uDD94\uDD95\uDD97-\uDDA1\uDDA3-\uDDB1\uDDB3-\uDDB9\uDDBB\uDDBC\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67\uDF80-\uDF85\uDF87-\uDFB0\uDFB2-\uDFBA]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE35\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2\uDD00-\uDD23\uDE80-\uDEA9\uDEB0\uDEB1\uDF00-\uDF1C\uDF27\uDF30-\uDF45\uDF70-\uDF81\uDFB0-\uDFC4\uDFE0-\uDFF6]|\uD804[\uDC03-\uDC37\uDC71\uDC72\uDC75\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD44\uDD47\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC5F-\uDC61\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDEB8\uDF00-\uDF1A\uDF40-\uDF46]|\uD806[\uDC00-\uDC2B\uDCA0-\uDCDF\uDCFF-\uDD06\uDD09\uDD0C-\uDD13\uDD15\uDD16\uDD18-\uDD2F\uDD3F\uDD41\uDDA0-\uDDA7\uDDAA-\uDDD0\uDDE1\uDDE3\uDE00\uDE0B-\uDE32\uDE3A\uDE50\uDE5C-\uDE89\uDE9D\uDEB0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC72-\uDC8F\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD30\uDD46\uDD60-\uDD65\uDD67\uDD68\uDD6A-\uDD89\uDD98\uDEE0-\uDEF2\uDFB0]|\uD808[\uDC00-\uDF99]|\uD809[\uDC80-\uDD43]|\uD80B[\uDF90-\uDFF0]|[\uD80C\uD81C-\uD820\uD822\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879\uD880-\uD883][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE70-\uDEBE\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDE40-\uDE7F\uDF00-\uDF4A\uDF50\uDF93-\uDF9F\uDFE0\uDFE1\uDFE3]|\uD821[\uDC00-\uDFF7]|\uD823[\uDC00-\uDCD5\uDD00-\uDD08]|\uD82B[\uDFF0-\uDFF3\uDFF5-\uDFFB\uDFFD\uDFFE]|\uD82C[\uDC00-\uDD22\uDD50-\uDD52\uDD64-\uDD67\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD837[\uDF00-\uDF1E]|\uD838[\uDD00-\uDD2C\uDD37-\uDD3D\uDD4E\uDE90-\uDEAD\uDEC0-\uDEEB]|\uD839[\uDFE0-\uDFE6\uDFE8-\uDFEB\uDFED\uDFEE\uDFF0-\uDFFE]|\uD83A[\uDC00-\uDCC4\uDD00-\uDD43\uDD4B]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDEDF\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF38\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]|\uD884[\uDC00-\uDF4A])\S*/g;
+var TitleCasePipe = class _TitleCasePipe {
+  transform(value) {
+    if (value == null) return null;
+    assertPipeArgument(_TitleCasePipe, value);
+    return value.replace(unicodeWordMatch, (txt) => txt[0].toUpperCase() + txt.slice(1).toLowerCase());
+  }
+  static \u0275fac = function TitleCasePipe_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _TitleCasePipe)();
+  };
+  static \u0275pipe = /* @__PURE__ */ \u0275\u0275definePipe({
+    name: "titlecase",
+    type: _TitleCasePipe,
+    pure: true
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(TitleCasePipe, [{
+    type: Pipe,
+    args: [{
+      name: "titlecase"
+    }]
+  }], null, null);
+})();
+var UpperCasePipe = class _UpperCasePipe {
+  transform(value) {
+    if (value == null) return null;
+    assertPipeArgument(_UpperCasePipe, value);
+    return value.toUpperCase();
+  }
+  static \u0275fac = function UpperCasePipe_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _UpperCasePipe)();
+  };
+  static \u0275pipe = /* @__PURE__ */ \u0275\u0275definePipe({
+    name: "uppercase",
+    type: _UpperCasePipe,
+    pure: true
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(UpperCasePipe, [{
+    type: Pipe,
+    args: [{
+      name: "uppercase"
+    }]
+  }], null, null);
+})();
+function assertPipeArgument(pipe2, value) {
+  if (typeof value !== "string") {
+    throw invalidPipeArgumentError(pipe2, value);
+  }
+}
+var DEFAULT_DATE_FORMAT = "mediumDate";
+var DATE_PIPE_DEFAULT_TIMEZONE = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "DATE_PIPE_DEFAULT_TIMEZONE" : "");
+var DATE_PIPE_DEFAULT_OPTIONS = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "DATE_PIPE_DEFAULT_OPTIONS" : "");
+var DatePipe = class _DatePipe {
+  locale;
+  defaultTimezone;
+  defaultOptions;
+  constructor(locale, defaultTimezone, defaultOptions) {
+    this.locale = locale;
+    this.defaultTimezone = defaultTimezone;
+    this.defaultOptions = defaultOptions;
+  }
+  transform(value, format, timezone, locale) {
+    if (value == null || value === "" || value !== value) return null;
+    try {
+      const _format = format ?? this.defaultOptions?.dateFormat ?? DEFAULT_DATE_FORMAT;
+      const _timezone = timezone ?? this.defaultOptions?.timezone ?? this.defaultTimezone ?? void 0;
+      return formatDate(value, _format, locale || this.locale, _timezone);
+    } catch (error) {
+      throw invalidPipeArgumentError(_DatePipe, error.message);
+    }
+  }
+  static \u0275fac = function DatePipe_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _DatePipe)(\u0275\u0275directiveInject(LOCALE_ID, 16), \u0275\u0275directiveInject(DATE_PIPE_DEFAULT_TIMEZONE, 24), \u0275\u0275directiveInject(DATE_PIPE_DEFAULT_OPTIONS, 24));
+  };
+  static \u0275pipe = /* @__PURE__ */ \u0275\u0275definePipe({
+    name: "date",
+    type: _DatePipe,
+    pure: true
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DatePipe, [{
+    type: Pipe,
+    args: [{
+      name: "date"
+    }]
+  }], () => [{
+    type: void 0,
+    decorators: [{
+      type: Inject,
+      args: [LOCALE_ID]
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Inject,
+      args: [DATE_PIPE_DEFAULT_TIMEZONE]
+    }, {
+      type: Optional
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Inject,
+      args: [DATE_PIPE_DEFAULT_OPTIONS]
+    }, {
+      type: Optional
+    }]
+  }], null);
+})();
+var _INTERPOLATION_REGEXP = /#/g;
+var I18nPluralPipe = class _I18nPluralPipe {
+  _localization;
+  constructor(_localization) {
+    this._localization = _localization;
+  }
+  transform(value, pluralMap, locale) {
+    if (value == null) return "";
+    if (typeof pluralMap !== "object" || pluralMap === null) {
+      throw invalidPipeArgumentError(_I18nPluralPipe, pluralMap);
+    }
+    const key = getPluralCategory(value, Object.keys(pluralMap), this._localization, locale);
+    return pluralMap[key].replace(_INTERPOLATION_REGEXP, value.toString());
+  }
+  static \u0275fac = function I18nPluralPipe_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _I18nPluralPipe)(\u0275\u0275directiveInject(NgLocalization, 16));
+  };
+  static \u0275pipe = /* @__PURE__ */ \u0275\u0275definePipe({
+    name: "i18nPlural",
+    type: _I18nPluralPipe,
+    pure: true
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(I18nPluralPipe, [{
+    type: Pipe,
+    args: [{
+      name: "i18nPlural"
+    }]
+  }], () => [{
+    type: NgLocalization
+  }], null);
+})();
+var I18nSelectPipe = class _I18nSelectPipe {
+  transform(value, mapping) {
+    if (value == null) return "";
+    if (typeof mapping !== "object" || typeof value !== "string") {
+      throw invalidPipeArgumentError(_I18nSelectPipe, mapping);
+    }
+    if (mapping.hasOwnProperty(value)) {
+      return mapping[value];
+    }
+    if (mapping.hasOwnProperty("other")) {
+      return mapping["other"];
+    }
+    return "";
+  }
+  static \u0275fac = function I18nSelectPipe_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _I18nSelectPipe)();
+  };
+  static \u0275pipe = /* @__PURE__ */ \u0275\u0275definePipe({
+    name: "i18nSelect",
+    type: _I18nSelectPipe,
+    pure: true
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(I18nSelectPipe, [{
+    type: Pipe,
+    args: [{
+      name: "i18nSelect"
+    }]
+  }], null, null);
+})();
+var JsonPipe = class _JsonPipe {
+  transform(value) {
+    ngDevMode && warnIfSignal("JsonPipe", value);
+    return JSON.stringify(value, null, 2);
+  }
+  static \u0275fac = function JsonPipe_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _JsonPipe)();
+  };
+  static \u0275pipe = /* @__PURE__ */ \u0275\u0275definePipe({
+    name: "json",
+    type: _JsonPipe,
+    pure: false
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(JsonPipe, [{
+    type: Pipe,
+    args: [{
+      name: "json",
+      pure: false
+    }]
+  }], null, null);
+})();
+function makeKeyValuePair(key, value) {
+  return {
+    key,
+    value
+  };
+}
+var KeyValuePipe = class _KeyValuePipe {
+  differs;
+  constructor(differs) {
+    this.differs = differs;
+  }
+  differ;
+  keyValues = [];
+  compareFn = defaultComparator;
+  transform(input2, compareFn = defaultComparator) {
+    ngDevMode && warnIfSignal("KeyValuePipe", input2);
+    if (!input2 || !(input2 instanceof Map) && typeof input2 !== "object") {
+      return null;
+    }
+    this.differ ??= this.differs.find(input2).create();
+    const differChanges = this.differ.diff(input2);
+    const compareFnChanged = compareFn !== this.compareFn;
+    if (differChanges) {
+      this.keyValues = [];
+      differChanges.forEachItem((r) => {
+        this.keyValues.push(makeKeyValuePair(r.key, r.currentValue));
+      });
+    }
+    if (differChanges || compareFnChanged) {
+      if (compareFn) {
+        this.keyValues.sort(compareFn);
+      }
+      this.compareFn = compareFn;
+    }
+    return this.keyValues;
+  }
+  static \u0275fac = function KeyValuePipe_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _KeyValuePipe)(\u0275\u0275directiveInject(KeyValueDiffers, 16));
+  };
+  static \u0275pipe = /* @__PURE__ */ \u0275\u0275definePipe({
+    name: "keyvalue",
+    type: _KeyValuePipe,
+    pure: false
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(KeyValuePipe, [{
+    type: Pipe,
+    args: [{
+      name: "keyvalue",
+      pure: false
+    }]
+  }], () => [{
+    type: KeyValueDiffers
+  }], null);
+})();
+function defaultComparator(keyValueA, keyValueB) {
+  const a = keyValueA.key;
+  const b = keyValueB.key;
+  if (a === b) return 0;
+  if (a == null) return 1;
+  if (b == null) return -1;
+  if (typeof a == "string" && typeof b == "string") {
+    return a < b ? -1 : 1;
+  }
+  if (typeof a == "number" && typeof b == "number") {
+    return a - b;
+  }
+  if (typeof a == "boolean" && typeof b == "boolean") {
+    return a < b ? -1 : 1;
+  }
+  const aString = String(a);
+  const bString = String(b);
+  return aString == bString ? 0 : aString < bString ? -1 : 1;
+}
+var DecimalPipe = class _DecimalPipe {
+  _locale;
+  constructor(_locale) {
+    this._locale = _locale;
+  }
+  transform(value, digitsInfo, locale) {
+    if (!isValue(value)) return null;
+    locale ||= this._locale;
+    try {
+      const num = strToNumber(value);
+      return formatNumber(num, locale, digitsInfo);
+    } catch (error) {
+      throw invalidPipeArgumentError(_DecimalPipe, error.message);
+    }
+  }
+  static \u0275fac = function DecimalPipe_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _DecimalPipe)(\u0275\u0275directiveInject(LOCALE_ID, 16));
+  };
+  static \u0275pipe = /* @__PURE__ */ \u0275\u0275definePipe({
+    name: "number",
+    type: _DecimalPipe,
+    pure: true
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DecimalPipe, [{
+    type: Pipe,
+    args: [{
+      name: "number"
+    }]
+  }], () => [{
+    type: void 0,
+    decorators: [{
+      type: Inject,
+      args: [LOCALE_ID]
+    }]
+  }], null);
+})();
+var PercentPipe = class _PercentPipe {
+  _locale;
+  constructor(_locale) {
+    this._locale = _locale;
+  }
+  transform(value, digitsInfo, locale) {
+    if (!isValue(value)) return null;
+    locale ||= this._locale;
+    try {
+      const num = strToNumber(value);
+      return formatPercent(num, locale, digitsInfo);
+    } catch (error) {
+      throw invalidPipeArgumentError(_PercentPipe, error.message);
+    }
+  }
+  static \u0275fac = function PercentPipe_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _PercentPipe)(\u0275\u0275directiveInject(LOCALE_ID, 16));
+  };
+  static \u0275pipe = /* @__PURE__ */ \u0275\u0275definePipe({
+    name: "percent",
+    type: _PercentPipe,
+    pure: true
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(PercentPipe, [{
+    type: Pipe,
+    args: [{
+      name: "percent"
+    }]
+  }], () => [{
+    type: void 0,
+    decorators: [{
+      type: Inject,
+      args: [LOCALE_ID]
+    }]
+  }], null);
+})();
+var CurrencyPipe = class _CurrencyPipe {
+  _locale;
+  _defaultCurrencyCode;
+  constructor(_locale, _defaultCurrencyCode = "USD") {
+    this._locale = _locale;
+    this._defaultCurrencyCode = _defaultCurrencyCode;
+  }
+  transform(value, currencyCode = this._defaultCurrencyCode, display = "symbol", digitsInfo, locale) {
+    if (!isValue(value)) return null;
+    locale ||= this._locale;
+    if (typeof display === "boolean") {
+      if (typeof ngDevMode === "undefined" || ngDevMode) {
+        console.warn(`Warning: the currency pipe has been changed in Angular v5. The symbolDisplay option (third parameter) is now a string instead of a boolean. The accepted values are "code", "symbol" or "symbol-narrow".`);
+      }
+      display = display ? "symbol" : "code";
+    }
+    let currency = currencyCode || this._defaultCurrencyCode;
+    if (display !== "code") {
+      if (display === "symbol" || display === "symbol-narrow") {
+        currency = getCurrencySymbol(currency, display === "symbol" ? "wide" : "narrow", locale);
+      } else {
+        currency = display;
+      }
+    }
+    try {
+      const num = strToNumber(value);
+      return formatCurrency(num, locale, currency, currencyCode, digitsInfo);
+    } catch (error) {
+      throw invalidPipeArgumentError(_CurrencyPipe, error.message);
+    }
+  }
+  static \u0275fac = function CurrencyPipe_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _CurrencyPipe)(\u0275\u0275directiveInject(LOCALE_ID, 16), \u0275\u0275directiveInject(DEFAULT_CURRENCY_CODE, 16));
+  };
+  static \u0275pipe = /* @__PURE__ */ \u0275\u0275definePipe({
+    name: "currency",
+    type: _CurrencyPipe,
+    pure: true
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(CurrencyPipe, [{
+    type: Pipe,
+    args: [{
+      name: "currency"
+    }]
+  }], () => [{
+    type: void 0,
+    decorators: [{
+      type: Inject,
+      args: [LOCALE_ID]
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Inject,
+      args: [DEFAULT_CURRENCY_CODE]
+    }]
+  }], null);
+})();
+function isValue(value) {
+  return !(value == null || value === "" || value !== value);
+}
+function strToNumber(value) {
+  if (typeof value === "string" && !isNaN(Number(value) - parseFloat(value))) {
+    return Number(value);
+  }
+  if (typeof value !== "number") {
+    throw new RuntimeError(2309, ngDevMode && `${value} is not a number`);
+  }
+  return value;
+}
+var SlicePipe = class _SlicePipe {
+  transform(value, start, end) {
+    if (value == null) return null;
+    const supports = typeof value === "string" || Array.isArray(value);
+    if (!supports) {
+      throw invalidPipeArgumentError(_SlicePipe, value);
+    }
+    return value.slice(start, end);
+  }
+  static \u0275fac = function SlicePipe_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _SlicePipe)();
+  };
+  static \u0275pipe = /* @__PURE__ */ \u0275\u0275definePipe({
+    name: "slice",
+    type: _SlicePipe,
+    pure: false
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(SlicePipe, [{
+    type: Pipe,
+    args: [{
+      name: "slice",
+      pure: false
+    }]
+  }], null, null);
+})();
+var COMMON_PIPES = [AsyncPipe, UpperCasePipe, LowerCasePipe, JsonPipe, SlicePipe, DecimalPipe, PercentPipe, TitleCasePipe, CurrencyPipe, DatePipe, I18nPluralPipe, I18nSelectPipe, KeyValuePipe];
+var CommonModule = class _CommonModule {
+  static \u0275fac = function CommonModule_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _CommonModule)();
+  };
+  static \u0275mod = /* @__PURE__ */ \u0275\u0275defineNgModule({
+    type: _CommonModule,
+    imports: [NgClass, NgComponentOutlet, NgForOf, NgIf, NgTemplateOutlet, NgStyle, NgSwitch, NgSwitchCase, NgSwitchDefault, NgPlural, NgPluralCase, AsyncPipe, UpperCasePipe, LowerCasePipe, JsonPipe, SlicePipe, DecimalPipe, PercentPipe, TitleCasePipe, CurrencyPipe, DatePipe, I18nPluralPipe, I18nSelectPipe, KeyValuePipe],
+    exports: [NgClass, NgComponentOutlet, NgForOf, NgIf, NgTemplateOutlet, NgStyle, NgSwitch, NgSwitchCase, NgSwitchDefault, NgPlural, NgPluralCase, AsyncPipe, UpperCasePipe, LowerCasePipe, JsonPipe, SlicePipe, DecimalPipe, PercentPipe, TitleCasePipe, CurrencyPipe, DatePipe, I18nPluralPipe, I18nSelectPipe, KeyValuePipe]
+  });
+  static \u0275inj = /* @__PURE__ */ \u0275\u0275defineInjector({});
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(CommonModule, [{
+    type: NgModule,
+    args: [{
+      imports: [COMMON_DIRECTIVES, COMMON_PIPES],
+      exports: [COMMON_DIRECTIVES, COMMON_PIPES]
+    }]
+  }], null, null);
+})();
+
+// node_modules/@angular/common/fesm2022/_platform_navigation-chunk.mjs
+/**
+ * @license Angular v21.2.17
+ * (c) 2010-2026 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+var PRECOMMIT_HANDLER_SUPPORTED = new InjectionToken("", {
+  factory: () => {
+    return typeof window !== "undefined" && typeof window.NavigationPrecommitController !== "undefined";
+  }
+});
+var PlatformNavigation = class _PlatformNavigation {
+  static \u0275fac = function PlatformNavigation_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _PlatformNavigation)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _PlatformNavigation,
+    factory: () => (() => window.navigation)(),
+    providedIn: "platform"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(PlatformNavigation, [{
+    type: Injectable,
+    args: [{
+      providedIn: "platform",
+      useFactory: () => window.navigation
+    }]
+  }], null, null);
+})();
+
+// node_modules/@angular/common/fesm2022/_xhr-chunk.mjs
+/**
+ * @license Angular v21.2.17
+ * (c) 2010-2026 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+function parseCookieValue(cookieStr, name) {
+  name = encodeURIComponent(name);
+  for (const cookie of cookieStr.split(";")) {
+    const eqIndex = cookie.indexOf("=");
+    const [cookieName, cookieValue] = eqIndex == -1 ? [cookie, ""] : [cookie.slice(0, eqIndex), cookie.slice(eqIndex + 1)];
+    if (cookieName.trim() === name) {
+      return decodeURIComponent(cookieValue);
+    }
+  }
+  return null;
+}
+var XhrFactory = class {
+};
+
+// node_modules/@angular/common/fesm2022/common.mjs
+/**
+ * @license Angular v21.2.17
+ * (c) 2010-2026 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+var NavigationAdapterForLocation = class _NavigationAdapterForLocation extends Location {
+  navigation = inject2(PlatformNavigation);
+  destroyRef = inject2(DestroyRef);
+  constructor() {
+    super(inject2(LocationStrategy));
+    this.registerNavigationListeners();
+  }
+  registerNavigationListeners() {
+    const currentEntryChangeListener = () => {
+      this._notifyUrlChangeListeners(this.path(true), this.getState());
+    };
+    this.navigation.addEventListener("currententrychange", currentEntryChangeListener);
+    this.destroyRef.onDestroy(() => {
+      this.navigation.removeEventListener("currententrychange", currentEntryChangeListener);
+    });
+  }
+  getState() {
+    return this.navigation.currentEntry?.getState();
+  }
+  replaceState(path, query = "", state = null) {
+    const url = this.prepareExternalUrl(path + normalizeQueryParams(query));
+    this.navigation.navigate(url, {
+      state,
+      history: "replace"
+    });
+  }
+  go(path, query = "", state = null) {
+    const url = this.prepareExternalUrl(path + normalizeQueryParams(query));
+    this.navigation.navigate(url, {
+      state,
+      history: "push"
+    });
+  }
+  back() {
+    this.navigation.back();
+  }
+  forward() {
+    this.navigation.forward();
+  }
+  onUrlChange(fn) {
+    this._urlChangeListeners.push(fn);
+    return () => {
+      const fnIndex = this._urlChangeListeners.indexOf(fn);
+      this._urlChangeListeners.splice(fnIndex, 1);
+    };
+  }
+  static \u0275fac = function NavigationAdapterForLocation_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _NavigationAdapterForLocation)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _NavigationAdapterForLocation,
+    factory: _NavigationAdapterForLocation.\u0275fac
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NavigationAdapterForLocation, [{
+    type: Injectable
+  }], () => [], null);
+})();
+var PLATFORM_BROWSER_ID = "browser";
+var ViewportScroller = class _ViewportScroller {
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _ViewportScroller,
+    providedIn: "root",
+    factory: () => false ? new NullViewportScroller() : new BrowserViewportScroller(inject2(DOCUMENT), window)
+  });
+};
+var BrowserViewportScroller = class {
+  document;
+  window;
+  offset = () => [0, 0];
+  constructor(document2, window2) {
+    this.document = document2;
+    this.window = window2;
+  }
+  setOffset(offset) {
+    if (Array.isArray(offset)) {
+      this.offset = () => offset;
+    } else {
+      this.offset = offset;
+    }
+  }
+  getScrollPosition() {
+    return [this.window.scrollX, this.window.scrollY];
+  }
+  scrollToPosition(position, options) {
+    this.window.scrollTo(__spreadProps(__spreadValues({}, options), {
+      left: position[0],
+      top: position[1]
+    }));
+  }
+  scrollToAnchor(target, options) {
+    const elSelected = findAnchorFromDocument(this.document, target);
+    if (elSelected) {
+      this.scrollToElement(elSelected, options);
+      elSelected.focus({
+        preventScroll: true
+      });
+    }
+  }
+  setHistoryScrollRestoration(scrollRestoration) {
+    try {
+      this.window.history.scrollRestoration = scrollRestoration;
+    } catch {
+      console.warn(formatRuntimeError(2400, ngDevMode && "Failed to set `window.history.scrollRestoration`. This may occur when:\n\u2022 The script is running inside a sandboxed iframe\n\u2022 The window is partially navigated or inactive\n\u2022 The script is executed in an untrusted or special context (e.g., test runners, browser extensions, or content previews)\nScroll position may not be preserved across navigation."));
+    }
+  }
+  scrollToElement(el, options) {
+    const rect = el.getBoundingClientRect();
+    const left = rect.left + this.window.pageXOffset;
+    const top = rect.top + this.window.pageYOffset;
+    const offset = this.offset();
+    this.window.scrollTo(__spreadProps(__spreadValues({}, options), {
+      left: left - offset[0],
+      top: top - offset[1]
+    }));
+  }
+};
+function findAnchorFromDocument(document2, target) {
+  const documentResult = document2.getElementById(target) || document2.getElementsByName(target)[0];
+  if (documentResult) {
+    return documentResult;
+  }
+  if (typeof document2.createTreeWalker === "function" && document2.body && typeof document2.body.attachShadow === "function") {
+    const treeWalker = document2.createTreeWalker(document2.body, NodeFilter.SHOW_ELEMENT);
+    let currentNode = treeWalker.currentNode;
+    while (currentNode) {
+      const shadowRoot = currentNode.shadowRoot;
+      if (shadowRoot) {
+        const result = shadowRoot.getElementById(target) || shadowRoot.querySelector(`[name="${target}"]`);
+        if (result) {
+          return result;
+        }
+      }
+      currentNode = treeWalker.nextNode();
+    }
+  }
+  return null;
+}
+var PLACEHOLDER_QUALITY = "20";
+function getUrl(src, win) {
+  return isAbsoluteUrl(src) ? new URL(src) : new URL(src, win.location.href);
+}
+function isAbsoluteUrl(src) {
+  return /^https?:\/\//.test(src);
+}
+function extractHostname(url) {
+  return isAbsoluteUrl(url) ? new URL(url).hostname : url;
+}
+function isValidPath(path) {
+  const isString = typeof path === "string";
+  if (!isString || path.trim() === "") {
+    return false;
+  }
+  try {
+    const url = new URL(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizePath(path) {
+  return path.endsWith("/") ? path.slice(0, -1) : path;
+}
+function normalizeSrc(src) {
+  return src.startsWith("/") ? src.slice(1) : src;
+}
+var noopImageLoader = (config2) => config2.src;
+var IMAGE_LOADER = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "ImageLoader" : "", {
+  factory: () => noopImageLoader
+});
+function createImageLoader(buildUrlFn, exampleUrls) {
+  return function provideImageLoader(path) {
+    if (!isValidPath(path)) {
+      throwInvalidPathError(path, exampleUrls || []);
+    }
+    path = normalizePath(path);
+    const loaderFn = (config2) => {
+      if (isAbsoluteUrl(config2.src)) {
+        throwUnexpectedAbsoluteUrlError(path, config2.src);
+      }
+      return buildUrlFn(path, __spreadProps(__spreadValues({}, config2), {
+        src: normalizeSrc(config2.src)
+      }));
+    };
+    const providers = [{
+      provide: IMAGE_LOADER,
+      useValue: loaderFn
+    }];
+    return providers;
+  };
+}
+function throwInvalidPathError(path, exampleUrls) {
+  throw new RuntimeError(2959, ngDevMode && `Image loader has detected an invalid path (\`${path}\`). To fix this, supply a path using one of the following formats: ${exampleUrls.join(" or ")}`);
+}
+function throwUnexpectedAbsoluteUrlError(path, url) {
+  throw new RuntimeError(2959, ngDevMode && `Image loader has detected a \`<img>\` tag with an invalid \`ngSrc\` attribute: ${url}. This image loader expects \`ngSrc\` to be a relative URL - however the provided value is an absolute URL. To fix this, provide \`ngSrc\` as a path relative to the base URL configured for this loader (\`${path}\`).`);
+}
+function normalizeLoaderTransform(transform, separator) {
+  if (typeof transform === "string") {
+    return transform;
+  }
+  return Object.entries(transform).map(([key, value]) => `${key}${separator}${value}`).join(",");
+}
+var provideCloudflareLoader = createImageLoader(createCloudflareUrl, ngDevMode ? ["https://<ZONE>/cdn-cgi/image/<OPTIONS>/<SOURCE-IMAGE>"] : void 0);
+function createCloudflareUrl(path, config2) {
+  let params = `format=auto`;
+  if (config2.width) {
+    params += `,width=${config2.width}`;
+  }
+  if (config2.height) {
+    params += `,height=${config2.height}`;
+  }
+  if (config2.isPlaceholder) {
+    params += `,quality=${PLACEHOLDER_QUALITY}`;
+  }
+  if (config2.loaderParams?.["transform"]) {
+    const transformStr = normalizeLoaderTransform(config2.loaderParams["transform"], "=");
+    params += `,${transformStr}`;
+  }
+  return `${path}/cdn-cgi/image/${params}/${config2.src}`;
+}
+var cloudinaryLoaderInfo = {
+  name: "Cloudinary",
+  testUrl: isCloudinaryUrl
+};
+var CLOUDINARY_LOADER_REGEX = /https?\:\/\/[^\/]+\.cloudinary\.com\/.+/;
+function isCloudinaryUrl(url) {
+  return CLOUDINARY_LOADER_REGEX.test(url);
+}
+var provideCloudinaryLoader = createImageLoader(createCloudinaryUrl, ngDevMode ? ["https://res.cloudinary.com/mysite", "https://mysite.cloudinary.com", "https://subdomain.mysite.com"] : void 0);
+function createCloudinaryUrl(path, config2) {
+  const quality = config2.isPlaceholder ? "q_auto:low" : "q_auto";
+  let params = `f_auto,${quality}`;
+  if (config2.width) {
+    params += `,w_${config2.width}`;
+  }
+  if (config2.height) {
+    params += `,h_${config2.height}`;
+  }
+  if (config2.loaderParams?.["rounded"]) {
+    params += `,r_max`;
+  }
+  if (config2.loaderParams?.["transform"]) {
+    const transformStr = normalizeLoaderTransform(config2.loaderParams["transform"], "_");
+    params += `,${transformStr}`;
+  }
+  return `${path}/image/upload/${params}/${config2.src}`;
+}
+var imageKitLoaderInfo = {
+  name: "ImageKit",
+  testUrl: isImageKitUrl
+};
+var IMAGE_KIT_LOADER_REGEX = /https?\:\/\/[^\/]+\.imagekit\.io\/.+/;
+function isImageKitUrl(url) {
+  return IMAGE_KIT_LOADER_REGEX.test(url);
+}
+var provideImageKitLoader = createImageLoader(createImagekitUrl, ngDevMode ? ["https://ik.imagekit.io/mysite", "https://subdomain.mysite.com"] : void 0);
+function createImagekitUrl(path, config2) {
+  const {
+    src,
+    width
+  } = config2;
+  const params = [];
+  if (width) {
+    params.push(`w-${width}`);
+  }
+  if (config2.height) {
+    params.push(`h-${config2.height}`);
+  }
+  if (config2.isPlaceholder) {
+    params.push(`q-${PLACEHOLDER_QUALITY}`);
+  }
+  if (config2.loaderParams?.["transform"]) {
+    const transformStr = normalizeLoaderTransform(config2.loaderParams["transform"], "-");
+    params.push(transformStr);
+  }
+  const urlSegments = params.length ? [path, `tr:${params.join(",")}`, src] : [path, src];
+  const url = new URL(urlSegments.join("/"));
+  return url.href;
+}
+var imgixLoaderInfo = {
+  name: "Imgix",
+  testUrl: isImgixUrl
+};
+var IMGIX_LOADER_REGEX = /https?\:\/\/[^\/]+\.imgix\.net\/.+/;
+function isImgixUrl(url) {
+  return IMGIX_LOADER_REGEX.test(url);
+}
+var provideImgixLoader = createImageLoader(createImgixUrl, ngDevMode ? ["https://somepath.imgix.net/"] : void 0);
+function createImgixUrl(path, config2) {
+  const params = [];
+  params.push("auto=format");
+  if (config2.width) {
+    params.push(`w=${config2.width}`);
+  }
+  if (config2.height) {
+    params.push(`h=${config2.height}`);
+  }
+  if (config2.isPlaceholder) {
+    params.push(`q=${PLACEHOLDER_QUALITY}`);
+  }
+  if (config2.loaderParams?.["transform"]) {
+    const transform = normalizeLoaderTransform(config2.loaderParams["transform"], "=").split(",");
+    params.push(...transform);
+  }
+  const url = new URL(`${path}/${config2.src}`);
+  url.search = params.join("&");
+  return url.href;
+}
+var netlifyLoaderInfo = {
+  name: "Netlify",
+  testUrl: isNetlifyUrl
+};
+var NETLIFY_LOADER_REGEX = /https?\:\/\/[^\/]+\.netlify\.app\/.+/;
+function isNetlifyUrl(url) {
+  return NETLIFY_LOADER_REGEX.test(url);
+}
+function imgDirectiveDetails(ngSrc, includeNgSrc = true) {
+  const ngSrcInfo = includeNgSrc ? `(activated on an <img> element with the \`ngSrc="${ngSrc}"\`) ` : "";
+  return `The NgOptimizedImage directive ${ngSrcInfo}has detected that`;
+}
+function assertDevMode(checkName) {
+  if (!ngDevMode) {
+    throw new RuntimeError(2958, `Unexpected invocation of the ${checkName} in the prod mode. Please make sure that the prod mode is enabled for production builds.`);
+  }
+}
+var LCPImageObserver = class _LCPImageObserver {
+  images = /* @__PURE__ */ new Map();
+  window = inject2(DOCUMENT).defaultView;
+  observer = null;
+  constructor() {
+    assertDevMode("LCP checker");
+    if (typeof PerformanceObserver !== "undefined") {
+      this.observer = this.initPerformanceObserver();
+    }
+  }
+  initPerformanceObserver() {
+    const observer = new PerformanceObserver((entryList) => {
+      const entries = entryList.getEntries();
+      if (entries.length === 0) return;
+      const lcpElement = entries[entries.length - 1];
+      const imgSrc = lcpElement.element?.src ?? "";
+      if (imgSrc.startsWith("data:") || imgSrc.startsWith("blob:")) return;
+      const img = this.images.get(imgSrc);
+      if (!img) return;
+      if (!img.priority && !img.alreadyWarnedPriority) {
+        img.alreadyWarnedPriority = true;
+        logMissingPriorityError(imgSrc);
+      }
+      if (img.modified && !img.alreadyWarnedModified) {
+        img.alreadyWarnedModified = true;
+        logModifiedWarning(imgSrc);
+      }
+    });
+    observer.observe({
+      type: "largest-contentful-paint",
+      buffered: true
+    });
+    return observer;
+  }
+  registerImage(rewrittenSrc, isPriority) {
+    if (!this.observer) return;
+    const url = getUrl(rewrittenSrc, this.window).href;
+    const existingState = this.images.get(url);
+    if (existingState) {
+      existingState.priority = existingState.priority || isPriority;
+      existingState.count++;
+    } else {
+      const newObservedImageState = {
+        priority: isPriority,
+        modified: false,
+        alreadyWarnedModified: false,
+        alreadyWarnedPriority: false,
+        count: 1
+      };
+      this.images.set(url, newObservedImageState);
+    }
+  }
+  unregisterImage(rewrittenSrc) {
+    if (!this.observer) return;
+    const url = getUrl(rewrittenSrc, this.window).href;
+    const existingState = this.images.get(url);
+    if (existingState) {
+      existingState.count--;
+      if (existingState.count <= 0) {
+        this.images.delete(url);
+      }
+    }
+  }
+  updateImage(originalSrc, newSrc) {
+    if (!this.observer) return;
+    const originalUrl = getUrl(originalSrc, this.window).href;
+    const newUrl = getUrl(newSrc, this.window).href;
+    if (originalUrl === newUrl) return;
+    const originalState = this.images.get(originalUrl);
+    if (!originalState) return;
+    originalState.count--;
+    if (originalState.count <= 0) {
+      this.images.delete(originalUrl);
+    }
+    const newState = this.images.get(newUrl);
+    if (newState) {
+      newState.priority = newState.priority || originalState.priority;
+      newState.modified = true;
+      newState.alreadyWarnedPriority = newState.alreadyWarnedPriority || originalState.alreadyWarnedPriority;
+      newState.alreadyWarnedModified = newState.alreadyWarnedModified || originalState.alreadyWarnedModified;
+      newState.count++;
+    } else {
+      this.images.set(newUrl, {
+        priority: originalState.priority,
+        modified: true,
+        alreadyWarnedModified: originalState.alreadyWarnedModified,
+        alreadyWarnedPriority: originalState.alreadyWarnedPriority,
+        count: 1
+      });
+    }
+  }
+  ngOnDestroy() {
+    if (!this.observer) return;
+    this.observer.disconnect();
+    this.images.clear();
+  }
+  static \u0275fac = function LCPImageObserver_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _LCPImageObserver)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _LCPImageObserver,
+    factory: _LCPImageObserver.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(LCPImageObserver, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], () => [], null);
+})();
+function logMissingPriorityError(ngSrc) {
+  const directiveDetails = imgDirectiveDetails(ngSrc);
+  console.error(formatRuntimeError(2955, `${directiveDetails} this image is the Largest Contentful Paint (LCP) element but was not marked "priority". This image should be marked "priority" in order to prioritize its loading. To fix this, add the "priority" attribute.`));
+}
+function logModifiedWarning(ngSrc) {
+  const directiveDetails = imgDirectiveDetails(ngSrc);
+  console.warn(formatRuntimeError(2964, `${directiveDetails} this image is the Largest Contentful Paint (LCP) element and has had its "ngSrc" attribute modified. This can cause slower loading performance. It is recommended not to modify the "ngSrc" property on any image which could be the LCP element.`));
+}
+var INTERNAL_PRECONNECT_CHECK_BLOCKLIST = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "0.0.0.0", "[::1]"]);
+var PRECONNECT_CHECK_BLOCKLIST = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "PRECONNECT_CHECK_BLOCKLIST" : "");
+var PreconnectLinkChecker = class _PreconnectLinkChecker {
+  document = inject2(DOCUMENT);
+  preconnectLinks = null;
+  alreadySeen = /* @__PURE__ */ new Set();
+  window = this.document.defaultView;
+  blocklist = new Set(INTERNAL_PRECONNECT_CHECK_BLOCKLIST);
+  constructor() {
+    assertDevMode("preconnect link checker");
+    const blocklist = inject2(PRECONNECT_CHECK_BLOCKLIST, {
+      optional: true
+    });
+    if (blocklist) {
+      this.populateBlocklist(blocklist);
+    }
+  }
+  populateBlocklist(origins) {
+    if (Array.isArray(origins)) {
+      deepForEach2(origins, (origin) => {
+        this.blocklist.add(extractHostname(origin));
+      });
+    } else {
+      this.blocklist.add(extractHostname(origins));
+    }
+  }
+  assertPreconnect(rewrittenSrc, originalNgSrc) {
+    if (false) return;
+    const imgUrl = getUrl(rewrittenSrc, this.window);
+    if (this.blocklist.has(imgUrl.hostname) || this.alreadySeen.has(imgUrl.origin)) return;
+    this.alreadySeen.add(imgUrl.origin);
+    this.preconnectLinks ??= this.queryPreconnectLinks();
+    if (!this.preconnectLinks.has(imgUrl.origin)) {
+      console.warn(formatRuntimeError(2956, `${imgDirectiveDetails(originalNgSrc)} there is no preconnect tag present for this image. Preconnecting to the origin(s) that serve priority images ensures that these images are delivered as soon as possible. To fix this, please add the following element into the <head> of the document:
+  <link rel="preconnect" href="${imgUrl.origin}">`));
+    }
+  }
+  queryPreconnectLinks() {
+    const preconnectUrls = /* @__PURE__ */ new Set();
+    const links = this.document.querySelectorAll("link[rel=preconnect]");
+    for (const link of links) {
+      const url = getUrl(link.href, this.window);
+      preconnectUrls.add(url.origin);
+    }
+    return preconnectUrls;
+  }
+  ngOnDestroy() {
+    this.preconnectLinks?.clear();
+    this.alreadySeen.clear();
+  }
+  static \u0275fac = function PreconnectLinkChecker_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _PreconnectLinkChecker)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _PreconnectLinkChecker,
+    factory: _PreconnectLinkChecker.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(PreconnectLinkChecker, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], () => [], null);
+})();
+function deepForEach2(input2, fn) {
+  for (let value of input2) {
+    Array.isArray(value) ? deepForEach2(value, fn) : fn(value);
+  }
+}
+var DEFAULT_PRELOADED_IMAGES_LIMIT = 5;
+var PRELOADED_IMAGES = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "NG_OPTIMIZED_PRELOADED_IMAGES" : "", {
+  factory: () => /* @__PURE__ */ new Set()
+});
+var PreloadLinkCreator = class _PreloadLinkCreator {
+  preloadedImages = inject2(PRELOADED_IMAGES);
+  document = inject2(DOCUMENT);
+  errorShown = false;
+  createPreloadLinkTag(renderer, src, srcset, sizes) {
+    if (ngDevMode && !this.errorShown && this.preloadedImages.size >= DEFAULT_PRELOADED_IMAGES_LIMIT) {
+      this.errorShown = true;
+      console.warn(formatRuntimeError(2961, `The \`NgOptimizedImage\` directive has detected that more than ${DEFAULT_PRELOADED_IMAGES_LIMIT} images were marked as priority. This might negatively affect an overall performance of the page. To fix this, remove the "priority" attribute from images with less priority.`));
+    }
+    if (this.preloadedImages.has(src)) {
+      return;
+    }
+    this.preloadedImages.add(src);
+    const preload = renderer.createElement("link");
+    renderer.setAttribute(preload, "as", "image");
+    renderer.setAttribute(preload, "href", src);
+    renderer.setAttribute(preload, "rel", "preload");
+    renderer.setAttribute(preload, "fetchpriority", "high");
+    if (sizes) {
+      renderer.setAttribute(preload, "imageSizes", sizes);
+    }
+    if (srcset) {
+      renderer.setAttribute(preload, "imageSrcset", srcset);
+    }
+    renderer.appendChild(this.document.head, preload);
+  }
+  static \u0275fac = function PreloadLinkCreator_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _PreloadLinkCreator)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _PreloadLinkCreator,
+    factory: _PreloadLinkCreator.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(PreloadLinkCreator, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], null, null);
+})();
+var BASE64_IMG_MAX_LENGTH_IN_ERROR = 50;
+var VALID_WIDTH_DESCRIPTOR_SRCSET = /^((\s*\d+w\s*(,|$)){1,})$/;
+var VALID_DENSITY_DESCRIPTOR_SRCSET = /^((\s*\d+(\.\d+)?x\s*(,|$)){1,})$/;
+var ABSOLUTE_SRCSET_DENSITY_CAP = 3;
+var RECOMMENDED_SRCSET_DENSITY_CAP = 2;
+var DENSITY_SRCSET_MULTIPLIERS = [1, 2];
+var VIEWPORT_BREAKPOINT_CUTOFF = 640;
+var ASPECT_RATIO_TOLERANCE = 0.1;
+var OVERSIZED_IMAGE_TOLERANCE2 = 1e3;
+var FIXED_SRCSET_WIDTH_LIMIT = 1920;
+var FIXED_SRCSET_HEIGHT_LIMIT = 1080;
+var PLACEHOLDER_DIMENSION_LIMIT = 1e3;
+var DATA_URL_WARN_LIMIT = 4e3;
+var DATA_URL_ERROR_LIMIT = 1e4;
+var BUILT_IN_LOADERS = [imgixLoaderInfo, imageKitLoaderInfo, cloudinaryLoaderInfo, netlifyLoaderInfo];
+var PRIORITY_COUNT_THRESHOLD = 10;
+var IMGS_WITH_PRIORITY_ATTR_COUNT = 0;
+var NgOptimizedImage = class _NgOptimizedImage {
+  imageLoader = inject2(IMAGE_LOADER);
+  config = processConfig(inject2(IMAGE_CONFIG));
+  renderer = inject2(Renderer2);
+  imgElement = inject2(ElementRef).nativeElement;
+  injector = inject2(Injector);
+  destroyRef = inject2(DestroyRef);
+  lcpObserver;
+  _renderedSrc = null;
+  ngSrc;
+  ngSrcset;
+  sizes;
+  width;
+  height;
+  decoding;
+  loading;
+  priority = false;
+  loaderParams;
+  disableOptimizedSrcset = false;
+  fill = false;
+  placeholder;
+  placeholderConfig;
+  src;
+  srcset;
+  constructor() {
+    if (ngDevMode) {
+      this.lcpObserver = this.injector.get(LCPImageObserver);
+      this.destroyRef.onDestroy(() => {
+        if (!this.priority && this._renderedSrc !== null) {
+          this.lcpObserver.unregisterImage(this._renderedSrc);
+        }
+      });
+    }
+    this.destroyRef.onDestroy(() => {
+      this.renderer.removeAttribute(this.imgElement, "loading");
+    });
+  }
+  ngOnInit() {
+    performanceMarkFeature("NgOptimizedImage");
+    if (ngDevMode) {
+      const ngZone = this.injector.get(NgZone);
+      assertNonEmptyInput(this, "ngSrc", this.ngSrc);
+      assertValidNgSrcset(this, this.ngSrcset);
+      assertNoConflictingSrc(this);
+      if (this.ngSrcset) {
+        assertNoConflictingSrcset(this);
+      }
+      assertNotBase64Image(this);
+      assertNotBlobUrl(this);
+      if (this.fill) {
+        assertEmptyWidthAndHeight(this);
+        ngZone.runOutsideAngular(() => assertNonZeroRenderedHeight(this, this.imgElement, this.renderer, this.destroyRef));
+      } else {
+        assertNonEmptyWidthAndHeight(this);
+        if (this.height !== void 0) {
+          assertGreaterThanZero(this, this.height, "height");
+        }
+        if (this.width !== void 0) {
+          assertGreaterThanZero(this, this.width, "width");
+        }
+        ngZone.runOutsideAngular(() => assertNoImageDistortion(this, this.imgElement, this.renderer, this.destroyRef));
+      }
+      assertValidLoadingInput(this);
+      assertValidDecodingInput(this);
+      if (!this.ngSrcset) {
+        assertNoComplexSizes(this);
+      }
+      assertValidPlaceholder(this, this.imageLoader);
+      assertNotMissingBuiltInLoader(this.ngSrc, this.imageLoader);
+      assertNoNgSrcsetWithoutLoader(this, this.imageLoader);
+      assertNoLoaderParamsWithoutLoader(this, this.imageLoader);
+      ngZone.runOutsideAngular(() => {
+        this.lcpObserver.registerImage(this.getRewrittenSrc(), this.priority);
+      });
+      if (this.priority) {
+        const checker = this.injector.get(PreconnectLinkChecker);
+        checker.assertPreconnect(this.getRewrittenSrc(), this.ngSrc);
+        if (true) {
+          const applicationRef = this.injector.get(ApplicationRef);
+          assetPriorityCountBelowThreshold(applicationRef);
+        }
+      }
+    }
+    if (this.placeholder) {
+      this.removePlaceholderOnLoad(this.imgElement);
+    }
+    this.setHostAttributes();
+  }
+  setHostAttributes() {
+    if (this.fill) {
+      this.sizes ||= "100vw";
+    } else {
+      this.setHostAttribute("width", this.width.toString());
+      this.setHostAttribute("height", this.height.toString());
+    }
+    this.setHostAttribute("loading", this.getLoadingBehavior());
+    this.setHostAttribute("fetchpriority", this.getFetchPriority());
+    this.setHostAttribute("decoding", this.getDecoding());
+    this.setHostAttribute("ng-img", "true");
+    const rewrittenSrcset = this.updateSrcAndSrcset();
+    if (this.sizes) {
+      if (this.getLoadingBehavior() === "lazy") {
+        this.setHostAttribute("sizes", "auto, " + this.sizes);
+      } else {
+        this.setHostAttribute("sizes", this.sizes);
+      }
+    } else {
+      if (this.ngSrcset && VALID_WIDTH_DESCRIPTOR_SRCSET.test(this.ngSrcset) && this.getLoadingBehavior() === "lazy") {
+        this.setHostAttribute("sizes", "auto, 100vw");
+      }
+    }
+    if (false) {
+      const preloadLinkCreator = this.injector.get(PreloadLinkCreator);
+      preloadLinkCreator.createPreloadLinkTag(this.renderer, this.getRewrittenSrc(), rewrittenSrcset, this.sizes);
+    }
+  }
+  ngOnChanges(changes) {
+    if (ngDevMode) {
+      assertNoPostInitInputChange(this, changes, ["ngSrcset", "width", "height", "priority", "fill", "loading", "sizes", "loaderParams", "disableOptimizedSrcset"]);
+    }
+    if (changes["ngSrc"] && !changes["ngSrc"].isFirstChange()) {
+      const oldSrc = this._renderedSrc;
+      this.updateSrcAndSrcset(true);
+      if (ngDevMode) {
+        const newSrc = this._renderedSrc;
+        if (oldSrc && newSrc && oldSrc !== newSrc) {
+          const ngZone = this.injector.get(NgZone);
+          ngZone.runOutsideAngular(() => {
+            this.lcpObserver.updateImage(oldSrc, newSrc);
+          });
+        }
+      }
+    }
+    if (ngDevMode && changes["placeholder"]?.currentValue && true && true) {
+      assertPlaceholderDimensions(this, this.imgElement);
+    }
+  }
+  getAspectRatio() {
+    if (this.width && this.height && this.height !== 0) {
+      return this.width / this.height;
+    }
+    return null;
+  }
+  callImageLoader(configWithoutCustomParams) {
+    let augmentedConfig = configWithoutCustomParams;
+    if (this.loaderParams) {
+      augmentedConfig.loaderParams = this.loaderParams;
+    }
+    const ratio = this.getAspectRatio();
+    if (ratio !== null && augmentedConfig.width) {
+      augmentedConfig.height = Math.round(augmentedConfig.width / ratio);
+    }
+    return this.imageLoader(augmentedConfig);
+  }
+  getLoadingBehavior() {
+    if (!this.priority && this.loading !== void 0) {
+      return this.loading;
+    }
+    return this.priority ? "eager" : "lazy";
+  }
+  getFetchPriority() {
+    return this.priority ? "high" : "auto";
+  }
+  getDecoding() {
+    if (this.priority) {
+      return "sync";
+    }
+    return this.decoding ?? "auto";
+  }
+  getRewrittenSrc() {
+    if (!this._renderedSrc) {
+      const imgConfig = {
+        src: this.ngSrc
+      };
+      this._renderedSrc = this.callImageLoader(imgConfig);
+    }
+    return this._renderedSrc;
+  }
+  getRewrittenSrcset() {
+    const widthSrcSet = VALID_WIDTH_DESCRIPTOR_SRCSET.test(this.ngSrcset);
+    const finalSrcs = this.ngSrcset.split(",").filter((src) => src !== "").map((srcStr) => {
+      srcStr = srcStr.trim();
+      const width = widthSrcSet ? parseFloat(srcStr) : parseFloat(srcStr) * this.width;
+      return `${this.callImageLoader({
+        src: this.ngSrc,
+        width
+      })} ${srcStr}`;
+    });
+    return finalSrcs.join(", ");
+  }
+  getAutomaticSrcset() {
+    if (this.sizes) {
+      return this.getResponsiveSrcset();
+    } else {
+      return this.getFixedSrcset();
+    }
+  }
+  getResponsiveSrcset() {
+    const {
+      breakpoints
+    } = this.config;
+    let filteredBreakpoints = breakpoints;
+    if (this.sizes?.trim() === "100vw") {
+      filteredBreakpoints = breakpoints.filter((bp) => bp >= VIEWPORT_BREAKPOINT_CUTOFF);
+    }
+    const finalSrcs = filteredBreakpoints.map((bp) => `${this.callImageLoader({
+      src: this.ngSrc,
+      width: bp
+    })} ${bp}w`);
+    return finalSrcs.join(", ");
+  }
+  updateSrcAndSrcset(forceSrcRecalc = false) {
+    if (forceSrcRecalc) {
+      this._renderedSrc = null;
+    }
+    const rewrittenSrc = this.getRewrittenSrc();
+    this.setHostAttribute("src", rewrittenSrc);
+    let rewrittenSrcset = void 0;
+    if (this.ngSrcset) {
+      rewrittenSrcset = this.getRewrittenSrcset();
+    } else if (this.shouldGenerateAutomaticSrcset()) {
+      rewrittenSrcset = this.getAutomaticSrcset();
+    }
+    if (rewrittenSrcset) {
+      this.setHostAttribute("srcset", rewrittenSrcset);
+    }
+    return rewrittenSrcset;
+  }
+  getFixedSrcset() {
+    const finalSrcs = DENSITY_SRCSET_MULTIPLIERS.map((multiplier) => `${this.callImageLoader({
+      src: this.ngSrc,
+      width: this.width * multiplier
+    })} ${multiplier}x`);
+    return finalSrcs.join(", ");
+  }
+  shouldGenerateAutomaticSrcset() {
+    let oversizedImage = false;
+    if (!this.sizes) {
+      oversizedImage = this.width > FIXED_SRCSET_WIDTH_LIMIT || this.height > FIXED_SRCSET_HEIGHT_LIMIT;
+    }
+    return !this.disableOptimizedSrcset && !this.srcset && this.imageLoader !== noopImageLoader && !oversizedImage;
+  }
+  generatePlaceholder(placeholderInput) {
+    const {
+      placeholderResolution
+    } = this.config;
+    if (placeholderInput === true) {
+      return `url("${escapeCssUrl(this.callImageLoader({
+        src: this.ngSrc,
+        width: placeholderResolution,
+        isPlaceholder: true
+      }))}")`;
+    } else if (typeof placeholderInput === "string") {
+      return `url("${escapeCssUrl(placeholderInput)}")`;
+    }
+    return null;
+  }
+  shouldBlurPlaceholder(placeholderConfig) {
+    if (!placeholderConfig || !placeholderConfig.hasOwnProperty("blur")) {
+      return true;
+    }
+    return Boolean(placeholderConfig.blur);
+  }
+  removePlaceholderOnLoad(img) {
+    const callback = () => {
+      const changeDetectorRef = this.injector.get(ChangeDetectorRef);
+      removeLoadListenerFn();
+      removeErrorListenerFn();
+      this.placeholder = false;
+      changeDetectorRef.markForCheck();
+    };
+    const removeLoadListenerFn = this.renderer.listen(img, "load", callback);
+    const removeErrorListenerFn = this.renderer.listen(img, "error", callback);
+    this.destroyRef.onDestroy(() => {
+      removeLoadListenerFn();
+      removeErrorListenerFn();
+    });
+    callOnLoadIfImageIsLoaded(img, callback);
+  }
+  setHostAttribute(name, value) {
+    this.renderer.setAttribute(this.imgElement, name, value);
+  }
+  static \u0275fac = function NgOptimizedImage_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _NgOptimizedImage)();
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _NgOptimizedImage,
+    selectors: [["img", "ngSrc", ""]],
+    hostVars: 18,
+    hostBindings: function NgOptimizedImage_HostBindings(rf, ctx) {
+      if (rf & 2) {
+        \u0275\u0275styleProp("position", ctx.fill ? "absolute" : null)("width", ctx.fill ? "100%" : null)("height", ctx.fill ? "100%" : null)("inset", ctx.fill ? "0" : null)("background-size", ctx.placeholder ? "cover" : null)("background-position", ctx.placeholder ? "50% 50%" : null)("background-repeat", ctx.placeholder ? "no-repeat" : null)("background-image", ctx.placeholder ? ctx.generatePlaceholder(ctx.placeholder) : null)("filter", ctx.placeholder && ctx.shouldBlurPlaceholder(ctx.placeholderConfig) ? "blur(15px)" : null);
+      }
+    },
+    inputs: {
+      ngSrc: [2, "ngSrc", "ngSrc", unwrapSafeUrl],
+      ngSrcset: "ngSrcset",
+      sizes: "sizes",
+      width: [2, "width", "width", numberAttribute],
+      height: [2, "height", "height", numberAttribute],
+      decoding: "decoding",
+      loading: "loading",
+      priority: [2, "priority", "priority", booleanAttribute],
+      loaderParams: "loaderParams",
+      disableOptimizedSrcset: [2, "disableOptimizedSrcset", "disableOptimizedSrcset", booleanAttribute],
+      fill: [2, "fill", "fill", booleanAttribute],
+      placeholder: [2, "placeholder", "placeholder", booleanOrUrlAttribute],
+      placeholderConfig: "placeholderConfig",
+      src: "src",
+      srcset: "srcset"
+    },
+    features: [\u0275\u0275NgOnChangesFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgOptimizedImage, [{
+    type: Directive,
+    args: [{
+      selector: "img[ngSrc]",
+      host: {
+        "[style.position]": 'fill ? "absolute" : null',
+        "[style.width]": 'fill ? "100%" : null',
+        "[style.height]": 'fill ? "100%" : null',
+        "[style.inset]": 'fill ? "0" : null',
+        "[style.background-size]": 'placeholder ? "cover" : null',
+        "[style.background-position]": 'placeholder ? "50% 50%" : null',
+        "[style.background-repeat]": 'placeholder ? "no-repeat" : null',
+        "[style.background-image]": "placeholder ? generatePlaceholder(placeholder) : null",
+        "[style.filter]": 'placeholder && shouldBlurPlaceholder(placeholderConfig) ? "blur(15px)" : null'
+      }
+    }]
+  }], () => [], {
+    ngSrc: [{
+      type: Input,
+      args: [{
+        required: true,
+        transform: unwrapSafeUrl
+      }]
+    }],
+    ngSrcset: [{
+      type: Input
+    }],
+    sizes: [{
+      type: Input
+    }],
+    width: [{
+      type: Input,
+      args: [{
+        transform: numberAttribute
+      }]
+    }],
+    height: [{
+      type: Input,
+      args: [{
+        transform: numberAttribute
+      }]
+    }],
+    decoding: [{
+      type: Input
+    }],
+    loading: [{
+      type: Input
+    }],
+    priority: [{
+      type: Input,
+      args: [{
+        transform: booleanAttribute
+      }]
+    }],
+    loaderParams: [{
+      type: Input
+    }],
+    disableOptimizedSrcset: [{
+      type: Input,
+      args: [{
+        transform: booleanAttribute
+      }]
+    }],
+    fill: [{
+      type: Input,
+      args: [{
+        transform: booleanAttribute
+      }]
+    }],
+    placeholder: [{
+      type: Input,
+      args: [{
+        transform: booleanOrUrlAttribute
+      }]
+    }],
+    placeholderConfig: [{
+      type: Input
+    }],
+    src: [{
+      type: Input
+    }],
+    srcset: [{
+      type: Input
+    }]
+  });
+})();
+function processConfig(config2) {
+  let sortedBreakpoints = {};
+  if (config2.breakpoints) {
+    sortedBreakpoints.breakpoints = config2.breakpoints.sort((a, b) => a - b);
+  }
+  return Object.assign({}, IMAGE_CONFIG_DEFAULTS, config2, sortedBreakpoints);
+}
+function assertNoConflictingSrc(dir) {
+  if (dir.src) {
+    throw new RuntimeError(2950, `${imgDirectiveDetails(dir.ngSrc)} both \`src\` and \`ngSrc\` have been set. Supplying both of these attributes breaks lazy loading. The NgOptimizedImage directive sets \`src\` itself based on the value of \`ngSrc\`. To fix this, please remove the \`src\` attribute.`);
+  }
+}
+function assertNoConflictingSrcset(dir) {
+  if (dir.srcset) {
+    throw new RuntimeError(2951, `${imgDirectiveDetails(dir.ngSrc)} both \`srcset\` and \`ngSrcset\` have been set. Supplying both of these attributes breaks lazy loading. The NgOptimizedImage directive sets \`srcset\` itself based on the value of \`ngSrcset\`. To fix this, please remove the \`srcset\` attribute.`);
+  }
+}
+function assertNotBase64Image(dir) {
+  let ngSrc = dir.ngSrc.trim();
+  if (ngSrc.startsWith("data:")) {
+    if (ngSrc.length > BASE64_IMG_MAX_LENGTH_IN_ERROR) {
+      ngSrc = ngSrc.substring(0, BASE64_IMG_MAX_LENGTH_IN_ERROR) + "...";
+    }
+    throw new RuntimeError(2952, `${imgDirectiveDetails(dir.ngSrc, false)} \`ngSrc\` is a Base64-encoded string (${ngSrc}). NgOptimizedImage does not support Base64-encoded strings. To fix this, disable the NgOptimizedImage directive for this element by removing \`ngSrc\` and using a standard \`src\` attribute instead.`);
+  }
+}
+function assertNoComplexSizes(dir) {
+  let sizes = dir.sizes;
+  if (sizes?.match(/((\)|,)\s|^)\d+px/)) {
+    throw new RuntimeError(2952, `${imgDirectiveDetails(dir.ngSrc, false)} \`sizes\` was set to a string including pixel values. For automatic \`srcset\` generation, \`sizes\` must only include responsive values, such as \`sizes="50vw"\` or \`sizes="(min-width: 768px) 50vw, 100vw"\`. To fix this, modify the \`sizes\` attribute, or provide your own \`ngSrcset\` value directly.`);
+  }
+}
+function assertValidPlaceholder(dir, imageLoader) {
+  assertNoPlaceholderConfigWithoutPlaceholder(dir);
+  assertNoRelativePlaceholderWithoutLoader(dir, imageLoader);
+  assertNoOversizedDataUrl(dir);
+}
+function assertNoPlaceholderConfigWithoutPlaceholder(dir) {
+  if (dir.placeholderConfig && !dir.placeholder) {
+    throw new RuntimeError(2952, `${imgDirectiveDetails(dir.ngSrc, false)} \`placeholderConfig\` options were provided for an image that does not use the \`placeholder\` attribute, and will have no effect.`);
+  }
+}
+function assertNoRelativePlaceholderWithoutLoader(dir, imageLoader) {
+  if (dir.placeholder === true && imageLoader === noopImageLoader) {
+    throw new RuntimeError(2963, `${imgDirectiveDetails(dir.ngSrc)} the \`placeholder\` attribute is set to true but no image loader is configured (i.e. the default one is being used), which would result in the same image being used for the primary image and its placeholder. To fix this, provide a loader or remove the \`placeholder\` attribute from the image.`);
+  }
+}
+function assertNoOversizedDataUrl(dir) {
+  if (dir.placeholder && typeof dir.placeholder === "string" && dir.placeholder.startsWith("data:")) {
+    if (dir.placeholder.length > DATA_URL_ERROR_LIMIT) {
+      throw new RuntimeError(2965, `${imgDirectiveDetails(dir.ngSrc)} the \`placeholder\` attribute is set to a data URL which is longer than ${DATA_URL_ERROR_LIMIT} characters. This is strongly discouraged, as large inline placeholders directly increase the bundle size of Angular and hurt page load performance. To fix this, generate a smaller data URL placeholder.`);
+    }
+    if (dir.placeholder.length > DATA_URL_WARN_LIMIT) {
+      console.warn(formatRuntimeError(2965, `${imgDirectiveDetails(dir.ngSrc)} the \`placeholder\` attribute is set to a data URL which is longer than ${DATA_URL_WARN_LIMIT} characters. This is discouraged, as large inline placeholders directly increase the bundle size of Angular and hurt page load performance. For better loading performance, generate a smaller data URL placeholder.`));
+    }
+  }
+}
+function assertNotBlobUrl(dir) {
+  const ngSrc = dir.ngSrc.trim();
+  if (ngSrc.startsWith("blob:")) {
+    throw new RuntimeError(2952, `${imgDirectiveDetails(dir.ngSrc)} \`ngSrc\` was set to a blob URL (${ngSrc}). Blob URLs are not supported by the NgOptimizedImage directive. To fix this, disable the NgOptimizedImage directive for this element by removing \`ngSrc\` and using a regular \`src\` attribute instead.`);
+  }
+}
+function assertNonEmptyInput(dir, name, value) {
+  const isString = typeof value === "string";
+  const isEmptyString = isString && value.trim() === "";
+  if (!isString || isEmptyString) {
+    throw new RuntimeError(2952, `${imgDirectiveDetails(dir.ngSrc)} \`${name}\` has an invalid value (\`${value}\`). To fix this, change the value to a non-empty string.`);
+  }
+}
+function assertValidNgSrcset(dir, value) {
+  if (value == null) return;
+  assertNonEmptyInput(dir, "ngSrcset", value);
+  const stringVal = value;
+  const isValidWidthDescriptor = VALID_WIDTH_DESCRIPTOR_SRCSET.test(stringVal);
+  const isValidDensityDescriptor = VALID_DENSITY_DESCRIPTOR_SRCSET.test(stringVal);
+  if (isValidDensityDescriptor) {
+    assertUnderDensityCap(dir, stringVal);
+  }
+  const isValidSrcset = isValidWidthDescriptor || isValidDensityDescriptor;
+  if (!isValidSrcset) {
+    throw new RuntimeError(2952, `${imgDirectiveDetails(dir.ngSrc)} \`ngSrcset\` has an invalid value (\`${value}\`). To fix this, supply \`ngSrcset\` using a comma-separated list of one or more width descriptors (e.g. "100w, 200w") or density descriptors (e.g. "1x, 2x").`);
+  }
+}
+function assertUnderDensityCap(dir, value) {
+  const underDensityCap = value.split(",").every((num) => num === "" || parseFloat(num) <= ABSOLUTE_SRCSET_DENSITY_CAP);
+  if (!underDensityCap) {
+    throw new RuntimeError(2952, `${imgDirectiveDetails(dir.ngSrc)} the \`ngSrcset\` contains an unsupported image density:\`${value}\`. NgOptimizedImage generally recommends a max image density of ${RECOMMENDED_SRCSET_DENSITY_CAP}x but supports image densities up to ${ABSOLUTE_SRCSET_DENSITY_CAP}x. The human eye cannot distinguish between image densities greater than ${RECOMMENDED_SRCSET_DENSITY_CAP}x - which makes them unnecessary for most use cases. Images that will be pinch-zoomed are typically the primary use case for ${ABSOLUTE_SRCSET_DENSITY_CAP}x images. Please remove the high density descriptor and try again.`);
+  }
+}
+function postInitInputChangeError(dir, inputName) {
+  let reason;
+  if (inputName === "width" || inputName === "height") {
+    reason = `Changing \`${inputName}\` may result in different attribute value applied to the underlying image element and cause layout shifts on a page.`;
+  } else {
+    reason = `Changing the \`${inputName}\` would have no effect on the underlying image element, because the resource loading has already occurred.`;
+  }
+  return new RuntimeError(2953, `${imgDirectiveDetails(dir.ngSrc)} \`${inputName}\` was updated after initialization. The NgOptimizedImage directive will not react to this input change. ${reason} To fix this, either switch \`${inputName}\` to a static value or wrap the image element in an @if that is gated on the necessary value.`);
+}
+function assertNoPostInitInputChange(dir, changes, inputs) {
+  inputs.forEach((input2) => {
+    const isUpdated = changes.hasOwnProperty(input2);
+    if (isUpdated && !changes[input2].isFirstChange()) {
+      if (input2 === "ngSrc") {
+        dir = {
+          ngSrc: changes[input2].previousValue
+        };
+      }
+      throw postInitInputChangeError(dir, input2);
+    }
+  });
+}
+function assertGreaterThanZero(dir, inputValue, inputName) {
+  const validNumber = typeof inputValue === "number" && inputValue > 0;
+  const validString = typeof inputValue === "string" && /^\d+$/.test(inputValue.trim()) && parseInt(inputValue) > 0;
+  if (!validNumber && !validString) {
+    throw new RuntimeError(2952, `${imgDirectiveDetails(dir.ngSrc)} \`${inputName}\` has an invalid value. To fix this, provide \`${inputName}\` as a number greater than 0.`);
+  }
+}
+function assertNoImageDistortion(dir, img, renderer, destroyRef) {
+  const callback = () => {
+    removeLoadListenerFn();
+    removeErrorListenerFn();
+    const computedStyle = window.getComputedStyle(img);
+    let renderedWidth = parseFloat(computedStyle.getPropertyValue("width"));
+    let renderedHeight = parseFloat(computedStyle.getPropertyValue("height"));
+    const boxSizing = computedStyle.getPropertyValue("box-sizing");
+    if (boxSizing === "border-box") {
+      const paddingTop = computedStyle.getPropertyValue("padding-top");
+      const paddingRight = computedStyle.getPropertyValue("padding-right");
+      const paddingBottom = computedStyle.getPropertyValue("padding-bottom");
+      const paddingLeft = computedStyle.getPropertyValue("padding-left");
+      renderedWidth -= parseFloat(paddingRight) + parseFloat(paddingLeft);
+      renderedHeight -= parseFloat(paddingTop) + parseFloat(paddingBottom);
+    }
+    const renderedAspectRatio = renderedWidth / renderedHeight;
+    const nonZeroRenderedDimensions = renderedWidth !== 0 && renderedHeight !== 0;
+    const intrinsicWidth = img.naturalWidth;
+    const intrinsicHeight = img.naturalHeight;
+    const intrinsicAspectRatio = intrinsicWidth / intrinsicHeight;
+    const suppliedWidth = dir.width;
+    const suppliedHeight = dir.height;
+    const suppliedAspectRatio = suppliedWidth / suppliedHeight;
+    const inaccurateDimensions = Math.abs(suppliedAspectRatio - intrinsicAspectRatio) > ASPECT_RATIO_TOLERANCE;
+    const stylingDistortion = nonZeroRenderedDimensions && Math.abs(intrinsicAspectRatio - renderedAspectRatio) > ASPECT_RATIO_TOLERANCE;
+    if (inaccurateDimensions) {
+      console.warn(formatRuntimeError(2952, `${imgDirectiveDetails(dir.ngSrc)} the aspect ratio of the image does not match the aspect ratio indicated by the width and height attributes. 
+Intrinsic image size: ${intrinsicWidth}w x ${intrinsicHeight}h (aspect-ratio: ${round(intrinsicAspectRatio)}). 
+Supplied width and height attributes: ${suppliedWidth}w x ${suppliedHeight}h (aspect-ratio: ${round(suppliedAspectRatio)}). 
+To fix this, update the width and height attributes.`));
+    } else if (stylingDistortion) {
+      console.warn(formatRuntimeError(2952, `${imgDirectiveDetails(dir.ngSrc)} the aspect ratio of the rendered image does not match the image's intrinsic aspect ratio. 
+Intrinsic image size: ${intrinsicWidth}w x ${intrinsicHeight}h (aspect-ratio: ${round(intrinsicAspectRatio)}). 
+Rendered image size: ${renderedWidth}w x ${renderedHeight}h (aspect-ratio: ${round(renderedAspectRatio)}). 
+This issue can occur if "width" and "height" attributes are added to an image without updating the corresponding image styling. To fix this, adjust image styling. In most cases, adding "height: auto" or "width: auto" to the image styling will fix this issue.`));
+    } else if (!dir.ngSrcset && nonZeroRenderedDimensions) {
+      const recommendedWidth = RECOMMENDED_SRCSET_DENSITY_CAP * renderedWidth;
+      const recommendedHeight = RECOMMENDED_SRCSET_DENSITY_CAP * renderedHeight;
+      const oversizedWidth = intrinsicWidth - recommendedWidth >= OVERSIZED_IMAGE_TOLERANCE2;
+      const oversizedHeight = intrinsicHeight - recommendedHeight >= OVERSIZED_IMAGE_TOLERANCE2;
+      if (oversizedWidth || oversizedHeight) {
+        console.warn(formatRuntimeError(2960, `${imgDirectiveDetails(dir.ngSrc)} the intrinsic image is significantly larger than necessary. 
+Rendered image size: ${renderedWidth}w x ${renderedHeight}h. 
+Intrinsic image size: ${intrinsicWidth}w x ${intrinsicHeight}h. 
+Recommended intrinsic image size: ${recommendedWidth}w x ${recommendedHeight}h. 
+Note: Recommended intrinsic image size is calculated assuming a maximum DPR of ${RECOMMENDED_SRCSET_DENSITY_CAP}. To improve loading time, resize the image or consider using the "ngSrcset" and "sizes" attributes.`));
+      }
+    }
+  };
+  const removeLoadListenerFn = renderer.listen(img, "load", callback);
+  const removeErrorListenerFn = renderer.listen(img, "error", () => {
+    removeLoadListenerFn();
+    removeErrorListenerFn();
+  });
+  destroyRef.onDestroy(() => {
+    removeLoadListenerFn();
+    removeErrorListenerFn();
+  });
+  callOnLoadIfImageIsLoaded(img, callback);
+}
+function assertNonEmptyWidthAndHeight(dir) {
+  let missingAttributes = [];
+  if (dir.width === void 0) missingAttributes.push("width");
+  if (dir.height === void 0) missingAttributes.push("height");
+  if (missingAttributes.length > 0) {
+    throw new RuntimeError(2954, `${imgDirectiveDetails(dir.ngSrc)} these required attributes are missing: ${missingAttributes.map((attr) => `"${attr}"`).join(", ")}. Including "width" and "height" attributes will prevent image-related layout shifts. To fix this, include "width" and "height" attributes on the image tag or turn on "fill" mode with the \`fill\` attribute.`);
+  }
+}
+function assertEmptyWidthAndHeight(dir) {
+  if (dir.width || dir.height) {
+    throw new RuntimeError(2952, `${imgDirectiveDetails(dir.ngSrc)} the attributes \`height\` and/or \`width\` are present along with the \`fill\` attribute. Because \`fill\` mode causes an image to fill its containing element, the size attributes have no effect and should be removed.`);
+  }
+}
+function assertNonZeroRenderedHeight(dir, img, renderer, destroyRef) {
+  const callback = () => {
+    removeLoadListenerFn();
+    removeErrorListenerFn();
+    const renderedHeight = img.clientHeight;
+    if (dir.fill && renderedHeight === 0) {
+      console.warn(formatRuntimeError(2952, `${imgDirectiveDetails(dir.ngSrc)} the height of the fill-mode image is zero. This is likely because the containing element does not have the CSS 'position' property set to one of the following: "relative", "fixed", or "absolute". To fix this problem, make sure the container element has the CSS 'position' property defined and the height of the element is not zero.`));
+    }
+  };
+  const removeLoadListenerFn = renderer.listen(img, "load", callback);
+  const removeErrorListenerFn = renderer.listen(img, "error", () => {
+    removeLoadListenerFn();
+    removeErrorListenerFn();
+  });
+  destroyRef.onDestroy(() => {
+    removeLoadListenerFn();
+    removeErrorListenerFn();
+  });
+  callOnLoadIfImageIsLoaded(img, callback);
+}
+function assertValidLoadingInput(dir) {
+  if (dir.loading && dir.priority) {
+    throw new RuntimeError(2952, `${imgDirectiveDetails(dir.ngSrc)} the \`loading\` attribute was used on an image that was marked "priority". Setting \`loading\` on priority images is not allowed because these images will always be eagerly loaded. To fix this, remove the \u201Cloading\u201D attribute from the priority image.`);
+  }
+  const validInputs = ["auto", "eager", "lazy"];
+  if (typeof dir.loading === "string" && !validInputs.includes(dir.loading)) {
+    throw new RuntimeError(2952, `${imgDirectiveDetails(dir.ngSrc)} the \`loading\` attribute has an invalid value (\`${dir.loading}\`). To fix this, provide a valid value ("lazy", "eager", or "auto").`);
+  }
+}
+function assertValidDecodingInput(dir) {
+  const validInputs = ["sync", "async", "auto"];
+  if (typeof dir.decoding === "string" && !validInputs.includes(dir.decoding)) {
+    throw new RuntimeError(2952, `${imgDirectiveDetails(dir.ngSrc)} the \`decoding\` attribute has an invalid value (\`${dir.decoding}\`). To fix this, provide a valid value ("sync", "async", or "auto").`);
+  }
+}
+function assertNotMissingBuiltInLoader(ngSrc, imageLoader) {
+  if (imageLoader === noopImageLoader) {
+    let builtInLoaderName = "";
+    for (const loader of BUILT_IN_LOADERS) {
+      if (loader.testUrl(ngSrc)) {
+        builtInLoaderName = loader.name;
+        break;
+      }
+    }
+    if (builtInLoaderName) {
+      console.warn(formatRuntimeError(2962, `NgOptimizedImage: It looks like your images may be hosted on the ${builtInLoaderName} CDN, but your app is not using Angular's built-in loader for that CDN. We recommend switching to use the built-in by calling \`provide${builtInLoaderName}Loader()\` in your \`providers\` and passing it your instance's base URL. If you don't want to use the built-in loader, define a custom loader function using IMAGE_LOADER to silence this warning.`));
+    }
+  }
+}
+function assertNoNgSrcsetWithoutLoader(dir, imageLoader) {
+  if (dir.ngSrcset && imageLoader === noopImageLoader) {
+    console.warn(formatRuntimeError(2963, `${imgDirectiveDetails(dir.ngSrc)} the \`ngSrcset\` attribute is present but no image loader is configured (i.e. the default one is being used), which would result in the same image being used for all configured sizes. To fix this, provide a loader or remove the \`ngSrcset\` attribute from the image.`));
+  }
+}
+function assertNoLoaderParamsWithoutLoader(dir, imageLoader) {
+  if (dir.loaderParams && imageLoader === noopImageLoader) {
+    console.warn(formatRuntimeError(2963, `${imgDirectiveDetails(dir.ngSrc)} the \`loaderParams\` attribute is present but no image loader is configured (i.e. the default one is being used), which means that the loaderParams data will not be consumed and will not affect the URL. To fix this, provide a custom loader or remove the \`loaderParams\` attribute from the image.`));
+  }
+}
+async function assetPriorityCountBelowThreshold(appRef) {
+  if (IMGS_WITH_PRIORITY_ATTR_COUNT === 0) {
+    IMGS_WITH_PRIORITY_ATTR_COUNT++;
+    await appRef.whenStable();
+    if (IMGS_WITH_PRIORITY_ATTR_COUNT > PRIORITY_COUNT_THRESHOLD) {
+      console.warn(formatRuntimeError(2966, `NgOptimizedImage: The "priority" attribute is set to true more than ${PRIORITY_COUNT_THRESHOLD} times (${IMGS_WITH_PRIORITY_ATTR_COUNT} times). Marking too many images as "high" priority can hurt your application's LCP (https://web.dev/lcp). "Priority" should only be set on the image expected to be the page's LCP element.`));
+    }
+  } else {
+    IMGS_WITH_PRIORITY_ATTR_COUNT++;
+  }
+}
+function assertPlaceholderDimensions(dir, imgElement) {
+  const computedStyle = window.getComputedStyle(imgElement);
+  let renderedWidth = parseFloat(computedStyle.getPropertyValue("width"));
+  let renderedHeight = parseFloat(computedStyle.getPropertyValue("height"));
+  if (renderedWidth > PLACEHOLDER_DIMENSION_LIMIT || renderedHeight > PLACEHOLDER_DIMENSION_LIMIT) {
+    console.warn(formatRuntimeError(2967, `${imgDirectiveDetails(dir.ngSrc)} it uses a placeholder image, but at least one of the dimensions attribute (height or width) exceeds the limit of ${PLACEHOLDER_DIMENSION_LIMIT}px. To fix this, use a smaller image as a placeholder.`));
+  }
+}
+function callOnLoadIfImageIsLoaded(img, callback) {
+  if (img.complete && img.naturalWidth) {
+    callback();
+  }
+}
+function round(input2) {
+  return Number.isInteger(input2) ? input2 : input2.toFixed(2);
+}
+function unwrapSafeUrl(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  return unwrapSafeValue(value);
+}
+function escapeCssUrl(input2) {
+  return input2.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function booleanOrUrlAttribute(value) {
+  if (typeof value === "string" && value !== "true" && value !== "false" && value !== "") {
+    return value;
+  }
+  return booleanAttribute(value);
+}
+
+// node_modules/@angular/platform-browser/fesm2022/_dom_renderer-chunk.mjs
+/**
+ * @license Angular v21.2.17
+ * (c) 2010-2026 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+var EventManagerPlugin = class {
+  _doc;
+  constructor(_doc) {
+    this._doc = _doc;
+  }
+  manager;
+};
+var DomEventsPlugin = class _DomEventsPlugin extends EventManagerPlugin {
+  constructor(doc) {
+    super(doc);
+  }
+  supports(eventName) {
+    return true;
+  }
+  addEventListener(element, eventName, handler, options) {
+    element.addEventListener(eventName, handler, options);
+    return () => this.removeEventListener(element, eventName, handler, options);
+  }
+  removeEventListener(target, eventName, callback, options) {
+    return target.removeEventListener(eventName, callback, options);
+  }
+  static \u0275fac = function DomEventsPlugin_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _DomEventsPlugin)(\u0275\u0275inject(DOCUMENT));
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _DomEventsPlugin,
+    factory: _DomEventsPlugin.\u0275fac
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DomEventsPlugin, [{
+    type: Injectable
+  }], () => [{
+    type: void 0,
+    decorators: [{
+      type: Inject,
+      args: [DOCUMENT]
+    }]
+  }], null);
+})();
+var EVENT_MANAGER_PLUGINS = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "EventManagerPlugins" : "");
+var EventManager = class _EventManager {
+  _zone;
+  _plugins;
+  _eventNameToPlugin = /* @__PURE__ */ new Map();
+  constructor(plugins, _zone) {
+    this._zone = _zone;
+    plugins.forEach((plugin) => {
+      plugin.manager = this;
+    });
+    const otherPlugins = plugins.filter((p) => !(p instanceof DomEventsPlugin));
+    this._plugins = otherPlugins.slice().reverse();
+    const domEventPlugin = plugins.find((p) => p instanceof DomEventsPlugin);
+    if (domEventPlugin) {
+      this._plugins.push(domEventPlugin);
+    }
+  }
+  addEventListener(element, eventName, handler, options) {
+    const plugin = this._findPluginFor(eventName);
+    return plugin.addEventListener(element, eventName, handler, options);
+  }
+  getZone() {
+    return this._zone;
+  }
+  _findPluginFor(eventName) {
+    let plugin = this._eventNameToPlugin.get(eventName);
+    if (plugin) {
+      return plugin;
+    }
+    const plugins = this._plugins;
+    plugin = plugins.find((plugin2) => plugin2.supports(eventName));
+    if (!plugin) {
+      throw new RuntimeError(5101, (typeof ngDevMode === "undefined" || ngDevMode) && `No event manager plugin found for event ${eventName}`);
+    }
+    this._eventNameToPlugin.set(eventName, plugin);
+    return plugin;
+  }
+  static \u0275fac = function EventManager_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _EventManager)(\u0275\u0275inject(EVENT_MANAGER_PLUGINS), \u0275\u0275inject(NgZone));
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _EventManager,
+    factory: _EventManager.\u0275fac
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(EventManager, [{
+    type: Injectable
+  }], () => [{
+    type: void 0,
+    decorators: [{
+      type: Inject,
+      args: [EVENT_MANAGER_PLUGINS]
+    }]
+  }, {
+    type: NgZone
+  }], null);
+})();
+var APP_ID_ATTRIBUTE_NAME = "ng-app-id";
+function removeElements(elements) {
+  for (const element of elements) {
+    element.remove();
+  }
+}
+function createStyleElement(style, doc) {
+  const styleElement = doc.createElement("style");
+  styleElement.textContent = style;
+  return styleElement;
+}
+function addServerStyles(doc, appId, inline, external) {
+  const elements = doc.head?.querySelectorAll(`style[${APP_ID_ATTRIBUTE_NAME}="${appId}"],link[${APP_ID_ATTRIBUTE_NAME}="${appId}"]`);
+  if (elements) {
+    for (const styleElement of elements) {
+      styleElement.removeAttribute(APP_ID_ATTRIBUTE_NAME);
+      if (styleElement instanceof HTMLLinkElement) {
+        external.set(styleElement.href.slice(styleElement.href.lastIndexOf("/") + 1), {
+          usage: 0,
+          elements: [styleElement]
+        });
+      } else if (styleElement.textContent) {
+        inline.set(styleElement.textContent, {
+          usage: 0,
+          elements: [styleElement]
+        });
+      }
+    }
+  }
+}
+function createLinkElement(url, doc) {
+  const linkElement = doc.createElement("link");
+  linkElement.setAttribute("rel", "stylesheet");
+  linkElement.setAttribute("href", url);
+  return linkElement;
+}
+var SharedStylesHost = class _SharedStylesHost {
+  doc;
+  appId;
+  nonce;
+  inline = /* @__PURE__ */ new Map();
+  external = /* @__PURE__ */ new Map();
+  hosts = /* @__PURE__ */ new Set();
+  constructor(doc, appId, nonce, platformId = {}) {
+    this.doc = doc;
+    this.appId = appId;
+    this.nonce = nonce;
+    addServerStyles(doc, appId, this.inline, this.external);
+    this.hosts.add(doc.head);
+  }
+  addStyles(styles, urls) {
+    for (const value of styles) {
+      this.addUsage(value, this.inline, createStyleElement);
+    }
+    urls?.forEach((value) => this.addUsage(value, this.external, createLinkElement));
+  }
+  removeStyles(styles, urls) {
+    for (const value of styles) {
+      this.removeUsage(value, this.inline);
+    }
+    urls?.forEach((value) => this.removeUsage(value, this.external));
+  }
+  addUsage(value, usages, creator) {
+    const record = usages.get(value);
+    if (record) {
+      if ((typeof ngDevMode === "undefined" || ngDevMode) && record.usage === 0) {
+        record.elements.forEach((element) => element.setAttribute("ng-style-reused", ""));
+      }
+      record.usage++;
+    } else {
+      usages.set(value, {
+        usage: 1,
+        elements: [...this.hosts].map((host) => this.addElement(host, creator(value, this.doc)))
+      });
+    }
+  }
+  removeUsage(value, usages) {
+    const record = usages.get(value);
+    if (record) {
+      record.usage--;
+      if (record.usage <= 0) {
+        removeElements(record.elements);
+        usages.delete(value);
+      }
+    }
+  }
+  ngOnDestroy() {
+    for (const [, {
+      elements
+    }] of [...this.inline, ...this.external]) {
+      removeElements(elements);
+    }
+    this.hosts.clear();
+  }
+  addHost(hostNode) {
+    this.hosts.add(hostNode);
+    for (const [style, {
+      elements
+    }] of this.inline) {
+      elements.push(this.addElement(hostNode, createStyleElement(style, this.doc)));
+    }
+    for (const [url, {
+      elements
+    }] of this.external) {
+      elements.push(this.addElement(hostNode, createLinkElement(url, this.doc)));
+    }
+  }
+  removeHost(hostNode) {
+    this.hosts.delete(hostNode);
+  }
+  addElement(host, element) {
+    if (this.nonce) {
+      element.setAttribute("nonce", this.nonce);
+    }
+    if (false) {
+      element.setAttribute(APP_ID_ATTRIBUTE_NAME, this.appId);
+    }
+    return host.appendChild(element);
+  }
+  static \u0275fac = function SharedStylesHost_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _SharedStylesHost)(\u0275\u0275inject(DOCUMENT), \u0275\u0275inject(APP_ID), \u0275\u0275inject(CSP_NONCE, 8), \u0275\u0275inject(PLATFORM_ID));
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _SharedStylesHost,
+    factory: _SharedStylesHost.\u0275fac
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(SharedStylesHost, [{
+    type: Injectable
+  }], () => [{
+    type: Document,
+    decorators: [{
+      type: Inject,
+      args: [DOCUMENT]
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Inject,
+      args: [APP_ID]
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Inject,
+      args: [CSP_NONCE]
+    }, {
+      type: Optional
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Inject,
+      args: [PLATFORM_ID]
+    }]
+  }], null);
+})();
+var NAMESPACE_URIS = {
+  "svg": "http://www.w3.org/2000/svg",
+  "xhtml": "http://www.w3.org/1999/xhtml",
+  "xlink": "http://www.w3.org/1999/xlink",
+  "xml": "http://www.w3.org/XML/1998/namespace",
+  "xmlns": "http://www.w3.org/2000/xmlns/",
+  "math": "http://www.w3.org/1998/Math/MathML"
+};
+var COMPONENT_REGEX = /%COMP%/g;
+var SOURCEMAP_URL_REGEXP = /\/\*#\s*sourceMappingURL=(.+?)\s*\*\//;
+var PROTOCOL_REGEXP = /^https?:/;
+var COMPONENT_VARIABLE = "%COMP%";
+var HOST_ATTR = `_nghost-${COMPONENT_VARIABLE}`;
+var CONTENT_ATTR = `_ngcontent-${COMPONENT_VARIABLE}`;
+var REMOVE_STYLES_ON_COMPONENT_DESTROY_DEFAULT = true;
+var REMOVE_STYLES_ON_COMPONENT_DESTROY = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "RemoveStylesOnCompDestroy" : "", {
+  factory: () => REMOVE_STYLES_ON_COMPONENT_DESTROY_DEFAULT
+});
+function shimContentAttribute(componentShortId) {
+  return CONTENT_ATTR.replace(COMPONENT_REGEX, componentShortId);
+}
+function shimHostAttribute(componentShortId) {
+  return HOST_ATTR.replace(COMPONENT_REGEX, componentShortId);
+}
+function shimStylesContent(compId, styles) {
+  return styles.map((s) => s.replace(COMPONENT_REGEX, compId));
+}
+function addBaseHrefToCssSourceMap(baseHref, styles) {
+  if (!baseHref) {
+    return styles;
+  }
+  const absoluteBaseHrefUrl = new URL(baseHref, "http://localhost");
+  return styles.map((cssContent) => {
+    if (!cssContent.includes("sourceMappingURL=")) {
+      return cssContent;
+    }
+    return cssContent.replace(SOURCEMAP_URL_REGEXP, (_, sourceMapUrl) => {
+      if (sourceMapUrl[0] === "/" || sourceMapUrl.startsWith("data:") || PROTOCOL_REGEXP.test(sourceMapUrl)) {
+        return `/*# sourceMappingURL=${sourceMapUrl} */`;
+      }
+      const {
+        pathname: resolvedSourceMapUrl
+      } = new URL(sourceMapUrl, absoluteBaseHrefUrl);
+      return `/*# sourceMappingURL=${resolvedSourceMapUrl} */`;
+    });
+  });
+}
+var DomRendererFactory2 = class _DomRendererFactory2 {
+  eventManager;
+  sharedStylesHost;
+  appId;
+  removeStylesOnCompDestroy;
+  doc;
+  ngZone;
+  nonce;
+  tracingService;
+  rendererByCompId = /* @__PURE__ */ new Map();
+  defaultRenderer;
+  constructor(eventManager, sharedStylesHost, appId, removeStylesOnCompDestroy, doc, ngZone, nonce = null, tracingService = null) {
+    this.eventManager = eventManager;
+    this.sharedStylesHost = sharedStylesHost;
+    this.appId = appId;
+    this.removeStylesOnCompDestroy = removeStylesOnCompDestroy;
+    this.doc = doc;
+    this.ngZone = ngZone;
+    this.nonce = nonce;
+    this.tracingService = tracingService;
+    this.defaultRenderer = new DefaultDomRenderer2(eventManager, doc, ngZone, this.tracingService);
+  }
+  createRenderer(element, type) {
+    if (!element || !type) {
+      return this.defaultRenderer;
+    }
+    if (false) {
+      type = __spreadProps(__spreadValues({}, type), {
+        encapsulation: ViewEncapsulation.Emulated
+      });
+    }
+    const renderer = this.getOrCreateRenderer(element, type);
+    if (renderer instanceof EmulatedEncapsulationDomRenderer2) {
+      renderer.applyToHost(element);
+    } else if (renderer instanceof NoneEncapsulationDomRenderer) {
+      renderer.applyStyles();
+    }
+    return renderer;
+  }
+  getOrCreateRenderer(element, type) {
+    const rendererByCompId = this.rendererByCompId;
+    let renderer = rendererByCompId.get(type.id);
+    if (!renderer) {
+      const doc = this.doc;
+      const ngZone = this.ngZone;
+      const eventManager = this.eventManager;
+      const sharedStylesHost = this.sharedStylesHost;
+      const removeStylesOnCompDestroy = this.removeStylesOnCompDestroy;
+      const tracingService = this.tracingService;
+      switch (type.encapsulation) {
+        case ViewEncapsulation.Emulated:
+          renderer = new EmulatedEncapsulationDomRenderer2(eventManager, sharedStylesHost, type, this.appId, removeStylesOnCompDestroy, doc, ngZone, tracingService);
+          break;
+        case ViewEncapsulation.ShadowDom:
+          return new ShadowDomRenderer(eventManager, element, type, doc, ngZone, this.nonce, tracingService, sharedStylesHost);
+        case ViewEncapsulation.ExperimentalIsolatedShadowDom:
+          return new ShadowDomRenderer(eventManager, element, type, doc, ngZone, this.nonce, tracingService);
+        default:
+          renderer = new NoneEncapsulationDomRenderer(eventManager, sharedStylesHost, type, removeStylesOnCompDestroy, doc, ngZone, tracingService);
+          break;
+      }
+      rendererByCompId.set(type.id, renderer);
+    }
+    return renderer;
+  }
+  ngOnDestroy() {
+    this.rendererByCompId.clear();
+  }
+  componentReplaced(componentId) {
+    this.rendererByCompId.delete(componentId);
+  }
+  static \u0275fac = function DomRendererFactory2_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _DomRendererFactory2)(\u0275\u0275inject(EventManager), \u0275\u0275inject(SharedStylesHost), \u0275\u0275inject(APP_ID), \u0275\u0275inject(REMOVE_STYLES_ON_COMPONENT_DESTROY), \u0275\u0275inject(DOCUMENT), \u0275\u0275inject(NgZone), \u0275\u0275inject(CSP_NONCE), \u0275\u0275inject(TracingService, 8));
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _DomRendererFactory2,
+    factory: _DomRendererFactory2.\u0275fac
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DomRendererFactory2, [{
+    type: Injectable
+  }], () => [{
+    type: EventManager
+  }, {
+    type: SharedStylesHost
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Inject,
+      args: [APP_ID]
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Inject,
+      args: [REMOVE_STYLES_ON_COMPONENT_DESTROY]
+    }]
+  }, {
+    type: Document,
+    decorators: [{
+      type: Inject,
+      args: [DOCUMENT]
+    }]
+  }, {
+    type: NgZone
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Inject,
+      args: [CSP_NONCE]
+    }]
+  }, {
+    type: TracingService,
+    decorators: [{
+      type: Inject,
+      args: [TracingService]
+    }, {
+      type: Optional
+    }]
+  }], null);
+})();
+var DefaultDomRenderer2 = class {
+  eventManager;
+  doc;
+  ngZone;
+  tracingService;
+  data = /* @__PURE__ */ Object.create(null);
+  throwOnSyntheticProps = true;
+  constructor(eventManager, doc, ngZone, tracingService) {
+    this.eventManager = eventManager;
+    this.doc = doc;
+    this.ngZone = ngZone;
+    this.tracingService = tracingService;
+  }
+  destroy() {
+  }
+  destroyNode = null;
+  createElement(name, namespace) {
+    if (namespace) {
+      return this.doc.createElementNS(NAMESPACE_URIS[namespace] || namespace, name);
+    }
+    return this.doc.createElement(name);
+  }
+  createComment(value) {
+    return this.doc.createComment(value);
+  }
+  createText(value) {
+    return this.doc.createTextNode(value);
+  }
+  appendChild(parent, newChild) {
+    const targetParent = isTemplateNode(parent) ? parent.content : parent;
+    targetParent.appendChild(newChild);
+  }
+  insertBefore(parent, newChild, refChild) {
+    if (parent) {
+      const targetParent = isTemplateNode(parent) ? parent.content : parent;
+      targetParent.insertBefore(newChild, refChild);
+    }
+  }
+  removeChild(_parent, oldChild) {
+    oldChild.remove();
+  }
+  selectRootElement(selectorOrNode, preserveContent) {
+    let el = typeof selectorOrNode === "string" ? this.doc.querySelector(selectorOrNode) : selectorOrNode;
+    if (!el) {
+      throw new RuntimeError(-5104, (typeof ngDevMode === "undefined" || ngDevMode) && `The selector "${selectorOrNode}" did not match any elements`);
+    }
+    if (!preserveContent) {
+      el.textContent = "";
+    }
+    return el;
+  }
+  parentNode(node) {
+    return node.parentNode;
+  }
+  nextSibling(node) {
+    return node.nextSibling;
+  }
+  setAttribute(el, name, value, namespace) {
+    if (namespace) {
+      name = namespace + ":" + name;
+      const namespaceUri = NAMESPACE_URIS[namespace];
+      if (namespaceUri) {
+        el.setAttributeNS(namespaceUri, name, value);
+      } else {
+        el.setAttribute(name, value);
+      }
+    } else {
+      el.setAttribute(name, value);
+    }
+  }
+  removeAttribute(el, name, namespace) {
+    if (namespace) {
+      const namespaceUri = NAMESPACE_URIS[namespace];
+      if (namespaceUri) {
+        el.removeAttributeNS(namespaceUri, name);
+      } else {
+        el.removeAttribute(`${namespace}:${name}`);
+      }
+    } else {
+      el.removeAttribute(name);
+    }
+  }
+  addClass(el, name) {
+    el.classList.add(name);
+  }
+  removeClass(el, name) {
+    el.classList.remove(name);
+  }
+  setStyle(el, style, value, flags) {
+    if (flags & (RendererStyleFlags2.DashCase | RendererStyleFlags2.Important)) {
+      el.style.setProperty(style, value, flags & RendererStyleFlags2.Important ? "important" : "");
+    } else {
+      el.style[style] = value;
+    }
+  }
+  removeStyle(el, style, flags) {
+    if (flags & RendererStyleFlags2.DashCase) {
+      el.style.removeProperty(style);
+    } else {
+      el.style[style] = "";
+    }
+  }
+  setProperty(el, name, value) {
+    if (el == null) {
+      return;
+    }
+    (typeof ngDevMode === "undefined" || ngDevMode) && this.throwOnSyntheticProps && checkNoSyntheticProp(name, "property");
+    el[name] = value;
+  }
+  setValue(node, value) {
+    node.nodeValue = value;
+  }
+  listen(target, event, callback, options) {
+    (typeof ngDevMode === "undefined" || ngDevMode) && this.throwOnSyntheticProps && checkNoSyntheticProp(event, "listener");
+    if (typeof target === "string") {
+      target = getDOM().getGlobalEventTarget(this.doc, target);
+      if (!target) {
+        throw new RuntimeError(5102, (typeof ngDevMode === "undefined" || ngDevMode) && `Unsupported event target ${target} for event ${event}`);
+      }
+    }
+    let wrappedCallback = this.decoratePreventDefault(callback);
+    if (this.tracingService?.wrapEventListener) {
+      wrappedCallback = this.tracingService.wrapEventListener(target, event, wrappedCallback);
+    }
+    return this.eventManager.addEventListener(target, event, wrappedCallback, options);
+  }
+  decoratePreventDefault(eventHandler) {
+    return (event) => {
+      if (event === "__ngUnwrap__") {
+        return eventHandler;
+      }
+      const allowDefaultBehavior = false ? this.ngZone.runGuarded(() => eventHandler(event)) : eventHandler(event);
+      if (allowDefaultBehavior === false) {
+        event.preventDefault();
+      }
+      return void 0;
+    };
+  }
+};
+var AT_CHARCODE = (() => "@".charCodeAt(0))();
+function checkNoSyntheticProp(name, nameKind) {
+  if (name.charCodeAt(0) === AT_CHARCODE) {
+    throw new RuntimeError(5105, `Unexpected synthetic ${nameKind} ${name} found. Please make sure that:
+  - Make sure \`provideAnimationsAsync()\`, \`provideAnimations()\` or \`provideNoopAnimations()\` call was added to a list of providers used to bootstrap an application.
+  - There is a corresponding animation configuration named \`${name}\` defined in the \`animations\` field of the \`@Component\` decorator (see https://angular.dev/api/core/Component#animations).`);
+  }
+}
+function isTemplateNode(node) {
+  return node.tagName === "TEMPLATE" && node.content !== void 0;
+}
+var ShadowDomRenderer = class extends DefaultDomRenderer2 {
+  hostEl;
+  sharedStylesHost;
+  shadowRoot;
+  constructor(eventManager, hostEl, component, doc, ngZone, nonce, tracingService, sharedStylesHost) {
+    super(eventManager, doc, ngZone, tracingService);
+    this.hostEl = hostEl;
+    this.sharedStylesHost = sharedStylesHost;
+    this.shadowRoot = hostEl.attachShadow({
+      mode: "open"
+    });
+    if (this.sharedStylesHost) {
+      this.sharedStylesHost.addHost(this.shadowRoot);
+    }
+    let styles = component.styles;
+    if (ngDevMode) {
+      const baseHref = getDOM().getBaseHref(doc) ?? "";
+      styles = addBaseHrefToCssSourceMap(baseHref, styles);
+    }
+    styles = shimStylesContent(component.id, styles);
+    for (const style of styles) {
+      const styleEl = document.createElement("style");
+      if (nonce) {
+        styleEl.setAttribute("nonce", nonce);
+      }
+      styleEl.textContent = style;
+      this.shadowRoot.appendChild(styleEl);
+    }
+    const styleUrls = component.getExternalStyles?.();
+    if (styleUrls) {
+      for (const styleUrl of styleUrls) {
+        const linkEl = createLinkElement(styleUrl, doc);
+        if (nonce) {
+          linkEl.setAttribute("nonce", nonce);
+        }
+        this.shadowRoot.appendChild(linkEl);
+      }
+    }
+  }
+  nodeOrShadowRoot(node) {
+    return node === this.hostEl ? this.shadowRoot : node;
+  }
+  appendChild(parent, newChild) {
+    return super.appendChild(this.nodeOrShadowRoot(parent), newChild);
+  }
+  insertBefore(parent, newChild, refChild) {
+    return super.insertBefore(this.nodeOrShadowRoot(parent), newChild, refChild);
+  }
+  removeChild(_parent, oldChild) {
+    return super.removeChild(null, oldChild);
+  }
+  parentNode(node) {
+    return this.nodeOrShadowRoot(super.parentNode(this.nodeOrShadowRoot(node)));
+  }
+  destroy() {
+    if (this.sharedStylesHost) {
+      this.sharedStylesHost.removeHost(this.shadowRoot);
+    }
+  }
+};
+var NoneEncapsulationDomRenderer = class extends DefaultDomRenderer2 {
+  sharedStylesHost;
+  removeStylesOnCompDestroy;
+  styles;
+  styleUrls;
+  constructor(eventManager, sharedStylesHost, component, removeStylesOnCompDestroy, doc, ngZone, tracingService, compId) {
+    super(eventManager, doc, ngZone, tracingService);
+    this.sharedStylesHost = sharedStylesHost;
+    this.removeStylesOnCompDestroy = removeStylesOnCompDestroy;
+    let styles = component.styles;
+    if (ngDevMode) {
+      const baseHref = getDOM().getBaseHref(doc) ?? "";
+      styles = addBaseHrefToCssSourceMap(baseHref, styles);
+    }
+    this.styles = compId ? shimStylesContent(compId, styles) : styles;
+    this.styleUrls = component.getExternalStyles?.(compId);
+  }
+  applyStyles() {
+    this.sharedStylesHost.addStyles(this.styles, this.styleUrls);
+  }
+  destroy() {
+    if (!this.removeStylesOnCompDestroy) {
+      return;
+    }
+    if (allLeavingAnimations.size === 0) {
+      this.sharedStylesHost.removeStyles(this.styles, this.styleUrls);
+    }
+  }
+};
+var EmulatedEncapsulationDomRenderer2 = class extends NoneEncapsulationDomRenderer {
+  contentAttr;
+  hostAttr;
+  constructor(eventManager, sharedStylesHost, component, appId, removeStylesOnCompDestroy, doc, ngZone, tracingService) {
+    const compId = appId + "-" + component.id;
+    super(eventManager, sharedStylesHost, component, removeStylesOnCompDestroy, doc, ngZone, tracingService, compId);
+    this.contentAttr = shimContentAttribute(compId);
+    this.hostAttr = shimHostAttribute(compId);
+  }
+  applyToHost(element) {
+    this.applyStyles();
+    this.setAttribute(element, this.hostAttr, "");
+  }
+  createElement(parent, name) {
+    const el = super.createElement(parent, name);
+    super.setAttribute(el, this.contentAttr, "");
+    return el;
+  }
+};
+
+// node_modules/@angular/platform-browser/fesm2022/_browser-chunk.mjs
+/**
+ * @license Angular v21.2.17
+ * (c) 2010-2026 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+var BrowserDomAdapter = class _BrowserDomAdapter extends DomAdapter {
+  supportsDOMEvents = true;
+  static makeCurrent() {
+    setRootDomAdapter(new _BrowserDomAdapter());
+  }
+  onAndCancel(el, evt, listener, options) {
+    el.addEventListener(evt, listener, options);
+    return () => {
+      el.removeEventListener(evt, listener, options);
+    };
+  }
+  dispatchEvent(el, evt) {
+    el.dispatchEvent(evt);
+  }
+  remove(node) {
+    node.remove();
+  }
+  createElement(tagName, doc) {
+    doc = doc || this.getDefaultDocument();
+    return doc.createElement(tagName);
+  }
+  createHtmlDocument() {
+    return document.implementation.createHTMLDocument("fakeTitle");
+  }
+  getDefaultDocument() {
+    return document;
+  }
+  isElementNode(node) {
+    return node.nodeType === Node.ELEMENT_NODE;
+  }
+  isShadowRoot(node) {
+    return node instanceof DocumentFragment;
+  }
+  getGlobalEventTarget(doc, target) {
+    if (target === "window") {
+      return window;
+    }
+    if (target === "document") {
+      return doc;
+    }
+    if (target === "body") {
+      return doc.body;
+    }
+    return null;
+  }
+  getBaseHref(doc) {
+    const href = getBaseElementHref();
+    return href == null ? null : relativePath(href);
+  }
+  resetBaseElement() {
+    baseElement = null;
+  }
+  getUserAgent() {
+    return window.navigator.userAgent;
+  }
+  getCookie(name) {
+    return parseCookieValue(document.cookie, name);
+  }
+};
+var baseElement = null;
+function getBaseElementHref() {
+  baseElement = baseElement || document.head.querySelector("base");
+  return baseElement ? baseElement.getAttribute("href") : null;
+}
+function relativePath(url) {
+  return new URL(url, document.baseURI).pathname;
+}
+var BrowserGetTestability = class {
+  addToWindow(registry) {
+    _global["getAngularTestability"] = (elem, findInAncestors = true) => {
+      const testability = registry.findTestabilityInTree(elem, findInAncestors);
+      if (testability == null) {
+        throw new RuntimeError(5103, (typeof ngDevMode === "undefined" || ngDevMode) && "Could not find testability for element.");
+      }
+      return testability;
+    };
+    _global["getAllAngularTestabilities"] = () => registry.getAllTestabilities();
+    _global["getAllAngularRootElements"] = () => registry.getAllRootElements();
+    const whenAllStable = (callback) => {
+      const testabilities = _global["getAllAngularTestabilities"]();
+      let count = testabilities.length;
+      const decrement = function() {
+        count--;
+        if (count == 0) {
+          callback();
+        }
+      };
+      testabilities.forEach((testability) => {
+        testability.whenStable(decrement);
+      });
+    };
+    if (!_global["frameworkStabilizers"]) {
+      _global["frameworkStabilizers"] = [];
+    }
+    _global["frameworkStabilizers"].push(whenAllStable);
+  }
+  findTestabilityInTree(registry, elem, findInAncestors) {
+    if (elem == null) {
+      return null;
+    }
+    const t = registry.getTestability(elem);
+    if (t != null) {
+      return t;
+    } else if (!findInAncestors) {
+      return null;
+    }
+    if (getDOM().isShadowRoot(elem)) {
+      return this.findTestabilityInTree(registry, elem.host, true);
+    }
+    return this.findTestabilityInTree(registry, elem.parentElement, true);
+  }
+};
+var BrowserXhr = class _BrowserXhr {
+  build() {
+    return new XMLHttpRequest();
+  }
+  static \u0275fac = function BrowserXhr_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _BrowserXhr)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _BrowserXhr,
+    factory: _BrowserXhr.\u0275fac
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(BrowserXhr, [{
+    type: Injectable
+  }], null, null);
+})();
+var MODIFIER_KEYS = ["alt", "control", "meta", "shift"];
+var _keyMap = {
+  "\b": "Backspace",
+  "	": "Tab",
+  "\x7F": "Delete",
+  "\x1B": "Escape",
+  "Del": "Delete",
+  "Esc": "Escape",
+  "Left": "ArrowLeft",
+  "Right": "ArrowRight",
+  "Up": "ArrowUp",
+  "Down": "ArrowDown",
+  "Menu": "ContextMenu",
+  "Scroll": "ScrollLock",
+  "Win": "OS"
+};
+var MODIFIER_KEY_GETTERS = {
+  "alt": (event) => event.altKey,
+  "control": (event) => event.ctrlKey,
+  "meta": (event) => event.metaKey,
+  "shift": (event) => event.shiftKey
+};
+var KeyEventsPlugin = class _KeyEventsPlugin extends EventManagerPlugin {
+  constructor(doc) {
+    super(doc);
+  }
+  supports(eventName) {
+    return _KeyEventsPlugin.parseEventName(eventName) != null;
+  }
+  addEventListener(element, eventName, handler, options) {
+    const parsedEvent = _KeyEventsPlugin.parseEventName(eventName);
+    const outsideHandler = _KeyEventsPlugin.eventCallback(parsedEvent["fullKey"], handler, this.manager.getZone());
+    return this.manager.getZone().runOutsideAngular(() => {
+      return getDOM().onAndCancel(element, parsedEvent["domEventName"], outsideHandler, options);
+    });
+  }
+  static parseEventName(eventName) {
+    const parts = eventName.toLowerCase().split(".");
+    const domEventName = parts.shift();
+    if (parts.length === 0 || !(domEventName === "keydown" || domEventName === "keyup")) {
+      return null;
+    }
+    const key = _KeyEventsPlugin._normalizeKey(parts.pop());
+    let fullKey = "";
+    let codeIX = parts.indexOf("code");
+    if (codeIX > -1) {
+      parts.splice(codeIX, 1);
+      fullKey = "code.";
+    }
+    MODIFIER_KEYS.forEach((modifierName) => {
+      const index = parts.indexOf(modifierName);
+      if (index > -1) {
+        parts.splice(index, 1);
+        fullKey += modifierName + ".";
+      }
+    });
+    fullKey += key;
+    if (parts.length != 0 || key.length === 0) {
+      return null;
+    }
+    const result = {};
+    result["domEventName"] = domEventName;
+    result["fullKey"] = fullKey;
+    return result;
+  }
+  static matchEventFullKeyCode(event, fullKeyCode) {
+    let keycode = _keyMap[event.key] || event.key;
+    let key = "";
+    if (fullKeyCode.indexOf("code.") > -1) {
+      keycode = event.code;
+      key = "code.";
+    }
+    if (keycode == null || !keycode) return false;
+    keycode = keycode.toLowerCase();
+    if (keycode === " ") {
+      keycode = "space";
+    } else if (keycode === ".") {
+      keycode = "dot";
+    }
+    MODIFIER_KEYS.forEach((modifierName) => {
+      if (modifierName !== keycode) {
+        const modifierGetter = MODIFIER_KEY_GETTERS[modifierName];
+        if (modifierGetter(event)) {
+          key += modifierName + ".";
+        }
+      }
+    });
+    key += keycode;
+    return key === fullKeyCode;
+  }
+  static eventCallback(fullKey, handler, zone) {
+    return (event) => {
+      if (_KeyEventsPlugin.matchEventFullKeyCode(event, fullKey)) {
+        zone.runGuarded(() => handler(event));
+      }
+    };
+  }
+  static _normalizeKey(keyName) {
+    return keyName === "esc" ? "escape" : keyName;
+  }
+  static \u0275fac = function KeyEventsPlugin_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _KeyEventsPlugin)(\u0275\u0275inject(DOCUMENT));
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _KeyEventsPlugin,
+    factory: _KeyEventsPlugin.\u0275fac
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(KeyEventsPlugin, [{
+    type: Injectable
+  }], () => [{
+    type: void 0,
+    decorators: [{
+      type: Inject,
+      args: [DOCUMENT]
+    }]
+  }], null);
+})();
+async function bootstrapApplication(rootComponent, options, context2) {
+  const config2 = __spreadValues({
+    rootComponent
+  }, createProvidersConfig(options, context2));
+  if (false) {
+    await resolveJitResources();
+  }
+  return internalCreateApplication(config2);
+}
+function createProvidersConfig(options, context2) {
+  return {
+    platformRef: context2?.platformRef,
+    appProviders: [...BROWSER_MODULE_PROVIDERS, ...options?.providers ?? []],
+    platformProviders: INTERNAL_BROWSER_PLATFORM_PROVIDERS
+  };
+}
+function initDomAdapter() {
+  BrowserDomAdapter.makeCurrent();
+}
+function errorHandler() {
+  return new ErrorHandler();
+}
+function _document() {
+  setDocument(document);
+  return document;
+}
+var INTERNAL_BROWSER_PLATFORM_PROVIDERS = [{
+  provide: PLATFORM_ID,
+  useValue: PLATFORM_BROWSER_ID
+}, {
+  provide: PLATFORM_INITIALIZER,
+  useValue: initDomAdapter,
+  multi: true
+}, {
+  provide: DOCUMENT,
+  useFactory: _document
+}];
+var platformBrowser = createPlatformFactory(platformCore, "browser", INTERNAL_BROWSER_PLATFORM_PROVIDERS);
+var BROWSER_MODULE_PROVIDERS_MARKER = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "BrowserModule Providers Marker" : "");
+var TESTABILITY_PROVIDERS = [{
+  provide: TESTABILITY_GETTER,
+  useClass: BrowserGetTestability
+}, {
+  provide: TESTABILITY,
+  useClass: Testability
+}, {
+  provide: Testability,
+  useClass: Testability
+}];
+var BROWSER_MODULE_PROVIDERS = [{
+  provide: INJECTOR_SCOPE,
+  useValue: "root"
+}, {
+  provide: ErrorHandler,
+  useFactory: errorHandler
+}, {
+  provide: EVENT_MANAGER_PLUGINS,
+  useClass: DomEventsPlugin,
+  multi: true
+}, {
+  provide: EVENT_MANAGER_PLUGINS,
+  useClass: KeyEventsPlugin,
+  multi: true
+}, DomRendererFactory2, SharedStylesHost, EventManager, {
+  provide: RendererFactory2,
+  useExisting: DomRendererFactory2
+}, {
+  provide: XhrFactory,
+  useClass: BrowserXhr
+}, typeof ngDevMode === "undefined" || ngDevMode ? {
+  provide: BROWSER_MODULE_PROVIDERS_MARKER,
+  useValue: true
+} : []];
+var BrowserModule = class _BrowserModule {
+  constructor() {
+    if (typeof ngDevMode === "undefined" || ngDevMode) {
+      const providersAlreadyPresent = inject2(BROWSER_MODULE_PROVIDERS_MARKER, {
+        optional: true,
+        skipSelf: true
+      });
+      if (providersAlreadyPresent) {
+        throw new RuntimeError(5100, `Providers from the \`BrowserModule\` have already been loaded. If you need access to common directives such as NgIf and NgFor, import the \`CommonModule\` instead.`);
+      }
+    }
+  }
+  static \u0275fac = function BrowserModule_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _BrowserModule)();
+  };
+  static \u0275mod = /* @__PURE__ */ \u0275\u0275defineNgModule({
+    type: _BrowserModule,
+    exports: [CommonModule, ApplicationModule]
+  });
+  static \u0275inj = /* @__PURE__ */ \u0275\u0275defineInjector({
+    providers: [...BROWSER_MODULE_PROVIDERS, ...TESTABILITY_PROVIDERS],
+    imports: [CommonModule, ApplicationModule]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(BrowserModule, [{
+    type: NgModule,
+    args: [{
+      providers: [...BROWSER_MODULE_PROVIDERS, ...TESTABILITY_PROVIDERS],
+      exports: [CommonModule, ApplicationModule]
+    }]
+  }], () => [], null);
+})();
+
+// node_modules/@angular/common/fesm2022/_module-chunk.mjs
+/**
+ * @license Angular v21.2.17
+ * (c) 2010-2026 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+var HttpHeaders = class _HttpHeaders {
+  headers;
+  normalizedNames = /* @__PURE__ */ new Map();
+  lazyInit;
+  lazyUpdate = null;
+  constructor(headers) {
+    if (!headers) {
+      this.headers = /* @__PURE__ */ new Map();
+    } else if (typeof headers === "string") {
+      this.lazyInit = () => {
+        this.headers = /* @__PURE__ */ new Map();
+        headers.split("\n").forEach((line) => {
+          const index = line.indexOf(":");
+          if (index > 0) {
+            const name = line.slice(0, index);
+            const value = line.slice(index + 1).trim();
+            this.addHeaderEntry(name, value);
+          }
+        });
+      };
+    } else if (typeof Headers !== "undefined" && headers instanceof Headers) {
+      this.headers = /* @__PURE__ */ new Map();
+      headers.forEach((value, name) => {
+        this.addHeaderEntry(name, value);
+      });
+    } else {
+      this.lazyInit = () => {
+        if (typeof ngDevMode === "undefined" || ngDevMode) {
+          assertValidHeaders(headers);
+        }
+        this.headers = /* @__PURE__ */ new Map();
+        Object.entries(headers).forEach(([name, values]) => {
+          this.setHeaderEntries(name, values);
+        });
+      };
+    }
+  }
+  has(name) {
+    this.init();
+    return this.headers.has(name.toLowerCase());
+  }
+  get(name) {
+    this.init();
+    const values = this.headers.get(name.toLowerCase());
+    return values && values.length > 0 ? values[0] : null;
+  }
+  keys() {
+    this.init();
+    return Array.from(this.normalizedNames.values());
+  }
+  getAll(name) {
+    this.init();
+    return this.headers.get(name.toLowerCase()) || null;
+  }
+  append(name, value) {
+    return this.clone({
+      name,
+      value,
+      op: "a"
+    });
+  }
+  set(name, value) {
+    return this.clone({
+      name,
+      value,
+      op: "s"
+    });
+  }
+  delete(name, value) {
+    return this.clone({
+      name,
+      value,
+      op: "d"
+    });
+  }
+  maybeSetNormalizedName(name, lcName) {
+    if (!this.normalizedNames.has(lcName)) {
+      this.normalizedNames.set(lcName, name);
+    }
+  }
+  init() {
+    if (!!this.lazyInit) {
+      if (this.lazyInit instanceof _HttpHeaders) {
+        this.copyFrom(this.lazyInit);
+      } else {
+        this.lazyInit();
+      }
+      this.lazyInit = null;
+      if (!!this.lazyUpdate) {
+        this.lazyUpdate.forEach((update) => this.applyUpdate(update));
+        this.lazyUpdate = null;
+      }
+    }
+  }
+  copyFrom(other) {
+    other.init();
+    Array.from(other.headers.keys()).forEach((key) => {
+      this.headers.set(key, other.headers.get(key));
+      this.normalizedNames.set(key, other.normalizedNames.get(key));
+    });
+  }
+  clone(update) {
+    const clone = new _HttpHeaders();
+    clone.lazyInit = !!this.lazyInit && this.lazyInit instanceof _HttpHeaders ? this.lazyInit : this;
+    clone.lazyUpdate = (this.lazyUpdate || []).concat([update]);
+    return clone;
+  }
+  applyUpdate(update) {
+    const key = update.name.toLowerCase();
+    switch (update.op) {
+      case "a":
+      case "s":
+        let value = update.value;
+        if (typeof value === "string") {
+          value = [value];
+        }
+        if (value.length === 0) {
+          return;
+        }
+        this.maybeSetNormalizedName(update.name, key);
+        const base = (update.op === "a" ? this.headers.get(key) : void 0) || [];
+        base.push(...value);
+        this.headers.set(key, base);
+        break;
+      case "d":
+        const toDelete = update.value;
+        if (!toDelete) {
+          this.headers.delete(key);
+          this.normalizedNames.delete(key);
+        } else {
+          let existing = this.headers.get(key);
+          if (!existing) {
+            return;
+          }
+          existing = existing.filter((value2) => toDelete.indexOf(value2) === -1);
+          if (existing.length === 0) {
+            this.headers.delete(key);
+            this.normalizedNames.delete(key);
+          } else {
+            this.headers.set(key, existing);
+          }
+        }
+        break;
+    }
+  }
+  addHeaderEntry(name, value) {
+    const key = name.toLowerCase();
+    this.maybeSetNormalizedName(name, key);
+    if (this.headers.has(key)) {
+      this.headers.get(key).push(value);
+    } else {
+      this.headers.set(key, [value]);
+    }
+  }
+  setHeaderEntries(name, values) {
+    const headerValues = (Array.isArray(values) ? values : [values]).map((value) => value.toString());
+    const key = name.toLowerCase();
+    this.headers.set(key, headerValues);
+    this.maybeSetNormalizedName(name, key);
+  }
+  forEach(fn) {
+    this.init();
+    Array.from(this.normalizedNames.keys()).forEach((key) => fn(this.normalizedNames.get(key), this.headers.get(key)));
+  }
+};
+function assertValidHeaders(headers) {
+  for (const [key, value] of Object.entries(headers)) {
+    if (!(typeof value === "string" || typeof value === "number") && !Array.isArray(value)) {
+      throw new Error(`Unexpected value of the \`${key}\` header provided. Expecting either a string, a number or an array, but got: \`${value}\`.`);
+    }
+  }
+}
+var HttpContext = class {
+  map = /* @__PURE__ */ new Map();
+  set(token, value) {
+    this.map.set(token, value);
+    return this;
+  }
+  get(token) {
+    if (!this.map.has(token)) {
+      this.map.set(token, token.defaultValue());
+    }
+    return this.map.get(token);
+  }
+  delete(token) {
+    this.map.delete(token);
+    return this;
+  }
+  has(token) {
+    return this.map.has(token);
+  }
+  keys() {
+    return this.map.keys();
+  }
+};
+var HttpUrlEncodingCodec = class {
+  encodeKey(key) {
+    return standardEncoding(key);
+  }
+  encodeValue(value) {
+    return standardEncoding(value);
+  }
+  decodeKey(key) {
+    return decodeURIComponent(key);
+  }
+  decodeValue(value) {
+    return decodeURIComponent(value);
+  }
+};
+function paramParser(rawParams, codec) {
+  const map2 = /* @__PURE__ */ new Map();
+  if (rawParams.length > 0) {
+    const params = rawParams.replace(/^\?/, "").split("&");
+    params.forEach((param) => {
+      const eqIdx = param.indexOf("=");
+      const [key, val] = eqIdx == -1 ? [codec.decodeKey(param), ""] : [codec.decodeKey(param.slice(0, eqIdx)), codec.decodeValue(param.slice(eqIdx + 1))];
+      const list = map2.get(key) || [];
+      list.push(val);
+      map2.set(key, list);
+    });
+  }
+  return map2;
+}
+var STANDARD_ENCODING_REGEX = /%(\d[a-f0-9])/gi;
+var STANDARD_ENCODING_REPLACEMENTS = {
+  "40": "@",
+  "3A": ":",
+  "24": "$",
+  "2C": ",",
+  "3B": ";",
+  "3D": "=",
+  "3F": "?",
+  "2F": "/"
+};
+function standardEncoding(v) {
+  return encodeURIComponent(v).replace(STANDARD_ENCODING_REGEX, (s, t) => STANDARD_ENCODING_REPLACEMENTS[t] ?? s);
+}
+function valueToString(value) {
+  return `${value}`;
+}
+var HttpParams = class _HttpParams {
+  map;
+  encoder;
+  updates = null;
+  cloneFrom = null;
+  constructor(options = {}) {
+    this.encoder = options.encoder || new HttpUrlEncodingCodec();
+    if (options.fromString) {
+      if (options.fromObject) {
+        throw new RuntimeError(2805, ngDevMode && "Cannot specify both fromString and fromObject.");
+      }
+      this.map = paramParser(options.fromString, this.encoder);
+    } else if (!!options.fromObject) {
+      this.map = /* @__PURE__ */ new Map();
+      Object.keys(options.fromObject).forEach((key) => {
+        const value = options.fromObject[key];
+        const values = Array.isArray(value) ? value.map(valueToString) : [valueToString(value)];
+        this.map.set(key, values);
+      });
+    } else {
+      this.map = null;
+    }
+  }
+  has(param) {
+    this.init();
+    return this.map.has(param);
+  }
+  get(param) {
+    this.init();
+    const res = this.map.get(param);
+    return !!res ? res[0] : null;
+  }
+  getAll(param) {
+    this.init();
+    return this.map.get(param) || null;
+  }
+  keys() {
+    this.init();
+    return Array.from(this.map.keys());
+  }
+  append(param, value) {
+    return this.clone({
+      param,
+      value,
+      op: "a"
+    });
+  }
+  appendAll(params) {
+    const updates = [];
+    Object.keys(params).forEach((param) => {
+      const value = params[param];
+      if (Array.isArray(value)) {
+        value.forEach((_value) => {
+          updates.push({
+            param,
+            value: _value,
+            op: "a"
+          });
+        });
+      } else {
+        updates.push({
+          param,
+          value,
+          op: "a"
+        });
+      }
+    });
+    return this.clone(updates);
+  }
+  set(param, value) {
+    return this.clone({
+      param,
+      value,
+      op: "s"
+    });
+  }
+  delete(param, value) {
+    return this.clone({
+      param,
+      value,
+      op: "d"
+    });
+  }
+  toString() {
+    this.init();
+    return this.keys().map((key) => {
+      const eKey = this.encoder.encodeKey(key);
+      return this.map.get(key).map((value) => eKey + "=" + this.encoder.encodeValue(value)).join("&");
+    }).filter((param) => param !== "").join("&");
+  }
+  clone(update) {
+    const clone = new _HttpParams({
+      encoder: this.encoder
+    });
+    clone.cloneFrom = this.cloneFrom || this;
+    clone.updates = (this.updates || []).concat(update);
+    return clone;
+  }
+  init() {
+    if (this.map === null) {
+      this.map = /* @__PURE__ */ new Map();
+    }
+    if (this.cloneFrom !== null) {
+      this.cloneFrom.init();
+      this.cloneFrom.keys().forEach((key) => this.map.set(key, this.cloneFrom.map.get(key)));
+      this.updates.forEach((update) => {
+        switch (update.op) {
+          case "a":
+          case "s":
+            const base = (update.op === "a" ? this.map.get(update.param) : void 0) || [];
+            base.push(valueToString(update.value));
+            this.map.set(update.param, base);
+            break;
+          case "d":
+            if (update.value !== void 0) {
+              let base2 = this.map.get(update.param) || [];
+              const idx = base2.indexOf(valueToString(update.value));
+              if (idx !== -1) {
+                base2.splice(idx, 1);
+              }
+              if (base2.length > 0) {
+                this.map.set(update.param, base2);
+              } else {
+                this.map.delete(update.param);
+              }
+            } else {
+              this.map.delete(update.param);
+              break;
+            }
+        }
+      });
+      this.cloneFrom = this.updates = null;
+    }
+  }
+};
+function mightHaveBody(method) {
+  switch (method) {
+    case "DELETE":
+    case "GET":
+    case "HEAD":
+    case "OPTIONS":
+    case "JSONP":
+      return false;
+    default:
+      return true;
+  }
+}
+function isArrayBuffer(value) {
+  return typeof ArrayBuffer !== "undefined" && value instanceof ArrayBuffer;
+}
+function isBlob(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function isFormData(value) {
+  return typeof FormData !== "undefined" && value instanceof FormData;
+}
+function isUrlSearchParams(value) {
+  return typeof URLSearchParams !== "undefined" && value instanceof URLSearchParams;
+}
+var CONTENT_TYPE_HEADER = "Content-Type";
+var ACCEPT_HEADER = "Accept";
+var TEXT_CONTENT_TYPE = "text/plain";
+var JSON_CONTENT_TYPE = "application/json";
+var ACCEPT_HEADER_VALUE = `${JSON_CONTENT_TYPE}, ${TEXT_CONTENT_TYPE}, */*`;
+var HttpRequest = class _HttpRequest {
+  url;
+  body = null;
+  headers;
+  context;
+  reportProgress = false;
+  withCredentials = false;
+  credentials;
+  keepalive = false;
+  cache;
+  priority;
+  mode;
+  redirect;
+  referrer;
+  integrity;
+  referrerPolicy;
+  responseType = "json";
+  method;
+  params;
+  urlWithParams;
+  transferCache;
+  timeout;
+  constructor(method, url, third, fourth) {
+    this.url = url;
+    this.method = method.toUpperCase();
+    let options;
+    if (mightHaveBody(this.method) || !!fourth) {
+      this.body = third !== void 0 ? third : null;
+      options = fourth;
+    } else {
+      options = third;
+    }
+    if (options) {
+      this.reportProgress = !!options.reportProgress;
+      this.withCredentials = !!options.withCredentials;
+      this.keepalive = !!options.keepalive;
+      if (!!options.responseType) {
+        this.responseType = options.responseType;
+      }
+      if (options.headers) {
+        this.headers = options.headers;
+      }
+      if (options.context) {
+        this.context = options.context;
+      }
+      if (options.params) {
+        this.params = options.params;
+      }
+      if (options.priority) {
+        this.priority = options.priority;
+      }
+      if (options.cache) {
+        this.cache = options.cache;
+      }
+      if (options.credentials) {
+        this.credentials = options.credentials;
+      }
+      if (typeof options.timeout === "number") {
+        if (options.timeout < 1 || !Number.isInteger(options.timeout)) {
+          throw new RuntimeError(2822, ngDevMode ? "`timeout` must be a positive integer value" : "");
+        }
+        this.timeout = options.timeout;
+      }
+      if (options.mode) {
+        this.mode = options.mode;
+      }
+      if (options.redirect) {
+        this.redirect = options.redirect;
+      }
+      if (options.integrity) {
+        this.integrity = options.integrity;
+      }
+      if (options.referrer !== void 0) {
+        this.referrer = options.referrer;
+      }
+      if (options.referrerPolicy) {
+        this.referrerPolicy = options.referrerPolicy;
+      }
+      this.transferCache = options.transferCache;
+    }
+    this.headers ??= new HttpHeaders();
+    this.context ??= new HttpContext();
+    if (!this.params) {
+      this.params = new HttpParams();
+      this.urlWithParams = url;
+    } else {
+      const params = this.params.toString();
+      if (params.length === 0) {
+        this.urlWithParams = url;
+      } else {
+        const qIdx = url.indexOf("?");
+        const sep = qIdx === -1 ? "?" : qIdx < url.length - 1 ? "&" : "";
+        this.urlWithParams = url + sep + params;
+      }
+    }
+  }
+  serializeBody() {
+    if (this.body === null) {
+      return null;
+    }
+    if (typeof this.body === "string" || isArrayBuffer(this.body) || isBlob(this.body) || isFormData(this.body) || isUrlSearchParams(this.body)) {
+      return this.body;
+    }
+    if (this.body instanceof HttpParams) {
+      return this.body.toString();
+    }
+    if (typeof this.body === "object" || typeof this.body === "boolean" || Array.isArray(this.body)) {
+      return JSON.stringify(this.body);
+    }
+    return this.body.toString();
+  }
+  detectContentTypeHeader() {
+    if (this.body === null) {
+      return null;
+    }
+    if (isFormData(this.body)) {
+      return null;
+    }
+    if (isBlob(this.body)) {
+      return this.body.type || null;
+    }
+    if (isArrayBuffer(this.body)) {
+      return null;
+    }
+    if (typeof this.body === "string") {
+      return TEXT_CONTENT_TYPE;
+    }
+    if (this.body instanceof HttpParams) {
+      return "application/x-www-form-urlencoded;charset=UTF-8";
+    }
+    if (typeof this.body === "object" || typeof this.body === "number" || typeof this.body === "boolean") {
+      return JSON_CONTENT_TYPE;
+    }
+    return null;
+  }
+  clone(update = {}) {
+    const method = update.method || this.method;
+    const url = update.url || this.url;
+    const responseType = update.responseType || this.responseType;
+    const keepalive = update.keepalive ?? this.keepalive;
+    const priority = update.priority || this.priority;
+    const cache = update.cache || this.cache;
+    const mode = update.mode || this.mode;
+    const redirect = update.redirect || this.redirect;
+    const credentials = update.credentials || this.credentials;
+    const referrer = update.referrer ?? this.referrer;
+    const integrity = update.integrity || this.integrity;
+    const referrerPolicy = update.referrerPolicy || this.referrerPolicy;
+    const transferCache = update.transferCache ?? this.transferCache;
+    const timeout2 = update.timeout ?? this.timeout;
+    const body = update.body !== void 0 ? update.body : this.body;
+    const withCredentials = update.withCredentials ?? this.withCredentials;
+    const reportProgress = update.reportProgress ?? this.reportProgress;
+    let headers = update.headers || this.headers;
+    let params = update.params || this.params;
+    const context2 = update.context ?? this.context;
+    if (update.setHeaders !== void 0) {
+      headers = Object.keys(update.setHeaders).reduce((headers2, name) => headers2.set(name, update.setHeaders[name]), headers);
+    }
+    if (update.setParams) {
+      params = Object.keys(update.setParams).reduce((params2, param) => params2.set(param, update.setParams[param]), params);
+    }
+    return new _HttpRequest(method, url, body, {
+      params,
+      headers,
+      context: context2,
+      reportProgress,
+      responseType,
+      withCredentials,
+      transferCache,
+      keepalive,
+      cache,
+      priority,
+      timeout: timeout2,
+      mode,
+      redirect,
+      credentials,
+      referrer,
+      integrity,
+      referrerPolicy
+    });
+  }
+};
+var HttpEventType;
+(function(HttpEventType2) {
+  HttpEventType2[HttpEventType2["Sent"] = 0] = "Sent";
+  HttpEventType2[HttpEventType2["UploadProgress"] = 1] = "UploadProgress";
+  HttpEventType2[HttpEventType2["ResponseHeader"] = 2] = "ResponseHeader";
+  HttpEventType2[HttpEventType2["DownloadProgress"] = 3] = "DownloadProgress";
+  HttpEventType2[HttpEventType2["Response"] = 4] = "Response";
+  HttpEventType2[HttpEventType2["User"] = 5] = "User";
+})(HttpEventType || (HttpEventType = {}));
+var HttpResponseBase = class {
+  headers;
+  status;
+  statusText;
+  url;
+  ok;
+  type;
+  redirected;
+  responseType;
+  constructor(init, defaultStatus = 200, defaultStatusText = "OK") {
+    this.headers = init.headers || new HttpHeaders();
+    this.status = init.status !== void 0 ? init.status : defaultStatus;
+    this.statusText = init.statusText || defaultStatusText;
+    this.url = init.url || null;
+    this.redirected = init.redirected;
+    this.responseType = init.responseType;
+    this.ok = this.status >= 200 && this.status < 300;
+  }
+};
+var HttpHeaderResponse = class _HttpHeaderResponse extends HttpResponseBase {
+  constructor(init = {}) {
+    super(init);
+  }
+  type = HttpEventType.ResponseHeader;
+  clone(update = {}) {
+    return new _HttpHeaderResponse({
+      headers: update.headers || this.headers,
+      status: update.status !== void 0 ? update.status : this.status,
+      statusText: update.statusText || this.statusText,
+      url: update.url || this.url || void 0
+    });
+  }
+};
+var HttpResponse = class _HttpResponse extends HttpResponseBase {
+  body;
+  constructor(init = {}) {
+    super(init);
+    this.body = init.body !== void 0 ? init.body : null;
+  }
+  type = HttpEventType.Response;
+  clone(update = {}) {
+    return new _HttpResponse({
+      body: update.body !== void 0 ? update.body : this.body,
+      headers: update.headers || this.headers,
+      status: update.status !== void 0 ? update.status : this.status,
+      statusText: update.statusText || this.statusText,
+      url: update.url || this.url || void 0,
+      redirected: update.redirected ?? this.redirected,
+      responseType: update.responseType ?? this.responseType
+    });
+  }
+};
+var HttpErrorResponse = class extends HttpResponseBase {
+  name = "HttpErrorResponse";
+  message;
+  error;
+  ok = false;
+  constructor(init) {
+    super(init, 0, "Unknown Error");
+    if (this.status >= 200 && this.status < 300) {
+      this.message = `Http failure during parsing for ${init.url || "(unknown url)"}`;
+    } else {
+      this.message = `Http failure response for ${init.url || "(unknown url)"}: ${init.status} ${init.statusText}`;
+    }
+    this.error = init.error || null;
+  }
+};
+var HTTP_STATUS_CODE_OK = 200;
+var HTTP_STATUS_CODE_NO_CONTENT = 204;
+var HttpStatusCode;
+(function(HttpStatusCode2) {
+  HttpStatusCode2[HttpStatusCode2["Continue"] = 100] = "Continue";
+  HttpStatusCode2[HttpStatusCode2["SwitchingProtocols"] = 101] = "SwitchingProtocols";
+  HttpStatusCode2[HttpStatusCode2["Processing"] = 102] = "Processing";
+  HttpStatusCode2[HttpStatusCode2["EarlyHints"] = 103] = "EarlyHints";
+  HttpStatusCode2[HttpStatusCode2["Ok"] = 200] = "Ok";
+  HttpStatusCode2[HttpStatusCode2["Created"] = 201] = "Created";
+  HttpStatusCode2[HttpStatusCode2["Accepted"] = 202] = "Accepted";
+  HttpStatusCode2[HttpStatusCode2["NonAuthoritativeInformation"] = 203] = "NonAuthoritativeInformation";
+  HttpStatusCode2[HttpStatusCode2["NoContent"] = 204] = "NoContent";
+  HttpStatusCode2[HttpStatusCode2["ResetContent"] = 205] = "ResetContent";
+  HttpStatusCode2[HttpStatusCode2["PartialContent"] = 206] = "PartialContent";
+  HttpStatusCode2[HttpStatusCode2["MultiStatus"] = 207] = "MultiStatus";
+  HttpStatusCode2[HttpStatusCode2["AlreadyReported"] = 208] = "AlreadyReported";
+  HttpStatusCode2[HttpStatusCode2["ImUsed"] = 226] = "ImUsed";
+  HttpStatusCode2[HttpStatusCode2["MultipleChoices"] = 300] = "MultipleChoices";
+  HttpStatusCode2[HttpStatusCode2["MovedPermanently"] = 301] = "MovedPermanently";
+  HttpStatusCode2[HttpStatusCode2["Found"] = 302] = "Found";
+  HttpStatusCode2[HttpStatusCode2["SeeOther"] = 303] = "SeeOther";
+  HttpStatusCode2[HttpStatusCode2["NotModified"] = 304] = "NotModified";
+  HttpStatusCode2[HttpStatusCode2["UseProxy"] = 305] = "UseProxy";
+  HttpStatusCode2[HttpStatusCode2["Unused"] = 306] = "Unused";
+  HttpStatusCode2[HttpStatusCode2["TemporaryRedirect"] = 307] = "TemporaryRedirect";
+  HttpStatusCode2[HttpStatusCode2["PermanentRedirect"] = 308] = "PermanentRedirect";
+  HttpStatusCode2[HttpStatusCode2["BadRequest"] = 400] = "BadRequest";
+  HttpStatusCode2[HttpStatusCode2["Unauthorized"] = 401] = "Unauthorized";
+  HttpStatusCode2[HttpStatusCode2["PaymentRequired"] = 402] = "PaymentRequired";
+  HttpStatusCode2[HttpStatusCode2["Forbidden"] = 403] = "Forbidden";
+  HttpStatusCode2[HttpStatusCode2["NotFound"] = 404] = "NotFound";
+  HttpStatusCode2[HttpStatusCode2["MethodNotAllowed"] = 405] = "MethodNotAllowed";
+  HttpStatusCode2[HttpStatusCode2["NotAcceptable"] = 406] = "NotAcceptable";
+  HttpStatusCode2[HttpStatusCode2["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
+  HttpStatusCode2[HttpStatusCode2["RequestTimeout"] = 408] = "RequestTimeout";
+  HttpStatusCode2[HttpStatusCode2["Conflict"] = 409] = "Conflict";
+  HttpStatusCode2[HttpStatusCode2["Gone"] = 410] = "Gone";
+  HttpStatusCode2[HttpStatusCode2["LengthRequired"] = 411] = "LengthRequired";
+  HttpStatusCode2[HttpStatusCode2["PreconditionFailed"] = 412] = "PreconditionFailed";
+  HttpStatusCode2[HttpStatusCode2["PayloadTooLarge"] = 413] = "PayloadTooLarge";
+  HttpStatusCode2[HttpStatusCode2["UriTooLong"] = 414] = "UriTooLong";
+  HttpStatusCode2[HttpStatusCode2["UnsupportedMediaType"] = 415] = "UnsupportedMediaType";
+  HttpStatusCode2[HttpStatusCode2["RangeNotSatisfiable"] = 416] = "RangeNotSatisfiable";
+  HttpStatusCode2[HttpStatusCode2["ExpectationFailed"] = 417] = "ExpectationFailed";
+  HttpStatusCode2[HttpStatusCode2["ImATeapot"] = 418] = "ImATeapot";
+  HttpStatusCode2[HttpStatusCode2["MisdirectedRequest"] = 421] = "MisdirectedRequest";
+  HttpStatusCode2[HttpStatusCode2["UnprocessableEntity"] = 422] = "UnprocessableEntity";
+  HttpStatusCode2[HttpStatusCode2["Locked"] = 423] = "Locked";
+  HttpStatusCode2[HttpStatusCode2["FailedDependency"] = 424] = "FailedDependency";
+  HttpStatusCode2[HttpStatusCode2["TooEarly"] = 425] = "TooEarly";
+  HttpStatusCode2[HttpStatusCode2["UpgradeRequired"] = 426] = "UpgradeRequired";
+  HttpStatusCode2[HttpStatusCode2["PreconditionRequired"] = 428] = "PreconditionRequired";
+  HttpStatusCode2[HttpStatusCode2["TooManyRequests"] = 429] = "TooManyRequests";
+  HttpStatusCode2[HttpStatusCode2["RequestHeaderFieldsTooLarge"] = 431] = "RequestHeaderFieldsTooLarge";
+  HttpStatusCode2[HttpStatusCode2["UnavailableForLegalReasons"] = 451] = "UnavailableForLegalReasons";
+  HttpStatusCode2[HttpStatusCode2["InternalServerError"] = 500] = "InternalServerError";
+  HttpStatusCode2[HttpStatusCode2["NotImplemented"] = 501] = "NotImplemented";
+  HttpStatusCode2[HttpStatusCode2["BadGateway"] = 502] = "BadGateway";
+  HttpStatusCode2[HttpStatusCode2["ServiceUnavailable"] = 503] = "ServiceUnavailable";
+  HttpStatusCode2[HttpStatusCode2["GatewayTimeout"] = 504] = "GatewayTimeout";
+  HttpStatusCode2[HttpStatusCode2["HttpVersionNotSupported"] = 505] = "HttpVersionNotSupported";
+  HttpStatusCode2[HttpStatusCode2["VariantAlsoNegotiates"] = 506] = "VariantAlsoNegotiates";
+  HttpStatusCode2[HttpStatusCode2["InsufficientStorage"] = 507] = "InsufficientStorage";
+  HttpStatusCode2[HttpStatusCode2["LoopDetected"] = 508] = "LoopDetected";
+  HttpStatusCode2[HttpStatusCode2["NotExtended"] = 510] = "NotExtended";
+  HttpStatusCode2[HttpStatusCode2["NetworkAuthenticationRequired"] = 511] = "NetworkAuthenticationRequired";
+})(HttpStatusCode || (HttpStatusCode = {}));
+var XSSI_PREFIX$1 = /^\)\]\}',?\n/;
+var FETCH_BACKEND = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "FETCH_BACKEND" : "");
+var FetchBackend = class _FetchBackend {
+  fetchImpl = inject2(FetchFactory, {
+    optional: true
+  })?.fetch ?? ((...args) => globalThis.fetch(...args));
+  ngZone = inject2(NgZone);
+  destroyRef = inject2(DestroyRef);
+  handle(request) {
+    return new Observable((observer) => {
+      const aborter = new AbortController();
+      this.doRequest(request, aborter.signal, observer).then(noop3, (error) => observer.error(new HttpErrorResponse({
+        error
+      })));
+      let timeoutId;
+      if (request.timeout) {
+        timeoutId = this.ngZone.runOutsideAngular(() => setTimeout(() => {
+          if (!aborter.signal.aborted) {
+            aborter.abort(new DOMException("signal timed out", "TimeoutError"));
+          }
+        }, request.timeout));
+      }
+      return () => {
+        if (timeoutId !== void 0) {
+          clearTimeout(timeoutId);
+        }
+        aborter.abort();
+      };
+    });
+  }
+  async doRequest(request, signal2, observer) {
+    const init = this.createRequestInit(request);
+    let response;
+    try {
+      const fetchPromise = this.ngZone.runOutsideAngular(() => this.fetchImpl(request.urlWithParams, __spreadValues({
+        signal: signal2
+      }, init)));
+      silenceSuperfluousUnhandledPromiseRejection(fetchPromise);
+      observer.next({
+        type: HttpEventType.Sent
+      });
+      response = await fetchPromise;
+    } catch (error) {
+      observer.error(new HttpErrorResponse({
+        error,
+        status: error.status ?? 0,
+        statusText: error.statusText,
+        url: request.urlWithParams,
+        headers: error.headers
+      }));
+      return;
+    }
+    const headers = new HttpHeaders(response.headers);
+    const statusText = response.statusText;
+    const url = response.url || request.urlWithParams;
+    let status = response.status;
+    let body = null;
+    if (request.reportProgress) {
+      observer.next(new HttpHeaderResponse({
+        headers,
+        status,
+        statusText,
+        url
+      }));
+    }
+    if (response.body) {
+      const contentLength = response.headers.get("content-length");
+      const chunks = [];
+      const reader = response.body.getReader();
+      let receivedLength = 0;
+      let decoder;
+      let partialText;
+      const reqZone = typeof Zone !== "undefined" && Zone.current;
+      let canceled = false;
+      await this.ngZone.runOutsideAngular(async () => {
+        while (true) {
+          if (this.destroyRef.destroyed) {
+            await reader.cancel();
+            canceled = true;
+            break;
+          }
+          const {
+            done,
+            value
+          } = await reader.read();
+          if (done) {
+            break;
+          }
+          chunks.push(value);
+          receivedLength += value.length;
+          if (request.reportProgress) {
+            partialText = request.responseType === "text" ? (partialText ?? "") + (decoder ??= new TextDecoder()).decode(value, {
+              stream: true
+            }) : void 0;
+            const reportProgress = () => observer.next({
+              type: HttpEventType.DownloadProgress,
+              total: contentLength ? +contentLength : void 0,
+              loaded: receivedLength,
+              partialText
+            });
+            reqZone ? reqZone.run(reportProgress) : reportProgress();
+          }
+        }
+      });
+      if (canceled) {
+        observer.complete();
+        return;
+      }
+      const chunksAll = this.concatChunks(chunks, receivedLength);
+      try {
+        const contentType = response.headers.get(CONTENT_TYPE_HEADER) ?? "";
+        body = this.parseBody(request, chunksAll, contentType, status);
+      } catch (error) {
+        observer.error(new HttpErrorResponse({
+          error,
+          headers: new HttpHeaders(response.headers),
+          status: response.status,
+          statusText: response.statusText,
+          url: response.url || request.urlWithParams
+        }));
+        return;
+      }
+    }
+    if (status === 0) {
+      status = body ? HTTP_STATUS_CODE_OK : 0;
+    }
+    const ok = status >= 200 && status < 300;
+    const redirected = response.redirected;
+    const responseType = response.type;
+    if (ok) {
+      observer.next(new HttpResponse({
+        body,
+        headers,
+        status,
+        statusText,
+        url,
+        redirected,
+        responseType
+      }));
+      observer.complete();
+    } else {
+      observer.error(new HttpErrorResponse({
+        error: body,
+        headers,
+        status,
+        statusText,
+        url,
+        redirected,
+        responseType
+      }));
+    }
+  }
+  parseBody(request, binContent, contentType, status) {
+    switch (request.responseType) {
+      case "json":
+        const text = new TextDecoder().decode(binContent).replace(XSSI_PREFIX$1, "");
+        if (text === "") {
+          return null;
+        }
+        try {
+          return JSON.parse(text);
+        } catch (e) {
+          if (status < 200 || status >= 300) {
+            return text;
+          }
+          throw e;
+        }
+      case "text":
+        return new TextDecoder().decode(binContent);
+      case "blob":
+        return new Blob([binContent], {
+          type: contentType
+        });
+      case "arraybuffer":
+        return binContent.buffer;
+    }
+  }
+  createRequestInit(req) {
+    const headers = {};
+    let credentials;
+    credentials = req.credentials;
+    if (req.withCredentials) {
+      (typeof ngDevMode === "undefined" || ngDevMode) && warningOptionsMessage(req);
+      credentials = "include";
+    }
+    req.headers.forEach((name, values) => headers[name] = values.join(","));
+    if (!req.headers.has(ACCEPT_HEADER)) {
+      headers[ACCEPT_HEADER] = ACCEPT_HEADER_VALUE;
+    }
+    if (!req.headers.has(CONTENT_TYPE_HEADER)) {
+      const detectedType = req.detectContentTypeHeader();
+      if (detectedType !== null) {
+        headers[CONTENT_TYPE_HEADER] = detectedType;
+      }
+    }
+    return {
+      body: req.serializeBody(),
+      method: req.method,
+      headers,
+      credentials,
+      keepalive: req.keepalive,
+      cache: req.cache,
+      priority: req.priority,
+      mode: req.mode,
+      redirect: req.redirect,
+      referrer: req.referrer,
+      integrity: req.integrity,
+      referrerPolicy: req.referrerPolicy
+    };
+  }
+  concatChunks(chunks, totalLength) {
+    const chunksAll = new Uint8Array(totalLength);
+    let position = 0;
+    for (const chunk of chunks) {
+      chunksAll.set(chunk, position);
+      position += chunk.length;
+    }
+    return chunksAll;
+  }
+  static \u0275fac = function FetchBackend_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _FetchBackend)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _FetchBackend,
+    factory: _FetchBackend.\u0275fac
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(FetchBackend, [{
+    type: Injectable
+  }], null, null);
+})();
+var FetchFactory = class {
+};
+function noop3() {
+}
+function warningOptionsMessage(req) {
+  if (req.credentials && req.withCredentials) {
+    console.warn(formatRuntimeError(2819, `Angular detected that a \`HttpClient\` request has both \`withCredentials: true\` and \`credentials: '${req.credentials}'\` options. The \`withCredentials\` option is overriding the explicit \`credentials\` setting to 'include'. Consider removing \`withCredentials\` and using \`credentials: '${req.credentials}'\` directly for clarity.`));
+  }
+}
+function silenceSuperfluousUnhandledPromiseRejection(promise) {
+  promise.then(noop3, noop3);
+}
+var XSSI_PREFIX = /^\)\]\}',?\n/;
+function validateXhrCompatibility(req) {
+  const unsupportedOptions = [{
+    property: "keepalive",
+    errorCode: 2813
+  }, {
+    property: "cache",
+    errorCode: 2814
+  }, {
+    property: "priority",
+    errorCode: 2815
+  }, {
+    property: "mode",
+    errorCode: 2816
+  }, {
+    property: "redirect",
+    errorCode: 2817
+  }, {
+    property: "credentials",
+    errorCode: 2818
+  }, {
+    property: "integrity",
+    errorCode: 2820
+  }, {
+    property: "referrer",
+    errorCode: 2821
+  }, {
+    property: "referrerPolicy",
+    errorCode: 2823
+  }];
+  for (const {
+    property,
+    errorCode
+  } of unsupportedOptions) {
+    if (req[property]) {
+      console.warn(formatRuntimeError(errorCode, `Angular detected that a \`HttpClient\` request with the \`${property}\` option was sent using XHR, which does not support it. To use the \`${property}\` option, enable Fetch API support by passing \`withFetch()\` as an argument to \`provideHttpClient()\`.`));
+    }
+  }
+}
+var HttpXhrBackend = class _HttpXhrBackend {
+  xhrFactory;
+  tracingService = inject2(TracingService, {
+    optional: true
+  });
+  constructor(xhrFactory) {
+    this.xhrFactory = xhrFactory;
+  }
+  maybePropagateTrace(fn) {
+    return this.tracingService?.propagate ? this.tracingService.propagate(fn) : fn;
+  }
+  handle(req) {
+    if (req.method === "JSONP") {
+      throw new RuntimeError(-2800, (typeof ngDevMode === "undefined" || ngDevMode) && `Cannot make a JSONP request without JSONP support. To fix the problem, either add the \`withJsonpSupport()\` call (if \`provideHttpClient()\` is used) or import the \`HttpClientJsonpModule\` in the root NgModule.`);
+    }
+    ngDevMode && validateXhrCompatibility(req);
+    const xhrFactory = this.xhrFactory;
+    const source = false ? from(xhrFactory.\u0275loadImpl()) : of(null);
+    return source.pipe(switchMap(() => {
+      return new Observable((observer) => {
+        const xhr = xhrFactory.build();
+        xhr.open(req.method, req.urlWithParams);
+        if (req.withCredentials) {
+          xhr.withCredentials = true;
+        }
+        req.headers.forEach((name, values) => xhr.setRequestHeader(name, values.join(",")));
+        if (!req.headers.has(ACCEPT_HEADER)) {
+          xhr.setRequestHeader(ACCEPT_HEADER, ACCEPT_HEADER_VALUE);
+        }
+        if (!req.headers.has(CONTENT_TYPE_HEADER)) {
+          const detectedType = req.detectContentTypeHeader();
+          if (detectedType !== null) {
+            xhr.setRequestHeader(CONTENT_TYPE_HEADER, detectedType);
+          }
+        }
+        if (req.timeout) {
+          xhr.timeout = req.timeout;
+        }
+        if (req.responseType) {
+          const responseType = req.responseType.toLowerCase();
+          xhr.responseType = responseType !== "json" ? responseType : "text";
+        }
+        const reqBody = req.serializeBody();
+        let headerResponse = null;
+        const partialFromXhr = () => {
+          if (headerResponse !== null) {
+            return headerResponse;
+          }
+          const statusText = xhr.statusText || "OK";
+          const headers = new HttpHeaders(xhr.getAllResponseHeaders());
+          const url = xhr.responseURL || req.url;
+          headerResponse = new HttpHeaderResponse({
+            headers,
+            status: xhr.status,
+            statusText,
+            url
+          });
+          return headerResponse;
+        };
+        const onLoad = this.maybePropagateTrace(() => {
+          let {
+            headers,
+            status,
+            statusText,
+            url
+          } = partialFromXhr();
+          let body = null;
+          if (status !== HTTP_STATUS_CODE_NO_CONTENT) {
+            body = typeof xhr.response === "undefined" ? xhr.responseText : xhr.response;
+          }
+          if (status === 0) {
+            status = !!body ? HTTP_STATUS_CODE_OK : 0;
+          }
+          let ok = status >= 200 && status < 300;
+          if (req.responseType === "json" && typeof body === "string") {
+            const originalBody = body;
+            body = body.replace(XSSI_PREFIX, "");
+            try {
+              body = body !== "" ? JSON.parse(body) : null;
+            } catch (error) {
+              body = originalBody;
+              if (ok) {
+                ok = false;
+                body = {
+                  error,
+                  text: body
+                };
+              }
+            }
+          }
+          if (ok) {
+            observer.next(new HttpResponse({
+              body,
+              headers,
+              status,
+              statusText,
+              url: url || void 0
+            }));
+            observer.complete();
+          } else {
+            observer.error(new HttpErrorResponse({
+              error: body,
+              headers,
+              status,
+              statusText,
+              url: url || void 0
+            }));
+          }
+        });
+        const onError = this.maybePropagateTrace((error) => {
+          const {
+            url
+          } = partialFromXhr();
+          const res = new HttpErrorResponse({
+            error,
+            status: xhr.status || 0,
+            statusText: xhr.statusText || "Unknown Error",
+            url: url || void 0
+          });
+          observer.error(res);
+        });
+        let onTimeout = onError;
+        if (req.timeout) {
+          onTimeout = this.maybePropagateTrace((_) => {
+            const {
+              url
+            } = partialFromXhr();
+            const res = new HttpErrorResponse({
+              error: new DOMException("Request timed out", "TimeoutError"),
+              status: xhr.status || 0,
+              statusText: xhr.statusText || "Request timeout",
+              url: url || void 0
+            });
+            observer.error(res);
+          });
+        }
+        let sentHeaders = false;
+        const onDownProgress = this.maybePropagateTrace((event) => {
+          if (!sentHeaders) {
+            observer.next(partialFromXhr());
+            sentHeaders = true;
+          }
+          let progressEvent = {
+            type: HttpEventType.DownloadProgress,
+            loaded: event.loaded
+          };
+          if (event.lengthComputable) {
+            progressEvent.total = event.total;
+          }
+          if (req.responseType === "text" && !!xhr.responseText) {
+            progressEvent.partialText = xhr.responseText;
+          }
+          observer.next(progressEvent);
+        });
+        const onUpProgress = this.maybePropagateTrace((event) => {
+          let progress = {
+            type: HttpEventType.UploadProgress,
+            loaded: event.loaded
+          };
+          if (event.lengthComputable) {
+            progress.total = event.total;
+          }
+          observer.next(progress);
+        });
+        xhr.addEventListener("load", onLoad);
+        xhr.addEventListener("error", onError);
+        xhr.addEventListener("timeout", onTimeout);
+        xhr.addEventListener("abort", onError);
+        if (req.reportProgress) {
+          xhr.addEventListener("progress", onDownProgress);
+          if (reqBody !== null && xhr.upload) {
+            xhr.upload.addEventListener("progress", onUpProgress);
+          }
+        }
+        xhr.send(reqBody);
+        observer.next({
+          type: HttpEventType.Sent
+        });
+        return () => {
+          xhr.removeEventListener("error", onError);
+          xhr.removeEventListener("abort", onError);
+          xhr.removeEventListener("load", onLoad);
+          xhr.removeEventListener("timeout", onTimeout);
+          if (req.reportProgress) {
+            xhr.removeEventListener("progress", onDownProgress);
+            if (reqBody !== null && xhr.upload) {
+              xhr.upload.removeEventListener("progress", onUpProgress);
+            }
+          }
+          if (xhr.readyState !== xhr.DONE) {
+            xhr.abort();
+          }
+        };
+      });
+    }));
+  }
+  static \u0275fac = function HttpXhrBackend_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _HttpXhrBackend)(\u0275\u0275inject(XhrFactory));
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _HttpXhrBackend,
+    factory: _HttpXhrBackend.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HttpXhrBackend, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], () => [{
+    type: XhrFactory
+  }], null);
+})();
+function interceptorChainEndFn(req, finalHandlerFn) {
+  return finalHandlerFn(req);
+}
+function adaptLegacyInterceptorToChain(chainTailFn, interceptor) {
+  return (initialRequest, finalHandlerFn) => interceptor.intercept(initialRequest, {
+    handle: (downstreamRequest) => chainTailFn(downstreamRequest, finalHandlerFn)
+  });
+}
+function chainedInterceptorFn(chainTailFn, interceptorFn, injector) {
+  return (initialRequest, finalHandlerFn) => runInInjectionContext(injector, () => interceptorFn(initialRequest, (downstreamRequest) => chainTailFn(downstreamRequest, finalHandlerFn)));
+}
+var HTTP_INTERCEPTORS = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "HTTP_INTERCEPTORS" : "");
+var HTTP_INTERCEPTOR_FNS = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "HTTP_INTERCEPTOR_FNS" : "", {
+  factory: () => []
+});
+var HTTP_ROOT_INTERCEPTOR_FNS = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "HTTP_ROOT_INTERCEPTOR_FNS" : "");
+var REQUESTS_CONTRIBUTE_TO_STABILITY = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "REQUESTS_CONTRIBUTE_TO_STABILITY" : "", {
+  factory: () => true
+});
+function legacyInterceptorFnFactory() {
+  let chain = null;
+  return (req, handler) => {
+    if (chain === null) {
+      const interceptors = inject2(HTTP_INTERCEPTORS, {
+        optional: true
+      }) ?? [];
+      chain = interceptors.reduceRight(adaptLegacyInterceptorToChain, interceptorChainEndFn);
+    }
+    const pendingTasks = inject2(PendingTasks);
+    const contributeToStability = inject2(REQUESTS_CONTRIBUTE_TO_STABILITY);
+    if (contributeToStability) {
+      const removeTask = pendingTasks.add();
+      return chain(req, handler).pipe(finalize(removeTask));
+    } else {
+      return chain(req, handler);
+    }
+  };
+}
+var HttpBackend = class _HttpBackend {
+  static \u0275fac = function HttpBackend_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _HttpBackend)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _HttpBackend,
+    factory: function HttpBackend_Factory(__ngFactoryType__) {
+      let __ngConditionalFactory__ = null;
+      if (__ngFactoryType__) {
+        __ngConditionalFactory__ = new (__ngFactoryType__ || _HttpBackend)();
+      } else {
+        __ngConditionalFactory__ = \u0275\u0275inject(HttpXhrBackend);
+      }
+      return __ngConditionalFactory__;
+    },
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HttpBackend, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root",
+      useExisting: HttpXhrBackend
+    }]
+  }], null, null);
+})();
+var fetchBackendWarningDisplayed = false;
+var HttpInterceptorHandler = class _HttpInterceptorHandler {
+  backend;
+  injector;
+  chain = null;
+  pendingTasks = inject2(PendingTasks);
+  contributeToStability = inject2(REQUESTS_CONTRIBUTE_TO_STABILITY);
+  constructor(backend, injector) {
+    this.backend = backend;
+    this.injector = injector;
+    if ((typeof ngDevMode === "undefined" || ngDevMode) && !fetchBackendWarningDisplayed) {
+      const isTestingBackend = this.backend.isTestingBackend;
+      if (false) {
+        fetchBackendWarningDisplayed = true;
+        injector.get(Console).warn(formatRuntimeError(2801, "Angular detected that `HttpClient` is not configured to use `fetch` APIs. It's strongly recommended to enable `fetch` for applications that use Server-Side Rendering for better performance and compatibility. To enable `fetch`, add the `withFetch()` to the `provideHttpClient()` call at the root of the application."));
+      }
+    }
+  }
+  handle(initialRequest) {
+    if (this.chain === null) {
+      const dedupedInterceptorFns = Array.from(/* @__PURE__ */ new Set([...this.injector.get(HTTP_INTERCEPTOR_FNS), ...this.injector.get(HTTP_ROOT_INTERCEPTOR_FNS, [])]));
+      this.chain = dedupedInterceptorFns.reduceRight((nextSequencedFn, interceptorFn) => chainedInterceptorFn(nextSequencedFn, interceptorFn, this.injector), interceptorChainEndFn);
+    }
+    if (this.contributeToStability) {
+      const removeTask = this.pendingTasks.add();
+      return this.chain(initialRequest, (downstreamRequest) => this.backend.handle(downstreamRequest)).pipe(finalize(removeTask));
+    } else {
+      return this.chain(initialRequest, (downstreamRequest) => this.backend.handle(downstreamRequest));
+    }
+  }
+  static \u0275fac = function HttpInterceptorHandler_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _HttpInterceptorHandler)(\u0275\u0275inject(HttpBackend), \u0275\u0275inject(EnvironmentInjector));
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _HttpInterceptorHandler,
+    factory: _HttpInterceptorHandler.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HttpInterceptorHandler, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], () => [{
+    type: HttpBackend
+  }, {
+    type: EnvironmentInjector
+  }], null);
+})();
+var HttpHandler = class _HttpHandler {
+  static \u0275fac = function HttpHandler_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _HttpHandler)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _HttpHandler,
+    factory: function HttpHandler_Factory(__ngFactoryType__) {
+      let __ngConditionalFactory__ = null;
+      if (__ngFactoryType__) {
+        __ngConditionalFactory__ = new (__ngFactoryType__ || _HttpHandler)();
+      } else {
+        __ngConditionalFactory__ = \u0275\u0275inject(HttpInterceptorHandler);
+      }
+      return __ngConditionalFactory__;
+    },
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HttpHandler, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root",
+      useExisting: HttpInterceptorHandler
+    }]
+  }], null, null);
+})();
+function addBody(options, body) {
+  return {
+    body,
+    headers: options.headers,
+    context: options.context,
+    observe: options.observe,
+    params: options.params,
+    reportProgress: options.reportProgress,
+    responseType: options.responseType,
+    withCredentials: options.withCredentials,
+    credentials: options.credentials,
+    transferCache: options.transferCache,
+    timeout: options.timeout,
+    keepalive: options.keepalive,
+    priority: options.priority,
+    cache: options.cache,
+    mode: options.mode,
+    redirect: options.redirect,
+    integrity: options.integrity,
+    referrer: options.referrer,
+    referrerPolicy: options.referrerPolicy
+  };
+}
+var HttpClient = class _HttpClient {
+  handler;
+  constructor(handler) {
+    this.handler = handler;
+  }
+  request(first2, url, options = {}) {
+    let req;
+    if (first2 instanceof HttpRequest) {
+      req = first2;
+    } else {
+      let headers = void 0;
+      if (options.headers instanceof HttpHeaders) {
+        headers = options.headers;
+      } else {
+        headers = new HttpHeaders(options.headers);
+      }
+      let params = void 0;
+      if (!!options.params) {
+        if (options.params instanceof HttpParams) {
+          params = options.params;
+        } else {
+          params = new HttpParams({
+            fromObject: options.params
+          });
+        }
+      }
+      req = new HttpRequest(first2, url, options.body !== void 0 ? options.body : null, {
+        headers,
+        context: options.context,
+        params,
+        reportProgress: options.reportProgress,
+        responseType: options.responseType || "json",
+        withCredentials: options.withCredentials,
+        transferCache: options.transferCache,
+        keepalive: options.keepalive,
+        priority: options.priority,
+        cache: options.cache,
+        mode: options.mode,
+        redirect: options.redirect,
+        credentials: options.credentials,
+        referrer: options.referrer,
+        referrerPolicy: options.referrerPolicy,
+        integrity: options.integrity,
+        timeout: options.timeout
+      });
+    }
+    const events$ = of(req).pipe(concatMap((req2) => this.handler.handle(req2)));
+    if (first2 instanceof HttpRequest || options.observe === "events") {
+      return events$;
+    }
+    const res$ = events$.pipe(filter((event) => event instanceof HttpResponse));
+    switch (options.observe || "body") {
+      case "body":
+        switch (req.responseType) {
+          case "arraybuffer":
+            return res$.pipe(map((res) => {
+              if (res.body !== null && !(res.body instanceof ArrayBuffer)) {
+                throw new RuntimeError(2806, ngDevMode && "Response is not an ArrayBuffer.");
+              }
+              return res.body;
+            }));
+          case "blob":
+            return res$.pipe(map((res) => {
+              if (res.body !== null && !(res.body instanceof Blob)) {
+                throw new RuntimeError(2807, ngDevMode && "Response is not a Blob.");
+              }
+              return res.body;
+            }));
+          case "text":
+            return res$.pipe(map((res) => {
+              if (res.body !== null && typeof res.body !== "string") {
+                throw new RuntimeError(2808, ngDevMode && "Response is not a string.");
+              }
+              return res.body;
+            }));
+          case "json":
+          default:
+            return res$.pipe(map((res) => res.body));
+        }
+      case "response":
+        return res$;
+      default:
+        throw new RuntimeError(2809, ngDevMode && `Unreachable: unhandled observe type ${options.observe}}`);
+    }
+  }
+  delete(url, options = {}) {
+    return this.request("DELETE", url, options);
+  }
+  get(url, options = {}) {
+    return this.request("GET", url, options);
+  }
+  head(url, options = {}) {
+    return this.request("HEAD", url, options);
+  }
+  jsonp(url, callbackParam) {
+    return this.request("JSONP", url, {
+      params: new HttpParams().append(callbackParam, "JSONP_CALLBACK"),
+      observe: "body",
+      responseType: "json"
+    });
+  }
+  options(url, options = {}) {
+    return this.request("OPTIONS", url, options);
+  }
+  patch(url, body, options = {}) {
+    return this.request("PATCH", url, addBody(options, body));
+  }
+  post(url, body, options = {}) {
+    return this.request("POST", url, addBody(options, body));
+  }
+  put(url, body, options = {}) {
+    return this.request("PUT", url, addBody(options, body));
+  }
+  static \u0275fac = function HttpClient_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _HttpClient)(\u0275\u0275inject(HttpHandler));
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _HttpClient,
+    factory: _HttpClient.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HttpClient, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], () => [{
+    type: HttpHandler
+  }], null);
+})();
+var nextRequestId = 0;
+var foreignDocument;
+var JSONP_ERR_NO_CALLBACK = "JSONP injected script did not invoke callback.";
+var JSONP_ERR_WRONG_METHOD = "JSONP requests must use JSONP request method.";
+var JSONP_ERR_WRONG_RESPONSE_TYPE = "JSONP requests must use Json response type.";
+var JSONP_ERR_HEADERS_NOT_SUPPORTED = "JSONP requests do not support headers.";
+var JSONP_ERR_UNSAFE_URL = "JSONP requests only support absolute URLs with HTTP(S) protocols.";
+var JsonpCallbackContext = class {
+};
+function jsonpCallbackContext() {
+  if (typeof window === "object") {
+    return window;
+  }
+  return {};
+}
+var JsonpClientBackend = class _JsonpClientBackend {
+  callbackMap;
+  document;
+  resolvedPromise = Promise.resolve();
+  nonce = inject2(CSP_NONCE, {
+    optional: true
+  });
+  constructor(callbackMap, document2) {
+    this.callbackMap = callbackMap;
+    this.document = document2;
+  }
+  nextCallback() {
+    return `ng_jsonp_callback_${nextRequestId++}`;
+  }
+  handle(req) {
+    if (req.method !== "JSONP") {
+      throw new RuntimeError(2810, ngDevMode && JSONP_ERR_WRONG_METHOD);
+    } else if (req.responseType !== "json") {
+      throw new RuntimeError(2811, ngDevMode && JSONP_ERR_WRONG_RESPONSE_TYPE);
+    }
+    if (req.headers.keys().length > 0) {
+      throw new RuntimeError(2812, ngDevMode && JSONP_ERR_HEADERS_NOT_SUPPORTED);
+    }
+    if (!this.isAllowedJsonpUrl(req.urlWithParams)) {
+      throw new RuntimeError(2826, ngDevMode && JSONP_ERR_UNSAFE_URL);
+    }
+    return new Observable((observer) => {
+      const callback = this.nextCallback();
+      const url = req.urlWithParams.replace(/=JSONP_CALLBACK(&|$)/, `=${callback}$1`);
+      const node = this.document.createElement("script");
+      node.src = url;
+      if (this.nonce) {
+        node.setAttribute("nonce", this.nonce);
+      }
+      let body = null;
+      let finished = false;
+      this.callbackMap[callback] = (data) => {
+        delete this.callbackMap[callback];
+        body = data;
+        finished = true;
+      };
+      const cleanup = () => {
+        node.removeEventListener("load", onLoad);
+        node.removeEventListener("error", onError);
+        node.remove();
+        delete this.callbackMap[callback];
+      };
+      const onLoad = () => {
+        this.resolvedPromise.then(() => {
+          cleanup();
+          if (!finished) {
+            observer.error(new HttpErrorResponse({
+              url,
+              status: 0,
+              statusText: "JSONP Error",
+              error: new Error(JSONP_ERR_NO_CALLBACK)
+            }));
+            return;
+          }
+          observer.next(new HttpResponse({
+            body,
+            status: HTTP_STATUS_CODE_OK,
+            statusText: "OK",
+            url
+          }));
+          observer.complete();
+        });
+      };
+      const onError = (error) => {
+        cleanup();
+        observer.error(new HttpErrorResponse({
+          error,
+          status: 0,
+          statusText: "JSONP Error",
+          url
+        }));
+      };
+      node.addEventListener("load", onLoad);
+      node.addEventListener("error", onError);
+      this.document.body.appendChild(node);
+      observer.next({
+        type: HttpEventType.Sent
+      });
+      return () => {
+        if (!finished) {
+          this.removeListeners(node);
+        }
+        cleanup();
+      };
+    });
+  }
+  removeListeners(script) {
+    foreignDocument ??= this.document.implementation.createHTMLDocument();
+    foreignDocument.adoptNode(script);
+  }
+  isAllowedJsonpUrl(url) {
+    return /^https?:\/\//i.test(url);
+  }
+  static \u0275fac = function JsonpClientBackend_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _JsonpClientBackend)(\u0275\u0275inject(JsonpCallbackContext), \u0275\u0275inject(DOCUMENT));
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _JsonpClientBackend,
+    factory: _JsonpClientBackend.\u0275fac
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(JsonpClientBackend, [{
+    type: Injectable
+  }], () => [{
+    type: JsonpCallbackContext
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Inject,
+      args: [DOCUMENT]
+    }]
+  }], null);
+})();
+function jsonpInterceptorFn(req, next) {
+  if (req.method === "JSONP") {
+    return inject2(JsonpClientBackend).handle(req);
+  }
+  return next(req);
+}
+var JsonpInterceptor = class _JsonpInterceptor {
+  injector;
+  constructor(injector) {
+    this.injector = injector;
+  }
+  intercept(initialRequest, next) {
+    return runInInjectionContext(this.injector, () => jsonpInterceptorFn(initialRequest, (downstreamRequest) => next.handle(downstreamRequest)));
+  }
+  static \u0275fac = function JsonpInterceptor_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _JsonpInterceptor)(\u0275\u0275inject(EnvironmentInjector));
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _JsonpInterceptor,
+    factory: _JsonpInterceptor.\u0275fac
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(JsonpInterceptor, [{
+    type: Injectable
+  }], () => [{
+    type: EnvironmentInjector
+  }], null);
+})();
+var XSRF_ENABLED = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "XSRF_ENABLED" : "", {
+  factory: () => true
+});
+var XSRF_DEFAULT_COOKIE_NAME = "XSRF-TOKEN";
+var XSRF_COOKIE_NAME = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "XSRF_COOKIE_NAME" : "", {
+  factory: () => XSRF_DEFAULT_COOKIE_NAME
+});
+var XSRF_DEFAULT_HEADER_NAME = "X-XSRF-TOKEN";
+var XSRF_HEADER_NAME = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "XSRF_HEADER_NAME" : "", {
+  factory: () => XSRF_DEFAULT_HEADER_NAME
+});
+var HttpXsrfCookieExtractor = class _HttpXsrfCookieExtractor {
+  cookieName = inject2(XSRF_COOKIE_NAME);
+  doc = inject2(DOCUMENT);
+  lastCookieString = "";
+  lastToken = null;
+  parseCount = 0;
+  getToken() {
+    if (false) {
+      return null;
+    }
+    const cookieString = this.doc.cookie || "";
+    if (cookieString !== this.lastCookieString) {
+      this.parseCount++;
+      this.lastToken = parseCookieValue(cookieString, this.cookieName);
+      this.lastCookieString = cookieString;
+    }
+    return this.lastToken;
+  }
+  static \u0275fac = function HttpXsrfCookieExtractor_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _HttpXsrfCookieExtractor)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _HttpXsrfCookieExtractor,
+    factory: _HttpXsrfCookieExtractor.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HttpXsrfCookieExtractor, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], null, null);
+})();
+var HttpXsrfTokenExtractor = class _HttpXsrfTokenExtractor {
+  static \u0275fac = function HttpXsrfTokenExtractor_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _HttpXsrfTokenExtractor)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _HttpXsrfTokenExtractor,
+    factory: function HttpXsrfTokenExtractor_Factory(__ngFactoryType__) {
+      let __ngConditionalFactory__ = null;
+      if (__ngFactoryType__) {
+        __ngConditionalFactory__ = new (__ngFactoryType__ || _HttpXsrfTokenExtractor)();
+      } else {
+        __ngConditionalFactory__ = \u0275\u0275inject(HttpXsrfCookieExtractor);
+      }
+      return __ngConditionalFactory__;
+    },
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HttpXsrfTokenExtractor, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root",
+      useExisting: HttpXsrfCookieExtractor
+    }]
+  }], null, null);
+})();
+function xsrfInterceptorFn(req, next) {
+  if (!inject2(XSRF_ENABLED) || req.method === "GET" || req.method === "HEAD") {
+    return next(req);
+  }
+  try {
+    const locationHref = inject2(PlatformLocation).href;
+    const {
+      origin: locationOrigin
+    } = new URL(locationHref);
+    const {
+      origin: requestOrigin
+    } = new URL(req.url, locationOrigin);
+    if (locationOrigin !== requestOrigin) {
+      return next(req);
+    }
+  } catch {
+    return next(req);
+  }
+  const token = inject2(HttpXsrfTokenExtractor).getToken();
+  const headerName = inject2(XSRF_HEADER_NAME);
+  if (token != null && !req.headers.has(headerName)) {
+    req = req.clone({
+      headers: req.headers.set(headerName, token)
+    });
+  }
+  return next(req);
+}
+var HttpXsrfInterceptor = class _HttpXsrfInterceptor {
+  injector = inject2(EnvironmentInjector);
+  intercept(initialRequest, next) {
+    return runInInjectionContext(this.injector, () => xsrfInterceptorFn(initialRequest, (downstreamRequest) => next.handle(downstreamRequest)));
+  }
+  static \u0275fac = function HttpXsrfInterceptor_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _HttpXsrfInterceptor)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _HttpXsrfInterceptor,
+    factory: _HttpXsrfInterceptor.\u0275fac
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HttpXsrfInterceptor, [{
+    type: Injectable
+  }], null, null);
+})();
+var HttpFeatureKind;
+(function(HttpFeatureKind2) {
+  HttpFeatureKind2[HttpFeatureKind2["Interceptors"] = 0] = "Interceptors";
+  HttpFeatureKind2[HttpFeatureKind2["LegacyInterceptors"] = 1] = "LegacyInterceptors";
+  HttpFeatureKind2[HttpFeatureKind2["CustomXsrfConfiguration"] = 2] = "CustomXsrfConfiguration";
+  HttpFeatureKind2[HttpFeatureKind2["NoXsrfProtection"] = 3] = "NoXsrfProtection";
+  HttpFeatureKind2[HttpFeatureKind2["JsonpSupport"] = 4] = "JsonpSupport";
+  HttpFeatureKind2[HttpFeatureKind2["RequestsMadeViaParent"] = 5] = "RequestsMadeViaParent";
+  HttpFeatureKind2[HttpFeatureKind2["Fetch"] = 6] = "Fetch";
+})(HttpFeatureKind || (HttpFeatureKind = {}));
+function makeHttpFeature(kind, providers) {
+  return {
+    \u0275kind: kind,
+    \u0275providers: providers
+  };
+}
+function provideHttpClient(...features) {
+  if (ngDevMode) {
+    const featureKinds = new Set(features.map((f) => f.\u0275kind));
+    if (featureKinds.has(HttpFeatureKind.NoXsrfProtection) && featureKinds.has(HttpFeatureKind.CustomXsrfConfiguration)) {
+      throw new Error(ngDevMode ? `Configuration error: found both withXsrfConfiguration() and withNoXsrfProtection() in the same call to provideHttpClient(), which is a contradiction.` : "");
+    }
+  }
+  const providers = [HttpClient, HttpInterceptorHandler, {
+    provide: HttpHandler,
+    useExisting: HttpInterceptorHandler
+  }, {
+    provide: HttpBackend,
+    useFactory: () => {
+      return inject2(FETCH_BACKEND, {
+        optional: true
+      }) ?? inject2(HttpXhrBackend);
+    }
+  }, {
+    provide: HTTP_INTERCEPTOR_FNS,
+    useValue: xsrfInterceptorFn,
+    multi: true
+  }];
+  for (const feature of features) {
+    providers.push(...feature.\u0275providers);
+  }
+  return makeEnvironmentProviders(providers);
+}
+var LEGACY_INTERCEPTOR_FN = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "LEGACY_INTERCEPTOR_FN" : "");
+function withInterceptorsFromDi() {
+  return makeHttpFeature(HttpFeatureKind.LegacyInterceptors, [{
+    provide: LEGACY_INTERCEPTOR_FN,
+    useFactory: legacyInterceptorFnFactory
+  }, {
+    provide: HTTP_INTERCEPTOR_FNS,
+    useExisting: LEGACY_INTERCEPTOR_FN,
+    multi: true
+  }]);
+}
+function withXsrfConfiguration({
+  cookieName,
+  headerName
+}) {
+  const providers = [];
+  if (cookieName !== void 0) {
+    providers.push({
+      provide: XSRF_COOKIE_NAME,
+      useValue: cookieName
+    });
+  }
+  if (headerName !== void 0) {
+    providers.push({
+      provide: XSRF_HEADER_NAME,
+      useValue: headerName
+    });
+  }
+  return makeHttpFeature(HttpFeatureKind.CustomXsrfConfiguration, providers);
+}
+function withNoXsrfProtection() {
+  return makeHttpFeature(HttpFeatureKind.NoXsrfProtection, [{
+    provide: XSRF_ENABLED,
+    useValue: false
+  }]);
+}
+function withJsonpSupport() {
+  return makeHttpFeature(HttpFeatureKind.JsonpSupport, [JsonpClientBackend, {
+    provide: JsonpCallbackContext,
+    useFactory: jsonpCallbackContext
+  }, {
+    provide: HTTP_INTERCEPTOR_FNS,
+    useValue: jsonpInterceptorFn,
+    multi: true
+  }]);
+}
+var HttpClientXsrfModule = class _HttpClientXsrfModule {
+  static disable() {
+    return {
+      ngModule: _HttpClientXsrfModule,
+      providers: [withNoXsrfProtection().\u0275providers]
+    };
+  }
+  static withOptions(options = {}) {
+    return {
+      ngModule: _HttpClientXsrfModule,
+      providers: withXsrfConfiguration(options).\u0275providers
+    };
+  }
+  static \u0275fac = function HttpClientXsrfModule_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _HttpClientXsrfModule)();
+  };
+  static \u0275mod = /* @__PURE__ */ \u0275\u0275defineNgModule({
+    type: _HttpClientXsrfModule
+  });
+  static \u0275inj = /* @__PURE__ */ \u0275\u0275defineInjector({
+    providers: [HttpXsrfInterceptor, {
+      provide: HTTP_INTERCEPTORS,
+      useExisting: HttpXsrfInterceptor,
+      multi: true
+    }, {
+      provide: HttpXsrfTokenExtractor,
+      useClass: HttpXsrfCookieExtractor
+    }, withXsrfConfiguration({
+      cookieName: XSRF_DEFAULT_COOKIE_NAME,
+      headerName: XSRF_DEFAULT_HEADER_NAME
+    }).\u0275providers, {
+      provide: XSRF_ENABLED,
+      useValue: true
+    }]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HttpClientXsrfModule, [{
+    type: NgModule,
+    args: [{
+      providers: [HttpXsrfInterceptor, {
+        provide: HTTP_INTERCEPTORS,
+        useExisting: HttpXsrfInterceptor,
+        multi: true
+      }, {
+        provide: HttpXsrfTokenExtractor,
+        useClass: HttpXsrfCookieExtractor
+      }, withXsrfConfiguration({
+        cookieName: XSRF_DEFAULT_COOKIE_NAME,
+        headerName: XSRF_DEFAULT_HEADER_NAME
+      }).\u0275providers, {
+        provide: XSRF_ENABLED,
+        useValue: true
+      }]
+    }]
+  }], null, null);
+})();
+var HttpClientModule = class _HttpClientModule {
+  static \u0275fac = function HttpClientModule_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _HttpClientModule)();
+  };
+  static \u0275mod = /* @__PURE__ */ \u0275\u0275defineNgModule({
+    type: _HttpClientModule
+  });
+  static \u0275inj = /* @__PURE__ */ \u0275\u0275defineInjector({
+    providers: [provideHttpClient(withInterceptorsFromDi())]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HttpClientModule, [{
+    type: NgModule,
+    args: [{
+      providers: [provideHttpClient(withInterceptorsFromDi())]
+    }]
+  }], null, null);
+})();
+var HttpClientJsonpModule = class _HttpClientJsonpModule {
+  static \u0275fac = function HttpClientJsonpModule_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _HttpClientJsonpModule)();
+  };
+  static \u0275mod = /* @__PURE__ */ \u0275\u0275defineNgModule({
+    type: _HttpClientJsonpModule
+  });
+  static \u0275inj = /* @__PURE__ */ \u0275\u0275defineInjector({
+    providers: [withJsonpSupport().\u0275providers]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HttpClientJsonpModule, [{
+    type: NgModule,
+    args: [{
+      providers: [withJsonpSupport().\u0275providers]
+    }]
+  }], null, null);
+})();
+
+// node_modules/@angular/common/fesm2022/http.mjs
+/**
+ * @license Angular v21.2.17
+ * (c) 2010-2026 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+var HTTP_TRANSFER_CACHE_ORIGIN_MAP = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "HTTP_TRANSFER_CACHE_ORIGIN_MAP" : "");
+var BODY = "b";
+var HEADERS = "h";
+var STATUS = "s";
+var STATUS_TEXT = "st";
+var REQ_URL = "u";
+var RESPONSE_TYPE = "rt";
+var CACHE_OPTIONS = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "HTTP_TRANSFER_STATE_CACHE_OPTIONS" : "");
+var ALLOWED_METHODS = ["GET", "HEAD"];
+function canUseOrCacheRequest(req, options) {
+  const _a = options, {
+    isCacheActive
+  } = _a, globalOptions = __objRest(_a, [
+    "isCacheActive"
+  ]);
+  const {
+    transferCache: requestOptions,
+    method: requestMethod
+  } = req;
+  if (!isCacheActive || requestOptions === false || hasOutgoingCredentials(req) || requestMethod === "POST" && !globalOptions.includePostRequests && !requestOptions || requestMethod !== "POST" && !ALLOWED_METHODS.includes(requestMethod) || !globalOptions.includeRequestsWithAuthHeaders && hasAuthHeaders(req) || hasUncacheableCacheControl(req.headers) || isNonCacheableRequest(req.cache) || globalOptions.filter?.(req) === false) {
+    return false;
+  }
+  return true;
+}
+function getHeadersToInclude(options, requestOptions) {
+  return typeof requestOptions === "object" && requestOptions.includeHeaders ? requestOptions.includeHeaders : options.includeHeaders;
+}
+function retrieveStateFromCache(req, options, transferState, originMap, storeKey, skipUseCacheChecks = false) {
+  if (!skipUseCacheChecks && !canUseOrCacheRequest(req, options)) {
+    return null;
+  }
+  if (originMap) {
+    throw new RuntimeError(2803, ngDevMode && "Angular detected that the `HTTP_TRANSFER_CACHE_ORIGIN_MAP` token is configured and present in the client side code. Please ensure that this token is only provided in the server code of the application.");
+  }
+  if (!storeKey) {
+    const requestUrl = false ? mapRequestOriginUrl(req.url, originMap) : req.url;
+    storeKey = makeCacheKey(req, requestUrl);
+  }
+  const response = transferState.get(storeKey, null);
+  if (!response) {
+    return null;
+  }
+  const {
+    [BODY]: undecodedBody,
+    [RESPONSE_TYPE]: responseType,
+    [HEADERS]: httpHeaders,
+    [STATUS]: status,
+    [STATUS_TEXT]: statusText,
+    [REQ_URL]: url
+  } = response;
+  let body = undecodedBody;
+  switch (responseType) {
+    case "arraybuffer":
+      body = fromBase64(undecodedBody);
+      break;
+    case "blob":
+      body = new Blob([fromBase64(undecodedBody)]);
+      break;
+  }
+  let headers = new HttpHeaders(httpHeaders);
+  if (typeof ngDevMode === "undefined" || ngDevMode) {
+    const {
+      transferCache: requestOptions
+    } = req;
+    const headersToInclude = getHeadersToInclude(options, requestOptions);
+    headers = appendMissingHeadersDetection(req.url, headers, headersToInclude ?? []);
+  }
+  return new HttpResponse({
+    body,
+    headers,
+    status,
+    statusText,
+    url
+  });
+}
+function hasAuthHeaders(req) {
+  const headers = req.headers;
+  return headers.has("authorization") || headers.has("proxy-authorization") || headers.has("cookie");
+}
+function hasOutgoingCredentials(req) {
+  const {
+    withCredentials,
+    credentials
+  } = req;
+  return withCredentials || credentials === "include" || credentials === "same-origin";
+}
+var UNCACHEABLE_CACHE_CONTROL_DIRECTIVES = /* @__PURE__ */ new Set(["no-store", "private", "no-cache"]);
+function hasUncacheableCacheControl(headers) {
+  const cacheControl = headers.get("cache-control");
+  if (!cacheControl) {
+    return false;
+  }
+  return cacheControl.split(",").some((directive) => {
+    const directiveName = directive.split("=", 1)[0].trim().toLowerCase();
+    return UNCACHEABLE_CACHE_CONTROL_DIRECTIVES.has(directiveName);
+  });
+}
+function isNonCacheableRequest(cache) {
+  return cache === "no-cache" || cache === "no-store";
+}
+function sortAndConcatParams(params) {
+  return [...params.keys()].sort().map((k) => `${k}=${params.getAll(k)}`).join("&");
+}
+function makeCacheKey(request, mappedRequestUrl) {
+  const {
+    params,
+    method,
+    responseType
+  } = request;
+  const encodedParams = sortAndConcatParams(params);
+  let serializedBody = request.serializeBody();
+  if (serializedBody instanceof URLSearchParams) {
+    serializedBody = sortAndConcatParams(serializedBody);
+  } else if (typeof serializedBody !== "string") {
+    serializedBody = "";
+  }
+  const key = [method, responseType, mappedRequestUrl, serializedBody, encodedParams].join("|");
+  const hash = generateHash(key);
+  return makeStateKey(hash);
+}
+function fromBase64(base64) {
+  const binary = atob(base64);
+  const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
+  return bytes.buffer;
+}
+function appendMissingHeadersDetection(url, headers, headersToInclude) {
+  const warningProduced = /* @__PURE__ */ new Set();
+  return new Proxy(headers, {
+    get(target, prop) {
+      const value = Reflect.get(target, prop);
+      const methods = /* @__PURE__ */ new Set(["get", "has", "getAll"]);
+      if (typeof value !== "function" || !methods.has(prop)) {
+        return value;
+      }
+      return (headerName) => {
+        const key = (prop + ":" + headerName).toLowerCase();
+        if (!headersToInclude.includes(headerName) && !warningProduced.has(key)) {
+          warningProduced.add(key);
+          const truncatedUrl = truncateMiddle(url);
+          console.warn(formatRuntimeError(-2802, `Angular detected that the \`${headerName}\` header is accessed, but the value of the header was not transferred from the server to the client by the HttpTransferCache. To include the value of the \`${headerName}\` header for the \`${truncatedUrl}\` request, use the \`includeHeaders\` list. The \`includeHeaders\` can be defined either on a request level by adding the \`transferCache\` parameter, or on an application level by adding the \`httpCacheTransfer.includeHeaders\` argument to the \`provideClientHydration()\` call. `));
+        }
+        return value.apply(target, [headerName]);
+      };
+    }
+  });
+}
+var SHA256_ROUND_CONSTANTS = /* @__PURE__ */ new Uint32Array([1116352408, 1899447441, 3049323471, 3921009573, 961987163, 1508970993, 2453635748, 2870763221, 3624381080, 310598401, 607225278, 1426881987, 1925078388, 2162078206, 2614888103, 3248222580, 3835390401, 4022224774, 264347078, 604807628, 770255983, 1249150122, 1555081692, 1996064986, 2554220882, 2821834349, 2952996808, 3210313671, 3336571891, 3584528711, 113926993, 338241895, 666307205, 773529912, 1294757372, 1396182291, 1695183700, 1986661051, 2177026350, 2456956037, 2730485921, 2820302411, 3259730800, 3345764771, 3516065817, 3600352804, 4094571909, 275423344, 430227734, 506948616, 659060556, 883997877, 958139571, 1322822218, 1537002063, 1747873779, 1955562222, 2024104815, 2227730452, 2361852424, 2428436474, 2756734187, 3204031479, 3329325298]);
+var textEncoder;
+function generateHash(value) {
+  textEncoder ??= new TextEncoder();
+  const inputBytes = textEncoder.encode(value);
+  let hashState0 = 1779033703;
+  let hashState1 = 3144134277;
+  let hashState2 = 1013904242;
+  let hashState3 = 2773480762;
+  let hashState4 = 1359893119;
+  let hashState5 = 2600822924;
+  let hashState6 = 528734635;
+  let hashState7 = 1541459225;
+  const messageLengthInBits = inputBytes.length * 8;
+  const paddedLengthInBytes = (inputBytes.length + 8 >> 6) + 1 << 6;
+  const paddedBytes = new Uint8Array(paddedLengthInBytes);
+  paddedBytes.set(inputBytes);
+  paddedBytes[inputBytes.length] = 128;
+  const paddedBytesView = new DataView(paddedBytes.buffer);
+  const lowBits = messageLengthInBits >>> 0;
+  const highBits = messageLengthInBits / 4294967296 >>> 0;
+  paddedBytesView.setUint32(paddedLengthInBytes - 8, highBits, false);
+  paddedBytesView.setUint32(paddedLengthInBytes - 4, lowBits, false);
+  const messageSchedule = new Uint32Array(64);
+  for (let chunkOffset = 0; chunkOffset < paddedLengthInBytes; chunkOffset += 64) {
+    for (let i = 0; i < 16; i++) {
+      messageSchedule[i] = paddedBytesView.getUint32(chunkOffset + i * 4, false);
+    }
+    for (let i = 16; i < 64; i++) {
+      const prevWord15 = messageSchedule[i - 15];
+      const sigma0 = ((prevWord15 >>> 7 | prevWord15 << 25) ^ (prevWord15 >>> 18 | prevWord15 << 14) ^ prevWord15 >>> 3) >>> 0;
+      const prevWord2 = messageSchedule[i - 2];
+      const sigma1 = ((prevWord2 >>> 17 | prevWord2 << 15) ^ (prevWord2 >>> 19 | prevWord2 << 13) ^ prevWord2 >>> 10) >>> 0;
+      messageSchedule[i] = messageSchedule[i - 16] + sigma0 + messageSchedule[i - 7] + sigma1 >>> 0;
+    }
+    let workingStateA = hashState0;
+    let workingStateB = hashState1;
+    let workingStateC = hashState2;
+    let workingStateD = hashState3;
+    let workingStateE = hashState4;
+    let workingStateF = hashState5;
+    let workingStateG = hashState6;
+    let workingStateH = hashState7;
+    for (let i = 0; i < 64; i++) {
+      const capitalSigma1 = ((workingStateE >>> 6 | workingStateE << 26) ^ (workingStateE >>> 11 | workingStateE << 21) ^ (workingStateE >>> 25 | workingStateE << 7)) >>> 0;
+      const chFunction = (workingStateE & workingStateF ^ ~workingStateE & workingStateG) >>> 0;
+      const temp1 = workingStateH + capitalSigma1 + chFunction + SHA256_ROUND_CONSTANTS[i] + messageSchedule[i] >>> 0;
+      const capitalSigma0 = ((workingStateA >>> 2 | workingStateA << 30) ^ (workingStateA >>> 13 | workingStateA << 19) ^ (workingStateA >>> 22 | workingStateA << 10)) >>> 0;
+      const majFunction = (workingStateA & workingStateB ^ workingStateA & workingStateC ^ workingStateB & workingStateC) >>> 0;
+      const temp2 = capitalSigma0 + majFunction >>> 0;
+      workingStateH = workingStateG;
+      workingStateG = workingStateF;
+      workingStateF = workingStateE;
+      workingStateE = workingStateD + temp1 >>> 0;
+      workingStateD = workingStateC;
+      workingStateC = workingStateB;
+      workingStateB = workingStateA;
+      workingStateA = temp1 + temp2 >>> 0;
+    }
+    hashState0 = hashState0 + workingStateA >>> 0;
+    hashState1 = hashState1 + workingStateB >>> 0;
+    hashState2 = hashState2 + workingStateC >>> 0;
+    hashState3 = hashState3 + workingStateD >>> 0;
+    hashState4 = hashState4 + workingStateE >>> 0;
+    hashState5 = hashState5 + workingStateF >>> 0;
+    hashState6 = hashState6 + workingStateG >>> 0;
+    hashState7 = hashState7 + workingStateH >>> 0;
+  }
+  return [hashState0, hashState1, hashState2, hashState3, hashState4, hashState5, hashState6, hashState7].map((x) => x.toString(16).padStart(8, "0")).join("");
+}
+var httpResource = (() => {
+  const jsonFn = makeHttpResourceFn("json");
+  jsonFn.arrayBuffer = makeHttpResourceFn("arraybuffer");
+  jsonFn.blob = makeHttpResourceFn("blob");
+  jsonFn.text = makeHttpResourceFn("text");
+  return jsonFn;
+})();
+function makeHttpResourceFn(responseType) {
+  return function httpResource2(request, options) {
+    if (ngDevMode && !options?.injector) {
+      assertInInjectionContext(httpResource2);
+    }
+    const injector = options?.injector ?? inject2(Injector);
+    const cacheOptions = injector.get(CACHE_OPTIONS, null, {
+      optional: true
+    });
+    const transferState = injector.get(TransferState, null, {
+      optional: true
+    });
+    const originMap = injector.get(HTTP_TRANSFER_CACHE_ORIGIN_MAP, null, {
+      optional: true
+    });
+    const getInitialStream = (req) => {
+      if (cacheOptions && transferState && req) {
+        const cachedResponse = retrieveStateFromCache(req, cacheOptions, transferState, originMap);
+        if (cachedResponse) {
+          try {
+            const body = cachedResponse.body;
+            const parsed = options?.parse ? options.parse(body) : body;
+            return signal({
+              value: parsed
+            });
+          } catch (e) {
+            if (typeof ngDevMode === "undefined" || ngDevMode) {
+              console.warn(`Angular detected an error while parsing the cached response for the httpResource at \`${req.url}\`. The resource will fall back to its default value and try again asynchronously.`, e);
+            }
+          }
+        }
+      }
+      return void 0;
+    };
+    return new HttpResourceImpl(injector, () => normalizeRequest(request, responseType), options?.defaultValue, options?.debugName, options?.parse, options?.equal, getInitialStream);
+  };
+}
+function normalizeRequest(request, responseType) {
+  let unwrappedRequest = typeof request === "function" ? request() : request;
+  if (unwrappedRequest === void 0) {
+    return void 0;
+  } else if (typeof unwrappedRequest === "string") {
+    unwrappedRequest = {
+      url: unwrappedRequest
+    };
+  }
+  const headers = unwrappedRequest.headers instanceof HttpHeaders ? unwrappedRequest.headers : new HttpHeaders(unwrappedRequest.headers);
+  const params = unwrappedRequest.params instanceof HttpParams ? unwrappedRequest.params : new HttpParams({
+    fromObject: unwrappedRequest.params
+  });
+  return new HttpRequest(unwrappedRequest.method ?? "GET", unwrappedRequest.url, unwrappedRequest.body ?? null, {
+    headers,
+    params,
+    reportProgress: unwrappedRequest.reportProgress,
+    withCredentials: unwrappedRequest.withCredentials,
+    keepalive: unwrappedRequest.keepalive,
+    cache: unwrappedRequest.cache,
+    priority: unwrappedRequest.priority,
+    mode: unwrappedRequest.mode,
+    redirect: unwrappedRequest.redirect,
+    responseType,
+    context: unwrappedRequest.context,
+    transferCache: unwrappedRequest.transferCache,
+    credentials: unwrappedRequest.credentials,
+    referrer: unwrappedRequest.referrer,
+    referrerPolicy: unwrappedRequest.referrerPolicy,
+    integrity: unwrappedRequest.integrity,
+    timeout: unwrappedRequest.timeout
+  });
+}
+var HttpResourceImpl = class extends ResourceImpl {
+  client;
+  _headers = linkedSignal(__spreadProps(__spreadValues({}, ngDevMode ? {
+    debugName: "_headers"
+  } : {}), {
+    source: this.extRequest,
+    computation: () => void 0
+  }));
+  _progress = linkedSignal(__spreadProps(__spreadValues({}, ngDevMode ? {
+    debugName: "_progress"
+  } : {}), {
+    source: this.extRequest,
+    computation: () => void 0
+  }));
+  _statusCode = linkedSignal(__spreadProps(__spreadValues({}, ngDevMode ? {
+    debugName: "_statusCode"
+  } : {}), {
+    source: this.extRequest,
+    computation: () => void 0
+  }));
+  headers = computed(() => this.status() === "resolved" || this.status() === "error" ? this._headers() : void 0, ...ngDevMode ? [{
+    debugName: "headers"
+  }] : []);
+  progress = this._progress.asReadonly();
+  statusCode = this._statusCode.asReadonly();
+  constructor(injector, request, defaultValue, debugName, parse, equal, getInitialStream) {
+    super(request, ({
+      params: request2,
+      abortSignal
+    }) => {
+      let sub;
+      const onAbort = () => sub.unsubscribe();
+      abortSignal.addEventListener("abort", onAbort);
+      const stream = signal({
+        value: void 0
+      }, ...ngDevMode ? [{
+        debugName: "stream"
+      }] : []);
+      let resolve;
+      const promise = new Promise((r) => resolve = r);
+      const send = (value) => {
+        stream.set(value);
+        resolve?.(stream);
+        resolve = void 0;
+      };
+      sub = this.client.request(request2).subscribe({
+        next: (event) => {
+          switch (event.type) {
+            case HttpEventType.Response:
+              this._headers.set(event.headers);
+              this._statusCode.set(event.status);
+              try {
+                send({
+                  value: parse ? parse(event.body) : event.body
+                });
+              } catch (error) {
+                send({
+                  error: encapsulateResourceError(error)
+                });
+              }
+              break;
+            case HttpEventType.DownloadProgress:
+              this._progress.set(event);
+              break;
+          }
+        },
+        error: (error) => {
+          if (error instanceof HttpErrorResponse) {
+            this._headers.set(error.headers);
+            this._statusCode.set(error.status);
+          }
+          send({
+            error
+          });
+          abortSignal.removeEventListener("abort", onAbort);
+        },
+        complete: () => {
+          if (resolve) {
+            send({
+              error: new RuntimeError(991, ngDevMode && "Resource completed before producing a value")
+            });
+          }
+          abortSignal.removeEventListener("abort", onAbort);
+        }
+      });
+      return promise;
+    }, defaultValue, equal, debugName, injector, getInitialStream);
+    this.client = injector.get(HttpClient);
+  }
+  set(value) {
+    super.set(value);
+    this._headers.set(void 0);
+    this._progress.set(void 0);
+    this._statusCode.set(void 0);
+  }
+};
+
+// node_modules/@angular/platform-browser/fesm2022/platform-browser.mjs
+/**
+ * @license Angular v21.2.17
+ * (c) 2010-2026 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+var Meta = class _Meta {
+  _doc;
+  _dom;
+  constructor(_doc) {
+    this._doc = _doc;
+    this._dom = getDOM();
+  }
+  addTag(tag, forceCreation = false) {
+    if (!tag) return null;
+    return this._getOrCreateElement(tag, forceCreation);
+  }
+  addTags(tags, forceCreation = false) {
+    if (!tags) return [];
+    return tags.reduce((result, tag) => {
+      if (tag) {
+        result.push(this._getOrCreateElement(tag, forceCreation));
+      }
+      return result;
+    }, []);
+  }
+  getTag(attrSelector) {
+    if (!attrSelector) return null;
+    const meta = this._doc.querySelector(`meta[${attrSelector}]`);
+    return meta?.nodeName.toLowerCase() === "meta" ? meta : null;
+  }
+  getTags(attrSelector) {
+    if (!attrSelector) return [];
+    const list = this._doc.querySelectorAll(`meta[${attrSelector}]`);
+    return list ? [].slice.call(list).filter((elem) => elem.nodeName.toLowerCase() === "meta") : [];
+  }
+  updateTag(tag, selector) {
+    if (!tag) return null;
+    selector = selector || this._parseSelector(tag);
+    const meta = this.getTag(selector);
+    if (meta) {
+      return this._setMetaElementAttributes(tag, meta);
+    }
+    return this._getOrCreateElement(tag, true);
+  }
+  removeTag(attrSelector) {
+    this.removeTagElement(this.getTag(attrSelector));
+  }
+  removeTagElement(meta) {
+    if (meta) {
+      this._dom.remove(meta);
+    }
+  }
+  _getOrCreateElement(meta, forceCreation = false) {
+    if (!forceCreation) {
+      const selector = this._parseSelector(meta);
+      const elem = this.getTags(selector).filter((elem2) => this._containsAttributes(meta, elem2))[0];
+      if (elem !== void 0) return elem;
+    }
+    const element = this._dom.createElement("meta");
+    this._setMetaElementAttributes(meta, element);
+    const head = this._doc.getElementsByTagName("head")[0];
+    head.appendChild(element);
+    return element;
+  }
+  _setMetaElementAttributes(tag, el) {
+    Object.keys(tag).forEach((prop) => el.setAttribute(this._getMetaKeyMap(prop), tag[prop]));
+    return el;
+  }
+  _parseSelector(tag) {
+    const attr = tag.name ? "name" : "property";
+    return `${attr}=${this._escapeSelectorValue(String(tag[attr]))}`;
+  }
+  _escapeSelectorValue(value) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+  }
+  _containsAttributes(tag, elem) {
+    return Object.keys(tag).every((key) => elem.getAttribute(this._getMetaKeyMap(key)) === tag[key]);
+  }
+  _getMetaKeyMap(prop) {
+    return META_KEYS_MAP[prop] || prop;
+  }
+  static \u0275fac = function Meta_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _Meta)(\u0275\u0275inject(DOCUMENT));
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _Meta,
+    factory: _Meta.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(Meta, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], () => [{
+    type: void 0,
+    decorators: [{
+      type: Inject,
+      args: [DOCUMENT]
+    }]
+  }], null);
+})();
+var META_KEYS_MAP = {
+  httpEquiv: "http-equiv"
+};
+var Title = class _Title {
+  _doc;
+  constructor(_doc) {
+    this._doc = _doc;
+  }
+  getTitle() {
+    return this._doc.title;
+  }
+  setTitle(newTitle) {
+    this._doc.title = newTitle || "";
+  }
+  static \u0275fac = function Title_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _Title)(\u0275\u0275inject(DOCUMENT));
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _Title,
+    factory: _Title.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(Title, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], () => [{
+    type: void 0,
+    decorators: [{
+      type: Inject,
+      args: [DOCUMENT]
+    }]
+  }], null);
+})();
+var EVENT_NAMES = {
+  "pan": true,
+  "panstart": true,
+  "panmove": true,
+  "panend": true,
+  "pancancel": true,
+  "panleft": true,
+  "panright": true,
+  "panup": true,
+  "pandown": true,
+  "pinch": true,
+  "pinchstart": true,
+  "pinchmove": true,
+  "pinchend": true,
+  "pinchcancel": true,
+  "pinchin": true,
+  "pinchout": true,
+  "press": true,
+  "pressup": true,
+  "rotate": true,
+  "rotatestart": true,
+  "rotatemove": true,
+  "rotateend": true,
+  "rotatecancel": true,
+  "swipe": true,
+  "swipeleft": true,
+  "swiperight": true,
+  "swipeup": true,
+  "swipedown": true,
+  "tap": true,
+  "doubletap": true
+};
+var HAMMER_GESTURE_CONFIG = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "HammerGestureConfig" : "");
+var HAMMER_LOADER = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "HammerLoader" : "");
+var HammerGestureConfig = class _HammerGestureConfig {
+  events = [];
+  overrides = {};
+  options;
+  buildHammer(element) {
+    const mc = new Hammer(element, this.options);
+    mc.get("pinch").set({
+      enable: true
+    });
+    mc.get("rotate").set({
+      enable: true
+    });
+    for (const eventName in this.overrides) {
+      mc.get(eventName).set(this.overrides[eventName]);
+    }
+    return mc;
+  }
+  static \u0275fac = function HammerGestureConfig_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _HammerGestureConfig)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _HammerGestureConfig,
+    factory: _HammerGestureConfig.\u0275fac
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HammerGestureConfig, [{
+    type: Injectable
+  }], null, null);
+})();
+var HammerGesturesPlugin = class _HammerGesturesPlugin extends EventManagerPlugin {
+  _config;
+  _injector;
+  loader;
+  _loaderPromise = null;
+  constructor(doc, _config, _injector, loader) {
+    super(doc);
+    this._config = _config;
+    this._injector = _injector;
+    this.loader = loader;
+  }
+  supports(eventName) {
+    if (!EVENT_NAMES.hasOwnProperty(eventName.toLowerCase()) && !this.isCustomEvent(eventName)) {
+      return false;
+    }
+    if (!window.Hammer && !this.loader) {
+      if (typeof ngDevMode === "undefined" || ngDevMode) {
+        const _console = this._injector.get(Console);
+        _console.warn(`The "${eventName}" event cannot be bound because Hammer.JS is not loaded and no custom loader has been specified.`);
+      }
+      return false;
+    }
+    return true;
+  }
+  addEventListener(element, eventName, handler) {
+    const zone = this.manager.getZone();
+    eventName = eventName.toLowerCase();
+    if (!window.Hammer && this.loader) {
+      this._loaderPromise = this._loaderPromise || zone.runOutsideAngular(() => this.loader());
+      let cancelRegistration = false;
+      let deregister = () => {
+        cancelRegistration = true;
+      };
+      zone.runOutsideAngular(() => this._loaderPromise.then(() => {
+        if (!window.Hammer) {
+          if (typeof ngDevMode === "undefined" || ngDevMode) {
+            const _console = this._injector.get(Console);
+            _console.warn(`The custom HAMMER_LOADER completed, but Hammer.JS is not present.`);
+          }
+          deregister = () => {
+          };
+          return;
+        }
+        if (!cancelRegistration) {
+          deregister = this.addEventListener(element, eventName, handler);
+        }
+      }).catch(() => {
+        if (typeof ngDevMode === "undefined" || ngDevMode) {
+          const _console = this._injector.get(Console);
+          _console.warn(`The "${eventName}" event cannot be bound because the custom Hammer.JS loader failed.`);
+        }
+        deregister = () => {
+        };
+      }));
+      return () => {
+        deregister();
+      };
+    }
+    return zone.runOutsideAngular(() => {
+      const mc = this._config.buildHammer(element);
+      const callback = function(eventObj) {
+        zone.runGuarded(function() {
+          handler(eventObj);
+        });
+      };
+      mc.on(eventName, callback);
+      return () => {
+        mc.off(eventName, callback);
+        if (typeof mc.destroy === "function") {
+          mc.destroy();
+        }
+      };
+    });
+  }
+  isCustomEvent(eventName) {
+    return this._config.events.indexOf(eventName) > -1;
+  }
+  static \u0275fac = function HammerGesturesPlugin_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _HammerGesturesPlugin)(\u0275\u0275inject(DOCUMENT), \u0275\u0275inject(HAMMER_GESTURE_CONFIG), \u0275\u0275inject(Injector), \u0275\u0275inject(HAMMER_LOADER, 8));
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _HammerGesturesPlugin,
+    factory: _HammerGesturesPlugin.\u0275fac
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HammerGesturesPlugin, [{
+    type: Injectable
+  }], () => [{
+    type: void 0,
+    decorators: [{
+      type: Inject,
+      args: [DOCUMENT]
+    }]
+  }, {
+    type: HammerGestureConfig,
+    decorators: [{
+      type: Inject,
+      args: [HAMMER_GESTURE_CONFIG]
+    }]
+  }, {
+    type: Injector
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Inject,
+      args: [HAMMER_LOADER]
+    }]
+  }], null);
+})();
+var HammerModule = class _HammerModule {
+  static \u0275fac = function HammerModule_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _HammerModule)();
+  };
+  static \u0275mod = /* @__PURE__ */ \u0275\u0275defineNgModule({
+    type: _HammerModule
+  });
+  static \u0275inj = /* @__PURE__ */ \u0275\u0275defineInjector({
+    providers: [{
+      provide: EVENT_MANAGER_PLUGINS,
+      useClass: HammerGesturesPlugin,
+      multi: true,
+      deps: [DOCUMENT, HAMMER_GESTURE_CONFIG, Injector, [new Optional(), HAMMER_LOADER]]
+    }, {
+      provide: HAMMER_GESTURE_CONFIG,
+      useClass: HammerGestureConfig
+    }]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HammerModule, [{
+    type: NgModule,
+    args: [{
+      providers: [{
+        provide: EVENT_MANAGER_PLUGINS,
+        useClass: HammerGesturesPlugin,
+        multi: true,
+        deps: [DOCUMENT, HAMMER_GESTURE_CONFIG, Injector, [new Optional(), HAMMER_LOADER]]
+      }, {
+        provide: HAMMER_GESTURE_CONFIG,
+        useClass: HammerGestureConfig
+      }]
+    }]
+  }], null, null);
+})();
+var DomSanitizer = class _DomSanitizer {
+  static \u0275fac = function DomSanitizer_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _DomSanitizer)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _DomSanitizer,
+    factory: function DomSanitizer_Factory(__ngFactoryType__) {
+      let __ngConditionalFactory__ = null;
+      if (__ngFactoryType__) {
+        __ngConditionalFactory__ = new (__ngFactoryType__ || _DomSanitizer)();
+      } else {
+        __ngConditionalFactory__ = \u0275\u0275inject(DomSanitizerImpl);
+      }
+      return __ngConditionalFactory__;
+    },
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DomSanitizer, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root",
+      useExisting: forwardRef(() => DomSanitizerImpl)
+    }]
+  }], null, null);
+})();
+var DomSanitizerImpl = class _DomSanitizerImpl extends DomSanitizer {
+  _doc;
+  constructor(_doc) {
+    super();
+    this._doc = _doc;
+  }
+  sanitize(ctx, value) {
+    if (value == null) return null;
+    switch (ctx) {
+      case SecurityContext.NONE:
+        return value;
+      case SecurityContext.HTML:
+        if (allowSanitizationBypassAndThrow(value, "HTML")) {
+          return unwrapSafeValue(value);
+        }
+        return _sanitizeHtml(this._doc, String(value)).toString();
+      case SecurityContext.STYLE:
+        if (allowSanitizationBypassAndThrow(value, "Style")) {
+          return unwrapSafeValue(value);
+        }
+        return value;
+      case SecurityContext.SCRIPT:
+        if (allowSanitizationBypassAndThrow(value, "Script")) {
+          return unwrapSafeValue(value);
+        }
+        throw new RuntimeError(5200, (typeof ngDevMode === "undefined" || ngDevMode) && "unsafe value used in a script context");
+      case SecurityContext.URL:
+        if (allowSanitizationBypassAndThrow(value, "URL")) {
+          return unwrapSafeValue(value);
+        }
+        return _sanitizeUrl(String(value));
+      case SecurityContext.RESOURCE_URL:
+        if (allowSanitizationBypassAndThrow(value, "ResourceURL")) {
+          return unwrapSafeValue(value);
+        }
+        throw new RuntimeError(5201, (typeof ngDevMode === "undefined" || ngDevMode) && `unsafe value used in a resource URL context (see ${XSS_SECURITY_URL})`);
+      default:
+        throw new RuntimeError(5202, (typeof ngDevMode === "undefined" || ngDevMode) && `Unexpected SecurityContext ${ctx} (see ${XSS_SECURITY_URL})`);
+    }
+  }
+  bypassSecurityTrustHtml(value) {
+    return bypassSanitizationTrustHtml(value);
+  }
+  bypassSecurityTrustStyle(value) {
+    return bypassSanitizationTrustStyle(value);
+  }
+  bypassSecurityTrustScript(value) {
+    return bypassSanitizationTrustScript(value);
+  }
+  bypassSecurityTrustUrl(value) {
+    return bypassSanitizationTrustUrl(value);
+  }
+  bypassSecurityTrustResourceUrl(value) {
+    return bypassSanitizationTrustResourceUrl(value);
+  }
+  static \u0275fac = function DomSanitizerImpl_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _DomSanitizerImpl)(\u0275\u0275inject(DOCUMENT));
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _DomSanitizerImpl,
+    factory: _DomSanitizerImpl.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DomSanitizerImpl, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], () => [{
+    type: void 0,
+    decorators: [{
+      type: Inject,
+      args: [DOCUMENT]
+    }]
+  }], null);
+})();
+var HydrationFeatureKind;
+(function(HydrationFeatureKind2) {
+  HydrationFeatureKind2[HydrationFeatureKind2["NoHttpTransferCache"] = 0] = "NoHttpTransferCache";
+  HydrationFeatureKind2[HydrationFeatureKind2["HttpTransferCacheOptions"] = 1] = "HttpTransferCacheOptions";
+  HydrationFeatureKind2[HydrationFeatureKind2["I18nSupport"] = 2] = "I18nSupport";
+  HydrationFeatureKind2[HydrationFeatureKind2["EventReplay"] = 3] = "EventReplay";
+  HydrationFeatureKind2[HydrationFeatureKind2["IncrementalHydration"] = 4] = "IncrementalHydration";
+})(HydrationFeatureKind || (HydrationFeatureKind = {}));
+
+// node_modules/@angular/router/fesm2022/_router-chunk.mjs
+/**
+ * @license Angular v21.2.17
+ * (c) 2010-2026 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+var PRIMARY_OUTLET = "primary";
+var RouteTitleKey = /* @__PURE__ */ Symbol("RouteTitle");
+var ParamsAsMap = class {
+  params;
+  constructor(params) {
+    this.params = params || {};
+  }
+  has(name) {
+    return Object.prototype.hasOwnProperty.call(this.params, name);
+  }
+  get(name) {
+    if (this.has(name)) {
+      const v = this.params[name];
+      return Array.isArray(v) ? v[0] : v;
+    }
+    return null;
+  }
+  getAll(name) {
+    if (this.has(name)) {
+      const v = this.params[name];
+      return Array.isArray(v) ? v : [v];
+    }
+    return [];
+  }
+  get keys() {
+    return Object.keys(this.params);
+  }
+};
+function convertToParamMap(params) {
+  return new ParamsAsMap(params);
+}
+function matchParts(routeParts, urlSegments, posParams) {
+  for (let i = 0; i < routeParts.length; i++) {
+    const part = routeParts[i];
+    const segment = urlSegments[i];
+    const isParameter = part[0] === ":";
+    if (isParameter) {
+      posParams[part.substring(1)] = segment;
+    } else if (part !== segment.path) {
+      return false;
+    }
+  }
+  return true;
+}
+function defaultUrlMatcher(segments, segmentGroup, route) {
+  const parts = route.path.split("/");
+  const wildcardIndex = parts.indexOf("**");
+  if (wildcardIndex === -1) {
+    if (parts.length > segments.length) {
+      return null;
+    }
+    if (route.pathMatch === "full" && (segmentGroup.hasChildren() || parts.length < segments.length)) {
+      return null;
+    }
+    const posParams2 = {};
+    const consumed = segments.slice(0, parts.length);
+    if (!matchParts(parts, consumed, posParams2)) {
+      return null;
+    }
+    return {
+      consumed,
+      posParams: posParams2
+    };
+  }
+  if (wildcardIndex !== parts.lastIndexOf("**")) {
+    return null;
+  }
+  const pre = parts.slice(0, wildcardIndex);
+  const post = parts.slice(wildcardIndex + 1);
+  if (pre.length + post.length > segments.length) {
+    return null;
+  }
+  if (route.pathMatch === "full" && segmentGroup.hasChildren() && route.path !== "**") {
+    return null;
+  }
+  const posParams = {};
+  if (!matchParts(pre, segments.slice(0, pre.length), posParams)) {
+    return null;
+  }
+  if (!matchParts(post, segments.slice(segments.length - post.length), posParams)) {
+    return null;
+  }
+  return {
+    consumed: segments,
+    posParams
+  };
+}
+function firstValueFrom(source) {
+  return new Promise((resolve, reject) => {
+    source.pipe(first()).subscribe({
+      next: (value) => resolve(value),
+      error: (err) => reject(err)
+    });
+  });
+}
+function shallowEqualArrays(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; ++i) {
+    if (!shallowEqual(a[i], b[i])) return false;
+  }
+  return true;
+}
+function shallowEqual(a, b) {
+  const k1 = a ? getDataKeys(a) : void 0;
+  const k2 = b ? getDataKeys(b) : void 0;
+  if (!k1 || !k2 || k1.length != k2.length) {
+    return false;
+  }
+  let key;
+  for (let i = 0; i < k1.length; i++) {
+    key = k1[i];
+    if (!equalArraysOrString(a[key], b[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+function getDataKeys(obj) {
+  return [...Object.keys(obj), ...Object.getOwnPropertySymbols(obj)];
+}
+function equalArraysOrString(a, b) {
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    const aSorted = [...a].sort();
+    const bSorted = [...b].sort();
+    return aSorted.every((val, index) => bSorted[index] === val);
+  } else {
+    return a === b;
+  }
+}
+function last2(a) {
+  return a.length > 0 ? a[a.length - 1] : null;
+}
+function wrapIntoObservable(value) {
+  if (isObservable(value)) {
+    return value;
+  }
+  if (isPromise2(value)) {
+    return from(Promise.resolve(value));
+  }
+  return of(value);
+}
+function wrapIntoPromise(value) {
+  if (isObservable(value)) {
+    return firstValueFrom(value);
+  }
+  return Promise.resolve(value);
+}
+var pathCompareMap = {
+  "exact": equalSegmentGroups,
+  "subset": containsSegmentGroup
+};
+var paramCompareMap = {
+  "exact": equalParams,
+  "subset": containsParams,
+  "ignored": () => true
+};
+var exactMatchOptions = {
+  paths: "exact",
+  fragment: "ignored",
+  matrixParams: "ignored",
+  queryParams: "exact"
+};
+var subsetMatchOptions = {
+  paths: "subset",
+  fragment: "ignored",
+  matrixParams: "ignored",
+  queryParams: "subset"
+};
+function isActive(url, router, matchOptions) {
+  const urlTree = url instanceof UrlTree ? url : router.parseUrl(url);
+  return computed(() => containsTree(router.lastSuccessfulNavigation()?.finalUrl ?? new UrlTree(), urlTree, __spreadValues(__spreadValues({}, subsetMatchOptions), matchOptions)));
+}
+function containsTree(container, containee, options) {
+  return pathCompareMap[options.paths](container.root, containee.root, options.matrixParams) && paramCompareMap[options.queryParams](container.queryParams, containee.queryParams) && !(options.fragment === "exact" && container.fragment !== containee.fragment);
+}
+function equalParams(container, containee) {
+  return shallowEqual(container, containee);
+}
+function equalSegmentGroups(container, containee, matrixParams) {
+  if (!equalPath(container.segments, containee.segments)) return false;
+  if (!matrixParamsMatch(container.segments, containee.segments, matrixParams)) {
+    return false;
+  }
+  if (container.numberOfChildren !== containee.numberOfChildren) return false;
+  for (const c in containee.children) {
+    if (!container.children[c]) return false;
+    if (!equalSegmentGroups(container.children[c], containee.children[c], matrixParams)) return false;
+  }
+  return true;
+}
+function containsParams(container, containee) {
+  return Object.keys(containee).length <= Object.keys(container).length && Object.keys(containee).every((key) => equalArraysOrString(container[key], containee[key]));
+}
+function containsSegmentGroup(container, containee, matrixParams) {
+  return containsSegmentGroupHelper(container, containee, containee.segments, matrixParams);
+}
+function containsSegmentGroupHelper(container, containee, containeePaths, matrixParams) {
+  if (container.segments.length > containeePaths.length) {
+    const current = container.segments.slice(0, containeePaths.length);
+    if (!equalPath(current, containeePaths)) return false;
+    if (containee.hasChildren()) return false;
+    if (!matrixParamsMatch(current, containeePaths, matrixParams)) return false;
+    return true;
+  } else if (container.segments.length === containeePaths.length) {
+    if (!equalPath(container.segments, containeePaths)) return false;
+    if (!matrixParamsMatch(container.segments, containeePaths, matrixParams)) return false;
+    for (const c in containee.children) {
+      if (!container.children[c]) return false;
+      if (!containsSegmentGroup(container.children[c], containee.children[c], matrixParams)) {
+        return false;
+      }
+    }
+    return true;
+  } else {
+    const current = containeePaths.slice(0, container.segments.length);
+    const next = containeePaths.slice(container.segments.length);
+    if (!equalPath(container.segments, current)) return false;
+    if (!matrixParamsMatch(container.segments, current, matrixParams)) return false;
+    if (!container.children[PRIMARY_OUTLET]) return false;
+    return containsSegmentGroupHelper(container.children[PRIMARY_OUTLET], containee, next, matrixParams);
+  }
+}
+function matrixParamsMatch(containerPaths, containeePaths, options) {
+  return containeePaths.every((containeeSegment, i) => {
+    return paramCompareMap[options](containerPaths[i].parameters, containeeSegment.parameters);
+  });
+}
+var UrlTree = class {
+  root;
+  queryParams;
+  fragment;
+  _queryParamMap;
+  constructor(root = new UrlSegmentGroup([], {}), queryParams = {}, fragment = null) {
+    this.root = root;
+    this.queryParams = queryParams;
+    this.fragment = fragment;
+    if (typeof ngDevMode === "undefined" || ngDevMode) {
+      if (root.segments.length > 0) {
+        throw new RuntimeError(4015, "The root `UrlSegmentGroup` should not contain `segments`. Instead, these segments belong in the `children` so they can be associated with a named outlet.");
+      }
+    }
+  }
+  get queryParamMap() {
+    this._queryParamMap ??= convertToParamMap(this.queryParams);
+    return this._queryParamMap;
+  }
+  toString() {
+    return DEFAULT_SERIALIZER.serialize(this);
+  }
+};
+var UrlSegmentGroup = class {
+  segments;
+  children;
+  parent = null;
+  constructor(segments, children) {
+    this.segments = segments;
+    this.children = children;
+    Object.values(children).forEach((v) => v.parent = this);
+  }
+  hasChildren() {
+    return this.numberOfChildren > 0;
+  }
+  get numberOfChildren() {
+    return Object.keys(this.children).length;
+  }
+  toString() {
+    return serializePaths(this);
+  }
+};
+var UrlSegment = class {
+  path;
+  parameters;
+  _parameterMap;
+  constructor(path, parameters) {
+    this.path = path;
+    this.parameters = parameters;
+  }
+  get parameterMap() {
+    this._parameterMap ??= convertToParamMap(this.parameters);
+    return this._parameterMap;
+  }
+  toString() {
+    return serializePath(this);
+  }
+};
+function equalSegments(as, bs) {
+  return equalPath(as, bs) && as.every((a, i) => shallowEqual(a.parameters, bs[i].parameters));
+}
+function equalPath(as, bs) {
+  if (as.length !== bs.length) return false;
+  return as.every((a, i) => a.path === bs[i].path);
+}
+function mapChildrenIntoArray(segment, fn) {
+  let res = [];
+  Object.entries(segment.children).forEach(([childOutlet, child]) => {
+    if (childOutlet === PRIMARY_OUTLET) {
+      res = res.concat(fn(child, childOutlet));
+    }
+  });
+  Object.entries(segment.children).forEach(([childOutlet, child]) => {
+    if (childOutlet !== PRIMARY_OUTLET) {
+      res = res.concat(fn(child, childOutlet));
+    }
+  });
+  return res;
+}
+var UrlSerializer = class _UrlSerializer {
+  static \u0275fac = function UrlSerializer_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _UrlSerializer)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _UrlSerializer,
+    factory: () => (() => new DefaultUrlSerializer())(),
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(UrlSerializer, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root",
+      useFactory: () => new DefaultUrlSerializer()
+    }]
+  }], null, null);
+})();
+var DefaultUrlSerializer = class {
+  parse(url) {
+    const p = new UrlParser(url);
+    return new UrlTree(p.parseRootSegment(), p.parseQueryParams(), p.parseFragment());
+  }
+  serialize(tree2) {
+    const segment = `/${serializeSegment(tree2.root, true)}`;
+    const query = serializeQueryParams(tree2.queryParams);
+    const fragment = typeof tree2.fragment === `string` ? `#${encodeUriFragment(tree2.fragment)}` : "";
+    return `${segment}${query}${fragment}`;
+  }
+};
+var DEFAULT_SERIALIZER = new DefaultUrlSerializer();
+function serializePaths(segment) {
+  return segment.segments.map((p) => serializePath(p)).join("/");
+}
+function serializeSegment(segment, root) {
+  if (!segment.hasChildren()) {
+    return serializePaths(segment);
+  }
+  if (root) {
+    const primary = segment.children[PRIMARY_OUTLET] ? serializeSegment(segment.children[PRIMARY_OUTLET], false) : "";
+    const children = [];
+    Object.entries(segment.children).forEach(([k, v]) => {
+      if (k !== PRIMARY_OUTLET) {
+        children.push(`${k}:${serializeSegment(v, false)}`);
+      }
+    });
+    return children.length > 0 ? `${primary}(${children.join("//")})` : primary;
+  } else {
+    const children = mapChildrenIntoArray(segment, (v, k) => {
+      if (k === PRIMARY_OUTLET) {
+        return [serializeSegment(segment.children[PRIMARY_OUTLET], false)];
+      }
+      return [`${k}:${serializeSegment(v, false)}`];
+    });
+    if (Object.keys(segment.children).length === 1 && segment.children[PRIMARY_OUTLET] != null) {
+      return `${serializePaths(segment)}/${children[0]}`;
+    }
+    return `${serializePaths(segment)}/(${children.join("//")})`;
+  }
+}
+function encodeUriString(s) {
+  return encodeURIComponent(s).replace(/%40/g, "@").replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",");
+}
+function encodeUriQuery(s) {
+  return encodeUriString(s).replace(/%3B/gi, ";");
+}
+function encodeUriFragment(s) {
+  return encodeURI(s);
+}
+function encodeUriSegment(s) {
+  return encodeUriString(s).replace(/\(/g, "%28").replace(/\)/g, "%29").replace(/%26/gi, "&");
+}
+function decode(s) {
+  return decodeURIComponent(s);
+}
+function decodeQuery(s) {
+  return decode(s.replace(/\+/g, "%20"));
+}
+function serializePath(path) {
+  return `${encodeUriSegment(path.path)}${serializeMatrixParams(path.parameters)}`;
+}
+function serializeMatrixParams(params) {
+  return Object.entries(params).map(([key, value]) => `;${encodeUriSegment(key)}=${encodeUriSegment(value)}`).join("");
+}
+function serializeQueryParams(params) {
+  const strParams = Object.entries(params).map(([name, value]) => {
+    return Array.isArray(value) ? value.map((v) => `${encodeUriQuery(name)}=${encodeUriQuery(v)}`).join("&") : `${encodeUriQuery(name)}=${encodeUriQuery(value)}`;
+  }).filter((s) => s);
+  return strParams.length ? `?${strParams.join("&")}` : "";
+}
+var SEGMENT_RE = /^[^\/()?;#]+/;
+function matchSegments(str) {
+  const match2 = str.match(SEGMENT_RE);
+  return match2 ? match2[0] : "";
+}
+var MATRIX_PARAM_SEGMENT_RE = /^[^\/()?;=#]+/;
+function matchMatrixKeySegments(str) {
+  const match2 = str.match(MATRIX_PARAM_SEGMENT_RE);
+  return match2 ? match2[0] : "";
+}
+var QUERY_PARAM_RE = /^[^=?&#]+/;
+function matchQueryParams(str) {
+  const match2 = str.match(QUERY_PARAM_RE);
+  return match2 ? match2[0] : "";
+}
+var QUERY_PARAM_VALUE_RE = /^[^&#]+/;
+function matchUrlQueryParamValue(str) {
+  const match2 = str.match(QUERY_PARAM_VALUE_RE);
+  return match2 ? match2[0] : "";
+}
+var UrlParser = class {
+  url;
+  remaining;
+  constructor(url) {
+    this.url = url;
+    this.remaining = url;
+  }
+  parseRootSegment() {
+    while (this.consumeOptional("/")) {
+    }
+    if (this.remaining === "" || this.peekStartsWith("?") || this.peekStartsWith("#")) {
+      return new UrlSegmentGroup([], {});
+    }
+    return new UrlSegmentGroup([], this.parseChildren());
+  }
+  parseQueryParams() {
+    const params = {};
+    if (this.consumeOptional("?")) {
+      do {
+        this.parseQueryParam(params);
+      } while (this.consumeOptional("&"));
+    }
+    return params;
+  }
+  parseFragment() {
+    return this.consumeOptional("#") ? decodeURIComponent(this.remaining) : null;
+  }
+  parseChildren(depth = 0) {
+    if (depth > 50) {
+      throw new RuntimeError(4010, (typeof ngDevMode === "undefined" || ngDevMode) && "URL is too deep");
+    }
+    if (this.remaining === "") {
+      return {};
+    }
+    this.consumeOptional("/");
+    const segments = [];
+    if (!this.peekStartsWith("(")) {
+      segments.push(this.parseSegment());
+    }
+    while (this.peekStartsWith("/") && !this.peekStartsWith("//") && !this.peekStartsWith("/(")) {
+      this.capture("/");
+      segments.push(this.parseSegment());
+    }
+    let children = {};
+    if (this.peekStartsWith("/(")) {
+      this.capture("/");
+      children = this.parseParens(true, depth);
+    }
+    let res = {};
+    if (this.peekStartsWith("(")) {
+      res = this.parseParens(false, depth);
+    }
+    if (segments.length > 0 || Object.keys(children).length > 0) {
+      res[PRIMARY_OUTLET] = new UrlSegmentGroup(segments, children);
+    }
+    return res;
+  }
+  parseSegment() {
+    const path = matchSegments(this.remaining);
+    if (path === "" && this.peekStartsWith(";")) {
+      throw new RuntimeError(4009, (typeof ngDevMode === "undefined" || ngDevMode) && `Empty path url segment cannot have parameters: '${this.remaining}'.`);
+    }
+    this.capture(path);
+    return new UrlSegment(decode(path), this.parseMatrixParams());
+  }
+  parseMatrixParams() {
+    const params = {};
+    while (this.consumeOptional(";")) {
+      this.parseParam(params);
+    }
+    return params;
+  }
+  parseParam(params) {
+    const key = matchMatrixKeySegments(this.remaining);
+    if (!key) {
+      return;
+    }
+    this.capture(key);
+    let value = "";
+    if (this.consumeOptional("=")) {
+      const valueMatch = matchSegments(this.remaining);
+      if (valueMatch) {
+        value = valueMatch;
+        this.capture(value);
+      }
+    }
+    params[decode(key)] = decode(value);
+  }
+  parseQueryParam(params) {
+    const key = matchQueryParams(this.remaining);
+    if (!key) {
+      return;
+    }
+    this.capture(key);
+    let value = "";
+    if (this.consumeOptional("=")) {
+      const valueMatch = matchUrlQueryParamValue(this.remaining);
+      if (valueMatch) {
+        value = valueMatch;
+        this.capture(value);
+      }
+    }
+    const decodedKey = decodeQuery(key);
+    const decodedVal = decodeQuery(value);
+    if (params.hasOwnProperty(decodedKey)) {
+      let currentVal = params[decodedKey];
+      if (!Array.isArray(currentVal)) {
+        currentVal = [currentVal];
+        params[decodedKey] = currentVal;
+      }
+      currentVal.push(decodedVal);
+    } else {
+      params[decodedKey] = decodedVal;
+    }
+  }
+  parseParens(allowPrimary, depth) {
+    const segments = {};
+    this.capture("(");
+    while (!this.consumeOptional(")") && this.remaining.length > 0) {
+      const path = matchSegments(this.remaining);
+      const next = this.remaining[path.length];
+      if (next !== "/" && next !== ")" && next !== ";") {
+        throw new RuntimeError(4010, (typeof ngDevMode === "undefined" || ngDevMode) && `Cannot parse url '${this.url}'`);
+      }
+      let outletName;
+      if (path.indexOf(":") > -1) {
+        outletName = path.slice(0, path.indexOf(":"));
+        this.capture(outletName);
+        this.capture(":");
+      } else if (allowPrimary) {
+        outletName = PRIMARY_OUTLET;
+      }
+      const children = this.parseChildren(depth + 1);
+      segments[outletName ?? PRIMARY_OUTLET] = Object.keys(children).length === 1 && children[PRIMARY_OUTLET] ? children[PRIMARY_OUTLET] : new UrlSegmentGroup([], children);
+      this.consumeOptional("//");
+    }
+    return segments;
+  }
+  peekStartsWith(str) {
+    return this.remaining.startsWith(str);
+  }
+  consumeOptional(str) {
+    if (this.peekStartsWith(str)) {
+      this.remaining = this.remaining.substring(str.length);
+      return true;
+    }
+    return false;
+  }
+  capture(str) {
+    if (!this.consumeOptional(str)) {
+      throw new RuntimeError(4011, (typeof ngDevMode === "undefined" || ngDevMode) && `Expected "${str}".`);
+    }
+  }
+};
+function createRoot(rootCandidate) {
+  return rootCandidate.segments.length > 0 ? new UrlSegmentGroup([], {
+    [PRIMARY_OUTLET]: rootCandidate
+  }) : rootCandidate;
+}
+function squashSegmentGroup(segmentGroup) {
+  const newChildren = {};
+  for (const [childOutlet, child] of Object.entries(segmentGroup.children)) {
+    const childCandidate = squashSegmentGroup(child);
+    if (childOutlet === PRIMARY_OUTLET && childCandidate.segments.length === 0 && childCandidate.hasChildren()) {
+      for (const [grandChildOutlet, grandChild] of Object.entries(childCandidate.children)) {
+        newChildren[grandChildOutlet] = grandChild;
+      }
+    } else if (childCandidate.segments.length > 0 || childCandidate.hasChildren()) {
+      newChildren[childOutlet] = childCandidate;
+    }
+  }
+  const s = new UrlSegmentGroup(segmentGroup.segments, newChildren);
+  return mergeTrivialChildren(s);
+}
+function mergeTrivialChildren(s) {
+  if (s.numberOfChildren === 1 && s.children[PRIMARY_OUTLET]) {
+    const c = s.children[PRIMARY_OUTLET];
+    return new UrlSegmentGroup(s.segments.concat(c.segments), c.children);
+  }
+  return s;
+}
+function isUrlTree(v) {
+  return v instanceof UrlTree;
+}
+function createUrlTreeFromSnapshot(relativeTo, commands, queryParams = null, fragment = null, urlSerializer = new DefaultUrlSerializer()) {
+  const relativeToUrlSegmentGroup = createSegmentGroupFromRoute(relativeTo);
+  return createUrlTreeFromSegmentGroup(relativeToUrlSegmentGroup, commands, queryParams, fragment, urlSerializer);
+}
+function createSegmentGroupFromRoute(route) {
+  let targetGroup;
+  function createSegmentGroupFromRouteRecursive(currentRoute) {
+    const childOutlets = {};
+    for (const childSnapshot of currentRoute.children) {
+      const root = createSegmentGroupFromRouteRecursive(childSnapshot);
+      childOutlets[childSnapshot.outlet] = root;
+    }
+    const segmentGroup = new UrlSegmentGroup(currentRoute.url, childOutlets);
+    if (currentRoute === route) {
+      targetGroup = segmentGroup;
+    }
+    return segmentGroup;
+  }
+  const rootCandidate = createSegmentGroupFromRouteRecursive(route.root);
+  const rootSegmentGroup = createRoot(rootCandidate);
+  return targetGroup ?? rootSegmentGroup;
+}
+function createUrlTreeFromSegmentGroup(relativeTo, commands, queryParams, fragment, urlSerializer) {
+  let root = relativeTo;
+  while (root.parent) {
+    root = root.parent;
+  }
+  if (commands.length === 0) {
+    return tree(root, root, root, queryParams, fragment, urlSerializer);
+  }
+  const nav = computeNavigation(commands);
+  if (nav.toRoot()) {
+    return tree(root, root, new UrlSegmentGroup([], {}), queryParams, fragment, urlSerializer);
+  }
+  const position = findStartingPositionForTargetGroup(nav, root, relativeTo);
+  const newSegmentGroup = position.processChildren ? updateSegmentGroupChildren(position.segmentGroup, position.index, nav.commands) : updateSegmentGroup(position.segmentGroup, position.index, nav.commands);
+  return tree(root, position.segmentGroup, newSegmentGroup, queryParams, fragment, urlSerializer);
+}
+function isMatrixParams(command) {
+  return typeof command === "object" && command != null && !command.outlets && !command.segmentPath;
+}
+function isCommandWithOutlets(command) {
+  return typeof command === "object" && command != null && command.outlets;
+}
+function normalizeQueryParams2(k, v, urlSerializer) {
+  k ||= "\u0275";
+  const tree2 = new UrlTree();
+  tree2.queryParams = {
+    [k]: v
+  };
+  return urlSerializer.parse(urlSerializer.serialize(tree2)).queryParams[k];
+}
+function tree(oldRoot, oldSegmentGroup, newSegmentGroup, queryParams, fragment, urlSerializer) {
+  const qp = {};
+  for (const [key, value] of Object.entries(queryParams ?? {})) {
+    qp[key] = Array.isArray(value) ? value.map((v) => normalizeQueryParams2(key, v, urlSerializer)) : normalizeQueryParams2(key, value, urlSerializer);
+  }
+  let rootCandidate;
+  if (oldRoot === oldSegmentGroup) {
+    rootCandidate = newSegmentGroup;
+  } else {
+    rootCandidate = replaceSegment(oldRoot, oldSegmentGroup, newSegmentGroup);
+  }
+  const newRoot = createRoot(squashSegmentGroup(rootCandidate));
+  return new UrlTree(newRoot, qp, fragment);
+}
+function replaceSegment(current, oldSegment, newSegment) {
+  const children = {};
+  Object.entries(current.children).forEach(([outletName, c]) => {
+    if (c === oldSegment) {
+      children[outletName] = newSegment;
+    } else {
+      children[outletName] = replaceSegment(c, oldSegment, newSegment);
+    }
+  });
+  return new UrlSegmentGroup(current.segments, children);
+}
+var Navigation = class {
+  isAbsolute;
+  numberOfDoubleDots;
+  commands;
+  constructor(isAbsolute, numberOfDoubleDots, commands) {
+    this.isAbsolute = isAbsolute;
+    this.numberOfDoubleDots = numberOfDoubleDots;
+    this.commands = commands;
+    if (isAbsolute && commands.length > 0 && isMatrixParams(commands[0])) {
+      throw new RuntimeError(4003, (typeof ngDevMode === "undefined" || ngDevMode) && "Root segment cannot have matrix parameters");
+    }
+    const cmdWithOutlet = commands.find(isCommandWithOutlets);
+    if (cmdWithOutlet && cmdWithOutlet !== last2(commands)) {
+      throw new RuntimeError(4004, (typeof ngDevMode === "undefined" || ngDevMode) && "{outlets:{}} has to be the last command");
+    }
+  }
+  toRoot() {
+    return this.isAbsolute && this.commands.length === 1 && this.commands[0] == "/";
+  }
+};
+function computeNavigation(commands) {
+  if (typeof commands[0] === "string" && commands.length === 1 && commands[0] === "/") {
+    return new Navigation(true, 0, commands);
+  }
+  let numberOfDoubleDots = 0;
+  let isAbsolute = false;
+  const res = commands.reduce((res2, cmd, cmdIdx) => {
+    if (typeof cmd === "object" && cmd != null) {
+      if (cmd.outlets) {
+        const outlets = {};
+        Object.entries(cmd.outlets).forEach(([name, commands2]) => {
+          outlets[name] = typeof commands2 === "string" ? commands2.split("/") : commands2;
+        });
+        return [...res2, {
+          outlets
+        }];
+      }
+      if (cmd.segmentPath) {
+        return [...res2, cmd.segmentPath];
+      }
+    }
+    if (!(typeof cmd === "string")) {
+      return [...res2, cmd];
+    }
+    if (cmdIdx === 0) {
+      cmd.split("/").forEach((urlPart, partIndex) => {
+        if (partIndex == 0 && urlPart === ".") ;
+        else if (partIndex == 0 && urlPart === "") {
+          isAbsolute = true;
+        } else if (urlPart === "..") {
+          numberOfDoubleDots++;
+        } else if (urlPart != "") {
+          res2.push(urlPart);
+        }
+      });
+      return res2;
+    }
+    return [...res2, cmd];
+  }, []);
+  return new Navigation(isAbsolute, numberOfDoubleDots, res);
+}
+var Position = class {
+  segmentGroup;
+  processChildren;
+  index;
+  constructor(segmentGroup, processChildren, index) {
+    this.segmentGroup = segmentGroup;
+    this.processChildren = processChildren;
+    this.index = index;
+  }
+};
+function findStartingPositionForTargetGroup(nav, root, target) {
+  if (nav.isAbsolute) {
+    return new Position(root, true, 0);
+  }
+  if (!target) {
+    return new Position(root, false, NaN);
+  }
+  if (target.parent === null) {
+    return new Position(target, true, 0);
+  }
+  const modifier = isMatrixParams(nav.commands[0]) ? 0 : 1;
+  const index = target.segments.length - 1 + modifier;
+  return createPositionApplyingDoubleDots(target, index, nav.numberOfDoubleDots);
+}
+function createPositionApplyingDoubleDots(group, index, numberOfDoubleDots) {
+  let g = group;
+  let ci = index;
+  let dd = numberOfDoubleDots;
+  while (dd > ci) {
+    dd -= ci;
+    g = g.parent;
+    if (!g) {
+      throw new RuntimeError(4005, (typeof ngDevMode === "undefined" || ngDevMode) && "Invalid number of '../'");
+    }
+    ci = g.segments.length;
+  }
+  return new Position(g, false, ci - dd);
+}
+function getOutlets(commands) {
+  if (isCommandWithOutlets(commands[0])) {
+    return commands[0].outlets;
+  }
+  return {
+    [PRIMARY_OUTLET]: commands
+  };
+}
+function updateSegmentGroup(segmentGroup, startIndex, commands) {
+  segmentGroup ??= new UrlSegmentGroup([], {});
+  if (segmentGroup.segments.length === 0 && segmentGroup.hasChildren()) {
+    return updateSegmentGroupChildren(segmentGroup, startIndex, commands);
+  }
+  const m = prefixedWith(segmentGroup, startIndex, commands);
+  const slicedCommands = commands.slice(m.commandIndex);
+  if (m.match && m.pathIndex < segmentGroup.segments.length) {
+    const g = new UrlSegmentGroup(segmentGroup.segments.slice(0, m.pathIndex), {});
+    g.children[PRIMARY_OUTLET] = new UrlSegmentGroup(segmentGroup.segments.slice(m.pathIndex), segmentGroup.children);
+    return updateSegmentGroupChildren(g, 0, slicedCommands);
+  } else if (m.match && slicedCommands.length === 0) {
+    return new UrlSegmentGroup(segmentGroup.segments, {});
+  } else if (m.match && !segmentGroup.hasChildren()) {
+    return createNewSegmentGroup(segmentGroup, startIndex, commands);
+  } else if (m.match) {
+    return updateSegmentGroupChildren(segmentGroup, 0, slicedCommands);
+  } else {
+    return createNewSegmentGroup(segmentGroup, startIndex, commands);
+  }
+}
+function updateSegmentGroupChildren(segmentGroup, startIndex, commands) {
+  if (commands.length === 0) {
+    return new UrlSegmentGroup(segmentGroup.segments, {});
+  } else {
+    const outlets = getOutlets(commands);
+    const children = {};
+    if (Object.keys(outlets).some((o) => o !== PRIMARY_OUTLET) && segmentGroup.children[PRIMARY_OUTLET] && segmentGroup.numberOfChildren === 1 && segmentGroup.children[PRIMARY_OUTLET].segments.length === 0) {
+      const childrenOfEmptyChild = updateSegmentGroupChildren(segmentGroup.children[PRIMARY_OUTLET], startIndex, commands);
+      return new UrlSegmentGroup(segmentGroup.segments, childrenOfEmptyChild.children);
+    }
+    Object.entries(outlets).forEach(([outlet, commands2]) => {
+      if (typeof commands2 === "string") {
+        commands2 = [commands2];
+      }
+      if (commands2 !== null) {
+        children[outlet] = updateSegmentGroup(segmentGroup.children[outlet], startIndex, commands2);
+      }
+    });
+    Object.entries(segmentGroup.children).forEach(([childOutlet, child]) => {
+      if (outlets[childOutlet] === void 0) {
+        children[childOutlet] = child;
+      }
+    });
+    return new UrlSegmentGroup(segmentGroup.segments, children);
+  }
+}
+function prefixedWith(segmentGroup, startIndex, commands) {
+  let currentCommandIndex = 0;
+  let currentPathIndex = startIndex;
+  const noMatch2 = {
+    match: false,
+    pathIndex: 0,
+    commandIndex: 0
+  };
+  while (currentPathIndex < segmentGroup.segments.length) {
+    if (currentCommandIndex >= commands.length) return noMatch2;
+    const path = segmentGroup.segments[currentPathIndex];
+    const command = commands[currentCommandIndex];
+    if (isCommandWithOutlets(command)) {
+      break;
+    }
+    const curr = `${command}`;
+    const next = currentCommandIndex < commands.length - 1 ? commands[currentCommandIndex + 1] : null;
+    if (currentPathIndex > 0 && curr === void 0) break;
+    if (curr && next && typeof next === "object" && next.outlets === void 0) {
+      if (!compare(curr, next, path)) return noMatch2;
+      currentCommandIndex += 2;
+    } else {
+      if (!compare(curr, {}, path)) return noMatch2;
+      currentCommandIndex++;
+    }
+    currentPathIndex++;
+  }
+  return {
+    match: true,
+    pathIndex: currentPathIndex,
+    commandIndex: currentCommandIndex
+  };
+}
+function createNewSegmentGroup(segmentGroup, startIndex, commands) {
+  const paths = segmentGroup.segments.slice(0, startIndex);
+  let i = 0;
+  while (i < commands.length) {
+    const command = commands[i];
+    if (isCommandWithOutlets(command)) {
+      const children = createNewSegmentChildren(command.outlets);
+      return new UrlSegmentGroup(paths, children);
+    }
+    if (i === 0 && isMatrixParams(commands[0])) {
+      const p = segmentGroup.segments[startIndex];
+      paths.push(new UrlSegment(p.path, stringify2(commands[0])));
+      i++;
+      continue;
+    }
+    const curr = isCommandWithOutlets(command) ? command.outlets[PRIMARY_OUTLET] : `${command}`;
+    const next = i < commands.length - 1 ? commands[i + 1] : null;
+    if (curr && next && isMatrixParams(next)) {
+      paths.push(new UrlSegment(curr, stringify2(next)));
+      i += 2;
+    } else {
+      paths.push(new UrlSegment(curr, {}));
+      i++;
+    }
+  }
+  return new UrlSegmentGroup(paths, {});
+}
+function createNewSegmentChildren(outlets) {
+  const children = {};
+  Object.entries(outlets).forEach(([outlet, commands]) => {
+    if (typeof commands === "string") {
+      commands = [commands];
+    }
+    if (commands !== null) {
+      children[outlet] = createNewSegmentGroup(new UrlSegmentGroup([], {}), 0, commands);
+    }
+  });
+  return children;
+}
+function stringify2(params) {
+  const res = {};
+  Object.entries(params).forEach(([k, v]) => res[k] = `${v}`);
+  return res;
+}
+function compare(path, params, segment) {
+  return path == segment.path && shallowEqual(params, segment.parameters);
+}
+var IMPERATIVE_NAVIGATION = "imperative";
+var EventType;
+(function(EventType2) {
+  EventType2[EventType2["NavigationStart"] = 0] = "NavigationStart";
+  EventType2[EventType2["NavigationEnd"] = 1] = "NavigationEnd";
+  EventType2[EventType2["NavigationCancel"] = 2] = "NavigationCancel";
+  EventType2[EventType2["NavigationError"] = 3] = "NavigationError";
+  EventType2[EventType2["RoutesRecognized"] = 4] = "RoutesRecognized";
+  EventType2[EventType2["ResolveStart"] = 5] = "ResolveStart";
+  EventType2[EventType2["ResolveEnd"] = 6] = "ResolveEnd";
+  EventType2[EventType2["GuardsCheckStart"] = 7] = "GuardsCheckStart";
+  EventType2[EventType2["GuardsCheckEnd"] = 8] = "GuardsCheckEnd";
+  EventType2[EventType2["RouteConfigLoadStart"] = 9] = "RouteConfigLoadStart";
+  EventType2[EventType2["RouteConfigLoadEnd"] = 10] = "RouteConfigLoadEnd";
+  EventType2[EventType2["ChildActivationStart"] = 11] = "ChildActivationStart";
+  EventType2[EventType2["ChildActivationEnd"] = 12] = "ChildActivationEnd";
+  EventType2[EventType2["ActivationStart"] = 13] = "ActivationStart";
+  EventType2[EventType2["ActivationEnd"] = 14] = "ActivationEnd";
+  EventType2[EventType2["Scroll"] = 15] = "Scroll";
+  EventType2[EventType2["NavigationSkipped"] = 16] = "NavigationSkipped";
+})(EventType || (EventType = {}));
+var RouterEvent = class {
+  id;
+  url;
+  constructor(id, url) {
+    this.id = id;
+    this.url = url;
+  }
+};
+var NavigationStart = class extends RouterEvent {
+  type = EventType.NavigationStart;
+  navigationTrigger;
+  restoredState;
+  constructor(id, url, navigationTrigger = "imperative", restoredState = null) {
+    super(id, url);
+    this.navigationTrigger = navigationTrigger;
+    this.restoredState = restoredState;
+  }
+  toString() {
+    return `NavigationStart(id: ${this.id}, url: '${this.url}')`;
+  }
+};
+var NavigationEnd = class extends RouterEvent {
+  urlAfterRedirects;
+  type = EventType.NavigationEnd;
+  constructor(id, url, urlAfterRedirects) {
+    super(id, url);
+    this.urlAfterRedirects = urlAfterRedirects;
+  }
+  toString() {
+    return `NavigationEnd(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}')`;
+  }
+};
+var NavigationCancellationCode;
+(function(NavigationCancellationCode2) {
+  NavigationCancellationCode2[NavigationCancellationCode2["Redirect"] = 0] = "Redirect";
+  NavigationCancellationCode2[NavigationCancellationCode2["SupersededByNewNavigation"] = 1] = "SupersededByNewNavigation";
+  NavigationCancellationCode2[NavigationCancellationCode2["NoDataFromResolver"] = 2] = "NoDataFromResolver";
+  NavigationCancellationCode2[NavigationCancellationCode2["GuardRejected"] = 3] = "GuardRejected";
+  NavigationCancellationCode2[NavigationCancellationCode2["Aborted"] = 4] = "Aborted";
+})(NavigationCancellationCode || (NavigationCancellationCode = {}));
+var NavigationSkippedCode;
+(function(NavigationSkippedCode2) {
+  NavigationSkippedCode2[NavigationSkippedCode2["IgnoredSameUrlNavigation"] = 0] = "IgnoredSameUrlNavigation";
+  NavigationSkippedCode2[NavigationSkippedCode2["IgnoredByUrlHandlingStrategy"] = 1] = "IgnoredByUrlHandlingStrategy";
+})(NavigationSkippedCode || (NavigationSkippedCode = {}));
+var NavigationCancel = class extends RouterEvent {
+  reason;
+  code;
+  type = EventType.NavigationCancel;
+  constructor(id, url, reason, code) {
+    super(id, url);
+    this.reason = reason;
+    this.code = code;
+  }
+  toString() {
+    return `NavigationCancel(id: ${this.id}, url: '${this.url}')`;
+  }
+};
+function isRedirectingEvent(event) {
+  return event instanceof NavigationCancel && (event.code === NavigationCancellationCode.Redirect || event.code === NavigationCancellationCode.SupersededByNewNavigation);
+}
+var NavigationSkipped = class extends RouterEvent {
+  reason;
+  code;
+  type = EventType.NavigationSkipped;
+  constructor(id, url, reason, code) {
+    super(id, url);
+    this.reason = reason;
+    this.code = code;
+  }
+};
+var NavigationError = class extends RouterEvent {
+  error;
+  target;
+  type = EventType.NavigationError;
+  constructor(id, url, error, target) {
+    super(id, url);
+    this.error = error;
+    this.target = target;
+  }
+  toString() {
+    return `NavigationError(id: ${this.id}, url: '${this.url}', error: ${this.error})`;
+  }
+};
+var RoutesRecognized = class extends RouterEvent {
+  urlAfterRedirects;
+  state;
+  type = EventType.RoutesRecognized;
+  constructor(id, url, urlAfterRedirects, state) {
+    super(id, url);
+    this.urlAfterRedirects = urlAfterRedirects;
+    this.state = state;
+  }
+  toString() {
+    return `RoutesRecognized(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state})`;
+  }
+};
+var GuardsCheckStart = class extends RouterEvent {
+  urlAfterRedirects;
+  state;
+  type = EventType.GuardsCheckStart;
+  constructor(id, url, urlAfterRedirects, state) {
+    super(id, url);
+    this.urlAfterRedirects = urlAfterRedirects;
+    this.state = state;
+  }
+  toString() {
+    return `GuardsCheckStart(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state})`;
+  }
+};
+var GuardsCheckEnd = class extends RouterEvent {
+  urlAfterRedirects;
+  state;
+  shouldActivate;
+  type = EventType.GuardsCheckEnd;
+  constructor(id, url, urlAfterRedirects, state, shouldActivate) {
+    super(id, url);
+    this.urlAfterRedirects = urlAfterRedirects;
+    this.state = state;
+    this.shouldActivate = shouldActivate;
+  }
+  toString() {
+    return `GuardsCheckEnd(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state}, shouldActivate: ${this.shouldActivate})`;
+  }
+};
+var ResolveStart = class extends RouterEvent {
+  urlAfterRedirects;
+  state;
+  type = EventType.ResolveStart;
+  constructor(id, url, urlAfterRedirects, state) {
+    super(id, url);
+    this.urlAfterRedirects = urlAfterRedirects;
+    this.state = state;
+  }
+  toString() {
+    return `ResolveStart(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state})`;
+  }
+};
+var ResolveEnd = class extends RouterEvent {
+  urlAfterRedirects;
+  state;
+  type = EventType.ResolveEnd;
+  constructor(id, url, urlAfterRedirects, state) {
+    super(id, url);
+    this.urlAfterRedirects = urlAfterRedirects;
+    this.state = state;
+  }
+  toString() {
+    return `ResolveEnd(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state})`;
+  }
+};
+var RouteConfigLoadStart = class {
+  route;
+  type = EventType.RouteConfigLoadStart;
+  constructor(route) {
+    this.route = route;
+  }
+  toString() {
+    return `RouteConfigLoadStart(path: ${this.route.path})`;
+  }
+};
+var RouteConfigLoadEnd = class {
+  route;
+  type = EventType.RouteConfigLoadEnd;
+  constructor(route) {
+    this.route = route;
+  }
+  toString() {
+    return `RouteConfigLoadEnd(path: ${this.route.path})`;
+  }
+};
+var ChildActivationStart = class {
+  snapshot;
+  type = EventType.ChildActivationStart;
+  constructor(snapshot) {
+    this.snapshot = snapshot;
+  }
+  toString() {
+    const path = this.snapshot.routeConfig && this.snapshot.routeConfig.path || "";
+    return `ChildActivationStart(path: '${path}')`;
+  }
+};
+var ChildActivationEnd = class {
+  snapshot;
+  type = EventType.ChildActivationEnd;
+  constructor(snapshot) {
+    this.snapshot = snapshot;
+  }
+  toString() {
+    const path = this.snapshot.routeConfig && this.snapshot.routeConfig.path || "";
+    return `ChildActivationEnd(path: '${path}')`;
+  }
+};
+var ActivationStart = class {
+  snapshot;
+  type = EventType.ActivationStart;
+  constructor(snapshot) {
+    this.snapshot = snapshot;
+  }
+  toString() {
+    const path = this.snapshot.routeConfig && this.snapshot.routeConfig.path || "";
+    return `ActivationStart(path: '${path}')`;
+  }
+};
+var ActivationEnd = class {
+  snapshot;
+  type = EventType.ActivationEnd;
+  constructor(snapshot) {
+    this.snapshot = snapshot;
+  }
+  toString() {
+    const path = this.snapshot.routeConfig && this.snapshot.routeConfig.path || "";
+    return `ActivationEnd(path: '${path}')`;
+  }
+};
+var Scroll = class {
+  routerEvent;
+  position;
+  anchor;
+  scrollBehavior;
+  type = EventType.Scroll;
+  constructor(routerEvent, position, anchor, scrollBehavior) {
+    this.routerEvent = routerEvent;
+    this.position = position;
+    this.anchor = anchor;
+    this.scrollBehavior = scrollBehavior;
+  }
+  toString() {
+    const pos = this.position ? `${this.position[0]}, ${this.position[1]}` : null;
+    return `Scroll(anchor: '${this.anchor}', position: '${pos}')`;
+  }
+};
+var BeforeActivateRoutes = class {
+};
+var BeforeRoutesRecognized = class {
+};
+var RedirectRequest = class {
+  url;
+  navigationBehaviorOptions;
+  constructor(url, navigationBehaviorOptions) {
+    this.url = url;
+    this.navigationBehaviorOptions = navigationBehaviorOptions;
+  }
+};
+function isPublicRouterEvent(e) {
+  return !(e instanceof BeforeActivateRoutes) && !(e instanceof RedirectRequest) && !(e instanceof BeforeRoutesRecognized);
+}
+function stringifyEvent(routerEvent) {
+  switch (routerEvent.type) {
+    case EventType.ActivationEnd:
+      return `ActivationEnd(path: '${routerEvent.snapshot.routeConfig?.path || ""}')`;
+    case EventType.ActivationStart:
+      return `ActivationStart(path: '${routerEvent.snapshot.routeConfig?.path || ""}')`;
+    case EventType.ChildActivationEnd:
+      return `ChildActivationEnd(path: '${routerEvent.snapshot.routeConfig?.path || ""}')`;
+    case EventType.ChildActivationStart:
+      return `ChildActivationStart(path: '${routerEvent.snapshot.routeConfig?.path || ""}')`;
+    case EventType.GuardsCheckEnd:
+      return `GuardsCheckEnd(id: ${routerEvent.id}, url: '${routerEvent.url}', urlAfterRedirects: '${routerEvent.urlAfterRedirects}', state: ${routerEvent.state}, shouldActivate: ${routerEvent.shouldActivate})`;
+    case EventType.GuardsCheckStart:
+      return `GuardsCheckStart(id: ${routerEvent.id}, url: '${routerEvent.url}', urlAfterRedirects: '${routerEvent.urlAfterRedirects}', state: ${routerEvent.state})`;
+    case EventType.NavigationCancel:
+      return `NavigationCancel(id: ${routerEvent.id}, url: '${routerEvent.url}')`;
+    case EventType.NavigationSkipped:
+      return `NavigationSkipped(id: ${routerEvent.id}, url: '${routerEvent.url}')`;
+    case EventType.NavigationEnd:
+      return `NavigationEnd(id: ${routerEvent.id}, url: '${routerEvent.url}', urlAfterRedirects: '${routerEvent.urlAfterRedirects}')`;
+    case EventType.NavigationError:
+      return `NavigationError(id: ${routerEvent.id}, url: '${routerEvent.url}', error: ${routerEvent.error})`;
+    case EventType.NavigationStart:
+      return `NavigationStart(id: ${routerEvent.id}, url: '${routerEvent.url}')`;
+    case EventType.ResolveEnd:
+      return `ResolveEnd(id: ${routerEvent.id}, url: '${routerEvent.url}', urlAfterRedirects: '${routerEvent.urlAfterRedirects}', state: ${routerEvent.state})`;
+    case EventType.ResolveStart:
+      return `ResolveStart(id: ${routerEvent.id}, url: '${routerEvent.url}', urlAfterRedirects: '${routerEvent.urlAfterRedirects}', state: ${routerEvent.state})`;
+    case EventType.RouteConfigLoadEnd:
+      return `RouteConfigLoadEnd(path: ${routerEvent.route.path})`;
+    case EventType.RouteConfigLoadStart:
+      return `RouteConfigLoadStart(path: ${routerEvent.route.path})`;
+    case EventType.RoutesRecognized:
+      return `RoutesRecognized(id: ${routerEvent.id}, url: '${routerEvent.url}', urlAfterRedirects: '${routerEvent.urlAfterRedirects}', state: ${routerEvent.state})`;
+    case EventType.Scroll:
+      const pos = routerEvent.position ? `${routerEvent.position[0]}, ${routerEvent.position[1]}` : null;
+      return `Scroll(anchor: '${routerEvent.anchor}', position: '${pos}')`;
+  }
+}
+var OutletContext = class {
+  rootInjector;
+  outlet = null;
+  route = null;
+  children;
+  attachRef = null;
+  get injector() {
+    return this.route?.snapshot._environmentInjector ?? this.rootInjector;
+  }
+  constructor(rootInjector) {
+    this.rootInjector = rootInjector;
+    this.children = new ChildrenOutletContexts(this.rootInjector);
+  }
+};
+var ChildrenOutletContexts = class _ChildrenOutletContexts {
+  rootInjector;
+  contexts = /* @__PURE__ */ new Map();
+  constructor(rootInjector) {
+    this.rootInjector = rootInjector;
+  }
+  onChildOutletCreated(childName, outlet) {
+    const context2 = this.getOrCreateContext(childName);
+    context2.outlet = outlet;
+    this.contexts.set(childName, context2);
+  }
+  onChildOutletDestroyed(childName) {
+    const context2 = this.getContext(childName);
+    if (context2) {
+      context2.outlet = null;
+      context2.attachRef = null;
+    }
+  }
+  onOutletDeactivated() {
+    const contexts = this.contexts;
+    this.contexts = /* @__PURE__ */ new Map();
+    return contexts;
+  }
+  onOutletReAttached(contexts) {
+    this.contexts = contexts;
+  }
+  getOrCreateContext(childName) {
+    let context2 = this.getContext(childName);
+    if (!context2) {
+      context2 = new OutletContext(this.rootInjector);
+      this.contexts.set(childName, context2);
+    }
+    return context2;
+  }
+  getContext(childName) {
+    return this.contexts.get(childName) || null;
+  }
+  static \u0275fac = function ChildrenOutletContexts_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _ChildrenOutletContexts)(\u0275\u0275inject(EnvironmentInjector));
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _ChildrenOutletContexts,
+    factory: _ChildrenOutletContexts.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ChildrenOutletContexts, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], () => [{
+    type: EnvironmentInjector
+  }], null);
+})();
+var Tree = class {
+  _root;
+  constructor(root) {
+    this._root = root;
+  }
+  get root() {
+    return this._root.value;
+  }
+  parent(t) {
+    const p = this.pathFromRoot(t);
+    return p.length > 1 ? p[p.length - 2] : null;
+  }
+  children(t) {
+    const n = findNode(t, this._root);
+    return n ? n.children.map((t2) => t2.value) : [];
+  }
+  firstChild(t) {
+    const n = findNode(t, this._root);
+    return n && n.children.length > 0 ? n.children[0].value : null;
+  }
+  siblings(t) {
+    const p = findPath(t, this._root);
+    if (p.length < 2) return [];
+    const c = p[p.length - 2].children.map((c2) => c2.value);
+    return c.filter((cc) => cc !== t);
+  }
+  pathFromRoot(t) {
+    return findPath(t, this._root).map((s) => s.value);
+  }
+};
+function findNode(value, node) {
+  if (value === node.value) return node;
+  for (const child of node.children) {
+    const node2 = findNode(value, child);
+    if (node2) return node2;
+  }
+  return null;
+}
+function findPath(value, node) {
+  if (value === node.value) return [node];
+  for (const child of node.children) {
+    const path = findPath(value, child);
+    if (path.length) {
+      path.unshift(node);
+      return path;
+    }
+  }
+  return [];
+}
+var TreeNode = class {
+  value;
+  children;
+  constructor(value, children) {
+    this.value = value;
+    this.children = children;
+  }
+  toString() {
+    return `TreeNode(${this.value})`;
+  }
+};
+function nodeChildrenAsMap(node) {
+  const map2 = {};
+  if (node) {
+    node.children.forEach((child) => map2[child.value.outlet] = child);
+  }
+  return map2;
+}
+var RouterState = class extends Tree {
+  snapshot;
+  constructor(root, snapshot) {
+    super(root);
+    this.snapshot = snapshot;
+    setRouterState(this, root);
+  }
+  toString() {
+    return this.snapshot.toString();
+  }
+};
+function createEmptyState(rootComponent, injector) {
+  const snapshot = createEmptyStateSnapshot(rootComponent, injector);
+  const emptyUrl = new BehaviorSubject([new UrlSegment("", {})]);
+  const emptyParams = new BehaviorSubject({});
+  const emptyData = new BehaviorSubject({});
+  const emptyQueryParams = new BehaviorSubject({});
+  const fragment = new BehaviorSubject("");
+  const activated = new ActivatedRoute(emptyUrl, emptyParams, emptyQueryParams, fragment, emptyData, PRIMARY_OUTLET, rootComponent, snapshot.root);
+  activated.snapshot = snapshot.root;
+  return new RouterState(new TreeNode(activated, []), snapshot);
+}
+function createEmptyStateSnapshot(rootComponent, injector) {
+  const emptyParams = {};
+  const emptyData = {};
+  const emptyQueryParams = {};
+  const fragment = "";
+  const activated = new ActivatedRouteSnapshot([], emptyParams, emptyQueryParams, fragment, emptyData, PRIMARY_OUTLET, rootComponent, null, {}, injector);
+  return new RouterStateSnapshot("", new TreeNode(activated, []));
+}
+var ActivatedRoute = class {
+  urlSubject;
+  paramsSubject;
+  queryParamsSubject;
+  fragmentSubject;
+  dataSubject;
+  outlet;
+  component;
+  snapshot;
+  _futureSnapshot;
+  _routerState;
+  _paramMap;
+  _queryParamMap;
+  title;
+  url;
+  params;
+  queryParams;
+  fragment;
+  data;
+  constructor(urlSubject, paramsSubject, queryParamsSubject, fragmentSubject, dataSubject, outlet, component, futureSnapshot) {
+    this.urlSubject = urlSubject;
+    this.paramsSubject = paramsSubject;
+    this.queryParamsSubject = queryParamsSubject;
+    this.fragmentSubject = fragmentSubject;
+    this.dataSubject = dataSubject;
+    this.outlet = outlet;
+    this.component = component;
+    this._futureSnapshot = futureSnapshot;
+    this.title = this.dataSubject?.pipe(map((d) => d[RouteTitleKey])) ?? of(void 0);
+    this.url = urlSubject;
+    this.params = paramsSubject;
+    this.queryParams = queryParamsSubject;
+    this.fragment = fragmentSubject;
+    this.data = dataSubject;
+  }
+  get routeConfig() {
+    return this._futureSnapshot.routeConfig;
+  }
+  get root() {
+    return this._routerState.root;
+  }
+  get parent() {
+    return this._routerState.parent(this);
+  }
+  get firstChild() {
+    return this._routerState.firstChild(this);
+  }
+  get children() {
+    return this._routerState.children(this);
+  }
+  get pathFromRoot() {
+    return this._routerState.pathFromRoot(this);
+  }
+  get paramMap() {
+    this._paramMap ??= this.params.pipe(map((p) => convertToParamMap(p)));
+    return this._paramMap;
+  }
+  get queryParamMap() {
+    this._queryParamMap ??= this.queryParams.pipe(map((p) => convertToParamMap(p)));
+    return this._queryParamMap;
+  }
+  toString() {
+    return this.snapshot ? this.snapshot.toString() : `Future(${this._futureSnapshot})`;
+  }
+};
+function getInherited(route, parent, paramsInheritanceStrategy = "emptyOnly") {
+  let inherited;
+  const {
+    routeConfig
+  } = route;
+  if (parent !== null && (paramsInheritanceStrategy === "always" || routeConfig?.path === "" || !parent.component && !parent.routeConfig?.loadComponent)) {
+    inherited = {
+      params: __spreadValues(__spreadValues({}, parent.params), route.params),
+      data: __spreadValues(__spreadValues({}, parent.data), route.data),
+      resolve: __spreadValues(__spreadValues(__spreadValues(__spreadValues({}, route.data), parent.data), routeConfig?.data), route._resolvedData)
+    };
+  } else {
+    inherited = {
+      params: __spreadValues({}, route.params),
+      data: __spreadValues({}, route.data),
+      resolve: __spreadValues(__spreadValues({}, route.data), route._resolvedData ?? {})
+    };
+  }
+  if (routeConfig && hasStaticTitle(routeConfig)) {
+    inherited.resolve[RouteTitleKey] = routeConfig.title;
+  }
+  return inherited;
+}
+var ActivatedRouteSnapshot = class {
+  url;
+  params;
+  queryParams;
+  fragment;
+  data;
+  outlet;
+  component;
+  routeConfig;
+  _resolve;
+  _resolvedData;
+  _routerState;
+  _paramMap;
+  _queryParamMap;
+  _environmentInjector;
+  get title() {
+    return this.data?.[RouteTitleKey];
+  }
+  constructor(url, params, queryParams, fragment, data, outlet, component, routeConfig, resolve, environmentInjector) {
+    this.url = url;
+    this.params = params;
+    this.queryParams = queryParams;
+    this.fragment = fragment;
+    this.data = data;
+    this.outlet = outlet;
+    this.component = component;
+    this.routeConfig = routeConfig;
+    this._resolve = resolve;
+    this._environmentInjector = environmentInjector;
+  }
+  get root() {
+    return this._routerState.root;
+  }
+  get parent() {
+    return this._routerState.parent(this);
+  }
+  get firstChild() {
+    return this._routerState.firstChild(this);
+  }
+  get children() {
+    return this._routerState.children(this);
+  }
+  get pathFromRoot() {
+    return this._routerState.pathFromRoot(this);
+  }
+  get paramMap() {
+    this._paramMap ??= convertToParamMap(this.params);
+    return this._paramMap;
+  }
+  get queryParamMap() {
+    this._queryParamMap ??= convertToParamMap(this.queryParams);
+    return this._queryParamMap;
+  }
+  toString() {
+    const url = this.url.map((segment) => segment.toString()).join("/");
+    const matched = this.routeConfig ? this.routeConfig.path : "";
+    return `Route(url:'${url}', path:'${matched}')`;
+  }
+};
+var RouterStateSnapshot = class extends Tree {
+  url;
+  constructor(url, root) {
+    super(root);
+    this.url = url;
+    setRouterState(this, root);
+  }
+  toString() {
+    return serializeNode(this._root);
+  }
+};
+function setRouterState(state, node) {
+  node.value._routerState = state;
+  node.children.forEach((c) => setRouterState(state, c));
+}
+function serializeNode(node) {
+  const c = node.children.length > 0 ? ` { ${node.children.map(serializeNode).join(", ")} } ` : "";
+  return `${node.value}${c}`;
+}
+function advanceActivatedRoute(route) {
+  if (route.snapshot) {
+    const currentSnapshot = route.snapshot;
+    const nextSnapshot = route._futureSnapshot;
+    route.snapshot = nextSnapshot;
+    if (!shallowEqual(currentSnapshot.queryParams, nextSnapshot.queryParams)) {
+      route.queryParamsSubject.next(nextSnapshot.queryParams);
+    }
+    if (currentSnapshot.fragment !== nextSnapshot.fragment) {
+      route.fragmentSubject.next(nextSnapshot.fragment);
+    }
+    if (!shallowEqual(currentSnapshot.params, nextSnapshot.params)) {
+      route.paramsSubject.next(nextSnapshot.params);
+    }
+    if (!shallowEqualArrays(currentSnapshot.url, nextSnapshot.url)) {
+      route.urlSubject.next(nextSnapshot.url);
+    }
+    if (!shallowEqual(currentSnapshot.data, nextSnapshot.data)) {
+      route.dataSubject.next(nextSnapshot.data);
+    }
+  } else {
+    route.snapshot = route._futureSnapshot;
+    route.dataSubject.next(route._futureSnapshot.data);
+  }
+}
+function equalParamsAndUrlSegments(a, b) {
+  const equalUrlParams = shallowEqual(a.params, b.params) && equalSegments(a.url, b.url);
+  const parentsMismatch = !a.parent !== !b.parent;
+  return equalUrlParams && !parentsMismatch && (!a.parent || equalParamsAndUrlSegments(a.parent, b.parent));
+}
+function hasStaticTitle(config2) {
+  return typeof config2.title === "string" || config2.title === null;
+}
+var ROUTER_OUTLET_DATA = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "RouterOutlet data" : "");
+var RouterOutlet = class _RouterOutlet {
+  activated = null;
+  get activatedComponentRef() {
+    return this.activated;
+  }
+  _activatedRoute = null;
+  name = PRIMARY_OUTLET;
+  activateEvents = new EventEmitter();
+  deactivateEvents = new EventEmitter();
+  attachEvents = new EventEmitter();
+  detachEvents = new EventEmitter();
+  routerOutletData = input(...ngDevMode ? [void 0, {
+    debugName: "routerOutletData"
+  }] : []);
+  parentContexts = inject2(ChildrenOutletContexts);
+  location = inject2(ViewContainerRef);
+  changeDetector = inject2(ChangeDetectorRef);
+  inputBinder = inject2(INPUT_BINDER, {
+    optional: true
+  });
+  supportsBindingToComponentInputs = true;
+  ngOnChanges(changes) {
+    if (changes["name"]) {
+      const {
+        firstChange,
+        previousValue
+      } = changes["name"];
+      if (firstChange) {
+        return;
+      }
+      if (this.isTrackedInParentContexts(previousValue)) {
+        this.deactivate();
+        this.parentContexts.onChildOutletDestroyed(previousValue);
+      }
+      this.initializeOutletWithName();
+    }
+  }
+  ngOnDestroy() {
+    if (this.isTrackedInParentContexts(this.name)) {
+      this.parentContexts.onChildOutletDestroyed(this.name);
+    }
+    this.inputBinder?.unsubscribeFromRouteData(this);
+  }
+  isTrackedInParentContexts(outletName) {
+    return this.parentContexts.getContext(outletName)?.outlet === this;
+  }
+  ngOnInit() {
+    this.initializeOutletWithName();
+  }
+  initializeOutletWithName() {
+    this.parentContexts.onChildOutletCreated(this.name, this);
+    if (this.activated) {
+      return;
+    }
+    const context2 = this.parentContexts.getContext(this.name);
+    if (context2?.route) {
+      if (context2.attachRef) {
+        this.attach(context2.attachRef, context2.route);
+      } else {
+        this.activateWith(context2.route, context2.injector);
+      }
+    }
+  }
+  get isActivated() {
+    return !!this.activated;
+  }
+  get component() {
+    if (!this.activated) throw new RuntimeError(4012, (typeof ngDevMode === "undefined" || ngDevMode) && "Outlet is not activated");
+    return this.activated.instance;
+  }
+  get activatedRoute() {
+    if (!this.activated) throw new RuntimeError(4012, (typeof ngDevMode === "undefined" || ngDevMode) && "Outlet is not activated");
+    return this._activatedRoute;
+  }
+  get activatedRouteData() {
+    if (this._activatedRoute) {
+      return this._activatedRoute.snapshot.data;
+    }
+    return {};
+  }
+  detach() {
+    if (!this.activated) throw new RuntimeError(4012, (typeof ngDevMode === "undefined" || ngDevMode) && "Outlet is not activated");
+    this.location.detach();
+    const cmp = this.activated;
+    this.activated = null;
+    this._activatedRoute = null;
+    this.detachEvents.emit(cmp.instance);
+    return cmp;
+  }
+  attach(ref, activatedRoute) {
+    this.activated = ref;
+    this._activatedRoute = activatedRoute;
+    this.location.insert(ref.hostView);
+    this.inputBinder?.bindActivatedRouteToOutletComponent(this);
+    this.attachEvents.emit(ref.instance);
+  }
+  deactivate() {
+    if (this.activated) {
+      const c = this.component;
+      this.activated.destroy();
+      this.activated = null;
+      this._activatedRoute = null;
+      this.deactivateEvents.emit(c);
+    }
+  }
+  activateWith(activatedRoute, environmentInjector) {
+    if (this.isActivated) {
+      throw new RuntimeError(4013, (typeof ngDevMode === "undefined" || ngDevMode) && "Cannot activate an already activated outlet");
+    }
+    this._activatedRoute = activatedRoute;
+    const location2 = this.location;
+    const snapshot = activatedRoute.snapshot;
+    const component = snapshot.component;
+    const childContexts = this.parentContexts.getOrCreateContext(this.name).children;
+    const injector = new OutletInjector(activatedRoute, childContexts, location2.injector, this.routerOutletData);
+    this.activated = location2.createComponent(component, {
+      index: location2.length,
+      injector,
+      environmentInjector
+    });
+    this.changeDetector.markForCheck();
+    this.inputBinder?.bindActivatedRouteToOutletComponent(this);
+    this.activateEvents.emit(this.activated.instance);
+  }
+  static \u0275fac = function RouterOutlet_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _RouterOutlet)();
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _RouterOutlet,
+    selectors: [["router-outlet"]],
+    inputs: {
+      name: "name",
+      routerOutletData: [1, "routerOutletData"]
+    },
+    outputs: {
+      activateEvents: "activate",
+      deactivateEvents: "deactivate",
+      attachEvents: "attach",
+      detachEvents: "detach"
+    },
+    exportAs: ["outlet"],
+    features: [\u0275\u0275NgOnChangesFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(RouterOutlet, [{
+    type: Directive,
+    args: [{
+      selector: "router-outlet",
+      exportAs: "outlet"
+    }]
+  }], null, {
+    name: [{
+      type: Input
+    }],
+    activateEvents: [{
+      type: Output,
+      args: ["activate"]
+    }],
+    deactivateEvents: [{
+      type: Output,
+      args: ["deactivate"]
+    }],
+    attachEvents: [{
+      type: Output,
+      args: ["attach"]
+    }],
+    detachEvents: [{
+      type: Output,
+      args: ["detach"]
+    }],
+    routerOutletData: [{
+      type: Input,
+      args: [{
+        isSignal: true,
+        alias: "routerOutletData",
+        required: false
+      }]
+    }]
+  });
+})();
+var OutletInjector = class {
+  route;
+  childContexts;
+  parent;
+  outletData;
+  constructor(route, childContexts, parent, outletData) {
+    this.route = route;
+    this.childContexts = childContexts;
+    this.parent = parent;
+    this.outletData = outletData;
+  }
+  get(token, notFoundValue) {
+    if (token === ActivatedRoute) {
+      return this.route;
+    }
+    if (token === ChildrenOutletContexts) {
+      return this.childContexts;
+    }
+    if (token === ROUTER_OUTLET_DATA) {
+      return this.outletData;
+    }
+    return this.parent.get(token, notFoundValue);
+  }
+};
+var INPUT_BINDER = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "Router Input Binder" : "");
+var RoutedComponentInputBinder = class _RoutedComponentInputBinder {
+  outletDataSubscriptions = /* @__PURE__ */ new Map();
+  bindActivatedRouteToOutletComponent(outlet) {
+    this.unsubscribeFromRouteData(outlet);
+    this.subscribeToRouteData(outlet);
+  }
+  unsubscribeFromRouteData(outlet) {
+    this.outletDataSubscriptions.get(outlet)?.unsubscribe();
+    this.outletDataSubscriptions.delete(outlet);
+  }
+  subscribeToRouteData(outlet) {
+    const {
+      activatedRoute
+    } = outlet;
+    const dataSubscription = combineLatest([activatedRoute.queryParams, activatedRoute.params, activatedRoute.data]).pipe(switchMap(([queryParams, params, data], index) => {
+      data = __spreadValues(__spreadValues(__spreadValues({}, queryParams), params), data);
+      if (index === 0) {
+        return of(data);
+      }
+      return Promise.resolve(data);
+    })).subscribe((data) => {
+      if (!outlet.isActivated || !outlet.activatedComponentRef || outlet.activatedRoute !== activatedRoute || activatedRoute.component === null) {
+        this.unsubscribeFromRouteData(outlet);
+        return;
+      }
+      const mirror = reflectComponentType(activatedRoute.component);
+      if (!mirror) {
+        this.unsubscribeFromRouteData(outlet);
+        return;
+      }
+      for (const {
+        templateName
+      } of mirror.inputs) {
+        outlet.activatedComponentRef.setInput(templateName, data[templateName]);
+      }
+    });
+    this.outletDataSubscriptions.set(outlet, dataSubscription);
+  }
+  static \u0275fac = function RoutedComponentInputBinder_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _RoutedComponentInputBinder)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _RoutedComponentInputBinder,
+    factory: _RoutedComponentInputBinder.\u0275fac
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(RoutedComponentInputBinder, [{
+    type: Injectable
+  }], null, null);
+})();
+var \u0275EmptyOutletComponent = class _\u0275EmptyOutletComponent {
+  static \u0275fac = function \u0275EmptyOutletComponent_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _\u0275EmptyOutletComponent)();
+  };
+  static \u0275cmp = /* @__PURE__ */ \u0275\u0275defineComponent({
+    type: _\u0275EmptyOutletComponent,
+    selectors: [["ng-component"]],
+    exportAs: ["emptyRouterOutlet"],
+    decls: 1,
+    vars: 0,
+    template: function _EmptyOutletComponent_Template(rf, ctx) {
+      if (rf & 1) {
+        \u0275\u0275element(0, "router-outlet");
+      }
+    },
+    dependencies: [RouterOutlet],
+    encapsulation: 2
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(\u0275EmptyOutletComponent, [{
+    type: Component,
+    args: [{
+      template: `<router-outlet />`,
+      imports: [RouterOutlet],
+      exportAs: "emptyRouterOutlet",
+      changeDetection: ChangeDetectionStrategy.Eager
+    }]
+  }], null, null);
+})();
+function standardizeConfig(r) {
+  const children = r.children && r.children.map(standardizeConfig);
+  const c = children ? __spreadProps(__spreadValues({}, r), {
+    children
+  }) : __spreadValues({}, r);
+  if (!c.component && !c.loadComponent && (children || c.loadChildren) && c.outlet && c.outlet !== PRIMARY_OUTLET) {
+    c.component = \u0275EmptyOutletComponent;
+  }
+  return c;
+}
+function createRouterState(routeReuseStrategy, curr, prevState) {
+  const root = createNode(routeReuseStrategy, curr._root, prevState ? prevState._root : void 0);
+  return new RouterState(root, curr);
+}
+function createNode(routeReuseStrategy, curr, prevState) {
+  if (prevState && routeReuseStrategy.shouldReuseRoute(curr.value, prevState.value.snapshot)) {
+    const value = prevState.value;
+    value._futureSnapshot = curr.value;
+    const children = createOrReuseChildren(routeReuseStrategy, curr, prevState);
+    return new TreeNode(value, children);
+  } else {
+    if (routeReuseStrategy.shouldAttach(curr.value)) {
+      const detachedRouteHandle = routeReuseStrategy.retrieve(curr.value);
+      if (detachedRouteHandle !== null) {
+        const tree2 = detachedRouteHandle.route;
+        tree2.value._futureSnapshot = curr.value;
+        tree2.children = curr.children.map((c) => createNode(routeReuseStrategy, c));
+        return tree2;
+      }
+    }
+    const value = createActivatedRoute(curr.value);
+    const children = curr.children.map((c) => createNode(routeReuseStrategy, c));
+    return new TreeNode(value, children);
+  }
+}
+function createOrReuseChildren(routeReuseStrategy, curr, prevState) {
+  return curr.children.map((child) => {
+    for (const p of prevState.children) {
+      if (routeReuseStrategy.shouldReuseRoute(child.value, p.value.snapshot)) {
+        return createNode(routeReuseStrategy, child, p);
+      }
+    }
+    return createNode(routeReuseStrategy, child);
+  });
+}
+function createActivatedRoute(c) {
+  return new ActivatedRoute(new BehaviorSubject(c.url), new BehaviorSubject(c.params), new BehaviorSubject(c.queryParams), new BehaviorSubject(c.fragment), new BehaviorSubject(c.data), c.outlet, c.component, c);
+}
+var RedirectCommand = class {
+  redirectTo;
+  navigationBehaviorOptions;
+  constructor(redirectTo, navigationBehaviorOptions) {
+    this.redirectTo = redirectTo;
+    this.navigationBehaviorOptions = navigationBehaviorOptions;
+  }
+};
+var NAVIGATION_CANCELING_ERROR = "ngNavigationCancelingError";
+function redirectingNavigationError(urlSerializer, redirect) {
+  const {
+    redirectTo,
+    navigationBehaviorOptions
+  } = isUrlTree(redirect) ? {
+    redirectTo: redirect,
+    navigationBehaviorOptions: void 0
+  } : redirect;
+  const error = navigationCancelingError(ngDevMode && `Redirecting to "${urlSerializer.serialize(redirectTo)}"`, NavigationCancellationCode.Redirect);
+  error.url = redirectTo;
+  error.navigationBehaviorOptions = navigationBehaviorOptions;
+  return error;
+}
+function navigationCancelingError(message, code) {
+  const error = new Error(`NavigationCancelingError: ${message || ""}`);
+  error[NAVIGATION_CANCELING_ERROR] = true;
+  error.cancellationCode = code;
+  return error;
+}
+function isRedirectingNavigationCancelingError(error) {
+  return isNavigationCancelingError(error) && isUrlTree(error.url);
+}
+function isNavigationCancelingError(error) {
+  return !!error && error[NAVIGATION_CANCELING_ERROR];
+}
+var warnedAboutUnsupportedInputBinding = false;
+var ActivateRoutes = class {
+  routeReuseStrategy;
+  futureState;
+  currState;
+  forwardEvent;
+  inputBindingEnabled;
+  constructor(routeReuseStrategy, futureState, currState, forwardEvent, inputBindingEnabled) {
+    this.routeReuseStrategy = routeReuseStrategy;
+    this.futureState = futureState;
+    this.currState = currState;
+    this.forwardEvent = forwardEvent;
+    this.inputBindingEnabled = inputBindingEnabled;
+  }
+  activate(parentContexts) {
+    const futureRoot = this.futureState._root;
+    const currRoot = this.currState ? this.currState._root : null;
+    this.deactivateChildRoutes(futureRoot, currRoot, parentContexts);
+    advanceActivatedRoute(this.futureState.root);
+    this.activateChildRoutes(futureRoot, currRoot, parentContexts);
+  }
+  deactivateChildRoutes(futureNode, currNode, contexts) {
+    const children = nodeChildrenAsMap(currNode);
+    futureNode.children.forEach((futureChild) => {
+      const childOutletName = futureChild.value.outlet;
+      this.deactivateRoutes(futureChild, children[childOutletName], contexts);
+      delete children[childOutletName];
+    });
+    Object.values(children).forEach((v) => {
+      this.deactivateRouteAndItsChildren(v, contexts);
+    });
+  }
+  deactivateRoutes(futureNode, currNode, parentContext) {
+    const future = futureNode.value;
+    const curr = currNode ? currNode.value : null;
+    if (future === curr) {
+      if (future.component) {
+        const context2 = parentContext.getContext(future.outlet);
+        if (context2) {
+          this.deactivateChildRoutes(futureNode, currNode, context2.children);
+        }
+      } else {
+        this.deactivateChildRoutes(futureNode, currNode, parentContext);
+      }
+    } else {
+      if (curr) {
+        this.deactivateRouteAndItsChildren(currNode, parentContext);
+      }
+    }
+  }
+  deactivateRouteAndItsChildren(route, parentContexts) {
+    if (route.value.component && this.routeReuseStrategy.shouldDetach(route.value.snapshot)) {
+      this.detachAndStoreRouteSubtree(route, parentContexts);
+    } else {
+      this.deactivateRouteAndOutlet(route, parentContexts);
+    }
+  }
+  detachAndStoreRouteSubtree(route, parentContexts) {
+    const context2 = parentContexts.getContext(route.value.outlet);
+    const contexts = context2 && route.value.component ? context2.children : parentContexts;
+    const children = nodeChildrenAsMap(route);
+    for (const treeNode of Object.values(children)) {
+      this.deactivateRouteAndItsChildren(treeNode, contexts);
+    }
+    if (context2 && context2.outlet) {
+      const componentRef = context2.outlet.detach();
+      const contexts2 = context2.children.onOutletDeactivated();
+      this.routeReuseStrategy.store(route.value.snapshot, {
+        componentRef,
+        route,
+        contexts: contexts2
+      });
+    }
+  }
+  deactivateRouteAndOutlet(route, parentContexts) {
+    const context2 = parentContexts.getContext(route.value.outlet);
+    const contexts = context2 && route.value.component ? context2.children : parentContexts;
+    const children = nodeChildrenAsMap(route);
+    for (const treeNode of Object.values(children)) {
+      this.deactivateRouteAndItsChildren(treeNode, contexts);
+    }
+    if (context2) {
+      if (context2.outlet) {
+        context2.outlet.deactivate();
+        context2.children.onOutletDeactivated();
+      }
+      context2.attachRef = null;
+      context2.route = null;
+    }
+  }
+  activateChildRoutes(futureNode, currNode, contexts) {
+    const children = nodeChildrenAsMap(currNode);
+    futureNode.children.forEach((c) => {
+      this.activateRoutes(c, children[c.value.outlet], contexts);
+      this.forwardEvent(new ActivationEnd(c.value.snapshot));
+    });
+    if (futureNode.children.length) {
+      this.forwardEvent(new ChildActivationEnd(futureNode.value.snapshot));
+    }
+  }
+  activateRoutes(futureNode, currNode, parentContexts) {
+    const future = futureNode.value;
+    const curr = currNode ? currNode.value : null;
+    advanceActivatedRoute(future);
+    if (future === curr) {
+      if (future.component) {
+        const context2 = parentContexts.getOrCreateContext(future.outlet);
+        this.activateChildRoutes(futureNode, currNode, context2.children);
+      } else {
+        this.activateChildRoutes(futureNode, currNode, parentContexts);
+      }
+    } else {
+      if (future.component) {
+        const context2 = parentContexts.getOrCreateContext(future.outlet);
+        if (this.routeReuseStrategy.shouldAttach(future.snapshot)) {
+          const stored = this.routeReuseStrategy.retrieve(future.snapshot);
+          this.routeReuseStrategy.store(future.snapshot, null);
+          context2.children.onOutletReAttached(stored.contexts);
+          context2.attachRef = stored.componentRef;
+          context2.route = stored.route.value;
+          if (context2.outlet) {
+            context2.outlet.attach(stored.componentRef, stored.route.value);
+          }
+          advanceActivatedRoute(stored.route.value);
+          this.activateChildRoutes(futureNode, null, context2.children);
+        } else {
+          context2.attachRef = null;
+          context2.route = future;
+          if (context2.outlet) {
+            context2.outlet.activateWith(future, context2.injector);
+          }
+          this.activateChildRoutes(futureNode, null, context2.children);
+        }
+      } else {
+        this.activateChildRoutes(futureNode, null, parentContexts);
+      }
+    }
+    if (typeof ngDevMode === "undefined" || ngDevMode) {
+      const context2 = parentContexts.getOrCreateContext(future.outlet);
+      const outlet = context2.outlet;
+      if (outlet && this.inputBindingEnabled && !outlet.supportsBindingToComponentInputs && !warnedAboutUnsupportedInputBinding) {
+        console.warn(`'withComponentInputBinding' feature is enabled but this application is using an outlet that may not support binding to component inputs.`);
+        warnedAboutUnsupportedInputBinding = true;
+      }
+    }
+  }
+};
+var CanActivate = class {
+  path;
+  route;
+  constructor(path) {
+    this.path = path;
+    this.route = this.path[this.path.length - 1];
+  }
+};
+var CanDeactivate = class {
+  component;
+  route;
+  constructor(component, route) {
+    this.component = component;
+    this.route = route;
+  }
+};
+function getAllRouteGuards(future, curr, parentContexts) {
+  const futureRoot = future._root;
+  const currRoot = curr ? curr._root : null;
+  return getChildRouteGuards(futureRoot, currRoot, parentContexts, [futureRoot.value]);
+}
+function getCanActivateChild(p) {
+  const canActivateChild = p.routeConfig ? p.routeConfig.canActivateChild : null;
+  if (!canActivateChild || canActivateChild.length === 0) return null;
+  return {
+    node: p,
+    guards: canActivateChild
+  };
+}
+function getTokenOrFunctionIdentity(tokenOrFunction, injector) {
+  const NOT_FOUND3 = /* @__PURE__ */ Symbol();
+  const result = injector.get(tokenOrFunction, NOT_FOUND3);
+  if (result === NOT_FOUND3) {
+    if (typeof tokenOrFunction === "function" && !isInjectable(tokenOrFunction)) {
+      return tokenOrFunction;
+    } else {
+      return injector.get(tokenOrFunction);
+    }
+  }
+  return result;
+}
+function getChildRouteGuards(futureNode, currNode, contexts, futurePath, checks = {
+  canDeactivateChecks: [],
+  canActivateChecks: []
+}) {
+  const prevChildren = nodeChildrenAsMap(currNode);
+  futureNode.children.forEach((c) => {
+    getRouteGuards(c, prevChildren[c.value.outlet], contexts, futurePath.concat([c.value]), checks);
+    delete prevChildren[c.value.outlet];
+  });
+  Object.entries(prevChildren).forEach(([k, v]) => deactivateRouteAndItsChildren(v, contexts.getContext(k), checks));
+  return checks;
+}
+function getRouteGuards(futureNode, currNode, parentContexts, futurePath, checks = {
+  canDeactivateChecks: [],
+  canActivateChecks: []
+}) {
+  const future = futureNode.value;
+  const curr = currNode ? currNode.value : null;
+  const context2 = parentContexts ? parentContexts.getContext(futureNode.value.outlet) : null;
+  if (curr && future.routeConfig === curr.routeConfig) {
+    const shouldRun = shouldRunGuardsAndResolvers(curr, future, future.routeConfig.runGuardsAndResolvers);
+    if (shouldRun) {
+      checks.canActivateChecks.push(new CanActivate(futurePath));
+    } else {
+      future.data = curr.data;
+      future._resolvedData = curr._resolvedData;
+    }
+    if (future.component) {
+      getChildRouteGuards(futureNode, currNode, context2 ? context2.children : null, futurePath, checks);
+    } else {
+      getChildRouteGuards(futureNode, currNode, parentContexts, futurePath, checks);
+    }
+    if (shouldRun && context2 && context2.outlet && context2.outlet.isActivated) {
+      checks.canDeactivateChecks.push(new CanDeactivate(context2.outlet.component, curr));
+    }
+  } else {
+    if (curr) {
+      deactivateRouteAndItsChildren(currNode, context2, checks);
+    }
+    checks.canActivateChecks.push(new CanActivate(futurePath));
+    if (future.component) {
+      getChildRouteGuards(futureNode, null, context2 ? context2.children : null, futurePath, checks);
+    } else {
+      getChildRouteGuards(futureNode, null, parentContexts, futurePath, checks);
+    }
+  }
+  return checks;
+}
+function shouldRunGuardsAndResolvers(curr, future, mode) {
+  if (typeof mode === "function") {
+    return runInInjectionContext(future._environmentInjector, () => mode(curr, future));
+  }
+  switch (mode) {
+    case "pathParamsChange":
+      return !equalPath(curr.url, future.url);
+    case "pathParamsOrQueryParamsChange":
+      return !equalPath(curr.url, future.url) || !shallowEqual(curr.queryParams, future.queryParams);
+    case "always":
+      return true;
+    case "paramsOrQueryParamsChange":
+      return !equalParamsAndUrlSegments(curr, future) || !shallowEqual(curr.queryParams, future.queryParams);
+    case "paramsChange":
+    default:
+      return !equalParamsAndUrlSegments(curr, future);
+  }
+}
+function deactivateRouteAndItsChildren(route, context2, checks) {
+  const children = nodeChildrenAsMap(route);
+  const r = route.value;
+  Object.entries(children).forEach(([childName, node]) => {
+    if (!r.component) {
+      deactivateRouteAndItsChildren(node, context2, checks);
+    } else if (context2) {
+      deactivateRouteAndItsChildren(node, context2.children.getContext(childName), checks);
+    } else {
+      deactivateRouteAndItsChildren(node, null, checks);
+    }
+  });
+  if (!r.component) {
+    checks.canDeactivateChecks.push(new CanDeactivate(null, r));
+  } else if (context2 && context2.outlet && context2.outlet.isActivated) {
+    checks.canDeactivateChecks.push(new CanDeactivate(context2.outlet.component, r));
+  } else {
+    checks.canDeactivateChecks.push(new CanDeactivate(null, r));
+  }
+}
+function isFunction2(v) {
+  return typeof v === "function";
+}
+function isBoolean(v) {
+  return typeof v === "boolean";
+}
+function isCanLoad(guard) {
+  return guard && isFunction2(guard.canLoad);
+}
+function isCanActivate(guard) {
+  return guard && isFunction2(guard.canActivate);
+}
+function isCanActivateChild(guard) {
+  return guard && isFunction2(guard.canActivateChild);
+}
+function isCanDeactivate(guard) {
+  return guard && isFunction2(guard.canDeactivate);
+}
+function isCanMatch(guard) {
+  return guard && isFunction2(guard.canMatch);
+}
+function isEmptyError(e) {
+  return e instanceof EmptyError || e?.name === "EmptyError";
+}
+var INITIAL_VALUE = /* @__PURE__ */ Symbol("INITIAL_VALUE");
+function prioritizedGuardValue() {
+  return switchMap((obs) => {
+    return combineLatest(obs.map((o) => o.pipe(take(1), startWith(INITIAL_VALUE)))).pipe(map((results) => {
+      for (const result of results) {
+        if (result === true) {
+          continue;
+        } else if (result === INITIAL_VALUE) {
+          return INITIAL_VALUE;
+        } else if (result === false || isRedirect(result)) {
+          return result;
+        }
+      }
+      return true;
+    }), filter((item) => item !== INITIAL_VALUE), take(1));
+  });
+}
+function isRedirect(val) {
+  return isUrlTree(val) || val instanceof RedirectCommand;
+}
+function abortSignalToObservable(signal2) {
+  if (signal2.aborted) {
+    return of(void 0).pipe(take(1));
+  }
+  return new Observable((subscriber) => {
+    const handler = () => {
+      subscriber.next();
+      subscriber.complete();
+    };
+    signal2.addEventListener("abort", handler);
+    return () => signal2.removeEventListener("abort", handler);
+  });
+}
+function takeUntilAbort(signal2) {
+  return takeUntil(abortSignalToObservable(signal2));
+}
+function checkGuards(forwardEvent) {
+  return mergeMap((t) => {
+    const {
+      targetSnapshot,
+      currentSnapshot,
+      guards: {
+        canActivateChecks,
+        canDeactivateChecks
+      }
+    } = t;
+    if (canDeactivateChecks.length === 0 && canActivateChecks.length === 0) {
+      return of(__spreadProps(__spreadValues({}, t), {
+        guardsResult: true
+      }));
+    }
+    return runCanDeactivateChecks(canDeactivateChecks, targetSnapshot, currentSnapshot).pipe(mergeMap((canDeactivate) => {
+      return canDeactivate && isBoolean(canDeactivate) ? runCanActivateChecks(targetSnapshot, canActivateChecks, forwardEvent) : of(canDeactivate);
+    }), map((guardsResult) => __spreadProps(__spreadValues({}, t), {
+      guardsResult
+    })));
+  });
+}
+function runCanDeactivateChecks(checks, futureRSS, currRSS) {
+  return from(checks).pipe(mergeMap((check) => runCanDeactivate(check.component, check.route, currRSS, futureRSS)), first((result) => {
+    return result !== true;
+  }, true));
+}
+function runCanActivateChecks(futureSnapshot, checks, forwardEvent) {
+  return from(checks).pipe(concatMap((check) => {
+    return concat(fireChildActivationStart(check.route.parent, forwardEvent), fireActivationStart(check.route, forwardEvent), runCanActivateChild(futureSnapshot, check.path), runCanActivate(futureSnapshot, check.route));
+  }), first((result) => {
+    return result !== true;
+  }, true));
+}
+function fireActivationStart(snapshot, forwardEvent) {
+  if (snapshot !== null && forwardEvent) {
+    forwardEvent(new ActivationStart(snapshot));
+  }
+  return of(true);
+}
+function fireChildActivationStart(snapshot, forwardEvent) {
+  if (snapshot !== null && forwardEvent) {
+    forwardEvent(new ChildActivationStart(snapshot));
+  }
+  return of(true);
+}
+function runCanActivate(futureRSS, futureARS) {
+  const canActivate = futureARS.routeConfig ? futureARS.routeConfig.canActivate : null;
+  if (!canActivate || canActivate.length === 0) return of(true);
+  const canActivateObservables = canActivate.map((canActivate2) => {
+    return defer(() => {
+      const closestInjector = futureARS._environmentInjector;
+      const guard = getTokenOrFunctionIdentity(canActivate2, closestInjector);
+      const guardVal = isCanActivate(guard) ? guard.canActivate(futureARS, futureRSS) : runInInjectionContext(closestInjector, () => guard(futureARS, futureRSS));
+      return wrapIntoObservable(guardVal).pipe(first());
+    });
+  });
+  return of(canActivateObservables).pipe(prioritizedGuardValue());
+}
+function runCanActivateChild(futureRSS, path) {
+  const futureARS = path[path.length - 1];
+  const canActivateChildGuards = path.slice(0, path.length - 1).reverse().map((p) => getCanActivateChild(p)).filter((_) => _ !== null);
+  const canActivateChildGuardsMapped = canActivateChildGuards.map((d) => {
+    return defer(() => {
+      const guardsMapped = d.guards.map((canActivateChild) => {
+        const closestInjector = d.node._environmentInjector;
+        const guard = getTokenOrFunctionIdentity(canActivateChild, closestInjector);
+        const guardVal = isCanActivateChild(guard) ? guard.canActivateChild(futureARS, futureRSS) : runInInjectionContext(closestInjector, () => guard(futureARS, futureRSS));
+        return wrapIntoObservable(guardVal).pipe(first());
+      });
+      return of(guardsMapped).pipe(prioritizedGuardValue());
+    });
+  });
+  return of(canActivateChildGuardsMapped).pipe(prioritizedGuardValue());
+}
+function runCanDeactivate(component, currARS, currRSS, futureRSS) {
+  const canDeactivate = currARS && currARS.routeConfig ? currARS.routeConfig.canDeactivate : null;
+  if (!canDeactivate || canDeactivate.length === 0) return of(true);
+  const canDeactivateObservables = canDeactivate.map((c) => {
+    const closestInjector = currARS._environmentInjector;
+    const guard = getTokenOrFunctionIdentity(c, closestInjector);
+    const guardVal = isCanDeactivate(guard) ? guard.canDeactivate(component, currARS, currRSS, futureRSS) : runInInjectionContext(closestInjector, () => guard(component, currARS, currRSS, futureRSS));
+    return wrapIntoObservable(guardVal).pipe(first());
+  });
+  return of(canDeactivateObservables).pipe(prioritizedGuardValue());
+}
+function runCanLoadGuards(injector, route, segments, urlSerializer, abortSignal) {
+  const canLoad = route.canLoad;
+  if (canLoad === void 0 || canLoad.length === 0) {
+    return of(true);
+  }
+  const canLoadObservables = canLoad.map((injectionToken) => {
+    const guard = getTokenOrFunctionIdentity(injectionToken, injector);
+    const guardVal = isCanLoad(guard) ? guard.canLoad(route, segments) : runInInjectionContext(injector, () => guard(route, segments));
+    const obs$ = wrapIntoObservable(guardVal);
+    return abortSignal ? obs$.pipe(takeUntilAbort(abortSignal)) : obs$;
+  });
+  return of(canLoadObservables).pipe(prioritizedGuardValue(), redirectIfUrlTree(urlSerializer));
+}
+function redirectIfUrlTree(urlSerializer) {
+  return pipe(tap((result) => {
+    if (typeof result === "boolean") return;
+    throw redirectingNavigationError(urlSerializer, result);
+  }), map((result) => result === true));
+}
+function runCanMatchGuards(injector, route, segments, urlSerializer, currentSnapshot, abortSignal) {
+  const canMatch = route.canMatch;
+  if (!canMatch || canMatch.length === 0) return of(true);
+  const canMatchObservables = canMatch.map((injectionToken) => {
+    const guard = getTokenOrFunctionIdentity(injectionToken, injector);
+    const guardVal = isCanMatch(guard) ? guard.canMatch(route, segments, currentSnapshot) : runInInjectionContext(injector, () => guard(route, segments, currentSnapshot));
+    return wrapIntoObservable(guardVal).pipe(takeUntilAbort(abortSignal));
+  });
+  return of(canMatchObservables).pipe(prioritizedGuardValue(), redirectIfUrlTree(urlSerializer));
+}
+var NoMatch = class _NoMatch extends Error {
+  segmentGroup;
+  constructor(segmentGroup) {
+    super();
+    this.segmentGroup = segmentGroup || null;
+    Object.setPrototypeOf(this, _NoMatch.prototype);
+  }
+};
+var AbsoluteRedirect = class _AbsoluteRedirect extends Error {
+  urlTree;
+  constructor(urlTree) {
+    super();
+    this.urlTree = urlTree;
+    Object.setPrototypeOf(this, _AbsoluteRedirect.prototype);
+  }
+};
+function namedOutletsRedirect(redirectTo) {
+  throw new RuntimeError(4e3, (typeof ngDevMode === "undefined" || ngDevMode) && `Only absolute redirects can have named outlets. redirectTo: '${redirectTo}'`);
+}
+function canLoadFails(route) {
+  throw navigationCancelingError((typeof ngDevMode === "undefined" || ngDevMode) && `Cannot load children because the guard of the route "path: '${route.path}'" returned false`, NavigationCancellationCode.GuardRejected);
+}
+var ApplyRedirects = class {
+  urlSerializer;
+  urlTree;
+  constructor(urlSerializer, urlTree) {
+    this.urlSerializer = urlSerializer;
+    this.urlTree = urlTree;
+  }
+  async lineralizeSegments(route, urlTree) {
+    let res = [];
+    let c = urlTree.root;
+    while (true) {
+      res = res.concat(c.segments);
+      if (c.numberOfChildren === 0) {
+        return res;
+      }
+      if (c.numberOfChildren > 1 || !c.children[PRIMARY_OUTLET]) {
+        throw namedOutletsRedirect(`${route.redirectTo}`);
+      }
+      c = c.children[PRIMARY_OUTLET];
+    }
+  }
+  async applyRedirectCommands(segments, redirectTo, posParams, currentSnapshot, injector) {
+    const redirect = await getRedirectResult(redirectTo, currentSnapshot, injector);
+    if (redirect instanceof UrlTree) {
+      throw new AbsoluteRedirect(redirect);
+    }
+    const newTree = this.applyRedirectCreateUrlTree(redirect, this.urlSerializer.parse(redirect), segments, posParams);
+    if (redirect[0] === "/") {
+      throw new AbsoluteRedirect(newTree);
+    }
+    return newTree;
+  }
+  applyRedirectCreateUrlTree(redirectTo, urlTree, segments, posParams) {
+    const newRoot = this.createSegmentGroup(redirectTo, urlTree.root, segments, posParams);
+    return new UrlTree(newRoot, this.createQueryParams(urlTree.queryParams, this.urlTree.queryParams), urlTree.fragment);
+  }
+  createQueryParams(redirectToParams, actualParams) {
+    const res = {};
+    Object.entries(redirectToParams).forEach(([k, v]) => {
+      const copySourceValue = typeof v === "string" && v[0] === ":";
+      if (copySourceValue) {
+        const sourceName = v.substring(1);
+        res[k] = actualParams[sourceName];
+      } else {
+        res[k] = v;
+      }
+    });
+    return res;
+  }
+  createSegmentGroup(redirectTo, group, segments, posParams) {
+    const updatedSegments = this.createSegments(redirectTo, group.segments, segments, posParams);
+    let children = {};
+    Object.entries(group.children).forEach(([name, child]) => {
+      children[name] = this.createSegmentGroup(redirectTo, child, segments, posParams);
+    });
+    return new UrlSegmentGroup(updatedSegments, children);
+  }
+  createSegments(redirectTo, redirectToSegments, actualSegments, posParams) {
+    return redirectToSegments.map((s) => s.path[0] === ":" ? this.findPosParam(redirectTo, s, posParams) : this.findOrReturn(s, actualSegments));
+  }
+  findPosParam(redirectTo, redirectToUrlSegment, posParams) {
+    const pos = posParams[redirectToUrlSegment.path.substring(1)];
+    if (!pos) throw new RuntimeError(4001, (typeof ngDevMode === "undefined" || ngDevMode) && `Cannot redirect to '${redirectTo}'. Cannot find '${redirectToUrlSegment.path}'.`);
+    return pos;
+  }
+  findOrReturn(redirectToUrlSegment, actualSegments) {
+    let idx = 0;
+    for (const s of actualSegments) {
+      if (s.path === redirectToUrlSegment.path) {
+        actualSegments.splice(idx);
+        return s;
+      }
+      idx++;
+    }
+    return redirectToUrlSegment;
+  }
+};
+function getRedirectResult(redirectTo, currentSnapshot, injector) {
+  if (typeof redirectTo === "string") {
+    return Promise.resolve(redirectTo);
+  }
+  const redirectToFn = redirectTo;
+  return firstValueFrom(wrapIntoObservable(runInInjectionContext(injector, () => redirectToFn(currentSnapshot))));
+}
+function getOrCreateRouteInjectorIfNeeded(route, currentInjector) {
+  if (route.providers && !route._injector) {
+    route._injector = createEnvironmentInjector(route.providers, currentInjector, `Route: ${route.path}`);
+  }
+  return route._injector ?? currentInjector;
+}
+function validateConfig(config2, parentPath = "", requireStandaloneComponents = false) {
+  for (let i = 0; i < config2.length; i++) {
+    const route = config2[i];
+    const fullPath = getFullPath(parentPath, route);
+    validateNode(route, fullPath, requireStandaloneComponents);
+  }
+}
+function assertStandalone(fullPath, component) {
+  if (component && isNgModule(component)) {
+    throw new RuntimeError(4014, `Invalid configuration of route '${fullPath}'. You are using 'loadComponent' with a module, but it must be used with standalone components. Use 'loadChildren' instead.`);
+  } else if (component && !isStandalone(component)) {
+    throw new RuntimeError(4014, `Invalid configuration of route '${fullPath}'. The component must be standalone.`);
+  }
+}
+function validateNode(route, fullPath, requireStandaloneComponents) {
+  if (typeof ngDevMode === "undefined" || ngDevMode) {
+    if (!route) {
+      throw new RuntimeError(4014, `
+      Invalid configuration of route '${fullPath}': Encountered undefined route.
+      The reason might be an extra comma.
+
+      Example:
+      const routes: Routes = [
+        { path: '', redirectTo: '/dashboard', pathMatch: 'full' },
+        { path: 'dashboard',  component: DashboardComponent },, << two commas
+        { path: 'detail/:id', component: HeroDetailComponent }
+      ];
+    `);
+    }
+    if (Array.isArray(route)) {
+      throw new RuntimeError(4014, `Invalid configuration of route '${fullPath}': Array cannot be specified`);
+    }
+    if (!route.redirectTo && !route.component && !route.loadComponent && !route.children && !route.loadChildren && route.outlet && route.outlet !== PRIMARY_OUTLET) {
+      throw new RuntimeError(4014, `Invalid configuration of route '${fullPath}': a componentless route without children or loadChildren cannot have a named outlet set`);
+    }
+    if (route.redirectTo && route.children) {
+      throw new RuntimeError(4014, `Invalid configuration of route '${fullPath}': redirectTo and children cannot be used together`);
+    }
+    if (route.redirectTo && route.loadChildren) {
+      throw new RuntimeError(4014, `Invalid configuration of route '${fullPath}': redirectTo and loadChildren cannot be used together`);
+    }
+    if (route.children && route.loadChildren) {
+      throw new RuntimeError(4014, `Invalid configuration of route '${fullPath}': children and loadChildren cannot be used together`);
+    }
+    if (route.component && route.loadComponent) {
+      throw new RuntimeError(4014, `Invalid configuration of route '${fullPath}': component and loadComponent cannot be used together`);
+    }
+    if (route.redirectTo) {
+      if (route.component || route.loadComponent) {
+        throw new RuntimeError(4014, `Invalid configuration of route '${fullPath}': redirectTo and component/loadComponent cannot be used together`);
+      }
+      if (route.canMatch || route.canActivate) {
+        throw new RuntimeError(4014, `Invalid configuration of route '${fullPath}': redirectTo and ${route.canMatch ? "canMatch" : "canActivate"} cannot be used together.Redirects happen before guards are executed.`);
+      }
+    }
+    if (route.path && route.matcher) {
+      throw new RuntimeError(4014, `Invalid configuration of route '${fullPath}': path and matcher cannot be used together`);
+    }
+    if (route.redirectTo === void 0 && !route.component && !route.loadComponent && !route.children && !route.loadChildren) {
+      throw new RuntimeError(4014, `Invalid configuration of route '${fullPath}'. One of the following must be provided: component, loadComponent, redirectTo, children or loadChildren`);
+    }
+    if (route.path === void 0 && route.matcher === void 0) {
+      throw new RuntimeError(4014, `Invalid configuration of route '${fullPath}': routes must have either a path or a matcher specified`);
+    }
+    if (typeof route.path === "string" && route.path.charAt(0) === "/") {
+      throw new RuntimeError(4014, `Invalid configuration of route '${fullPath}': path cannot start with a slash`);
+    }
+    if (route.path === "" && route.redirectTo !== void 0 && route.pathMatch === void 0) {
+      const exp = `The default value of 'pathMatch' is 'prefix', but often the intent is to use 'full'.`;
+      throw new RuntimeError(4014, `Invalid configuration of route '{path: "${fullPath}", redirectTo: "${route.redirectTo}"}': please provide 'pathMatch'. ${exp}`);
+    }
+    if (requireStandaloneComponents) {
+      assertStandalone(fullPath, route.component);
+    }
+  }
+  if (route.children) {
+    validateConfig(route.children, fullPath, requireStandaloneComponents);
+  }
+}
+function getFullPath(parentPath, currentRoute) {
+  if (!currentRoute) {
+    return parentPath;
+  }
+  if (!parentPath && !currentRoute.path) {
+    return "";
+  } else if (parentPath && !currentRoute.path) {
+    return `${parentPath}/`;
+  } else if (!parentPath && currentRoute.path) {
+    return currentRoute.path;
+  } else {
+    return `${parentPath}/${currentRoute.path}`;
+  }
+}
+function getOutlet(route) {
+  return route.outlet || PRIMARY_OUTLET;
+}
+function sortByMatchingOutlets(routes2, outletName) {
+  const sortedConfig = routes2.filter((r) => getOutlet(r) === outletName);
+  sortedConfig.push(...routes2.filter((r) => getOutlet(r) !== outletName));
+  return sortedConfig;
+}
+var noMatch = {
+  matched: false,
+  consumedSegments: [],
+  remainingSegments: [],
+  parameters: {},
+  positionalParamSegments: {}
+};
+function createPreMatchRouteSnapshot(snapshot) {
+  return {
+    routeConfig: snapshot.routeConfig,
+    url: snapshot.url,
+    params: snapshot.params,
+    queryParams: snapshot.queryParams,
+    fragment: snapshot.fragment,
+    data: snapshot.data,
+    outlet: snapshot.outlet,
+    title: snapshot.title,
+    paramMap: snapshot.paramMap,
+    queryParamMap: snapshot.queryParamMap
+  };
+}
+function matchWithChecks(segmentGroup, route, segments, injector, urlSerializer, createSnapshot, abortSignal) {
+  const result = match(segmentGroup, route, segments);
+  if (!result.matched) {
+    return of(result);
+  }
+  const currentSnapshot = createPreMatchRouteSnapshot(createSnapshot(result));
+  injector = getOrCreateRouteInjectorIfNeeded(route, injector);
+  return runCanMatchGuards(injector, route, segments, urlSerializer, currentSnapshot, abortSignal).pipe(map((v) => v === true ? result : __spreadValues({}, noMatch)));
+}
+function match(segmentGroup, route, segments) {
+  if (route.path === "") {
+    if (route.pathMatch === "full" && (segmentGroup.hasChildren() || segments.length > 0)) {
+      return __spreadValues({}, noMatch);
+    }
+    return {
+      matched: true,
+      consumedSegments: [],
+      remainingSegments: segments,
+      parameters: {},
+      positionalParamSegments: {}
+    };
+  }
+  const matcher = route.matcher || defaultUrlMatcher;
+  const res = matcher(segments, segmentGroup, route);
+  if (!res) return __spreadValues({}, noMatch);
+  const posParams = {};
+  Object.entries(res.posParams ?? {}).forEach(([k, v]) => {
+    posParams[k] = v.path;
+  });
+  const parameters = res.consumed.length > 0 ? __spreadValues(__spreadValues({}, posParams), res.consumed[res.consumed.length - 1].parameters) : posParams;
+  return {
+    matched: true,
+    consumedSegments: res.consumed,
+    remainingSegments: segments.slice(res.consumed.length),
+    parameters,
+    positionalParamSegments: res.posParams ?? {}
+  };
+}
+function split(segmentGroup, consumedSegments, slicedSegments, config2, outlet) {
+  if (slicedSegments.length > 0 && containsEmptyPathMatchesWithNamedOutlets(segmentGroup, slicedSegments, config2, outlet)) {
+    const s2 = new UrlSegmentGroup(consumedSegments, createChildrenForEmptyPaths(config2, new UrlSegmentGroup(slicedSegments, segmentGroup.children)));
+    return {
+      segmentGroup: s2,
+      slicedSegments: []
+    };
+  }
+  if (slicedSegments.length === 0 && containsEmptyPathMatches(segmentGroup, slicedSegments, config2)) {
+    const s2 = new UrlSegmentGroup(segmentGroup.segments, addEmptyPathsToChildrenIfNeeded(segmentGroup, slicedSegments, config2, segmentGroup.children));
+    return {
+      segmentGroup: s2,
+      slicedSegments
+    };
+  }
+  const s = new UrlSegmentGroup(segmentGroup.segments, segmentGroup.children);
+  return {
+    segmentGroup: s,
+    slicedSegments
+  };
+}
+function addEmptyPathsToChildrenIfNeeded(segmentGroup, slicedSegments, routes2, children) {
+  const res = {};
+  for (const r of routes2) {
+    if (emptyPathMatch(segmentGroup, slicedSegments, r) && !children[getOutlet(r)]) {
+      const s = new UrlSegmentGroup([], {});
+      res[getOutlet(r)] = s;
+    }
+  }
+  return __spreadValues(__spreadValues({}, children), res);
+}
+function createChildrenForEmptyPaths(routes2, primarySegment) {
+  const res = {};
+  res[PRIMARY_OUTLET] = primarySegment;
+  for (const r of routes2) {
+    if (r.path === "" && getOutlet(r) !== PRIMARY_OUTLET) {
+      const s = new UrlSegmentGroup([], {});
+      res[getOutlet(r)] = s;
+    }
+  }
+  return res;
+}
+function containsEmptyPathMatchesWithNamedOutlets(segmentGroup, slicedSegments, routes2, outlet) {
+  return routes2.some((r) => {
+    const matchesEmpty = emptyPathMatch(segmentGroup, slicedSegments, r);
+    if (!matchesEmpty) return false;
+    const isNamedOutlet = getOutlet(r) !== PRIMARY_OUTLET;
+    if (!isNamedOutlet) return false;
+    const isSelfEvaluating = outlet !== void 0 && getOutlet(r) === outlet;
+    return !isSelfEvaluating;
+  });
+}
+function containsEmptyPathMatches(segmentGroup, slicedSegments, routes2) {
+  return routes2.some((r) => emptyPathMatch(segmentGroup, slicedSegments, r));
+}
+function emptyPathMatch(segmentGroup, slicedSegments, r) {
+  if ((segmentGroup.hasChildren() || slicedSegments.length > 0) && r.pathMatch === "full") {
+    return false;
+  }
+  return r.path === "";
+}
+function noLeftoversInUrl(segmentGroup, segments, outlet) {
+  return segments.length === 0 && !segmentGroup.children[outlet];
+}
+var NoLeftoversInUrl = class {
+};
+async function recognize$1(injector, configLoader, rootComponentType, config2, urlTree, urlSerializer, paramsInheritanceStrategy = "emptyOnly", abortSignal) {
+  return new Recognizer(injector, configLoader, rootComponentType, config2, urlTree, paramsInheritanceStrategy, urlSerializer, abortSignal).recognize();
+}
+var MAX_ALLOWED_REDIRECTS = 31;
+var Recognizer = class {
+  injector;
+  configLoader;
+  rootComponentType;
+  config;
+  urlTree;
+  paramsInheritanceStrategy;
+  urlSerializer;
+  abortSignal;
+  applyRedirects;
+  absoluteRedirectCount = 0;
+  allowRedirects = true;
+  constructor(injector, configLoader, rootComponentType, config2, urlTree, paramsInheritanceStrategy, urlSerializer, abortSignal) {
+    this.injector = injector;
+    this.configLoader = configLoader;
+    this.rootComponentType = rootComponentType;
+    this.config = config2;
+    this.urlTree = urlTree;
+    this.paramsInheritanceStrategy = paramsInheritanceStrategy;
+    this.urlSerializer = urlSerializer;
+    this.abortSignal = abortSignal;
+    this.applyRedirects = new ApplyRedirects(this.urlSerializer, this.urlTree);
+  }
+  noMatchError(e) {
+    return new RuntimeError(4002, typeof ngDevMode === "undefined" || ngDevMode ? `Cannot match any routes. URL Segment: '${e.segmentGroup}'` : `'${e.segmentGroup}'`);
+  }
+  async recognize() {
+    const rootSegmentGroup = split(this.urlTree.root, [], [], this.config).segmentGroup;
+    const {
+      children,
+      rootSnapshot
+    } = await this.match(rootSegmentGroup);
+    const rootNode = new TreeNode(rootSnapshot, children);
+    const routeState = new RouterStateSnapshot("", rootNode);
+    const tree2 = createUrlTreeFromSnapshot(rootSnapshot, [], this.urlTree.queryParams, this.urlTree.fragment);
+    tree2.queryParams = this.urlTree.queryParams;
+    routeState.url = this.urlSerializer.serialize(tree2);
+    return {
+      state: routeState,
+      tree: tree2
+    };
+  }
+  async match(rootSegmentGroup) {
+    const rootSnapshot = new ActivatedRouteSnapshot([], Object.freeze({}), Object.freeze(__spreadValues({}, this.urlTree.queryParams)), this.urlTree.fragment, Object.freeze({}), PRIMARY_OUTLET, this.rootComponentType, null, {}, this.injector);
+    try {
+      const children = await this.processSegmentGroup(this.injector, this.config, rootSegmentGroup, PRIMARY_OUTLET, rootSnapshot);
+      return {
+        children,
+        rootSnapshot
+      };
+    } catch (e) {
+      if (e instanceof AbsoluteRedirect) {
+        this.urlTree = e.urlTree;
+        return this.match(e.urlTree.root);
+      }
+      if (e instanceof NoMatch) {
+        throw this.noMatchError(e);
+      }
+      throw e;
+    }
+  }
+  async processSegmentGroup(injector, config2, segmentGroup, outlet, parentRoute) {
+    if (segmentGroup.segments.length === 0 && segmentGroup.hasChildren()) {
+      return this.processChildren(injector, config2, segmentGroup, parentRoute);
+    }
+    const child = await this.processSegment(injector, config2, segmentGroup, segmentGroup.segments, outlet, true, parentRoute);
+    return child instanceof TreeNode ? [child] : [];
+  }
+  async processChildren(injector, config2, segmentGroup, parentRoute) {
+    const childOutlets = [];
+    for (const child of Object.keys(segmentGroup.children)) {
+      if (child === "primary") {
+        childOutlets.unshift(child);
+      } else {
+        childOutlets.push(child);
+      }
+    }
+    let children = [];
+    for (const childOutlet of childOutlets) {
+      const child = segmentGroup.children[childOutlet];
+      const sortedConfig = sortByMatchingOutlets(config2, childOutlet);
+      const outletChildren = await this.processSegmentGroup(injector, sortedConfig, child, childOutlet, parentRoute);
+      children.push(...outletChildren);
+    }
+    const mergedChildren = mergeEmptyPathMatches(children);
+    if (typeof ngDevMode === "undefined" || ngDevMode) {
+      checkOutletNameUniqueness(mergedChildren);
+    }
+    sortActivatedRouteSnapshots(mergedChildren);
+    return mergedChildren;
+  }
+  async processSegment(injector, routes2, segmentGroup, segments, outlet, allowRedirects, parentRoute) {
+    for (const r of routes2) {
+      try {
+        return await this.processSegmentAgainstRoute(r._injector ?? injector, routes2, r, segmentGroup, segments, outlet, allowRedirects, parentRoute);
+      } catch (e) {
+        if (e instanceof NoMatch || isEmptyError(e)) {
+          continue;
+        }
+        throw e;
+      }
+    }
+    if (noLeftoversInUrl(segmentGroup, segments, outlet)) {
+      return new NoLeftoversInUrl();
+    }
+    throw new NoMatch(segmentGroup);
+  }
+  async processSegmentAgainstRoute(injector, routes2, route, rawSegment, segments, outlet, allowRedirects, parentRoute) {
+    if (getOutlet(route) !== outlet && (outlet === PRIMARY_OUTLET || !emptyPathMatch(rawSegment, segments, route))) {
+      throw new NoMatch(rawSegment);
+    }
+    if (route.redirectTo === void 0) {
+      return this.matchSegmentAgainstRoute(injector, rawSegment, route, segments, outlet, parentRoute);
+    }
+    if (this.allowRedirects && allowRedirects) {
+      return this.expandSegmentAgainstRouteUsingRedirect(injector, rawSegment, routes2, route, segments, outlet, parentRoute);
+    }
+    throw new NoMatch(rawSegment);
+  }
+  async expandSegmentAgainstRouteUsingRedirect(injector, segmentGroup, routes2, route, segments, outlet, parentRoute) {
+    const {
+      matched,
+      parameters,
+      consumedSegments,
+      positionalParamSegments,
+      remainingSegments
+    } = match(segmentGroup, route, segments);
+    if (!matched) throw new NoMatch(segmentGroup);
+    if (typeof route.redirectTo === "string" && route.redirectTo[0] === "/") {
+      this.absoluteRedirectCount++;
+      if (this.absoluteRedirectCount > MAX_ALLOWED_REDIRECTS) {
+        if (ngDevMode) {
+          throw new RuntimeError(4016, `Detected possible infinite redirect when redirecting from '${this.urlTree}' to '${route.redirectTo}'.
+This is currently a dev mode only error but will become a call stack size exceeded error in production in a future major version.`);
+        }
+        this.allowRedirects = false;
+      }
+    }
+    const currentSnapshot = this.createSnapshot(injector, route, segments, parameters, parentRoute);
+    if (this.abortSignal.aborted) {
+      throw new Error(this.abortSignal.reason);
+    }
+    const newTree = await this.applyRedirects.applyRedirectCommands(consumedSegments, route.redirectTo, positionalParamSegments, createPreMatchRouteSnapshot(currentSnapshot), injector);
+    const newSegments = await this.applyRedirects.lineralizeSegments(route, newTree);
+    return this.processSegment(injector, routes2, segmentGroup, newSegments.concat(remainingSegments), outlet, false, parentRoute);
+  }
+  createSnapshot(injector, route, segments, parameters, parentRoute) {
+    const snapshot = new ActivatedRouteSnapshot(segments, parameters, Object.freeze(__spreadValues({}, this.urlTree.queryParams)), this.urlTree.fragment, getData(route), getOutlet(route), route.component ?? route._loadedComponent ?? null, route, getResolve(route), injector);
+    const inherited = getInherited(snapshot, parentRoute, this.paramsInheritanceStrategy);
+    snapshot.params = Object.freeze(inherited.params);
+    snapshot.data = Object.freeze(inherited.data);
+    return snapshot;
+  }
+  async matchSegmentAgainstRoute(injector, rawSegment, route, segments, outlet, parentRoute) {
+    if (this.abortSignal.aborted) {
+      throw new Error(this.abortSignal.reason);
+    }
+    const createSnapshot = (result2) => this.createSnapshot(injector, route, result2.consumedSegments, result2.parameters, parentRoute);
+    const result = await firstValueFrom(matchWithChecks(rawSegment, route, segments, injector, this.urlSerializer, createSnapshot, this.abortSignal));
+    if (route.path === "**") {
+      rawSegment.children = {};
+    }
+    if (!result?.matched) {
+      throw new NoMatch(rawSegment);
+    }
+    injector = route._injector ?? injector;
+    const {
+      routes: childConfig
+    } = await this.getChildConfig(injector, route, segments);
+    const childInjector = route._loadedInjector ?? injector;
+    const {
+      parameters,
+      consumedSegments,
+      remainingSegments
+    } = result;
+    const snapshot = this.createSnapshot(injector, route, consumedSegments, parameters, parentRoute);
+    const {
+      segmentGroup,
+      slicedSegments
+    } = split(rawSegment, consumedSegments, remainingSegments, childConfig, outlet);
+    if (slicedSegments.length === 0 && segmentGroup.hasChildren()) {
+      const children = await this.processChildren(childInjector, childConfig, segmentGroup, snapshot);
+      return new TreeNode(snapshot, children);
+    }
+    if (childConfig.length === 0 && slicedSegments.length === 0) {
+      return new TreeNode(snapshot, []);
+    }
+    const matchedOnOutlet = getOutlet(route) === outlet;
+    const child = await this.processSegment(childInjector, childConfig, segmentGroup, slicedSegments, matchedOnOutlet ? PRIMARY_OUTLET : outlet, true, snapshot);
+    return new TreeNode(snapshot, child instanceof TreeNode ? [child] : []);
+  }
+  async getChildConfig(injector, route, segments) {
+    if (route.children) {
+      return {
+        routes: route.children,
+        injector
+      };
+    }
+    if (route.loadChildren) {
+      if (route._loadedRoutes !== void 0) {
+        const ngModuleFactory = route._loadedNgModuleFactory;
+        if (ngModuleFactory && !route._loadedInjector) {
+          route._loadedInjector = ngModuleFactory.create(injector).injector;
+        }
+        return {
+          routes: route._loadedRoutes,
+          injector: route._loadedInjector
+        };
+      }
+      if (this.abortSignal.aborted) {
+        throw new Error(this.abortSignal.reason);
+      }
+      const shouldLoadResult = await firstValueFrom(runCanLoadGuards(injector, route, segments, this.urlSerializer, this.abortSignal));
+      if (shouldLoadResult) {
+        const cfg = await this.configLoader.loadChildren(injector, route);
+        route._loadedRoutes = cfg.routes;
+        route._loadedInjector = cfg.injector;
+        route._loadedNgModuleFactory = cfg.factory;
+        return cfg;
+      }
+      throw canLoadFails(route);
+    }
+    return {
+      routes: [],
+      injector
+    };
+  }
+};
+function sortActivatedRouteSnapshots(nodes) {
+  nodes.sort((a, b) => {
+    if (a.value.outlet === PRIMARY_OUTLET) return -1;
+    if (b.value.outlet === PRIMARY_OUTLET) return 1;
+    return a.value.outlet.localeCompare(b.value.outlet);
+  });
+}
+function hasEmptyPathConfig(node) {
+  const config2 = node.value.routeConfig;
+  return config2 && config2.path === "";
+}
+function mergeEmptyPathMatches(nodes) {
+  const result = [];
+  const mergedNodes = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    if (!hasEmptyPathConfig(node)) {
+      result.push(node);
+      continue;
+    }
+    const duplicateEmptyPathNode = result.find((resultNode) => node.value.routeConfig === resultNode.value.routeConfig);
+    if (duplicateEmptyPathNode !== void 0) {
+      duplicateEmptyPathNode.children.push(...node.children);
+      mergedNodes.add(duplicateEmptyPathNode);
+    } else {
+      result.push(node);
+    }
+  }
+  for (const mergedNode of mergedNodes) {
+    const mergedChildren = mergeEmptyPathMatches(mergedNode.children);
+    result.push(new TreeNode(mergedNode.value, mergedChildren));
+  }
+  return result.filter((n) => !mergedNodes.has(n));
+}
+function checkOutletNameUniqueness(nodes) {
+  const names = {};
+  nodes.forEach((n) => {
+    const routeWithSameOutletName = names[n.value.outlet];
+    if (routeWithSameOutletName) {
+      const p = routeWithSameOutletName.url.map((s) => s.toString()).join("/");
+      const c = n.value.url.map((s) => s.toString()).join("/");
+      throw new RuntimeError(4006, (typeof ngDevMode === "undefined" || ngDevMode) && `Two segments cannot have the same outlet name: '${p}' and '${c}'.`);
+    }
+    names[n.value.outlet] = n.value;
+  });
+}
+function getData(route) {
+  return route.data || {};
+}
+function getResolve(route) {
+  return route.resolve || {};
+}
+function recognize(injector, configLoader, rootComponentType, config2, serializer, paramsInheritanceStrategy, abortSignal) {
+  return mergeMap(async (t) => {
+    const {
+      state: targetSnapshot,
+      tree: urlAfterRedirects
+    } = await recognize$1(injector, configLoader, rootComponentType, config2, t.extractedUrl, serializer, paramsInheritanceStrategy, abortSignal);
+    return __spreadProps(__spreadValues({}, t), {
+      targetSnapshot,
+      urlAfterRedirects
+    });
+  });
+}
+function resolveData(paramsInheritanceStrategy) {
+  return mergeMap((t) => {
+    const {
+      targetSnapshot,
+      guards: {
+        canActivateChecks
+      }
+    } = t;
+    if (!canActivateChecks.length) {
+      return of(t);
+    }
+    const routesWithResolversToRun = new Set(canActivateChecks.map((check) => check.route));
+    const routesNeedingDataUpdates = /* @__PURE__ */ new Set();
+    for (const route of routesWithResolversToRun) {
+      if (routesNeedingDataUpdates.has(route)) {
+        continue;
+      }
+      for (const newRoute of flattenRouteTree(route)) {
+        routesNeedingDataUpdates.add(newRoute);
+      }
+    }
+    let routesProcessed = 0;
+    return from(routesNeedingDataUpdates).pipe(concatMap((route) => {
+      if (routesWithResolversToRun.has(route)) {
+        return runResolve(route, targetSnapshot, paramsInheritanceStrategy);
+      } else {
+        route.data = getInherited(route, route.parent, paramsInheritanceStrategy).resolve;
+        return of(void 0);
+      }
+    }), tap(() => routesProcessed++), takeLast(1), mergeMap((_) => routesProcessed === routesNeedingDataUpdates.size ? of(t) : EMPTY));
+  });
+}
+function flattenRouteTree(route) {
+  const descendants = route.children.map((child) => flattenRouteTree(child)).flat();
+  return [route, ...descendants];
+}
+function runResolve(futureARS, futureRSS, paramsInheritanceStrategy) {
+  const config2 = futureARS.routeConfig;
+  const resolve = futureARS._resolve;
+  if (config2?.title !== void 0 && !hasStaticTitle(config2)) {
+    resolve[RouteTitleKey] = config2.title;
+  }
+  return defer(() => {
+    futureARS.data = getInherited(futureARS, futureARS.parent, paramsInheritanceStrategy).resolve;
+    return resolveNode(resolve, futureARS, futureRSS).pipe(map((resolvedData) => {
+      futureARS._resolvedData = resolvedData;
+      futureARS.data = __spreadValues(__spreadValues({}, futureARS.data), resolvedData);
+      return null;
+    }));
+  });
+}
+function resolveNode(resolve, futureARS, futureRSS) {
+  const keys = getDataKeys(resolve);
+  if (keys.length === 0) {
+    return of({});
+  }
+  const data = {};
+  return from(keys).pipe(mergeMap((key) => getResolver(resolve[key], futureARS, futureRSS).pipe(first(), tap((value) => {
+    if (value instanceof RedirectCommand) {
+      throw redirectingNavigationError(new DefaultUrlSerializer(), value);
+    }
+    data[key] = value;
+  }))), takeLast(1), map(() => data), catchError((e) => isEmptyError(e) ? EMPTY : throwError(e)));
+}
+function getResolver(injectionToken, futureARS, futureRSS) {
+  const closestInjector = futureARS._environmentInjector;
+  const resolver = getTokenOrFunctionIdentity(injectionToken, closestInjector);
+  const resolverValue = resolver.resolve ? resolver.resolve(futureARS, futureRSS) : runInInjectionContext(closestInjector, () => resolver(futureARS, futureRSS));
+  return wrapIntoObservable(resolverValue);
+}
+function switchTap(next) {
+  return switchMap((v) => {
+    const nextResult = next(v);
+    if (nextResult) {
+      return from(nextResult).pipe(map(() => v));
+    }
+    return of(v);
+  });
+}
+var TitleStrategy = class _TitleStrategy {
+  buildTitle(snapshot) {
+    let pageTitle;
+    let route = snapshot.root;
+    while (route !== void 0) {
+      pageTitle = this.getResolvedTitleForRoute(route) ?? pageTitle;
+      route = route.children.find((child) => child.outlet === PRIMARY_OUTLET);
+    }
+    return pageTitle;
+  }
+  getResolvedTitleForRoute(snapshot) {
+    return snapshot.data[RouteTitleKey];
+  }
+  static \u0275fac = function TitleStrategy_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _TitleStrategy)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _TitleStrategy,
+    factory: () => (() => inject2(DefaultTitleStrategy))(),
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(TitleStrategy, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root",
+      useFactory: () => inject2(DefaultTitleStrategy)
+    }]
+  }], null, null);
+})();
+var DefaultTitleStrategy = class _DefaultTitleStrategy extends TitleStrategy {
+  title;
+  constructor(title) {
+    super();
+    this.title = title;
+  }
+  updateTitle(snapshot) {
+    const title = this.buildTitle(snapshot);
+    if (title !== void 0) {
+      this.title.setTitle(title);
+    }
+  }
+  static \u0275fac = function DefaultTitleStrategy_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _DefaultTitleStrategy)(\u0275\u0275inject(Title));
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _DefaultTitleStrategy,
+    factory: _DefaultTitleStrategy.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DefaultTitleStrategy, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], () => [{
+    type: Title
+  }], null);
+})();
+var ROUTER_CONFIGURATION = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "router config" : "", {
+  factory: () => ({})
+});
+var ROUTES = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "ROUTES" : "");
+var RouterConfigLoader = class _RouterConfigLoader {
+  componentLoaders = /* @__PURE__ */ new WeakMap();
+  childrenLoaders = /* @__PURE__ */ new WeakMap();
+  onLoadStartListener;
+  onLoadEndListener;
+  compiler = inject2(Compiler);
+  async loadComponent(injector, route) {
+    if (this.componentLoaders.get(route)) {
+      return this.componentLoaders.get(route);
+    } else if (route._loadedComponent) {
+      return Promise.resolve(route._loadedComponent);
+    }
+    if (this.onLoadStartListener) {
+      this.onLoadStartListener(route);
+    }
+    const loader = (async () => {
+      try {
+        const loaded = await wrapIntoPromise(runInInjectionContext(injector, () => route.loadComponent()));
+        const component = await maybeResolveResources(maybeUnwrapDefaultExport(loaded));
+        if (this.onLoadEndListener) {
+          this.onLoadEndListener(route);
+        }
+        (typeof ngDevMode === "undefined" || ngDevMode) && assertStandalone(route.path ?? "", component);
+        route._loadedComponent = component;
+        return component;
+      } finally {
+        this.componentLoaders.delete(route);
+      }
+    })();
+    this.componentLoaders.set(route, loader);
+    return loader;
+  }
+  loadChildren(parentInjector, route) {
+    if (this.childrenLoaders.get(route)) {
+      return this.childrenLoaders.get(route);
+    } else if (route._loadedRoutes) {
+      return Promise.resolve({
+        routes: route._loadedRoutes,
+        injector: route._loadedInjector
+      });
+    }
+    if (this.onLoadStartListener) {
+      this.onLoadStartListener(route);
+    }
+    const loader = (async () => {
+      try {
+        const result = await loadChildren(route, this.compiler, parentInjector, this.onLoadEndListener);
+        route._loadedRoutes = result.routes;
+        route._loadedInjector = result.injector;
+        route._loadedNgModuleFactory = result.factory;
+        return result;
+      } finally {
+        this.childrenLoaders.delete(route);
+      }
+    })();
+    this.childrenLoaders.set(route, loader);
+    return loader;
+  }
+  static \u0275fac = function RouterConfigLoader_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _RouterConfigLoader)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _RouterConfigLoader,
+    factory: _RouterConfigLoader.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(RouterConfigLoader, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], null, null);
+})();
+async function loadChildren(route, compiler, parentInjector, onLoadEndListener) {
+  const loaded = await wrapIntoPromise(runInInjectionContext(parentInjector, () => route.loadChildren()));
+  const t = await maybeResolveResources(maybeUnwrapDefaultExport(loaded));
+  let factoryOrRoutes;
+  if (t instanceof NgModuleFactory$1 || Array.isArray(t)) {
+    factoryOrRoutes = t;
+  } else {
+    factoryOrRoutes = await compiler.compileModuleAsync(t);
+  }
+  if (onLoadEndListener) {
+    onLoadEndListener(route);
+  }
+  let injector;
+  let rawRoutes;
+  let requireStandaloneComponents = false;
+  let factory = void 0;
+  if (Array.isArray(factoryOrRoutes)) {
+    rawRoutes = factoryOrRoutes;
+    requireStandaloneComponents = true;
+  } else {
+    injector = factoryOrRoutes.create(parentInjector).injector;
+    factory = factoryOrRoutes;
+    rawRoutes = injector.get(ROUTES, [], {
+      optional: true,
+      self: true
+    }).flat();
+  }
+  const routes2 = rawRoutes.map(standardizeConfig);
+  (typeof ngDevMode === "undefined" || ngDevMode) && validateConfig(routes2, route.path, requireStandaloneComponents);
+  return {
+    routes: routes2,
+    injector,
+    factory
+  };
+}
+function isWrappedDefaultExport(value) {
+  return value && typeof value === "object" && "default" in value;
+}
+function maybeUnwrapDefaultExport(input2) {
+  return isWrappedDefaultExport(input2) ? input2["default"] : input2;
+}
+async function maybeResolveResources(value) {
+  if (false) {
+    try {
+      await resolveComponentResources(fetch);
+    } catch (error) {
+      console.error(error);
+    }
+  }
+  return value;
+}
+var UrlHandlingStrategy = class _UrlHandlingStrategy {
+  static \u0275fac = function UrlHandlingStrategy_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _UrlHandlingStrategy)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _UrlHandlingStrategy,
+    factory: () => (() => inject2(DefaultUrlHandlingStrategy))(),
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(UrlHandlingStrategy, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root",
+      useFactory: () => inject2(DefaultUrlHandlingStrategy)
+    }]
+  }], null, null);
+})();
+var DefaultUrlHandlingStrategy = class _DefaultUrlHandlingStrategy {
+  shouldProcessUrl(url) {
+    return true;
+  }
+  extract(url) {
+    return url;
+  }
+  merge(newUrlPart, wholeUrl) {
+    return newUrlPart;
+  }
+  static \u0275fac = function DefaultUrlHandlingStrategy_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _DefaultUrlHandlingStrategy)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _DefaultUrlHandlingStrategy,
+    factory: _DefaultUrlHandlingStrategy.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DefaultUrlHandlingStrategy, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], null, null);
+})();
+var CREATE_VIEW_TRANSITION = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "view transition helper" : "");
+var VIEW_TRANSITION_OPTIONS = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "view transition options" : "");
+function createViewTransition(injector, from2, to) {
+  const transitionOptions = injector.get(VIEW_TRANSITION_OPTIONS);
+  const document2 = injector.get(DOCUMENT);
+  if (!document2.startViewTransition || transitionOptions.skipNextTransition) {
+    transitionOptions.skipNextTransition = false;
+    return new Promise((resolve) => setTimeout(resolve));
+  }
+  let resolveViewTransitionStarted;
+  const viewTransitionStarted = new Promise((resolve) => {
+    resolveViewTransitionStarted = resolve;
+  });
+  const transition = document2.startViewTransition(() => {
+    resolveViewTransitionStarted();
+    return createRenderPromise(injector);
+  });
+  transition.updateCallbackDone.catch((error) => {
+    if (typeof ngDevMode === "undefined" || ngDevMode) {
+      console.error(error);
+    }
+  });
+  transition.ready.catch((error) => {
+    if (typeof ngDevMode === "undefined" || ngDevMode) {
+      console.error(error);
+    }
+  });
+  transition.finished.catch((error) => {
+    if (typeof ngDevMode === "undefined" || ngDevMode) {
+      console.error(error);
+    }
+  });
+  const {
+    onViewTransitionCreated
+  } = transitionOptions;
+  if (onViewTransitionCreated) {
+    runInInjectionContext(injector, () => onViewTransitionCreated({
+      transition,
+      from: from2,
+      to
+    }));
+  }
+  return viewTransitionStarted;
+}
+function createRenderPromise(injector) {
+  return new Promise((resolve) => {
+    afterNextRender({
+      read: () => setTimeout(resolve)
+    }, {
+      injector
+    });
+  });
+}
+var noop4 = () => {
+};
+var NAVIGATION_ERROR_HANDLER = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "navigation error handler" : "");
+var NavigationTransitions = class _NavigationTransitions {
+  currentNavigation = signal(null, __spreadProps(__spreadValues({}, ngDevMode ? {
+    debugName: "currentNavigation"
+  } : {}), {
+    equal: () => false
+  }));
+  currentTransition = null;
+  lastSuccessfulNavigation = signal(null, ...ngDevMode ? [{
+    debugName: "lastSuccessfulNavigation"
+  }] : []);
+  events = new Subject();
+  transitionAbortWithErrorSubject = new Subject();
+  configLoader = inject2(RouterConfigLoader);
+  environmentInjector = inject2(EnvironmentInjector);
+  destroyRef = inject2(DestroyRef);
+  urlSerializer = inject2(UrlSerializer);
+  rootContexts = inject2(ChildrenOutletContexts);
+  location = inject2(Location);
+  inputBindingEnabled = inject2(INPUT_BINDER, {
+    optional: true
+  }) !== null;
+  titleStrategy = inject2(TitleStrategy);
+  options = inject2(ROUTER_CONFIGURATION, {
+    optional: true
+  }) || {};
+  paramsInheritanceStrategy = this.options.paramsInheritanceStrategy || "emptyOnly";
+  urlHandlingStrategy = inject2(UrlHandlingStrategy);
+  createViewTransition = inject2(CREATE_VIEW_TRANSITION, {
+    optional: true
+  });
+  navigationErrorHandler = inject2(NAVIGATION_ERROR_HANDLER, {
+    optional: true
+  });
+  navigationId = 0;
+  get hasRequestedNavigation() {
+    return this.navigationId !== 0;
+  }
+  transitions;
+  afterPreactivation = () => of(void 0);
+  rootComponentType = null;
+  destroyed = false;
+  constructor() {
+    const onLoadStart = (r) => this.events.next(new RouteConfigLoadStart(r));
+    const onLoadEnd = (r) => this.events.next(new RouteConfigLoadEnd(r));
+    this.configLoader.onLoadEndListener = onLoadEnd;
+    this.configLoader.onLoadStartListener = onLoadStart;
+    this.destroyRef.onDestroy(() => {
+      this.destroyed = true;
+    });
+  }
+  complete() {
+    this.transitions?.complete();
+  }
+  handleNavigationRequest(request) {
+    const id = ++this.navigationId;
+    untracked2(() => {
+      this.transitions?.next(__spreadProps(__spreadValues({}, request), {
+        extractedUrl: this.urlHandlingStrategy.extract(request.rawUrl),
+        targetSnapshot: null,
+        targetRouterState: null,
+        guards: {
+          canActivateChecks: [],
+          canDeactivateChecks: []
+        },
+        guardsResult: null,
+        id,
+        routesRecognizeHandler: {},
+        beforeActivateHandler: {}
+      }));
+    });
+  }
+  setupNavigations(router) {
+    this.transitions = new BehaviorSubject(null);
+    return this.transitions.pipe(filter((t) => t !== null), switchMap((overallTransitionState) => {
+      let completedOrAborted = false;
+      const abortController = new AbortController();
+      const shouldContinueNavigation = () => {
+        return !completedOrAborted && this.currentTransition?.id === overallTransitionState.id;
+      };
+      return of(overallTransitionState).pipe(switchMap((t) => {
+        if (this.navigationId > overallTransitionState.id) {
+          const cancellationReason = typeof ngDevMode === "undefined" || ngDevMode ? `Navigation ID ${overallTransitionState.id} is not equal to the current navigation id ${this.navigationId}` : "";
+          this.cancelNavigationTransition(overallTransitionState, cancellationReason, NavigationCancellationCode.SupersededByNewNavigation);
+          return EMPTY;
+        }
+        this.currentTransition = overallTransitionState;
+        const lastSuccessfulNavigation = this.lastSuccessfulNavigation();
+        this.currentNavigation.set({
+          id: t.id,
+          initialUrl: t.rawUrl,
+          extractedUrl: t.extractedUrl,
+          targetBrowserUrl: typeof t.extras.browserUrl === "string" ? this.urlSerializer.parse(t.extras.browserUrl) : t.extras.browserUrl,
+          trigger: t.source,
+          extras: t.extras,
+          previousNavigation: !lastSuccessfulNavigation ? null : __spreadProps(__spreadValues({}, lastSuccessfulNavigation), {
+            previousNavigation: null
+          }),
+          abort: () => abortController.abort(),
+          routesRecognizeHandler: t.routesRecognizeHandler,
+          beforeActivateHandler: t.beforeActivateHandler
+        });
+        const urlTransition = !router.navigated || this.isUpdatingInternalState() || this.isUpdatedBrowserUrl();
+        const onSameUrlNavigation = t.extras.onSameUrlNavigation ?? router.onSameUrlNavigation;
+        if (!urlTransition && onSameUrlNavigation !== "reload") {
+          const reason = typeof ngDevMode === "undefined" || ngDevMode ? `Navigation to ${t.rawUrl} was ignored because it is the same as the current Router URL.` : "";
+          this.events.next(new NavigationSkipped(t.id, this.urlSerializer.serialize(t.rawUrl), reason, NavigationSkippedCode.IgnoredSameUrlNavigation));
+          t.resolve(false);
+          return EMPTY;
+        }
+        if (this.urlHandlingStrategy.shouldProcessUrl(t.rawUrl)) {
+          return of(t).pipe(switchMap((t2) => {
+            this.events.next(new NavigationStart(t2.id, this.urlSerializer.serialize(t2.extractedUrl), t2.source, t2.restoredState));
+            if (t2.id !== this.navigationId) {
+              return EMPTY;
+            }
+            return Promise.resolve(t2);
+          }), recognize(this.environmentInjector, this.configLoader, this.rootComponentType, router.config, this.urlSerializer, this.paramsInheritanceStrategy, abortController.signal), tap((t2) => {
+            overallTransitionState.targetSnapshot = t2.targetSnapshot;
+            overallTransitionState.urlAfterRedirects = t2.urlAfterRedirects;
+            this.currentNavigation.update((nav) => {
+              nav.finalUrl = t2.urlAfterRedirects;
+              return nav;
+            });
+            this.events.next(new BeforeRoutesRecognized());
+          }), switchMap((value) => from(overallTransitionState.routesRecognizeHandler.deferredHandle ?? of(void 0)).pipe(map(() => value))), tap(() => {
+            const routesRecognized = new RoutesRecognized(t.id, this.urlSerializer.serialize(t.extractedUrl), this.urlSerializer.serialize(t.urlAfterRedirects), t.targetSnapshot);
+            this.events.next(routesRecognized);
+          }));
+        } else if (urlTransition && this.urlHandlingStrategy.shouldProcessUrl(t.currentRawUrl)) {
+          const {
+            id,
+            extractedUrl,
+            source,
+            restoredState,
+            extras
+          } = t;
+          const navStart = new NavigationStart(id, this.urlSerializer.serialize(extractedUrl), source, restoredState);
+          this.events.next(navStart);
+          const targetSnapshot = createEmptyState(this.rootComponentType, this.environmentInjector).snapshot;
+          this.currentTransition = overallTransitionState = __spreadProps(__spreadValues({}, t), {
+            targetSnapshot,
+            urlAfterRedirects: extractedUrl,
+            extras: __spreadProps(__spreadValues({}, extras), {
+              skipLocationChange: false,
+              replaceUrl: false
+            })
+          });
+          this.currentNavigation.update((nav) => {
+            nav.finalUrl = extractedUrl;
+            return nav;
+          });
+          return of(overallTransitionState);
+        } else {
+          const reason = typeof ngDevMode === "undefined" || ngDevMode ? `Navigation was ignored because the UrlHandlingStrategy indicated neither the current URL ${t.currentRawUrl} nor target URL ${t.rawUrl} should be processed.` : "";
+          this.events.next(new NavigationSkipped(t.id, this.urlSerializer.serialize(t.extractedUrl), reason, NavigationSkippedCode.IgnoredByUrlHandlingStrategy));
+          t.resolve(false);
+          return EMPTY;
+        }
+      }), map((t) => {
+        const guardsStart = new GuardsCheckStart(t.id, this.urlSerializer.serialize(t.extractedUrl), this.urlSerializer.serialize(t.urlAfterRedirects), t.targetSnapshot);
+        this.events.next(guardsStart);
+        this.currentTransition = overallTransitionState = __spreadProps(__spreadValues({}, t), {
+          guards: getAllRouteGuards(t.targetSnapshot, t.currentSnapshot, this.rootContexts)
+        });
+        return overallTransitionState;
+      }), checkGuards((evt) => this.events.next(evt)), switchMap((t) => {
+        overallTransitionState.guardsResult = t.guardsResult;
+        if (t.guardsResult && typeof t.guardsResult !== "boolean") {
+          throw redirectingNavigationError(this.urlSerializer, t.guardsResult);
+        }
+        const guardsEnd = new GuardsCheckEnd(t.id, this.urlSerializer.serialize(t.extractedUrl), this.urlSerializer.serialize(t.urlAfterRedirects), t.targetSnapshot, !!t.guardsResult);
+        this.events.next(guardsEnd);
+        if (!shouldContinueNavigation()) {
+          return EMPTY;
+        }
+        if (!t.guardsResult) {
+          this.cancelNavigationTransition(t, "", NavigationCancellationCode.GuardRejected);
+          return EMPTY;
+        }
+        if (t.guards.canActivateChecks.length === 0) {
+          return of(t);
+        }
+        const resolveStart = new ResolveStart(t.id, this.urlSerializer.serialize(t.extractedUrl), this.urlSerializer.serialize(t.urlAfterRedirects), t.targetSnapshot);
+        this.events.next(resolveStart);
+        if (!shouldContinueNavigation()) {
+          return EMPTY;
+        }
+        let dataResolved = false;
+        return of(t).pipe(resolveData(this.paramsInheritanceStrategy), tap({
+          next: () => {
+            dataResolved = true;
+            const resolveEnd = new ResolveEnd(t.id, this.urlSerializer.serialize(t.extractedUrl), this.urlSerializer.serialize(t.urlAfterRedirects), t.targetSnapshot);
+            this.events.next(resolveEnd);
+          },
+          complete: () => {
+            if (!dataResolved) {
+              this.cancelNavigationTransition(t, typeof ngDevMode === "undefined" || ngDevMode ? `At least one route resolver didn't emit any value.` : "", NavigationCancellationCode.NoDataFromResolver);
+            }
+          }
+        }));
+      }), switchTap((t) => {
+        const loadComponents = (route) => {
+          const loaders2 = [];
+          if (route.routeConfig?._loadedComponent) {
+            route.component = route.routeConfig?._loadedComponent;
+          } else if (route.routeConfig?.loadComponent) {
+            const injector = route._environmentInjector;
+            loaders2.push(this.configLoader.loadComponent(injector, route.routeConfig).then((loadedComponent) => {
+              route.component = loadedComponent;
+            }));
+          }
+          for (const child of route.children) {
+            loaders2.push(...loadComponents(child));
+          }
+          return loaders2;
+        };
+        const loaders = loadComponents(t.targetSnapshot.root);
+        return loaders.length === 0 ? of(t) : from(Promise.all(loaders).then(() => t));
+      }), switchTap(() => this.afterPreactivation()), switchMap(() => {
+        const {
+          currentSnapshot,
+          targetSnapshot
+        } = overallTransitionState;
+        const viewTransitionStarted = this.createViewTransition?.(this.environmentInjector, currentSnapshot.root, targetSnapshot.root);
+        return viewTransitionStarted ? from(viewTransitionStarted).pipe(map(() => overallTransitionState)) : of(overallTransitionState);
+      }), take(1), switchMap((t) => {
+        const targetRouterState = createRouterState(router.routeReuseStrategy, t.targetSnapshot, t.currentRouterState);
+        this.currentTransition = overallTransitionState = t = __spreadProps(__spreadValues({}, t), {
+          targetRouterState
+        });
+        this.currentNavigation.update((nav) => {
+          nav.targetRouterState = targetRouterState;
+          return nav;
+        });
+        this.events.next(new BeforeActivateRoutes());
+        const deferred = overallTransitionState.beforeActivateHandler.deferredHandle;
+        return deferred ? from(deferred.then(() => t)) : of(t);
+      }), tap((t) => {
+        new ActivateRoutes(router.routeReuseStrategy, overallTransitionState.targetRouterState, overallTransitionState.currentRouterState, (evt) => this.events.next(evt), this.inputBindingEnabled).activate(this.rootContexts);
+        if (!shouldContinueNavigation()) {
+          return;
+        }
+        completedOrAborted = true;
+        this.currentNavigation.update((nav) => {
+          nav.abort = noop4;
+          return nav;
+        });
+        this.lastSuccessfulNavigation.set(untracked2(this.currentNavigation));
+        this.events.next(new NavigationEnd(t.id, this.urlSerializer.serialize(t.extractedUrl), this.urlSerializer.serialize(t.urlAfterRedirects)));
+        this.titleStrategy?.updateTitle(t.targetRouterState.snapshot);
+        t.resolve(true);
+      }), takeUntil(abortSignalToObservable(abortController.signal).pipe(filter(() => !completedOrAborted && !overallTransitionState.targetRouterState), tap(() => {
+        this.cancelNavigationTransition(overallTransitionState, abortController.signal.reason + "", NavigationCancellationCode.Aborted);
+      }))), tap({
+        complete: () => {
+          completedOrAborted = true;
+        }
+      }), takeUntil(this.transitionAbortWithErrorSubject.pipe(tap((err) => {
+        throw err;
+      }))), finalize(() => {
+        abortController.abort();
+        if (!completedOrAborted) {
+          const cancelationReason = typeof ngDevMode === "undefined" || ngDevMode ? `Navigation ID ${overallTransitionState.id} is not equal to the current navigation id ${this.navigationId}` : "";
+          this.cancelNavigationTransition(overallTransitionState, cancelationReason, NavigationCancellationCode.SupersededByNewNavigation);
+        }
+        if (this.currentTransition?.id === overallTransitionState.id) {
+          this.currentNavigation.set(null);
+          this.currentTransition = null;
+        }
+      }), catchError((e) => {
+        completedOrAborted = true;
+        if (this.destroyed) {
+          overallTransitionState.resolve(false);
+          return EMPTY;
+        }
+        if (isNavigationCancelingError(e)) {
+          this.events.next(new NavigationCancel(overallTransitionState.id, this.urlSerializer.serialize(overallTransitionState.extractedUrl), e.message, e.cancellationCode));
+          if (!isRedirectingNavigationCancelingError(e)) {
+            overallTransitionState.resolve(false);
+          } else {
+            this.events.next(new RedirectRequest(e.url, e.navigationBehaviorOptions));
+          }
+        } else {
+          const navigationError = new NavigationError(overallTransitionState.id, this.urlSerializer.serialize(overallTransitionState.extractedUrl), e, overallTransitionState.targetSnapshot ?? void 0);
+          try {
+            const navigationErrorHandlerResult = runInInjectionContext(this.environmentInjector, () => this.navigationErrorHandler?.(navigationError));
+            if (navigationErrorHandlerResult instanceof RedirectCommand) {
+              const {
+                message,
+                cancellationCode
+              } = redirectingNavigationError(this.urlSerializer, navigationErrorHandlerResult);
+              this.events.next(new NavigationCancel(overallTransitionState.id, this.urlSerializer.serialize(overallTransitionState.extractedUrl), message, cancellationCode));
+              this.events.next(new RedirectRequest(navigationErrorHandlerResult.redirectTo, navigationErrorHandlerResult.navigationBehaviorOptions));
+            } else {
+              this.events.next(navigationError);
+              throw e;
+            }
+          } catch (ee) {
+            if (this.options.resolveNavigationPromiseOnError) {
+              overallTransitionState.resolve(false);
+            } else {
+              overallTransitionState.reject(ee);
+            }
+          }
+        }
+        return EMPTY;
+      }));
+    }));
+  }
+  cancelNavigationTransition(t, reason, code) {
+    const navCancel = new NavigationCancel(t.id, this.urlSerializer.serialize(t.extractedUrl), reason, code);
+    this.events.next(navCancel);
+    t.resolve(false);
+  }
+  isUpdatingInternalState() {
+    return this.currentTransition?.extractedUrl.toString() !== this.currentTransition?.currentUrlTree.toString();
+  }
+  isUpdatedBrowserUrl() {
+    const currentBrowserUrl = this.urlHandlingStrategy.extract(this.urlSerializer.parse(this.location.path(true)));
+    const currentNavigation = untracked2(this.currentNavigation);
+    const targetBrowserUrl = currentNavigation?.targetBrowserUrl ?? currentNavigation?.extractedUrl;
+    return currentBrowserUrl.toString() !== targetBrowserUrl?.toString() && !currentNavigation?.extras.skipLocationChange;
+  }
+  static \u0275fac = function NavigationTransitions_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _NavigationTransitions)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _NavigationTransitions,
+    factory: _NavigationTransitions.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NavigationTransitions, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], () => [], null);
+})();
+function isBrowserTriggeredNavigation(source) {
+  return source !== IMPERATIVE_NAVIGATION;
+}
+var ROUTE_INJECTOR_CLEANUP = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "RouteInjectorCleanup" : "");
+var RouteReuseStrategy = class _RouteReuseStrategy {
+  static \u0275fac = function RouteReuseStrategy_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _RouteReuseStrategy)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _RouteReuseStrategy,
+    factory: () => (() => inject2(DefaultRouteReuseStrategy))(),
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(RouteReuseStrategy, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root",
+      useFactory: () => inject2(DefaultRouteReuseStrategy)
+    }]
+  }], null, null);
+})();
+var BaseRouteReuseStrategy = class {
+  shouldDetach(route) {
+    return false;
+  }
+  store(route, detachedTree) {
+  }
+  shouldAttach(route) {
+    return false;
+  }
+  retrieve(route) {
+    return null;
+  }
+  shouldReuseRoute(future, curr) {
+    return future.routeConfig === curr.routeConfig;
+  }
+  shouldDestroyInjector(route) {
+    return true;
+  }
+};
+var DefaultRouteReuseStrategy = class _DefaultRouteReuseStrategy extends BaseRouteReuseStrategy {
+  static \u0275fac = /* @__PURE__ */ (() => {
+    let \u0275DefaultRouteReuseStrategy_BaseFactory;
+    return function DefaultRouteReuseStrategy_Factory(__ngFactoryType__) {
+      return (\u0275DefaultRouteReuseStrategy_BaseFactory || (\u0275DefaultRouteReuseStrategy_BaseFactory = \u0275\u0275getInheritedFactory(_DefaultRouteReuseStrategy)))(__ngFactoryType__ || _DefaultRouteReuseStrategy);
+    };
+  })();
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _DefaultRouteReuseStrategy,
+    factory: _DefaultRouteReuseStrategy.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DefaultRouteReuseStrategy, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], null, null);
+})();
+var StateManager = class _StateManager {
+  urlSerializer = inject2(UrlSerializer);
+  options = inject2(ROUTER_CONFIGURATION, {
+    optional: true
+  }) || {};
+  canceledNavigationResolution = this.options.canceledNavigationResolution || "replace";
+  location = inject2(Location);
+  urlHandlingStrategy = inject2(UrlHandlingStrategy);
+  urlUpdateStrategy = this.options.urlUpdateStrategy || "deferred";
+  currentUrlTree = new UrlTree();
+  getCurrentUrlTree() {
+    return this.currentUrlTree;
+  }
+  rawUrlTree = this.currentUrlTree;
+  getRawUrlTree() {
+    return this.rawUrlTree;
+  }
+  createBrowserPath({
+    finalUrl,
+    initialUrl,
+    targetBrowserUrl
+  }) {
+    const rawUrl = finalUrl !== void 0 ? this.urlHandlingStrategy.merge(finalUrl, initialUrl) : initialUrl;
+    const url = targetBrowserUrl ?? rawUrl;
+    const path = url instanceof UrlTree ? this.urlSerializer.serialize(url) : url;
+    return path;
+  }
+  routerUrlState(navigation) {
+    if (navigation?.targetBrowserUrl === void 0 || navigation?.finalUrl === void 0) {
+      return {};
+    }
+    return {
+      \u0275routerUrl: this.urlSerializer.serialize(navigation.finalUrl)
+    };
+  }
+  commitTransition({
+    targetRouterState,
+    finalUrl,
+    initialUrl
+  }) {
+    if (finalUrl && targetRouterState) {
+      this.currentUrlTree = finalUrl;
+      this.rawUrlTree = this.urlHandlingStrategy.merge(finalUrl, initialUrl);
+      this.routerState = targetRouterState;
+    } else {
+      this.rawUrlTree = initialUrl;
+    }
+  }
+  routerState = createEmptyState(null, inject2(EnvironmentInjector));
+  getRouterState() {
+    return this.routerState;
+  }
+  _stateMemento = this.createStateMemento();
+  get stateMemento() {
+    return this._stateMemento;
+  }
+  updateStateMemento() {
+    this._stateMemento = this.createStateMemento();
+  }
+  createStateMemento() {
+    return {
+      rawUrlTree: this.rawUrlTree,
+      currentUrlTree: this.currentUrlTree,
+      routerState: this.routerState
+    };
+  }
+  restoredState() {
+    return this.location.getState();
+  }
+  static \u0275fac = function StateManager_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _StateManager)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _StateManager,
+    factory: () => (() => inject2(HistoryStateManager))(),
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(StateManager, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root",
+      useFactory: () => inject2(HistoryStateManager)
+    }]
+  }], null, null);
+})();
+var HistoryStateManager = class _HistoryStateManager extends StateManager {
+  currentPageId = 0;
+  lastSuccessfulId = -1;
+  get browserPageId() {
+    if (this.canceledNavigationResolution !== "computed") {
+      return this.currentPageId;
+    }
+    return this.restoredState()?.\u0275routerPageId ?? this.currentPageId;
+  }
+  registerNonRouterCurrentEntryChangeListener(listener) {
+    return this.location.subscribe((event) => {
+      if (event["type"] === "popstate") {
+        setTimeout(() => {
+          listener(event["url"], event.state, "popstate", {
+            replaceUrl: true
+          });
+        });
+      }
+    });
+  }
+  handleRouterEvent(e, currentTransition) {
+    if (e instanceof NavigationStart) {
+      this.updateStateMemento();
+    } else if (e instanceof NavigationSkipped) {
+      this.commitTransition(currentTransition);
+    } else if (e instanceof RoutesRecognized) {
+      if (this.urlUpdateStrategy === "eager") {
+        if (!currentTransition.extras.skipLocationChange) {
+          this.setBrowserUrl(this.createBrowserPath(currentTransition), currentTransition);
+        }
+      }
+    } else if (e instanceof BeforeActivateRoutes) {
+      this.commitTransition(currentTransition);
+      if (this.urlUpdateStrategy === "deferred" && !currentTransition.extras.skipLocationChange) {
+        this.setBrowserUrl(this.createBrowserPath(currentTransition), currentTransition);
+      }
+    } else if (e instanceof NavigationCancel && !isRedirectingEvent(e)) {
+      this.restoreHistory(currentTransition);
+    } else if (e instanceof NavigationError) {
+      this.restoreHistory(currentTransition, true);
+    } else if (e instanceof NavigationEnd) {
+      this.lastSuccessfulId = e.id;
+      this.currentPageId = this.browserPageId;
+    }
+  }
+  setBrowserUrl(path, navigation) {
+    const {
+      extras,
+      id
+    } = navigation;
+    const {
+      replaceUrl,
+      state
+    } = extras;
+    if (this.location.isCurrentPathEqualTo(path) || !!replaceUrl) {
+      const currentBrowserPageId = this.browserPageId;
+      const newState = __spreadValues(__spreadValues({}, state), this.generateNgRouterState(id, currentBrowserPageId, navigation));
+      this.location.replaceState(path, "", newState);
+    } else {
+      const newState = __spreadValues(__spreadValues({}, state), this.generateNgRouterState(id, this.browserPageId + 1, navigation));
+      this.location.go(path, "", newState);
+    }
+  }
+  restoreHistory(navigation, restoringFromCaughtError = false) {
+    if (this.canceledNavigationResolution === "computed") {
+      const currentBrowserPageId = this.browserPageId;
+      const targetPagePosition = this.currentPageId - currentBrowserPageId;
+      if (targetPagePosition !== 0) {
+        this.location.historyGo(targetPagePosition);
+      } else if (this.getCurrentUrlTree() === navigation.finalUrl && targetPagePosition === 0) {
+        this.resetInternalState(navigation);
+        this.resetUrlToCurrentUrlTree();
+      } else ;
+    } else if (this.canceledNavigationResolution === "replace") {
+      if (restoringFromCaughtError) {
+        this.resetInternalState(navigation);
+      }
+      this.resetUrlToCurrentUrlTree();
+    }
+  }
+  resetInternalState({
+    finalUrl
+  }) {
+    this.routerState = this.stateMemento.routerState;
+    this.currentUrlTree = this.stateMemento.currentUrlTree;
+    this.rawUrlTree = this.urlHandlingStrategy.merge(this.currentUrlTree, finalUrl ?? this.rawUrlTree);
+  }
+  resetUrlToCurrentUrlTree() {
+    this.location.replaceState(this.urlSerializer.serialize(this.getRawUrlTree()), "", this.generateNgRouterState(this.lastSuccessfulId, this.currentPageId));
+  }
+  generateNgRouterState(navigationId, routerPageId, navigation) {
+    if (this.canceledNavigationResolution === "computed") {
+      return __spreadValues({
+        navigationId,
+        \u0275routerPageId: routerPageId
+      }, this.routerUrlState(navigation));
+    }
+    return __spreadValues({
+      navigationId
+    }, this.routerUrlState(navigation));
+  }
+  static \u0275fac = /* @__PURE__ */ (() => {
+    let \u0275HistoryStateManager_BaseFactory;
+    return function HistoryStateManager_Factory(__ngFactoryType__) {
+      return (\u0275HistoryStateManager_BaseFactory || (\u0275HistoryStateManager_BaseFactory = \u0275\u0275getInheritedFactory(_HistoryStateManager)))(__ngFactoryType__ || _HistoryStateManager);
+    };
+  })();
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _HistoryStateManager,
+    factory: _HistoryStateManager.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HistoryStateManager, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], null, null);
+})();
+function afterNextNavigation(router, action) {
+  router.events.pipe(filter((e) => e instanceof NavigationEnd || e instanceof NavigationCancel || e instanceof NavigationError || e instanceof NavigationSkipped), map((e) => {
+    if (e instanceof NavigationEnd || e instanceof NavigationSkipped) {
+      return 0;
+    }
+    const redirecting = e instanceof NavigationCancel ? e.code === NavigationCancellationCode.Redirect || e.code === NavigationCancellationCode.SupersededByNewNavigation : false;
+    return redirecting ? 2 : 1;
+  }), filter((result) => result !== 2), take(1)).subscribe(() => {
+    action();
+  });
+}
+var Router = class _Router {
+  get currentUrlTree() {
+    return this.stateManager.getCurrentUrlTree();
+  }
+  get rawUrlTree() {
+    return this.stateManager.getRawUrlTree();
+  }
+  disposed = false;
+  nonRouterCurrentEntryChangeSubscription;
+  console = inject2(Console);
+  stateManager = inject2(StateManager);
+  options = inject2(ROUTER_CONFIGURATION, {
+    optional: true
+  }) || {};
+  pendingTasks = inject2(PendingTasksInternal);
+  urlUpdateStrategy = this.options.urlUpdateStrategy || "deferred";
+  navigationTransitions = inject2(NavigationTransitions);
+  urlSerializer = inject2(UrlSerializer);
+  location = inject2(Location);
+  urlHandlingStrategy = inject2(UrlHandlingStrategy);
+  injector = inject2(EnvironmentInjector);
+  _events = new Subject();
+  get events() {
+    return this._events;
+  }
+  get routerState() {
+    return this.stateManager.getRouterState();
+  }
+  navigated = false;
+  routeReuseStrategy = inject2(RouteReuseStrategy);
+  injectorCleanup = inject2(ROUTE_INJECTOR_CLEANUP, {
+    optional: true
+  });
+  onSameUrlNavigation = this.options.onSameUrlNavigation || "ignore";
+  config = inject2(ROUTES, {
+    optional: true
+  })?.flat() ?? [];
+  componentInputBindingEnabled = !!inject2(INPUT_BINDER, {
+    optional: true
+  });
+  currentNavigation = this.navigationTransitions.currentNavigation.asReadonly();
+  constructor() {
+    this.resetConfig(this.config);
+    this.navigationTransitions.setupNavigations(this).subscribe({
+      error: (e) => {
+      }
+    });
+    this.subscribeToNavigationEvents();
+  }
+  eventsSubscription = new Subscription();
+  subscribeToNavigationEvents() {
+    const subscription = this.navigationTransitions.events.subscribe((e) => {
+      try {
+        const currentTransition = this.navigationTransitions.currentTransition;
+        const currentNavigation = untracked2(this.navigationTransitions.currentNavigation);
+        if (currentTransition !== null && currentNavigation !== null) {
+          this.stateManager.handleRouterEvent(e, currentNavigation);
+          if (e instanceof NavigationCancel && e.code !== NavigationCancellationCode.Redirect && e.code !== NavigationCancellationCode.SupersededByNewNavigation) {
+            this.navigated = true;
+          } else if (e instanceof NavigationEnd) {
+            this.navigated = true;
+            this.injectorCleanup?.(this.routeReuseStrategy, this.routerState, this.config);
+          } else if (e instanceof RedirectRequest) {
+            const opts = e.navigationBehaviorOptions;
+            const mergedTree = this.urlHandlingStrategy.merge(e.url, currentTransition.currentRawUrl);
+            const extras = __spreadValues({
+              scroll: currentTransition.extras.scroll,
+              browserUrl: currentTransition.extras.browserUrl,
+              info: currentTransition.extras.info,
+              skipLocationChange: currentTransition.extras.skipLocationChange,
+              replaceUrl: currentTransition.extras.replaceUrl || this.urlUpdateStrategy === "eager" || isBrowserTriggeredNavigation(currentTransition.source)
+            }, opts);
+            this.scheduleNavigation(mergedTree, IMPERATIVE_NAVIGATION, null, extras, {
+              resolve: currentTransition.resolve,
+              reject: currentTransition.reject,
+              promise: currentTransition.promise
+            });
+          }
+        }
+        if (isPublicRouterEvent(e)) {
+          this._events.next(e);
+        }
+      } catch (e2) {
+        this.navigationTransitions.transitionAbortWithErrorSubject.next(e2);
+      }
+    });
+    this.eventsSubscription.add(subscription);
+  }
+  resetRootComponentType(rootComponentType) {
+    this.routerState.root.component = rootComponentType;
+    this.navigationTransitions.rootComponentType = rootComponentType;
+  }
+  initialNavigation() {
+    this.setUpLocationChangeListener();
+    if (!this.navigationTransitions.hasRequestedNavigation) {
+      this.navigateToSyncWithBrowser(this.location.path(true), IMPERATIVE_NAVIGATION, this.stateManager.restoredState(), {
+        replaceUrl: true
+      });
+    }
+  }
+  setUpLocationChangeListener() {
+    this.nonRouterCurrentEntryChangeSubscription ??= this.stateManager.registerNonRouterCurrentEntryChangeListener((url, state, source, extras) => {
+      this.navigateToSyncWithBrowser(url, source, state, extras);
+    });
+  }
+  navigateToSyncWithBrowser(url, source, state, extras) {
+    const restoredState = state?.navigationId ? state : null;
+    const routerUrl = state?.\u0275routerUrl ?? url;
+    if (state?.\u0275routerUrl) {
+      extras = __spreadProps(__spreadValues({}, extras), {
+        browserUrl: url
+      });
+    }
+    if (state) {
+      const stateCopy = __spreadValues({}, state);
+      delete stateCopy.navigationId;
+      delete stateCopy.\u0275routerPageId;
+      delete stateCopy.\u0275routerUrl;
+      if (Object.keys(stateCopy).length !== 0) {
+        extras.state = stateCopy;
+      }
+    }
+    const urlTree = this.parseUrl(routerUrl);
+    this.scheduleNavigation(urlTree, source, restoredState, extras).catch((e) => {
+      if (this.disposed) {
+        return;
+      }
+      this.injector.get(INTERNAL_APPLICATION_ERROR_HANDLER)(e);
+    });
+  }
+  get url() {
+    return this.serializeUrl(this.currentUrlTree);
+  }
+  getCurrentNavigation() {
+    return untracked2(this.navigationTransitions.currentNavigation);
+  }
+  get lastSuccessfulNavigation() {
+    return this.navigationTransitions.lastSuccessfulNavigation;
+  }
+  resetConfig(config2) {
+    (typeof ngDevMode === "undefined" || ngDevMode) && validateConfig(config2);
+    this.config = config2.map(standardizeConfig);
+    this.navigated = false;
+  }
+  ngOnDestroy() {
+    this.dispose();
+  }
+  dispose() {
+    this._events.unsubscribe();
+    this.navigationTransitions.complete();
+    this.nonRouterCurrentEntryChangeSubscription?.unsubscribe();
+    this.nonRouterCurrentEntryChangeSubscription = void 0;
+    this.disposed = true;
+    this.eventsSubscription.unsubscribe();
+  }
+  createUrlTree(commands, navigationExtras = {}) {
+    const {
+      relativeTo,
+      queryParams,
+      fragment,
+      queryParamsHandling,
+      preserveFragment
+    } = navigationExtras;
+    const f = preserveFragment ? this.currentUrlTree.fragment : fragment;
+    let q = null;
+    switch (queryParamsHandling ?? this.options.defaultQueryParamsHandling) {
+      case "merge":
+        q = __spreadValues(__spreadValues({}, this.currentUrlTree.queryParams), queryParams);
+        break;
+      case "preserve":
+        q = this.currentUrlTree.queryParams;
+        break;
+      default:
+        q = queryParams || null;
+    }
+    if (q !== null) {
+      q = this.removeEmptyProps(q);
+    }
+    let relativeToUrlSegmentGroup;
+    try {
+      const relativeToSnapshot = relativeTo ? relativeTo.snapshot : this.routerState.snapshot.root;
+      relativeToUrlSegmentGroup = createSegmentGroupFromRoute(relativeToSnapshot);
+    } catch (e) {
+      if (typeof commands[0] !== "string" || commands[0][0] !== "/") {
+        commands = [];
+      }
+      relativeToUrlSegmentGroup = this.currentUrlTree.root;
+    }
+    return createUrlTreeFromSegmentGroup(relativeToUrlSegmentGroup, commands, q, f ?? null, this.urlSerializer);
+  }
+  navigateByUrl(url, extras = {
+    skipLocationChange: false
+  }) {
+    const urlTree = isUrlTree(url) ? url : this.parseUrl(url);
+    const mergedTree = this.urlHandlingStrategy.merge(urlTree, this.rawUrlTree);
+    return this.scheduleNavigation(mergedTree, IMPERATIVE_NAVIGATION, null, extras);
+  }
+  navigate(commands, extras = {
+    skipLocationChange: false
+  }) {
+    validateCommands(commands);
+    return this.navigateByUrl(this.createUrlTree(commands, extras), extras);
+  }
+  serializeUrl(url) {
+    return this.urlSerializer.serialize(url);
+  }
+  parseUrl(url) {
+    try {
+      return this.urlSerializer.parse(url);
+    } catch (e) {
+      this.console.warn(formatRuntimeError(4018, ngDevMode && `Error parsing URL ${url}. Falling back to '/' instead. 
+` + e));
+      return this.urlSerializer.parse("/");
+    }
+  }
+  isActive(url, matchOptions) {
+    let options;
+    if (matchOptions === true) {
+      options = __spreadValues({}, exactMatchOptions);
+    } else if (matchOptions === false) {
+      options = __spreadValues({}, subsetMatchOptions);
+    } else {
+      options = __spreadValues(__spreadValues({}, subsetMatchOptions), matchOptions);
+    }
+    if (isUrlTree(url)) {
+      return containsTree(this.currentUrlTree, url, options);
+    }
+    const urlTree = this.parseUrl(url);
+    return containsTree(this.currentUrlTree, urlTree, options);
+  }
+  removeEmptyProps(params) {
+    return Object.entries(params).reduce((result, [key, value]) => {
+      if (value !== null && value !== void 0) {
+        result[key] = value;
+      }
+      return result;
+    }, {});
+  }
+  scheduleNavigation(rawUrl, source, restoredState, extras, priorPromise) {
+    if (this.disposed) {
+      return Promise.resolve(false);
+    }
+    let resolve;
+    let reject;
+    let promise;
+    if (priorPromise) {
+      resolve = priorPromise.resolve;
+      reject = priorPromise.reject;
+      promise = priorPromise.promise;
+    } else {
+      promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+      });
+    }
+    const taskId = this.pendingTasks.add();
+    afterNextNavigation(this, () => {
+      queueMicrotask(() => this.pendingTasks.remove(taskId));
+    });
+    this.navigationTransitions.handleNavigationRequest({
+      source,
+      restoredState,
+      currentUrlTree: this.currentUrlTree,
+      currentRawUrl: this.currentUrlTree,
+      rawUrl,
+      extras,
+      resolve,
+      reject,
+      promise,
+      currentSnapshot: this.routerState.snapshot,
+      currentRouterState: this.routerState
+    });
+    return promise.catch(Promise.reject.bind(Promise));
+  }
+  static \u0275fac = function Router_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _Router)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _Router,
+    factory: _Router.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(Router, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], () => [], null);
+})();
+function validateCommands(commands) {
+  for (let i = 0; i < commands.length; i++) {
+    const cmd = commands[i];
+    if (cmd == null) {
+      throw new RuntimeError(4008, (typeof ngDevMode === "undefined" || ngDevMode) && `The requested path contains ${cmd} segment at index ${i}`);
+    }
+  }
+}
+
+// node_modules/@angular/router/fesm2022/_router_module-chunk.mjs
+/**
+ * @license Angular v21.2.17
+ * (c) 2010-2026 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+var ReactiveRouterState = class _ReactiveRouterState {
+  router = inject2(Router);
+  stateManager = inject2(StateManager);
+  fragment = signal("", ...ngDevMode ? [{
+    debugName: "fragment"
+  }] : []);
+  queryParams = signal({}, ...ngDevMode ? [{
+    debugName: "queryParams"
+  }] : []);
+  path = signal("", ...ngDevMode ? [{
+    debugName: "path"
+  }] : []);
+  serializer = inject2(UrlSerializer);
+  constructor() {
+    this.updateState();
+    this.router.events?.subscribe((e) => {
+      if (e instanceof NavigationEnd) {
+        this.updateState();
+      }
+    });
+  }
+  updateState() {
+    const {
+      fragment,
+      root,
+      queryParams
+    } = this.stateManager.getCurrentUrlTree();
+    this.fragment.set(fragment);
+    this.queryParams.set(queryParams);
+    this.path.set(this.serializer.serialize(new UrlTree(root)));
+  }
+  static \u0275fac = function ReactiveRouterState_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _ReactiveRouterState)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _ReactiveRouterState,
+    factory: _ReactiveRouterState.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ReactiveRouterState, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], () => [], null);
+})();
+var RouterLink = class _RouterLink {
+  router;
+  route;
+  tabIndexAttribute;
+  renderer;
+  el;
+  locationStrategy;
+  hrefAttributeValue = inject2(new HostAttributeToken("href"), {
+    optional: true
+  });
+  reactiveHref = linkedSignal(() => {
+    if (!this.isAnchorElement) {
+      return this.hrefAttributeValue;
+    }
+    return this.computeHref(this._urlTree());
+  }, ...ngDevMode ? [{
+    debugName: "reactiveHref"
+  }] : []);
+  get href() {
+    return untracked2(this.reactiveHref);
+  }
+  set href(value) {
+    this.reactiveHref.set(value);
+  }
+  set target(value) {
+    this._target.set(value);
+  }
+  get target() {
+    return untracked2(this._target);
+  }
+  _target = signal(void 0, ...ngDevMode ? [{
+    debugName: "_target"
+  }] : []);
+  set queryParams(value) {
+    this._queryParams.set(value);
+  }
+  get queryParams() {
+    return untracked2(this._queryParams);
+  }
+  _queryParams = signal(void 0, __spreadProps(__spreadValues({}, ngDevMode ? {
+    debugName: "_queryParams"
+  } : {}), {
+    equal: () => false
+  }));
+  set fragment(value) {
+    this._fragment.set(value);
+  }
+  get fragment() {
+    return untracked2(this._fragment);
+  }
+  _fragment = signal(void 0, ...ngDevMode ? [{
+    debugName: "_fragment"
+  }] : []);
+  set queryParamsHandling(value) {
+    this._queryParamsHandling.set(value);
+  }
+  get queryParamsHandling() {
+    return untracked2(this._queryParamsHandling);
+  }
+  _queryParamsHandling = signal(void 0, ...ngDevMode ? [{
+    debugName: "_queryParamsHandling"
+  }] : []);
+  set state(value) {
+    this._state.set(value);
+  }
+  get state() {
+    return untracked2(this._state);
+  }
+  _state = signal(void 0, __spreadProps(__spreadValues({}, ngDevMode ? {
+    debugName: "_state"
+  } : {}), {
+    equal: () => false
+  }));
+  set info(value) {
+    this._info.set(value);
+  }
+  get info() {
+    return untracked2(this._info);
+  }
+  _info = signal(void 0, __spreadProps(__spreadValues({}, ngDevMode ? {
+    debugName: "_info"
+  } : {}), {
+    equal: () => false
+  }));
+  set relativeTo(value) {
+    this._relativeTo.set(value);
+  }
+  get relativeTo() {
+    return untracked2(this._relativeTo);
+  }
+  _relativeTo = signal(void 0, ...ngDevMode ? [{
+    debugName: "_relativeTo"
+  }] : []);
+  set preserveFragment(value) {
+    this._preserveFragment.set(value);
+  }
+  get preserveFragment() {
+    return untracked2(this._preserveFragment);
+  }
+  _preserveFragment = signal(false, ...ngDevMode ? [{
+    debugName: "_preserveFragment"
+  }] : []);
+  set skipLocationChange(value) {
+    this._skipLocationChange.set(value);
+  }
+  get skipLocationChange() {
+    return untracked2(this._skipLocationChange);
+  }
+  _skipLocationChange = signal(false, ...ngDevMode ? [{
+    debugName: "_skipLocationChange"
+  }] : []);
+  set replaceUrl(value) {
+    this._replaceUrl.set(value);
+  }
+  get replaceUrl() {
+    return untracked2(this._replaceUrl);
+  }
+  _replaceUrl = signal(false, ...ngDevMode ? [{
+    debugName: "_replaceUrl"
+  }] : []);
+  isAnchorElement;
+  onChanges = new Subject();
+  applicationErrorHandler = inject2(INTERNAL_APPLICATION_ERROR_HANDLER);
+  options = inject2(ROUTER_CONFIGURATION, {
+    optional: true
+  });
+  reactiveRouterState = inject2(ReactiveRouterState);
+  constructor(router, route, tabIndexAttribute, renderer, el, locationStrategy) {
+    this.router = router;
+    this.route = route;
+    this.tabIndexAttribute = tabIndexAttribute;
+    this.renderer = renderer;
+    this.el = el;
+    this.locationStrategy = locationStrategy;
+    const tagName = el.nativeElement.tagName?.toLowerCase();
+    this.isAnchorElement = tagName === "a" || tagName === "area" || !!(typeof customElements === "object" && customElements.get(tagName)?.observedAttributes?.includes?.("href"));
+    if (typeof ngDevMode !== "undefined" && ngDevMode) {
+      effect(() => {
+        if (isUrlTree(this.routerLinkInput()) && (this._fragment() !== void 0 || this._queryParams() || this._queryParamsHandling() || this._preserveFragment() || this._relativeTo())) {
+          throw new RuntimeError(4017, "Cannot configure queryParams or fragment when using a UrlTree as the routerLink input value.");
+        }
+      });
+    }
+  }
+  setTabIndexIfNotOnNativeEl(newTabIndex) {
+    if (this.tabIndexAttribute != null || this.isAnchorElement) {
+      return;
+    }
+    this.applyAttributeValue("tabindex", newTabIndex);
+  }
+  ngOnChanges(changes) {
+    this.onChanges.next(this);
+  }
+  routerLinkInput = signal(null, ...ngDevMode ? [{
+    debugName: "routerLinkInput"
+  }] : []);
+  set routerLink(commandsOrUrlTree) {
+    if (commandsOrUrlTree == null) {
+      this.routerLinkInput.set(null);
+      this.setTabIndexIfNotOnNativeEl(null);
+    } else {
+      if (isUrlTree(commandsOrUrlTree)) {
+        this.routerLinkInput.set(commandsOrUrlTree);
+      } else {
+        this.routerLinkInput.set(Array.isArray(commandsOrUrlTree) ? commandsOrUrlTree : [commandsOrUrlTree]);
+      }
+      this.setTabIndexIfNotOnNativeEl("0");
+    }
+  }
+  onClick(button, ctrlKey, shiftKey, altKey, metaKey) {
+    const urlTree = this._urlTree();
+    if (urlTree === null) {
+      return true;
+    }
+    if (this.isAnchorElement) {
+      if (button !== 0 || ctrlKey || shiftKey || altKey || metaKey) {
+        return true;
+      }
+      if (typeof this.target === "string" && this.target != "_self") {
+        return true;
+      }
+    }
+    const extras = {
+      skipLocationChange: this.skipLocationChange,
+      replaceUrl: this.replaceUrl,
+      state: this.state,
+      info: this.info
+    };
+    this.router.navigateByUrl(urlTree, extras)?.catch((e) => {
+      this.applicationErrorHandler(e);
+    });
+    return !this.isAnchorElement;
+  }
+  ngOnDestroy() {
+  }
+  applyAttributeValue(attrName, attrValue) {
+    const renderer = this.renderer;
+    const nativeElement = this.el.nativeElement;
+    if (attrValue !== null) {
+      renderer.setAttribute(nativeElement, attrName, attrValue);
+    } else {
+      renderer.removeAttribute(nativeElement, attrName);
+    }
+  }
+  _urlTree = computed(() => {
+    this.reactiveRouterState.path();
+    if (this._preserveFragment()) {
+      this.reactiveRouterState.fragment();
+    }
+    const shouldTrackParams = (handling) => handling === "preserve" || handling === "merge";
+    if (shouldTrackParams(this._queryParamsHandling()) || shouldTrackParams(this.options?.defaultQueryParamsHandling)) {
+      this.reactiveRouterState.queryParams();
+    }
+    const routerLinkInput = this.routerLinkInput();
+    if (routerLinkInput === null || !this.router.createUrlTree) {
+      return null;
+    } else if (isUrlTree(routerLinkInput)) {
+      return routerLinkInput;
+    }
+    return this.router.createUrlTree(routerLinkInput, {
+      relativeTo: this._relativeTo() !== void 0 ? this._relativeTo() : this.route,
+      queryParams: this._queryParams(),
+      fragment: this._fragment(),
+      queryParamsHandling: this._queryParamsHandling(),
+      preserveFragment: this._preserveFragment()
+    });
+  }, __spreadProps(__spreadValues({}, ngDevMode ? {
+    debugName: "_urlTree"
+  } : {}), {
+    equal: (a, b) => this.computeHref(a) === this.computeHref(b)
+  }));
+  get urlTree() {
+    return untracked2(this._urlTree);
+  }
+  computeHref(urlTree) {
+    return urlTree !== null && this.locationStrategy ? this.locationStrategy?.prepareExternalUrl(this.router.serializeUrl(urlTree)) ?? "" : null;
+  }
+  static \u0275fac = function RouterLink_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _RouterLink)(\u0275\u0275directiveInject(Router), \u0275\u0275directiveInject(ActivatedRoute), \u0275\u0275injectAttribute("tabindex"), \u0275\u0275directiveInject(Renderer2), \u0275\u0275directiveInject(ElementRef), \u0275\u0275directiveInject(LocationStrategy));
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _RouterLink,
+    selectors: [["", "routerLink", ""]],
+    hostVars: 2,
+    hostBindings: function RouterLink_HostBindings(rf, ctx) {
+      if (rf & 1) {
+        \u0275\u0275listener("click", function RouterLink_click_HostBindingHandler($event) {
+          return ctx.onClick($event.button, $event.ctrlKey, $event.shiftKey, $event.altKey, $event.metaKey);
+        });
+      }
+      if (rf & 2) {
+        \u0275\u0275attribute("href", ctx.reactiveHref(), \u0275\u0275sanitizeUrlOrResourceUrl)("target", ctx._target());
+      }
+    },
+    inputs: {
+      target: "target",
+      queryParams: "queryParams",
+      fragment: "fragment",
+      queryParamsHandling: "queryParamsHandling",
+      state: "state",
+      info: "info",
+      relativeTo: "relativeTo",
+      preserveFragment: [2, "preserveFragment", "preserveFragment", booleanAttribute],
+      skipLocationChange: [2, "skipLocationChange", "skipLocationChange", booleanAttribute],
+      replaceUrl: [2, "replaceUrl", "replaceUrl", booleanAttribute],
+      routerLink: "routerLink"
+    },
+    features: [\u0275\u0275NgOnChangesFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(RouterLink, [{
+    type: Directive,
+    args: [{
+      selector: "[routerLink]",
+      host: {
+        "[attr.href]": "reactiveHref()",
+        "[attr.target]": "_target()"
+      }
+    }]
+  }], () => [{
+    type: Router
+  }, {
+    type: ActivatedRoute
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Attribute,
+      args: ["tabindex"]
+    }]
+  }, {
+    type: Renderer2
+  }, {
+    type: ElementRef
+  }, {
+    type: LocationStrategy
+  }], {
+    target: [{
+      type: Input
+    }],
+    queryParams: [{
+      type: Input
+    }],
+    fragment: [{
+      type: Input
+    }],
+    queryParamsHandling: [{
+      type: Input
+    }],
+    state: [{
+      type: Input
+    }],
+    info: [{
+      type: Input
+    }],
+    relativeTo: [{
+      type: Input
+    }],
+    preserveFragment: [{
+      type: Input,
+      args: [{
+        transform: booleanAttribute
+      }]
+    }],
+    skipLocationChange: [{
+      type: Input,
+      args: [{
+        transform: booleanAttribute
+      }]
+    }],
+    replaceUrl: [{
+      type: Input,
+      args: [{
+        transform: booleanAttribute
+      }]
+    }],
+    routerLink: [{
+      type: Input
+    }],
+    onClick: [{
+      type: HostListener,
+      args: ["click", ["$event.button", "$event.ctrlKey", "$event.shiftKey", "$event.altKey", "$event.metaKey"]]
+    }]
+  });
+})();
+var RouterLinkActive = class _RouterLinkActive {
+  router;
+  element;
+  renderer;
+  cdr;
+  links;
+  classes = [];
+  routerEventsSubscription;
+  linkInputChangesSubscription;
+  _isActive = false;
+  get isActive() {
+    return this._isActive;
+  }
+  routerLinkActiveOptions = {
+    exact: false
+  };
+  ariaCurrentWhenActive;
+  isActiveChange = new EventEmitter();
+  link = inject2(RouterLink, {
+    optional: true
+  });
+  constructor(router, element, renderer, cdr) {
+    this.router = router;
+    this.element = element;
+    this.renderer = renderer;
+    this.cdr = cdr;
+    this.routerEventsSubscription = router.events.subscribe((s) => {
+      if (s instanceof NavigationEnd) {
+        this.update();
+      }
+    });
+  }
+  ngAfterContentInit() {
+    of(this.links.changes, of(null)).pipe(mergeAll()).subscribe((_) => {
+      this.update();
+      this.subscribeToEachLinkOnChanges();
+    });
+  }
+  subscribeToEachLinkOnChanges() {
+    this.linkInputChangesSubscription?.unsubscribe();
+    const allLinkChanges = [...this.links.toArray(), this.link].filter((link) => !!link).map((link) => link.onChanges);
+    this.linkInputChangesSubscription = from(allLinkChanges).pipe(mergeAll()).subscribe((link) => {
+      if (this._isActive !== this.isLinkActive(this.router)(link)) {
+        this.update();
+      }
+    });
+  }
+  set routerLinkActive(data) {
+    const classes = Array.isArray(data) ? data : data.split(" ");
+    this.classes = classes.filter((c) => !!c);
+  }
+  ngOnChanges(changes) {
+    this.update();
+  }
+  ngOnDestroy() {
+    this.routerEventsSubscription.unsubscribe();
+    this.linkInputChangesSubscription?.unsubscribe();
+  }
+  update() {
+    if (!this.links || !this.router.navigated) return;
+    queueMicrotask(() => {
+      const hasActiveLinks = this.hasActiveLinks();
+      this.classes.forEach((c) => {
+        if (hasActiveLinks) {
+          this.renderer.addClass(this.element.nativeElement, c);
+        } else {
+          this.renderer.removeClass(this.element.nativeElement, c);
+        }
+      });
+      if (hasActiveLinks && this.ariaCurrentWhenActive !== void 0) {
+        this.renderer.setAttribute(this.element.nativeElement, "aria-current", this.ariaCurrentWhenActive.toString());
+      } else {
+        this.renderer.removeAttribute(this.element.nativeElement, "aria-current");
+      }
+      if (this._isActive !== hasActiveLinks) {
+        this._isActive = hasActiveLinks;
+        this.cdr.markForCheck();
+        this.isActiveChange.emit(hasActiveLinks);
+      }
+    });
+  }
+  isLinkActive(router) {
+    const options = isActiveMatchOptions(this.routerLinkActiveOptions) ? this.routerLinkActiveOptions : this.routerLinkActiveOptions.exact ?? false ? __spreadValues({}, exactMatchOptions) : __spreadValues({}, subsetMatchOptions);
+    return (link) => {
+      const urlTree = link.urlTree;
+      return urlTree ? untracked2(isActive(urlTree, router, options)) : false;
+    };
+  }
+  hasActiveLinks() {
+    const isActiveCheckFn = this.isLinkActive(this.router);
+    return this.link && isActiveCheckFn(this.link) || this.links.some(isActiveCheckFn);
+  }
+  static \u0275fac = function RouterLinkActive_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _RouterLinkActive)(\u0275\u0275directiveInject(Router), \u0275\u0275directiveInject(ElementRef), \u0275\u0275directiveInject(Renderer2), \u0275\u0275directiveInject(ChangeDetectorRef));
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _RouterLinkActive,
+    selectors: [["", "routerLinkActive", ""]],
+    contentQueries: function RouterLinkActive_ContentQueries(rf, ctx, dirIndex) {
+      if (rf & 1) {
+        \u0275\u0275contentQuery(dirIndex, RouterLink, 5);
+      }
+      if (rf & 2) {
+        let _t;
+        \u0275\u0275queryRefresh(_t = \u0275\u0275loadQuery()) && (ctx.links = _t);
+      }
+    },
+    inputs: {
+      routerLinkActiveOptions: "routerLinkActiveOptions",
+      ariaCurrentWhenActive: "ariaCurrentWhenActive",
+      routerLinkActive: "routerLinkActive"
+    },
+    outputs: {
+      isActiveChange: "isActiveChange"
+    },
+    exportAs: ["routerLinkActive"],
+    features: [\u0275\u0275NgOnChangesFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(RouterLinkActive, [{
+    type: Directive,
+    args: [{
+      selector: "[routerLinkActive]",
+      exportAs: "routerLinkActive"
+    }]
+  }], () => [{
+    type: Router
+  }, {
+    type: ElementRef
+  }, {
+    type: Renderer2
+  }, {
+    type: ChangeDetectorRef
+  }], {
+    links: [{
+      type: ContentChildren,
+      args: [RouterLink, {
+        descendants: true
+      }]
+    }],
+    routerLinkActiveOptions: [{
+      type: Input
+    }],
+    ariaCurrentWhenActive: [{
+      type: Input
+    }],
+    isActiveChange: [{
+      type: Output
+    }],
+    routerLinkActive: [{
+      type: Input
+    }]
+  });
+})();
+function isActiveMatchOptions(options) {
+  const o = options;
+  return !!(o.paths || o.matrixParams || o.queryParams || o.fragment);
+}
+var PreloadingStrategy = class {
+};
+var PreloadAllModules = class _PreloadAllModules {
+  preload(route, fn) {
+    return fn().pipe(catchError(() => of(null)));
+  }
+  static \u0275fac = function PreloadAllModules_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _PreloadAllModules)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _PreloadAllModules,
+    factory: _PreloadAllModules.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(PreloadAllModules, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], null, null);
+})();
+var NoPreloading = class _NoPreloading {
+  preload(route, fn) {
+    return of(null);
+  }
+  static \u0275fac = function NoPreloading_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _NoPreloading)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _NoPreloading,
+    factory: _NoPreloading.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NoPreloading, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], null, null);
+})();
+var RouterPreloader = class _RouterPreloader {
+  router;
+  injector;
+  preloadingStrategy;
+  loader;
+  subscription;
+  constructor(router, injector, preloadingStrategy, loader) {
+    this.router = router;
+    this.injector = injector;
+    this.preloadingStrategy = preloadingStrategy;
+    this.loader = loader;
+  }
+  setUpPreloading() {
+    this.subscription = this.router.events.pipe(filter((e) => e instanceof NavigationEnd), concatMap(() => this.preload())).subscribe(() => {
+    });
+  }
+  preload() {
+    return this.processRoutes(this.injector, this.router.config);
+  }
+  ngOnDestroy() {
+    this.subscription?.unsubscribe();
+  }
+  processRoutes(injector, routes2) {
+    const res = [];
+    for (const route of routes2) {
+      if (route.providers && !route._injector) {
+        route._injector = createEnvironmentInjector(route.providers, injector, typeof ngDevMode === "undefined" || ngDevMode ? `Route: ${route.path}` : "");
+      }
+      const injectorForCurrentRoute = route._injector ?? injector;
+      if (route._loadedNgModuleFactory && !route._loadedInjector) {
+        route._loadedInjector = route._loadedNgModuleFactory.create(injectorForCurrentRoute).injector;
+      }
+      const injectorForChildren = route._loadedInjector ?? injectorForCurrentRoute;
+      if (route.loadChildren && !route._loadedRoutes && route.canLoad === void 0 || route.loadComponent && !route._loadedComponent) {
+        res.push(this.preloadConfig(injectorForCurrentRoute, route));
+      }
+      if (route.children || route._loadedRoutes) {
+        res.push(this.processRoutes(injectorForChildren, route.children ?? route._loadedRoutes));
+      }
+    }
+    return from(res).pipe(mergeAll());
+  }
+  preloadConfig(injector, route) {
+    return this.preloadingStrategy.preload(route, () => {
+      if (injector.destroyed) {
+        return of(null);
+      }
+      let loadedChildren$;
+      if (route.loadChildren && route.canLoad === void 0) {
+        loadedChildren$ = from(this.loader.loadChildren(injector, route));
+      } else {
+        loadedChildren$ = of(null);
+      }
+      const recursiveLoadChildren$ = loadedChildren$.pipe(mergeMap((config2) => {
+        if (config2 === null) {
+          return of(void 0);
+        }
+        route._loadedRoutes = config2.routes;
+        route._loadedInjector = config2.injector;
+        route._loadedNgModuleFactory = config2.factory;
+        return this.processRoutes(config2.injector ?? injector, config2.routes);
+      }));
+      if (route.loadComponent && !route._loadedComponent) {
+        const loadComponent$ = this.loader.loadComponent(injector, route);
+        return from([recursiveLoadChildren$, loadComponent$]).pipe(mergeAll());
+      } else {
+        return recursiveLoadChildren$;
+      }
+    });
+  }
+  static \u0275fac = function RouterPreloader_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _RouterPreloader)(\u0275\u0275inject(Router), \u0275\u0275inject(EnvironmentInjector), \u0275\u0275inject(PreloadingStrategy), \u0275\u0275inject(RouterConfigLoader));
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _RouterPreloader,
+    factory: _RouterPreloader.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(RouterPreloader, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], () => [{
+    type: Router
+  }, {
+    type: EnvironmentInjector
+  }, {
+    type: PreloadingStrategy
+  }, {
+    type: RouterConfigLoader
+  }], null);
+})();
+var ROUTER_SCROLLER = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "Router Scroller" : "");
+var RouterScroller = class _RouterScroller {
+  options;
+  routerEventsSubscription;
+  scrollEventsSubscription;
+  lastId = 0;
+  lastSource = IMPERATIVE_NAVIGATION;
+  restoredId = 0;
+  store = {};
+  isHydrating = inject2(IS_HYDRATION_DOM_REUSE_ENABLED, {
+    optional: true
+  }) ?? false;
+  urlSerializer = inject2(UrlSerializer);
+  zone = inject2(NgZone);
+  viewportScroller = inject2(ViewportScroller);
+  transitions = inject2(NavigationTransitions);
+  constructor(options) {
+    this.options = options;
+    this.options.scrollPositionRestoration ||= "disabled";
+    this.options.anchorScrolling ||= "disabled";
+    if (this.isHydrating) {
+      inject2(ApplicationRef).whenStable().then(() => {
+        this.isHydrating = false;
+      });
+    }
+  }
+  init() {
+    if (this.options.scrollPositionRestoration !== "disabled") {
+      this.viewportScroller.setHistoryScrollRestoration("manual");
+    }
+    this.routerEventsSubscription = this.createScrollEvents();
+    this.scrollEventsSubscription = this.consumeScrollEvents();
+  }
+  createScrollEvents() {
+    return this.transitions.events.subscribe((e) => {
+      if (e instanceof NavigationStart) {
+        this.store[this.lastId] = this.viewportScroller.getScrollPosition();
+        this.lastSource = e.navigationTrigger;
+        this.restoredId = e.restoredState ? e.restoredState.navigationId : 0;
+      } else if (e instanceof NavigationEnd) {
+        this.lastId = e.id;
+        this.scheduleScrollEvent(e, this.urlSerializer.parse(e.urlAfterRedirects).fragment);
+      } else if (e instanceof NavigationSkipped && e.code === NavigationSkippedCode.IgnoredSameUrlNavigation) {
+        this.lastSource = void 0;
+        this.restoredId = 0;
+        this.scheduleScrollEvent(e, this.urlSerializer.parse(e.url).fragment);
+      }
+    });
+  }
+  consumeScrollEvents() {
+    return this.transitions.events.subscribe((e) => {
+      if (!(e instanceof Scroll) || e.scrollBehavior === "manual") return;
+      const instantScroll = {
+        behavior: "instant"
+      };
+      if (e.position) {
+        if (this.options.scrollPositionRestoration === "top") {
+          this.viewportScroller.scrollToPosition([0, 0], instantScroll);
+        } else if (this.options.scrollPositionRestoration === "enabled") {
+          this.viewportScroller.scrollToPosition(e.position, instantScroll);
+        }
+      } else {
+        if (e.anchor && this.options.anchorScrolling === "enabled") {
+          this.viewportScroller.scrollToAnchor(e.anchor);
+        } else if (this.options.scrollPositionRestoration !== "disabled") {
+          this.viewportScroller.scrollToPosition([0, 0]);
+        }
+      }
+    });
+  }
+  scheduleScrollEvent(routerEvent, anchor) {
+    if (this.isHydrating) return;
+    const scroll = untracked2(this.transitions.currentNavigation)?.extras.scroll;
+    this.zone.runOutsideAngular(async () => {
+      await new Promise((resolve) => {
+        setTimeout(resolve);
+        if (typeof requestAnimationFrame !== "undefined") {
+          requestAnimationFrame(resolve);
+        }
+      });
+      this.zone.run(() => {
+        this.transitions.events.next(new Scroll(routerEvent, this.lastSource === "popstate" ? this.store[this.restoredId] : null, anchor, scroll));
+      });
+    });
+  }
+  ngOnDestroy() {
+    this.routerEventsSubscription?.unsubscribe();
+    this.scrollEventsSubscription?.unsubscribe();
+  }
+  static \u0275fac = function RouterScroller_Factory(__ngFactoryType__) {
+    \u0275\u0275invalidFactory();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _RouterScroller,
+    factory: _RouterScroller.\u0275fac
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(RouterScroller, [{
+    type: Injectable
+  }], () => [{
+    type: void 0
+  }], null);
+})();
+function getLoadedRoutes(route) {
+  return route._loadedRoutes;
+}
+function getRouterInstance(injector) {
+  return injector.get(Router, null, {
+    optional: true
+  });
+}
+function navigateByUrl(router, url) {
+  if (!(router instanceof Router)) {
+    throw new Error("The provided router is not an Angular Router.");
+  }
+  return router.navigateByUrl(url);
+}
+var NavigationStateManager = class _NavigationStateManager extends StateManager {
+  injector = inject2(EnvironmentInjector);
+  navigation = inject2(PlatformNavigation);
+  inMemoryScrollingEnabled = inject2(ROUTER_SCROLLER, {
+    optional: true
+  }) !== null;
+  base = new URL(inject2(PlatformLocation).href).origin;
+  appRootURL = new URL(this.location.prepareExternalUrl?.("/") ?? "/", this.base).href;
+  precommitHandlerSupported = inject2(PRECOMMIT_HANDLER_SUPPORTED);
+  activeHistoryEntry = this.navigation.currentEntry;
+  currentNavigation = {};
+  nonRouterCurrentEntryChangeSubject = new Subject();
+  nonRouterEntryChangeListener;
+  get registered() {
+    return this.nonRouterEntryChangeListener !== void 0 && !this.nonRouterEntryChangeListener.closed;
+  }
+  constructor() {
+    super();
+    const navigateListener = (event) => {
+      this.handleNavigate(event);
+    };
+    this.navigation.addEventListener("navigate", navigateListener);
+    inject2(DestroyRef).onDestroy(() => this.navigation.removeEventListener("navigate", navigateListener));
+  }
+  registerNonRouterCurrentEntryChangeListener(listener) {
+    this.activeHistoryEntry = this.navigation.currentEntry;
+    this.nonRouterEntryChangeListener = this.nonRouterCurrentEntryChangeSubject.subscribe(({
+      path,
+      state
+    }) => {
+      listener(path, state, "popstate", !this.precommitHandlerSupported ? {
+        replaceUrl: true
+      } : {});
+    });
+    return this.nonRouterEntryChangeListener;
+  }
+  async handleRouterEvent(e, transition) {
+    this.currentNavigation = __spreadProps(__spreadValues({}, this.currentNavigation), {
+      routerTransition: transition
+    });
+    if (e instanceof NavigationStart) {
+      this.updateStateMemento();
+      if (this.precommitHandlerSupported) {
+        this.maybeCreateNavigationForTransition(transition);
+      }
+    } else if (e instanceof NavigationSkipped) {
+      this.finishNavigation();
+      this.commitTransition(transition);
+    } else if (e instanceof BeforeRoutesRecognized) {
+      transition.routesRecognizeHandler.deferredHandle = new Promise(async (resolve) => {
+        if (this.urlUpdateStrategy === "eager") {
+          try {
+            this.maybeCreateNavigationForTransition(transition);
+            await this.currentNavigation.commitUrl?.();
+          } catch {
+            return;
+          }
+        }
+        resolve();
+      });
+    } else if (e instanceof BeforeActivateRoutes) {
+      transition.beforeActivateHandler.deferredHandle = new Promise(async (resolve) => {
+        if (this.urlUpdateStrategy === "deferred") {
+          try {
+            this.maybeCreateNavigationForTransition(transition);
+            await this.currentNavigation.commitUrl?.();
+          } catch {
+            return;
+          }
+        }
+        this.commitTransition(transition);
+        resolve();
+      });
+    } else if (e instanceof NavigationCancel || e instanceof NavigationError) {
+      const redirectingBeforeUrlCommit = e instanceof NavigationCancel && e.code === NavigationCancellationCode.Redirect && !!this.currentNavigation.commitUrl;
+      if (redirectingBeforeUrlCommit) {
+        return;
+      }
+      void this.cancel(transition, e);
+    } else if (e instanceof NavigationEnd) {
+      const {
+        resolveHandler,
+        removeAbortListener
+      } = this.currentNavigation;
+      this.currentNavigation = {};
+      removeAbortListener?.();
+      this.activeHistoryEntry = this.navigation.currentEntry;
+      afterNextRender({
+        read: () => resolveHandler?.()
+      }, {
+        injector: this.injector
+      });
+    }
+  }
+  maybeCreateNavigationForTransition(transition) {
+    const {
+      navigationEvent,
+      commitUrl
+    } = this.currentNavigation;
+    if (commitUrl || navigationEvent && navigationEvent.navigationType === "traverse" && this.eventAndRouterDestinationsMatch(navigationEvent, transition)) {
+      return;
+    }
+    this.currentNavigation.removeAbortListener?.();
+    const path = this.createBrowserPath(transition);
+    this.navigate(path, transition);
+  }
+  navigate(internalPath, transition) {
+    const path = transition.extras.skipLocationChange ? this.navigation.currentEntry.url : this.location.prepareExternalUrl(internalPath);
+    const state = __spreadValues(__spreadValues({}, transition.extras.state), this.generateNgRouterState(transition));
+    const info = {
+      \u0275routerInfo: {
+        intercept: true
+      }
+    };
+    if (!this.navigation.transition && this.currentNavigation.navigationEvent) {
+      transition.extras.replaceUrl = false;
+    }
+    const history = this.location.isCurrentPathEqualTo(path) || transition.extras.replaceUrl || transition.extras.skipLocationChange ? "replace" : "push";
+    handleResultRejections(this.navigation.navigate(path, {
+      state,
+      history,
+      info
+    }));
+  }
+  finishNavigation() {
+    this.currentNavigation.commitUrl?.();
+    this.currentNavigation?.resolveHandler?.();
+    this.currentNavigation = {};
+  }
+  async cancel(transition, cause) {
+    this.currentNavigation.rejectNavigateEvent?.();
+    const clearedState = {};
+    this.currentNavigation = clearedState;
+    if (isRedirectingEvent(cause)) {
+      return;
+    }
+    const isTraversalReset = this.canceledNavigationResolution === "computed" && this.navigation.currentEntry.key !== this.activeHistoryEntry.key;
+    this.resetInternalState(transition.finalUrl, isTraversalReset);
+    if (this.navigation.currentEntry.id === this.activeHistoryEntry.id) {
+      return;
+    }
+    if (cause instanceof NavigationCancel && cause.code === NavigationCancellationCode.Aborted) {
+      await Promise.resolve();
+      if (this.currentNavigation !== clearedState) {
+        return;
+      }
+    }
+    if (isTraversalReset) {
+      handleResultRejections(this.navigation.traverseTo(this.activeHistoryEntry.key, {
+        info: {
+          \u0275routerInfo: {
+            intercept: false
+          }
+        }
+      }));
+    } else {
+      const internalPath = this.urlSerializer.serialize(this.getCurrentUrlTree());
+      const pathOrUrl = this.location.prepareExternalUrl(internalPath);
+      handleResultRejections(this.navigation.navigate(pathOrUrl, {
+        state: this.activeHistoryEntry.getState(),
+        history: "replace",
+        info: {
+          \u0275routerInfo: {
+            intercept: false
+          }
+        }
+      }));
+    }
+  }
+  resetInternalState(finalUrl, traversalReset) {
+    this.routerState = this.stateMemento.routerState;
+    this.currentUrlTree = this.stateMemento.currentUrlTree;
+    this.rawUrlTree = traversalReset ? this.stateMemento.rawUrlTree : this.urlHandlingStrategy.merge(this.currentUrlTree, finalUrl ?? this.rawUrlTree);
+  }
+  handleNavigate(event) {
+    if (!event.canIntercept || event.navigationType === "reload") {
+      return;
+    }
+    const routerInfo = event?.info?.\u0275routerInfo;
+    if (routerInfo && !routerInfo.intercept) {
+      return;
+    }
+    const isTriggeredByRouterTransition = !!routerInfo;
+    if (!isTriggeredByRouterTransition) {
+      this.currentNavigation.routerTransition?.abort();
+      if (!this.registered) {
+        this.finishNavigation();
+        return;
+      }
+    }
+    this.currentNavigation = __spreadValues({}, this.currentNavigation);
+    this.currentNavigation.navigationEvent = event;
+    const abortHandler = () => {
+      this.currentNavigation.routerTransition?.abort();
+    };
+    event.signal.addEventListener("abort", abortHandler);
+    this.currentNavigation.removeAbortListener = () => event.signal.removeEventListener("abort", abortHandler);
+    let scroll = this.inMemoryScrollingEnabled ? "manual" : this.currentNavigation.routerTransition?.extras.scroll ?? "after-transition";
+    const interceptOptions = {
+      scroll
+    };
+    const {
+      promise: handlerPromise,
+      resolve: resolveHandler,
+      reject: rejectHandler
+    } = promiseWithResolvers();
+    const {
+      promise: precommitHandlerPromise,
+      resolve: resolvePrecommitHandler,
+      reject: rejectPrecommitHandler
+    } = promiseWithResolvers();
+    this.currentNavigation.rejectNavigateEvent = () => {
+      event.signal.removeEventListener("abort", abortHandler);
+      rejectPrecommitHandler();
+      rejectHandler();
+    };
+    this.currentNavigation.resolveHandler = () => {
+      this.currentNavigation.removeAbortListener?.();
+      resolveHandler();
+    };
+    handlerPromise.catch(() => {
+    });
+    precommitHandlerPromise.catch(() => {
+    });
+    interceptOptions.handler = () => handlerPromise;
+    if (this.deferredCommitSupported(event)) {
+      const redirect = new Promise((resolve) => {
+        interceptOptions.precommitHandler = (controller) => {
+          if (this.navigation.transition?.navigationType === "traverse") {
+            resolve(() => {
+            });
+          } else {
+            resolve(controller.redirect.bind(controller));
+          }
+          return precommitHandlerPromise;
+        };
+      });
+      this.currentNavigation.commitUrl = async () => {
+        this.currentNavigation.commitUrl = void 0;
+        const transition = this.currentNavigation.routerTransition;
+        if (transition && !transition.extras.skipLocationChange) {
+          const internalPath = this.createBrowserPath(transition);
+          const history = this.location.isCurrentPathEqualTo(internalPath) || !!transition.extras.replaceUrl ? "replace" : "push";
+          const state = __spreadValues(__spreadValues({}, transition.extras.state), this.generateNgRouterState(transition));
+          const pathOrUrl = this.location.prepareExternalUrl(internalPath);
+          (await redirect)(pathOrUrl, {
+            state,
+            history
+          });
+        }
+        resolvePrecommitHandler();
+        return await this.navigation.transition?.committed;
+      };
+    }
+    event.intercept(interceptOptions);
+    if (!isTriggeredByRouterTransition) {
+      this.handleNavigateEventTriggeredOutsideRouterAPIs(event);
+    }
+  }
+  handleNavigateEventTriggeredOutsideRouterAPIs(event) {
+    const path = event.destination.url.substring(this.appRootURL.length - 1);
+    const state = event.destination.getState();
+    this.nonRouterCurrentEntryChangeSubject.next({
+      path,
+      state
+    });
+  }
+  eventAndRouterDestinationsMatch(navigateEvent, transition) {
+    const internalPath = this.createBrowserPath(transition);
+    const eventDestination = new URL(navigateEvent.destination.url);
+    const routerDestination = this.location.prepareExternalUrl(internalPath);
+    return new URL(routerDestination, eventDestination.origin).href === eventDestination.href;
+  }
+  generateNgRouterState(transition) {
+    return __spreadProps(__spreadValues({}, this.routerUrlState(transition)), {
+      navigationId: transition.id
+    });
+  }
+  deferredCommitSupported(event) {
+    return this.precommitHandlerSupported && event.cancelable;
+  }
+  static \u0275fac = function NavigationStateManager_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _NavigationStateManager)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _NavigationStateManager,
+    factory: _NavigationStateManager.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NavigationStateManager, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], () => [], null);
+})();
+function handleResultRejections(result) {
+  result.finished?.catch(() => {
+  });
+  result.committed?.catch(() => {
+  });
+  return result;
+}
+function provideRouter(routes2, ...features) {
+  if (typeof ngDevMode === "undefined" || ngDevMode) {
+    publishExternalGlobalUtil("\u0275getLoadedRoutes", getLoadedRoutes);
+    publishExternalGlobalUtil("\u0275getRouterInstance", getRouterInstance);
+    publishExternalGlobalUtil("\u0275navigateByUrl", navigateByUrl);
+  }
+  return makeEnvironmentProviders([{
+    provide: ROUTES,
+    multi: true,
+    useValue: routes2
+  }, typeof ngDevMode === "undefined" || ngDevMode ? {
+    provide: ROUTER_IS_PROVIDED,
+    useValue: true
+  } : [], {
+    provide: ActivatedRoute,
+    useFactory: rootRoute
+  }, {
+    provide: APP_BOOTSTRAP_LISTENER,
+    multi: true,
+    useFactory: getBootstrapListener
+  }, features.map((feature) => feature.\u0275providers)]);
+}
+function rootRoute() {
+  return inject2(Router).routerState.root;
+}
+function routerFeature(kind, providers) {
+  return {
+    \u0275kind: kind,
+    \u0275providers: providers
+  };
+}
+var ROUTER_IS_PROVIDED = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "Router is provided" : "", {
+  factory: () => false
+});
+function getBootstrapListener() {
+  const injector = inject2(Injector);
+  return (bootstrappedComponentRef) => {
+    const ref = injector.get(ApplicationRef);
+    if (bootstrappedComponentRef !== ref.components[0]) {
+      return;
+    }
+    const router = injector.get(Router);
+    const bootstrapDone = injector.get(BOOTSTRAP_DONE);
+    if (injector.get(INITIAL_NAVIGATION) === 1) {
+      router.initialNavigation();
+    }
+    injector.get(ROUTER_PRELOADER, null, {
+      optional: true
+    })?.setUpPreloading();
+    injector.get(ROUTER_SCROLLER, null, {
+      optional: true
+    })?.init();
+    router.resetRootComponentType(ref.componentTypes[0]);
+    if (!bootstrapDone.closed) {
+      bootstrapDone.next();
+      bootstrapDone.complete();
+      bootstrapDone.unsubscribe();
+    }
+  };
+}
+var BOOTSTRAP_DONE = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "bootstrap done indicator" : "", {
+  factory: () => {
+    return new Subject();
+  }
+});
+var INITIAL_NAVIGATION = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "initial navigation" : "", {
+  factory: () => 1
+});
+function withEnabledBlockingInitialNavigation() {
+  const providers = [{
+    provide: IS_ENABLED_BLOCKING_INITIAL_NAVIGATION,
+    useValue: true
+  }, {
+    provide: INITIAL_NAVIGATION,
+    useValue: 0
+  }, provideAppInitializer(() => {
+    const injector = inject2(Injector);
+    const locationInitialized = injector.get(LOCATION_INITIALIZED, Promise.resolve());
+    return locationInitialized.then(() => {
+      return new Promise((resolve) => {
+        const router = injector.get(Router);
+        const bootstrapDone = injector.get(BOOTSTRAP_DONE);
+        afterNextNavigation(router, () => {
+          resolve(true);
+        });
+        injector.get(NavigationTransitions).afterPreactivation = () => {
+          resolve(true);
+          return bootstrapDone.closed ? of(void 0) : bootstrapDone;
+        };
+        router.initialNavigation();
+      });
+    });
+  })];
+  return routerFeature(2, providers);
+}
+function withDisabledInitialNavigation() {
+  const providers = [provideAppInitializer(() => {
+    inject2(Router).setUpLocationChangeListener();
+  }), {
+    provide: INITIAL_NAVIGATION,
+    useValue: 2
+  }];
+  return routerFeature(3, providers);
+}
+function withDebugTracing() {
+  let providers = [];
+  if (typeof ngDevMode === "undefined" || ngDevMode) {
+    providers = [{
+      provide: ENVIRONMENT_INITIALIZER,
+      multi: true,
+      useFactory: () => {
+        const router = inject2(Router);
+        return () => router.events.subscribe((e) => {
+          console.group?.(`Router Event: ${e.constructor.name}`);
+          console.log(stringifyEvent(e));
+          console.log(e);
+          console.groupEnd?.();
+        });
+      }
+    }];
+  } else {
+    providers = [];
+  }
+  return routerFeature(1, providers);
+}
+var ROUTER_PRELOADER = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "router preloader" : "");
+function withPreloading(preloadingStrategy) {
+  const providers = [{
+    provide: ROUTER_PRELOADER,
+    useExisting: RouterPreloader
+  }, {
+    provide: PreloadingStrategy,
+    useExisting: preloadingStrategy
+  }];
+  return routerFeature(0, providers);
+}
+function withComponentInputBinding() {
+  const providers = [RoutedComponentInputBinder, {
+    provide: INPUT_BINDER,
+    useExisting: RoutedComponentInputBinder
+  }];
+  return routerFeature(8, providers);
+}
+function withViewTransitions(options) {
+  performanceMarkFeature("NgRouterViewTransitions");
+  const providers = [{
+    provide: CREATE_VIEW_TRANSITION,
+    useValue: createViewTransition
+  }, {
+    provide: VIEW_TRANSITION_OPTIONS,
+    useValue: __spreadValues({
+      skipNextTransition: !!options?.skipInitialTransition
+    }, options)
+  }];
+  return routerFeature(9, providers);
+}
+var ROUTER_DIRECTIVES = [RouterOutlet, RouterLink, RouterLinkActive, \u0275EmptyOutletComponent];
+var ROUTER_FORROOT_GUARD = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "router duplicate forRoot guard" : "");
+var ROUTER_PROVIDERS = [Location, {
+  provide: UrlSerializer,
+  useClass: DefaultUrlSerializer
+}, Router, ChildrenOutletContexts, {
+  provide: ActivatedRoute,
+  useFactory: rootRoute
+}, RouterConfigLoader, typeof ngDevMode === "undefined" || ngDevMode ? {
+  provide: ROUTER_IS_PROVIDED,
+  useValue: true
+} : []];
+var RouterModule = class _RouterModule {
+  constructor() {
+    if (typeof ngDevMode === "undefined" || ngDevMode) {
+      inject2(ROUTER_FORROOT_GUARD, {
+        optional: true
+      });
+    }
+  }
+  static forRoot(routes2, config2) {
+    return {
+      ngModule: _RouterModule,
+      providers: [ROUTER_PROVIDERS, typeof ngDevMode === "undefined" || ngDevMode ? config2?.enableTracing ? withDebugTracing().\u0275providers : [] : [], {
+        provide: ROUTES,
+        multi: true,
+        useValue: routes2
+      }, typeof ngDevMode === "undefined" || ngDevMode ? {
+        provide: ROUTER_FORROOT_GUARD,
+        useFactory: provideForRootGuard
+      } : [], config2?.errorHandler ? {
+        provide: NAVIGATION_ERROR_HANDLER,
+        useValue: config2.errorHandler
+      } : [], {
+        provide: ROUTER_CONFIGURATION,
+        useValue: config2 ? config2 : {}
+      }, config2?.useHash ? provideHashLocationStrategy() : providePathLocationStrategy(), provideRouterScroller(), config2?.preloadingStrategy ? withPreloading(config2.preloadingStrategy).\u0275providers : [], config2?.initialNavigation ? provideInitialNavigation(config2) : [], config2?.bindToComponentInputs ? withComponentInputBinding().\u0275providers : [], config2?.enableViewTransitions ? withViewTransitions().\u0275providers : [], provideRouterInitializer()]
+    };
+  }
+  static forChild(routes2) {
+    return {
+      ngModule: _RouterModule,
+      providers: [{
+        provide: ROUTES,
+        multi: true,
+        useValue: routes2
+      }]
+    };
+  }
+  static \u0275fac = function RouterModule_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _RouterModule)();
+  };
+  static \u0275mod = /* @__PURE__ */ \u0275\u0275defineNgModule({
+    type: _RouterModule,
+    imports: [RouterOutlet, RouterLink, RouterLinkActive, \u0275EmptyOutletComponent],
+    exports: [RouterOutlet, RouterLink, RouterLinkActive, \u0275EmptyOutletComponent]
+  });
+  static \u0275inj = /* @__PURE__ */ \u0275\u0275defineInjector({});
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(RouterModule, [{
+    type: NgModule,
+    args: [{
+      imports: ROUTER_DIRECTIVES,
+      exports: ROUTER_DIRECTIVES
+    }]
+  }], () => [], null);
+})();
+function provideRouterScroller() {
+  return {
+    provide: ROUTER_SCROLLER,
+    useFactory: () => {
+      const viewportScroller = inject2(ViewportScroller);
+      const config2 = inject2(ROUTER_CONFIGURATION);
+      if (config2.scrollOffset) {
+        viewportScroller.setOffset(config2.scrollOffset);
+      }
+      return new RouterScroller(config2);
+    }
+  };
+}
+function provideHashLocationStrategy() {
+  return {
+    provide: LocationStrategy,
+    useClass: HashLocationStrategy
+  };
+}
+function providePathLocationStrategy() {
+  return {
+    provide: LocationStrategy,
+    useClass: PathLocationStrategy
+  };
+}
+function provideForRootGuard() {
+  const router = inject2(Router, {
+    optional: true,
+    skipSelf: true
+  });
+  if (router) {
+    throw new RuntimeError(4007, `The Router was provided more than once. This can happen if 'forRoot' is used outside of the root injector. Lazy loaded modules should use RouterModule.forChild() instead.`);
+  }
+  return "guarded";
+}
+function provideInitialNavigation(config2) {
+  return [config2.initialNavigation === "disabled" ? withDisabledInitialNavigation().\u0275providers : [], config2.initialNavigation === "enabledBlocking" ? withEnabledBlockingInitialNavigation().\u0275providers : []];
+}
+var ROUTER_INITIALIZER = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "Router Initializer" : "");
+function provideRouterInitializer() {
+  return [{
+    provide: ROUTER_INITIALIZER,
+    useFactory: getBootstrapListener
+  }, {
+    provide: APP_BOOTSTRAP_LISTENER,
+    multi: true,
+    useExisting: ROUTER_INITIALIZER
+  }];
+}
+
+// node_modules/@angular/router/fesm2022/router.mjs
+/**
+ * @license Angular v21.2.17
+ * (c) 2010-2026 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+
+// node_modules/@angular/forms/fesm2022/forms.mjs
+/**
+ * @license Angular v21.2.17
+ * (c) 2010-2026 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+var BaseControlValueAccessor = class _BaseControlValueAccessor {
+  _renderer;
+  _elementRef;
+  onChange = (_) => {
+  };
+  onTouched = () => {
+  };
+  constructor(_renderer, _elementRef) {
+    this._renderer = _renderer;
+    this._elementRef = _elementRef;
+  }
+  setProperty(key, value) {
+    this._renderer.setProperty(this._elementRef.nativeElement, key, value);
+  }
+  registerOnTouched(fn) {
+    this.onTouched = fn;
+  }
+  registerOnChange(fn) {
+    this.onChange = fn;
+  }
+  setDisabledState(isDisabled) {
+    this.setProperty("disabled", isDisabled);
+  }
+  static \u0275fac = function BaseControlValueAccessor_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _BaseControlValueAccessor)(\u0275\u0275directiveInject(Renderer2), \u0275\u0275directiveInject(ElementRef));
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _BaseControlValueAccessor
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(BaseControlValueAccessor, [{
+    type: Directive
+  }], () => [{
+    type: Renderer2
+  }, {
+    type: ElementRef
+  }], null);
+})();
+var BuiltInControlValueAccessor = class _BuiltInControlValueAccessor extends BaseControlValueAccessor {
+  static \u0275fac = /* @__PURE__ */ (() => {
+    let \u0275BuiltInControlValueAccessor_BaseFactory;
+    return function BuiltInControlValueAccessor_Factory(__ngFactoryType__) {
+      return (\u0275BuiltInControlValueAccessor_BaseFactory || (\u0275BuiltInControlValueAccessor_BaseFactory = \u0275\u0275getInheritedFactory(_BuiltInControlValueAccessor)))(__ngFactoryType__ || _BuiltInControlValueAccessor);
+    };
+  })();
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _BuiltInControlValueAccessor,
+    features: [\u0275\u0275InheritDefinitionFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(BuiltInControlValueAccessor, [{
+    type: Directive
+  }], null, null);
+})();
+var NG_VALUE_ACCESSOR = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "NgValueAccessor" : "");
+var CHECKBOX_VALUE_ACCESSOR = {
+  provide: NG_VALUE_ACCESSOR,
+  useExisting: forwardRef(() => CheckboxControlValueAccessor),
+  multi: true
+};
+var CheckboxControlValueAccessor = class _CheckboxControlValueAccessor extends BuiltInControlValueAccessor {
+  writeValue(value) {
+    this.setProperty("checked", value);
+  }
+  static \u0275fac = /* @__PURE__ */ (() => {
+    let \u0275CheckboxControlValueAccessor_BaseFactory;
+    return function CheckboxControlValueAccessor_Factory(__ngFactoryType__) {
+      return (\u0275CheckboxControlValueAccessor_BaseFactory || (\u0275CheckboxControlValueAccessor_BaseFactory = \u0275\u0275getInheritedFactory(_CheckboxControlValueAccessor)))(__ngFactoryType__ || _CheckboxControlValueAccessor);
+    };
+  })();
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _CheckboxControlValueAccessor,
+    selectors: [["input", "type", "checkbox", "formControlName", ""], ["input", "type", "checkbox", "formControl", ""], ["input", "type", "checkbox", "ngModel", ""]],
+    hostBindings: function CheckboxControlValueAccessor_HostBindings(rf, ctx) {
+      if (rf & 1) {
+        \u0275\u0275listener("change", function CheckboxControlValueAccessor_change_HostBindingHandler($event) {
+          return ctx.onChange($event.target.checked);
+        })("blur", function CheckboxControlValueAccessor_blur_HostBindingHandler() {
+          return ctx.onTouched();
+        });
+      }
+    },
+    standalone: false,
+    features: [\u0275\u0275ProvidersFeature([CHECKBOX_VALUE_ACCESSOR]), \u0275\u0275InheritDefinitionFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(CheckboxControlValueAccessor, [{
+    type: Directive,
+    args: [{
+      selector: "input[type=checkbox][formControlName],input[type=checkbox][formControl],input[type=checkbox][ngModel]",
+      host: {
+        "(change)": "onChange($any($event.target).checked)",
+        "(blur)": "onTouched()"
+      },
+      providers: [CHECKBOX_VALUE_ACCESSOR],
+      standalone: false
+    }]
+  }], null, null);
+})();
+var DEFAULT_VALUE_ACCESSOR = {
+  provide: NG_VALUE_ACCESSOR,
+  useExisting: forwardRef(() => DefaultValueAccessor),
+  multi: true
+};
+function _isAndroid() {
+  const userAgent = getDOM() ? getDOM().getUserAgent() : "";
+  return /android (\d+)/.test(userAgent.toLowerCase());
+}
+var COMPOSITION_BUFFER_MODE = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "CompositionEventMode" : "");
+var DefaultValueAccessor = class _DefaultValueAccessor extends BaseControlValueAccessor {
+  _compositionMode;
+  _composing = false;
+  constructor(renderer, elementRef, _compositionMode) {
+    super(renderer, elementRef);
+    this._compositionMode = _compositionMode;
+    if (this._compositionMode == null) {
+      this._compositionMode = !_isAndroid();
+    }
+  }
+  writeValue(value) {
+    const normalizedValue = value == null ? "" : value;
+    this.setProperty("value", normalizedValue);
+  }
+  _handleInput(value) {
+    if (!this._compositionMode || this._compositionMode && !this._composing) {
+      this.onChange(value);
+    }
+  }
+  _compositionStart() {
+    this._composing = true;
+  }
+  _compositionEnd(value) {
+    this._composing = false;
+    this._compositionMode && this.onChange(value);
+  }
+  static \u0275fac = function DefaultValueAccessor_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _DefaultValueAccessor)(\u0275\u0275directiveInject(Renderer2), \u0275\u0275directiveInject(ElementRef), \u0275\u0275directiveInject(COMPOSITION_BUFFER_MODE, 8));
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _DefaultValueAccessor,
+    selectors: [["input", "formControlName", "", 3, "type", "checkbox"], ["textarea", "formControlName", ""], ["input", "formControl", "", 3, "type", "checkbox"], ["textarea", "formControl", ""], ["input", "ngModel", "", 3, "type", "checkbox"], ["textarea", "ngModel", ""], ["", "ngDefaultControl", ""]],
+    hostBindings: function DefaultValueAccessor_HostBindings(rf, ctx) {
+      if (rf & 1) {
+        \u0275\u0275listener("input", function DefaultValueAccessor_input_HostBindingHandler($event) {
+          return ctx._handleInput($event.target.value);
+        })("blur", function DefaultValueAccessor_blur_HostBindingHandler() {
+          return ctx.onTouched();
+        })("compositionstart", function DefaultValueAccessor_compositionstart_HostBindingHandler() {
+          return ctx._compositionStart();
+        })("compositionend", function DefaultValueAccessor_compositionend_HostBindingHandler($event) {
+          return ctx._compositionEnd($event.target.value);
+        });
+      }
+    },
+    standalone: false,
+    features: [\u0275\u0275ProvidersFeature([DEFAULT_VALUE_ACCESSOR]), \u0275\u0275InheritDefinitionFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DefaultValueAccessor, [{
+    type: Directive,
+    args: [{
+      selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]",
+      host: {
+        "(input)": "_handleInput($any($event.target).value)",
+        "(blur)": "onTouched()",
+        "(compositionstart)": "_compositionStart()",
+        "(compositionend)": "_compositionEnd($any($event.target).value)"
+      },
+      providers: [DEFAULT_VALUE_ACCESSOR],
+      standalone: false
+    }]
+  }], () => [{
+    type: Renderer2
+  }, {
+    type: ElementRef
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Inject,
+      args: [COMPOSITION_BUFFER_MODE]
+    }]
+  }], null);
+})();
+function isEmptyInputValue(value) {
+  return value == null || lengthOrSize(value) === 0;
+}
+function lengthOrSize(value) {
+  if (value == null) {
+    return null;
+  } else if (Array.isArray(value) || typeof value === "string") {
+    return value.length;
+  } else if (value instanceof Set) {
+    return value.size;
+  }
+  return null;
+}
+var NG_VALIDATORS = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "NgValidators" : "");
+var NG_ASYNC_VALIDATORS = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "NgAsyncValidators" : "");
+var EMAIL_REGEXP = /^(?=.{1,254}$)(?=.{1,64}@)[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+function minValidator(min) {
+  return (control) => {
+    if (control.value == null || min == null) {
+      return null;
+    }
+    const value = parseFloat(control.value);
+    return !isNaN(value) && value < min ? {
+      "min": {
+        "min": min,
+        "actual": control.value
+      }
+    } : null;
+  };
+}
+function maxValidator(max) {
+  return (control) => {
+    if (control.value == null || max == null) {
+      return null;
+    }
+    const value = parseFloat(control.value);
+    return !isNaN(value) && value > max ? {
+      "max": {
+        "max": max,
+        "actual": control.value
+      }
+    } : null;
+  };
+}
+function requiredValidator(control) {
+  return isEmptyInputValue(control.value) ? {
+    "required": true
+  } : null;
+}
+function requiredTrueValidator(control) {
+  return control.value === true ? null : {
+    "required": true
+  };
+}
+function emailValidator(control) {
+  if (isEmptyInputValue(control.value)) {
+    return null;
+  }
+  return EMAIL_REGEXP.test(control.value) ? null : {
+    "email": true
+  };
+}
+function minLengthValidator(minLength) {
+  return (control) => {
+    const length = control.value?.length ?? lengthOrSize(control.value);
+    if (length === null || length === 0) {
+      return null;
+    }
+    return length < minLength ? {
+      "minlength": {
+        "requiredLength": minLength,
+        "actualLength": length
+      }
+    } : null;
+  };
+}
+function maxLengthValidator(maxLength) {
+  return (control) => {
+    const length = control.value?.length ?? lengthOrSize(control.value);
+    if (length !== null && length > maxLength) {
+      return {
+        "maxlength": {
+          "requiredLength": maxLength,
+          "actualLength": length
+        }
+      };
+    }
+    return null;
+  };
+}
+function patternValidator(pattern) {
+  if (!pattern) return nullValidator;
+  let regex;
+  let regexStr;
+  if (typeof pattern === "string") {
+    regexStr = "";
+    if (pattern.charAt(0) !== "^") regexStr += "^";
+    regexStr += pattern;
+    if (pattern.charAt(pattern.length - 1) !== "$") regexStr += "$";
+    regex = new RegExp(regexStr);
+  } else {
+    regexStr = pattern.toString();
+    regex = pattern;
+  }
+  return (control) => {
+    if (isEmptyInputValue(control.value)) {
+      return null;
+    }
+    const value = control.value;
+    return regex.test(value) ? null : {
+      "pattern": {
+        "requiredPattern": regexStr,
+        "actualValue": value
+      }
+    };
+  };
+}
+function nullValidator(control) {
+  return null;
+}
+function isPresent(o) {
+  return o != null;
+}
+function toObservable(value) {
+  const obs = isPromise2(value) ? from(value) : value;
+  if ((typeof ngDevMode === "undefined" || ngDevMode) && !isSubscribable(obs)) {
+    let errorMessage = `Expected async validator to return Promise or Observable.`;
+    if (typeof value === "object") {
+      errorMessage += " Are you using a synchronous validator where an async validator is expected?";
+    }
+    throw new RuntimeError(-1101, errorMessage);
+  }
+  return obs;
+}
+function mergeErrors(arrayOfErrors) {
+  let res = {};
+  arrayOfErrors.forEach((errors) => {
+    res = errors != null ? __spreadValues(__spreadValues({}, res), errors) : res;
+  });
+  return Object.keys(res).length === 0 ? null : res;
+}
+function executeValidators(control, validators) {
+  return validators.map((validator) => validator(control));
+}
+function isValidatorFn(validator) {
+  return !validator.validate;
+}
+function normalizeValidators(validators) {
+  return validators.map((validator) => {
+    return isValidatorFn(validator) ? validator : (c) => validator.validate(c);
+  });
+}
+function compose(validators) {
+  if (!validators) return null;
+  const presentValidators = validators.filter(isPresent);
+  if (presentValidators.length == 0) return null;
+  return function(control) {
+    return mergeErrors(executeValidators(control, presentValidators));
+  };
+}
+function composeValidators(validators) {
+  return validators != null ? compose(normalizeValidators(validators)) : null;
+}
+function composeAsync(validators) {
+  if (!validators) return null;
+  const presentValidators = validators.filter(isPresent);
+  if (presentValidators.length == 0) return null;
+  return function(control) {
+    const observables = executeValidators(control, presentValidators).map(toObservable);
+    return forkJoin(observables).pipe(map(mergeErrors));
+  };
+}
+function composeAsyncValidators(validators) {
+  return validators != null ? composeAsync(normalizeValidators(validators)) : null;
+}
+function mergeValidators(controlValidators, dirValidator) {
+  if (controlValidators === null) return [dirValidator];
+  return Array.isArray(controlValidators) ? [...controlValidators, dirValidator] : [controlValidators, dirValidator];
+}
+function getControlValidators(control) {
+  return control._rawValidators;
+}
+function getControlAsyncValidators(control) {
+  return control._rawAsyncValidators;
+}
+function makeValidatorsArray(validators) {
+  if (!validators) return [];
+  return Array.isArray(validators) ? validators : [validators];
+}
+function hasValidator(validators, validator) {
+  return Array.isArray(validators) ? validators.includes(validator) : validators === validator;
+}
+function addValidators(validators, currentValidators) {
+  const current = makeValidatorsArray(currentValidators);
+  const validatorsToAdd = makeValidatorsArray(validators);
+  validatorsToAdd.forEach((v) => {
+    if (!hasValidator(current, v)) {
+      current.push(v);
+    }
+  });
+  return current;
+}
+function removeValidators(validators, currentValidators) {
+  return makeValidatorsArray(currentValidators).filter((v) => !hasValidator(validators, v));
+}
+var AbstractControlDirective = class {
+  get value() {
+    return this.control ? this.control.value : null;
+  }
+  get valid() {
+    return this.control ? this.control.valid : null;
+  }
+  get invalid() {
+    return this.control ? this.control.invalid : null;
+  }
+  get pending() {
+    return this.control ? this.control.pending : null;
+  }
+  get disabled() {
+    return this.control ? this.control.disabled : null;
+  }
+  get enabled() {
+    return this.control ? this.control.enabled : null;
+  }
+  get errors() {
+    return this.control ? this.control.errors : null;
+  }
+  get pristine() {
+    return this.control ? this.control.pristine : null;
+  }
+  get dirty() {
+    return this.control ? this.control.dirty : null;
+  }
+  get touched() {
+    return this.control ? this.control.touched : null;
+  }
+  get status() {
+    return this.control ? this.control.status : null;
+  }
+  get untouched() {
+    return this.control ? this.control.untouched : null;
+  }
+  get statusChanges() {
+    return this.control ? this.control.statusChanges : null;
+  }
+  get valueChanges() {
+    return this.control ? this.control.valueChanges : null;
+  }
+  get path() {
+    return null;
+  }
+  _composedValidatorFn;
+  _composedAsyncValidatorFn;
+  _rawValidators = [];
+  _rawAsyncValidators = [];
+  _setValidators(validators) {
+    this._rawValidators = validators || [];
+    this._composedValidatorFn = composeValidators(this._rawValidators);
+  }
+  _setAsyncValidators(validators) {
+    this._rawAsyncValidators = validators || [];
+    this._composedAsyncValidatorFn = composeAsyncValidators(this._rawAsyncValidators);
+  }
+  get validator() {
+    return this._composedValidatorFn || null;
+  }
+  get asyncValidator() {
+    return this._composedAsyncValidatorFn || null;
+  }
+  _onDestroyCallbacks = [];
+  _registerOnDestroy(fn) {
+    this._onDestroyCallbacks.push(fn);
+  }
+  _invokeOnDestroyCallbacks() {
+    this._onDestroyCallbacks.forEach((fn) => fn());
+    this._onDestroyCallbacks = [];
+  }
+  reset(value = void 0) {
+    this.control?.reset(value);
+  }
+  hasError(errorCode, path) {
+    return this.control ? this.control.hasError(errorCode, path) : false;
+  }
+  getError(errorCode, path) {
+    return this.control ? this.control.getError(errorCode, path) : null;
+  }
+};
+var ControlContainer = class extends AbstractControlDirective {
+  name;
+  get formDirective() {
+    return null;
+  }
+  get path() {
+    return null;
+  }
+};
+var NgControl = class extends AbstractControlDirective {
+  _parent = null;
+  name = null;
+  valueAccessor = null;
+};
+var AbstractControlStatus = class {
+  _cd;
+  constructor(cd) {
+    this._cd = cd;
+  }
+  get isTouched() {
+    this._cd?.control?._touched?.();
+    return !!this._cd?.control?.touched;
+  }
+  get isUntouched() {
+    return !!this._cd?.control?.untouched;
+  }
+  get isPristine() {
+    this._cd?.control?._pristine?.();
+    return !!this._cd?.control?.pristine;
+  }
+  get isDirty() {
+    return !!this._cd?.control?.dirty;
+  }
+  get isValid() {
+    this._cd?.control?._status?.();
+    return !!this._cd?.control?.valid;
+  }
+  get isInvalid() {
+    return !!this._cd?.control?.invalid;
+  }
+  get isPending() {
+    return !!this._cd?.control?.pending;
+  }
+  get isSubmitted() {
+    this._cd?._submitted?.();
+    return !!this._cd?.submitted;
+  }
+};
+var ngControlStatusHost = {
+  "[class.ng-untouched]": "isUntouched",
+  "[class.ng-touched]": "isTouched",
+  "[class.ng-pristine]": "isPristine",
+  "[class.ng-dirty]": "isDirty",
+  "[class.ng-valid]": "isValid",
+  "[class.ng-invalid]": "isInvalid",
+  "[class.ng-pending]": "isPending"
+};
+var NgControlStatus = class _NgControlStatus extends AbstractControlStatus {
+  constructor(cd) {
+    super(cd);
+  }
+  static \u0275fac = function NgControlStatus_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _NgControlStatus)(\u0275\u0275directiveInject(NgControl, 2));
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _NgControlStatus,
+    selectors: [["", "formControlName", ""], ["", "ngModel", ""], ["", "formControl", ""]],
+    hostVars: 14,
+    hostBindings: function NgControlStatus_HostBindings(rf, ctx) {
+      if (rf & 2) {
+        \u0275\u0275classProp("ng-untouched", ctx.isUntouched)("ng-touched", ctx.isTouched)("ng-pristine", ctx.isPristine)("ng-dirty", ctx.isDirty)("ng-valid", ctx.isValid)("ng-invalid", ctx.isInvalid)("ng-pending", ctx.isPending);
+      }
+    },
+    standalone: false,
+    features: [\u0275\u0275InheritDefinitionFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgControlStatus, [{
+    type: Directive,
+    args: [{
+      selector: "[formControlName],[ngModel],[formControl]",
+      host: ngControlStatusHost,
+      standalone: false
+    }]
+  }], () => [{
+    type: NgControl,
+    decorators: [{
+      type: Self
+    }]
+  }], null);
+})();
+var NgControlStatusGroup = class _NgControlStatusGroup extends AbstractControlStatus {
+  constructor(cd) {
+    super(cd);
+  }
+  static \u0275fac = function NgControlStatusGroup_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _NgControlStatusGroup)(\u0275\u0275directiveInject(ControlContainer, 10));
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _NgControlStatusGroup,
+    selectors: [["", "formGroupName", ""], ["", "formArrayName", ""], ["", "ngModelGroup", ""], ["", "formGroup", ""], ["", "formArray", ""], ["form", 3, "ngNoForm", ""], ["", "ngForm", ""]],
+    hostVars: 16,
+    hostBindings: function NgControlStatusGroup_HostBindings(rf, ctx) {
+      if (rf & 2) {
+        \u0275\u0275classProp("ng-untouched", ctx.isUntouched)("ng-touched", ctx.isTouched)("ng-pristine", ctx.isPristine)("ng-dirty", ctx.isDirty)("ng-valid", ctx.isValid)("ng-invalid", ctx.isInvalid)("ng-pending", ctx.isPending)("ng-submitted", ctx.isSubmitted);
+      }
+    },
+    standalone: false,
+    features: [\u0275\u0275InheritDefinitionFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgControlStatusGroup, [{
+    type: Directive,
+    args: [{
+      selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],[formArray],form:not([ngNoForm]),[ngForm]",
+      host: __spreadProps(__spreadValues({}, ngControlStatusHost), {
+        "[class.ng-submitted]": "isSubmitted"
+      }),
+      standalone: false
+    }]
+  }], () => [{
+    type: ControlContainer,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Self
+    }]
+  }], null);
+})();
+var formControlNameExample = `
+  <div [formGroup]="myGroup">
+    <input formControlName="firstName">
+  </div>
+
+  In your class:
+
+  this.myGroup = new FormGroup({
+      firstName: new FormControl()
+  });`;
+var formGroupNameExample = `
+  <div [formGroup]="myGroup">
+      <div formGroupName="person">
+        <input formControlName="firstName">
+      </div>
+  </div>
+
+  In your class:
+
+  this.myGroup = new FormGroup({
+      person: new FormGroup({ firstName: new FormControl() })
+  });`;
+var formArrayNameExample = `
+  <div [formGroup]="myGroup">
+    <div formArrayName="cities">
+      <div *ngFor="let city of cityArray.controls; index as i">
+        <input [formControlName]="i">
+      </div>
+    </div>
+  </div>
+
+  In your class:
+
+  this.cityArray = new FormArray([new FormControl('SF')]);
+  this.myGroup = new FormGroup({
+    cities: this.cityArray
+  });`;
+var ngModelGroupExample = `
+  <form>
+      <div ngModelGroup="person">
+        <input [(ngModel)]="person.name" name="firstName">
+      </div>
+  </form>`;
+var ngModelWithFormGroupExample = `
+  <div [formGroup]="myGroup">
+      <input formControlName="firstName">
+      <input [(ngModel)]="showMoreControls" [ngModelOptions]="{standalone: true}">
+  </div>
+`;
+var VERSION2 = /* @__PURE__ */ new Version("21.2.17");
+function controlParentException(nameOrIndex) {
+  return new RuntimeError(1050, `formControlName must be used with a parent formGroup or formArray directive. You'll want to add a formGroup/formArray
+      directive and pass it an existing FormGroup/FormArray instance (you can create one in your class).
+
+      ${describeFormControl(nameOrIndex)}
+
+    Example:
+
+    ${formControlNameExample}`);
+}
+function describeFormControl(nameOrIndex) {
+  if (nameOrIndex == null || nameOrIndex === "") {
+    return "";
+  }
+  const valueType = typeof nameOrIndex === "string" ? "name" : "index";
+  return `Affected Form Control ${valueType}: "${nameOrIndex}"`;
+}
+function ngModelGroupException() {
+  return new RuntimeError(1051, `formControlName cannot be used with an ngModelGroup parent. It is only compatible with parents
+      that also have a "form" prefix: formGroupName, formArrayName, or formGroup.
+
+      Option 1:  Update the parent to be formGroupName (reactive form strategy)
+
+      ${formGroupNameExample}
+
+      Option 2: Use ngModel instead of formControlName (template-driven strategy)
+
+      ${ngModelGroupExample}`);
+}
+function missingFormException() {
+  return new RuntimeError(1052, `formGroup expects a FormGroup instance. Please pass one in.
+
+      Example:
+
+      ${formControlNameExample}`);
+}
+function groupParentException() {
+  return new RuntimeError(1053, `formGroupName must be used with a parent formGroup directive.  You'll want to add a formGroup
+    directive and pass it an existing FormGroup instance (you can create one in your class).
+
+    Example:
+
+    ${formGroupNameExample}`);
+}
+function arrayParentException() {
+  return new RuntimeError(1054, `formArrayName must be used with a parent formGroup directive.  You'll want to add a formGroup
+      directive and pass it an existing FormGroup instance (you can create one in your class).
+
+      Example:
+
+      ${formArrayNameExample}`);
+}
+var disabledAttrWarning = `
+  It looks like you're using the disabled attribute with a reactive form directive. If you set disabled to true
+  when you set up this control in your component class, the disabled attribute will actually be set in the DOM for
+  you. We recommend using this approach to avoid 'changed after checked' errors.
+
+  Example:
+  // Specify the \`disabled\` property at control creation time:
+  form = new FormGroup({
+    first: new FormControl({value: 'Nancy', disabled: true}, Validators.required),
+    last: new FormControl('Drew', Validators.required)
+  });
+
+  // Controls can also be enabled/disabled after creation:
+  form.get('first')?.enable();
+  form.get('last')?.disable();
+`;
+var asyncValidatorsDroppedWithOptsWarning = `
+  It looks like you're constructing using a FormControl with both an options argument and an
+  async validators argument. Mixing these arguments will cause your async validators to be dropped.
+  You should either put all your validators in the options object, or in separate validators
+  arguments. For example:
+
+  // Using validators arguments
+  fc = new FormControl(42, Validators.required, myAsyncValidator);
+
+  // Using AbstractControlOptions
+  fc = new FormControl(42, {validators: Validators.required, asyncValidators: myAV});
+
+  // Do NOT mix them: async validators will be dropped!
+  fc = new FormControl(42, {validators: Validators.required}, /* Oops! */ myAsyncValidator);
+`;
+function ngModelWarning(directiveName) {
+  const versionSubDomain = VERSION2.major !== "0" ? `v${VERSION2.major}.` : "";
+  return `
+  It looks like you're using ngModel on the same form field as ${directiveName}.
+  Support for using the ngModel input property and ngModelChange event with
+  reactive form directives has been deprecated in Angular v6 and will be removed
+  in a future version of Angular.
+
+  For more information on this, see our API docs here:
+  https://${versionSubDomain}angular.dev/api/forms/${directiveName === "formControl" ? "FormControlDirective" : "FormControlName"}
+  `;
+}
+function describeKey(isFormGroup, key) {
+  return isFormGroup ? `with name: '${key}'` : `at index: ${key}`;
+}
+function noControlsError(isFormGroup) {
+  return `
+    There are no form controls registered with this ${isFormGroup ? "group" : "array"} yet. If you're using ngModel,
+    you may want to check next tick (e.g. use setTimeout).
+  `;
+}
+function missingControlError(isFormGroup, key) {
+  return `Cannot find form control ${describeKey(isFormGroup, key)}`;
+}
+function missingControlValueError(isFormGroup, key) {
+  return `Must supply a value for form control ${describeKey(isFormGroup, key)}`;
+}
+var VALID = "VALID";
+var INVALID = "INVALID";
+var PENDING = "PENDING";
+var DISABLED = "DISABLED";
+var ControlEvent = class {
+};
+var ValueChangeEvent = class extends ControlEvent {
+  value;
+  source;
+  constructor(value, source) {
+    super();
+    this.value = value;
+    this.source = source;
+  }
+};
+var PristineChangeEvent = class extends ControlEvent {
+  pristine;
+  source;
+  constructor(pristine, source) {
+    super();
+    this.pristine = pristine;
+    this.source = source;
+  }
+};
+var TouchedChangeEvent = class extends ControlEvent {
+  touched;
+  source;
+  constructor(touched, source) {
+    super();
+    this.touched = touched;
+    this.source = source;
+  }
+};
+var StatusChangeEvent = class extends ControlEvent {
+  status;
+  source;
+  constructor(status, source) {
+    super();
+    this.status = status;
+    this.source = source;
+  }
+};
+var FormSubmittedEvent = class extends ControlEvent {
+  source;
+  constructor(source) {
+    super();
+    this.source = source;
+  }
+};
+var FormResetEvent = class extends ControlEvent {
+  source;
+  constructor(source) {
+    super();
+    this.source = source;
+  }
+};
+function pickValidators(validatorOrOpts) {
+  return (isOptionsObj(validatorOrOpts) ? validatorOrOpts.validators : validatorOrOpts) || null;
+}
+function coerceToValidator(validator) {
+  return Array.isArray(validator) ? composeValidators(validator) : validator || null;
+}
+function pickAsyncValidators(asyncValidator, validatorOrOpts) {
+  if (typeof ngDevMode === "undefined" || ngDevMode) {
+    if (isOptionsObj(validatorOrOpts) && asyncValidator) {
+      console.warn(asyncValidatorsDroppedWithOptsWarning);
+    }
+  }
+  return (isOptionsObj(validatorOrOpts) ? validatorOrOpts.asyncValidators : asyncValidator) || null;
+}
+function coerceToAsyncValidator(asyncValidator) {
+  return Array.isArray(asyncValidator) ? composeAsyncValidators(asyncValidator) : asyncValidator || null;
+}
+function isOptionsObj(validatorOrOpts) {
+  return validatorOrOpts != null && !Array.isArray(validatorOrOpts) && typeof validatorOrOpts === "object";
+}
+function assertControlPresent(parent, isGroup, key) {
+  const controls = parent.controls;
+  const collection = isGroup ? Object.keys(controls) : controls;
+  if (!collection.length) {
+    throw new RuntimeError(1e3, typeof ngDevMode === "undefined" || ngDevMode ? noControlsError(isGroup) : "");
+  }
+  if (!controls[key]) {
+    throw new RuntimeError(1001, typeof ngDevMode === "undefined" || ngDevMode ? missingControlError(isGroup, key) : "");
+  }
+}
+function assertAllValuesPresent(control, isGroup, value) {
+  control._forEachChild((_, key) => {
+    if (value[key] === void 0) {
+      throw new RuntimeError(-1002, typeof ngDevMode === "undefined" || ngDevMode ? missingControlValueError(isGroup, key) : "");
+    }
+  });
+}
+var AbstractControl = class {
+  _pendingDirty = false;
+  _hasOwnPendingAsyncValidator = null;
+  _pendingTouched = false;
+  _onCollectionChange = () => {
+  };
+  _updateOn;
+  _parent = null;
+  _asyncValidationSubscription;
+  _composedValidatorFn;
+  _composedAsyncValidatorFn;
+  _rawValidators;
+  _rawAsyncValidators;
+  value;
+  constructor(validators, asyncValidators) {
+    this._assignValidators(validators);
+    this._assignAsyncValidators(asyncValidators);
+  }
+  get validator() {
+    return this._composedValidatorFn;
+  }
+  set validator(validatorFn) {
+    this._rawValidators = this._composedValidatorFn = validatorFn;
+  }
+  get asyncValidator() {
+    return this._composedAsyncValidatorFn;
+  }
+  set asyncValidator(asyncValidatorFn) {
+    this._rawAsyncValidators = this._composedAsyncValidatorFn = asyncValidatorFn;
+  }
+  get parent() {
+    return this._parent;
+  }
+  get status() {
+    return untracked2(this.statusReactive);
+  }
+  set status(v) {
+    untracked2(() => this.statusReactive.set(v));
+  }
+  _status = computed(() => this.statusReactive(), ...ngDevMode ? [{
+    debugName: "_status"
+  }] : []);
+  statusReactive = signal(void 0, ...ngDevMode ? [{
+    debugName: "statusReactive"
+  }] : []);
+  get valid() {
+    return this.status === VALID;
+  }
+  get invalid() {
+    return this.status === INVALID;
+  }
+  get pending() {
+    return this.status === PENDING;
+  }
+  get disabled() {
+    return this.status === DISABLED;
+  }
+  get enabled() {
+    return this.status !== DISABLED;
+  }
+  errors;
+  get pristine() {
+    return untracked2(this.pristineReactive);
+  }
+  set pristine(v) {
+    untracked2(() => this.pristineReactive.set(v));
+  }
+  _pristine = computed(() => this.pristineReactive(), ...ngDevMode ? [{
+    debugName: "_pristine"
+  }] : []);
+  pristineReactive = signal(true, ...ngDevMode ? [{
+    debugName: "pristineReactive"
+  }] : []);
+  get dirty() {
+    return !this.pristine;
+  }
+  get touched() {
+    return untracked2(this.touchedReactive);
+  }
+  set touched(v) {
+    untracked2(() => this.touchedReactive.set(v));
+  }
+  _touched = computed(() => this.touchedReactive(), ...ngDevMode ? [{
+    debugName: "_touched"
+  }] : []);
+  touchedReactive = signal(false, ...ngDevMode ? [{
+    debugName: "touchedReactive"
+  }] : []);
+  get untouched() {
+    return !this.touched;
+  }
+  _events = new Subject();
+  events = this._events.asObservable();
+  valueChanges;
+  statusChanges;
+  get updateOn() {
+    return this._updateOn ? this._updateOn : this.parent ? this.parent.updateOn : "change";
+  }
+  setValidators(validators) {
+    this._assignValidators(validators);
+  }
+  setAsyncValidators(validators) {
+    this._assignAsyncValidators(validators);
+  }
+  addValidators(validators) {
+    this.setValidators(addValidators(validators, this._rawValidators));
+  }
+  addAsyncValidators(validators) {
+    this.setAsyncValidators(addValidators(validators, this._rawAsyncValidators));
+  }
+  removeValidators(validators) {
+    this.setValidators(removeValidators(validators, this._rawValidators));
+  }
+  removeAsyncValidators(validators) {
+    this.setAsyncValidators(removeValidators(validators, this._rawAsyncValidators));
+  }
+  hasValidator(validator) {
+    return hasValidator(this._rawValidators, validator);
+  }
+  hasAsyncValidator(validator) {
+    return hasValidator(this._rawAsyncValidators, validator);
+  }
+  clearValidators() {
+    this.validator = null;
+  }
+  clearAsyncValidators() {
+    this.asyncValidator = null;
+  }
+  markAsTouched(opts = {}) {
+    const changed = this.touched === false;
+    this.touched = true;
+    const sourceControl = opts.sourceControl ?? this;
+    if (!opts.onlySelf) {
+      this._parent?.markAsTouched(__spreadProps(__spreadValues({}, opts), {
+        sourceControl
+      }));
+    }
+    if (changed && opts.emitEvent !== false) {
+      this._events.next(new TouchedChangeEvent(true, sourceControl));
+    }
+  }
+  markAllAsDirty(opts = {}) {
+    this.markAsDirty({
+      onlySelf: true,
+      emitEvent: opts.emitEvent,
+      sourceControl: this
+    });
+    this._forEachChild((control) => control.markAllAsDirty(opts));
+  }
+  markAllAsTouched(opts = {}) {
+    this.markAsTouched({
+      onlySelf: true,
+      emitEvent: opts.emitEvent,
+      sourceControl: this
+    });
+    this._forEachChild((control) => control.markAllAsTouched(opts));
+  }
+  markAsUntouched(opts = {}) {
+    const changed = this.touched === true;
+    this.touched = false;
+    this._pendingTouched = false;
+    const sourceControl = opts.sourceControl ?? this;
+    this._forEachChild((control) => {
+      control.markAsUntouched({
+        onlySelf: true,
+        emitEvent: opts.emitEvent,
+        sourceControl
+      });
+    });
+    if (!opts.onlySelf) {
+      this._parent?._updateTouched(opts, sourceControl);
+    }
+    if (changed && opts.emitEvent !== false) {
+      this._events.next(new TouchedChangeEvent(false, sourceControl));
+    }
+  }
+  markAsDirty(opts = {}) {
+    const changed = this.pristine === true;
+    this.pristine = false;
+    const sourceControl = opts.sourceControl ?? this;
+    if (!opts.onlySelf) {
+      this._parent?.markAsDirty(__spreadProps(__spreadValues({}, opts), {
+        sourceControl
+      }));
+    }
+    if (changed && opts.emitEvent !== false) {
+      this._events.next(new PristineChangeEvent(false, sourceControl));
+    }
+  }
+  markAsPristine(opts = {}) {
+    const changed = this.pristine === false;
+    this.pristine = true;
+    this._pendingDirty = false;
+    const sourceControl = opts.sourceControl ?? this;
+    this._forEachChild((control) => {
+      control.markAsPristine({
+        onlySelf: true,
+        emitEvent: opts.emitEvent
+      });
+    });
+    if (!opts.onlySelf) {
+      this._parent?._updatePristine(opts, sourceControl);
+    }
+    if (changed && opts.emitEvent !== false) {
+      this._events.next(new PristineChangeEvent(true, sourceControl));
+    }
+  }
+  markAsPending(opts = {}) {
+    this.status = PENDING;
+    const sourceControl = opts.sourceControl ?? this;
+    if (opts.emitEvent !== false) {
+      this._events.next(new StatusChangeEvent(this.status, sourceControl));
+      this.statusChanges.emit(this.status);
+    }
+    if (!opts.onlySelf) {
+      this._parent?.markAsPending(__spreadProps(__spreadValues({}, opts), {
+        sourceControl
+      }));
+    }
+  }
+  disable(opts = {}) {
+    const skipPristineCheck = this._parentMarkedDirty(opts.onlySelf);
+    this.status = DISABLED;
+    this.errors = null;
+    this._forEachChild((control) => {
+      control.disable(__spreadProps(__spreadValues({}, opts), {
+        onlySelf: true
+      }));
+    });
+    this._updateValue();
+    const sourceControl = opts.sourceControl ?? this;
+    if (opts.emitEvent !== false) {
+      this._events.next(new ValueChangeEvent(this.value, sourceControl));
+      this._events.next(new StatusChangeEvent(this.status, sourceControl));
+      this.valueChanges.emit(this.value);
+      this.statusChanges.emit(this.status);
+    }
+    this._updateAncestors(__spreadProps(__spreadValues({}, opts), {
+      skipPristineCheck
+    }), this);
+    this._onDisabledChange.forEach((changeFn) => changeFn(true));
+  }
+  enable(opts = {}) {
+    const skipPristineCheck = this._parentMarkedDirty(opts.onlySelf);
+    this.status = VALID;
+    this._forEachChild((control) => {
+      control.enable(__spreadProps(__spreadValues({}, opts), {
+        onlySelf: true
+      }));
+    });
+    this.updateValueAndValidity({
+      onlySelf: true,
+      emitEvent: opts.emitEvent
+    });
+    this._updateAncestors(__spreadProps(__spreadValues({}, opts), {
+      skipPristineCheck
+    }), this);
+    this._onDisabledChange.forEach((changeFn) => changeFn(false));
+  }
+  _updateAncestors(opts, sourceControl) {
+    if (!opts.onlySelf) {
+      this._parent?.updateValueAndValidity(opts);
+      if (!opts.skipPristineCheck) {
+        this._parent?._updatePristine({}, sourceControl);
+      }
+      this._parent?._updateTouched({}, sourceControl);
+    }
+  }
+  setParent(parent) {
+    this._parent = parent;
+  }
+  getRawValue() {
+    return this.value;
+  }
+  updateValueAndValidity(opts = {}) {
+    this._setInitialStatus();
+    this._updateValue();
+    if (this.enabled) {
+      const shouldHaveEmitted = this._cancelExistingSubscription();
+      this.errors = this._runValidator();
+      this.status = this._calculateStatus();
+      if (this.status === VALID || this.status === PENDING) {
+        this._runAsyncValidator(shouldHaveEmitted, opts.emitEvent);
+      }
+    }
+    const sourceControl = opts.sourceControl ?? this;
+    if (opts.emitEvent !== false) {
+      this._events.next(new ValueChangeEvent(this.value, sourceControl));
+      this._events.next(new StatusChangeEvent(this.status, sourceControl));
+      this.valueChanges.emit(this.value);
+      this.statusChanges.emit(this.status);
+    }
+    if (!opts.onlySelf) {
+      this._parent?.updateValueAndValidity(__spreadProps(__spreadValues({}, opts), {
+        sourceControl
+      }));
+    }
+  }
+  _updateTreeValidity(opts = {
+    emitEvent: true
+  }) {
+    this._forEachChild((ctrl) => ctrl._updateTreeValidity(opts));
+    this.updateValueAndValidity({
+      onlySelf: true,
+      emitEvent: opts.emitEvent
+    });
+  }
+  _setInitialStatus() {
+    this.status = this._allControlsDisabled() ? DISABLED : VALID;
+  }
+  _runValidator() {
+    return this.validator ? this.validator(this) : null;
+  }
+  _runAsyncValidator(shouldHaveEmitted, emitEvent) {
+    if (this.asyncValidator) {
+      this.status = PENDING;
+      this._hasOwnPendingAsyncValidator = {
+        emitEvent: emitEvent !== false,
+        shouldHaveEmitted: shouldHaveEmitted !== false
+      };
+      const obs = toObservable(this.asyncValidator(this));
+      this._asyncValidationSubscription = obs.subscribe((errors) => {
+        this._hasOwnPendingAsyncValidator = null;
+        this.setErrors(errors, {
+          emitEvent,
+          shouldHaveEmitted
+        });
+      });
+    }
+  }
+  _cancelExistingSubscription() {
+    if (this._asyncValidationSubscription) {
+      this._asyncValidationSubscription.unsubscribe();
+      const shouldHaveEmitted = (this._hasOwnPendingAsyncValidator?.emitEvent || this._hasOwnPendingAsyncValidator?.shouldHaveEmitted) ?? false;
+      this._hasOwnPendingAsyncValidator = null;
+      return shouldHaveEmitted;
+    }
+    return false;
+  }
+  setErrors(errors, opts = {}) {
+    this.errors = errors;
+    this._updateControlsErrors(opts.emitEvent !== false, this, opts.shouldHaveEmitted);
+  }
+  get(path) {
+    let currPath = path;
+    if (currPath == null) return null;
+    if (!Array.isArray(currPath)) currPath = currPath.split(".");
+    if (currPath.length === 0) return null;
+    return currPath.reduce((control, name) => control && control._find(name), this);
+  }
+  getError(errorCode, path) {
+    const control = path ? this.get(path) : this;
+    return control?.errors ? control.errors[errorCode] : null;
+  }
+  hasError(errorCode, path) {
+    return !!this.getError(errorCode, path);
+  }
+  get root() {
+    let x = this;
+    while (x._parent) {
+      x = x._parent;
+    }
+    return x;
+  }
+  _updateControlsErrors(emitEvent, changedControl, shouldHaveEmitted) {
+    this.status = this._calculateStatus();
+    if (emitEvent) {
+      this.statusChanges.emit(this.status);
+    }
+    if (emitEvent || shouldHaveEmitted) {
+      this._events.next(new StatusChangeEvent(this.status, changedControl));
+    }
+    if (this._parent) {
+      this._parent._updateControlsErrors(emitEvent, changedControl, shouldHaveEmitted);
+    }
+  }
+  _initObservables() {
+    this.valueChanges = new EventEmitter();
+    this.statusChanges = new EventEmitter();
+  }
+  _calculateStatus() {
+    if (this._allControlsDisabled()) return DISABLED;
+    if (this.errors) return INVALID;
+    if (this._hasOwnPendingAsyncValidator || this._anyControlsHaveStatus(PENDING)) return PENDING;
+    if (this._anyControlsHaveStatus(INVALID)) return INVALID;
+    return VALID;
+  }
+  _anyControlsHaveStatus(status) {
+    return this._anyControls((control) => control.status === status);
+  }
+  _anyControlsDirty() {
+    return this._anyControls((control) => control.dirty);
+  }
+  _anyControlsTouched() {
+    return this._anyControls((control) => control.touched);
+  }
+  _updatePristine(opts, changedControl) {
+    const newPristine = !this._anyControlsDirty();
+    const changed = this.pristine !== newPristine;
+    this.pristine = newPristine;
+    if (!opts.onlySelf) {
+      this._parent?._updatePristine(opts, changedControl);
+    }
+    if (changed) {
+      this._events.next(new PristineChangeEvent(this.pristine, changedControl));
+    }
+  }
+  _updateTouched(opts = {}, changedControl) {
+    this.touched = this._anyControlsTouched();
+    this._events.next(new TouchedChangeEvent(this.touched, changedControl));
+    if (!opts.onlySelf) {
+      this._parent?._updateTouched(opts, changedControl);
+    }
+  }
+  _onDisabledChange = [];
+  _registerOnCollectionChange(fn) {
+    this._onCollectionChange = fn;
+  }
+  _setUpdateStrategy(opts) {
+    if (isOptionsObj(opts) && opts.updateOn != null) {
+      this._updateOn = opts.updateOn;
+    }
+  }
+  _parentMarkedDirty(onlySelf) {
+    return !onlySelf && !!this._parent?.dirty && !this._parent._anyControlsDirty();
+  }
+  _find(name) {
+    return null;
+  }
+  _assignValidators(validators) {
+    this._rawValidators = Array.isArray(validators) ? validators.slice() : validators;
+    this._composedValidatorFn = coerceToValidator(this._rawValidators);
+  }
+  _assignAsyncValidators(validators) {
+    this._rawAsyncValidators = Array.isArray(validators) ? validators.slice() : validators;
+    this._composedAsyncValidatorFn = coerceToAsyncValidator(this._rawAsyncValidators);
+  }
+};
+var FormGroup = class extends AbstractControl {
+  constructor(controls, validatorOrOpts, asyncValidator) {
+    super(pickValidators(validatorOrOpts), pickAsyncValidators(asyncValidator, validatorOrOpts));
+    (typeof ngDevMode === "undefined" || ngDevMode) && validateFormGroupControls(controls);
+    this.controls = controls;
+    this._initObservables();
+    this._setUpdateStrategy(validatorOrOpts);
+    this._setUpControls();
+    this.updateValueAndValidity({
+      onlySelf: true,
+      emitEvent: !!this.asyncValidator
+    });
+  }
+  controls;
+  registerControl(name, control) {
+    if (this.controls[name]) return this.controls[name];
+    this.controls[name] = control;
+    control.setParent(this);
+    control._registerOnCollectionChange(this._onCollectionChange);
+    return control;
+  }
+  addControl(name, control, options = {}) {
+    this.registerControl(name, control);
+    this.updateValueAndValidity({
+      emitEvent: options.emitEvent
+    });
+    this._onCollectionChange();
+  }
+  removeControl(name, options = {}) {
+    if (this.controls[name]) this.controls[name]._registerOnCollectionChange(() => {
+    });
+    delete this.controls[name];
+    this.updateValueAndValidity({
+      emitEvent: options.emitEvent
+    });
+    this._onCollectionChange();
+  }
+  setControl(name, control, options = {}) {
+    if (this.controls[name]) this.controls[name]._registerOnCollectionChange(() => {
+    });
+    delete this.controls[name];
+    if (control) this.registerControl(name, control);
+    this.updateValueAndValidity({
+      emitEvent: options.emitEvent
+    });
+    this._onCollectionChange();
+  }
+  contains(controlName) {
+    return this.controls.hasOwnProperty(controlName) && this.controls[controlName].enabled;
+  }
+  setValue(value, options = {}) {
+    assertAllValuesPresent(this, true, value);
+    Object.keys(value).forEach((name) => {
+      assertControlPresent(this, true, name);
+      this.controls[name].setValue(value[name], {
+        onlySelf: true,
+        emitEvent: options.emitEvent
+      });
+    });
+    this.updateValueAndValidity(options);
+  }
+  patchValue(value, options = {}) {
+    if (value == null) return;
+    Object.keys(value).forEach((name) => {
+      const control = this.controls[name];
+      if (control) {
+        control.patchValue(value[name], {
+          onlySelf: true,
+          emitEvent: options.emitEvent
+        });
+      }
+    });
+    this.updateValueAndValidity(options);
+  }
+  reset(value = {}, options = {}) {
+    this._forEachChild((control, name) => {
+      control.reset(value ? value[name] : null, __spreadProps(__spreadValues({}, options), {
+        onlySelf: true
+      }));
+    });
+    this._updatePristine(options, this);
+    this._updateTouched(options, this);
+    this.updateValueAndValidity(options);
+    if (options?.emitEvent !== false) {
+      this._events.next(new FormResetEvent(this));
+    }
+  }
+  getRawValue() {
+    return this._reduceChildren({}, (acc, control, name) => {
+      acc[name] = control.getRawValue();
+      return acc;
+    });
+  }
+  _syncPendingControls() {
+    let subtreeUpdated = this._reduceChildren(false, (updated, child) => {
+      return child._syncPendingControls() ? true : updated;
+    });
+    if (subtreeUpdated) this.updateValueAndValidity({
+      onlySelf: true
+    });
+    return subtreeUpdated;
+  }
+  _forEachChild(cb) {
+    Object.keys(this.controls).forEach((key) => {
+      const control = this.controls[key];
+      control && cb(control, key);
+    });
+  }
+  _setUpControls() {
+    this._forEachChild((control) => {
+      control.setParent(this);
+      control._registerOnCollectionChange(this._onCollectionChange);
+    });
+  }
+  _updateValue() {
+    this.value = this._reduceValue();
+  }
+  _anyControls(condition) {
+    for (const [controlName, control] of Object.entries(this.controls)) {
+      if (this.contains(controlName) && condition(control)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  _reduceValue() {
+    let acc = {};
+    return this._reduceChildren(acc, (acc2, control, name) => {
+      if (control.enabled || this.disabled) {
+        acc2[name] = control.value;
+      }
+      return acc2;
+    });
+  }
+  _reduceChildren(initValue, fn) {
+    let res = initValue;
+    this._forEachChild((control, name) => {
+      res = fn(res, control, name);
+    });
+    return res;
+  }
+  _allControlsDisabled() {
+    for (const controlName of Object.keys(this.controls)) {
+      if (this.controls[controlName].enabled) {
+        return false;
+      }
+    }
+    return Object.keys(this.controls).length > 0 || this.disabled;
+  }
+  _find(name) {
+    return this.controls.hasOwnProperty(name) ? this.controls[name] : null;
+  }
+};
+function validateFormGroupControls(controls) {
+  const invalidKeys = Object.keys(controls).filter((key) => key.includes("."));
+  if (invalidKeys.length > 0) {
+    console.warn(`FormGroup keys cannot include \`.\`, please replace the keys for: ${invalidKeys.join(",")}.`);
+  }
+}
+var FormRecord = class extends FormGroup {
+};
+var CALL_SET_DISABLED_STATE = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "CallSetDisabledState" : "", {
+  factory: () => setDisabledStateDefault
+});
+var setDisabledStateDefault = "always";
+function controlPath(name, parent) {
+  return [...parent.path, name];
+}
+function setUpControl(control, dir, callSetDisabledState = setDisabledStateDefault) {
+  if (typeof ngDevMode === "undefined" || ngDevMode) {
+    if (!control) _throwError(dir, "Cannot find control with");
+    if (!dir.valueAccessor) _throwMissingValueAccessorError(dir);
+  }
+  setUpValidators(control, dir);
+  dir.valueAccessor.writeValue(control.value);
+  if (control.disabled || callSetDisabledState === "always") {
+    dir.valueAccessor.setDisabledState?.(control.disabled);
+  }
+  setUpViewChangePipeline(control, dir);
+  setUpModelChangePipeline(control, dir);
+  setUpBlurPipeline(control, dir);
+  setUpDisabledChangeHandler(control, dir);
+}
+function cleanUpControl(control, dir, validateControlPresenceOnChange = true) {
+  const noop5 = () => {
+    if (validateControlPresenceOnChange && (typeof ngDevMode === "undefined" || ngDevMode)) {
+      _noControlError(dir);
+    }
+  };
+  dir?.valueAccessor?.registerOnChange(noop5);
+  dir?.valueAccessor?.registerOnTouched(noop5);
+  cleanUpValidators(control, dir);
+  if (control) {
+    dir._invokeOnDestroyCallbacks();
+    control._registerOnCollectionChange(() => {
+    });
+  }
+}
+function registerOnValidatorChange(validators, onChange) {
+  validators.forEach((validator) => {
+    if (validator.registerOnValidatorChange) validator.registerOnValidatorChange(onChange);
+  });
+}
+function setUpDisabledChangeHandler(control, dir) {
+  if (dir.valueAccessor.setDisabledState) {
+    const onDisabledChange = (isDisabled) => {
+      dir.valueAccessor.setDisabledState(isDisabled);
+    };
+    control.registerOnDisabledChange(onDisabledChange);
+    dir._registerOnDestroy(() => {
+      control._unregisterOnDisabledChange(onDisabledChange);
+    });
+  }
+}
+function setUpValidators(control, dir) {
+  const validators = getControlValidators(control);
+  if (dir.validator !== null) {
+    control.setValidators(mergeValidators(validators, dir.validator));
+  } else if (typeof validators === "function") {
+    control.setValidators([validators]);
+  }
+  const asyncValidators = getControlAsyncValidators(control);
+  if (dir.asyncValidator !== null) {
+    control.setAsyncValidators(mergeValidators(asyncValidators, dir.asyncValidator));
+  } else if (typeof asyncValidators === "function") {
+    control.setAsyncValidators([asyncValidators]);
+  }
+  const onValidatorChange = () => control.updateValueAndValidity();
+  registerOnValidatorChange(dir._rawValidators, onValidatorChange);
+  registerOnValidatorChange(dir._rawAsyncValidators, onValidatorChange);
+}
+function cleanUpValidators(control, dir) {
+  let isControlUpdated = false;
+  if (control !== null) {
+    if (dir.validator !== null) {
+      const validators = getControlValidators(control);
+      if (Array.isArray(validators) && validators.length > 0) {
+        const updatedValidators = validators.filter((validator) => validator !== dir.validator);
+        if (updatedValidators.length !== validators.length) {
+          isControlUpdated = true;
+          control.setValidators(updatedValidators);
+        }
+      }
+    }
+    if (dir.asyncValidator !== null) {
+      const asyncValidators = getControlAsyncValidators(control);
+      if (Array.isArray(asyncValidators) && asyncValidators.length > 0) {
+        const updatedAsyncValidators = asyncValidators.filter((asyncValidator) => asyncValidator !== dir.asyncValidator);
+        if (updatedAsyncValidators.length !== asyncValidators.length) {
+          isControlUpdated = true;
+          control.setAsyncValidators(updatedAsyncValidators);
+        }
+      }
+    }
+  }
+  const noop5 = () => {
+  };
+  registerOnValidatorChange(dir._rawValidators, noop5);
+  registerOnValidatorChange(dir._rawAsyncValidators, noop5);
+  return isControlUpdated;
+}
+function setUpViewChangePipeline(control, dir) {
+  dir.valueAccessor.registerOnChange((newValue) => {
+    control._pendingValue = newValue;
+    control._pendingChange = true;
+    control._pendingDirty = true;
+    if (control.updateOn === "change") updateControl(control, dir);
+  });
+}
+function setUpBlurPipeline(control, dir) {
+  dir.valueAccessor.registerOnTouched(() => {
+    control._pendingTouched = true;
+    if (control.updateOn === "blur" && control._pendingChange) updateControl(control, dir);
+    if (control.updateOn !== "submit") control.markAsTouched();
+  });
+}
+function updateControl(control, dir) {
+  if (control._pendingDirty) control.markAsDirty();
+  control.setValue(control._pendingValue, {
+    emitModelToViewChange: false
+  });
+  dir.viewToModelUpdate(control._pendingValue);
+  control._pendingChange = false;
+}
+function setUpModelChangePipeline(control, dir) {
+  const onChange = (newValue, emitModelEvent) => {
+    dir.valueAccessor.writeValue(newValue);
+    if (emitModelEvent) dir.viewToModelUpdate(newValue);
+  };
+  control.registerOnChange(onChange);
+  dir._registerOnDestroy(() => {
+    control._unregisterOnChange(onChange);
+  });
+}
+function setUpFormContainer(control, dir) {
+  if (control == null && (typeof ngDevMode === "undefined" || ngDevMode)) _throwError(dir, "Cannot find control with");
+  setUpValidators(control, dir);
+}
+function cleanUpFormContainer(control, dir) {
+  return cleanUpValidators(control, dir);
+}
+function _noControlError(dir) {
+  return _throwError(dir, "There is no FormControl instance attached to form control element with");
+}
+function _throwError(dir, message) {
+  const messageEnd = _describeControlLocation(dir);
+  throw new Error(`${message} ${messageEnd}`);
+}
+function _describeControlLocation(dir) {
+  const path = dir.path;
+  if (path && path.length > 1) return `path: '${path.join(" -> ")}'`;
+  if (path?.[0]) return `name: '${path}'`;
+  return "unspecified name attribute";
+}
+function _throwMissingValueAccessorError(dir) {
+  const loc = _describeControlLocation(dir);
+  throw new RuntimeError(-1203, `No value accessor for form control ${loc}.`);
+}
+function _throwInvalidValueAccessorError(dir) {
+  const loc = _describeControlLocation(dir);
+  throw new RuntimeError(1200, `Value accessor was not provided as an array for form control with ${loc}. Check that the \`NG_VALUE_ACCESSOR\` token is configured as a \`multi: true\` provider.`);
+}
+function isPropertyUpdated(changes, viewModel) {
+  if (!changes.hasOwnProperty("model")) return false;
+  const change = changes["model"];
+  if (change.isFirstChange()) return true;
+  return !Object.is(viewModel, change.currentValue);
+}
+function isBuiltInAccessor(valueAccessor) {
+  return Object.getPrototypeOf(valueAccessor.constructor) === BuiltInControlValueAccessor;
+}
+function syncPendingControls(form, directives) {
+  form._syncPendingControls();
+  directives.forEach((dir) => {
+    const control = dir.control;
+    if (control.updateOn === "submit" && control._pendingChange) {
+      dir.viewToModelUpdate(control._pendingValue);
+      control._pendingChange = false;
+    }
+  });
+}
+function selectValueAccessor(dir, valueAccessors) {
+  if (!valueAccessors) return null;
+  if (!Array.isArray(valueAccessors) && (typeof ngDevMode === "undefined" || ngDevMode)) _throwInvalidValueAccessorError(dir);
+  let defaultAccessor = void 0;
+  let builtinAccessor = void 0;
+  let customAccessor = void 0;
+  valueAccessors.forEach((v) => {
+    if (v.constructor === DefaultValueAccessor) {
+      defaultAccessor = v;
+    } else if (isBuiltInAccessor(v)) {
+      if (builtinAccessor && (typeof ngDevMode === "undefined" || ngDevMode)) _throwError(dir, "More than one built-in value accessor matches form control with");
+      builtinAccessor = v;
+    } else {
+      if (customAccessor && (typeof ngDevMode === "undefined" || ngDevMode)) _throwError(dir, "More than one custom value accessor matches form control with");
+      customAccessor = v;
+    }
+  });
+  if (customAccessor) return customAccessor;
+  if (builtinAccessor) return builtinAccessor;
+  if (defaultAccessor) return defaultAccessor;
+  if (typeof ngDevMode === "undefined" || ngDevMode) {
+    _throwError(dir, "No valid value accessor for form control with");
+  }
+  return null;
+}
+function removeListItem$1(list, el) {
+  const index = list.indexOf(el);
+  if (index > -1) list.splice(index, 1);
+}
+function _ngModelWarning(name, type, instance, warningConfig) {
+  if (warningConfig === "never") return;
+  if ((warningConfig === null || warningConfig === "once") && !type._ngModelWarningSentOnce || warningConfig === "always" && !instance._ngModelWarningSent) {
+    console.warn(ngModelWarning(name));
+    type._ngModelWarningSentOnce = true;
+    instance._ngModelWarningSent = true;
+  }
+}
+var formDirectiveProvider$2 = {
+  provide: ControlContainer,
+  useExisting: forwardRef(() => NgForm)
+};
+var resolvedPromise$1 = (() => Promise.resolve())();
+var NgForm = class _NgForm extends ControlContainer {
+  callSetDisabledState;
+  get submitted() {
+    return untracked2(this.submittedReactive);
+  }
+  _submitted = computed(() => this.submittedReactive(), ...ngDevMode ? [{
+    debugName: "_submitted"
+  }] : []);
+  submittedReactive = signal(false, ...ngDevMode ? [{
+    debugName: "submittedReactive"
+  }] : []);
+  _directives = /* @__PURE__ */ new Set();
+  form;
+  ngSubmit = new EventEmitter();
+  options;
+  constructor(validators, asyncValidators, callSetDisabledState) {
+    super();
+    this.callSetDisabledState = callSetDisabledState;
+    this.form = new FormGroup({}, composeValidators(validators), composeAsyncValidators(asyncValidators));
+  }
+  ngAfterViewInit() {
+    this._setUpdateStrategy();
+  }
+  get formDirective() {
+    return this;
+  }
+  get control() {
+    return this.form;
+  }
+  get path() {
+    return [];
+  }
+  get controls() {
+    return this.form.controls;
+  }
+  addControl(dir) {
+    resolvedPromise$1.then(() => {
+      const container = this._findContainer(dir.path);
+      dir.control = container.registerControl(dir.name, dir.control);
+      setUpControl(dir.control, dir, this.callSetDisabledState);
+      dir.control.updateValueAndValidity({
+        emitEvent: false
+      });
+      this._directives.add(dir);
+    });
+  }
+  getControl(dir) {
+    return this.form.get(dir.path);
+  }
+  removeControl(dir) {
+    resolvedPromise$1.then(() => {
+      const container = this._findContainer(dir.path);
+      container?.removeControl(dir.name);
+      this._directives.delete(dir);
+    });
+  }
+  addFormGroup(dir) {
+    resolvedPromise$1.then(() => {
+      const container = this._findContainer(dir.path);
+      const group = new FormGroup({});
+      setUpFormContainer(group, dir);
+      container.registerControl(dir.name, group);
+      group.updateValueAndValidity({
+        emitEvent: false
+      });
+    });
+  }
+  removeFormGroup(dir) {
+    resolvedPromise$1.then(() => {
+      const container = this._findContainer(dir.path);
+      container?.removeControl?.(dir.name);
+    });
+  }
+  getFormGroup(dir) {
+    return this.form.get(dir.path);
+  }
+  updateModel(dir, value) {
+    resolvedPromise$1.then(() => {
+      const ctrl = this.form.get(dir.path);
+      ctrl.setValue(value);
+    });
+  }
+  setValue(value) {
+    this.control.setValue(value);
+  }
+  onSubmit($event) {
+    this.submittedReactive.set(true);
+    syncPendingControls(this.form, this._directives);
+    this.ngSubmit.emit($event);
+    this.form._events.next(new FormSubmittedEvent(this.control));
+    return $event?.target?.method === "dialog";
+  }
+  onReset() {
+    this.resetForm();
+  }
+  resetForm(value = void 0) {
+    this.form.reset(value);
+    this.submittedReactive.set(false);
+  }
+  _setUpdateStrategy() {
+    if (this.options && this.options.updateOn != null) {
+      this.form._updateOn = this.options.updateOn;
+    }
+  }
+  _findContainer(path) {
+    path.pop();
+    return path.length ? this.form.get(path) : this.form;
+  }
+  static \u0275fac = function NgForm_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _NgForm)(\u0275\u0275directiveInject(NG_VALIDATORS, 10), \u0275\u0275directiveInject(NG_ASYNC_VALIDATORS, 10), \u0275\u0275directiveInject(CALL_SET_DISABLED_STATE, 8));
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _NgForm,
+    selectors: [["form", 3, "ngNoForm", "", 3, "formGroup", "", 3, "formArray", ""], ["ng-form"], ["", "ngForm", ""]],
+    hostBindings: function NgForm_HostBindings(rf, ctx) {
+      if (rf & 1) {
+        \u0275\u0275listener("submit", function NgForm_submit_HostBindingHandler($event) {
+          return ctx.onSubmit($event);
+        })("reset", function NgForm_reset_HostBindingHandler() {
+          return ctx.onReset();
+        });
+      }
+    },
+    inputs: {
+      options: [0, "ngFormOptions", "options"]
+    },
+    outputs: {
+      ngSubmit: "ngSubmit"
+    },
+    exportAs: ["ngForm"],
+    standalone: false,
+    features: [\u0275\u0275ProvidersFeature([formDirectiveProvider$2]), \u0275\u0275InheritDefinitionFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgForm, [{
+    type: Directive,
+    args: [{
+      selector: "form:not([ngNoForm]):not([formGroup]):not([formArray]),ng-form,[ngForm]",
+      providers: [formDirectiveProvider$2],
+      host: {
+        "(submit)": "onSubmit($event)",
+        "(reset)": "onReset()"
+      },
+      outputs: ["ngSubmit"],
+      exportAs: "ngForm",
+      standalone: false
+    }]
+  }], () => [{
+    type: void 0,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Self
+    }, {
+      type: Inject,
+      args: [NG_VALIDATORS]
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Self
+    }, {
+      type: Inject,
+      args: [NG_ASYNC_VALIDATORS]
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Inject,
+      args: [CALL_SET_DISABLED_STATE]
+    }]
+  }], {
+    options: [{
+      type: Input,
+      args: ["ngFormOptions"]
+    }]
+  });
+})();
+function removeListItem(list, el) {
+  const index = list.indexOf(el);
+  if (index > -1) list.splice(index, 1);
+}
+function isFormControlState(formState) {
+  return typeof formState === "object" && formState !== null && Object.keys(formState).length === 2 && "value" in formState && "disabled" in formState;
+}
+var FormControl = class FormControl2 extends AbstractControl {
+  defaultValue = null;
+  _onChange = [];
+  _pendingValue;
+  _pendingChange = false;
+  constructor(formState = null, validatorOrOpts, asyncValidator) {
+    super(pickValidators(validatorOrOpts), pickAsyncValidators(asyncValidator, validatorOrOpts));
+    this._applyFormState(formState);
+    this._setUpdateStrategy(validatorOrOpts);
+    this._initObservables();
+    this.updateValueAndValidity({
+      onlySelf: true,
+      emitEvent: !!this.asyncValidator
+    });
+    if (isOptionsObj(validatorOrOpts) && (validatorOrOpts.nonNullable || validatorOrOpts.initialValueIsDefault)) {
+      if (isFormControlState(formState)) {
+        this.defaultValue = formState.value;
+      } else {
+        this.defaultValue = formState;
+      }
+    }
+  }
+  setValue(value, options = {}) {
+    this.value = this._pendingValue = value;
+    if (this._onChange.length && options.emitModelToViewChange !== false) {
+      this._onChange.forEach((changeFn) => changeFn(this.value, options.emitViewToModelChange !== false));
+    }
+    this.updateValueAndValidity(options);
+  }
+  patchValue(value, options = {}) {
+    this.setValue(value, options);
+  }
+  reset(formState = this.defaultValue, options = {}) {
+    this._applyFormState(formState);
+    this.markAsPristine(options);
+    this.markAsUntouched(options);
+    this.setValue(this.value, options);
+    if (options.overwriteDefaultValue) {
+      this.defaultValue = this.value;
+    }
+    this._pendingChange = false;
+    if (options?.emitEvent !== false) {
+      this._events.next(new FormResetEvent(this));
+    }
+  }
+  _updateValue() {
+  }
+  _anyControls(condition) {
+    return false;
+  }
+  _allControlsDisabled() {
+    return this.disabled;
+  }
+  registerOnChange(fn) {
+    this._onChange.push(fn);
+  }
+  _unregisterOnChange(fn) {
+    removeListItem(this._onChange, fn);
+  }
+  registerOnDisabledChange(fn) {
+    this._onDisabledChange.push(fn);
+  }
+  _unregisterOnDisabledChange(fn) {
+    removeListItem(this._onDisabledChange, fn);
+  }
+  _forEachChild(cb) {
+  }
+  _syncPendingControls() {
+    if (this.updateOn === "submit") {
+      if (this._pendingDirty) this.markAsDirty();
+      if (this._pendingTouched) this.markAsTouched();
+      if (this._pendingChange) {
+        this.setValue(this._pendingValue, {
+          onlySelf: true,
+          emitModelToViewChange: false
+        });
+        return true;
+      }
+    }
+    return false;
+  }
+  _applyFormState(formState) {
+    if (isFormControlState(formState)) {
+      this.value = this._pendingValue = formState.value;
+      formState.disabled ? this.disable({
+        onlySelf: true,
+        emitEvent: false
+      }) : this.enable({
+        onlySelf: true,
+        emitEvent: false
+      });
+    } else {
+      this.value = this._pendingValue = formState;
+    }
+  }
+};
+var isFormControl = (control) => control instanceof FormControl;
+var AbstractFormGroupDirective = class _AbstractFormGroupDirective extends ControlContainer {
+  _parent;
+  ngOnInit() {
+    this._checkParentType();
+    this.formDirective.addFormGroup(this);
+  }
+  ngOnDestroy() {
+    this.formDirective?.removeFormGroup(this);
+  }
+  get control() {
+    return this.formDirective.getFormGroup(this);
+  }
+  get path() {
+    return controlPath(this.name == null ? this.name : this.name.toString(), this._parent);
+  }
+  get formDirective() {
+    return this._parent ? this._parent.formDirective : null;
+  }
+  _checkParentType() {
+  }
+  static \u0275fac = /* @__PURE__ */ (() => {
+    let \u0275AbstractFormGroupDirective_BaseFactory;
+    return function AbstractFormGroupDirective_Factory(__ngFactoryType__) {
+      return (\u0275AbstractFormGroupDirective_BaseFactory || (\u0275AbstractFormGroupDirective_BaseFactory = \u0275\u0275getInheritedFactory(_AbstractFormGroupDirective)))(__ngFactoryType__ || _AbstractFormGroupDirective);
+    };
+  })();
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _AbstractFormGroupDirective,
+    standalone: false,
+    features: [\u0275\u0275InheritDefinitionFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(AbstractFormGroupDirective, [{
+    type: Directive,
+    args: [{
+      standalone: false
+    }]
+  }], null, null);
+})();
+function modelParentException() {
+  return new RuntimeError(1350, `
+    ngModel cannot be used to register form controls with a parent formGroup directive.  Try using
+    formGroup's partner directive "formControlName" instead.  Example:
+
+    ${formControlNameExample}
+
+    Or, if you'd like to avoid registering this form control, indicate that it's standalone in ngModelOptions:
+
+    Example:
+
+    ${ngModelWithFormGroupExample}`);
+}
+function formGroupNameException() {
+  return new RuntimeError(1351, `
+    ngModel cannot be used to register form controls with a parent formGroupName or formArrayName directive.
+
+    Option 1: Use formControlName instead of ngModel (reactive strategy):
+
+    ${formGroupNameExample}
+
+    Option 2:  Update ngModel's parent be ngModelGroup (template-driven strategy):
+
+    ${ngModelGroupExample}`);
+}
+function missingNameException() {
+  return new RuntimeError(1352, `If ngModel is used within a form tag, either the name attribute must be set or the form
+    control must be defined as 'standalone' in ngModelOptions.
+
+    Example 1: <input [(ngModel)]="person.firstName" name="first">
+    Example 2: <input [(ngModel)]="person.firstName" [ngModelOptions]="{standalone: true}">`);
+}
+function modelGroupParentException() {
+  return new RuntimeError(1353, `
+    ngModelGroup cannot be used with a parent formGroup directive.
+
+    Option 1: Use formGroupName instead of ngModelGroup (reactive strategy):
+
+    ${formGroupNameExample}
+
+    Option 2:  Use a regular form tag instead of the formGroup directive (template-driven strategy):
+
+    ${ngModelGroupExample}`);
+}
+var modelGroupProvider = {
+  provide: ControlContainer,
+  useExisting: forwardRef(() => NgModelGroup)
+};
+var NgModelGroup = class _NgModelGroup extends AbstractFormGroupDirective {
+  name = "";
+  constructor(parent, validators, asyncValidators) {
+    super();
+    this._parent = parent;
+    this._setValidators(validators);
+    this._setAsyncValidators(asyncValidators);
+  }
+  _checkParentType() {
+    if (!(this._parent instanceof _NgModelGroup) && !(this._parent instanceof NgForm) && (typeof ngDevMode === "undefined" || ngDevMode)) {
+      throw modelGroupParentException();
+    }
+  }
+  static \u0275fac = function NgModelGroup_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _NgModelGroup)(\u0275\u0275directiveInject(ControlContainer, 5), \u0275\u0275directiveInject(NG_VALIDATORS, 10), \u0275\u0275directiveInject(NG_ASYNC_VALIDATORS, 10));
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _NgModelGroup,
+    selectors: [["", "ngModelGroup", ""]],
+    inputs: {
+      name: [0, "ngModelGroup", "name"]
+    },
+    exportAs: ["ngModelGroup"],
+    standalone: false,
+    features: [\u0275\u0275ProvidersFeature([modelGroupProvider]), \u0275\u0275InheritDefinitionFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgModelGroup, [{
+    type: Directive,
+    args: [{
+      selector: "[ngModelGroup]",
+      providers: [modelGroupProvider],
+      exportAs: "ngModelGroup",
+      standalone: false
+    }]
+  }], () => [{
+    type: ControlContainer,
+    decorators: [{
+      type: Host
+    }, {
+      type: SkipSelf
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Self
+    }, {
+      type: Inject,
+      args: [NG_VALIDATORS]
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Self
+    }, {
+      type: Inject,
+      args: [NG_ASYNC_VALIDATORS]
+    }]
+  }], {
+    name: [{
+      type: Input,
+      args: ["ngModelGroup"]
+    }]
+  });
+})();
+var formControlBinding$1 = {
+  provide: NgControl,
+  useExisting: forwardRef(() => NgModel)
+};
+var resolvedPromise = (() => Promise.resolve())();
+var NgModel = class _NgModel extends NgControl {
+  _changeDetectorRef;
+  callSetDisabledState;
+  control = new FormControl();
+  static ngAcceptInputType_isDisabled;
+  _registered = false;
+  viewModel;
+  name = "";
+  isDisabled;
+  model;
+  options;
+  update = new EventEmitter();
+  constructor(parent, validators, asyncValidators, valueAccessors, _changeDetectorRef, callSetDisabledState) {
+    super();
+    this._changeDetectorRef = _changeDetectorRef;
+    this.callSetDisabledState = callSetDisabledState;
+    this._parent = parent;
+    this._setValidators(validators);
+    this._setAsyncValidators(asyncValidators);
+    this.valueAccessor = selectValueAccessor(this, valueAccessors);
+  }
+  ngOnChanges(changes) {
+    this._checkForErrors();
+    if (!this._registered || "name" in changes) {
+      if (this._registered) {
+        this._checkName();
+        if (this.formDirective) {
+          const oldName = changes["name"].previousValue;
+          this.formDirective.removeControl({
+            name: oldName,
+            path: this._getPath(oldName)
+          });
+        }
+      }
+      this._setUpControl();
+    }
+    if ("isDisabled" in changes) {
+      this._updateDisabled(changes);
+    }
+    if (isPropertyUpdated(changes, this.viewModel)) {
+      this._updateValue(this.model);
+      this.viewModel = this.model;
+    }
+  }
+  ngOnDestroy() {
+    this.formDirective?.removeControl(this);
+  }
+  get path() {
+    return this._getPath(this.name);
+  }
+  get formDirective() {
+    return this._parent ? this._parent.formDirective : null;
+  }
+  viewToModelUpdate(newValue) {
+    this.viewModel = newValue;
+    this.update.emit(newValue);
+  }
+  _setUpControl() {
+    this._setUpdateStrategy();
+    this._isStandalone() ? this._setUpStandalone() : this.formDirective.addControl(this);
+    this._registered = true;
+  }
+  _setUpdateStrategy() {
+    if (this.options && this.options.updateOn != null) {
+      this.control._updateOn = this.options.updateOn;
+    }
+  }
+  _isStandalone() {
+    return !this._parent || !!(this.options && this.options.standalone);
+  }
+  _setUpStandalone() {
+    setUpControl(this.control, this, this.callSetDisabledState);
+    this.control.updateValueAndValidity({
+      emitEvent: false
+    });
+  }
+  _checkForErrors() {
+    if ((typeof ngDevMode === "undefined" || ngDevMode) && !this._isStandalone()) {
+      checkParentType$1(this._parent);
+    }
+    this._checkName();
+  }
+  _checkName() {
+    if (this.options && this.options.name) this.name = this.options.name;
+    if (!this._isStandalone() && !this.name && (typeof ngDevMode === "undefined" || ngDevMode)) {
+      throw missingNameException();
+    }
+  }
+  _updateValue(value) {
+    resolvedPromise.then(() => {
+      this.control.setValue(value, {
+        emitViewToModelChange: false
+      });
+      this._changeDetectorRef?.markForCheck();
+    });
+  }
+  _updateDisabled(changes) {
+    const disabledValue = changes["isDisabled"].currentValue;
+    const isDisabled = disabledValue !== 0 && booleanAttribute(disabledValue);
+    resolvedPromise.then(() => {
+      if (isDisabled && !this.control.disabled) {
+        this.control.disable();
+      } else if (!isDisabled && this.control.disabled) {
+        this.control.enable();
+      }
+      this._changeDetectorRef?.markForCheck();
+    });
+  }
+  _getPath(controlName) {
+    return this._parent ? controlPath(controlName, this._parent) : [controlName];
+  }
+  static \u0275fac = function NgModel_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _NgModel)(\u0275\u0275directiveInject(ControlContainer, 9), \u0275\u0275directiveInject(NG_VALIDATORS, 10), \u0275\u0275directiveInject(NG_ASYNC_VALIDATORS, 10), \u0275\u0275directiveInject(NG_VALUE_ACCESSOR, 10), \u0275\u0275directiveInject(ChangeDetectorRef, 8), \u0275\u0275directiveInject(CALL_SET_DISABLED_STATE, 8));
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _NgModel,
+    selectors: [["", "ngModel", "", 3, "formControlName", "", 3, "formControl", ""]],
+    inputs: {
+      name: "name",
+      isDisabled: [0, "disabled", "isDisabled"],
+      model: [0, "ngModel", "model"],
+      options: [0, "ngModelOptions", "options"]
+    },
+    outputs: {
+      update: "ngModelChange"
+    },
+    exportAs: ["ngModel"],
+    standalone: false,
+    features: [\u0275\u0275ProvidersFeature([formControlBinding$1]), \u0275\u0275InheritDefinitionFeature, \u0275\u0275NgOnChangesFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgModel, [{
+    type: Directive,
+    args: [{
+      selector: "[ngModel]:not([formControlName]):not([formControl])",
+      providers: [formControlBinding$1],
+      exportAs: "ngModel",
+      standalone: false
+    }]
+  }], () => [{
+    type: ControlContainer,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Host
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Self
+    }, {
+      type: Inject,
+      args: [NG_VALIDATORS]
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Self
+    }, {
+      type: Inject,
+      args: [NG_ASYNC_VALIDATORS]
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Self
+    }, {
+      type: Inject,
+      args: [NG_VALUE_ACCESSOR]
+    }]
+  }, {
+    type: ChangeDetectorRef,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Inject,
+      args: [ChangeDetectorRef]
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Inject,
+      args: [CALL_SET_DISABLED_STATE]
+    }]
+  }], {
+    name: [{
+      type: Input
+    }],
+    isDisabled: [{
+      type: Input,
+      args: ["disabled"]
+    }],
+    model: [{
+      type: Input,
+      args: ["ngModel"]
+    }],
+    options: [{
+      type: Input,
+      args: ["ngModelOptions"]
+    }],
+    update: [{
+      type: Output,
+      args: ["ngModelChange"]
+    }]
+  });
+})();
+function checkParentType$1(parent) {
+  if (!(parent instanceof NgModelGroup) && parent instanceof AbstractFormGroupDirective) {
+    throw formGroupNameException();
+  } else if (!(parent instanceof NgModelGroup) && !(parent instanceof NgForm)) {
+    throw modelParentException();
+  }
+}
+var \u0275NgNoValidate = class _\u0275NgNoValidate {
+  static \u0275fac = function \u0275NgNoValidate_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _\u0275NgNoValidate)();
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _\u0275NgNoValidate,
+    selectors: [["form", 3, "ngNoForm", "", 3, "ngNativeValidate", ""]],
+    hostAttrs: ["novalidate", ""],
+    standalone: false
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(\u0275NgNoValidate, [{
+    type: Directive,
+    args: [{
+      selector: "form:not([ngNoForm]):not([ngNativeValidate])",
+      host: {
+        "novalidate": ""
+      },
+      standalone: false
+    }]
+  }], null, null);
+})();
+var NUMBER_VALUE_ACCESSOR = {
+  provide: NG_VALUE_ACCESSOR,
+  useExisting: forwardRef(() => NumberValueAccessor),
+  multi: true
+};
+var NumberValueAccessor = class _NumberValueAccessor extends BuiltInControlValueAccessor {
+  writeValue(value) {
+    const normalizedValue = value == null ? "" : value;
+    this.setProperty("value", normalizedValue);
+  }
+  registerOnChange(fn) {
+    this.onChange = (value) => {
+      fn(value == "" ? null : parseFloat(value));
+    };
+  }
+  static \u0275fac = /* @__PURE__ */ (() => {
+    let \u0275NumberValueAccessor_BaseFactory;
+    return function NumberValueAccessor_Factory(__ngFactoryType__) {
+      return (\u0275NumberValueAccessor_BaseFactory || (\u0275NumberValueAccessor_BaseFactory = \u0275\u0275getInheritedFactory(_NumberValueAccessor)))(__ngFactoryType__ || _NumberValueAccessor);
+    };
+  })();
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _NumberValueAccessor,
+    selectors: [["input", "type", "number", "formControlName", ""], ["input", "type", "number", "formControl", ""], ["input", "type", "number", "ngModel", ""]],
+    hostBindings: function NumberValueAccessor_HostBindings(rf, ctx) {
+      if (rf & 1) {
+        \u0275\u0275listener("input", function NumberValueAccessor_input_HostBindingHandler($event) {
+          return ctx.onChange($event.target.value);
+        })("blur", function NumberValueAccessor_blur_HostBindingHandler() {
+          return ctx.onTouched();
+        });
+      }
+    },
+    standalone: false,
+    features: [\u0275\u0275ProvidersFeature([NUMBER_VALUE_ACCESSOR]), \u0275\u0275InheritDefinitionFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NumberValueAccessor, [{
+    type: Directive,
+    args: [{
+      selector: "input[type=number][formControlName],input[type=number][formControl],input[type=number][ngModel]",
+      host: {
+        "(input)": "onChange($any($event.target).value)",
+        "(blur)": "onTouched()"
+      },
+      providers: [NUMBER_VALUE_ACCESSOR],
+      standalone: false
+    }]
+  }], null, null);
+})();
+var RADIO_VALUE_ACCESSOR = {
+  provide: NG_VALUE_ACCESSOR,
+  useExisting: forwardRef(() => RadioControlValueAccessor),
+  multi: true
+};
+function throwNameError() {
+  throw new RuntimeError(1202, `
+      If you define both a name and a formControlName attribute on your radio button, their values
+      must match. Ex: <input type="radio" formControlName="food" name="food">
+    `);
+}
+var RadioControlRegistry = class _RadioControlRegistry {
+  _accessors = [];
+  add(control, accessor) {
+    this._accessors.push([control, accessor]);
+  }
+  remove(accessor) {
+    for (let i = this._accessors.length - 1; i >= 0; --i) {
+      if (this._accessors[i][1] === accessor) {
+        this._accessors.splice(i, 1);
+        return;
+      }
+    }
+  }
+  select(accessor) {
+    this._accessors.forEach((c) => {
+      if (this._isSameGroup(c, accessor) && c[1] !== accessor) {
+        c[1].fireUncheck(accessor.value);
+      }
+    });
+  }
+  _isSameGroup(controlPair, accessor) {
+    if (!controlPair[0].control) return false;
+    return controlPair[0]._parent === accessor._control._parent && controlPair[1].name === accessor.name;
+  }
+  static \u0275fac = function RadioControlRegistry_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _RadioControlRegistry)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _RadioControlRegistry,
+    factory: _RadioControlRegistry.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(RadioControlRegistry, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], null, null);
+})();
+var RadioControlValueAccessor = class _RadioControlValueAccessor extends BuiltInControlValueAccessor {
+  _registry;
+  _injector;
+  _state;
+  _control;
+  _fn;
+  setDisabledStateFired = false;
+  onChange = () => {
+  };
+  name;
+  formControlName;
+  value;
+  callSetDisabledState = inject2(CALL_SET_DISABLED_STATE, {
+    optional: true
+  }) ?? setDisabledStateDefault;
+  constructor(renderer, elementRef, _registry, _injector) {
+    super(renderer, elementRef);
+    this._registry = _registry;
+    this._injector = _injector;
+  }
+  ngOnInit() {
+    this._control = this._injector.get(NgControl);
+    this._checkName();
+    this._registry.add(this._control, this);
+  }
+  ngOnDestroy() {
+    this._registry.remove(this);
+  }
+  writeValue(value) {
+    this._state = value === this.value;
+    this.setProperty("checked", this._state);
+  }
+  registerOnChange(fn) {
+    this._fn = fn;
+    this.onChange = () => {
+      fn(this.value);
+      this._registry.select(this);
+    };
+  }
+  setDisabledState(isDisabled) {
+    if (this.setDisabledStateFired || isDisabled || this.callSetDisabledState === "whenDisabledForLegacyCode") {
+      this.setProperty("disabled", isDisabled);
+    }
+    this.setDisabledStateFired = true;
+  }
+  fireUncheck(value) {
+    this.writeValue(value);
+  }
+  _checkName() {
+    if (this.name && this.formControlName && this.name !== this.formControlName && (typeof ngDevMode === "undefined" || ngDevMode)) {
+      throwNameError();
+    }
+    if (!this.name && this.formControlName) this.name = this.formControlName;
+  }
+  static \u0275fac = function RadioControlValueAccessor_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _RadioControlValueAccessor)(\u0275\u0275directiveInject(Renderer2), \u0275\u0275directiveInject(ElementRef), \u0275\u0275directiveInject(RadioControlRegistry), \u0275\u0275directiveInject(Injector));
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _RadioControlValueAccessor,
+    selectors: [["input", "type", "radio", "formControlName", ""], ["input", "type", "radio", "formControl", ""], ["input", "type", "radio", "ngModel", ""]],
+    hostBindings: function RadioControlValueAccessor_HostBindings(rf, ctx) {
+      if (rf & 1) {
+        \u0275\u0275listener("change", function RadioControlValueAccessor_change_HostBindingHandler() {
+          return ctx.onChange();
+        })("blur", function RadioControlValueAccessor_blur_HostBindingHandler() {
+          return ctx.onTouched();
+        });
+      }
+    },
+    inputs: {
+      name: "name",
+      formControlName: "formControlName",
+      value: "value"
+    },
+    standalone: false,
+    features: [\u0275\u0275ProvidersFeature([RADIO_VALUE_ACCESSOR]), \u0275\u0275InheritDefinitionFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(RadioControlValueAccessor, [{
+    type: Directive,
+    args: [{
+      selector: "input[type=radio][formControlName],input[type=radio][formControl],input[type=radio][ngModel]",
+      host: {
+        "(change)": "onChange()",
+        "(blur)": "onTouched()"
+      },
+      providers: [RADIO_VALUE_ACCESSOR],
+      standalone: false
+    }]
+  }], () => [{
+    type: Renderer2
+  }, {
+    type: ElementRef
+  }, {
+    type: RadioControlRegistry
+  }, {
+    type: Injector
+  }], {
+    name: [{
+      type: Input
+    }],
+    formControlName: [{
+      type: Input
+    }],
+    value: [{
+      type: Input
+    }]
+  });
+})();
+var RANGE_VALUE_ACCESSOR = {
+  provide: NG_VALUE_ACCESSOR,
+  useExisting: forwardRef(() => RangeValueAccessor),
+  multi: true
+};
+var RangeValueAccessor = class _RangeValueAccessor extends BuiltInControlValueAccessor {
+  writeValue(value) {
+    this.setProperty("value", parseFloat(value));
+  }
+  registerOnChange(fn) {
+    this.onChange = (value) => {
+      fn(value == "" ? null : parseFloat(value));
+    };
+  }
+  static \u0275fac = /* @__PURE__ */ (() => {
+    let \u0275RangeValueAccessor_BaseFactory;
+    return function RangeValueAccessor_Factory(__ngFactoryType__) {
+      return (\u0275RangeValueAccessor_BaseFactory || (\u0275RangeValueAccessor_BaseFactory = \u0275\u0275getInheritedFactory(_RangeValueAccessor)))(__ngFactoryType__ || _RangeValueAccessor);
+    };
+  })();
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _RangeValueAccessor,
+    selectors: [["input", "type", "range", "formControlName", ""], ["input", "type", "range", "formControl", ""], ["input", "type", "range", "ngModel", ""]],
+    hostBindings: function RangeValueAccessor_HostBindings(rf, ctx) {
+      if (rf & 1) {
+        \u0275\u0275listener("change", function RangeValueAccessor_change_HostBindingHandler($event) {
+          return ctx.onChange($event.target.value);
+        })("input", function RangeValueAccessor_input_HostBindingHandler($event) {
+          return ctx.onChange($event.target.value);
+        })("blur", function RangeValueAccessor_blur_HostBindingHandler() {
+          return ctx.onTouched();
+        });
+      }
+    },
+    standalone: false,
+    features: [\u0275\u0275ProvidersFeature([RANGE_VALUE_ACCESSOR]), \u0275\u0275InheritDefinitionFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(RangeValueAccessor, [{
+    type: Directive,
+    args: [{
+      selector: "input[type=range][formControlName],input[type=range][formControl],input[type=range][ngModel]",
+      host: {
+        "(change)": "onChange($any($event.target).value)",
+        "(input)": "onChange($any($event.target).value)",
+        "(blur)": "onTouched()"
+      },
+      providers: [RANGE_VALUE_ACCESSOR],
+      standalone: false
+    }]
+  }], null, null);
+})();
+var FormArray = class extends AbstractControl {
+  constructor(controls, validatorOrOpts, asyncValidator) {
+    super(pickValidators(validatorOrOpts), pickAsyncValidators(asyncValidator, validatorOrOpts));
+    this.controls = controls;
+    this._initObservables();
+    this._setUpdateStrategy(validatorOrOpts);
+    this._setUpControls();
+    this.updateValueAndValidity({
+      onlySelf: true,
+      emitEvent: !!this.asyncValidator
+    });
+  }
+  controls;
+  at(index) {
+    return this.controls[this._adjustIndex(index)];
+  }
+  push(control, options = {}) {
+    if (Array.isArray(control)) {
+      control.forEach((ctrl) => {
+        this.controls.push(ctrl);
+        this._registerControl(ctrl);
+      });
+    } else {
+      this.controls.push(control);
+      this._registerControl(control);
+    }
+    this.updateValueAndValidity({
+      emitEvent: options.emitEvent
+    });
+    this._onCollectionChange();
+  }
+  insert(index, control, options = {}) {
+    this.controls.splice(index, 0, control);
+    this._registerControl(control);
+    this.updateValueAndValidity({
+      emitEvent: options.emitEvent
+    });
+  }
+  removeAt(index, options = {}) {
+    let adjustedIndex = this._adjustIndex(index);
+    if (adjustedIndex < 0) adjustedIndex = 0;
+    if (this.controls[adjustedIndex]) this.controls[adjustedIndex]._registerOnCollectionChange(() => {
+    });
+    this.controls.splice(adjustedIndex, 1);
+    this.updateValueAndValidity({
+      emitEvent: options.emitEvent
+    });
+  }
+  setControl(index, control, options = {}) {
+    let adjustedIndex = this._adjustIndex(index);
+    if (adjustedIndex < 0) adjustedIndex = 0;
+    if (this.controls[adjustedIndex]) this.controls[adjustedIndex]._registerOnCollectionChange(() => {
+    });
+    this.controls.splice(adjustedIndex, 1);
+    if (control) {
+      this.controls.splice(adjustedIndex, 0, control);
+      this._registerControl(control);
+    }
+    this.updateValueAndValidity({
+      emitEvent: options.emitEvent
+    });
+    this._onCollectionChange();
+  }
+  get length() {
+    return this.controls.length;
+  }
+  setValue(value, options = {}) {
+    assertAllValuesPresent(this, false, value);
+    value.forEach((newValue, index) => {
+      assertControlPresent(this, false, index);
+      this.at(index).setValue(newValue, {
+        onlySelf: true,
+        emitEvent: options.emitEvent
+      });
+    });
+    this.updateValueAndValidity(options);
+  }
+  patchValue(value, options = {}) {
+    if (value == null) return;
+    value.forEach((newValue, index) => {
+      if (this.at(index)) {
+        this.at(index).patchValue(newValue, {
+          onlySelf: true,
+          emitEvent: options.emitEvent
+        });
+      }
+    });
+    this.updateValueAndValidity(options);
+  }
+  reset(value = [], options = {}) {
+    this._forEachChild((control, index) => {
+      control.reset(value[index], __spreadProps(__spreadValues({}, options), {
+        onlySelf: true
+      }));
+    });
+    this._updatePristine(options, this);
+    this._updateTouched(options, this);
+    this.updateValueAndValidity(options);
+    if (options?.emitEvent !== false) {
+      this._events.next(new FormResetEvent(this));
+    }
+  }
+  getRawValue() {
+    return this.controls.map((control) => control.getRawValue());
+  }
+  clear(options = {}) {
+    if (this.controls.length < 1) return;
+    this._forEachChild((control) => control._registerOnCollectionChange(() => {
+    }));
+    this.controls.splice(0);
+    this.updateValueAndValidity({
+      emitEvent: options.emitEvent
+    });
+  }
+  _adjustIndex(index) {
+    return index < 0 ? index + this.length : index;
+  }
+  _syncPendingControls() {
+    let subtreeUpdated = this.controls.reduce((updated, child) => {
+      return child._syncPendingControls() ? true : updated;
+    }, false);
+    if (subtreeUpdated) this.updateValueAndValidity({
+      onlySelf: true
+    });
+    return subtreeUpdated;
+  }
+  _forEachChild(cb) {
+    this.controls.forEach((control, index) => {
+      cb(control, index);
+    });
+  }
+  _updateValue() {
+    this.value = this.controls.filter((control) => control.enabled || this.disabled).map((control) => control.value);
+  }
+  _anyControls(condition) {
+    return this.controls.some((control) => control.enabled && condition(control));
+  }
+  _setUpControls() {
+    this._forEachChild((control) => this._registerControl(control));
+  }
+  _allControlsDisabled() {
+    for (const control of this.controls) {
+      if (control.enabled) return false;
+    }
+    return this.controls.length > 0 || this.disabled;
+  }
+  _registerControl(control) {
+    control.setParent(this);
+    control._registerOnCollectionChange(this._onCollectionChange);
+  }
+  _find(name) {
+    return this.at(name) ?? null;
+  }
+};
+var AbstractFormDirective = class _AbstractFormDirective extends ControlContainer {
+  callSetDisabledState;
+  get submitted() {
+    return untracked2(this._submittedReactive);
+  }
+  set submitted(value) {
+    this._submittedReactive.set(value);
+  }
+  _submitted = computed(() => this._submittedReactive(), ...ngDevMode ? [{
+    debugName: "_submitted"
+  }] : []);
+  _submittedReactive = signal(false, ...ngDevMode ? [{
+    debugName: "_submittedReactive"
+  }] : []);
+  _oldForm;
+  _onCollectionChange = () => this._updateDomValue();
+  directives = [];
+  constructor(validators, asyncValidators, callSetDisabledState) {
+    super();
+    this.callSetDisabledState = callSetDisabledState;
+    this._setValidators(validators);
+    this._setAsyncValidators(asyncValidators);
+  }
+  ngOnChanges(changes) {
+    this.onChanges(changes);
+  }
+  ngOnDestroy() {
+    this.onDestroy();
+  }
+  onChanges(changes) {
+    this._checkFormPresent();
+    if (changes.hasOwnProperty("form")) {
+      this._updateValidators();
+      this._updateDomValue();
+      this._updateRegistrations();
+      this._oldForm = this.form;
+    }
+  }
+  onDestroy() {
+    if (this.form) {
+      cleanUpValidators(this.form, this);
+      if (this.form._onCollectionChange === this._onCollectionChange) {
+        this.form._registerOnCollectionChange(() => {
+        });
+      }
+    }
+  }
+  get formDirective() {
+    return this;
+  }
+  get path() {
+    return [];
+  }
+  addControl(dir) {
+    const ctrl = this.form.get(dir.path);
+    setUpControl(ctrl, dir, this.callSetDisabledState);
+    ctrl.updateValueAndValidity({
+      emitEvent: false
+    });
+    this.directives.push(dir);
+    return ctrl;
+  }
+  getControl(dir) {
+    return this.form.get(dir.path);
+  }
+  removeControl(dir) {
+    cleanUpControl(dir.control || null, dir, false);
+    removeListItem$1(this.directives, dir);
+  }
+  addFormGroup(dir) {
+    this._setUpFormContainer(dir);
+  }
+  removeFormGroup(dir) {
+    this._cleanUpFormContainer(dir);
+  }
+  getFormGroup(dir) {
+    return this.form.get(dir.path);
+  }
+  getFormArray(dir) {
+    return this.form.get(dir.path);
+  }
+  addFormArray(dir) {
+    this._setUpFormContainer(dir);
+  }
+  removeFormArray(dir) {
+    this._cleanUpFormContainer(dir);
+  }
+  updateModel(dir, value) {
+    const ctrl = this.form.get(dir.path);
+    ctrl.setValue(value);
+  }
+  onReset() {
+    this.resetForm();
+  }
+  resetForm(value = void 0, options = {}) {
+    this.form.reset(value, options);
+    this._submittedReactive.set(false);
+  }
+  onSubmit($event) {
+    this.submitted = true;
+    syncPendingControls(this.form, this.directives);
+    this.ngSubmit.emit($event);
+    this.form._events.next(new FormSubmittedEvent(this.control));
+    return $event?.target?.method === "dialog";
+  }
+  _updateDomValue() {
+    this.directives.forEach((dir) => {
+      const oldCtrl = dir.control;
+      const newCtrl = this.form.get(dir.path);
+      if (oldCtrl !== newCtrl) {
+        cleanUpControl(oldCtrl || null, dir);
+        if (isFormControl(newCtrl)) {
+          setUpControl(newCtrl, dir, this.callSetDisabledState);
+          dir.control = newCtrl;
+        }
+      }
+    });
+    this.form._updateTreeValidity({
+      emitEvent: false
+    });
+  }
+  _setUpFormContainer(dir) {
+    const ctrl = this.form.get(dir.path);
+    setUpFormContainer(ctrl, dir);
+    ctrl.updateValueAndValidity({
+      emitEvent: false
+    });
+  }
+  _cleanUpFormContainer(dir) {
+    const ctrl = this.form?.get(dir.path);
+    if (ctrl) {
+      const isControlUpdated = cleanUpFormContainer(ctrl, dir);
+      if (isControlUpdated) {
+        ctrl.updateValueAndValidity({
+          emitEvent: false
+        });
+      }
+    }
+  }
+  _updateRegistrations() {
+    this.form._registerOnCollectionChange(this._onCollectionChange);
+    this._oldForm?._registerOnCollectionChange(() => {
+    });
+  }
+  _updateValidators() {
+    setUpValidators(this.form, this);
+    if (this._oldForm) {
+      cleanUpValidators(this._oldForm, this);
+    }
+  }
+  _checkFormPresent() {
+    if (!this.form && (typeof ngDevMode === "undefined" || ngDevMode)) {
+      throw missingFormException();
+    }
+  }
+  static \u0275fac = function AbstractFormDirective_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _AbstractFormDirective)(\u0275\u0275directiveInject(NG_VALIDATORS, 10), \u0275\u0275directiveInject(NG_ASYNC_VALIDATORS, 10), \u0275\u0275directiveInject(CALL_SET_DISABLED_STATE, 8));
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _AbstractFormDirective,
+    features: [\u0275\u0275InheritDefinitionFeature, \u0275\u0275NgOnChangesFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(AbstractFormDirective, [{
+    type: Directive
+  }], () => [{
+    type: void 0,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Self
+    }, {
+      type: Inject,
+      args: [NG_VALIDATORS]
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Self
+    }, {
+      type: Inject,
+      args: [NG_ASYNC_VALIDATORS]
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Inject,
+      args: [CALL_SET_DISABLED_STATE]
+    }]
+  }], null);
+})();
+var formDirectiveProvider$1 = {
+  provide: ControlContainer,
+  useExisting: forwardRef(() => FormArrayDirective)
+};
+var FormArrayDirective = class _FormArrayDirective extends AbstractFormDirective {
+  form = null;
+  ngSubmit = new EventEmitter();
+  get control() {
+    return this.form;
+  }
+  static \u0275fac = /* @__PURE__ */ (() => {
+    let \u0275FormArrayDirective_BaseFactory;
+    return function FormArrayDirective_Factory(__ngFactoryType__) {
+      return (\u0275FormArrayDirective_BaseFactory || (\u0275FormArrayDirective_BaseFactory = \u0275\u0275getInheritedFactory(_FormArrayDirective)))(__ngFactoryType__ || _FormArrayDirective);
+    };
+  })();
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _FormArrayDirective,
+    selectors: [["", "formArray", ""]],
+    hostBindings: function FormArrayDirective_HostBindings(rf, ctx) {
+      if (rf & 1) {
+        \u0275\u0275listener("submit", function FormArrayDirective_submit_HostBindingHandler($event) {
+          return ctx.onSubmit($event);
+        })("reset", function FormArrayDirective_reset_HostBindingHandler() {
+          return ctx.onReset();
+        });
+      }
+    },
+    inputs: {
+      form: [0, "formArray", "form"]
+    },
+    outputs: {
+      ngSubmit: "ngSubmit"
+    },
+    exportAs: ["ngForm"],
+    standalone: false,
+    features: [\u0275\u0275ProvidersFeature([formDirectiveProvider$1]), \u0275\u0275InheritDefinitionFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(FormArrayDirective, [{
+    type: Directive,
+    args: [{
+      selector: "[formArray]",
+      providers: [formDirectiveProvider$1],
+      host: {
+        "(submit)": "onSubmit($event)",
+        "(reset)": "onReset()"
+      },
+      exportAs: "ngForm",
+      standalone: false
+    }]
+  }], null, {
+    form: [{
+      type: Input,
+      args: ["formArray"]
+    }],
+    ngSubmit: [{
+      type: Output
+    }]
+  });
+})();
+var NG_MODEL_WITH_FORM_CONTROL_WARNING = new InjectionToken(typeof ngDevMode !== "undefined" && ngDevMode ? "NgModelWithFormControlWarning" : "");
+var formControlBinding = {
+  provide: NgControl,
+  useExisting: forwardRef(() => FormControlDirective)
+};
+var FormControlDirective = class _FormControlDirective extends NgControl {
+  _ngModelWarningConfig;
+  callSetDisabledState;
+  viewModel;
+  form;
+  set isDisabled(isDisabled) {
+    if (typeof ngDevMode === "undefined" || ngDevMode) {
+      console.warn(disabledAttrWarning);
+    }
+  }
+  model;
+  update = new EventEmitter();
+  static _ngModelWarningSentOnce = false;
+  _ngModelWarningSent = false;
+  constructor(validators, asyncValidators, valueAccessors, _ngModelWarningConfig, callSetDisabledState) {
+    super();
+    this._ngModelWarningConfig = _ngModelWarningConfig;
+    this.callSetDisabledState = callSetDisabledState;
+    this._setValidators(validators);
+    this._setAsyncValidators(asyncValidators);
+    this.valueAccessor = selectValueAccessor(this, valueAccessors);
+  }
+  ngOnChanges(changes) {
+    if (this._isControlChanged(changes)) {
+      const previousForm = changes["form"].previousValue;
+      if (previousForm) {
+        cleanUpControl(previousForm, this, false);
+      }
+      setUpControl(this.form, this, this.callSetDisabledState);
+      this.form.updateValueAndValidity({
+        emitEvent: false
+      });
+    }
+    if (isPropertyUpdated(changes, this.viewModel)) {
+      if (typeof ngDevMode === "undefined" || ngDevMode) {
+        _ngModelWarning("formControl", _FormControlDirective, this, this._ngModelWarningConfig);
+      }
+      this.form.setValue(this.model);
+      this.viewModel = this.model;
+    }
+  }
+  ngOnDestroy() {
+    if (this.form) {
+      cleanUpControl(this.form, this, false);
+    }
+  }
+  get path() {
+    return [];
+  }
+  get control() {
+    return this.form;
+  }
+  viewToModelUpdate(newValue) {
+    this.viewModel = newValue;
+    this.update.emit(newValue);
+  }
+  _isControlChanged(changes) {
+    return changes.hasOwnProperty("form");
+  }
+  static \u0275fac = function FormControlDirective_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _FormControlDirective)(\u0275\u0275directiveInject(NG_VALIDATORS, 10), \u0275\u0275directiveInject(NG_ASYNC_VALIDATORS, 10), \u0275\u0275directiveInject(NG_VALUE_ACCESSOR, 10), \u0275\u0275directiveInject(NG_MODEL_WITH_FORM_CONTROL_WARNING, 8), \u0275\u0275directiveInject(CALL_SET_DISABLED_STATE, 8));
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _FormControlDirective,
+    selectors: [["", "formControl", ""]],
+    inputs: {
+      form: [0, "formControl", "form"],
+      isDisabled: [0, "disabled", "isDisabled"],
+      model: [0, "ngModel", "model"]
+    },
+    outputs: {
+      update: "ngModelChange"
+    },
+    exportAs: ["ngForm"],
+    standalone: false,
+    features: [\u0275\u0275ProvidersFeature([formControlBinding]), \u0275\u0275InheritDefinitionFeature, \u0275\u0275NgOnChangesFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(FormControlDirective, [{
+    type: Directive,
+    args: [{
+      selector: "[formControl]",
+      providers: [formControlBinding],
+      exportAs: "ngForm",
+      standalone: false
+    }]
+  }], () => [{
+    type: void 0,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Self
+    }, {
+      type: Inject,
+      args: [NG_VALIDATORS]
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Self
+    }, {
+      type: Inject,
+      args: [NG_ASYNC_VALIDATORS]
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Self
+    }, {
+      type: Inject,
+      args: [NG_VALUE_ACCESSOR]
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Inject,
+      args: [NG_MODEL_WITH_FORM_CONTROL_WARNING]
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Inject,
+      args: [CALL_SET_DISABLED_STATE]
+    }]
+  }], {
+    form: [{
+      type: Input,
+      args: ["formControl"]
+    }],
+    isDisabled: [{
+      type: Input,
+      args: ["disabled"]
+    }],
+    model: [{
+      type: Input,
+      args: ["ngModel"]
+    }],
+    update: [{
+      type: Output,
+      args: ["ngModelChange"]
+    }]
+  });
+})();
+var formGroupNameProvider = {
+  provide: ControlContainer,
+  useExisting: forwardRef(() => FormGroupName)
+};
+var FormGroupName = class _FormGroupName extends AbstractFormGroupDirective {
+  name = null;
+  constructor(parent, validators, asyncValidators) {
+    super();
+    this._parent = parent;
+    this._setValidators(validators);
+    this._setAsyncValidators(asyncValidators);
+  }
+  _checkParentType() {
+    if (hasInvalidParent(this._parent) && (typeof ngDevMode === "undefined" || ngDevMode)) {
+      throw groupParentException();
+    }
+  }
+  static \u0275fac = function FormGroupName_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _FormGroupName)(\u0275\u0275directiveInject(ControlContainer, 13), \u0275\u0275directiveInject(NG_VALIDATORS, 10), \u0275\u0275directiveInject(NG_ASYNC_VALIDATORS, 10));
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _FormGroupName,
+    selectors: [["", "formGroupName", ""]],
+    inputs: {
+      name: [0, "formGroupName", "name"]
+    },
+    standalone: false,
+    features: [\u0275\u0275ProvidersFeature([formGroupNameProvider]), \u0275\u0275InheritDefinitionFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(FormGroupName, [{
+    type: Directive,
+    args: [{
+      selector: "[formGroupName]",
+      providers: [formGroupNameProvider],
+      standalone: false
+    }]
+  }], () => [{
+    type: ControlContainer,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Host
+    }, {
+      type: SkipSelf
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Self
+    }, {
+      type: Inject,
+      args: [NG_VALIDATORS]
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Self
+    }, {
+      type: Inject,
+      args: [NG_ASYNC_VALIDATORS]
+    }]
+  }], {
+    name: [{
+      type: Input,
+      args: ["formGroupName"]
+    }]
+  });
+})();
+var formArrayNameProvider = {
+  provide: ControlContainer,
+  useExisting: forwardRef(() => FormArrayName)
+};
+var FormArrayName = class _FormArrayName extends ControlContainer {
+  _parent;
+  name = null;
+  constructor(parent, validators, asyncValidators) {
+    super();
+    this._parent = parent;
+    this._setValidators(validators);
+    this._setAsyncValidators(asyncValidators);
+  }
+  ngOnInit() {
+    if (hasInvalidParent(this._parent) && (typeof ngDevMode === "undefined" || ngDevMode)) {
+      throw arrayParentException();
+    }
+    this.formDirective.addFormArray(this);
+  }
+  ngOnDestroy() {
+    this.formDirective?.removeFormArray(this);
+  }
+  get control() {
+    return this.formDirective.getFormArray(this);
+  }
+  get formDirective() {
+    return this._parent ? this._parent.formDirective : null;
+  }
+  get path() {
+    return controlPath(this.name == null ? this.name : this.name.toString(), this._parent);
+  }
+  static \u0275fac = function FormArrayName_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _FormArrayName)(\u0275\u0275directiveInject(ControlContainer, 13), \u0275\u0275directiveInject(NG_VALIDATORS, 10), \u0275\u0275directiveInject(NG_ASYNC_VALIDATORS, 10));
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _FormArrayName,
+    selectors: [["", "formArrayName", ""]],
+    inputs: {
+      name: [0, "formArrayName", "name"]
+    },
+    standalone: false,
+    features: [\u0275\u0275ProvidersFeature([formArrayNameProvider]), \u0275\u0275InheritDefinitionFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(FormArrayName, [{
+    type: Directive,
+    args: [{
+      selector: "[formArrayName]",
+      providers: [formArrayNameProvider],
+      standalone: false
+    }]
+  }], () => [{
+    type: ControlContainer,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Host
+    }, {
+      type: SkipSelf
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Self
+    }, {
+      type: Inject,
+      args: [NG_VALIDATORS]
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Self
+    }, {
+      type: Inject,
+      args: [NG_ASYNC_VALIDATORS]
+    }]
+  }], {
+    name: [{
+      type: Input,
+      args: ["formArrayName"]
+    }]
+  });
+})();
+function hasInvalidParent(parent) {
+  return !(parent instanceof FormGroupName) && !(parent instanceof AbstractFormDirective) && !(parent instanceof FormArrayName);
+}
+var controlNameBinding = {
+  provide: NgControl,
+  useExisting: forwardRef(() => FormControlName)
+};
+var FormControlName = class _FormControlName extends NgControl {
+  _ngModelWarningConfig;
+  _added = false;
+  viewModel;
+  control;
+  name = null;
+  set isDisabled(isDisabled) {
+    if (typeof ngDevMode === "undefined" || ngDevMode) {
+      console.warn(disabledAttrWarning);
+    }
+  }
+  model;
+  update = new EventEmitter();
+  static _ngModelWarningSentOnce = false;
+  _ngModelWarningSent = false;
+  constructor(parent, validators, asyncValidators, valueAccessors, _ngModelWarningConfig) {
+    super();
+    this._ngModelWarningConfig = _ngModelWarningConfig;
+    this._parent = parent;
+    this._setValidators(validators);
+    this._setAsyncValidators(asyncValidators);
+    this.valueAccessor = selectValueAccessor(this, valueAccessors);
+  }
+  ngOnChanges(changes) {
+    if (!this._added) this._setUpControl();
+    if (isPropertyUpdated(changes, this.viewModel)) {
+      if (typeof ngDevMode === "undefined" || ngDevMode) {
+        _ngModelWarning("formControlName", _FormControlName, this, this._ngModelWarningConfig);
+      }
+      this.viewModel = this.model;
+      this.formDirective.updateModel(this, this.model);
+    }
+  }
+  ngOnDestroy() {
+    this.formDirective?.removeControl(this);
+  }
+  viewToModelUpdate(newValue) {
+    this.viewModel = newValue;
+    this.update.emit(newValue);
+  }
+  get path() {
+    return controlPath(this.name == null ? this.name : this.name.toString(), this._parent);
+  }
+  get formDirective() {
+    return this._parent ? this._parent.formDirective : null;
+  }
+  _setUpControl() {
+    if (typeof ngDevMode === "undefined" || ngDevMode) {
+      checkParentType(this._parent, this.name);
+    }
+    this.control = this.formDirective.addControl(this);
+    this._added = true;
+  }
+  static \u0275fac = function FormControlName_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _FormControlName)(\u0275\u0275directiveInject(ControlContainer, 13), \u0275\u0275directiveInject(NG_VALIDATORS, 10), \u0275\u0275directiveInject(NG_ASYNC_VALIDATORS, 10), \u0275\u0275directiveInject(NG_VALUE_ACCESSOR, 10), \u0275\u0275directiveInject(NG_MODEL_WITH_FORM_CONTROL_WARNING, 8));
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _FormControlName,
+    selectors: [["", "formControlName", ""]],
+    inputs: {
+      name: [0, "formControlName", "name"],
+      isDisabled: [0, "disabled", "isDisabled"],
+      model: [0, "ngModel", "model"]
+    },
+    outputs: {
+      update: "ngModelChange"
+    },
+    standalone: false,
+    features: [\u0275\u0275ProvidersFeature([controlNameBinding]), \u0275\u0275InheritDefinitionFeature, \u0275\u0275NgOnChangesFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(FormControlName, [{
+    type: Directive,
+    args: [{
+      selector: "[formControlName]",
+      providers: [controlNameBinding],
+      standalone: false
+    }]
+  }], () => [{
+    type: ControlContainer,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Host
+    }, {
+      type: SkipSelf
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Self
+    }, {
+      type: Inject,
+      args: [NG_VALIDATORS]
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Self
+    }, {
+      type: Inject,
+      args: [NG_ASYNC_VALIDATORS]
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Self
+    }, {
+      type: Inject,
+      args: [NG_VALUE_ACCESSOR]
+    }]
+  }, {
+    type: void 0,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Inject,
+      args: [NG_MODEL_WITH_FORM_CONTROL_WARNING]
+    }]
+  }], {
+    name: [{
+      type: Input,
+      args: ["formControlName"]
+    }],
+    isDisabled: [{
+      type: Input,
+      args: ["disabled"]
+    }],
+    model: [{
+      type: Input,
+      args: ["ngModel"]
+    }],
+    update: [{
+      type: Output,
+      args: ["ngModelChange"]
+    }]
+  });
+})();
+function checkParentType(parent, name) {
+  if (!(parent instanceof FormGroupName) && parent instanceof AbstractFormGroupDirective) {
+    throw ngModelGroupException();
+  } else if (!(parent instanceof FormGroupName) && !(parent instanceof AbstractFormDirective) && !(parent instanceof FormArrayName)) {
+    throw controlParentException(name);
+  }
+}
+var formDirectiveProvider = {
+  provide: ControlContainer,
+  useExisting: forwardRef(() => FormGroupDirective)
+};
+var FormGroupDirective = class _FormGroupDirective extends AbstractFormDirective {
+  form = null;
+  ngSubmit = new EventEmitter();
+  get control() {
+    return this.form;
+  }
+  static \u0275fac = /* @__PURE__ */ (() => {
+    let \u0275FormGroupDirective_BaseFactory;
+    return function FormGroupDirective_Factory(__ngFactoryType__) {
+      return (\u0275FormGroupDirective_BaseFactory || (\u0275FormGroupDirective_BaseFactory = \u0275\u0275getInheritedFactory(_FormGroupDirective)))(__ngFactoryType__ || _FormGroupDirective);
+    };
+  })();
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _FormGroupDirective,
+    selectors: [["", "formGroup", ""]],
+    hostBindings: function FormGroupDirective_HostBindings(rf, ctx) {
+      if (rf & 1) {
+        \u0275\u0275listener("submit", function FormGroupDirective_submit_HostBindingHandler($event) {
+          return ctx.onSubmit($event);
+        })("reset", function FormGroupDirective_reset_HostBindingHandler() {
+          return ctx.onReset();
+        });
+      }
+    },
+    inputs: {
+      form: [0, "formGroup", "form"]
+    },
+    outputs: {
+      ngSubmit: "ngSubmit"
+    },
+    exportAs: ["ngForm"],
+    standalone: false,
+    features: [\u0275\u0275ProvidersFeature([formDirectiveProvider]), \u0275\u0275InheritDefinitionFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(FormGroupDirective, [{
+    type: Directive,
+    args: [{
+      selector: "[formGroup]",
+      providers: [formDirectiveProvider],
+      host: {
+        "(submit)": "onSubmit($event)",
+        "(reset)": "onReset()"
+      },
+      exportAs: "ngForm",
+      standalone: false
+    }]
+  }], null, {
+    form: [{
+      type: Input,
+      args: ["formGroup"]
+    }],
+    ngSubmit: [{
+      type: Output
+    }]
+  });
+})();
+var SELECT_VALUE_ACCESSOR = {
+  provide: NG_VALUE_ACCESSOR,
+  useExisting: forwardRef(() => SelectControlValueAccessor),
+  multi: true
+};
+function _buildValueString$1(id, value) {
+  if (id == null) return `${value}`;
+  if (value && typeof value === "object") value = "Object";
+  return `${id}: ${value}`.slice(0, 50);
+}
+function _extractId$1(valueString) {
+  return valueString.split(":")[0];
+}
+var SelectControlValueAccessor = class _SelectControlValueAccessor extends BuiltInControlValueAccessor {
+  value;
+  _optionMap = /* @__PURE__ */ new Map();
+  _idCounter = 0;
+  set compareWith(fn) {
+    if (typeof fn !== "function" && (typeof ngDevMode === "undefined" || ngDevMode)) {
+      throw new RuntimeError(1201, `compareWith must be a function, but received ${JSON.stringify(fn)}`);
+    }
+    this._compareWith = fn;
+  }
+  _compareWith = Object.is;
+  appRefInjector = inject2(ApplicationRef).injector;
+  destroyRef = inject2(DestroyRef);
+  cdr = inject2(ChangeDetectorRef);
+  _queuedWrite = false;
+  _writeValueAfterRender() {
+    if (this._queuedWrite || this.appRefInjector.destroyed) {
+      return;
+    }
+    this._queuedWrite = true;
+    afterNextRender({
+      write: () => {
+        if (this.destroyRef.destroyed) {
+          return;
+        }
+        this._queuedWrite = false;
+        this.writeValue(this.value);
+      }
+    }, {
+      injector: this.appRefInjector
+    });
+  }
+  writeValue(value) {
+    this.cdr.markForCheck();
+    this.value = value;
+    const id = this._getOptionId(value);
+    const valueString = _buildValueString$1(id, value);
+    this.setProperty("value", valueString);
+  }
+  registerOnChange(fn) {
+    this.onChange = (valueString) => {
+      this.value = this._getOptionValue(valueString);
+      fn(this.value);
+    };
+  }
+  _registerOption() {
+    return (this._idCounter++).toString();
+  }
+  _getOptionId(value) {
+    for (const id of this._optionMap.keys()) {
+      if (this._compareWith(this._optionMap.get(id), value)) return id;
+    }
+    return null;
+  }
+  _getOptionValue(valueString) {
+    const id = _extractId$1(valueString);
+    return this._optionMap.has(id) ? this._optionMap.get(id) : valueString;
+  }
+  static \u0275fac = /* @__PURE__ */ (() => {
+    let \u0275SelectControlValueAccessor_BaseFactory;
+    return function SelectControlValueAccessor_Factory(__ngFactoryType__) {
+      return (\u0275SelectControlValueAccessor_BaseFactory || (\u0275SelectControlValueAccessor_BaseFactory = \u0275\u0275getInheritedFactory(_SelectControlValueAccessor)))(__ngFactoryType__ || _SelectControlValueAccessor);
+    };
+  })();
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _SelectControlValueAccessor,
+    selectors: [["select", "formControlName", "", 3, "multiple", ""], ["select", "formControl", "", 3, "multiple", ""], ["select", "ngModel", "", 3, "multiple", ""]],
+    hostBindings: function SelectControlValueAccessor_HostBindings(rf, ctx) {
+      if (rf & 1) {
+        \u0275\u0275listener("change", function SelectControlValueAccessor_change_HostBindingHandler($event) {
+          return ctx.onChange($event.target.value);
+        })("blur", function SelectControlValueAccessor_blur_HostBindingHandler() {
+          return ctx.onTouched();
+        });
+      }
+    },
+    inputs: {
+      compareWith: "compareWith"
+    },
+    standalone: false,
+    features: [\u0275\u0275ProvidersFeature([SELECT_VALUE_ACCESSOR]), \u0275\u0275InheritDefinitionFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(SelectControlValueAccessor, [{
+    type: Directive,
+    args: [{
+      selector: "select:not([multiple])[formControlName],select:not([multiple])[formControl],select:not([multiple])[ngModel]",
+      host: {
+        "(change)": "onChange($any($event.target).value)",
+        "(blur)": "onTouched()"
+      },
+      providers: [SELECT_VALUE_ACCESSOR],
+      standalone: false
+    }]
+  }], null, {
+    compareWith: [{
+      type: Input
+    }]
+  });
+})();
+var NgSelectOption = class _NgSelectOption {
+  _element;
+  _renderer;
+  _select;
+  id;
+  constructor(_element, _renderer, _select) {
+    this._element = _element;
+    this._renderer = _renderer;
+    this._select = _select;
+    if (this._select) this.id = this._select._registerOption();
+  }
+  set ngValue(value) {
+    if (this._select == null) return;
+    this._select._optionMap.set(this.id, value);
+    this._setElementValue(_buildValueString$1(this.id, value));
+    this._select._writeValueAfterRender();
+  }
+  set value(value) {
+    this._setElementValue(value);
+    this._select?._writeValueAfterRender();
+  }
+  _setElementValue(value) {
+    this._renderer.setProperty(this._element.nativeElement, "value", value);
+  }
+  ngOnDestroy() {
+    this._select?._optionMap.delete(this.id);
+    this._select?._writeValueAfterRender();
+  }
+  static \u0275fac = function NgSelectOption_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _NgSelectOption)(\u0275\u0275directiveInject(ElementRef), \u0275\u0275directiveInject(Renderer2), \u0275\u0275directiveInject(SelectControlValueAccessor, 9));
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _NgSelectOption,
+    selectors: [["option"]],
+    inputs: {
+      ngValue: "ngValue",
+      value: "value"
+    },
+    standalone: false
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgSelectOption, [{
+    type: Directive,
+    args: [{
+      selector: "option",
+      standalone: false
+    }]
+  }], () => [{
+    type: ElementRef
+  }, {
+    type: Renderer2
+  }, {
+    type: SelectControlValueAccessor,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Host
+    }]
+  }], {
+    ngValue: [{
+      type: Input,
+      args: ["ngValue"]
+    }],
+    value: [{
+      type: Input,
+      args: ["value"]
+    }]
+  });
+})();
+var SELECT_MULTIPLE_VALUE_ACCESSOR = {
+  provide: NG_VALUE_ACCESSOR,
+  useExisting: forwardRef(() => SelectMultipleControlValueAccessor),
+  multi: true
+};
+function _buildValueString(id, value) {
+  if (id == null) return `${value}`;
+  if (typeof value === "string") value = `'${value}'`;
+  if (value && typeof value === "object") value = "Object";
+  return `${id}: ${value}`.slice(0, 50);
+}
+function _extractId(valueString) {
+  return valueString.split(":")[0];
+}
+var SelectMultipleControlValueAccessor = class _SelectMultipleControlValueAccessor extends BuiltInControlValueAccessor {
+  value;
+  _optionMap = /* @__PURE__ */ new Map();
+  _idCounter = 0;
+  set compareWith(fn) {
+    if (typeof fn !== "function" && (typeof ngDevMode === "undefined" || ngDevMode)) {
+      throw new RuntimeError(1201, `compareWith must be a function, but received ${JSON.stringify(fn)}`);
+    }
+    this._compareWith = fn;
+  }
+  _compareWith = Object.is;
+  writeValue(value) {
+    this.value = value;
+    let optionSelectedStateSetter;
+    if (Array.isArray(value)) {
+      const ids = value.map((v) => this._getOptionId(v));
+      optionSelectedStateSetter = (opt, id) => {
+        opt._setSelected(ids.indexOf(id) > -1);
+      };
+    } else {
+      optionSelectedStateSetter = (opt) => {
+        opt._setSelected(false);
+      };
+    }
+    this._optionMap.forEach(optionSelectedStateSetter);
+  }
+  registerOnChange(fn) {
+    this.onChange = (element) => {
+      const selected = [];
+      const selectedOptions = element.selectedOptions;
+      if (selectedOptions !== void 0) {
+        const options = selectedOptions;
+        for (let i = 0; i < options.length; i++) {
+          const opt = options[i];
+          const val = this._getOptionValue(opt.value);
+          selected.push(val);
+        }
+      } else {
+        const options = element.options;
+        for (let i = 0; i < options.length; i++) {
+          const opt = options[i];
+          if (opt.selected) {
+            const val = this._getOptionValue(opt.value);
+            selected.push(val);
+          }
+        }
+      }
+      this.value = selected;
+      fn(selected);
+    };
+  }
+  _registerOption(value) {
+    const id = (this._idCounter++).toString();
+    this._optionMap.set(id, value);
+    return id;
+  }
+  _getOptionId(value) {
+    for (const id of this._optionMap.keys()) {
+      if (this._compareWith(this._optionMap.get(id)._value, value)) return id;
+    }
+    return null;
+  }
+  _getOptionValue(valueString) {
+    const id = _extractId(valueString);
+    return this._optionMap.has(id) ? this._optionMap.get(id)._value : valueString;
+  }
+  static \u0275fac = /* @__PURE__ */ (() => {
+    let \u0275SelectMultipleControlValueAccessor_BaseFactory;
+    return function SelectMultipleControlValueAccessor_Factory(__ngFactoryType__) {
+      return (\u0275SelectMultipleControlValueAccessor_BaseFactory || (\u0275SelectMultipleControlValueAccessor_BaseFactory = \u0275\u0275getInheritedFactory(_SelectMultipleControlValueAccessor)))(__ngFactoryType__ || _SelectMultipleControlValueAccessor);
+    };
+  })();
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _SelectMultipleControlValueAccessor,
+    selectors: [["select", "multiple", "", "formControlName", ""], ["select", "multiple", "", "formControl", ""], ["select", "multiple", "", "ngModel", ""]],
+    hostBindings: function SelectMultipleControlValueAccessor_HostBindings(rf, ctx) {
+      if (rf & 1) {
+        \u0275\u0275listener("change", function SelectMultipleControlValueAccessor_change_HostBindingHandler($event) {
+          return ctx.onChange($event.target);
+        })("blur", function SelectMultipleControlValueAccessor_blur_HostBindingHandler() {
+          return ctx.onTouched();
+        });
+      }
+    },
+    inputs: {
+      compareWith: "compareWith"
+    },
+    standalone: false,
+    features: [\u0275\u0275ProvidersFeature([SELECT_MULTIPLE_VALUE_ACCESSOR]), \u0275\u0275InheritDefinitionFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(SelectMultipleControlValueAccessor, [{
+    type: Directive,
+    args: [{
+      selector: "select[multiple][formControlName],select[multiple][formControl],select[multiple][ngModel]",
+      host: {
+        "(change)": "onChange($event.target)",
+        "(blur)": "onTouched()"
+      },
+      providers: [SELECT_MULTIPLE_VALUE_ACCESSOR],
+      standalone: false
+    }]
+  }], null, {
+    compareWith: [{
+      type: Input
+    }]
+  });
+})();
+var \u0275NgSelectMultipleOption = class _\u0275NgSelectMultipleOption {
+  _element;
+  _renderer;
+  _select;
+  id;
+  _value;
+  constructor(_element, _renderer, _select) {
+    this._element = _element;
+    this._renderer = _renderer;
+    this._select = _select;
+    if (this._select) {
+      this.id = this._select._registerOption(this);
+    }
+  }
+  set ngValue(value) {
+    if (this._select == null) return;
+    this._value = value;
+    this._setElementValue(_buildValueString(this.id, value));
+    this._select.writeValue(this._select.value);
+  }
+  set value(value) {
+    if (this._select) {
+      this._value = value;
+      this._setElementValue(_buildValueString(this.id, value));
+      this._select.writeValue(this._select.value);
+    } else {
+      this._setElementValue(value);
+    }
+  }
+  _setElementValue(value) {
+    this._renderer.setProperty(this._element.nativeElement, "value", value);
+  }
+  _setSelected(selected) {
+    this._renderer.setProperty(this._element.nativeElement, "selected", selected);
+  }
+  ngOnDestroy() {
+    if (this._select) {
+      this._select._optionMap.delete(this.id);
+      this._select.writeValue(this._select.value);
+    }
+  }
+  static \u0275fac = function \u0275NgSelectMultipleOption_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _\u0275NgSelectMultipleOption)(\u0275\u0275directiveInject(ElementRef), \u0275\u0275directiveInject(Renderer2), \u0275\u0275directiveInject(SelectMultipleControlValueAccessor, 9));
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _\u0275NgSelectMultipleOption,
+    selectors: [["option"]],
+    inputs: {
+      ngValue: "ngValue",
+      value: "value"
+    },
+    standalone: false
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(\u0275NgSelectMultipleOption, [{
+    type: Directive,
+    args: [{
+      selector: "option",
+      standalone: false
+    }]
+  }], () => [{
+    type: ElementRef
+  }, {
+    type: Renderer2
+  }, {
+    type: SelectMultipleControlValueAccessor,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Host
+    }]
+  }], {
+    ngValue: [{
+      type: Input,
+      args: ["ngValue"]
+    }],
+    value: [{
+      type: Input,
+      args: ["value"]
+    }]
+  });
+})();
+function toInteger(value) {
+  return typeof value === "number" ? value : parseInt(value, 10);
+}
+function toFloat(value) {
+  return typeof value === "number" ? value : parseFloat(value);
+}
+var AbstractValidatorDirective = class _AbstractValidatorDirective {
+  _validator = nullValidator;
+  _onChange;
+  _enabled;
+  ngOnChanges(changes) {
+    if (this.inputName in changes) {
+      const input2 = this.normalizeInput(changes[this.inputName].currentValue);
+      this._enabled = this.enabled(input2);
+      this._validator = this._enabled ? this.createValidator(input2) : nullValidator;
+      this._onChange?.();
+    }
+  }
+  validate(control) {
+    return this._validator(control);
+  }
+  registerOnValidatorChange(fn) {
+    this._onChange = fn;
+  }
+  enabled(input2) {
+    return input2 != null;
+  }
+  static \u0275fac = function AbstractValidatorDirective_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _AbstractValidatorDirective)();
+  };
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _AbstractValidatorDirective,
+    features: [\u0275\u0275NgOnChangesFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(AbstractValidatorDirective, [{
+    type: Directive
+  }], null, null);
+})();
+var MAX_VALIDATOR = {
+  provide: NG_VALIDATORS,
+  useExisting: forwardRef(() => MaxValidator),
+  multi: true
+};
+var MaxValidator = class _MaxValidator extends AbstractValidatorDirective {
+  max;
+  inputName = "max";
+  normalizeInput = (input2) => toFloat(input2);
+  createValidator = (max) => maxValidator(max);
+  static \u0275fac = /* @__PURE__ */ (() => {
+    let \u0275MaxValidator_BaseFactory;
+    return function MaxValidator_Factory(__ngFactoryType__) {
+      return (\u0275MaxValidator_BaseFactory || (\u0275MaxValidator_BaseFactory = \u0275\u0275getInheritedFactory(_MaxValidator)))(__ngFactoryType__ || _MaxValidator);
+    };
+  })();
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _MaxValidator,
+    selectors: [["input", "type", "number", "max", "", "formControlName", ""], ["input", "type", "number", "max", "", "formControl", ""], ["input", "type", "number", "max", "", "ngModel", ""]],
+    hostVars: 1,
+    hostBindings: function MaxValidator_HostBindings(rf, ctx) {
+      if (rf & 2) {
+        \u0275\u0275attribute("max", ctx._enabled ? ctx.max : null);
+      }
+    },
+    inputs: {
+      max: "max"
+    },
+    standalone: false,
+    features: [\u0275\u0275ProvidersFeature([MAX_VALIDATOR]), \u0275\u0275InheritDefinitionFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(MaxValidator, [{
+    type: Directive,
+    args: [{
+      selector: "input[type=number][max][formControlName],input[type=number][max][formControl],input[type=number][max][ngModel]",
+      providers: [MAX_VALIDATOR],
+      host: {
+        "[attr.max]": "_enabled ? max : null"
+      },
+      standalone: false
+    }]
+  }], null, {
+    max: [{
+      type: Input
+    }]
+  });
+})();
+var MIN_VALIDATOR = {
+  provide: NG_VALIDATORS,
+  useExisting: forwardRef(() => MinValidator),
+  multi: true
+};
+var MinValidator = class _MinValidator extends AbstractValidatorDirective {
+  min;
+  inputName = "min";
+  normalizeInput = (input2) => toFloat(input2);
+  createValidator = (min) => minValidator(min);
+  static \u0275fac = /* @__PURE__ */ (() => {
+    let \u0275MinValidator_BaseFactory;
+    return function MinValidator_Factory(__ngFactoryType__) {
+      return (\u0275MinValidator_BaseFactory || (\u0275MinValidator_BaseFactory = \u0275\u0275getInheritedFactory(_MinValidator)))(__ngFactoryType__ || _MinValidator);
+    };
+  })();
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _MinValidator,
+    selectors: [["input", "type", "number", "min", "", "formControlName", ""], ["input", "type", "number", "min", "", "formControl", ""], ["input", "type", "number", "min", "", "ngModel", ""]],
+    hostVars: 1,
+    hostBindings: function MinValidator_HostBindings(rf, ctx) {
+      if (rf & 2) {
+        \u0275\u0275attribute("min", ctx._enabled ? ctx.min : null);
+      }
+    },
+    inputs: {
+      min: "min"
+    },
+    standalone: false,
+    features: [\u0275\u0275ProvidersFeature([MIN_VALIDATOR]), \u0275\u0275InheritDefinitionFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(MinValidator, [{
+    type: Directive,
+    args: [{
+      selector: "input[type=number][min][formControlName],input[type=number][min][formControl],input[type=number][min][ngModel]",
+      providers: [MIN_VALIDATOR],
+      host: {
+        "[attr.min]": "_enabled ? min : null"
+      },
+      standalone: false
+    }]
+  }], null, {
+    min: [{
+      type: Input
+    }]
+  });
+})();
+var REQUIRED_VALIDATOR = {
+  provide: NG_VALIDATORS,
+  useExisting: forwardRef(() => RequiredValidator),
+  multi: true
+};
+var CHECKBOX_REQUIRED_VALIDATOR = {
+  provide: NG_VALIDATORS,
+  useExisting: forwardRef(() => CheckboxRequiredValidator),
+  multi: true
+};
+var RequiredValidator = class _RequiredValidator extends AbstractValidatorDirective {
+  required;
+  inputName = "required";
+  normalizeInput = booleanAttribute;
+  createValidator = (input2) => requiredValidator;
+  enabled(input2) {
+    return input2;
+  }
+  static \u0275fac = /* @__PURE__ */ (() => {
+    let \u0275RequiredValidator_BaseFactory;
+    return function RequiredValidator_Factory(__ngFactoryType__) {
+      return (\u0275RequiredValidator_BaseFactory || (\u0275RequiredValidator_BaseFactory = \u0275\u0275getInheritedFactory(_RequiredValidator)))(__ngFactoryType__ || _RequiredValidator);
+    };
+  })();
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _RequiredValidator,
+    selectors: [["", "required", "", "formControlName", "", 3, "type", "checkbox"], ["", "required", "", "formControl", "", 3, "type", "checkbox"], ["", "required", "", "ngModel", "", 3, "type", "checkbox"]],
+    hostVars: 1,
+    hostBindings: function RequiredValidator_HostBindings(rf, ctx) {
+      if (rf & 2) {
+        \u0275\u0275attribute("required", ctx._enabled ? "" : null);
+      }
+    },
+    inputs: {
+      required: "required"
+    },
+    standalone: false,
+    features: [\u0275\u0275ProvidersFeature([REQUIRED_VALIDATOR]), \u0275\u0275InheritDefinitionFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(RequiredValidator, [{
+    type: Directive,
+    args: [{
+      selector: ":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]",
+      providers: [REQUIRED_VALIDATOR],
+      host: {
+        "[attr.required]": '_enabled ? "" : null'
+      },
+      standalone: false
+    }]
+  }], null, {
+    required: [{
+      type: Input
+    }]
+  });
+})();
+var CheckboxRequiredValidator = class _CheckboxRequiredValidator extends RequiredValidator {
+  createValidator = (input2) => requiredTrueValidator;
+  static \u0275fac = /* @__PURE__ */ (() => {
+    let \u0275CheckboxRequiredValidator_BaseFactory;
+    return function CheckboxRequiredValidator_Factory(__ngFactoryType__) {
+      return (\u0275CheckboxRequiredValidator_BaseFactory || (\u0275CheckboxRequiredValidator_BaseFactory = \u0275\u0275getInheritedFactory(_CheckboxRequiredValidator)))(__ngFactoryType__ || _CheckboxRequiredValidator);
+    };
+  })();
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _CheckboxRequiredValidator,
+    selectors: [["input", "type", "checkbox", "required", "", "formControlName", ""], ["input", "type", "checkbox", "required", "", "formControl", ""], ["input", "type", "checkbox", "required", "", "ngModel", ""]],
+    hostVars: 1,
+    hostBindings: function CheckboxRequiredValidator_HostBindings(rf, ctx) {
+      if (rf & 2) {
+        \u0275\u0275attribute("required", ctx._enabled ? "" : null);
+      }
+    },
+    standalone: false,
+    features: [\u0275\u0275ProvidersFeature([CHECKBOX_REQUIRED_VALIDATOR]), \u0275\u0275InheritDefinitionFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(CheckboxRequiredValidator, [{
+    type: Directive,
+    args: [{
+      selector: "input[type=checkbox][required][formControlName],input[type=checkbox][required][formControl],input[type=checkbox][required][ngModel]",
+      providers: [CHECKBOX_REQUIRED_VALIDATOR],
+      host: {
+        "[attr.required]": '_enabled ? "" : null'
+      },
+      standalone: false
+    }]
+  }], null, null);
+})();
+var EMAIL_VALIDATOR = {
+  provide: NG_VALIDATORS,
+  useExisting: forwardRef(() => EmailValidator),
+  multi: true
+};
+var EmailValidator = class _EmailValidator extends AbstractValidatorDirective {
+  email;
+  inputName = "email";
+  normalizeInput = booleanAttribute;
+  createValidator = (input2) => emailValidator;
+  enabled(input2) {
+    return input2;
+  }
+  static \u0275fac = /* @__PURE__ */ (() => {
+    let \u0275EmailValidator_BaseFactory;
+    return function EmailValidator_Factory(__ngFactoryType__) {
+      return (\u0275EmailValidator_BaseFactory || (\u0275EmailValidator_BaseFactory = \u0275\u0275getInheritedFactory(_EmailValidator)))(__ngFactoryType__ || _EmailValidator);
+    };
+  })();
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _EmailValidator,
+    selectors: [["", "email", "", "formControlName", ""], ["", "email", "", "formControl", ""], ["", "email", "", "ngModel", ""]],
+    inputs: {
+      email: "email"
+    },
+    standalone: false,
+    features: [\u0275\u0275ProvidersFeature([EMAIL_VALIDATOR]), \u0275\u0275InheritDefinitionFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(EmailValidator, [{
+    type: Directive,
+    args: [{
+      selector: "[email][formControlName],[email][formControl],[email][ngModel]",
+      providers: [EMAIL_VALIDATOR],
+      standalone: false
+    }]
+  }], null, {
+    email: [{
+      type: Input
+    }]
+  });
+})();
+var MIN_LENGTH_VALIDATOR = {
+  provide: NG_VALIDATORS,
+  useExisting: forwardRef(() => MinLengthValidator),
+  multi: true
+};
+var MinLengthValidator = class _MinLengthValidator extends AbstractValidatorDirective {
+  minlength;
+  inputName = "minlength";
+  normalizeInput = (input2) => toInteger(input2);
+  createValidator = (minlength) => minLengthValidator(minlength);
+  static \u0275fac = /* @__PURE__ */ (() => {
+    let \u0275MinLengthValidator_BaseFactory;
+    return function MinLengthValidator_Factory(__ngFactoryType__) {
+      return (\u0275MinLengthValidator_BaseFactory || (\u0275MinLengthValidator_BaseFactory = \u0275\u0275getInheritedFactory(_MinLengthValidator)))(__ngFactoryType__ || _MinLengthValidator);
+    };
+  })();
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _MinLengthValidator,
+    selectors: [["", "minlength", "", "formControlName", ""], ["", "minlength", "", "formControl", ""], ["", "minlength", "", "ngModel", ""]],
+    hostVars: 1,
+    hostBindings: function MinLengthValidator_HostBindings(rf, ctx) {
+      if (rf & 2) {
+        \u0275\u0275attribute("minlength", ctx._enabled ? ctx.minlength : null);
+      }
+    },
+    inputs: {
+      minlength: "minlength"
+    },
+    standalone: false,
+    features: [\u0275\u0275ProvidersFeature([MIN_LENGTH_VALIDATOR]), \u0275\u0275InheritDefinitionFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(MinLengthValidator, [{
+    type: Directive,
+    args: [{
+      selector: "[minlength][formControlName],[minlength][formControl],[minlength][ngModel]",
+      providers: [MIN_LENGTH_VALIDATOR],
+      host: {
+        "[attr.minlength]": "_enabled ? minlength : null"
+      },
+      standalone: false
+    }]
+  }], null, {
+    minlength: [{
+      type: Input
+    }]
+  });
+})();
+var MAX_LENGTH_VALIDATOR = {
+  provide: NG_VALIDATORS,
+  useExisting: forwardRef(() => MaxLengthValidator),
+  multi: true
+};
+var MaxLengthValidator = class _MaxLengthValidator extends AbstractValidatorDirective {
+  maxlength;
+  inputName = "maxlength";
+  normalizeInput = (input2) => toInteger(input2);
+  createValidator = (maxlength) => maxLengthValidator(maxlength);
+  static \u0275fac = /* @__PURE__ */ (() => {
+    let \u0275MaxLengthValidator_BaseFactory;
+    return function MaxLengthValidator_Factory(__ngFactoryType__) {
+      return (\u0275MaxLengthValidator_BaseFactory || (\u0275MaxLengthValidator_BaseFactory = \u0275\u0275getInheritedFactory(_MaxLengthValidator)))(__ngFactoryType__ || _MaxLengthValidator);
+    };
+  })();
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _MaxLengthValidator,
+    selectors: [["", "maxlength", "", "formControlName", ""], ["", "maxlength", "", "formControl", ""], ["", "maxlength", "", "ngModel", ""]],
+    hostVars: 1,
+    hostBindings: function MaxLengthValidator_HostBindings(rf, ctx) {
+      if (rf & 2) {
+        \u0275\u0275attribute("maxlength", ctx._enabled ? ctx.maxlength : null);
+      }
+    },
+    inputs: {
+      maxlength: "maxlength"
+    },
+    standalone: false,
+    features: [\u0275\u0275ProvidersFeature([MAX_LENGTH_VALIDATOR]), \u0275\u0275InheritDefinitionFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(MaxLengthValidator, [{
+    type: Directive,
+    args: [{
+      selector: "[maxlength][formControlName],[maxlength][formControl],[maxlength][ngModel]",
+      providers: [MAX_LENGTH_VALIDATOR],
+      host: {
+        "[attr.maxlength]": "_enabled ? maxlength : null"
+      },
+      standalone: false
+    }]
+  }], null, {
+    maxlength: [{
+      type: Input
+    }]
+  });
+})();
+var PATTERN_VALIDATOR = {
+  provide: NG_VALIDATORS,
+  useExisting: forwardRef(() => PatternValidator),
+  multi: true
+};
+var PatternValidator = class _PatternValidator extends AbstractValidatorDirective {
+  pattern;
+  inputName = "pattern";
+  normalizeInput = (input2) => input2;
+  createValidator = (input2) => patternValidator(input2);
+  static \u0275fac = /* @__PURE__ */ (() => {
+    let \u0275PatternValidator_BaseFactory;
+    return function PatternValidator_Factory(__ngFactoryType__) {
+      return (\u0275PatternValidator_BaseFactory || (\u0275PatternValidator_BaseFactory = \u0275\u0275getInheritedFactory(_PatternValidator)))(__ngFactoryType__ || _PatternValidator);
+    };
+  })();
+  static \u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
+    type: _PatternValidator,
+    selectors: [["", "pattern", "", "formControlName", ""], ["", "pattern", "", "formControl", ""], ["", "pattern", "", "ngModel", ""]],
+    hostVars: 1,
+    hostBindings: function PatternValidator_HostBindings(rf, ctx) {
+      if (rf & 2) {
+        \u0275\u0275attribute("pattern", ctx._enabled ? ctx.pattern : null);
+      }
+    },
+    inputs: {
+      pattern: "pattern"
+    },
+    standalone: false,
+    features: [\u0275\u0275ProvidersFeature([PATTERN_VALIDATOR]), \u0275\u0275InheritDefinitionFeature]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(PatternValidator, [{
+    type: Directive,
+    args: [{
+      selector: "[pattern][formControlName],[pattern][formControl],[pattern][ngModel]",
+      providers: [PATTERN_VALIDATOR],
+      host: {
+        "[attr.pattern]": "_enabled ? pattern : null"
+      },
+      standalone: false
+    }]
+  }], null, {
+    pattern: [{
+      type: Input
+    }]
+  });
+})();
+var SHARED_FORM_DIRECTIVES = [\u0275NgNoValidate, NgSelectOption, \u0275NgSelectMultipleOption, DefaultValueAccessor, NumberValueAccessor, RangeValueAccessor, CheckboxControlValueAccessor, SelectControlValueAccessor, SelectMultipleControlValueAccessor, RadioControlValueAccessor, NgControlStatus, NgControlStatusGroup, RequiredValidator, MinLengthValidator, MaxLengthValidator, PatternValidator, CheckboxRequiredValidator, EmailValidator, MinValidator, MaxValidator];
+var TEMPLATE_DRIVEN_DIRECTIVES = [NgModel, NgModelGroup, NgForm];
+var REACTIVE_DRIVEN_DIRECTIVES = [FormControlDirective, FormGroupDirective, FormArrayDirective, FormControlName, FormGroupName, FormArrayName];
+var \u0275InternalFormsSharedModule = class _\u0275InternalFormsSharedModule {
+  static \u0275fac = function \u0275InternalFormsSharedModule_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _\u0275InternalFormsSharedModule)();
+  };
+  static \u0275mod = /* @__PURE__ */ \u0275\u0275defineNgModule({
+    type: _\u0275InternalFormsSharedModule,
+    declarations: [\u0275NgNoValidate, NgSelectOption, \u0275NgSelectMultipleOption, DefaultValueAccessor, NumberValueAccessor, RangeValueAccessor, CheckboxControlValueAccessor, SelectControlValueAccessor, SelectMultipleControlValueAccessor, RadioControlValueAccessor, NgControlStatus, NgControlStatusGroup, RequiredValidator, MinLengthValidator, MaxLengthValidator, PatternValidator, CheckboxRequiredValidator, EmailValidator, MinValidator, MaxValidator],
+    exports: [\u0275NgNoValidate, NgSelectOption, \u0275NgSelectMultipleOption, DefaultValueAccessor, NumberValueAccessor, RangeValueAccessor, CheckboxControlValueAccessor, SelectControlValueAccessor, SelectMultipleControlValueAccessor, RadioControlValueAccessor, NgControlStatus, NgControlStatusGroup, RequiredValidator, MinLengthValidator, MaxLengthValidator, PatternValidator, CheckboxRequiredValidator, EmailValidator, MinValidator, MaxValidator]
+  });
+  static \u0275inj = /* @__PURE__ */ \u0275\u0275defineInjector({});
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(\u0275InternalFormsSharedModule, [{
+    type: NgModule,
+    args: [{
+      declarations: SHARED_FORM_DIRECTIVES,
+      exports: SHARED_FORM_DIRECTIVES
+    }]
+  }], null, null);
+})();
+function isAbstractControlOptions(options) {
+  return !!options && (options.asyncValidators !== void 0 || options.validators !== void 0 || options.updateOn !== void 0);
+}
+var FormBuilder = class _FormBuilder {
+  useNonNullable = false;
+  get nonNullable() {
+    const nnfb = new _FormBuilder();
+    nnfb.useNonNullable = true;
+    return nnfb;
+  }
+  group(controls, options = null) {
+    const reducedControls = this._reduceControls(controls);
+    let newOptions = {};
+    if (isAbstractControlOptions(options)) {
+      newOptions = options;
+    } else if (options !== null) {
+      newOptions.validators = options.validator;
+      newOptions.asyncValidators = options.asyncValidator;
+    }
+    return new FormGroup(reducedControls, newOptions);
+  }
+  record(controls, options = null) {
+    const reducedControls = this._reduceControls(controls);
+    return new FormRecord(reducedControls, options);
+  }
+  control(formState, validatorOrOpts, asyncValidator) {
+    let newOptions = {};
+    if (!this.useNonNullable) {
+      return new FormControl(formState, validatorOrOpts, asyncValidator);
+    }
+    if (isAbstractControlOptions(validatorOrOpts)) {
+      newOptions = validatorOrOpts;
+    } else {
+      newOptions.validators = validatorOrOpts;
+      newOptions.asyncValidators = asyncValidator;
+    }
+    return new FormControl(formState, __spreadProps(__spreadValues({}, newOptions), {
+      nonNullable: true
+    }));
+  }
+  array(controls, validatorOrOpts, asyncValidator) {
+    const createdControls = controls.map((c) => this._createControl(c));
+    return new FormArray(createdControls, validatorOrOpts, asyncValidator);
+  }
+  _reduceControls(controls) {
+    const createdControls = {};
+    Object.keys(controls).forEach((controlName) => {
+      createdControls[controlName] = this._createControl(controls[controlName]);
+    });
+    return createdControls;
+  }
+  _createControl(controls) {
+    if (controls instanceof FormControl) {
+      return controls;
+    } else if (controls instanceof AbstractControl) {
+      return controls;
+    } else if (Array.isArray(controls)) {
+      const value = controls[0];
+      const validator = controls.length > 1 ? controls[1] : null;
+      const asyncValidator = controls.length > 2 ? controls[2] : null;
+      return this.control(value, validator, asyncValidator);
+    } else {
+      return this.control(controls);
+    }
+  }
+  static \u0275fac = function FormBuilder_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _FormBuilder)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _FormBuilder,
+    factory: _FormBuilder.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(FormBuilder, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], null, null);
+})();
+var NonNullableFormBuilder = class _NonNullableFormBuilder {
+  static \u0275fac = function NonNullableFormBuilder_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _NonNullableFormBuilder)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _NonNullableFormBuilder,
+    factory: () => (() => inject2(FormBuilder).nonNullable)(),
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NonNullableFormBuilder, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root",
+      useFactory: () => inject2(FormBuilder).nonNullable
+    }]
+  }], null, null);
+})();
+var UntypedFormBuilder = class _UntypedFormBuilder extends FormBuilder {
+  group(controlsConfig, options = null) {
+    return super.group(controlsConfig, options);
+  }
+  control(formState, validatorOrOpts, asyncValidator) {
+    return super.control(formState, validatorOrOpts, asyncValidator);
+  }
+  array(controlsConfig, validatorOrOpts, asyncValidator) {
+    return super.array(controlsConfig, validatorOrOpts, asyncValidator);
+  }
+  static \u0275fac = /* @__PURE__ */ (() => {
+    let \u0275UntypedFormBuilder_BaseFactory;
+    return function UntypedFormBuilder_Factory(__ngFactoryType__) {
+      return (\u0275UntypedFormBuilder_BaseFactory || (\u0275UntypedFormBuilder_BaseFactory = \u0275\u0275getInheritedFactory(_UntypedFormBuilder)))(__ngFactoryType__ || _UntypedFormBuilder);
+    };
+  })();
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _UntypedFormBuilder,
+    factory: _UntypedFormBuilder.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(UntypedFormBuilder, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], null, null);
+})();
+var FormsModule = class _FormsModule {
+  static withConfig(opts) {
+    return {
+      ngModule: _FormsModule,
+      providers: [{
+        provide: CALL_SET_DISABLED_STATE,
+        useValue: opts.callSetDisabledState ?? setDisabledStateDefault
+      }]
+    };
+  }
+  static \u0275fac = function FormsModule_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _FormsModule)();
+  };
+  static \u0275mod = /* @__PURE__ */ \u0275\u0275defineNgModule({
+    type: _FormsModule,
+    declarations: [NgModel, NgModelGroup, NgForm],
+    exports: [\u0275InternalFormsSharedModule, NgModel, NgModelGroup, NgForm]
+  });
+  static \u0275inj = /* @__PURE__ */ \u0275\u0275defineInjector({
+    imports: [\u0275InternalFormsSharedModule]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(FormsModule, [{
+    type: NgModule,
+    args: [{
+      declarations: TEMPLATE_DRIVEN_DIRECTIVES,
+      exports: [\u0275InternalFormsSharedModule, TEMPLATE_DRIVEN_DIRECTIVES]
+    }]
+  }], null, null);
+})();
+var ReactiveFormsModule = class _ReactiveFormsModule {
+  static withConfig(opts) {
+    return {
+      ngModule: _ReactiveFormsModule,
+      providers: [{
+        provide: NG_MODEL_WITH_FORM_CONTROL_WARNING,
+        useValue: opts.warnOnNgModelWithFormControl ?? "always"
+      }, {
+        provide: CALL_SET_DISABLED_STATE,
+        useValue: opts.callSetDisabledState ?? setDisabledStateDefault
+      }]
+    };
+  }
+  static \u0275fac = function ReactiveFormsModule_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _ReactiveFormsModule)();
+  };
+  static \u0275mod = /* @__PURE__ */ \u0275\u0275defineNgModule({
+    type: _ReactiveFormsModule,
+    declarations: [FormControlDirective, FormGroupDirective, FormArrayDirective, FormControlName, FormGroupName, FormArrayName],
+    exports: [\u0275InternalFormsSharedModule, FormControlDirective, FormGroupDirective, FormArrayDirective, FormControlName, FormGroupName, FormArrayName]
+  });
+  static \u0275inj = /* @__PURE__ */ \u0275\u0275defineInjector({
+    imports: [\u0275InternalFormsSharedModule]
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ReactiveFormsModule, [{
+    type: NgModule,
+    args: [{
+      declarations: [REACTIVE_DRIVEN_DIRECTIVES],
+      exports: [\u0275InternalFormsSharedModule, REACTIVE_DRIVEN_DIRECTIVES]
+    }]
+  }], null, null);
+})();
+
+// src/app/services/prediction.service.ts
+var PredictionService = class _PredictionService {
+  http;
+  apiUrl = "";
+  REQUEST_TIMEOUT_MS = 15e3;
+  constructor(http) {
+    this.http = http;
+  }
+  predict(claim, model2 = "logistic") {
+    return this.http.post(`${this.apiUrl}/predict`, { claim, model: model2 }).pipe(timeout(this.REQUEST_TIMEOUT_MS));
+  }
+  static \u0275fac = function PredictionService_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _PredictionService)(\u0275\u0275inject(HttpClient));
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({ token: _PredictionService, factory: _PredictionService.\u0275fac, providedIn: "root" });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(PredictionService, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], () => [{ type: HttpClient }], null);
+})();
+
+// src/app/pages/home/home.ts
+var _forTrack0 = ($index, $item) => $item.id;
+var _forTrack1 = ($index, $item) => $item.key;
+function HomeComponent_For_29_Template(rf, ctx) {
+  if (rf & 1) {
+    const _r1 = \u0275\u0275getCurrentView();
+    \u0275\u0275elementStart(0, "button", 34);
+    \u0275\u0275listener("click", function HomeComponent_For_29_Template_button_click_0_listener() {
+      const m_r2 = \u0275\u0275restoreView(_r1).$implicit;
+      const ctx_r2 = \u0275\u0275nextContext();
+      return \u0275\u0275resetView(ctx_r2.selectModel(m_r2));
+    });
+    \u0275\u0275elementStart(1, "span", 35);
+    \u0275\u0275text(2);
+    \u0275\u0275elementEnd();
+    \u0275\u0275elementStart(3, "span", 36);
+    \u0275\u0275text(4);
+    \u0275\u0275elementEnd();
+    \u0275\u0275elementStart(5, "span", 37);
+    \u0275\u0275text(6);
+    \u0275\u0275elementEnd()();
+  }
+  if (rf & 2) {
+    const m_r2 = ctx.$implicit;
+    const ctx_r2 = \u0275\u0275nextContext();
+    \u0275\u0275classProp("pill-on", ctx_r2.selectedModel === m_r2.id)("pill-off", !m_r2.available);
+    \u0275\u0275advance(2);
+    \u0275\u0275textInterpolate(ctx_r2.selectedModel === m_r2.id ? "\u25CF" : "\u25CB");
+    \u0275\u0275advance(2);
+    \u0275\u0275textInterpolate(m_r2.algorithm);
+    \u0275\u0275advance(2);
+    \u0275\u0275textInterpolate(m_r2.accuracy);
+  }
+}
+function HomeComponent_Conditional_42_Template(rf, ctx) {
+  if (rf & 1) {
+    \u0275\u0275text(0, " analyser \xA0\u2192 ");
+  }
+}
+function HomeComponent_Conditional_43_Template(rf, ctx) {
+  if (rf & 1) {
+    \u0275\u0275namespaceSVG();
+    \u0275\u0275elementStart(0, "svg", 38);
+    \u0275\u0275element(1, "path", 39);
+    \u0275\u0275elementEnd();
+    \u0275\u0275text(2, " en cours\u2026 ");
+  }
+}
+function HomeComponent_Conditional_47_Template(rf, ctx) {
+  if (rf & 1) {
+    \u0275\u0275elementStart(0, "div", 30);
+    \u0275\u0275element(1, "div", 40)(2, "div", 41);
+    \u0275\u0275elementStart(3, "div", 42);
+    \u0275\u0275element(4, "div", 43)(5, "div", 44)(6, "div", 45)(7, "div", 46)(8, "div", 47)(9, "div", 48);
+    \u0275\u0275elementEnd()();
+  }
+}
+function HomeComponent_Conditional_48_Template(rf, ctx) {
+  if (rf & 1) {
+    \u0275\u0275elementStart(0, "div", 31)(1, "span", 49);
+    \u0275\u0275text(2, "\xD7");
+    \u0275\u0275elementEnd();
+    \u0275\u0275elementStart(3, "div")(4, "strong");
+    \u0275\u0275text(5, "Backend inaccessible");
+    \u0275\u0275elementEnd();
+    \u0275\u0275elementStart(6, "p");
+    \u0275\u0275text(7);
+    \u0275\u0275elementEnd()()();
+  }
+  if (rf & 2) {
+    const ctx_r2 = \u0275\u0275nextContext();
+    \u0275\u0275advance(7);
+    \u0275\u0275textInterpolate(ctx_r2.error);
+  }
+}
+function HomeComponent_Conditional_49_For_16_Template(rf, ctx) {
+  if (rf & 1) {
+    \u0275\u0275elementStart(0, "div", 57)(1, "div", 58);
+    \u0275\u0275text(2);
+    \u0275\u0275elementStart(3, "span", 59);
+    \u0275\u0275text(4, "%");
+    \u0275\u0275elementEnd()();
+    \u0275\u0275elementStart(5, "div", 60);
+    \u0275\u0275element(6, "div");
+    \u0275\u0275elementEnd();
+    \u0275\u0275elementStart(7, "div", 61);
+    \u0275\u0275text(8);
+    \u0275\u0275elementEnd()();
+  }
+  if (rf & 2) {
+    const cls_r4 = ctx.$implicit;
+    const \u0275$index_155_r5 = ctx.$index;
+    const ctx_r2 = \u0275\u0275nextContext(2);
+    \u0275\u0275styleProp("--delay", \u0275$index_155_r5 * 80 + "ms");
+    \u0275\u0275classProp("col-active", cls_r4.key === ctx_r2.result);
+    \u0275\u0275advance();
+    \u0275\u0275classProp("pct-active", cls_r4.key === ctx_r2.result);
+    \u0275\u0275advance();
+    \u0275\u0275textInterpolate1(" ", cls_r4.probability);
+    \u0275\u0275advance(4);
+    \u0275\u0275classMap("col-bar bar-" + cls_r4.color);
+    \u0275\u0275styleProp("height", ctx_r2.animate ? cls_r4.probability + "%" : "0%");
+    \u0275\u0275advance();
+    \u0275\u0275classProp("key-active", cls_r4.key === ctx_r2.result);
+    \u0275\u0275advance();
+    \u0275\u0275textInterpolate(cls_r4.shortLabel);
+  }
+}
+function HomeComponent_Conditional_49_Template(rf, ctx) {
+  if (rf & 1) {
+    \u0275\u0275elementStart(0, "div", 32)(1, "div")(2, "div", 50);
+    \u0275\u0275text(3);
+    \u0275\u0275elementStart(4, "span", 51);
+    \u0275\u0275text(5, "%");
+    \u0275\u0275elementEnd()();
+    \u0275\u0275elementStart(6, "div", 52);
+    \u0275\u0275text(7);
+    \u0275\u0275elementEnd();
+    \u0275\u0275elementStart(8, "div", 53);
+    \u0275\u0275text(9);
+    \u0275\u0275elementEnd();
+    \u0275\u0275elementStart(10, "div", 54);
+    \u0275\u0275text(11);
+    \u0275\u0275elementStart(12, "code");
+    \u0275\u0275text(13);
+    \u0275\u0275elementEnd()()();
+    \u0275\u0275elementStart(14, "div", 55);
+    \u0275\u0275repeaterCreate(15, HomeComponent_Conditional_49_For_16_Template, 9, 14, "div", 56, _forTrack1);
+    \u0275\u0275elementEnd()();
+  }
+  if (rf & 2) {
+    const ctx_r2 = \u0275\u0275nextContext();
+    \u0275\u0275advance();
+    \u0275\u0275classMap(ctx_r2.getVerdictClass());
+    \u0275\u0275advance(2);
+    \u0275\u0275textInterpolate(ctx_r2.topProbability);
+    \u0275\u0275advance(4);
+    \u0275\u0275textInterpolate(ctx_r2.verdict.label);
+    \u0275\u0275advance(2);
+    \u0275\u0275textInterpolate(ctx_r2.verdict.desc);
+    \u0275\u0275advance(2);
+    \u0275\u0275textInterpolate2(" ", ctx_r2.getSelectedModel().algorithm, " + ", ctx_r2.getSelectedModel().vectorizer, " \xA0\xB7\xA0 sortie\xA0:\xA0");
+    \u0275\u0275advance(2);
+    \u0275\u0275textInterpolate(ctx_r2.result);
+    \u0275\u0275advance(2);
+    \u0275\u0275repeater(ctx_r2.classBreakdown);
+  }
+}
+function HomeComponent_Conditional_50_Template(rf, ctx) {
+  if (rf & 1) {
+    \u0275\u0275elementStart(0, "div", 33)(1, "p", 62);
+    \u0275\u0275text(2, "Aucune d\xE9claration analys\xE9e.");
+    \u0275\u0275elementEnd();
+    \u0275\u0275elementStart(3, "p", 63);
+    \u0275\u0275text(4, "Saisissez un texte ci-dessus et appuyez sur ");
+    \u0275\u0275elementStart(5, "em");
+    \u0275\u0275text(6, "analyser");
+    \u0275\u0275elementEnd();
+    \u0275\u0275text(7, ".");
+    \u0275\u0275elementEnd()();
+  }
+}
+var VERDICTS = {
+  "true": { label: "Vrai", desc: "Cette d\xE9claration est exacte et bien document\xE9e.", color: "green", icon: "check2" },
+  "mostly-true": { label: "Majoritairement vrai", desc: "Globalement exacte avec quelques impr\xE9cisions mineures.", color: "lime", icon: "check" },
+  "half-true": { label: "Partiellement vrai", desc: "D\xE9claration partiellement exacte mais manquant de contexte important.", color: "yellow", icon: "half" },
+  "barely-true": { label: "\xC0 peine vrai", desc: "Contient un fond de v\xE9rit\xE9 mais reste fondamentalement trompeur.", color: "orange", icon: "minus" },
+  "false": { label: "Faux", desc: "Cette d\xE9claration est inexacte.", color: "red", icon: "cross" },
+  "pants-fire": { label: "Totalement faux", desc: "D\xE9claration compl\xE8tement erron\xE9e et absurde.", color: "crimson", icon: "fire" }
+};
+var SHORT_LABELS = {
+  "true": "VRAI",
+  "mostly-true": "MAJ.",
+  "half-true": "PART.",
+  "barely-true": "PEINE",
+  "false": "FAUX",
+  "pants-fire": "TOT."
+};
+var VERDICT_ORDER = ["true", "mostly-true", "half-true", "barely-true", "false", "pants-fire"];
+var HomeComponent = class _HomeComponent {
+  predictionService;
+  cdr;
+  claim = "";
+  result = null;
+  verdict = null;
+  probabilities = null;
+  animate = false;
+  loading = false;
+  error = "";
+  charCount = 0;
+  maxChars = 1e3;
+  models = [
+    { id: "logistic", name: "R\xE9gression Logistique", algorithm: "LR", vectorizer: "TF-IDF", accuracy: "92%", available: true },
+    { id: "random_forest", name: "For\xEAt Al\xE9atoire", algorithm: "RF", vectorizer: "TF-IDF", accuracy: "89%", available: false },
+    { id: "svm", name: "SVM Lin\xE9aire", algorithm: "SVC", vectorizer: "TF-IDF", accuracy: "90%", available: false },
+    { id: "naive_bayes", name: "Naive Bayes", algorithm: "NB", vectorizer: "TF-IDF", accuracy: "85%", available: false }
+  ];
+  selectedModel = "logistic";
+  constructor(predictionService, cdr) {
+    this.predictionService = predictionService;
+    this.cdr = cdr;
+  }
+  get classBreakdown() {
+    return VERDICT_ORDER.map((key) => {
+      const v = VERDICTS[key];
+      const prob = this.probabilities ? Math.round((this.probabilities[key] ?? 0) * 100) : this.result === key ? 100 : 0;
+      return { key, label: v.label, shortLabel: SHORT_LABELS[key], color: v.color, probability: prob };
+    });
+  }
+  get topProbability() {
+    if (!this.result)
+      return 0;
+    return this.classBreakdown.find((c) => c.key === this.result)?.probability ?? 100;
+  }
+  getVerdictClass() {
+    return this.verdict ? `verdict-display vd-${this.verdict.color}` : "verdict-display";
+  }
+  selectModel(model2) {
+    if (model2.available)
+      this.selectedModel = model2.id;
+  }
+  getSelectedModel() {
+    return this.models.find((m) => m.id === this.selectedModel);
+  }
+  onClaimChange() {
+    this.charCount = this.claim.length;
+  }
+  predict() {
+    if (!this.claim.trim() || this.loading)
+      return;
+    this.loading = true;
+    this.error = "";
+    this.result = null;
+    this.verdict = null;
+    this.probabilities = null;
+    this.animate = false;
+    this.cdr.detectChanges();
+    this.predictionService.predict(this.claim, this.selectedModel).subscribe({
+      next: (res) => {
+        this.result = String(res.prediction).toLowerCase().trim();
+        this.verdict = VERDICTS[this.result] ?? {
+          label: res.prediction,
+          desc: "Classification inconnue.",
+          color: "red",
+          icon: "cross"
+        };
+        this.probabilities = res.probabilities ?? null;
+        this.loading = false;
+        this.cdr.detectChanges();
+        setTimeout(() => {
+          this.animate = true;
+          this.cdr.detectChanges();
+        }, 80);
+      },
+      error: (err) => {
+        this.loading = false;
+        if (err?.name === "TimeoutError") {
+          this.error = "D\xE9lai d\xE9pass\xE9 \u2014 backend inaccessible sur le port 8000.";
+        } else if (err?.status === 0) {
+          this.error = "Backend introuvable sur http://localhost:8000.";
+        } else {
+          this.error = err?.error?.detail ?? err?.message ?? "Erreur inconnue";
+        }
+        this.cdr.detectChanges();
+      }
+    });
+  }
+  clearForm() {
+    this.claim = "";
+    this.result = null;
+    this.verdict = null;
+    this.probabilities = null;
+    this.error = "";
+    this.charCount = 0;
+    this.animate = false;
+    this.cdr.detectChanges();
+  }
+  static \u0275fac = function HomeComponent_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _HomeComponent)(\u0275\u0275directiveInject(PredictionService), \u0275\u0275directiveInject(ChangeDetectorRef));
+  };
+  static \u0275cmp = /* @__PURE__ */ \u0275\u0275defineComponent({ type: _HomeComponent, selectors: [["app-home"]], decls: 51, vars: 16, consts: [[1, "page"], ["aria-hidden", "true", 1, "grain"], [1, "site-header"], [1, "hdr-left"], [1, "brand-name"], [1, "brand-r"], [1, "brand-dash"], [1, "brand-word"], [1, "hdr-right"], [1, "hdr-live"], [1, "live-dot"], [1, "page-body"], [1, "hero"], [1, "hero-eyebrow"], [1, "hero-title"], [1, "model-rail"], [1, "rail-label"], [1, "rail-pills"], [1, "model-pill", 3, "pill-on", "pill-off"], [1, "claim-section"], [1, "claim-eyebrow"], ["placeholder", "Saisissez une d\xE9claration politique, m\xE9diatique ou factuelle\u2026", "rows", "4", 1, "claim-field", 3, "ngModelChange", "input", "keydown.ctrl.enter", "ngModel"], [1, "claim-bar"], [1, "claim-count"], [1, "claim-actions"], [1, "act-clear", 3, "click", "disabled"], [1, "act-submit", 3, "click", "disabled"], [1, "divider"], [1, "divider-fill"], [1, "result-section"], [1, "skel-wrap"], [1, "error-wrap"], [1, "verdict-wrap"], [1, "empty-wrap"], [1, "model-pill", 3, "click"], [1, "pill-dot"], [1, "pill-algo"], [1, "pill-acc"], ["width", "13", "height", "13", "viewBox", "0 0 24 24", "fill", "none", "stroke", "currentColor", "stroke-width", "2.5", 1, "spin-icon"], ["d", "M12 2a10 10 0 0 1 10 10"], [1, "skel", "skel-title"], [1, "skel", "skel-rule"], [1, "skel-chart-row"], [1, "skel", "skel-col", 2, "height", "85%"], [1, "skel", "skel-col", 2, "height", "55%"], [1, "skel", "skel-col", 2, "height", "38%"], [1, "skel", "skel-col", 2, "height", "22%"], [1, "skel", "skel-col", 2, "height", "12%"], [1, "skel", "skel-col", 2, "height", "7%"], [1, "error-x"], [1, "vd-confidence"], [1, "pct"], [1, "vd-label"], [1, "vd-desc"], [1, "vd-meta"], [1, "class-chart"], [1, "chart-col", 3, "col-active", "--delay"], [1, "chart-col"], [1, "col-pct"], [1, "pct-s"], [1, "col-track"], [1, "col-key"], [1, "empty-italic"], [1, "empty-hint"]], template: function HomeComponent_Template(rf, ctx) {
+    if (rf & 1) {
+      \u0275\u0275elementStart(0, "div", 0);
+      \u0275\u0275element(1, "div", 1);
+      \u0275\u0275elementStart(2, "header", 2)(3, "div", 3)(4, "div", 4)(5, "span", 5);
+      \u0275\u0275text(6, "R");
+      \u0275\u0275elementEnd();
+      \u0275\u0275elementStart(7, "span", 6);
+      \u0275\u0275text(8, "\u2014");
+      \u0275\u0275elementEnd();
+      \u0275\u0275elementStart(9, "span", 7);
+      \u0275\u0275text(10, "Checker");
+      \u0275\u0275elementEnd()()();
+      \u0275\u0275elementStart(11, "div", 8)(12, "span", 9);
+      \u0275\u0275element(13, "span", 10);
+      \u0275\u0275text(14);
+      \u0275\u0275elementEnd()()();
+      \u0275\u0275elementStart(15, "div", 11)(16, "section", 12)(17, "p", 13);
+      \u0275\u0275text(18, "Analyse s\xE9mantique \xA0\xB7\xA0 Dataset LIAR \xA0\xB7\xA0 6 classes");
+      \u0275\u0275elementEnd();
+      \u0275\u0275elementStart(19, "h1", 14);
+      \u0275\u0275text(20, "Analysez");
+      \u0275\u0275element(21, "br");
+      \u0275\u0275elementStart(22, "em");
+      \u0275\u0275text(23, "la v\xE9rit\xE9");
+      \u0275\u0275elementEnd()()();
+      \u0275\u0275elementStart(24, "div", 15)(25, "span", 16);
+      \u0275\u0275text(26, "Mod\xE8le actif");
+      \u0275\u0275elementEnd();
+      \u0275\u0275elementStart(27, "div", 17);
+      \u0275\u0275repeaterCreate(28, HomeComponent_For_29_Template, 7, 7, "button", 18, _forTrack0);
+      \u0275\u0275elementEnd()();
+      \u0275\u0275elementStart(30, "section", 19)(31, "label", 20);
+      \u0275\u0275text(32, "\u21B3 d\xE9claration \xE0 analyser");
+      \u0275\u0275elementEnd();
+      \u0275\u0275elementStart(33, "textarea", 21);
+      \u0275\u0275twoWayListener("ngModelChange", function HomeComponent_Template_textarea_ngModelChange_33_listener($event) {
+        \u0275\u0275twoWayBindingSet(ctx.claim, $event) || (ctx.claim = $event);
+        return $event;
+      });
+      \u0275\u0275listener("input", function HomeComponent_Template_textarea_input_33_listener() {
+        return ctx.onClaimChange();
+      })("keydown.ctrl.enter", function HomeComponent_Template_textarea_keydown_ctrl_enter_33_listener() {
+        return ctx.predict();
+      });
+      \u0275\u0275text(34, "      ");
+      \u0275\u0275elementEnd();
+      \u0275\u0275elementStart(35, "div", 22)(36, "span", 23);
+      \u0275\u0275text(37);
+      \u0275\u0275elementEnd();
+      \u0275\u0275elementStart(38, "div", 24)(39, "button", 25);
+      \u0275\u0275listener("click", function HomeComponent_Template_button_click_39_listener() {
+        return ctx.clearForm();
+      });
+      \u0275\u0275text(40, "effacer");
+      \u0275\u0275elementEnd();
+      \u0275\u0275elementStart(41, "button", 26);
+      \u0275\u0275listener("click", function HomeComponent_Template_button_click_41_listener() {
+        return ctx.predict();
+      });
+      \u0275\u0275conditionalCreate(42, HomeComponent_Conditional_42_Template, 1, 0)(43, HomeComponent_Conditional_43_Template, 3, 0);
+      \u0275\u0275elementEnd()()()();
+      \u0275\u0275elementStart(44, "div", 27);
+      \u0275\u0275element(45, "div", 28);
+      \u0275\u0275elementEnd();
+      \u0275\u0275elementStart(46, "section", 29);
+      \u0275\u0275conditionalCreate(47, HomeComponent_Conditional_47_Template, 10, 0, "div", 30);
+      \u0275\u0275conditionalCreate(48, HomeComponent_Conditional_48_Template, 8, 1, "div", 31);
+      \u0275\u0275conditionalCreate(49, HomeComponent_Conditional_49_Template, 17, 8, "div", 32);
+      \u0275\u0275conditionalCreate(50, HomeComponent_Conditional_50_Template, 8, 0, "div", 33);
+      \u0275\u0275elementEnd()()();
+    }
+    if (rf & 2) {
+      \u0275\u0275advance(14);
+      \u0275\u0275textInterpolate1(" ", ctx.getSelectedModel().name, "\xA0\xB7\xA0actif ");
+      \u0275\u0275advance(14);
+      \u0275\u0275repeater(ctx.models);
+      \u0275\u0275advance(5);
+      \u0275\u0275twoWayProperty("ngModel", ctx.claim);
+      \u0275\u0275attribute("maxlength", ctx.maxChars);
+      \u0275\u0275advance(3);
+      \u0275\u0275classProp("warn", ctx.charCount > ctx.maxChars * 0.8);
+      \u0275\u0275advance();
+      \u0275\u0275textInterpolate2("", ctx.charCount, "/", ctx.maxChars);
+      \u0275\u0275advance(2);
+      \u0275\u0275property("disabled", !ctx.claim && !ctx.result);
+      \u0275\u0275advance(2);
+      \u0275\u0275property("disabled", !ctx.claim.trim() || ctx.loading);
+      \u0275\u0275advance();
+      \u0275\u0275conditional(!ctx.loading ? 42 : 43);
+      \u0275\u0275advance(3);
+      \u0275\u0275classProp("running", ctx.loading);
+      \u0275\u0275advance(2);
+      \u0275\u0275conditional(ctx.loading ? 47 : -1);
+      \u0275\u0275advance();
+      \u0275\u0275conditional(ctx.error && !ctx.loading ? 48 : -1);
+      \u0275\u0275advance();
+      \u0275\u0275conditional(ctx.verdict && !ctx.loading ? 49 : -1);
+      \u0275\u0275advance();
+      \u0275\u0275conditional(!ctx.verdict && !ctx.loading && !ctx.error ? 50 : -1);
+    }
+  }, dependencies: [FormsModule, DefaultValueAccessor, NgControlStatus, NgModel], styles: [`
+[_nghost-%COMP%] {
+  display: block;
+  min-height: 100vh;
+}
+*[_ngcontent-%COMP%] {
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+}
+.page[_ngcontent-%COMP%] {
+  min-height: 100vh;
+  background:
+    radial-gradient(
+      ellipse 140% 100% at 50% 0%,
+      #f8f4ec 0%,
+      #eee8da 100%);
+  font-family:
+    "Barlow",
+    -apple-system,
+    sans-serif;
+  color: #1a1510;
+  position: relative;
+}
+.grain[_ngcontent-%COMP%] {
+  position: fixed;
+  inset: 0;
+  pointer-events: none;
+  z-index: 900;
+  opacity: 0.035;
+  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='300' height='300'%3E%3Cfilter id='n'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='0.72' numOctaves='4' stitchTiles='stitch'/%3E%3C/filter%3E%3Crect width='300' height='300' filter='url(%23n)'/%3E%3C/svg%3E");
+  background-size: 280px;
+}
+.site-header[_ngcontent-%COMP%] {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 0 48px;
+  height: 60px;
+  border-bottom: 1px solid rgba(0, 0, 0, 0.1);
+  position: sticky;
+  top: 0;
+  background: rgba(248, 244, 236, 0.88);
+  backdrop-filter: blur(12px);
+  -webkit-backdrop-filter: blur(12px);
+  z-index: 50;
+}
+.hdr-left[_ngcontent-%COMP%] {
+  display: flex;
+  align-items: center;
+}
+.brand-name[_ngcontent-%COMP%] {
+  display: flex;
+  align-items: baseline;
+  line-height: 1;
+  -webkit-user-select: none;
+  user-select: none;
+}
+.brand-r[_ngcontent-%COMP%] {
+  font-family:
+    "Cormorant Garamond",
+    Georgia,
+    serif;
+  font-size: 30px;
+  font-weight: 700;
+  font-style: italic;
+  color: #c8952a;
+  line-height: 1;
+  letter-spacing: -0.5px;
+}
+.brand-dash[_ngcontent-%COMP%] {
+  font-family: "Barlow", sans-serif;
+  font-size: 15px;
+  font-weight: 300;
+  color: rgba(26, 21, 16, 0.22);
+  margin: 0 3px 0 2px;
+  align-self: center;
+}
+.brand-word[_ngcontent-%COMP%] {
+  font-family: "Barlow", sans-serif;
+  font-size: 12.5px;
+  font-weight: 700;
+  letter-spacing: 3.5px;
+  text-transform: uppercase;
+  color: #1a1510;
+  align-self: center;
+}
+.hdr-right[_ngcontent-%COMP%] {
+  display: flex;
+  align-items: center;
+}
+.hdr-live[_ngcontent-%COMP%] {
+  display: flex;
+  align-items: center;
+  gap: 7px;
+  font-family: "Fira Code", monospace;
+  font-size: 11px;
+  font-weight: 500;
+  color: #3a5044;
+  letter-spacing: 0.2px;
+}
+.live-dot[_ngcontent-%COMP%] {
+  width: 6px;
+  height: 6px;
+  background: #3a9460;
+  border-radius: 50%;
+  animation: _ngcontent-%COMP%_pulse 2.5s ease-in-out infinite;
+}
+.page-body[_ngcontent-%COMP%] {
+  max-width: 780px;
+  margin: 0 auto;
+  padding: 0 48px 100px;
+}
+.hero[_ngcontent-%COMP%] {
+  padding: 58px 0 28px;
+}
+.hero-eyebrow[_ngcontent-%COMP%] {
+  font-size: 10.5px;
+  font-weight: 600;
+  letter-spacing: 2px;
+  text-transform: uppercase;
+  color: #7a7265;
+  margin-bottom: 18px;
+}
+.hero-title[_ngcontent-%COMP%] {
+  font-family:
+    "Cormorant Garamond",
+    Georgia,
+    serif;
+  font-size: 72px;
+  font-weight: 600;
+  line-height: 0.92;
+  letter-spacing: -1.5px;
+  color: #1a1510;
+}
+.hero-title[_ngcontent-%COMP%]   em[_ngcontent-%COMP%] {
+  font-style: italic;
+  color: #c8952a;
+  font-weight: 500;
+}
+.model-rail[_ngcontent-%COMP%] {
+  display: flex;
+  align-items: center;
+  gap: 18px;
+  padding: 22px 0;
+  border-top: 1px solid rgba(0, 0, 0, 0.09);
+  border-bottom: 1px solid rgba(0, 0, 0, 0.09);
+  margin-bottom: 36px;
+  flex-wrap: wrap;
+}
+.rail-label[_ngcontent-%COMP%] {
+  font-size: 9.5px;
+  font-weight: 700;
+  letter-spacing: 1.8px;
+  text-transform: uppercase;
+  color: #6a6255;
+  flex-shrink: 0;
+}
+.rail-pills[_ngcontent-%COMP%] {
+  display: flex;
+  gap: 6px;
+  flex-wrap: wrap;
+}
+.model-pill[_ngcontent-%COMP%] {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 7px 15px;
+  background: transparent;
+  border: 1.5px solid rgba(0, 0, 0, 0.16);
+  border-radius: 28px;
+  font-family: "Barlow", sans-serif;
+  font-size: 12px;
+  font-weight: 600;
+  color: #5a5448;
+  cursor: default;
+  transition: all 0.17s;
+  letter-spacing: 0.2px;
+}
+.model-pill.pill-on[_ngcontent-%COMP%] {
+  background: #1a1510;
+  border-color: #1a1510;
+  color: #f5f0e5;
+  cursor: pointer;
+  box-shadow: 0 2px 10px rgba(0, 0, 0, 0.18);
+}
+.model-pill.pill-off[_ngcontent-%COMP%] {
+  opacity: 0.35;
+}
+.model-pill[_ngcontent-%COMP%]:not(.pill-on):not(.pill-off) {
+  cursor: pointer;
+}
+.model-pill[_ngcontent-%COMP%]:not(.pill-on):not(.pill-off):hover {
+  border-color: rgba(0, 0, 0, 0.28);
+  color: #1a1510;
+}
+.pill-dot[_ngcontent-%COMP%] {
+  font-size: 9.5px;
+  line-height: 1;
+  opacity: 0.8;
+}
+.pill-algo[_ngcontent-%COMP%] {
+  font-family: "Fira Code", monospace;
+  font-size: 11px;
+}
+.pill-acc[_ngcontent-%COMP%] {
+  font-size: 11px;
+  color: #8a8070;
+}
+.claim-section[_ngcontent-%COMP%] {
+  margin-bottom: 28px;
+}
+.claim-eyebrow[_ngcontent-%COMP%] {
+  display: block;
+  font-size: 9.5px;
+  font-weight: 700;
+  letter-spacing: 1.8px;
+  text-transform: uppercase;
+  color: #6a6255;
+  margin-bottom: 14px;
+}
+.claim-field[_ngcontent-%COMP%] {
+  display: block;
+  width: 100%;
+  background: transparent;
+  border: none;
+  border-bottom: 2px solid rgba(0, 0, 0, 0.14);
+  padding: 10px 0 14px;
+  font-family: "Barlow", sans-serif;
+  font-size: 16px;
+  line-height: 1.68;
+  color: #1a1510;
+  resize: none;
+  outline: none;
+  transition: border-color 0.2s;
+}
+.claim-field[_ngcontent-%COMP%]:focus {
+  border-bottom-color: #c8952a;
+}
+.claim-field[_ngcontent-%COMP%]::placeholder {
+  color: #ccc4b4;
+  font-style: italic;
+  font-size: 15.5px;
+}
+.claim-bar[_ngcontent-%COMP%] {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding-top: 10px;
+}
+.claim-count[_ngcontent-%COMP%] {
+  font-family: "Fira Code", monospace;
+  font-size: 11px;
+  color: #8a8275;
+}
+.claim-count.warn[_ngcontent-%COMP%] {
+  color: #c8952a;
+  font-weight: 600;
+}
+.claim-actions[_ngcontent-%COMP%] {
+  display: flex;
+  align-items: center;
+  gap: 16px;
+}
+.act-clear[_ngcontent-%COMP%] {
+  background: none;
+  border: none;
+  font-family: "Barlow", sans-serif;
+  font-size: 12.5px;
+  font-weight: 600;
+  color: #8a8275;
+  cursor: pointer;
+  letter-spacing: 0.3px;
+  transition: color 0.15s;
+  padding: 6px 0;
+}
+.act-clear[_ngcontent-%COMP%]:hover:not(:disabled) {
+  color: #1a1510;
+}
+.act-clear[_ngcontent-%COMP%]:disabled {
+  opacity: 0.28;
+  cursor: not-allowed;
+}
+.act-submit[_ngcontent-%COMP%] {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 10px 26px;
+  background: #1a1510;
+  color: #f5f0e5;
+  border: none;
+  border-radius: 3px;
+  font-family: "Barlow", sans-serif;
+  font-size: 13px;
+  font-weight: 700;
+  cursor: pointer;
+  letter-spacing: 0.6px;
+  transition:
+    background 0.15s,
+    transform 0.12s,
+    box-shadow 0.15s;
+}
+.act-submit[_ngcontent-%COMP%]:hover:not(:disabled) {
+  background: #2e2820;
+  box-shadow: 0 4px 18px rgba(0, 0, 0, 0.22);
+  transform: translateY(-1px);
+}
+.act-submit[_ngcontent-%COMP%]:active:not(:disabled) {
+  transform: translateY(0);
+  box-shadow: none;
+}
+.act-submit[_ngcontent-%COMP%]:disabled {
+  opacity: 0.3;
+  cursor: not-allowed;
+}
+.spin-icon[_ngcontent-%COMP%] {
+  animation: _ngcontent-%COMP%_spin 0.72s linear infinite;
+}
+.divider[_ngcontent-%COMP%] {
+  height: 2px;
+  background: rgba(0, 0, 0, 0.1);
+  margin-bottom: 40px;
+  position: relative;
+  overflow: hidden;
+  border-radius: 1px;
+}
+.divider-fill[_ngcontent-%COMP%] {
+  position: absolute;
+  left: 0;
+  top: 0;
+  bottom: 0;
+  width: 0;
+  background:
+    linear-gradient(
+      90deg,
+      #c8952a 0%,
+      #e8b840 50%,
+      #c8952a 100%);
+  background-size: 200% 100%;
+}
+.divider-fill.running[_ngcontent-%COMP%] {
+  animation: _ngcontent-%COMP%_progressRun 14s cubic-bezier(0.1, 0.9, 0.2, 1) forwards, _ngcontent-%COMP%_shimmerGold 1.6s linear infinite;
+}
+.result-section[_ngcontent-%COMP%] {
+  min-height: 160px;
+}
+.empty-wrap[_ngcontent-%COMP%] {
+  padding: 32px 0 20px;
+}
+.empty-italic[_ngcontent-%COMP%] {
+  font-family:
+    "Cormorant Garamond",
+    Georgia,
+    serif;
+  font-size: 26px;
+  font-style: italic;
+  font-weight: 500;
+  color: #9a9285;
+  margin-bottom: 8px;
+}
+.empty-hint[_ngcontent-%COMP%] {
+  font-size: 12.5px;
+  color: #8a8275;
+}
+.empty-hint[_ngcontent-%COMP%]   em[_ngcontent-%COMP%] {
+  font-style: normal;
+  font-weight: 700;
+  color: #6a6255;
+}
+.skel-wrap[_ngcontent-%COMP%] {
+  display: flex;
+  flex-direction: column;
+  gap: 18px;
+  animation: _ngcontent-%COMP%_fadeUp 0.22s ease;
+}
+.skel[_ngcontent-%COMP%] {
+  background:
+    linear-gradient(
+      90deg,
+      #e8e2d8 25%,
+      #ddd8cc 50%,
+      #e8e2d8 75%);
+  background-size: 200% 100%;
+  border-radius: 3px;
+  animation: _ngcontent-%COMP%_shimmer 1.4s infinite;
+}
+.skel-title[_ngcontent-%COMP%] {
+  height: 58px;
+  width: 55%;
+}
+.skel-rule[_ngcontent-%COMP%] {
+  height: 2px;
+  width: 100%;
+  border-radius: 0;
+}
+.skel-chart-row[_ngcontent-%COMP%] {
+  display: flex;
+  gap: 10px;
+  align-items: flex-end;
+  height: 88px;
+}
+.skel-col[_ngcontent-%COMP%] {
+  flex: 1;
+  border-radius: 2px;
+}
+.error-wrap[_ngcontent-%COMP%] {
+  display: flex;
+  align-items: flex-start;
+  gap: 16px;
+  padding: 20px 0;
+  border-top: 2.5px solid #b83020;
+  animation: _ngcontent-%COMP%_fadeUp 0.2s ease;
+}
+.error-x[_ngcontent-%COMP%] {
+  font-family: "Cormorant Garamond", serif;
+  font-size: 38px;
+  line-height: 1;
+  color: #b83020;
+  font-weight: 700;
+  flex-shrink: 0;
+  margin-top: -4px;
+}
+.error-wrap[_ngcontent-%COMP%]   div[_ngcontent-%COMP%]   strong[_ngcontent-%COMP%] {
+  font-size: 13.5px;
+  font-weight: 700;
+  color: #b83020;
+  display: block;
+  margin-bottom: 4px;
+}
+.error-wrap[_ngcontent-%COMP%]   div[_ngcontent-%COMP%]   p[_ngcontent-%COMP%] {
+  font-size: 12.5px;
+  color: #9a2810;
+  line-height: 1.55;
+}
+.verdict-wrap[_ngcontent-%COMP%] {
+  display: flex;
+  flex-direction: column;
+  gap: 36px;
+  animation: _ngcontent-%COMP%_fadeUp 0.28s cubic-bezier(0.34, 1.56, 0.64, 1);
+}
+.verdict-display[_ngcontent-%COMP%] {
+  padding: 24px 0 20px;
+  border-top: 2.5px solid currentColor;
+}
+.vd-confidence[_ngcontent-%COMP%] {
+  font-family: "Fira Code", monospace;
+  font-size: 13px;
+  font-weight: 600;
+  color: #6a6255;
+  margin-bottom: 4px;
+  letter-spacing: 0.5px;
+}
+.pct[_ngcontent-%COMP%] {
+  font-size: 10px;
+  opacity: 0.8;
+}
+.vd-label[_ngcontent-%COMP%] {
+  font-family:
+    "Cormorant Garamond",
+    Georgia,
+    serif;
+  font-size: 64px;
+  font-weight: 700;
+  line-height: 1;
+  letter-spacing: -1px;
+  margin-bottom: 16px;
+  text-transform: capitalize;
+}
+.vd-desc[_ngcontent-%COMP%] {
+  font-size: 15px;
+  line-height: 1.7;
+  color: #6a6050;
+  margin-bottom: 12px;
+  max-width: 500px;
+}
+.vd-meta[_ngcontent-%COMP%] {
+  font-family: "Fira Code", monospace;
+  font-size: 10.5px;
+  color: #7a7265;
+  letter-spacing: 0.3px;
+}
+.vd-meta[_ngcontent-%COMP%]   code[_ngcontent-%COMP%] {
+  background: rgba(0, 0, 0, 0.07);
+  padding: 1px 5px;
+  border-radius: 3px;
+}
+.vd-green[_ngcontent-%COMP%] {
+  color: #0c6030;
+  border-color: rgba(12, 96, 48, 0.45);
+}
+.vd-lime[_ngcontent-%COMP%] {
+  color: #28783c;
+  border-color: rgba(40, 120, 60, 0.40);
+}
+.vd-yellow[_ngcontent-%COMP%] {
+  color: #8a6600;
+  border-color: rgba(138, 102, 0, 0.42);
+}
+.vd-orange[_ngcontent-%COMP%] {
+  color: #8a4600;
+  border-color: rgba(138, 70, 0, 0.42);
+}
+.vd-red[_ngcontent-%COMP%] {
+  color: #8a1e10;
+  border-color: rgba(138, 30, 16, 0.42);
+}
+.vd-crimson[_ngcontent-%COMP%] {
+  color: #6a0818;
+  border-color: rgba(106, 8, 24, 0.42);
+}
+.class-chart[_ngcontent-%COMP%] {
+  display: flex;
+  gap: 8px;
+}
+.chart-col[_ngcontent-%COMP%] {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 8px;
+}
+.col-pct[_ngcontent-%COMP%] {
+  font-family: "Fira Code", monospace;
+  font-size: 10.5px;
+  color: #7a7265;
+  font-weight: 600;
+  line-height: 1;
+}
+.col-pct.pct-active[_ngcontent-%COMP%] {
+  color: #1a1510;
+  font-weight: 700;
+}
+.pct-s[_ngcontent-%COMP%] {
+  font-size: 8.5px;
+  opacity: 0.7;
+}
+.col-track[_ngcontent-%COMP%] {
+  width: 100%;
+  height: 88px;
+  display: flex;
+  align-items: flex-end;
+  background: rgba(0, 0, 0, 0.05);
+  border-radius: 3px;
+  overflow: hidden;
+}
+.chart-col.col-active[_ngcontent-%COMP%]   .col-track[_ngcontent-%COMP%] {
+  background: rgba(0, 0, 0, 0.08);
+}
+.col-bar[_ngcontent-%COMP%] {
+  width: 100%;
+  border-radius: 2px 2px 0 0;
+  min-height: 0;
+  transition: height 0.78s cubic-bezier(0.4, 0, 0.2, 1);
+  transition-delay: var(--delay, 0ms);
+}
+.bar-green[_ngcontent-%COMP%] {
+  background:
+    linear-gradient(
+      180deg,
+      #3aaa72 0%,
+      #1e8850 100%);
+}
+.bar-lime[_ngcontent-%COMP%] {
+  background:
+    linear-gradient(
+      180deg,
+      #50b868 0%,
+      #389050 100%);
+}
+.bar-yellow[_ngcontent-%COMP%] {
+  background:
+    linear-gradient(
+      180deg,
+      #d0aa22 0%,
+      #b09012 100%);
+}
+.bar-orange[_ngcontent-%COMP%] {
+  background:
+    linear-gradient(
+      180deg,
+      #d09232 0%,
+      #b07018 100%);
+}
+.bar-red[_ngcontent-%COMP%] {
+  background:
+    linear-gradient(
+      180deg,
+      #e06052 0%,
+      #c04035 100%);
+}
+.bar-crimson[_ngcontent-%COMP%] {
+  background:
+    linear-gradient(
+      180deg,
+      #c03058 0%,
+      #a01838 100%);
+}
+.col-key[_ngcontent-%COMP%] {
+  font-family: "Fira Code", monospace;
+  font-size: 9px;
+  font-weight: 700;
+  letter-spacing: 0.4px;
+  color: #7a7265;
+  text-align: center;
+}
+.col-key.key-active[_ngcontent-%COMP%] {
+  color: #1a1510;
+  font-weight: 700;
+}
+@keyframes _ngcontent-%COMP%_spin {
+  to {
+    transform: rotate(360deg);
+  }
+}
+@keyframes _ngcontent-%COMP%_pulse {
+  0%, 100% {
+    opacity: 1;
+  }
+  50% {
+    opacity: 0.22;
+  }
+}
+@keyframes _ngcontent-%COMP%_shimmer {
+  to {
+    background-position: -200% 0;
+  }
+}
+@keyframes _ngcontent-%COMP%_shimmerGold {
+  0%, 100% {
+    background-position: 0% 0;
+  }
+  50% {
+    background-position: 100% 0;
+  }
+}
+@keyframes _ngcontent-%COMP%_fadeUp {
+  from {
+    opacity: 0;
+    transform: translateY(9px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+@keyframes _ngcontent-%COMP%_progressRun {
+  0% {
+    width: 0%;
+  }
+  20% {
+    width: 36%;
+  }
+  50% {
+    width: 62%;
+  }
+  80% {
+    width: 82%;
+  }
+  100% {
+    width: 91%;
+  }
+}
+@media (max-width: 680px) {
+  .page-body[_ngcontent-%COMP%] {
+    padding: 0 22px 70px;
+  }
+  .site-header[_ngcontent-%COMP%] {
+    padding: 0 22px;
+  }
+  .hero-title[_ngcontent-%COMP%] {
+    font-size: 52px;
+  }
+  .vd-label[_ngcontent-%COMP%] {
+    font-size: 46px;
+  }
+  .col-track[_ngcontent-%COMP%] {
+    height: 68px;
+  }
+  .col-pct[_ngcontent-%COMP%] {
+    font-size: 9.5px;
+  }
+  .col-key[_ngcontent-%COMP%] {
+    font-size: 8px;
+  }
+  .class-chart[_ngcontent-%COMP%] {
+    gap: 5px;
+  }
+}
+@media (max-width: 440px) {
+  .hero-title[_ngcontent-%COMP%] {
+    font-size: 42px;
+  }
+  .vd-label[_ngcontent-%COMP%] {
+    font-size: 38px;
+  }
+  .hdr-label[_ngcontent-%COMP%] {
+    display: none;
+  }
+  .hdr-sep[_ngcontent-%COMP%] {
+    display: none;
+  }
+}
+/*# sourceMappingURL=home.css.map */`] });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HomeComponent, [{
+    type: Component,
+    args: [{ selector: "app-home", imports: [FormsModule], template: `<div class="page">
+
+  <!-- paper grain overlay -->
+  <div class="grain" aria-hidden="true"></div>
+
+  <!-- \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550 HEADER \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550 -->
+  <header class="site-header">
+
+    <div class="hdr-left">
+      <div class="brand-name">
+        <span class="brand-r">R</span><span class="brand-dash">\u2014</span><span class="brand-word">Checker</span>
+      </div>
+    </div>
+
+    <div class="hdr-right">
+      <span class="hdr-live">
+        <span class="live-dot"></span>
+        {{ getSelectedModel().name }}&nbsp;\xB7&nbsp;actif
+      </span>
+    </div>
+
+  </header>
+
+  <!-- \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550 BODY \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550 -->
+  <div class="page-body">
+
+    <!-- HERO -->
+    <section class="hero">
+      <p class="hero-eyebrow">Analyse s\xE9mantique &nbsp;\xB7&nbsp; Dataset LIAR &nbsp;\xB7&nbsp; 6 classes</p>
+      <h1 class="hero-title">Analysez<br><em>la v\xE9rit\xE9</em></h1>
+    </section>
+
+    <!-- MODEL SWITCHER -->
+    <div class="model-rail">
+      <span class="rail-label">Mod\xE8le actif</span>
+      <div class="rail-pills">
+        @for (m of models; track m.id) {
+          <button class="model-pill"
+                  [class.pill-on]="selectedModel === m.id"
+                  [class.pill-off]="!m.available"
+                  (click)="selectModel(m)">
+            <span class="pill-dot">{{ selectedModel === m.id ? '\u25CF' : '\u25CB' }}</span>
+            <span class="pill-algo">{{ m.algorithm }}</span>
+            <span class="pill-acc">{{ m.accuracy }}</span>
+          </button>
+        }
+      </div>
+    </div>
+
+    <!-- INPUT -->
+    <section class="claim-section">
+      <label class="claim-eyebrow">\u21B3 d\xE9claration \xE0 analyser</label>
+      <textarea
+        class="claim-field"
+        [(ngModel)]="claim"
+        (input)="onClaimChange()"
+        (keydown.ctrl.enter)="predict()"
+        placeholder="Saisissez une d\xE9claration politique, m\xE9diatique ou factuelle\u2026"
+        rows="4"
+        [attr.maxlength]="maxChars">
+      </textarea>
+      <div class="claim-bar">
+        <span class="claim-count" [class.warn]="charCount > maxChars * 0.8">{{ charCount }}/{{ maxChars }}</span>
+        <div class="claim-actions">
+          <button class="act-clear" (click)="clearForm()" [disabled]="!claim && !result">effacer</button>
+          <button class="act-submit" (click)="predict()" [disabled]="!claim.trim() || loading">
+            @if (!loading) {
+              analyser &nbsp;&rarr;
+            } @else {
+              <svg class="spin-icon" width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5">
+                <path d="M12 2a10 10 0 0 1 10 10"/>
+              </svg>
+              en cours\u2026
+            }
+          </button>
+        </div>
+      </div>
+    </section>
+
+    <!-- DIVIDER with progress -->
+    <div class="divider">
+      <div class="divider-fill" [class.running]="loading"></div>
+    </div>
+
+    <!-- RESULTS -->
+    <section class="result-section">
+
+      <!-- skeleton -->
+      @if (loading) {
+        <div class="skel-wrap">
+          <div class="skel skel-title"></div>
+          <div class="skel skel-rule"></div>
+          <div class="skel-chart-row">
+            <div class="skel skel-col" style="height:85%"></div>
+            <div class="skel skel-col" style="height:55%"></div>
+            <div class="skel skel-col" style="height:38%"></div>
+            <div class="skel skel-col" style="height:22%"></div>
+            <div class="skel skel-col" style="height:12%"></div>
+            <div class="skel skel-col" style="height:7%"></div>
+          </div>
+        </div>
+      }
+
+      <!-- error -->
+      @if (error && !loading) {
+        <div class="error-wrap">
+          <span class="error-x">\xD7</span>
+          <div>
+            <strong>Backend inaccessible</strong>
+            <p>{{ error }}</p>
+          </div>
+        </div>
+      }
+
+      <!-- verdict -->
+      @if (verdict && !loading) {
+        <div class="verdict-wrap">
+
+          <!-- Big verdict label -->
+          <div [class]="getVerdictClass()">
+            <div class="vd-confidence">{{ topProbability }}<span class="pct">%</span></div>
+            <div class="vd-label">{{ verdict.label }}</div>
+            <div class="vd-desc">{{ verdict.desc }}</div>
+            <div class="vd-meta">
+              {{ getSelectedModel().algorithm }} + {{ getSelectedModel().vectorizer }}
+              &nbsp;&middot;&nbsp; sortie&nbsp;:&nbsp;<code>{{ result }}</code>
+            </div>
+          </div>
+
+          <!-- 6-class vertical bar chart -->
+          <div class="class-chart">
+            @for (cls of classBreakdown; track cls.key; let i = $index) {
+              <div class="chart-col" [class.col-active]="cls.key === result" [style.--delay]="(i * 80) + 'ms'">
+                <div class="col-pct" [class.pct-active]="cls.key === result">
+                  {{ cls.probability }}<span class="pct-s">%</span>
+                </div>
+                <div class="col-track">
+                  <div [class]="'col-bar bar-' + cls.color"
+                       [style.height]="animate ? cls.probability + '%' : '0%'">
+                  </div>
+                </div>
+                <div class="col-key" [class.key-active]="cls.key === result">{{ cls.shortLabel }}</div>
+              </div>
+            }
+          </div>
+
+        </div>
+      }
+
+      <!-- empty -->
+      @if (!verdict && !loading && !error) {
+        <div class="empty-wrap">
+          <p class="empty-italic">Aucune d\xE9claration analys\xE9e.</p>
+          <p class="empty-hint">Saisissez un texte ci-dessus et appuyez sur <em>analyser</em>.</p>
+        </div>
+      }
+
+    </section>
+
+  </div>
+</div>
+`, styles: [`/* src/app/pages/home/home.css */
+:host {
+  display: block;
+  min-height: 100vh;
+}
+* {
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+}
+.page {
+  min-height: 100vh;
+  background:
+    radial-gradient(
+      ellipse 140% 100% at 50% 0%,
+      #f8f4ec 0%,
+      #eee8da 100%);
+  font-family:
+    "Barlow",
+    -apple-system,
+    sans-serif;
+  color: #1a1510;
+  position: relative;
+}
+.grain {
+  position: fixed;
+  inset: 0;
+  pointer-events: none;
+  z-index: 900;
+  opacity: 0.035;
+  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='300' height='300'%3E%3Cfilter id='n'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='0.72' numOctaves='4' stitchTiles='stitch'/%3E%3C/filter%3E%3Crect width='300' height='300' filter='url(%23n)'/%3E%3C/svg%3E");
+  background-size: 280px;
+}
+.site-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 0 48px;
+  height: 60px;
+  border-bottom: 1px solid rgba(0, 0, 0, 0.1);
+  position: sticky;
+  top: 0;
+  background: rgba(248, 244, 236, 0.88);
+  backdrop-filter: blur(12px);
+  -webkit-backdrop-filter: blur(12px);
+  z-index: 50;
+}
+.hdr-left {
+  display: flex;
+  align-items: center;
+}
+.brand-name {
+  display: flex;
+  align-items: baseline;
+  line-height: 1;
+  -webkit-user-select: none;
+  user-select: none;
+}
+.brand-r {
+  font-family:
+    "Cormorant Garamond",
+    Georgia,
+    serif;
+  font-size: 30px;
+  font-weight: 700;
+  font-style: italic;
+  color: #c8952a;
+  line-height: 1;
+  letter-spacing: -0.5px;
+}
+.brand-dash {
+  font-family: "Barlow", sans-serif;
+  font-size: 15px;
+  font-weight: 300;
+  color: rgba(26, 21, 16, 0.22);
+  margin: 0 3px 0 2px;
+  align-self: center;
+}
+.brand-word {
+  font-family: "Barlow", sans-serif;
+  font-size: 12.5px;
+  font-weight: 700;
+  letter-spacing: 3.5px;
+  text-transform: uppercase;
+  color: #1a1510;
+  align-self: center;
+}
+.hdr-right {
+  display: flex;
+  align-items: center;
+}
+.hdr-live {
+  display: flex;
+  align-items: center;
+  gap: 7px;
+  font-family: "Fira Code", monospace;
+  font-size: 11px;
+  font-weight: 500;
+  color: #3a5044;
+  letter-spacing: 0.2px;
+}
+.live-dot {
+  width: 6px;
+  height: 6px;
+  background: #3a9460;
+  border-radius: 50%;
+  animation: pulse 2.5s ease-in-out infinite;
+}
+.page-body {
+  max-width: 780px;
+  margin: 0 auto;
+  padding: 0 48px 100px;
+}
+.hero {
+  padding: 58px 0 28px;
+}
+.hero-eyebrow {
+  font-size: 10.5px;
+  font-weight: 600;
+  letter-spacing: 2px;
+  text-transform: uppercase;
+  color: #7a7265;
+  margin-bottom: 18px;
+}
+.hero-title {
+  font-family:
+    "Cormorant Garamond",
+    Georgia,
+    serif;
+  font-size: 72px;
+  font-weight: 600;
+  line-height: 0.92;
+  letter-spacing: -1.5px;
+  color: #1a1510;
+}
+.hero-title em {
+  font-style: italic;
+  color: #c8952a;
+  font-weight: 500;
+}
+.model-rail {
+  display: flex;
+  align-items: center;
+  gap: 18px;
+  padding: 22px 0;
+  border-top: 1px solid rgba(0, 0, 0, 0.09);
+  border-bottom: 1px solid rgba(0, 0, 0, 0.09);
+  margin-bottom: 36px;
+  flex-wrap: wrap;
+}
+.rail-label {
+  font-size: 9.5px;
+  font-weight: 700;
+  letter-spacing: 1.8px;
+  text-transform: uppercase;
+  color: #6a6255;
+  flex-shrink: 0;
+}
+.rail-pills {
+  display: flex;
+  gap: 6px;
+  flex-wrap: wrap;
+}
+.model-pill {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 7px 15px;
+  background: transparent;
+  border: 1.5px solid rgba(0, 0, 0, 0.16);
+  border-radius: 28px;
+  font-family: "Barlow", sans-serif;
+  font-size: 12px;
+  font-weight: 600;
+  color: #5a5448;
+  cursor: default;
+  transition: all 0.17s;
+  letter-spacing: 0.2px;
+}
+.model-pill.pill-on {
+  background: #1a1510;
+  border-color: #1a1510;
+  color: #f5f0e5;
+  cursor: pointer;
+  box-shadow: 0 2px 10px rgba(0, 0, 0, 0.18);
+}
+.model-pill.pill-off {
+  opacity: 0.35;
+}
+.model-pill:not(.pill-on):not(.pill-off) {
+  cursor: pointer;
+}
+.model-pill:not(.pill-on):not(.pill-off):hover {
+  border-color: rgba(0, 0, 0, 0.28);
+  color: #1a1510;
+}
+.pill-dot {
+  font-size: 9.5px;
+  line-height: 1;
+  opacity: 0.8;
+}
+.pill-algo {
+  font-family: "Fira Code", monospace;
+  font-size: 11px;
+}
+.pill-acc {
+  font-size: 11px;
+  color: #8a8070;
+}
+.claim-section {
+  margin-bottom: 28px;
+}
+.claim-eyebrow {
+  display: block;
+  font-size: 9.5px;
+  font-weight: 700;
+  letter-spacing: 1.8px;
+  text-transform: uppercase;
+  color: #6a6255;
+  margin-bottom: 14px;
+}
+.claim-field {
+  display: block;
+  width: 100%;
+  background: transparent;
+  border: none;
+  border-bottom: 2px solid rgba(0, 0, 0, 0.14);
+  padding: 10px 0 14px;
+  font-family: "Barlow", sans-serif;
+  font-size: 16px;
+  line-height: 1.68;
+  color: #1a1510;
+  resize: none;
+  outline: none;
+  transition: border-color 0.2s;
+}
+.claim-field:focus {
+  border-bottom-color: #c8952a;
+}
+.claim-field::placeholder {
+  color: #ccc4b4;
+  font-style: italic;
+  font-size: 15.5px;
+}
+.claim-bar {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding-top: 10px;
+}
+.claim-count {
+  font-family: "Fira Code", monospace;
+  font-size: 11px;
+  color: #8a8275;
+}
+.claim-count.warn {
+  color: #c8952a;
+  font-weight: 600;
+}
+.claim-actions {
+  display: flex;
+  align-items: center;
+  gap: 16px;
+}
+.act-clear {
+  background: none;
+  border: none;
+  font-family: "Barlow", sans-serif;
+  font-size: 12.5px;
+  font-weight: 600;
+  color: #8a8275;
+  cursor: pointer;
+  letter-spacing: 0.3px;
+  transition: color 0.15s;
+  padding: 6px 0;
+}
+.act-clear:hover:not(:disabled) {
+  color: #1a1510;
+}
+.act-clear:disabled {
+  opacity: 0.28;
+  cursor: not-allowed;
+}
+.act-submit {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 10px 26px;
+  background: #1a1510;
+  color: #f5f0e5;
+  border: none;
+  border-radius: 3px;
+  font-family: "Barlow", sans-serif;
+  font-size: 13px;
+  font-weight: 700;
+  cursor: pointer;
+  letter-spacing: 0.6px;
+  transition:
+    background 0.15s,
+    transform 0.12s,
+    box-shadow 0.15s;
+}
+.act-submit:hover:not(:disabled) {
+  background: #2e2820;
+  box-shadow: 0 4px 18px rgba(0, 0, 0, 0.22);
+  transform: translateY(-1px);
+}
+.act-submit:active:not(:disabled) {
+  transform: translateY(0);
+  box-shadow: none;
+}
+.act-submit:disabled {
+  opacity: 0.3;
+  cursor: not-allowed;
+}
+.spin-icon {
+  animation: spin 0.72s linear infinite;
+}
+.divider {
+  height: 2px;
+  background: rgba(0, 0, 0, 0.1);
+  margin-bottom: 40px;
+  position: relative;
+  overflow: hidden;
+  border-radius: 1px;
+}
+.divider-fill {
+  position: absolute;
+  left: 0;
+  top: 0;
+  bottom: 0;
+  width: 0;
+  background:
+    linear-gradient(
+      90deg,
+      #c8952a 0%,
+      #e8b840 50%,
+      #c8952a 100%);
+  background-size: 200% 100%;
+}
+.divider-fill.running {
+  animation: progressRun 14s cubic-bezier(0.1, 0.9, 0.2, 1) forwards, shimmerGold 1.6s linear infinite;
+}
+.result-section {
+  min-height: 160px;
+}
+.empty-wrap {
+  padding: 32px 0 20px;
+}
+.empty-italic {
+  font-family:
+    "Cormorant Garamond",
+    Georgia,
+    serif;
+  font-size: 26px;
+  font-style: italic;
+  font-weight: 500;
+  color: #9a9285;
+  margin-bottom: 8px;
+}
+.empty-hint {
+  font-size: 12.5px;
+  color: #8a8275;
+}
+.empty-hint em {
+  font-style: normal;
+  font-weight: 700;
+  color: #6a6255;
+}
+.skel-wrap {
+  display: flex;
+  flex-direction: column;
+  gap: 18px;
+  animation: fadeUp 0.22s ease;
+}
+.skel {
+  background:
+    linear-gradient(
+      90deg,
+      #e8e2d8 25%,
+      #ddd8cc 50%,
+      #e8e2d8 75%);
+  background-size: 200% 100%;
+  border-radius: 3px;
+  animation: shimmer 1.4s infinite;
+}
+.skel-title {
+  height: 58px;
+  width: 55%;
+}
+.skel-rule {
+  height: 2px;
+  width: 100%;
+  border-radius: 0;
+}
+.skel-chart-row {
+  display: flex;
+  gap: 10px;
+  align-items: flex-end;
+  height: 88px;
+}
+.skel-col {
+  flex: 1;
+  border-radius: 2px;
+}
+.error-wrap {
+  display: flex;
+  align-items: flex-start;
+  gap: 16px;
+  padding: 20px 0;
+  border-top: 2.5px solid #b83020;
+  animation: fadeUp 0.2s ease;
+}
+.error-x {
+  font-family: "Cormorant Garamond", serif;
+  font-size: 38px;
+  line-height: 1;
+  color: #b83020;
+  font-weight: 700;
+  flex-shrink: 0;
+  margin-top: -4px;
+}
+.error-wrap div strong {
+  font-size: 13.5px;
+  font-weight: 700;
+  color: #b83020;
+  display: block;
+  margin-bottom: 4px;
+}
+.error-wrap div p {
+  font-size: 12.5px;
+  color: #9a2810;
+  line-height: 1.55;
+}
+.verdict-wrap {
+  display: flex;
+  flex-direction: column;
+  gap: 36px;
+  animation: fadeUp 0.28s cubic-bezier(0.34, 1.56, 0.64, 1);
+}
+.verdict-display {
+  padding: 24px 0 20px;
+  border-top: 2.5px solid currentColor;
+}
+.vd-confidence {
+  font-family: "Fira Code", monospace;
+  font-size: 13px;
+  font-weight: 600;
+  color: #6a6255;
+  margin-bottom: 4px;
+  letter-spacing: 0.5px;
+}
+.pct {
+  font-size: 10px;
+  opacity: 0.8;
+}
+.vd-label {
+  font-family:
+    "Cormorant Garamond",
+    Georgia,
+    serif;
+  font-size: 64px;
+  font-weight: 700;
+  line-height: 1;
+  letter-spacing: -1px;
+  margin-bottom: 16px;
+  text-transform: capitalize;
+}
+.vd-desc {
+  font-size: 15px;
+  line-height: 1.7;
+  color: #6a6050;
+  margin-bottom: 12px;
+  max-width: 500px;
+}
+.vd-meta {
+  font-family: "Fira Code", monospace;
+  font-size: 10.5px;
+  color: #7a7265;
+  letter-spacing: 0.3px;
+}
+.vd-meta code {
+  background: rgba(0, 0, 0, 0.07);
+  padding: 1px 5px;
+  border-radius: 3px;
+}
+.vd-green {
+  color: #0c6030;
+  border-color: rgba(12, 96, 48, 0.45);
+}
+.vd-lime {
+  color: #28783c;
+  border-color: rgba(40, 120, 60, 0.40);
+}
+.vd-yellow {
+  color: #8a6600;
+  border-color: rgba(138, 102, 0, 0.42);
+}
+.vd-orange {
+  color: #8a4600;
+  border-color: rgba(138, 70, 0, 0.42);
+}
+.vd-red {
+  color: #8a1e10;
+  border-color: rgba(138, 30, 16, 0.42);
+}
+.vd-crimson {
+  color: #6a0818;
+  border-color: rgba(106, 8, 24, 0.42);
+}
+.class-chart {
+  display: flex;
+  gap: 8px;
+}
+.chart-col {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 8px;
+}
+.col-pct {
+  font-family: "Fira Code", monospace;
+  font-size: 10.5px;
+  color: #7a7265;
+  font-weight: 600;
+  line-height: 1;
+}
+.col-pct.pct-active {
+  color: #1a1510;
+  font-weight: 700;
+}
+.pct-s {
+  font-size: 8.5px;
+  opacity: 0.7;
+}
+.col-track {
+  width: 100%;
+  height: 88px;
+  display: flex;
+  align-items: flex-end;
+  background: rgba(0, 0, 0, 0.05);
+  border-radius: 3px;
+  overflow: hidden;
+}
+.chart-col.col-active .col-track {
+  background: rgba(0, 0, 0, 0.08);
+}
+.col-bar {
+  width: 100%;
+  border-radius: 2px 2px 0 0;
+  min-height: 0;
+  transition: height 0.78s cubic-bezier(0.4, 0, 0.2, 1);
+  transition-delay: var(--delay, 0ms);
+}
+.bar-green {
+  background:
+    linear-gradient(
+      180deg,
+      #3aaa72 0%,
+      #1e8850 100%);
+}
+.bar-lime {
+  background:
+    linear-gradient(
+      180deg,
+      #50b868 0%,
+      #389050 100%);
+}
+.bar-yellow {
+  background:
+    linear-gradient(
+      180deg,
+      #d0aa22 0%,
+      #b09012 100%);
+}
+.bar-orange {
+  background:
+    linear-gradient(
+      180deg,
+      #d09232 0%,
+      #b07018 100%);
+}
+.bar-red {
+  background:
+    linear-gradient(
+      180deg,
+      #e06052 0%,
+      #c04035 100%);
+}
+.bar-crimson {
+  background:
+    linear-gradient(
+      180deg,
+      #c03058 0%,
+      #a01838 100%);
+}
+.col-key {
+  font-family: "Fira Code", monospace;
+  font-size: 9px;
+  font-weight: 700;
+  letter-spacing: 0.4px;
+  color: #7a7265;
+  text-align: center;
+}
+.col-key.key-active {
+  color: #1a1510;
+  font-weight: 700;
+}
+@keyframes spin {
+  to {
+    transform: rotate(360deg);
+  }
+}
+@keyframes pulse {
+  0%, 100% {
+    opacity: 1;
+  }
+  50% {
+    opacity: 0.22;
+  }
+}
+@keyframes shimmer {
+  to {
+    background-position: -200% 0;
+  }
+}
+@keyframes shimmerGold {
+  0%, 100% {
+    background-position: 0% 0;
+  }
+  50% {
+    background-position: 100% 0;
+  }
+}
+@keyframes fadeUp {
+  from {
+    opacity: 0;
+    transform: translateY(9px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+@keyframes progressRun {
+  0% {
+    width: 0%;
+  }
+  20% {
+    width: 36%;
+  }
+  50% {
+    width: 62%;
+  }
+  80% {
+    width: 82%;
+  }
+  100% {
+    width: 91%;
+  }
+}
+@media (max-width: 680px) {
+  .page-body {
+    padding: 0 22px 70px;
+  }
+  .site-header {
+    padding: 0 22px;
+  }
+  .hero-title {
+    font-size: 52px;
+  }
+  .vd-label {
+    font-size: 46px;
+  }
+  .col-track {
+    height: 68px;
+  }
+  .col-pct {
+    font-size: 9.5px;
+  }
+  .col-key {
+    font-size: 8px;
+  }
+  .class-chart {
+    gap: 5px;
+  }
+}
+@media (max-width: 440px) {
+  .hero-title {
+    font-size: 42px;
+  }
+  .vd-label {
+    font-size: 38px;
+  }
+  .hdr-label {
+    display: none;
+  }
+  .hdr-sep {
+    display: none;
+  }
+}
+/*# sourceMappingURL=home.css.map */
+`] }]
+  }], () => [{ type: PredictionService }, { type: ChangeDetectorRef }], null);
+})();
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && \u0275setClassDebugInfo(HomeComponent, { className: "HomeComponent", filePath: "app/pages/home/home.ts", lineNumber: 47 });
+})();
+
+// src/app/app.routes.ts
+var routes = [
+  {
+    path: "",
+    component: HomeComponent
+  }
+];
+
+// src/app/app.config.ts
+var appConfig = {
+  providers: [
+    provideBrowserGlobalErrorListeners(),
+    provideRouter(routes),
+    provideHttpClient()
+  ]
+};
+
+// src/app/app.ts
+var App = class _App {
+  static \u0275fac = function App_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _App)();
+  };
+  static \u0275cmp = /* @__PURE__ */ \u0275\u0275defineComponent({ type: _App, selectors: [["app-root"]], decls: 1, vars: 0, template: function App_Template(rf, ctx) {
+    if (rf & 1) {
+      \u0275\u0275element(0, "router-outlet");
+    }
+  }, dependencies: [RouterOutlet], encapsulation: 2 });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(App, [{
+    type: Component,
+    args: [{ selector: "app-root", imports: [RouterOutlet], template: "<router-outlet></router-outlet>\r\n" }]
+  }], null, null);
+})();
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && \u0275setClassDebugInfo(App, { className: "App", filePath: "app/app.ts", lineNumber: 10 });
+})();
+
+// src/main.ts
+bootstrapApplication(App, appConfig).catch((err) => console.error(err));
+//# sourceMappingURL=main.js.map
+