init

node_modules/@angular/animations/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2010-2025 Google LLC. https://angular.dev/license
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

node_modules/@angular/animations/README.md

@@ -0,0 +1,7 @@
+# Angular
+
+The sources for this package are in the main [Angular](https://github.com/angular/angular) repo. Please file issues and pull requests against that repo.
+
+Usage information and reference details can be found in [Angular documentation](https://angular.dev/overview).
+
+License: MIT

node_modules/@angular/animations/animation_driver.d.d.ts

@@ -0,0 +1,69 @@
+/**
+ * @license Angular v20.3.11
+ * (c) 2010-2025 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+
+import * as i0 from '@angular/core';
+import { AnimationPlayer } from './animation_player.d.js';
+
+/**
+ * @publicApi
+ *
+ * @deprecated 20.2 Use `animate.enter` or `animate.leave` instead. Intent to remove in v23
+ *
+ * `AnimationDriver` implentation for Noop animations
+ */
+declare class NoopAnimationDriver implements AnimationDriver {
+    /**
+     * @returns Whether `prop` is a valid CSS property
+     */
+    validateStyleProperty(prop: string): boolean;
+    /**
+     *
+     * @returns Whether elm1 contains elm2.
+     */
+    containsElement(elm1: any, elm2: any): boolean;
+    /**
+     * @returns Rhe parent of the given element or `null` if the element is the `document`
+     */
+    getParentElement(element: unknown): unknown;
+    /**
+     * @returns The result of the query selector on the element. The array will contain up to 1 item
+     *     if `multi` is  `false`.
+     */
+    query(element: any, selector: string, multi: boolean): any[];
+    /**
+     * @returns The `defaultValue` or empty string
+     */
+    computeStyle(element: any, prop: string, defaultValue?: string): string;
+    /**
+     * @returns An `NoopAnimationPlayer`
+     */
+    animate(element: any, keyframes: Array<Map<string, string | number>>, duration: number, delay: number, easing: string, previousPlayers?: any[], scrubberAccessRequested?: boolean): AnimationPlayer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NoopAnimationDriver, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NoopAnimationDriver>;
+}
+/**
+ * @publicApi
+ *
+ * @deprecated 20.2 Use `animate.enter` or `animate.leave` instead. Intent to remove in v23
+ */
+declare abstract class AnimationDriver {
+    /**
+     * @deprecated Use the NoopAnimationDriver class.
+     */
+    static NOOP: AnimationDriver;
+    abstract validateStyleProperty(prop: string): boolean;
+    abstract validateAnimatableStyleProperty?: (prop: string) => boolean;
+    abstract containsElement(elm1: any, elm2: any): boolean;
+    /**
+     * Obtains the parent element, if any. `null` is returned if the element does not have a parent.
+     */
+    abstract getParentElement(element: unknown): unknown;
+    abstract query(element: any, selector: string, multi: boolean): any[];
+    abstract computeStyle(element: any, prop: string, defaultValue?: string): string;
+    abstract animate(element: any, keyframes: Array<Map<string, string | number>>, duration: number, delay: number, easing?: string | null, previousPlayers?: any[], scrubberAccessRequested?: boolean): any;
+}
+
+export { AnimationDriver, NoopAnimationDriver };

node_modules/@angular/animations/browser/index.d.ts

@@ -0,0 +1,275 @@
+/**
+ * @license Angular v20.3.11
+ * (c) 2010-2025 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+
+import { AnimationDriver } from '../animation_driver.d.js';
+export { NoopAnimationDriver } from '../animation_driver.d.js';
+import { AnimationTriggerMetadata, AnimationPlayer, ɵStyleDataMap as _StyleDataMap, AnimationMetadata, AnimationOptions, ɵStyleData as _StyleData } from '../animation_player.d.js';
+import { Renderer2, ɵAnimationRendererType as _AnimationRendererType, RendererStyleFlags2, ListenerOptions, RendererFactory2, NgZone, RendererType2 } from '@angular/core';
+
+declare abstract class AnimationStyleNormalizer {
+    abstract normalizePropertyName(propertyName: string, errors: Error[]): string;
+    abstract normalizeStyleValue(userProvidedProperty: string, normalizedProperty: string, value: string | number, errors: Error[]): string;
+}
+declare class NoopAnimationStyleNormalizer {
+    normalizePropertyName(propertyName: string, errors: Error[]): string;
+    normalizeStyleValue(userProvidedProperty: string, normalizedProperty: string, value: string | number, errors: Error[]): string;
+}
+
+declare class AnimationEngine {
+    private _driver;
+    private _normalizer;
+    private _transitionEngine;
+    private _timelineEngine;
+    private _triggerCache;
+    onRemovalComplete: (element: any, context: any) => void;
+    constructor(doc: Document, _driver: AnimationDriver, _normalizer: AnimationStyleNormalizer);
+    registerTrigger(componentId: string, namespaceId: string, hostElement: any, name: string, metadata: AnimationTriggerMetadata): void;
+    register(namespaceId: string, hostElement: any): void;
+    destroy(namespaceId: string, context: any): void;
+    onInsert(namespaceId: string, element: any, parent: any, insertBefore: boolean): void;
+    onRemove(namespaceId: string, element: any, context: any): void;
+    disableAnimations(element: any, disable: boolean): void;
+    process(namespaceId: string, element: any, property: string, value: any): void;
+    listen(namespaceId: string, element: any, eventName: string, eventPhase: string, callback: (event: any) => any): () => any;
+    flush(microtaskId?: number): void;
+    get players(): AnimationPlayer[];
+    whenRenderingDone(): Promise<any>;
+    afterFlushAnimationsDone(cb: VoidFunction): void;
+}
+
+declare function createEngine(type: 'animations' | 'noop', doc: Document): AnimationEngine;
+
+declare const enum AnimationTransitionInstructionType {
+    TransitionAnimation = 0,
+    TimelineAnimation = 1
+}
+interface AnimationEngineInstruction {
+    type: AnimationTransitionInstructionType;
+}
+
+interface AnimationTimelineInstruction extends AnimationEngineInstruction {
+    element: any;
+    keyframes: Array<_StyleDataMap>;
+    preStyleProps: string[];
+    postStyleProps: string[];
+    duration: number;
+    delay: number;
+    totalTime: number;
+    easing: string | null;
+    stretchStartingKeyframe?: boolean;
+    subTimeline: boolean;
+}
+
+declare class ElementInstructionMap {
+    private _map;
+    get(element: any): AnimationTimelineInstruction[];
+    append(element: any, instructions: AnimationTimelineInstruction[]): void;
+    has(element: any): boolean;
+    clear(): void;
+}
+
+declare class Animation$1 {
+    private _driver;
+    private _animationAst;
+    constructor(_driver: AnimationDriver, input: AnimationMetadata | AnimationMetadata[]);
+    buildTimelines(element: any, startingStyles: _StyleDataMap | Array<_StyleDataMap>, destinationStyles: _StyleDataMap | Array<_StyleDataMap>, options: AnimationOptions, subInstructions?: ElementInstructionMap): AnimationTimelineInstruction[];
+}
+
+declare class WebAnimationsStyleNormalizer extends AnimationStyleNormalizer {
+    normalizePropertyName(propertyName: string, errors: Error[]): string;
+    normalizeStyleValue(userProvidedProperty: string, normalizedProperty: string, value: string | number, errors: Error[]): string;
+}
+
+type AnimationFactoryWithListenerCallback = RendererFactory2 & {
+    scheduleListenerCallback: (count: number, fn: (e: any) => any, data: any) => void;
+};
+declare class BaseAnimationRenderer implements Renderer2 {
+    protected namespaceId: string;
+    delegate: Renderer2;
+    engine: AnimationEngine;
+    private _onDestroy?;
+    readonly ɵtype: _AnimationRendererType.Regular;
+    constructor(namespaceId: string, delegate: Renderer2, engine: AnimationEngine, _onDestroy?: (() => void) | undefined);
+    get data(): {
+        [key: string]: any;
+    };
+    destroyNode(node: any): void;
+    destroy(): void;
+    createElement(name: string, namespace?: string | null | undefined): any;
+    createComment(value: string): any;
+    createText(value: string): any;
+    appendChild(parent: any, newChild: any): void;
+    insertBefore(parent: any, newChild: any, refChild: any, isMove?: boolean): void;
+    removeChild(parent: any, oldChild: any, isHostElement?: boolean, requireSynchronousElementRemoval?: boolean): void;
+    selectRootElement(selectorOrNode: any, preserveContent?: boolean): any;
+    parentNode(node: any): any;
+    nextSibling(node: any): any;
+    setAttribute(el: any, name: string, value: string, namespace?: string | null | undefined): void;
+    removeAttribute(el: any, name: string, namespace?: string | null | undefined): void;
+    addClass(el: any, name: string): void;
+    removeClass(el: any, name: string): void;
+    setStyle(el: any, style: string, value: any, flags?: RendererStyleFlags2 | undefined): void;
+    removeStyle(el: any, style: string, flags?: RendererStyleFlags2 | undefined): void;
+    setProperty(el: any, name: string, value: any): void;
+    setValue(node: any, value: string): void;
+    listen(target: any, eventName: string, callback: (event: any) => boolean | void, options?: ListenerOptions): () => void;
+    protected disableAnimations(element: any, value: boolean): void;
+}
+declare class AnimationRenderer extends BaseAnimationRenderer implements Renderer2 {
+    factory: AnimationFactoryWithListenerCallback;
+    constructor(factory: AnimationFactoryWithListenerCallback, namespaceId: string, delegate: Renderer2, engine: AnimationEngine, onDestroy?: () => void);
+    setProperty(el: any, name: string, value: any): void;
+    listen(target: 'window' | 'document' | 'body' | any, eventName: string, callback: (event: any) => any, options?: ListenerOptions): () => void;
+}
+
+declare class AnimationRendererFactory implements RendererFactory2 {
+    private delegate;
+    private engine;
+    private _zone;
+    private _currentId;
+    private _microtaskId;
+    private _animationCallbacksBuffer;
+    private _rendererCache;
+    private _cdRecurDepth;
+    constructor(delegate: RendererFactory2, engine: AnimationEngine, _zone: NgZone);
+    createRenderer(hostElement: any, type: RendererType2): BaseAnimationRenderer;
+    begin(): void;
+    private _scheduleCountTask;
+    end(): void;
+    whenRenderingDone(): Promise<any>;
+    /**
+     * Used during HMR to clear any cached data about a component.
+     * @param componentId ID of the component that is being replaced.
+     */
+    protected componentReplaced(componentId: string): void;
+}
+
+declare function getParentElement(element: any): unknown | null;
+declare function validateStyleProperty(prop: string): boolean;
+declare function validateWebAnimatableStyleProperty(prop: string): boolean;
+declare function containsElement(elm1: any, elm2: any): boolean;
+declare function invokeQuery(element: any, selector: string, multi: boolean): any[];
+
+declare class WebAnimationsDriver implements AnimationDriver {
+    validateStyleProperty(prop: string): boolean;
+    validateAnimatableStyleProperty(prop: string): boolean;
+    containsElement(elm1: any, elm2: any): boolean;
+    getParentElement(element: unknown): unknown;
+    query(element: any, selector: string, multi: boolean): any[];
+    computeStyle(element: any, prop: string, defaultValue?: string): string;
+    animate(element: any, keyframes: Array<Map<string, string | number>>, duration: number, delay: number, easing: string, previousPlayers?: AnimationPlayer[]): AnimationPlayer;
+}
+
+/**
+ * Designed to be executed during a keyframe-based animation to apply any special-cased styles.
+ *
+ * When started (when the `start()` method is run) then the provided `startStyles`
+ * will be applied. When finished (when the `finish()` method is called) the
+ * `endStyles` will be applied as well any any starting styles. Finally when
+ * `destroy()` is called then all styles will be removed.
+ */
+declare class SpecialCasedStyles {
+    private _element;
+    private _startStyles;
+    private _endStyles;
+    static initialStylesByElement: WeakMap<any, _StyleDataMap>;
+    private _state;
+    private _initialStyles;
+    constructor(_element: any, _startStyles: _StyleDataMap | null, _endStyles: _StyleDataMap | null);
+    start(): void;
+    finish(): void;
+    destroy(): void;
+}
+
+declare class WebAnimationsPlayer implements AnimationPlayer {
+    element: any;
+    keyframes: Array<_StyleDataMap>;
+    options: {
+        [key: string]: string | number;
+    };
+    private _specialStyles?;
+    private _onDoneFns;
+    private _onStartFns;
+    private _onDestroyFns;
+    private _duration;
+    private _delay;
+    private _initialized;
+    private _finished;
+    private _started;
+    private _destroyed;
+    private _finalKeyframe?;
+    private _originalOnDoneFns;
+    private _originalOnStartFns;
+    domPlayer: Animation | null;
+    time: number;
+    parentPlayer: AnimationPlayer | null;
+    currentSnapshot: _StyleDataMap;
+    constructor(element: any, keyframes: Array<_StyleDataMap>, options: {
+        [key: string]: string | number;
+    }, _specialStyles?: (SpecialCasedStyles | null) | undefined);
+    private _onFinish;
+    init(): void;
+    private _buildPlayer;
+    private _preparePlayerBeforeStart;
+    private _convertKeyframesToObject;
+    onStart(fn: () => void): void;
+    onDone(fn: () => void): void;
+    onDestroy(fn: () => void): void;
+    play(): void;
+    pause(): void;
+    finish(): void;
+    reset(): void;
+    private _resetDomPlayerState;
+    restart(): void;
+    hasStarted(): boolean;
+    destroy(): void;
+    setPosition(p: number): void;
+    getPosition(): number;
+    get totalTime(): number;
+    beforeDestroy(): void;
+}
+
+declare const ENTER_CLASSNAME = "ng-enter";
+declare const LEAVE_CLASSNAME = "ng-leave";
+declare function normalizeKeyframes(keyframes: Array<_StyleData> | Array<_StyleDataMap>): Array<_StyleDataMap>;
+declare function camelCaseToDashCase(input: string): string;
+declare function allowPreviousPlayerStylesMerge(duration: number, delay: number): boolean;
+
+declare class TransitionAnimationPlayer implements AnimationPlayer {
+    namespaceId: string;
+    triggerName: string;
+    element: any;
+    private _player;
+    private _containsRealPlayer;
+    private _queuedCallbacks;
+    readonly destroyed = false;
+    parentPlayer: AnimationPlayer | null;
+    markedForDestroy: boolean;
+    disabled: boolean;
+    readonly queued: boolean;
+    readonly totalTime: number;
+    constructor(namespaceId: string, triggerName: string, element: any);
+    setRealPlayer(player: AnimationPlayer): void;
+    getRealPlayer(): AnimationPlayer;
+    overrideTotalTime(totalTime: number): void;
+    syncPlayerEvents(player: AnimationPlayer): void;
+    private _queueEvent;
+    onDone(fn: () => void): void;
+    onStart(fn: () => void): void;
+    onDestroy(fn: () => void): void;
+    init(): void;
+    hasStarted(): boolean;
+    play(): void;
+    pause(): void;
+    restart(): void;
+    finish(): void;
+    destroy(): void;
+    reset(): void;
+    setPosition(p: number): void;
+    getPosition(): number;
+}
+
+export { AnimationDriver, Animation$1 as ɵAnimation, AnimationEngine as ɵAnimationEngine, AnimationRenderer as ɵAnimationRenderer, AnimationRendererFactory as ɵAnimationRendererFactory, AnimationStyleNormalizer as ɵAnimationStyleNormalizer, BaseAnimationRenderer as ɵBaseAnimationRenderer, ENTER_CLASSNAME as ɵENTER_CLASSNAME, LEAVE_CLASSNAME as ɵLEAVE_CLASSNAME, NoopAnimationStyleNormalizer as ɵNoopAnimationStyleNormalizer, TransitionAnimationPlayer as ɵTransitionAnimationPlayer, WebAnimationsDriver as ɵWebAnimationsDriver, WebAnimationsPlayer as ɵWebAnimationsPlayer, WebAnimationsStyleNormalizer as ɵWebAnimationsStyleNormalizer, allowPreviousPlayerStylesMerge as ɵallowPreviousPlayerStylesMerge, camelCaseToDashCase as ɵcamelCaseToDashCase, containsElement as ɵcontainsElement, createEngine as ɵcreateEngine, getParentElement as ɵgetParentElement, invokeQuery as ɵinvokeQuery, normalizeKeyframes as ɵnormalizeKeyframes, validateStyleProperty as ɵvalidateStyleProperty, validateWebAnimatableStyleProperty as ɵvalidateWebAnimatableStyleProperty };

node_modules/@angular/animations/browser/testing/index.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @license Angular v20.3.11
+ * (c) 2010-2025 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+
+import { AnimationPlayer, ɵStyleDataMap as _StyleDataMap, NoopAnimationPlayer } from '../../animation_player.d.js';
+import { AnimationDriver } from '../../animation_driver.d.js';
+import '@angular/core';
+
+/**
+ * @publicApi
+ *
+ * @deprecated 20.2 Use `animate.enter` or `animate.leave` instead. Intent to remove in v23
+ */
+declare class MockAnimationDriver implements AnimationDriver {
+    static log: AnimationPlayer[];
+    validateStyleProperty(prop: string): boolean;
+    validateAnimatableStyleProperty(prop: string): boolean;
+    containsElement(elm1: any, elm2: any): boolean;
+    getParentElement(element: unknown): unknown;
+    query(element: any, selector: string, multi: boolean): any[];
+    computeStyle(element: any, prop: string, defaultValue?: string): string;
+    animate(element: any, keyframes: Array<_StyleDataMap>, duration: number, delay: number, easing: string, previousPlayers?: any[]): MockAnimationPlayer;
+}
+/**
+ * @publicApi
+ *
+ * @deprecated 20.2 Use `animate.enter` or `animate.leave` instead. Intent to remove in v23
+ */
+declare class MockAnimationPlayer extends NoopAnimationPlayer {
+    element: any;
+    keyframes: Array<_StyleDataMap>;
+    duration: number;
+    delay: number;
+    easing: string;
+    previousPlayers: any[];
+    private __finished;
+    private __started;
+    previousStyles: _StyleDataMap;
+    private _onInitFns;
+    currentSnapshot: _StyleDataMap;
+    private _keyframes;
+    constructor(element: any, keyframes: Array<_StyleDataMap>, duration: number, delay: number, easing: string, previousPlayers: any[]);
+    reset(): void;
+    finish(): void;
+    destroy(): void;
+    play(): void;
+    hasStarted(): boolean;
+    beforeDestroy(): void;
+}
+
+export { MockAnimationDriver, MockAnimationPlayer };

node_modules/@angular/animations/fesm2022/animations.mjs

@@ -0,0 +1,212 @@
+/**
+ * @license Angular v20.3.11
+ * (c) 2010-2025 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+
+import * as i0 from '@angular/core';
+import { inject, Injectable, ANIMATION_MODULE_TYPE, ɵRuntimeError as _RuntimeError, DOCUMENT, Inject, ViewEncapsulation } from '@angular/core';
+import { sequence } from './private_export.mjs';
+export { AUTO_STYLE, AnimationMetadataType, NoopAnimationPlayer, animate, animateChild, animation, group, keyframes, query, stagger, state, style, transition, trigger, useAnimation, AnimationGroupPlayer as ɵAnimationGroupPlayer, ɵPRE_STYLE } from './private_export.mjs';
+
+/**
+ * An injectable service that produces an animation sequence programmatically within an
+ * Angular component or directive.
+ * Provided by the `BrowserAnimationsModule` or `NoopAnimationsModule`.
+ *
+ * @usageNotes
+ *
+ * To use this service, add it to your component or directive as a dependency.
+ * The service is instantiated along with your component.
+ *
+ * Apps do not typically need to create their own animation players, but if you
+ * do need to, follow these steps:
+ *
+ * 1. Use the <code>[AnimationBuilder.build](api/animations/AnimationBuilder#build)()</code> method
+ * to create a programmatic animation. The method returns an `AnimationFactory` instance.
+ *
+ * 2. Use the factory object to create an `AnimationPlayer` and attach it to a DOM element.
+ *
+ * 3. Use the player object to control the animation programmatically.
+ *
+ * For example:
+ *
+ * ```ts
+ * // import the service from BrowserAnimationsModule
+ * import {AnimationBuilder} from '@angular/animations';
+ * // require the service as a dependency
+ * class MyCmp {
+ *   constructor(private _builder: AnimationBuilder) {}
+ *
+ *   makeAnimation(element: any) {
+ *     // first define a reusable animation
+ *     const myAnimation = this._builder.build([
+ *       style({ width: 0 }),
+ *       animate(1000, style({ width: '100px' }))
+ *     ]);
+ *
+ *     // use the returned factory object to create a player
+ *     const player = myAnimation.create(element);
+ *
+ *     player.play();
+ *   }
+ * }
+ * ```
+ *
+ * @publicApi
+ *
+ * @deprecated 20.2 Use `animate.enter` or `animate.leave` instead. Intent to remove in v23
+ */
+class AnimationBuilder {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: AnimationBuilder, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: AnimationBuilder, providedIn: 'root', useFactory: () => inject(BrowserAnimationBuilder) });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: AnimationBuilder, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root', useFactory: () => inject(BrowserAnimationBuilder) }]
+        }] });
+/**
+ * A factory object returned from the
+ * <code>[AnimationBuilder.build](api/animations/AnimationBuilder#build)()</code>
+ * method.
+ *
+ * @publicApi
+ *
+ * @deprecated 20.2 Use `animate.enter` or `animate.leave` instead. Intent to remove in v23
+ */
+class AnimationFactory {
+}
+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)) {
+            // We only support AnimationRenderer & DynamicDelegationRenderer for this AnimationBuilder
+            throw new _RuntimeError(3600 /* RuntimeErrorCode.BROWSER_ANIMATION_BUILDER_INJECTED_WITHOUT_ANIMATIONS */, (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(animation) {
+        const id = this._nextAnimationId;
+        this._nextAnimationId++;
+        const entry = Array.isArray(animation) ? sequence(animation) : animation;
+        issueAnimationCommand(this._renderer, null, id, 'register', [entry]);
+        return new BrowserAnimationFactory(id, this._renderer);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: BrowserAnimationBuilder, deps: [{ token: i0.RendererFactory2 }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: BrowserAnimationBuilder, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: BrowserAnimationBuilder, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i0.RendererFactory2 }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }] });
+class BrowserAnimationFactory 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);
+    }
+}
+class RendererAnimationPlayer {
+    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);
+}
+/**
+ * The following 2 methods cannot reference their correct types (AnimationRenderer &
+ * DynamicDelegationRenderer) since this would introduce a import cycle.
+ */
+function unwrapAnimationRenderer(renderer) {
+    const type = renderer.ɵtype;
+    if (type === 0 /* AnimationRendererType.Regular */) {
+        return renderer;
+    }
+    else if (type === 1 /* AnimationRendererType.Delegated */) {
+        return renderer.animationRenderer;
+    }
+    return null;
+}
+function isAnimationRenderer(renderer) {
+    const type = renderer.ɵtype;
+    return type === 0 /* AnimationRendererType.Regular */ || type === 1 /* AnimationRendererType.Delegated */;
+}
+
+export { AnimationBuilder, AnimationFactory, sequence, BrowserAnimationBuilder as ɵBrowserAnimationBuilder };
+//# sourceMappingURL=animations.mjs.map

