if (typeof ngDevMode === 'undefined' || ngDevMode) {

// Publish this util when the router is provided so that the devtools can use it.

ɵpublishNonCoreGlobalUtil('ɵgetLoadedRoutes', getLoadedRoutes);

ɵpublishNonCoreGlobalUtil('ɵgetRouterInstance', getRouterInstance);

ɵpublishNonCoreGlobalUtil('ɵnavigateByUrl', navigateByUrl);

}

return makeEnvironmentProviders([

{provide: ROUTES, multi: true, useValue: routes},

{provide: ActivatedRoute, useFactory: rootRoute},

{provide: APP_BOOTSTRAP_LISTENER, multi: true, useFactory: getBootstrapListener},

features.map((feature) => feature.ɵproviders),

]);

kind: FeatureKind,

providers: Array<Provider | EnvironmentProviders>,

): RouterFeature<FeatureKind> {

return {ɵkind: kind, ɵproviders: providers};

options: InMemoryScrollingOptions = {},

): InMemoryScrollingFeature {

const providers = [

{

provide: ROUTER_SCROLLER,

useFactory: () => new RouterScroller(options),

},

];

return routerFeature(RouterFeatureKind.InMemoryScrollingFeature, providers);

const devModeLocationCheck =

typeof ngDevMode === 'undefined' || ngDevMode

? [

provideEnvironmentInitializer(() => {

const locationInstance = inject(Location);

if (!(locationInstance instanceof ɵNavigationAdapterForLocation)) {

const locationConstructorName = (locationInstance as any).constructor.name;

let message =

`'withExperimentalPlatformNavigation' provides a 'Location' implementation that ensures navigation APIs are consistently used.` +

` An instance of ${locationConstructorName} was found instead.`;

if (locationConstructorName === 'SpyLocation') {

message += ` One of 'RouterTestingModule' or 'provideLocationMocks' was likely used. 'withExperimentalPlatformNavigation' does not work with these because they override the Location implementation.`;

}

throw new Error(message);

}

}),

]

: [];

const providers = [

{provide: StateManager, useExisting: NavigationStateManager},

{provide: Location, useClass: ɵNavigationAdapterForLocation},

devModeLocationCheck,

];

return routerFeature(RouterFeatureKind.ExperimentalPlatformNavigationFeature, providers);

const injector = inject(Injector);

return (bootstrappedComponentRef: ComponentRef<unknown>) => {

const ref = injector.get(ApplicationRef);

if (bootstrappedComponentRef !== ref.components[0]) {

return;

}

const router = injector.get(Router);

const bootstrapDone = injector.get(BOOTSTRAP_DONE);

if (injector.get(INITIAL_NAVIGATION) === InitialNavigation.EnabledNonBlocking) {

router.initialNavigation();

}

injector.get(ROUTER_PRELOADER, null, {optional: true})?.setUpPreloading();

injector.get(ROUTER_SCROLLER, null, {optional: true})?.init();

router.resetRootComponentType(ref.componentTypes[0]);

if (!bootstrapDone.closed) {

bootstrapDone.next();

bootstrapDone.complete();

bootstrapDone.unsubscribe();

}

};

EnabledBlocking,

EnabledNonBlocking,

Disabled,

const providers = [

{provide: IS_ENABLED_BLOCKING_INITIAL_NAVIGATION, useValue: true},

{provide: INITIAL_NAVIGATION, useValue: InitialNavigation.EnabledBlocking},

provideAppInitializer(() => {

const injector = inject(Injector);

const locationInitialized: Promise<any> = injector.get(

LOCATION_INITIALIZED,

Promise.resolve(),

);

return locationInitialized.then(() => {

return new Promise((resolve) => {

const router = injector.get(Router);

const bootstrapDone = injector.get(BOOTSTRAP_DONE);

afterNextNavigation(router, () => {

// Unblock APP_INITIALIZER in case the initial navigation was canceled or errored

// without a redirect.

resolve(true);

});

injector.get(NavigationTransitions).afterPreactivation = () => {

// Unblock APP_INITIALIZER once we get to `afterPreactivation`. At this point, we

// assume activation will complete successfully (even though this is not

// guaranteed).

resolve(true);

return bootstrapDone.closed ? of(void 0) : bootstrapDone;

};

router.initialNavigation();

});

});

}),

];

return routerFeature(RouterFeatureKind.EnabledBlockingInitialNavigationFeature, providers);

const providers = [

provideAppInitializer(() => {

inject(Router).setUpLocationChangeListener();

}),

{provide: INITIAL_NAVIGATION, useValue: InitialNavigation.Disabled},

];

return routerFeature(RouterFeatureKind.DisabledInitialNavigationFeature, providers);

let providers: Provider[] = [];

if (typeof ngDevMode === 'undefined' || ngDevMode) {

providers = [

{

provide: ENVIRONMENT_INITIALIZER,

multi: true,

useFactory: () => {

const router = inject(Router);

return () =>

router.events.subscribe((e: Event) => {

// tslint:disable:no-console

console.group?.(`Router Event: ${(<any>e.constructor).name}`);

console.log(stringifyEvent(e));

console.log(e);

console.groupEnd?.();

// tslint:enable:no-console

});

},

},

];

} else {

providers = [];

}

return routerFeature(RouterFeatureKind.DebugTracingFeature, providers);

const providers = [

{provide: ROUTER_PRELOADER, useExisting: RouterPreloader},

{provide: PreloadingStrategy, useExisting: preloadingStrategy},

];

return routerFeature(RouterFeatureKind.PreloadingFeature, providers);

handler: (error: NavigationError) => unknown | RedirectCommand,

): NavigationErrorHandlerFeature {

const providers = [

{

provide: NAVIGATION_ERROR_HANDLER,

useValue: handler,

},

];

return routerFeature(RouterFeatureKind.NavigationErrorHandlerFeature, providers);

return routerFeature(RouterFeatureKind.AutoCleanupInjectorsFeature, [

{provide: ROUTE_INJECTOR_CLEANUP, useValue: routeInjectorCleanup},

]);

options: ComponentInputBindingOptions = {},

): ComponentInputBindingFeature {

const providers = [

{

provide: INPUT_BINDER,

useFactory: () =>

new RoutedComponentInputBinder(options, inject(ROUTER_RESOURCES_FEATURE, {optional: true})),

},

];

return routerFeature(RouterFeatureKind.ComponentInputBindingFeature, providers);

options?: ViewTransitionsFeatureOptions,

): ViewTransitionsFeature {

performanceMarkFeature('NgRouterViewTransitions');

const providers = [

{provide: CREATE_VIEW_TRANSITION, useValue: createViewTransition},

{

provide: VIEW_TRANSITION_OPTIONS,

useValue: {skipNextTransition: !!options?.skipInitialTransition, ...options},

},

];

return routerFeature(RouterFeatureKind.ViewTransitionsFeature, providers);

const providers = [

{

provide: ROUTER_RESOURCES_FEATURE,

useValue: {

setupAndRunResources,

createResourceOutletBindingEffects,

},

},

];

return routerFeature(RouterFeatureKind.RouterResourcesFeature, providers);

| PreloadingFeature

| DebugTracingFeature

| InitialNavigationFeature

| InMemoryScrollingFeature

| RouterConfigurationFeature

| NavigationErrorHandlerFeature

| ComponentInputBindingFeature

| ViewTransitionsFeature

| AutoCleanupInjectorsFeature

| RouterHashLocationFeature

| ExperimentalPlatformNavigationFeature

PreloadingFeature,

DebugTracingFeature,

EnabledBlockingInitialNavigationFeature,

DisabledInitialNavigationFeature,

InMemoryScrollingFeature,

RouterConfigurationFeature,

RouterHashLocationFeature,

NavigationErrorHandlerFeature,

ComponentInputBindingFeature,

ViewTransitionsFeature,

AutoCleanupInjectorsFeature,

ExperimentalPlatformNavigationFeature,

RouterResourcesFeature,