@everymatrix/stage-dm-input-text 1.0.0 → 1.0.16

package/{chunk-ONYTYTRU.js → chunk-66ZMWCER.js}

@@ -7112,28 +7112,28 @@ var AfterRenderImpl = class _AfterRenderImpl {
   execute() {
     this.executing = true;
     for (const phase of AFTER_RENDER_PHASES) {
-      for (const sequence of this.sequences) {
-        if (sequence.erroredOrDestroyed || !sequence.hooks[phase]) {
+      for (const sequence2 of this.sequences) {
+        if (sequence2.erroredOrDestroyed || !sequence2.hooks[phase]) {
           continue;
         }
         try {
-          sequence.pipelinedValue = this.ngZone.runOutsideAngular(() => this.maybeTrace(() => sequence.hooks[phase](sequence.pipelinedValue), sequence.snapshot));
+          sequence2.pipelinedValue = this.ngZone.runOutsideAngular(() => this.maybeTrace(() => sequence2.hooks[phase](sequence2.pipelinedValue), sequence2.snapshot));
         } catch (err) {
-          sequence.erroredOrDestroyed = true;
+          sequence2.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 sequence2 of this.sequences) {
+      sequence2.afterRun();
+      if (sequence2.once) {
+        this.sequences.delete(sequence2);
+        sequence2.destroy();
       }
     }
-    for (const sequence of this.deferredRegistrations) {
-      this.sequences.add(sequence);
+    for (const sequence2 of this.deferredRegistrations) {
+      this.sequences.add(sequence2);
     }
     if (this.deferredRegistrations.size > 0) {
       this.scheduler.notify(
@@ -7143,25 +7143,25 @@ var AfterRenderImpl = class _AfterRenderImpl {
     }
     this.deferredRegistrations.clear();
   }
-  register(sequence) {
+  register(sequence2) {
     if (!this.executing) {
-      this.sequences.add(sequence);
+      this.sequences.add(sequence2);
       this.scheduler.notify(
         7
         /* NotificationSource.RenderHook */
       );
     } else {
-      this.deferredRegistrations.add(sequence);
+      this.deferredRegistrations.add(sequence2);
     }
   }
-  unregister(sequence) {
-    if (this.executing && this.sequences.has(sequence)) {
-      sequence.erroredOrDestroyed = true;
-      sequence.pipelinedValue = void 0;
-      sequence.once = true;
+  unregister(sequence2) {
+    if (this.executing && this.sequences.has(sequence2)) {
+      sequence2.erroredOrDestroyed = true;
+      sequence2.pipelinedValue = void 0;
+      sequence2.once = true;
     } else {
-      this.sequences.delete(sequence);
-      this.deferredRegistrations.delete(sequence);
+      this.sequences.delete(sequence2);
+      this.deferredRegistrations.delete(sequence2);
     }
   }
   maybeTrace(fn, snapshot) {
@@ -7243,9 +7243,9 @@ function afterRenderImpl(callbackOrSpec, injector, options, once) {
   });
   const hooks = options?.phase ?? AfterRenderPhase.MixedReadWrite;
   const destroyRef = options?.manualCleanup !== true ? injector.get(DestroyRef) : null;
-  const sequence = new AfterRenderSequence(manager.impl, getHooks(callbackOrSpec, hooks), once, destroyRef, tracing?.snapshot(null));
-  manager.impl.register(sequence);
-  return sequence;
+  const sequence2 = new AfterRenderSequence(manager.impl, getHooks(callbackOrSpec, hooks), once, destroyRef, tracing?.snapshot(null));
+  manager.impl.register(sequence2);
+  return sequence2;
 }
 var DeferDependenciesLoadingState;
 (function(DeferDependenciesLoadingState2) {
@@ -7402,13 +7402,13 @@ var DeferEventEntry = class {
     }
   };
 };
-function onInteraction(trigger, callback) {
-  let entry = interactionTriggers.get(trigger);
+function onInteraction(trigger2, callback) {
+  let entry = interactionTriggers.get(trigger2);
   if (!entry) {
     entry = new DeferEventEntry();
-    interactionTriggers.set(trigger, entry);
+    interactionTriggers.set(trigger2, entry);
     for (const name of interactionEventNames) {
-      trigger.addEventListener(name, entry.listener, eventListenerOptions);
+      trigger2.addEventListener(name, entry.listener, eventListenerOptions);
     }
   }
   entry.callbacks.add(callback);
@@ -7419,20 +7419,20 @@ function onInteraction(trigger, callback) {
     } = entry;
     callbacks.delete(callback);
     if (callbacks.size === 0) {
-      interactionTriggers.delete(trigger);
+      interactionTriggers.delete(trigger2);
       for (const name of interactionEventNames) {
-        trigger.removeEventListener(name, listener, eventListenerOptions);
+        trigger2.removeEventListener(name, listener, eventListenerOptions);
       }
     }
   };
 }
-function onHover(trigger, callback) {
-  let entry = hoverTriggers.get(trigger);
+function onHover(trigger2, callback) {
+  let entry = hoverTriggers.get(trigger2);
   if (!entry) {
     entry = new DeferEventEntry();
-    hoverTriggers.set(trigger, entry);
+    hoverTriggers.set(trigger2, entry);
     for (const name of hoverEventNames) {
-      trigger.addEventListener(name, entry.listener, eventListenerOptions);
+      trigger2.addEventListener(name, entry.listener, eventListenerOptions);
     }
   }
   entry.callbacks.add(callback);
@@ -7444,15 +7444,15 @@ function onHover(trigger, callback) {
     callbacks.delete(callback);
     if (callbacks.size === 0) {
       for (const name of hoverEventNames) {
-        trigger.removeEventListener(name, listener, eventListenerOptions);
+        trigger2.removeEventListener(name, listener, eventListenerOptions);
       }
-      hoverTriggers.delete(trigger);
+      hoverTriggers.delete(trigger2);
     }
   };
 }
-function onViewport(trigger, callback, injector) {
+function onViewport(trigger2, callback, injector) {
   const ngZone = injector.get(NgZone);
-  let entry = viewportTriggers.get(trigger);
+  let entry = viewportTriggers.get(trigger2);
   intersectionObserver = intersectionObserver || ngZone.runOutsideAngular(() => {
     return new IntersectionObserver((entries) => {
       for (const current of entries) {
@@ -7464,19 +7464,19 @@ function onViewport(trigger, callback, injector) {
   });
   if (!entry) {
     entry = new DeferEventEntry();
-    ngZone.runOutsideAngular(() => intersectionObserver.observe(trigger));
-    viewportTriggers.set(trigger, entry);
+    ngZone.runOutsideAngular(() => intersectionObserver.observe(trigger2));
+    viewportTriggers.set(trigger2, entry);
     observedViewportElements++;
   }
   entry.callbacks.add(callback);
   return () => {
-    if (!viewportTriggers.has(trigger)) {
+    if (!viewportTriggers.has(trigger2)) {
       return;
     }
     entry.callbacks.delete(callback);
     if (entry.callbacks.size === 0) {
-      intersectionObserver?.unobserve(trigger);
-      viewportTriggers.delete(trigger);
+      intersectionObserver?.unobserve(trigger2);
+      viewportTriggers.delete(trigger2);
       observedViewportElements--;
     }
     if (observedViewportElements === 0) {
@@ -11734,9 +11734,9 @@ function computeStaticStyling(tNode, attrs, writeToHost) {
       } else if (mode == 1) {
         classes = concatStringsWithSpace(classes, value);
       } else if (mode == 2) {
-        const style = value;
+        const style2 = value;
         const styleValue = attrs[++i];
-        styles = concatStringsWithSpace(styles, style + ": " + styleValue + ";");
+        styles = concatStringsWithSpace(styles, style2 + ": " + styleValue + ";");
       }
     }
   }
@@ -12873,8 +12873,8 @@ function resolveComponentResources(resourceResolver) {
       const styleUrls = component.styleUrls;
       component.styleUrls.forEach((styleUrl, index) => {
         styles.push("");
-        promises.push(cachedResourceResolve(styleUrl).then((style) => {
-          styles[styleOffset + index] = style;
+        promises.push(cachedResourceResolve(styleUrl).then((style2) => {
+          styles[styleOffset + index] = style2;
           styleUrls.splice(styleUrls.indexOf(styleUrl), 1);
           if (styleUrls.length == 0) {
             component.styleUrls = void 0;
@@ -12882,8 +12882,8 @@ function resolveComponentResources(resourceResolver) {
         }));
       });
     } else if (component.styleUrl) {
-      promises.push(cachedResourceResolve(component.styleUrl).then((style) => {
-        styles.push(style);
+      promises.push(cachedResourceResolve(component.styleUrl).then((style2) => {
+        styles.push(style2);
         component.styleUrl = void 0;
       }));
     }
@@ -15507,7 +15507,7 @@ function scheduleDelayedTrigger(scheduleFn) {
   const cleanupFn = scheduleFn(() => triggerDeferBlock(0, lView, tNode), injector);
   storeTriggerCleanupFn(0, lDetails, cleanupFn);
 }
-function scheduleDelayedPrefetching(scheduleFn, trigger) {
+function scheduleDelayedPrefetching(scheduleFn, trigger2) {
   if (false) return;
   const lView = getLView();
   const injector = lView[INJECTOR];
@@ -27888,6 +27888,461 @@ function booleanOrUrlAttribute(value) {
   return booleanAttribute(value);
 }
 
+// node_modules/@angular/animations/fesm2022/animations.mjs
+var AnimationMetadataType;
+(function(AnimationMetadataType2) {
+  AnimationMetadataType2[AnimationMetadataType2["State"] = 0] = "State";
+  AnimationMetadataType2[AnimationMetadataType2["Transition"] = 1] = "Transition";
+  AnimationMetadataType2[AnimationMetadataType2["Sequence"] = 2] = "Sequence";
+  AnimationMetadataType2[AnimationMetadataType2["Group"] = 3] = "Group";
+  AnimationMetadataType2[AnimationMetadataType2["Animate"] = 4] = "Animate";
+  AnimationMetadataType2[AnimationMetadataType2["Keyframes"] = 5] = "Keyframes";
+  AnimationMetadataType2[AnimationMetadataType2["Style"] = 6] = "Style";
+  AnimationMetadataType2[AnimationMetadataType2["Trigger"] = 7] = "Trigger";
+  AnimationMetadataType2[AnimationMetadataType2["Reference"] = 8] = "Reference";
+  AnimationMetadataType2[AnimationMetadataType2["AnimateChild"] = 9] = "AnimateChild";
+  AnimationMetadataType2[AnimationMetadataType2["AnimateRef"] = 10] = "AnimateRef";
+  AnimationMetadataType2[AnimationMetadataType2["Query"] = 11] = "Query";
+  AnimationMetadataType2[AnimationMetadataType2["Stagger"] = 12] = "Stagger";
+})(AnimationMetadataType || (AnimationMetadataType = {}));
+var AUTO_STYLE = "*";
+function trigger(name, definitions) {
+  return {
+    type: AnimationMetadataType.Trigger,
+    name,
+    definitions,
+    options: {}
+  };
+}
+function animate(timings, styles = null) {
+  return {
+    type: AnimationMetadataType.Animate,
+    styles,
+    timings
+  };
+}
+function sequence(steps, options = null) {
+  return {
+    type: AnimationMetadataType.Sequence,
+    steps,
+    options
+  };
+}
+function style(tokens) {
+  return {
+    type: AnimationMetadataType.Style,
+    styles: tokens,
+    offset: null
+  };
+}
+function transition(stateChangeExpr, steps, options = null) {
+  return {
+    type: AnimationMetadataType.Transition,
+    expr: stateChangeExpr,
+    animation: steps,
+    options
+  };
+}
+function animation(steps, options = null) {
+  return {
+    type: AnimationMetadataType.Reference,
+    animation: steps,
+    options
+  };
+}
+function useAnimation(animation2, options = null) {
+  return {
+    type: AnimationMetadataType.AnimateRef,
+    animation: animation2,
+    options
+  };
+}
+var AnimationBuilder = class _AnimationBuilder {
+  static \u0275fac = function AnimationBuilder_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _AnimationBuilder)();
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _AnimationBuilder,
+    factory: () => (() => inject(BrowserAnimationBuilder))(),
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(AnimationBuilder, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root",
+      useFactory: () => inject(BrowserAnimationBuilder)
+    }]
+  }], null, null);
+})();
+var AnimationFactory = class {
+};
+var BrowserAnimationBuilder = class _BrowserAnimationBuilder extends AnimationBuilder {
+  animationModuleType = inject(ANIMATION_MODULE_TYPE, {
+    optional: true
+  });
+  _nextAnimationId = 0;
+  _renderer;
+  constructor(rootRenderer, doc) {
+    super();
+    const typeData = {
+      id: "0",
+      encapsulation: ViewEncapsulation.None,
+      styles: [],
+      data: {
+        animation: []
+      }
+    };
+    this._renderer = rootRenderer.createRenderer(doc.body, typeData);
+    if (this.animationModuleType === null && !isAnimationRenderer(this._renderer)) {
+      throw new RuntimeError(3600, (typeof ngDevMode === "undefined" || ngDevMode) && "Angular detected that the `AnimationBuilder` was injected, but animation support was not enabled. Please make sure that you enable animations in your application by calling `provideAnimations()` or `provideAnimationsAsync()` function.");
+    }
+  }
+  build(animation2) {
+    const id = this._nextAnimationId;
+    this._nextAnimationId++;
+    const entry = Array.isArray(animation2) ? sequence(animation2) : animation2;
+    issueAnimationCommand(this._renderer, null, id, "register", [entry]);
+    return new BrowserAnimationFactory(id, this._renderer);
+  }
+  static \u0275fac = function BrowserAnimationBuilder_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || _BrowserAnimationBuilder)(\u0275\u0275inject(RendererFactory2), \u0275\u0275inject(DOCUMENT2));
+  };
+  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
+    token: _BrowserAnimationBuilder,
+    factory: _BrowserAnimationBuilder.\u0275fac,
+    providedIn: "root"
+  });
+};
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(BrowserAnimationBuilder, [{
+    type: Injectable,
+    args: [{
+      providedIn: "root"
+    }]
+  }], () => [{
+    type: RendererFactory2
+  }, {
+    type: Document,
+    decorators: [{
+      type: Inject,
+      args: [DOCUMENT2]
+    }]
+  }], null);
+})();
+var BrowserAnimationFactory = class extends AnimationFactory {
+  _id;
+  _renderer;
+  constructor(_id, _renderer) {
+    super();
+    this._id = _id;
+    this._renderer = _renderer;
+  }
+  create(element, options) {
+    return new RendererAnimationPlayer(this._id, element, options || {}, this._renderer);
+  }
+};
+var RendererAnimationPlayer = class {
+  id;
+  element;
+  _renderer;
+  parentPlayer = null;
+  _started = false;
+  constructor(id, element, options, _renderer) {
+    this.id = id;
+    this.element = element;
+    this._renderer = _renderer;
+    this._command("create", options);
+  }
+  _listen(eventName, callback) {
+    return this._renderer.listen(this.element, `@@${this.id}:${eventName}`, callback);
+  }
+  _command(command, ...args) {
+    issueAnimationCommand(this._renderer, this.element, this.id, command, args);
+  }
+  onDone(fn) {
+    this._listen("done", fn);
+  }
+  onStart(fn) {
+    this._listen("start", fn);
+  }
+  onDestroy(fn) {
+    this._listen("destroy", fn);
+  }
+  init() {
+    this._command("init");
+  }
+  hasStarted() {
+    return this._started;
+  }
+  play() {
+    this._command("play");
+    this._started = true;
+  }
+  pause() {
+    this._command("pause");
+  }
+  restart() {
+    this._command("restart");
+  }
+  finish() {
+    this._command("finish");
+  }
+  destroy() {
+    this._command("destroy");
+  }
+  reset() {
+    this._command("reset");
+    this._started = false;
+  }
+  setPosition(p) {
+    this._command("setPosition", p);
+  }
+  getPosition() {
+    return unwrapAnimationRenderer(this._renderer)?.engine?.players[this.id]?.getPosition() ?? 0;
+  }
+  totalTime = 0;
+};
+function issueAnimationCommand(renderer, element, id, command, args) {
+  renderer.setProperty(element, `@@${id}:${command}`, args);
+}
+function unwrapAnimationRenderer(renderer) {
+  const type = renderer.\u0275type;
+  if (type === 0) {
+    return renderer;
+  } else if (type === 1) {
+    return renderer.animationRenderer;
+  }
+  return null;
+}
+function isAnimationRenderer(renderer) {
+  const type = renderer.\u0275type;
+  return type === 0 || type === 1;
+}
+var NoopAnimationPlayer = class {
+  _onDoneFns = [];
+  _onStartFns = [];
+  _onDestroyFns = [];
+  _originalOnDoneFns = [];
+  _originalOnStartFns = [];
+  _started = false;
+  _destroyed = false;
+  _finished = false;
+  _position = 0;
+  parentPlayer = null;
+  totalTime;
+  constructor(duration = 0, delay = 0) {
+    this.totalTime = duration + delay;
+  }
+  _onFinish() {
+    if (!this._finished) {
+      this._finished = true;
+      this._onDoneFns.forEach((fn) => fn());
+      this._onDoneFns = [];
+    }
+  }
+  onStart(fn) {
+    this._originalOnStartFns.push(fn);
+    this._onStartFns.push(fn);
+  }
+  onDone(fn) {
+    this._originalOnDoneFns.push(fn);
+    this._onDoneFns.push(fn);
+  }
+  onDestroy(fn) {
+    this._onDestroyFns.push(fn);
+  }
+  hasStarted() {
+    return this._started;
+  }
+  init() {
+  }
+  play() {
+    if (!this.hasStarted()) {
+      this._onStart();
+      this.triggerMicrotask();
+    }
+    this._started = true;
+  }
+  /** @internal */
+  triggerMicrotask() {
+    queueMicrotask(() => this._onFinish());
+  }
+  _onStart() {
+    this._onStartFns.forEach((fn) => fn());
+    this._onStartFns = [];
+  }
+  pause() {
+  }
+  restart() {
+  }
+  finish() {
+    this._onFinish();
+  }
+  destroy() {
+    if (!this._destroyed) {
+      this._destroyed = true;
+      if (!this.hasStarted()) {
+        this._onStart();
+      }
+      this.finish();
+      this._onDestroyFns.forEach((fn) => fn());
+      this._onDestroyFns = [];
+    }
+  }
+  reset() {
+    this._started = false;
+    this._finished = false;
+    this._onStartFns = this._originalOnStartFns;
+    this._onDoneFns = this._originalOnDoneFns;
+  }
+  setPosition(position) {
+    this._position = this.totalTime ? position * this.totalTime : 1;
+  }
+  getPosition() {
+    return this.totalTime ? this._position / this.totalTime : 1;
+  }
+  /** @internal */
+  triggerCallback(phaseName) {
+    const methods = phaseName == "start" ? this._onStartFns : this._onDoneFns;
+    methods.forEach((fn) => fn());
+    methods.length = 0;
+  }
+};
+var AnimationGroupPlayer = class {
+  _onDoneFns = [];
+  _onStartFns = [];
+  _finished = false;
+  _started = false;
+  _destroyed = false;
+  _onDestroyFns = [];
+  parentPlayer = null;
+  totalTime = 0;
+  players;
+  constructor(_players) {
+    this.players = _players;
+    let doneCount = 0;
+    let destroyCount = 0;
+    let startCount = 0;
+    const total = this.players.length;
+    if (total == 0) {
+      queueMicrotask(() => this._onFinish());
+    } else {
+      this.players.forEach((player) => {
+        player.onDone(() => {
+          if (++doneCount == total) {
+            this._onFinish();
+          }
+        });
+        player.onDestroy(() => {
+          if (++destroyCount == total) {
+            this._onDestroy();
+          }
+        });
+        player.onStart(() => {
+          if (++startCount == total) {
+            this._onStart();
+          }
+        });
+      });
+    }
+    this.totalTime = this.players.reduce((time, player) => Math.max(time, player.totalTime), 0);
+  }
+  _onFinish() {
+    if (!this._finished) {
+      this._finished = true;
+      this._onDoneFns.forEach((fn) => fn());
+      this._onDoneFns = [];
+    }
+  }
+  init() {
+    this.players.forEach((player) => player.init());
+  }
+  onStart(fn) {
+    this._onStartFns.push(fn);
+  }
+  _onStart() {
+    if (!this.hasStarted()) {
+      this._started = true;
+      this._onStartFns.forEach((fn) => fn());
+      this._onStartFns = [];
+    }
+  }
+  onDone(fn) {
+    this._onDoneFns.push(fn);
+  }
+  onDestroy(fn) {
+    this._onDestroyFns.push(fn);
+  }
+  hasStarted() {
+    return this._started;
+  }
+  play() {
+    if (!this.parentPlayer) {
+      this.init();
+    }
+    this._onStart();
+    this.players.forEach((player) => player.play());
+  }
+  pause() {
+    this.players.forEach((player) => player.pause());
+  }
+  restart() {
+    this.players.forEach((player) => player.restart());
+  }
+  finish() {
+    this._onFinish();
+    this.players.forEach((player) => player.finish());
+  }
+  destroy() {
+    this._onDestroy();
+  }
+  _onDestroy() {
+    if (!this._destroyed) {
+      this._destroyed = true;
+      this._onFinish();
+      this.players.forEach((player) => player.destroy());
+      this._onDestroyFns.forEach((fn) => fn());
+      this._onDestroyFns = [];
+    }
+  }
+  reset() {
+    this.players.forEach((player) => player.reset());
+    this._destroyed = false;
+    this._finished = false;
+    this._started = false;
+  }
+  setPosition(p) {
+    const timeAtPosition = p * this.totalTime;
+    this.players.forEach((player) => {
+      const position = player.totalTime ? Math.min(1, timeAtPosition / player.totalTime) : 1;
+      player.setPosition(position);
+    });
+  }
+  getPosition() {
+    const longestPlayer = this.players.reduce((longestSoFar, player) => {
+      const newPlayerIsLongest = longestSoFar === null || player.totalTime > longestSoFar.totalTime;
+      return newPlayerIsLongest ? player : longestSoFar;
+    }, null);
+    return longestPlayer != null ? longestPlayer.getPosition() : 0;
+  }
+  beforeDestroy() {
+    this.players.forEach((player) => {
+      if (player.beforeDestroy) {
+        player.beforeDestroy();
+      }
+    });
+  }
+  /** @internal */
+  triggerCallback(phaseName) {
+    const methods = phaseName == "start" ? this._onStartFns : this._onDoneFns;
+    methods.forEach((fn) => fn());
+    methods.length = 0;
+  }
+};
+var \u0275PRE_STYLE = "!";
+
 export {
   __spreadValues,
   __spreadProps,
@@ -27970,6 +28425,7 @@ export {
   _sanitizeUrl,
   _sanitizeHtml,
   SecurityContext,
+  ɵɵsanitizeUrl,
   RendererStyleFlags2,
   ɵɵadvance,
   ɵɵdirectiveInject,
@@ -27979,6 +28435,9 @@ export {
   RendererFactory2,
   Renderer2,
   signal,
+  ContentChildren,
+  ContentChild,
+  ViewChild,
   ɵɵdefineComponent,
   ɵɵdefineNgModule,
   ɵɵdefineDirective,
@@ -27997,27 +28456,46 @@ export {
   ApplicationRef,
   ɵɵattribute,
   ɵɵproperty,
+  ɵɵstyleProp,
   ɵɵclassProp,
+  ɵɵstyleMap,
+  ɵɵclassMap,
   ɵɵconditional,
   ɵɵelementStart,
   ɵɵelementEnd,
   ɵɵelement,
+  ɵɵelementContainerStart,
+  ɵɵelementContainerEnd,
+  ɵɵelementContainer,
   ɵɵgetCurrentView,
   ɵɵlistener,
   ɵɵnextContext,
   ɵɵprojectionDef,
   ɵɵprojection,
+  ɵɵcontentQuery,
+  ɵɵviewQuery,
+  ɵɵqueryRefresh,
+  ɵɵloadQuery,
+  ɵɵreference,
   ɵɵtext,
   ɵɵtextInterpolate,
   ɵɵtextInterpolate1,
+  ɵɵtwoWayProperty,
+  ɵɵtwoWayBindingSet,
+  ɵɵtwoWayListener,
   ɵɵProvidersFeature,
   ɵɵpureFunction0,
   ɵɵpureFunction1,
+  ɵɵpureFunction2,
+  ɵɵpureFunction3,
+  ɵɵpureFunctionV,
+  ɵɵtemplateRefExtractor,
   ɵsetClassDebugInfo,
   Directive,
   Component,
   Input,
   Output,
+  HostBinding,
   HostListener,
   NgModule,
   Version,
@@ -28026,6 +28504,7 @@ export {
   platformCore,
   ApplicationModule,
   booleanAttribute,
+  numberAttribute,
   computed,
   untracked,
   effect,
@@ -28034,11 +28513,28 @@ export {
   DomAdapter,
   DOCUMENT2 as DOCUMENT,
   parseCookieValue,
+  NgClass,
+  NgForOf,
+  NgIf,
   NgStyle,
+  NgTemplateOutlet,
   CommonModule,
   PLATFORM_BROWSER_ID,
+  isPlatformBrowser,
   isPlatformServer,
-  XhrFactory
+  XhrFactory,
+  AnimationMetadataType,
+  AUTO_STYLE,
+  trigger,
+  animate,
+  sequence,
+  style,
+  transition,
+  animation,
+  useAnimation,
+  NoopAnimationPlayer,
+  AnimationGroupPlayer,
+  ɵPRE_STYLE
 };
 /*! Bundled license information:
 
@@ -28116,5 +28612,12 @@ export {
    * (c) 2010-2024 Google LLC. https://angular.io/
    * License: MIT
    *)
+
+@angular/animations/fesm2022/animations.mjs:
+  (**
+   * @license Angular v19.0.7
+   * (c) 2010-2024 Google LLC. https://angular.io/
+   * License: MIT
+   *)
 */
-//# sourceMappingURL=chunk-ONYTYTRU.js.map
+//# sourceMappingURL=chunk-66ZMWCER.js.map