node_modules/@angular/animations/fesm2022/browser/testing.mjs

@@ -0,0 +1,130 @@
+/**
+ * @license Angular v20.3.11
+ * (c) 2010-2025 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+
+import { validateStyleProperty, camelCaseToDashCase, validateWebAnimatableStyleProperty, containsElement, getParentElement, invokeQuery, normalizeKeyframes$1 as normalizeKeyframes, allowPreviousPlayerStylesMerge } from '../util.mjs';
+import { NoopAnimationPlayer, AUTO_STYLE } from '../private_export.mjs';
+import '@angular/core';
+
+/**
+ * @publicApi
+ *
+ * @deprecated 20.2 Use `animate.enter` or `animate.leave` instead. Intent to remove in v23
+ */
+class MockAnimationDriver {
+    static log = [];
+    validateStyleProperty(prop) {
+        return validateStyleProperty(prop);
+    }
+    validateAnimatableStyleProperty(prop) {
+        const cssProp = camelCaseToDashCase(prop);
+        return validateWebAnimatableStyleProperty(cssProp);
+    }
+    containsElement(elm1, elm2) {
+        return containsElement(elm1, elm2);
+    }
+    getParentElement(element) {
+        return getParentElement(element);
+    }
+    query(element, selector, multi) {
+        return invokeQuery(element, selector, multi);
+    }
+    computeStyle(element, prop, defaultValue) {
+        return defaultValue || '';
+    }
+    animate(element, keyframes, duration, delay, easing, previousPlayers = []) {
+        const player = new MockAnimationPlayer(element, keyframes, duration, delay, easing, previousPlayers);
+        MockAnimationDriver.log.push(player);
+        return player;
+    }
+}
+/**
+ * @publicApi
+ *
+ * @deprecated 20.2 Use `animate.enter` or `animate.leave` instead. Intent to remove in v23
+ */
+class MockAnimationPlayer extends NoopAnimationPlayer {
+    element;
+    keyframes;
+    duration;
+    delay;
+    easing;
+    previousPlayers;
+    __finished = false;
+    __started = false;
+    previousStyles = new Map();
+    _onInitFns = [];
+    currentSnapshot = new Map();
+    _keyframes = [];
+    constructor(element, keyframes, duration, delay, easing, previousPlayers) {
+        super(duration, delay);
+        this.element = element;
+        this.keyframes = keyframes;
+        this.duration = duration;
+        this.delay = delay;
+        this.easing = easing;
+        this.previousPlayers = previousPlayers;
+        this._keyframes = normalizeKeyframes(keyframes);
+        if (allowPreviousPlayerStylesMerge(duration, delay)) {
+            previousPlayers.forEach((player) => {
+                if (player instanceof MockAnimationPlayer) {
+                    const styles = player.currentSnapshot;
+                    styles.forEach((val, prop) => this.previousStyles.set(prop, val));
+                }
+            });
+        }
+    }
+    /** @internal */
+    onInit(fn) {
+        this._onInitFns.push(fn);
+    }
+    /** @internal */
+    init() {
+        super.init();
+        this._onInitFns.forEach((fn) => fn());
+        this._onInitFns = [];
+    }
+    reset() {
+        super.reset();
+        this.__started = false;
+    }
+    finish() {
+        super.finish();
+        this.__finished = true;
+    }
+    destroy() {
+        super.destroy();
+        this.__finished = true;
+    }
+    /** @internal */
+    triggerMicrotask() { }
+    play() {
+        super.play();
+        this.__started = true;
+    }
+    hasStarted() {
+        return this.__started;
+    }
+    beforeDestroy() {
+        const captures = new Map();
+        this.previousStyles.forEach((val, prop) => captures.set(prop, val));
+        if (this.hasStarted()) {
+            // when assembling the captured styles, it's important that
+            // we build the keyframe styles in the following order:
+            // {other styles within keyframes, ... previousStyles }
+            this._keyframes.forEach((kf) => {
+                for (let [prop, val] of kf) {
+                    if (prop !== 'offset') {
+                        captures.set(prop, this.__finished ? val : AUTO_STYLE);
+                    }
+                }
+            });
+        }
+        this.currentSnapshot = captures;
+    }
+}
+
+export { MockAnimationDriver, MockAnimationPlayer };
+//# sourceMappingURL=testing.mjs.map

