/* esm-bundle - @angular/platform-browser/animations@18.2.2 - system format - Use of this source code is governed by an MIT-style license that can be found in the LICENSE file at https://angular.io/license */
System.register(['@angular/core', '@angular/platform-browser', '@angular/animations/browser', '@angular/common'], (function (exports) {
    'use strict';
    var i0, Injectable, Inject, NgModule, ANIMATION_MODULE_TYPE, _performanceMarkFeature, RendererFactory2, NgZone, BrowserModule, _DomRendererFactory2, _AnimationEngine, i1, AnimationDriver, _WebAnimationsDriver, NoopAnimationDriver, _AnimationStyleNormalizer, _WebAnimationsStyleNormalizer, _AnimationRendererFactory, DOCUMENT;
    return {
        setters: [function (module) {
            i0 = module;
            Injectable = module.Injectable;
            Inject = module.Inject;
            NgModule = module.NgModule;
            ANIMATION_MODULE_TYPE = module.ANIMATION_MODULE_TYPE;
            _performanceMarkFeature = module.ɵperformanceMarkFeature;
            RendererFactory2 = module.RendererFactory2;
            NgZone = module.NgZone;
            exports("ANIMATION_MODULE_TYPE", module.ANIMATION_MODULE_TYPE);
        }, function (module) {
            BrowserModule = module.BrowserModule;
            _DomRendererFactory2 = module.ɵDomRendererFactory2;
        }, function (module) {
            _AnimationEngine = module.ɵAnimationEngine;
            i1 = module;
            AnimationDriver = module.AnimationDriver;
            _WebAnimationsDriver = module.ɵWebAnimationsDriver;
            NoopAnimationDriver = module.NoopAnimationDriver;
            _AnimationStyleNormalizer = module.ɵAnimationStyleNormalizer;
            _WebAnimationsStyleNormalizer = module.ɵWebAnimationsStyleNormalizer;
            _AnimationRendererFactory = module.ɵAnimationRendererFactory;
        }, function (module) {
            DOCUMENT = module.DOCUMENT;
        }],
        execute: (function () {

            exports({
                provideAnimations: provideAnimations,
                provideNoopAnimations: provideNoopAnimations
            });

            /**
             * @license Angular v18.2.2
             * (c) 2010-2024 Google LLC. https://angular.io/
             * License: MIT
             */

            class InjectableAnimationEngine extends _AnimationEngine {
              // The `ApplicationRef` is injected here explicitly to force the dependency ordering.
              // Since the `ApplicationRef` should be created earlier before the `AnimationEngine`, they
              // both have `ngOnDestroy` hooks and `flush()` must be called after all views are destroyed.
              constructor(doc, driver, normalizer) {
                super(doc, driver, normalizer);
              }
              ngOnDestroy() {
                this.flush();
              }
              static {
                this.ɵfac = function InjectableAnimationEngine_Factory(__ngFactoryType__) {
                  return new (__ngFactoryType__ || InjectableAnimationEngine)(i0.ɵɵinject(DOCUMENT), i0.ɵɵinject(i1.AnimationDriver), i0.ɵɵinject(i1.ɵAnimationStyleNormalizer));
                };
              }
              static {
                this.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({
                  token: InjectableAnimationEngine,
                  factory: InjectableAnimationEngine.ɵfac
                });
              }
            } exports("ɵInjectableAnimationEngine", InjectableAnimationEngine);
            (() => {
              (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(InjectableAnimationEngine, [{
                type: Injectable
              }], () => [{
                type: Document,
                decorators: [{
                  type: Inject,
                  args: [DOCUMENT]
                }]
              }, {
                type: i1.AnimationDriver
              }, {
                type: i1.ɵAnimationStyleNormalizer
              }], null);
            })();
            function instantiateDefaultStyleNormalizer() {
              return new _WebAnimationsStyleNormalizer();
            }
            function instantiateRendererFactory(renderer, engine, zone) {
              return new _AnimationRendererFactory(renderer, engine, zone);
            }
            const SHARED_ANIMATION_PROVIDERS = [{
              provide: _AnimationStyleNormalizer,
              useFactory: instantiateDefaultStyleNormalizer
            }, {
              provide: _AnimationEngine,
              useClass: InjectableAnimationEngine
            }, {
              provide: RendererFactory2,
              useFactory: instantiateRendererFactory,
              deps: [_DomRendererFactory2, _AnimationEngine, NgZone]
            }];
            /**
             * Separate providers from the actual module so that we can do a local modification in Google3 to
             * include them in the BrowserModule.
             */
            const BROWSER_ANIMATIONS_PROVIDERS = [{
              provide: AnimationDriver,
              useFactory: () => new _WebAnimationsDriver()
            }, {
              provide: ANIMATION_MODULE_TYPE,
              useValue: 'BrowserAnimations'
            }, ...SHARED_ANIMATION_PROVIDERS];
            /**
             * Separate providers from the actual module so that we can do a local modification in Google3 to
             * include them in the BrowserTestingModule.
             */
            const BROWSER_NOOP_ANIMATIONS_PROVIDERS = [{
              provide: AnimationDriver,
              useClass: NoopAnimationDriver
            }, {
              provide: ANIMATION_MODULE_TYPE,
              useValue: 'NoopAnimations'
            }, ...SHARED_ANIMATION_PROVIDERS];

            /**
             * Exports `BrowserModule` with additional dependency-injection providers
             * for use with animations. See [Animations](guide/animations).
             * @publicApi
             */
            class BrowserAnimationsModule {
              /**
               * Configures the module based on the specified object.
               *
               * @param config Object used to configure the behavior of the `BrowserAnimationsModule`.
               * @see {@link BrowserAnimationsModuleConfig}
               *
               * @usageNotes
               * When registering the `BrowserAnimationsModule`, you can use the `withConfig`
               * function as follows:
               * ```
               * @NgModule({
               *   imports: [BrowserAnimationsModule.withConfig(config)]
               * })
               * class MyNgModule {}
               * ```
               */
              static withConfig(config) {
                return {
                  ngModule: BrowserAnimationsModule,
                  providers: config.disableAnimations ? BROWSER_NOOP_ANIMATIONS_PROVIDERS : BROWSER_ANIMATIONS_PROVIDERS
                };
              }
              static {
                this.ɵfac = function BrowserAnimationsModule_Factory(__ngFactoryType__) {
                  return new (__ngFactoryType__ || BrowserAnimationsModule)();
                };
              }
              static {
                this.ɵmod = /* @__PURE__ */i0.ɵɵdefineNgModule({
                  type: BrowserAnimationsModule
                });
              }
              static {
                this.ɵinj = /* @__PURE__ */i0.ɵɵdefineInjector({
                  providers: BROWSER_ANIMATIONS_PROVIDERS,
                  imports: [BrowserModule]
                });
              }
            } exports("BrowserAnimationsModule", BrowserAnimationsModule);
            (() => {
              (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(BrowserAnimationsModule, [{
                type: NgModule,
                args: [{
                  exports: [BrowserModule],
                  providers: BROWSER_ANIMATIONS_PROVIDERS
                }]
              }], null, null);
            })();
            /**
             * Returns the set of dependency-injection providers
             * to enable animations in an application. See [animations guide](guide/animations)
             * to learn more about animations in Angular.
             *
             * @usageNotes
             *
             * The function is useful when you want to enable animations in an application
             * bootstrapped using the `bootstrapApplication` function. In this scenario there
             * is no need to import the `BrowserAnimationsModule` NgModule at all, just add
             * providers returned by this function to the `providers` list as show below.
             *
             * ```typescript
             * bootstrapApplication(RootComponent, {
             *   providers: [
             *     provideAnimations()
             *   ]
             * });
             * ```
             *
             * @publicApi
             */
            function provideAnimations() {
              _performanceMarkFeature('NgEagerAnimations');
              // Return a copy to prevent changes to the original array in case any in-place
              // alterations are performed to the `provideAnimations` call results in app code.
              return [...BROWSER_ANIMATIONS_PROVIDERS];
            }
            /**
             * A null player that must be imported to allow disabling of animations.
             * @publicApi
             */
            class NoopAnimationsModule {
              static {
                this.ɵfac = function NoopAnimationsModule_Factory(__ngFactoryType__) {
                  return new (__ngFactoryType__ || NoopAnimationsModule)();
                };
              }
              static {
                this.ɵmod = /* @__PURE__ */i0.ɵɵdefineNgModule({
                  type: NoopAnimationsModule
                });
              }
              static {
                this.ɵinj = /* @__PURE__ */i0.ɵɵdefineInjector({
                  providers: BROWSER_NOOP_ANIMATIONS_PROVIDERS,
                  imports: [BrowserModule]
                });
              }
            } exports("NoopAnimationsModule", NoopAnimationsModule);
            (() => {
              (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(NoopAnimationsModule, [{
                type: NgModule,
                args: [{
                  exports: [BrowserModule],
                  providers: BROWSER_NOOP_ANIMATIONS_PROVIDERS
                }]
              }], null, null);
            })();
            /**
             * Returns the set of dependency-injection providers
             * to disable animations in an application. See [animations guide](guide/animations)
             * to learn more about animations in Angular.
             *
             * @usageNotes
             *
             * The function is useful when you want to bootstrap an application using
             * the `bootstrapApplication` function, but you need to disable animations
             * (for example, when running tests).
             *
             * ```typescript
             * bootstrapApplication(RootComponent, {
             *   providers: [
             *     provideNoopAnimations()
             *   ]
             * });
             * ```
             *
             * @publicApi
             */
            function provideNoopAnimations() {
              // Return a copy to prevent changes to the original array in case any in-place
              // alterations are performed to the `provideNoopAnimations` call results in app code.
              return [...BROWSER_NOOP_ANIMATIONS_PROVIDERS];
            }

        })
    };
}));
//# sourceMappingURL=angular-platform-browser-animations.js.map