node_modules/@angular/animations/fesm2022/util.mjs

@@ -0,0 +1,697 @@
+/**
+ * @license Angular v20.3.11
+ * (c) 2010-2025 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+
+import { AnimationGroupPlayer, NoopAnimationPlayer, AUTO_STYLE, ɵPRE_STYLE as _PRE_STYLE, AnimationMetadataType, sequence } from './private_export.mjs';
+import { ɵRuntimeError as _RuntimeError } from '@angular/core';
+
+const LINE_START = '\n - ';
+function invalidTimingValue(exp) {
+    return new _RuntimeError(3000 /* RuntimeErrorCode.INVALID_TIMING_VALUE */, ngDevMode && `The provided timing value "${exp}" is invalid.`);
+}
+function negativeStepValue() {
+    return new _RuntimeError(3100 /* RuntimeErrorCode.NEGATIVE_STEP_VALUE */, ngDevMode && 'Duration values below 0 are not allowed for this animation step.');
+}
+function negativeDelayValue() {
+    return new _RuntimeError(3101 /* RuntimeErrorCode.NEGATIVE_DELAY_VALUE */, ngDevMode && 'Delay values below 0 are not allowed for this animation step.');
+}
+function invalidStyleParams(varName) {
+    return new _RuntimeError(3001 /* RuntimeErrorCode.INVALID_STYLE_PARAMS */, ngDevMode &&
+        `Unable to resolve the local animation param ${varName} in the given list of values`);
+}
+function invalidParamValue(varName) {
+    return new _RuntimeError(3003 /* RuntimeErrorCode.INVALID_PARAM_VALUE */, ngDevMode && `Please provide a value for the animation param ${varName}`);
+}
+function invalidNodeType(nodeType) {
+    return new _RuntimeError(3004 /* RuntimeErrorCode.INVALID_NODE_TYPE */, ngDevMode && `Unable to resolve animation metadata node #${nodeType}`);
+}
+function invalidCssUnitValue(userProvidedProperty, value) {
+    return new _RuntimeError(3005 /* RuntimeErrorCode.INVALID_CSS_UNIT_VALUE */, ngDevMode && `Please provide a CSS unit value for ${userProvidedProperty}:${value}`);
+}
+function invalidTrigger() {
+    return new _RuntimeError(3006 /* RuntimeErrorCode.INVALID_TRIGGER */, ngDevMode &&
+        "animation triggers cannot be prefixed with an `@` sign (e.g. trigger('@foo', [...]))");
+}
+function invalidDefinition() {
+    return new _RuntimeError(3007 /* RuntimeErrorCode.INVALID_DEFINITION */, ngDevMode && 'only state() and transition() definitions can sit inside of a trigger()');
+}
+function invalidState(metadataName, missingSubs) {
+    return new _RuntimeError(3008 /* RuntimeErrorCode.INVALID_STATE */, ngDevMode &&
+        `state("${metadataName}", ...) must define default values for all the following style substitutions: ${missingSubs.join(', ')}`);
+}
+function invalidStyleValue(value) {
+    return new _RuntimeError(3002 /* RuntimeErrorCode.INVALID_STYLE_VALUE */, ngDevMode && `The provided style string value ${value} is not allowed.`);
+}
+function invalidParallelAnimation(prop, firstStart, firstEnd, secondStart, secondEnd) {
+    return new _RuntimeError(3010 /* RuntimeErrorCode.INVALID_PARALLEL_ANIMATION */, ngDevMode &&
+        `The CSS property "${prop}" that exists between the times of "${firstStart}ms" and "${firstEnd}ms" is also being animated in a parallel animation between the times of "${secondStart}ms" and "${secondEnd}ms"`);
+}
+function invalidKeyframes() {
+    return new _RuntimeError(3011 /* RuntimeErrorCode.INVALID_KEYFRAMES */, ngDevMode && `keyframes() must be placed inside of a call to animate()`);
+}
+function invalidOffset() {
+    return new _RuntimeError(3012 /* RuntimeErrorCode.INVALID_OFFSET */, ngDevMode && `Please ensure that all keyframe offsets are between 0 and 1`);
+}
+function keyframeOffsetsOutOfOrder() {
+    return new _RuntimeError(3200 /* RuntimeErrorCode.KEYFRAME_OFFSETS_OUT_OF_ORDER */, ngDevMode && `Please ensure that all keyframe offsets are in order`);
+}
+function keyframesMissingOffsets() {
+    return new _RuntimeError(3202 /* RuntimeErrorCode.KEYFRAMES_MISSING_OFFSETS */, ngDevMode && `Not all style() steps within the declared keyframes() contain offsets`);
+}
+function invalidStagger() {
+    return new _RuntimeError(3013 /* RuntimeErrorCode.INVALID_STAGGER */, ngDevMode && `stagger() can only be used inside of query()`);
+}
+function invalidQuery(selector) {
+    return new _RuntimeError(3014 /* RuntimeErrorCode.INVALID_QUERY */, ngDevMode &&
+        `\`query("${selector}")\` returned zero elements. (Use \`query("${selector}", { optional: true })\` if you wish to allow this.)`);
+}
+function invalidExpression(expr) {
+    return new _RuntimeError(3015 /* RuntimeErrorCode.INVALID_EXPRESSION */, ngDevMode && `The provided transition expression "${expr}" is not supported`);
+}
+function invalidTransitionAlias(alias) {
+    return new _RuntimeError(3016 /* RuntimeErrorCode.INVALID_TRANSITION_ALIAS */, ngDevMode && `The transition alias value "${alias}" is not supported`);
+}
+function validationFailed(errors) {
+    return new _RuntimeError(3500 /* RuntimeErrorCode.VALIDATION_FAILED */, ngDevMode && `animation validation failed:\n${errors.map((err) => err.message).join('\n')}`);
+}
+function buildingFailed(errors) {
+    return new _RuntimeError(3501 /* RuntimeErrorCode.BUILDING_FAILED */, ngDevMode && `animation building failed:\n${errors.map((err) => err.message).join('\n')}`);
+}
+function triggerBuildFailed(name, errors) {
+    return new _RuntimeError(3404 /* RuntimeErrorCode.TRIGGER_BUILD_FAILED */, ngDevMode &&
+        `The animation trigger "${name}" has failed to build due to the following errors:\n - ${errors
+            .map((err) => err.message)
+            .join('\n - ')}`);
+}
+function animationFailed(errors) {
+    return new _RuntimeError(3502 /* RuntimeErrorCode.ANIMATION_FAILED */, ngDevMode &&
+        `Unable to animate due to the following errors:${LINE_START}${errors
+            .map((err) => err.message)
+            .join(LINE_START)}`);
+}
+function registerFailed(errors) {
+    return new _RuntimeError(3503 /* RuntimeErrorCode.REGISTRATION_FAILED */, ngDevMode &&
+        `Unable to build the animation due to the following errors: ${errors
+            .map((err) => err.message)
+            .join('\n')}`);
+}
+function missingOrDestroyedAnimation() {
+    return new _RuntimeError(3300 /* RuntimeErrorCode.MISSING_OR_DESTROYED_ANIMATION */, ngDevMode && "The requested animation doesn't exist or has already been destroyed");
+}
+function createAnimationFailed(errors) {
+    return new _RuntimeError(3504 /* RuntimeErrorCode.CREATE_ANIMATION_FAILED */, ngDevMode &&
+        `Unable to create the animation due to the following errors:${errors
+            .map((err) => err.message)
+            .join('\n')}`);
+}
+function missingPlayer(id) {
+    return new _RuntimeError(3301 /* RuntimeErrorCode.MISSING_PLAYER */, ngDevMode && `Unable to find the timeline player referenced by ${id}`);
+}
+function missingTrigger(phase, name) {
+    return new _RuntimeError(3302 /* RuntimeErrorCode.MISSING_TRIGGER */, ngDevMode &&
+        `Unable to listen on the animation trigger event "${phase}" because the animation trigger "${name}" doesn\'t exist!`);
+}
+function missingEvent(name) {
+    return new _RuntimeError(3303 /* RuntimeErrorCode.MISSING_EVENT */, ngDevMode &&
+        `Unable to listen on the animation trigger "${name}" because the provided event is undefined!`);
+}
+function unsupportedTriggerEvent(phase, name) {
+    return new _RuntimeError(3400 /* RuntimeErrorCode.UNSUPPORTED_TRIGGER_EVENT */, ngDevMode &&
+        `The provided animation trigger event "${phase}" for the animation trigger "${name}" is not supported!`);
+}
+function unregisteredTrigger(name) {
+    return new _RuntimeError(3401 /* RuntimeErrorCode.UNREGISTERED_TRIGGER */, ngDevMode && `The provided animation trigger "${name}" has not been registered!`);
+}
+function triggerTransitionsFailed(errors) {
+    return new _RuntimeError(3402 /* RuntimeErrorCode.TRIGGER_TRANSITIONS_FAILED */, ngDevMode &&
+        `Unable to process animations due to the following failed trigger transitions\n ${errors
+            .map((err) => err.message)
+            .join('\n')}`);
+}
+function transitionFailed(name, errors) {
+    return new _RuntimeError(3505 /* RuntimeErrorCode.TRANSITION_FAILED */, ngDevMode && `@${name} has failed due to:\n ${errors.map((err) => err.message).join('\n- ')}`);
+}
+
+/**
+ * Set of all animatable CSS properties
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_animated_properties
+ */
+const ANIMATABLE_PROP_SET = new Set([
+    '-moz-outline-radius',
+    '-moz-outline-radius-bottomleft',
+    '-moz-outline-radius-bottomright',
+    '-moz-outline-radius-topleft',
+    '-moz-outline-radius-topright',
+    '-ms-grid-columns',
+    '-ms-grid-rows',
+    '-webkit-line-clamp',
+    '-webkit-text-fill-color',
+    '-webkit-text-stroke',
+    '-webkit-text-stroke-color',
+    'accent-color',
+    'all',
+    'backdrop-filter',
+    'background',
+    'background-color',
+    'background-position',
+    'background-size',
+    'block-size',
+    'border',
+    'border-block-end',
+    'border-block-end-color',
+    'border-block-end-width',
+    'border-block-start',
+    'border-block-start-color',
+    'border-block-start-width',
+    'border-bottom',
+    'border-bottom-color',
+    'border-bottom-left-radius',
+    'border-bottom-right-radius',
+    'border-bottom-width',
+    'border-color',
+    'border-end-end-radius',
+    'border-end-start-radius',
+    'border-image-outset',
+    'border-image-slice',
+    'border-image-width',
+    'border-inline-end',
+    'border-inline-end-color',
+    'border-inline-end-width',
+    'border-inline-start',
+    'border-inline-start-color',
+    'border-inline-start-width',
+    'border-left',
+    'border-left-color',
+    'border-left-width',
+    'border-radius',
+    'border-right',
+    'border-right-color',
+    'border-right-width',
+    'border-start-end-radius',
+    'border-start-start-radius',
+    'border-top',
+    'border-top-color',
+    'border-top-left-radius',
+    'border-top-right-radius',
+    'border-top-width',
+    'border-width',
+    'bottom',
+    'box-shadow',
+    'caret-color',
+    'clip',
+    'clip-path',
+    'color',
+    'column-count',
+    'column-gap',
+    'column-rule',
+    'column-rule-color',
+    'column-rule-width',
+    'column-width',
+    'columns',
+    'filter',
+    'flex',
+    'flex-basis',
+    'flex-grow',
+    'flex-shrink',
+    'font',
+    'font-size',
+    'font-size-adjust',
+    'font-stretch',
+    'font-variation-settings',
+    'font-weight',
+    'gap',
+    'grid-column-gap',
+    'grid-gap',
+    'grid-row-gap',
+    'grid-template-columns',
+    'grid-template-rows',
+    'height',
+    'inline-size',
+    'input-security',
+    'inset',
+    'inset-block',
+    'inset-block-end',
+    'inset-block-start',
+    'inset-inline',
+    'inset-inline-end',
+    'inset-inline-start',
+    'left',
+    'letter-spacing',
+    'line-clamp',
+    'line-height',
+    'margin',
+    'margin-block-end',
+    'margin-block-start',
+    'margin-bottom',
+    'margin-inline-end',
+    'margin-inline-start',
+    'margin-left',
+    'margin-right',
+    'margin-top',
+    'mask',
+    'mask-border',
+    'mask-position',
+    'mask-size',
+    'max-block-size',
+    'max-height',
+    'max-inline-size',
+    'max-lines',
+    'max-width',
+    'min-block-size',
+    'min-height',
+    'min-inline-size',
+    'min-width',
+    'object-position',
+    'offset',
+    'offset-anchor',
+    'offset-distance',
+    'offset-path',
+    'offset-position',
+    'offset-rotate',
+    'opacity',
+    'order',
+    'outline',
+    'outline-color',
+    'outline-offset',
+    'outline-width',
+    'padding',
+    'padding-block-end',
+    'padding-block-start',
+    'padding-bottom',
+    'padding-inline-end',
+    'padding-inline-start',
+    'padding-left',
+    'padding-right',
+    'padding-top',
+    'perspective',
+    'perspective-origin',
+    'right',
+    'rotate',
+    'row-gap',
+    'scale',
+    'scroll-margin',
+    'scroll-margin-block',
+    'scroll-margin-block-end',
+    'scroll-margin-block-start',
+    'scroll-margin-bottom',
+    'scroll-margin-inline',
+    'scroll-margin-inline-end',
+    'scroll-margin-inline-start',
+    'scroll-margin-left',
+    'scroll-margin-right',
+    'scroll-margin-top',
+    'scroll-padding',
+    'scroll-padding-block',
+    'scroll-padding-block-end',
+    'scroll-padding-block-start',
+    'scroll-padding-bottom',
+    'scroll-padding-inline',
+    'scroll-padding-inline-end',
+    'scroll-padding-inline-start',
+    'scroll-padding-left',
+    'scroll-padding-right',
+    'scroll-padding-top',
+    'scroll-snap-coordinate',
+    'scroll-snap-destination',
+    'scrollbar-color',
+    'shape-image-threshold',
+    'shape-margin',
+    'shape-outside',
+    'tab-size',
+    'text-decoration',
+    'text-decoration-color',
+    'text-decoration-thickness',
+    'text-emphasis',
+    'text-emphasis-color',
+    'text-indent',
+    'text-shadow',
+    'text-underline-offset',
+    'top',
+    'transform',
+    'transform-origin',
+    'translate',
+    'vertical-align',
+    'visibility',
+    'width',
+    'word-spacing',
+    'z-index',
+    'zoom',
+]);
+
+function optimizeGroupPlayer(players) {
+    switch (players.length) {
+        case 0:
+            return new NoopAnimationPlayer();
+        case 1:
+            return players[0];
+        default:
+            return new AnimationGroupPlayer(players);
+    }
+}
+function normalizeKeyframes$1(normalizer, keyframes, preStyles = new Map(), postStyles = new Map()) {
+    const errors = [];
+    const normalizedKeyframes = [];
+    let previousOffset = -1;
+    let previousKeyframe = null;
+    keyframes.forEach((kf) => {
+        const offset = kf.get('offset');
+        const isSameOffset = offset == previousOffset;
+        const normalizedKeyframe = (isSameOffset && previousKeyframe) || new Map();
+        kf.forEach((val, prop) => {
+            let normalizedProp = prop;
+            let normalizedValue = val;
+            if (prop !== 'offset') {
+                normalizedProp = normalizer.normalizePropertyName(normalizedProp, errors);
+                switch (normalizedValue) {
+                    case _PRE_STYLE:
+                        normalizedValue = preStyles.get(prop);
+                        break;
+                    case AUTO_STYLE:
+                        normalizedValue = postStyles.get(prop);
+                        break;
+                    default:
+                        normalizedValue = normalizer.normalizeStyleValue(prop, normalizedProp, normalizedValue, errors);
+                        break;
+                }
+            }
+            normalizedKeyframe.set(normalizedProp, normalizedValue);
+        });
+        if (!isSameOffset) {
+            normalizedKeyframes.push(normalizedKeyframe);
+        }
+        previousKeyframe = normalizedKeyframe;
+        previousOffset = offset;
+    });
+    if (errors.length) {
+        throw animationFailed(errors);
+    }
+    return normalizedKeyframes;
+}
+function listenOnPlayer(player, eventName, event, callback) {
+    switch (eventName) {
+        case 'start':
+            player.onStart(() => callback(event && copyAnimationEvent(event, 'start', player)));
+            break;
+        case 'done':
+            player.onDone(() => callback(event && copyAnimationEvent(event, 'done', player)));
+            break;
+        case 'destroy':
+            player.onDestroy(() => callback(event && copyAnimationEvent(event, 'destroy', player)));
+            break;
+    }
+}
+function copyAnimationEvent(e, phaseName, player) {
+    const totalTime = player.totalTime;
+    const disabled = player.disabled ? true : false;
+    const event = makeAnimationEvent(e.element, e.triggerName, e.fromState, e.toState, phaseName || e.phaseName, totalTime == undefined ? e.totalTime : totalTime, disabled);
+    const data = e['_data'];
+    if (data != null) {
+        event['_data'] = data;
+    }
+    return event;
+}
+function makeAnimationEvent(element, triggerName, fromState, toState, phaseName = '', totalTime = 0, disabled) {
+    return { element, triggerName, fromState, toState, phaseName, totalTime, disabled: !!disabled };
+}
+function getOrSetDefaultValue(map, key, defaultValue) {
+    let value = map.get(key);
+    if (!value) {
+        map.set(key, (value = defaultValue));
+    }
+    return value;
+}
+function parseTimelineCommand(command) {
+    const separatorPos = command.indexOf(':');
+    const id = command.substring(1, separatorPos);
+    const action = command.slice(separatorPos + 1);
+    return [id, action];
+}
+const documentElement = /* @__PURE__ */ (() => typeof document === 'undefined' ? null : document.documentElement)();
+function getParentElement(element) {
+    const parent = element.parentNode || element.host || null; // consider host to support shadow DOM
+    if (parent === documentElement) {
+        return null;
+    }
+    return parent;
+}
+function containsVendorPrefix(prop) {
+    // Webkit is the only real popular vendor prefix nowadays
+    // cc: http://shouldiprefix.com/
+    return prop.substring(1, 6) == 'ebkit'; // webkit or Webkit
+}
+let _CACHED_BODY = null;
+let _IS_WEBKIT = false;
+function validateStyleProperty(prop) {
+    if (!_CACHED_BODY) {
+        _CACHED_BODY = getBodyNode() || {};
+        _IS_WEBKIT = _CACHED_BODY.style ? 'WebkitAppearance' in _CACHED_BODY.style : false;
+    }
+    let result = true;
+    if (_CACHED_BODY.style && !containsVendorPrefix(prop)) {
+        result = prop in _CACHED_BODY.style;
+        if (!result && _IS_WEBKIT) {
+            const camelProp = 'Webkit' + prop.charAt(0).toUpperCase() + prop.slice(1);
+            result = camelProp in _CACHED_BODY.style;
+        }
+    }
+    return result;
+}
+function validateWebAnimatableStyleProperty(prop) {
+    return ANIMATABLE_PROP_SET.has(prop);
+}
+function getBodyNode() {
+    if (typeof document != 'undefined') {
+        return document.body;
+    }
+    return null;
+}
+function containsElement(elm1, elm2) {
+    while (elm2) {
+        if (elm2 === elm1) {
+            return true;
+        }
+        elm2 = getParentElement(elm2);
+    }
+    return false;
+}
+function invokeQuery(element, selector, multi) {
+    if (multi) {
+        return Array.from(element.querySelectorAll(selector));
+    }
+    const elem = element.querySelector(selector);
+    return elem ? [elem] : [];
+}
+
+const ONE_SECOND = 1000;
+const SUBSTITUTION_EXPR_START = '{{';
+const SUBSTITUTION_EXPR_END = '}}';
+const ENTER_CLASSNAME = 'ng-enter';
+const LEAVE_CLASSNAME = 'ng-leave';
+const NG_TRIGGER_CLASSNAME = 'ng-trigger';
+const NG_TRIGGER_SELECTOR = '.ng-trigger';
+const NG_ANIMATING_CLASSNAME = 'ng-animating';
+const NG_ANIMATING_SELECTOR = '.ng-animating';
+function resolveTimingValue(value) {
+    if (typeof value == 'number')
+        return value;
+    const matches = value.match(/^(-?[\.\d]+)(m?s)/);
+    if (!matches || matches.length < 2)
+        return 0;
+    return _convertTimeValueToMS(parseFloat(matches[1]), matches[2]);
+}
+function _convertTimeValueToMS(value, unit) {
+    switch (unit) {
+        case 's':
+            return value * ONE_SECOND;
+        default: // ms or something else
+            return value;
+    }
+}
+function resolveTiming(timings, errors, allowNegativeValues) {
+    return timings.hasOwnProperty('duration')
+        ? timings
+        : parseTimeExpression(timings, errors, allowNegativeValues);
+}
+const PARSE_TIME_EXPRESSION_REGEX = /^(-?[\.\d]+)(m?s)(?:\s+(-?[\.\d]+)(m?s))?(?:\s+([-a-z]+(?:\(.+?\))?))?$/i;
+function parseTimeExpression(exp, errors, allowNegativeValues) {
+    let duration;
+    let delay = 0;
+    let easing = '';
+    if (typeof exp === 'string') {
+        const matches = exp.match(PARSE_TIME_EXPRESSION_REGEX);
+        if (matches === null) {
+            errors.push(invalidTimingValue(exp));
+            return { duration: 0, delay: 0, easing: '' };
+        }
+        duration = _convertTimeValueToMS(parseFloat(matches[1]), matches[2]);
+        const delayMatch = matches[3];
+        if (delayMatch != null) {
+            delay = _convertTimeValueToMS(parseFloat(delayMatch), matches[4]);
+        }
+        const easingVal = matches[5];
+        if (easingVal) {
+            easing = easingVal;
+        }
+    }
+    else {
+        duration = exp;
+    }
+    if (!allowNegativeValues) {
+        let containsErrors = false;
+        let startIndex = errors.length;
+        if (duration < 0) {
+            errors.push(negativeStepValue());
+            containsErrors = true;
+        }
+        if (delay < 0) {
+            errors.push(negativeDelayValue());
+            containsErrors = true;
+        }
+        if (containsErrors) {
+            errors.splice(startIndex, 0, invalidTimingValue(exp));
+        }
+    }
+    return { duration, delay, easing };
+}
+function normalizeKeyframes(keyframes) {
+    if (!keyframes.length) {
+        return [];
+    }
+    if (keyframes[0] instanceof Map) {
+        return keyframes;
+    }
+    return keyframes.map((kf) => new Map(Object.entries(kf)));
+}
+function normalizeStyles(styles) {
+    return Array.isArray(styles) ? new Map(...styles) : new Map(styles);
+}
+function setStyles(element, styles, formerStyles) {
+    styles.forEach((val, prop) => {
+        const camelProp = dashCaseToCamelCase(prop);
+        if (formerStyles && !formerStyles.has(prop)) {
+            formerStyles.set(prop, element.style[camelProp]);
+        }
+        element.style[camelProp] = val;
+    });
+}
+function eraseStyles(element, styles) {
+    styles.forEach((_, prop) => {
+        const camelProp = dashCaseToCamelCase(prop);
+        element.style[camelProp] = '';
+    });
+}
+function normalizeAnimationEntry(steps) {
+    if (Array.isArray(steps)) {
+        if (steps.length == 1)
+            return steps[0];
+        return sequence(steps);
+    }
+    return steps;
+}
+function validateStyleParams(value, options, errors) {
+    const params = options.params || {};
+    const matches = extractStyleParams(value);
+    if (matches.length) {
+        matches.forEach((varName) => {
+            if (!params.hasOwnProperty(varName)) {
+                errors.push(invalidStyleParams(varName));
+            }
+        });
+    }
+}
+const PARAM_REGEX = /* @__PURE__ */ new RegExp(`${SUBSTITUTION_EXPR_START}\\s*(.+?)\\s*${SUBSTITUTION_EXPR_END}`, 'g');
+function extractStyleParams(value) {
+    let params = [];
+    if (typeof value === 'string') {
+        let match;
+        while ((match = PARAM_REGEX.exec(value))) {
+            params.push(match[1]);
+        }
+        PARAM_REGEX.lastIndex = 0;
+    }
+    return params;
+}
+function interpolateParams(value, params, errors) {
+    const original = `${value}`;
+    const str = original.replace(PARAM_REGEX, (_, varName) => {
+        let localVal = params[varName];
+        // this means that the value was never overridden by the data passed in by the user
+        if (localVal == null) {
+            errors.push(invalidParamValue(varName));
+            localVal = '';
+        }
+        return localVal.toString();
+    });
+    // we do this to assert that numeric values stay as they are
+    return str == original ? value : str;
+}
+const DASH_CASE_REGEXP = /-+([a-z0-9])/g;
+function dashCaseToCamelCase(input) {
+    return input.replace(DASH_CASE_REGEXP, (...m) => m[1].toUpperCase());
+}
+function camelCaseToDashCase(input) {
+    return input.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+}
+function allowPreviousPlayerStylesMerge(duration, delay) {
+    return duration === 0 || delay === 0;
+}
+function balancePreviousStylesIntoKeyframes(element, keyframes, previousStyles) {
+    if (previousStyles.size && keyframes.length) {
+        let startingKeyframe = keyframes[0];
+        let missingStyleProps = [];
+        previousStyles.forEach((val, prop) => {
+            if (!startingKeyframe.has(prop)) {
+                missingStyleProps.push(prop);
+            }
+            startingKeyframe.set(prop, val);
+        });
+        if (missingStyleProps.length) {
+            for (let i = 1; i < keyframes.length; i++) {
+                let kf = keyframes[i];
+                missingStyleProps.forEach((prop) => kf.set(prop, computeStyle(element, prop)));
+            }
+        }
+    }
+    return keyframes;
+}
+function visitDslNode(visitor, node, context) {
+    switch (node.type) {
+        case AnimationMetadataType.Trigger:
+            return visitor.visitTrigger(node, context);
+        case AnimationMetadataType.State:
+            return visitor.visitState(node, context);
+        case AnimationMetadataType.Transition:
+            return visitor.visitTransition(node, context);
+        case AnimationMetadataType.Sequence:
+            return visitor.visitSequence(node, context);
+        case AnimationMetadataType.Group:
+            return visitor.visitGroup(node, context);
+        case AnimationMetadataType.Animate:
+            return visitor.visitAnimate(node, context);
+        case AnimationMetadataType.Keyframes:
+            return visitor.visitKeyframes(node, context);
+        case AnimationMetadataType.Style:
+            return visitor.visitStyle(node, context);
+        case AnimationMetadataType.Reference:
+            return visitor.visitReference(node, context);
+        case AnimationMetadataType.AnimateChild:
+            return visitor.visitAnimateChild(node, context);
+        case AnimationMetadataType.AnimateRef:
+            return visitor.visitAnimateRef(node, context);
+        case AnimationMetadataType.Query:
+            return visitor.visitQuery(node, context);
+        case AnimationMetadataType.Stagger:
+            return visitor.visitStagger(node, context);
+        default:
+            throw invalidNodeType(node.type);
+    }
+}
+function computeStyle(element, prop) {
+    return window.getComputedStyle(element)[prop];
+}
+
+export { ENTER_CLASSNAME, LEAVE_CLASSNAME, NG_ANIMATING_CLASSNAME, NG_ANIMATING_SELECTOR, NG_TRIGGER_CLASSNAME, NG_TRIGGER_SELECTOR, SUBSTITUTION_EXPR_START, allowPreviousPlayerStylesMerge, balancePreviousStylesIntoKeyframes, buildingFailed, camelCaseToDashCase, computeStyle, containsElement, createAnimationFailed, dashCaseToCamelCase, eraseStyles, extractStyleParams, getOrSetDefaultValue, getParentElement, interpolateParams, invalidCssUnitValue, invalidDefinition, invalidExpression, invalidKeyframes, invalidOffset, invalidParallelAnimation, invalidQuery, invalidStagger, invalidState, invalidStyleValue, invalidTransitionAlias, invalidTrigger, invokeQuery, keyframeOffsetsOutOfOrder, keyframesMissingOffsets, listenOnPlayer, makeAnimationEvent, missingEvent, missingOrDestroyedAnimation, missingPlayer, missingTrigger, normalizeAnimationEntry, normalizeKeyframes$1 as normalizeKeyframes, normalizeKeyframes as normalizeKeyframes$1, normalizeStyles, optimizeGroupPlayer, parseTimelineCommand, registerFailed, resolveTiming, resolveTimingValue, setStyles, transitionFailed, triggerBuildFailed, triggerTransitionsFailed, unregisteredTrigger, unsupportedTriggerEvent, validateStyleParams, validateStyleProperty, validateWebAnimatableStyleProperty, validationFailed, visitDslNode };
+//# sourceMappingURL=util.mjs.map

node_modules/@angular/animations/index.d.ts

@@ -0,0 +1,252 @@
+/**
+ * @license Angular v20.3.11
+ * (c) 2010-2025 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+
+import * as i0 from '@angular/core';
+import { RendererFactory2 } from '@angular/core';
+import { AnimationMetadata, AnimationOptions, AnimationPlayer } from './animation_player.d.js';
+export { AUTO_STYLE, AnimateChildOptions, AnimateTimings, AnimationAnimateChildMetadata, AnimationAnimateMetadata, AnimationAnimateRefMetadata, AnimationGroupMetadata, AnimationKeyframesSequenceMetadata, AnimationMetadataType, AnimationQueryMetadata, AnimationQueryOptions, AnimationReferenceMetadata, AnimationSequenceMetadata, AnimationStaggerMetadata, AnimationStateMetadata, AnimationStyleMetadata, AnimationTransitionMetadata, AnimationTriggerMetadata, NoopAnimationPlayer, animate, animateChild, animation, group, keyframes, query, sequence, stagger, state, style, transition, trigger, useAnimation, ɵStyleData, ɵStyleDataMap } from './animation_player.d.js';
+
+/**
+ * An injectable service that produces an animation sequence programmatically within an
+ * Angular component or directive.
+ * Provided by the `BrowserAnimationsModule` or `NoopAnimationsModule`.
+ *
+ * @usageNotes
+ *
+ * To use this service, add it to your component or directive as a dependency.
+ * The service is instantiated along with your component.
+ *
+ * Apps do not typically need to create their own animation players, but if you
+ * do need to, follow these steps:
+ *
+ * 1. Use the <code>[AnimationBuilder.build](api/animations/AnimationBuilder#build)()</code> method
+ * to create a programmatic animation. The method returns an `AnimationFactory` instance.
+ *
+ * 2. Use the factory object to create an `AnimationPlayer` and attach it to a DOM element.
+ *
+ * 3. Use the player object to control the animation programmatically.
+ *
+ * For example:
+ *
+ * ```ts
+ * // import the service from BrowserAnimationsModule
+ * import {AnimationBuilder} from '@angular/animations';
+ * // require the service as a dependency
+ * class MyCmp {
+ *   constructor(private _builder: AnimationBuilder) {}
+ *
+ *   makeAnimation(element: any) {
+ *     // first define a reusable animation
+ *     const myAnimation = this._builder.build([
+ *       style({ width: 0 }),
+ *       animate(1000, style({ width: '100px' }))
+ *     ]);
+ *
+ *     // use the returned factory object to create a player
+ *     const player = myAnimation.create(element);
+ *
+ *     player.play();
+ *   }
+ * }
+ * ```
+ *
+ * @publicApi
+ *
+ * @deprecated 20.2 Use `animate.enter` or `animate.leave` instead. Intent to remove in v23
+ */
+declare abstract class AnimationBuilder {
+    /**
+     * Builds a factory for producing a defined animation.
+     * @param animation A reusable animation definition.
+     * @returns A factory object that can create a player for the defined animation.
+     * @see {@link animate}
+     */
+    abstract build(animation: AnimationMetadata | AnimationMetadata[]): AnimationFactory;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnimationBuilder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AnimationBuilder>;
+}
+/**
+ * A factory object returned from the
+ * <code>[AnimationBuilder.build](api/animations/AnimationBuilder#build)()</code>
+ * method.
+ *
+ * @publicApi
+ *
+ * @deprecated 20.2 Use `animate.enter` or `animate.leave` instead. Intent to remove in v23
+ */
+declare abstract class AnimationFactory {
+    /**
+     * Creates an `AnimationPlayer` instance for the reusable animation defined by
+     * the <code>[AnimationBuilder.build](api/animations/AnimationBuilder#build)()</code>
+     * method that created this factory and attaches the new player a DOM element.
+     *
+     * @param element The DOM element to which to attach the player.
+     * @param options A set of options that can include a time delay and
+     * additional developer-defined parameters.
+     */
+    abstract create(element: any, options?: AnimationOptions): AnimationPlayer;
+}
+declare class BrowserAnimationBuilder extends AnimationBuilder {
+    private animationModuleType;
+    private _nextAnimationId;
+    private _renderer;
+    constructor(rootRenderer: RendererFactory2, doc: Document);
+    build(animation: AnimationMetadata | AnimationMetadata[]): AnimationFactory;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrowserAnimationBuilder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BrowserAnimationBuilder>;
+}
+
+/**
+ * An instance of this class is returned as an event parameter when an animation
+ * callback is captured for an animation either during the start or done phase.
+ *
+ * ```ts
+ * @Component({
+ *   host: {
+ *     '[@myAnimationTrigger]': 'someExpression',
+ *     '(@myAnimationTrigger.start)': 'captureStartEvent($event)',
+ *     '(@myAnimationTrigger.done)': 'captureDoneEvent($event)',
+ *   },
+ *   animations: [
+ *     trigger("myAnimationTrigger", [
+ *        // ...
+ *     ])
+ *   ]
+ * })
+ * class MyComponent {
+ *   someExpression: any = false;
+ *   captureStartEvent(event: AnimationEvent) {
+ *     // the toState, fromState and totalTime data is accessible from the event variable
+ *   }
+ *
+ *   captureDoneEvent(event: AnimationEvent) {
+ *     // the toState, fromState and totalTime data is accessible from the event variable
+ *   }
+ * }
+ * ```
+ *
+ * @publicApi
+ *
+ * @deprecated 20.2 Use `animate.enter` or `animate.leave` instead. Intent to remove in v23
+ */
+interface AnimationEvent {
+    /**
+     * The name of the state from which the animation is triggered.
+     */
+    fromState: string;
+    /**
+     * The name of the state in which the animation completes.
+     */
+    toState: string;
+    /**
+     * The time it takes the animation to complete, in milliseconds.
+     */
+    totalTime: number;
+    /**
+     * The animation phase in which the callback was invoked, one of
+     * "start" or "done".
+     */
+    phaseName: string;
+    /**
+     * The element to which the animation is attached.
+     */
+    element: any;
+    /**
+     * Internal.
+     */
+    triggerName: string;
+    /**
+     * Internal.
+     */
+    disabled: boolean;
+}
+
+/**
+ * The list of error codes used in runtime code of the `animations` package.
+ * Reserved error code range: 3000-3999.
+ */
+declare const enum RuntimeErrorCode {
+    INVALID_TIMING_VALUE = 3000,
+    INVALID_STYLE_PARAMS = 3001,
+    INVALID_STYLE_VALUE = 3002,
+    INVALID_PARAM_VALUE = 3003,
+    INVALID_NODE_TYPE = 3004,
+    INVALID_CSS_UNIT_VALUE = 3005,
+    INVALID_TRIGGER = 3006,
+    INVALID_DEFINITION = 3007,
+    INVALID_STATE = 3008,
+    INVALID_PROPERTY = 3009,
+    INVALID_PARALLEL_ANIMATION = 3010,
+    INVALID_KEYFRAMES = 3011,
+    INVALID_OFFSET = 3012,
+    INVALID_STAGGER = 3013,
+    INVALID_QUERY = 3014,
+    INVALID_EXPRESSION = 3015,
+    INVALID_TRANSITION_ALIAS = 3016,
+    NEGATIVE_STEP_VALUE = 3100,
+    NEGATIVE_DELAY_VALUE = 3101,
+    KEYFRAME_OFFSETS_OUT_OF_ORDER = 3200,
+    KEYFRAMES_MISSING_OFFSETS = 3202,
+    MISSING_OR_DESTROYED_ANIMATION = 3300,
+    MISSING_PLAYER = 3301,
+    MISSING_TRIGGER = 3302,
+    MISSING_EVENT = 3303,
+    UNSUPPORTED_TRIGGER_EVENT = 3400,
+    UNREGISTERED_TRIGGER = 3401,
+    TRIGGER_TRANSITIONS_FAILED = 3402,
+    TRIGGER_PARSING_FAILED = 3403,
+    TRIGGER_BUILD_FAILED = 3404,
+    VALIDATION_FAILED = 3500,
+    BUILDING_FAILED = 3501,
+    ANIMATION_FAILED = 3502,
+    REGISTRATION_FAILED = 3503,
+    CREATE_ANIMATION_FAILED = 3504,
+    TRANSITION_FAILED = 3505,
+    BROWSER_ANIMATION_BUILDER_INJECTED_WITHOUT_ANIMATIONS = 3600
+}
+
+/**
+ * A programmatic controller for a group of reusable animations.
+ * Used internally to control animations.
+ *
+ * @see {@link AnimationPlayer}
+ * @see {@link animations/group group}
+ *
+ */
+declare class AnimationGroupPlayer implements AnimationPlayer {
+    private _onDoneFns;
+    private _onStartFns;
+    private _finished;
+    private _started;
+    private _destroyed;
+    private _onDestroyFns;
+    parentPlayer: AnimationPlayer | null;
+    totalTime: number;
+    readonly players: AnimationPlayer[];
+    constructor(_players: AnimationPlayer[]);
+    private _onFinish;
+    init(): void;
+    onStart(fn: () => void): void;
+    private _onStart;
+    onDone(fn: () => void): void;
+    onDestroy(fn: () => void): void;
+    hasStarted(): boolean;
+    play(): void;
+    pause(): void;
+    restart(): void;
+    finish(): void;
+    destroy(): void;
+    private _onDestroy;
+    reset(): void;
+    setPosition(p: number): void;
+    getPosition(): number;
+    beforeDestroy(): void;
+}
+
+declare const ɵPRE_STYLE = "!";
+
+export { AnimationBuilder, AnimationFactory, AnimationMetadata, AnimationOptions, AnimationPlayer, AnimationGroupPlayer as ɵAnimationGroupPlayer, BrowserAnimationBuilder as ɵBrowserAnimationBuilder, ɵPRE_STYLE, RuntimeErrorCode as ɵRuntimeErrorCode };
+export type { AnimationEvent };

node_modules/@angular/animations/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@angular/animations",
+  "version": "20.3.11",
+  "description": "Angular - animations integration with web-animations",
+  "author": "angular",
+  "license": "MIT",
+  "engines": {
+    "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "peerDependencies": {
+    "@angular/core": "20.3.11"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/angular/angular.git",
+    "directory": "packages/animations"
+  },
+  "ng-update": {
+    "packageGroup": [
+      "@angular/core",
+      "@angular/bazel",
+      "@angular/common",
+      "@angular/compiler",
+      "@angular/compiler-cli",
+      "@angular/animations",
+      "@angular/elements",
+      "@angular/platform-browser",
+      "@angular/platform-browser-dynamic",
+      "@angular/forms",
+      "@angular/platform-server",
+      "@angular/upgrade",
+      "@angular/router",
+      "@angular/language-service",
+      "@angular/localize",
+      "@angular/service-worker"
+    ]
+  },
+  "sideEffects": false,
+  "module": "./fesm2022/animations.mjs",
+  "typings": "./index.d.ts",
+  "type": "module",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./fesm2022/animations.mjs"
+    },
+    "./browser": {
+      "types": "./browser/index.d.ts",
+      "default": "./fesm2022/browser.mjs"
+    },
+    "./browser/testing": {
+      "types": "./browser/testing/index.d.ts",
+      "default": "./fesm2022/browser/testing.mjs"
+    }
+  }
+}