@angular/router
Version:
Angular - the routing library
334 lines • 66.4 kB
JavaScript
/**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.dev/license
*/
import { ɵRuntimeError as RuntimeError } from '@angular/core';
import { from, of } from 'rxjs';
import { catchError, concatMap, defaultIfEmpty, first, last, map, mergeMap, scan, switchMap, tap, } from 'rxjs/operators';
import { AbsoluteRedirect, ApplyRedirects, canLoadFails, noMatch, NoMatch } from './apply_redirects';
import { createUrlTreeFromSnapshot } from './create_url_tree';
import { runCanLoadGuards } from './operators/check_guards';
import { ActivatedRouteSnapshot, getInherited, RouterStateSnapshot, } from './router_state';
import { PRIMARY_OUTLET } from './shared';
import { getOutlet, sortByMatchingOutlets } from './utils/config';
import { emptyPathMatch, match, matchWithChecks, noLeftoversInUrl, split, } from './utils/config_matching';
import { TreeNode } from './utils/tree';
import { isEmptyError } from './utils/type_guards';
/**
* Class used to indicate there were no additional route config matches but that all segments of
* the URL were consumed during matching so the route was URL matched. When this happens, we still
* try to match child configs in case there are empty path children.
*/
class NoLeftoversInUrl {
}
export function recognize(injector, configLoader, rootComponentType, config, urlTree, urlSerializer, paramsInheritanceStrategy = 'emptyOnly') {
return new Recognizer(injector, configLoader, rootComponentType, config, urlTree, paramsInheritanceStrategy, urlSerializer).recognize();
}
const MAX_ALLOWED_REDIRECTS = 31;
export class Recognizer {
constructor(injector, configLoader, rootComponentType, config, urlTree, paramsInheritanceStrategy, urlSerializer) {
this.injector = injector;
this.configLoader = configLoader;
this.rootComponentType = rootComponentType;
this.config = config;
this.urlTree = urlTree;
this.paramsInheritanceStrategy = paramsInheritanceStrategy;
this.urlSerializer = urlSerializer;
this.applyRedirects = new ApplyRedirects(this.urlSerializer, this.urlTree);
this.absoluteRedirectCount = 0;
this.allowRedirects = true;
}
noMatchError(e) {
return new RuntimeError(4002 /* RuntimeErrorCode.NO_MATCH */, typeof ngDevMode === 'undefined' || ngDevMode
? `Cannot match any routes. URL Segment: '${e.segmentGroup}'`
: `'${e.segmentGroup}'`);
}
recognize() {
const rootSegmentGroup = split(this.urlTree.root, [], [], this.config).segmentGroup;
return this.match(rootSegmentGroup).pipe(map(({ children, rootSnapshot }) => {
const rootNode = new TreeNode(rootSnapshot, children);
const routeState = new RouterStateSnapshot('', rootNode);
const tree = createUrlTreeFromSnapshot(rootSnapshot, [], this.urlTree.queryParams, this.urlTree.fragment);
// https://github.com/angular/angular/issues/47307
// Creating the tree stringifies the query params
// We don't want to do this here so reassign them to the original.
tree.queryParams = this.urlTree.queryParams;
routeState.url = this.urlSerializer.serialize(tree);
return { state: routeState, tree };
}));
}
match(rootSegmentGroup) {
// Use Object.freeze to prevent readers of the Router state from modifying it outside
// of a navigation, resulting in the router being out of sync with the browser.
const rootSnapshot = new ActivatedRouteSnapshot([], Object.freeze({}), Object.freeze({ ...this.urlTree.queryParams }), this.urlTree.fragment, Object.freeze({}), PRIMARY_OUTLET, this.rootComponentType, null, {});
return this.processSegmentGroup(this.injector, this.config, rootSegmentGroup, PRIMARY_OUTLET, rootSnapshot).pipe(map((children) => {
return { children, rootSnapshot };
}), catchError((e) => {
if (e instanceof AbsoluteRedirect) {
this.urlTree = e.urlTree;
return this.match(e.urlTree.root);
}
if (e instanceof NoMatch) {
throw this.noMatchError(e);
}
throw e;
}));
}
processSegmentGroup(injector, config, segmentGroup, outlet, parentRoute) {
if (segmentGroup.segments.length === 0 && segmentGroup.hasChildren()) {
return this.processChildren(injector, config, segmentGroup, parentRoute);
}
return this.processSegment(injector, config, segmentGroup, segmentGroup.segments, outlet, true, parentRoute).pipe(map((child) => (child instanceof TreeNode ? [child] : [])));
}
/**
* Matches every child outlet in the `segmentGroup` to a `Route` in the config. Returns `null` if
* we cannot find a match for _any_ of the children.
*
* @param config - The `Routes` to match against
* @param segmentGroup - The `UrlSegmentGroup` whose children need to be matched against the
* config.
*/
processChildren(injector, config, segmentGroup, parentRoute) {
// Expand outlets one at a time, starting with the primary outlet. We need to do it this way
// because an absolute redirect from the primary outlet takes precedence.
const childOutlets = [];
for (const child of Object.keys(segmentGroup.children)) {
if (child === 'primary') {
childOutlets.unshift(child);
}
else {
childOutlets.push(child);
}
}
return from(childOutlets).pipe(concatMap((childOutlet) => {
const child = segmentGroup.children[childOutlet];
// Sort the config so that routes with outlets that match the one being activated
// appear first, followed by routes for other outlets, which might match if they have
// an empty path.
const sortedConfig = sortByMatchingOutlets(config, childOutlet);
return this.processSegmentGroup(injector, sortedConfig, child, childOutlet, parentRoute);
}), scan((children, outletChildren) => {
children.push(...outletChildren);
return children;
}), defaultIfEmpty(null), last(), mergeMap((children) => {
if (children === null)
return noMatch(segmentGroup);
// Because we may have matched two outlets to the same empty path segment, we can have
// multiple activated results for the same outlet. We should merge the children of
// these results so the final return value is only one `TreeNode` per outlet.
const mergedChildren = mergeEmptyPathMatches(children);
if (typeof ngDevMode === 'undefined' || ngDevMode) {
// This should really never happen - we are only taking the first match for each
// outlet and merge the empty path matches.
checkOutletNameUniqueness(mergedChildren);
}
sortActivatedRouteSnapshots(mergedChildren);
return of(mergedChildren);
}));
}
processSegment(injector, routes, segmentGroup, segments, outlet, allowRedirects, parentRoute) {
return from(routes).pipe(concatMap((r) => {
return this.processSegmentAgainstRoute(r._injector ?? injector, routes, r, segmentGroup, segments, outlet, allowRedirects, parentRoute).pipe(catchError((e) => {
if (e instanceof NoMatch) {
return of(null);
}
throw e;
}));
}), first((x) => !!x), catchError((e) => {
if (isEmptyError(e)) {
if (noLeftoversInUrl(segmentGroup, segments, outlet)) {
return of(new NoLeftoversInUrl());
}
return noMatch(segmentGroup);
}
throw e;
}));
}
processSegmentAgainstRoute(injector, routes, route, rawSegment, segments, outlet, allowRedirects, parentRoute) {
// We allow matches to empty paths when the outlets differ so we can match a url like `/(b:b)` to
// a config like
// * `{path: '', children: [{path: 'b', outlet: 'b'}]}`
// or even
// * `{path: '', outlet: 'a', children: [{path: 'b', outlet: 'b'}]`
//
// The exception here is when the segment outlet is for the primary outlet. This would
// result in a match inside the named outlet because all children there are written as primary
// outlets. So we need to prevent child named outlet matches in a url like `/b` in a config like
// * `{path: '', outlet: 'x' children: [{path: 'b'}]}`
// This should only match if the url is `/(x:b)`.
if (getOutlet(route) !== outlet &&
(outlet === PRIMARY_OUTLET || !emptyPathMatch(rawSegment, segments, route))) {
return noMatch(rawSegment);
}
if (route.redirectTo === undefined) {
return this.matchSegmentAgainstRoute(injector, rawSegment, route, segments, outlet, parentRoute);
}
if (this.allowRedirects && allowRedirects) {
return this.expandSegmentAgainstRouteUsingRedirect(injector, rawSegment, routes, route, segments, outlet, parentRoute);
}
return noMatch(rawSegment);
}
expandSegmentAgainstRouteUsingRedirect(injector, segmentGroup, routes, route, segments, outlet, parentRoute) {
const { matched, parameters, consumedSegments, positionalParamSegments, remainingSegments } = match(segmentGroup, route, segments);
if (!matched)
return noMatch(segmentGroup);
// TODO(atscott): Move all of this under an if(ngDevMode) as a breaking change and allow stack
// size exceeded in production
if (typeof route.redirectTo === 'string' && route.redirectTo[0] === '/') {
this.absoluteRedirectCount++;
if (this.absoluteRedirectCount > MAX_ALLOWED_REDIRECTS) {
if (ngDevMode) {
throw new RuntimeError(4016 /* RuntimeErrorCode.INFINITE_REDIRECT */, `Detected possible infinite redirect when redirecting from '${this.urlTree}' to '${route.redirectTo}'.\n` +
`This is currently a dev mode only error but will become a` +
` call stack size exceeded error in production in a future major version.`);
}
this.allowRedirects = false;
}
}
const currentSnapshot = new ActivatedRouteSnapshot(segments, parameters, Object.freeze({ ...this.urlTree.queryParams }), this.urlTree.fragment, getData(route), getOutlet(route), route.component ?? route._loadedComponent ?? null, route, getResolve(route));
const inherited = getInherited(currentSnapshot, parentRoute, this.paramsInheritanceStrategy);
currentSnapshot.params = Object.freeze(inherited.params);
currentSnapshot.data = Object.freeze(inherited.data);
const newTree = this.applyRedirects.applyRedirectCommands(consumedSegments, route.redirectTo, positionalParamSegments, currentSnapshot, injector);
return this.applyRedirects.lineralizeSegments(route, newTree).pipe(mergeMap((newSegments) => {
return this.processSegment(injector, routes, segmentGroup, newSegments.concat(remainingSegments), outlet, false, parentRoute);
}));
}
matchSegmentAgainstRoute(injector, rawSegment, route, segments, outlet, parentRoute) {
const matchResult = matchWithChecks(rawSegment, route, segments, injector, this.urlSerializer);
if (route.path === '**') {
// Prior versions of the route matching algorithm would stop matching at the wildcard route.
// We should investigate a better strategy for any existing children. Otherwise, these
// child segments are silently dropped from the navigation.
// https://github.com/angular/angular/issues/40089
rawSegment.children = {};
}
return matchResult.pipe(switchMap((result) => {
if (!result.matched) {
return noMatch(rawSegment);
}
// If the route has an injector created from providers, we should start using that.
injector = route._injector ?? injector;
return this.getChildConfig(injector, route, segments).pipe(switchMap(({ routes: childConfig }) => {
const childInjector = route._loadedInjector ?? injector;
const { parameters, consumedSegments, remainingSegments } = result;
const snapshot = new ActivatedRouteSnapshot(consumedSegments, parameters, Object.freeze({ ...this.urlTree.queryParams }), this.urlTree.fragment, getData(route), getOutlet(route), route.component ?? route._loadedComponent ?? null, route, getResolve(route));
const inherited = getInherited(snapshot, parentRoute, this.paramsInheritanceStrategy);
snapshot.params = Object.freeze(inherited.params);
snapshot.data = Object.freeze(inherited.data);
const { segmentGroup, slicedSegments } = split(rawSegment, consumedSegments, remainingSegments, childConfig);
if (slicedSegments.length === 0 && segmentGroup.hasChildren()) {
return this.processChildren(childInjector, childConfig, segmentGroup, snapshot).pipe(map((children) => {
return new TreeNode(snapshot, children);
}));
}
if (childConfig.length === 0 && slicedSegments.length === 0) {
return of(new TreeNode(snapshot, []));
}
const matchedOnOutlet = getOutlet(route) === outlet;
// If we matched a config due to empty path match on a different outlet, we need to
// continue passing the current outlet for the segment rather than switch to PRIMARY.
// Note that we switch to primary when we have a match because outlet configs look like
// this: {path: 'a', outlet: 'a', children: [
// {path: 'b', component: B},
// {path: 'c', component: C},
// ]}
// Notice that the children of the named outlet are configured with the primary outlet
return this.processSegment(childInjector, childConfig, segmentGroup, slicedSegments, matchedOnOutlet ? PRIMARY_OUTLET : outlet, true, snapshot).pipe(map((child) => {
return new TreeNode(snapshot, child instanceof TreeNode ? [child] : []);
}));
}));
}));
}
getChildConfig(injector, route, segments) {
if (route.children) {
// The children belong to the same module
return of({ routes: route.children, injector });
}
if (route.loadChildren) {
// lazy children belong to the loaded module
if (route._loadedRoutes !== undefined) {
return of({ routes: route._loadedRoutes, injector: route._loadedInjector });
}
return runCanLoadGuards(injector, route, segments, this.urlSerializer).pipe(mergeMap((shouldLoadResult) => {
if (shouldLoadResult) {
return this.configLoader.loadChildren(injector, route).pipe(tap((cfg) => {
route._loadedRoutes = cfg.routes;
route._loadedInjector = cfg.injector;
}));
}
return canLoadFails(route);
}));
}
return of({ routes: [], injector });
}
}
function sortActivatedRouteSnapshots(nodes) {
nodes.sort((a, b) => {
if (a.value.outlet === PRIMARY_OUTLET)
return -1;
if (b.value.outlet === PRIMARY_OUTLET)
return 1;
return a.value.outlet.localeCompare(b.value.outlet);
});
}
function hasEmptyPathConfig(node) {
const config = node.value.routeConfig;
return config && config.path === '';
}
/**
* Finds `TreeNode`s with matching empty path route configs and merges them into `TreeNode` with
* the children from each duplicate. This is necessary because different outlets can match a
* single empty path route config and the results need to then be merged.
*/
function mergeEmptyPathMatches(nodes) {
const result = [];
// The set of nodes which contain children that were merged from two duplicate empty path nodes.
const mergedNodes = new Set();
for (const node of nodes) {
if (!hasEmptyPathConfig(node)) {
result.push(node);
continue;
}
const duplicateEmptyPathNode = result.find((resultNode) => node.value.routeConfig === resultNode.value.routeConfig);
if (duplicateEmptyPathNode !== undefined) {
duplicateEmptyPathNode.children.push(...node.children);
mergedNodes.add(duplicateEmptyPathNode);
}
else {
result.push(node);
}
}
// For each node which has children from multiple sources, we need to recompute a new `TreeNode`
// by also merging those children. This is necessary when there are multiple empty path configs
// in a row. Put another way: whenever we combine children of two nodes, we need to also check
// if any of those children can be combined into a single node as well.
for (const mergedNode of mergedNodes) {
const mergedChildren = mergeEmptyPathMatches(mergedNode.children);
result.push(new TreeNode(mergedNode.value, mergedChildren));
}
return result.filter((n) => !mergedNodes.has(n));
}
function checkOutletNameUniqueness(nodes) {
const names = {};
nodes.forEach((n) => {
const routeWithSameOutletName = names[n.value.outlet];
if (routeWithSameOutletName) {
const p = routeWithSameOutletName.url.map((s) => s.toString()).join('/');
const c = n.value.url.map((s) => s.toString()).join('/');
throw new RuntimeError(4006 /* RuntimeErrorCode.TWO_SEGMENTS_WITH_SAME_OUTLET */, (typeof ngDevMode === 'undefined' || ngDevMode) &&
`Two segments cannot have the same outlet name: '${p}' and '${c}'.`);
}
names[n.value.outlet] = n.value;
});
}
function getData(route) {
return route.data || {};
}
function getResolve(route) {
return route.resolve || {};
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recognize.js","sourceRoot":"","sources":["../../../../../../packages/router/src/recognize.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.dev/license\n */\n\nimport {EnvironmentInjector, Type, ɵRuntimeError as RuntimeError} from '@angular/core';\nimport {from, Observable, of} from 'rxjs';\nimport {\n  catchError,\n  concatMap,\n  defaultIfEmpty,\n  first,\n  last,\n  map,\n  mergeMap,\n  scan,\n  switchMap,\n  tap,\n} from 'rxjs/operators';\n\nimport {AbsoluteRedirect, ApplyRedirects, canLoadFails, noMatch, NoMatch} from './apply_redirects';\nimport {createUrlTreeFromSnapshot} from './create_url_tree';\nimport {RuntimeErrorCode} from './errors';\nimport {Data, LoadedRouterConfig, ResolveData, Route, Routes} from './models';\nimport {runCanLoadGuards} from './operators/check_guards';\nimport {RouterConfigLoader} from './router_config_loader';\nimport {\n  ActivatedRouteSnapshot,\n  getInherited,\n  ParamsInheritanceStrategy,\n  RouterStateSnapshot,\n} from './router_state';\nimport {PRIMARY_OUTLET} from './shared';\nimport {UrlSegment, UrlSegmentGroup, UrlSerializer, UrlTree} from './url_tree';\nimport {getOutlet, sortByMatchingOutlets} from './utils/config';\nimport {\n  emptyPathMatch,\n  match,\n  matchWithChecks,\n  noLeftoversInUrl,\n  split,\n} from './utils/config_matching';\nimport {TreeNode} from './utils/tree';\nimport {isEmptyError} from './utils/type_guards';\n\n/**\n * Class used to indicate there were no additional route config matches but that all segments of\n * the URL were consumed during matching so the route was URL matched. When this happens, we still\n * try to match child configs in case there are empty path children.\n */\nclass NoLeftoversInUrl {}\n\nexport function recognize(\n  injector: EnvironmentInjector,\n  configLoader: RouterConfigLoader,\n  rootComponentType: Type<any> | null,\n  config: Routes,\n  urlTree: UrlTree,\n  urlSerializer: UrlSerializer,\n  paramsInheritanceStrategy: ParamsInheritanceStrategy = 'emptyOnly',\n): Observable<{state: RouterStateSnapshot; tree: UrlTree}> {\n  return new Recognizer(\n    injector,\n    configLoader,\n    rootComponentType,\n    config,\n    urlTree,\n    paramsInheritanceStrategy,\n    urlSerializer,\n  ).recognize();\n}\n\nconst MAX_ALLOWED_REDIRECTS = 31;\n\nexport class Recognizer {\n  private applyRedirects = new ApplyRedirects(this.urlSerializer, this.urlTree);\n  private absoluteRedirectCount = 0;\n  allowRedirects = true;\n\n  constructor(\n    private injector: EnvironmentInjector,\n    private configLoader: RouterConfigLoader,\n    private rootComponentType: Type<any> | null,\n    private config: Routes,\n    private urlTree: UrlTree,\n    private paramsInheritanceStrategy: ParamsInheritanceStrategy,\n    private readonly urlSerializer: UrlSerializer,\n  ) {}\n\n  private noMatchError(e: NoMatch): RuntimeError<RuntimeErrorCode.NO_MATCH> {\n    return new RuntimeError(\n      RuntimeErrorCode.NO_MATCH,\n      typeof ngDevMode === 'undefined' || ngDevMode\n        ? `Cannot match any routes. URL Segment: '${e.segmentGroup}'`\n        : `'${e.segmentGroup}'`,\n    );\n  }\n\n  recognize(): Observable<{state: RouterStateSnapshot; tree: UrlTree}> {\n    const rootSegmentGroup = split(this.urlTree.root, [], [], this.config).segmentGroup;\n\n    return this.match(rootSegmentGroup).pipe(\n      map(({children, rootSnapshot}) => {\n        const rootNode = new TreeNode(rootSnapshot, children);\n        const routeState = new RouterStateSnapshot('', rootNode);\n        const tree = createUrlTreeFromSnapshot(\n          rootSnapshot,\n          [],\n          this.urlTree.queryParams,\n          this.urlTree.fragment,\n        );\n        // https://github.com/angular/angular/issues/47307\n        // Creating the tree stringifies the query params\n        // We don't want to do this here so reassign them to the original.\n        tree.queryParams = this.urlTree.queryParams;\n        routeState.url = this.urlSerializer.serialize(tree);\n        return {state: routeState, tree};\n      }),\n    );\n  }\n\n  private match(rootSegmentGroup: UrlSegmentGroup): Observable<{\n    children: TreeNode<ActivatedRouteSnapshot>[];\n    rootSnapshot: ActivatedRouteSnapshot;\n  }> {\n    // Use Object.freeze to prevent readers of the Router state from modifying it outside\n    // of a navigation, resulting in the router being out of sync with the browser.\n    const rootSnapshot = new ActivatedRouteSnapshot(\n      [],\n      Object.freeze({}),\n      Object.freeze({...this.urlTree.queryParams}),\n      this.urlTree.fragment,\n      Object.freeze({}),\n      PRIMARY_OUTLET,\n      this.rootComponentType,\n      null,\n      {},\n    );\n    return this.processSegmentGroup(\n      this.injector,\n      this.config,\n      rootSegmentGroup,\n      PRIMARY_OUTLET,\n      rootSnapshot,\n    ).pipe(\n      map((children) => {\n        return {children, rootSnapshot};\n      }),\n      catchError((e: any) => {\n        if (e instanceof AbsoluteRedirect) {\n          this.urlTree = e.urlTree;\n          return this.match(e.urlTree.root);\n        }\n        if (e instanceof NoMatch) {\n          throw this.noMatchError(e);\n        }\n\n        throw e;\n      }),\n    );\n  }\n\n  processSegmentGroup(\n    injector: EnvironmentInjector,\n    config: Route[],\n    segmentGroup: UrlSegmentGroup,\n    outlet: string,\n    parentRoute: ActivatedRouteSnapshot,\n  ): Observable<TreeNode<ActivatedRouteSnapshot>[]> {\n    if (segmentGroup.segments.length === 0 && segmentGroup.hasChildren()) {\n      return this.processChildren(injector, config, segmentGroup, parentRoute);\n    }\n\n    return this.processSegment(\n      injector,\n      config,\n      segmentGroup,\n      segmentGroup.segments,\n      outlet,\n      true,\n      parentRoute,\n    ).pipe(map((child) => (child instanceof TreeNode ? [child] : [])));\n  }\n\n  /**\n   * Matches every child outlet in the `segmentGroup` to a `Route` in the config. Returns `null` if\n   * we cannot find a match for _any_ of the children.\n   *\n   * @param config - The `Routes` to match against\n   * @param segmentGroup - The `UrlSegmentGroup` whose children need to be matched against the\n   *     config.\n   */\n  processChildren(\n    injector: EnvironmentInjector,\n    config: Route[],\n    segmentGroup: UrlSegmentGroup,\n    parentRoute: ActivatedRouteSnapshot,\n  ): Observable<TreeNode<ActivatedRouteSnapshot>[]> {\n    // Expand outlets one at a time, starting with the primary outlet. We need to do it this way\n    // because an absolute redirect from the primary outlet takes precedence.\n    const childOutlets: string[] = [];\n    for (const child of Object.keys(segmentGroup.children)) {\n      if (child === 'primary') {\n        childOutlets.unshift(child);\n      } else {\n        childOutlets.push(child);\n      }\n    }\n    return from(childOutlets).pipe(\n      concatMap((childOutlet) => {\n        const child = segmentGroup.children[childOutlet];\n        // Sort the config so that routes with outlets that match the one being activated\n        // appear first, followed by routes for other outlets, which might match if they have\n        // an empty path.\n        const sortedConfig = sortByMatchingOutlets(config, childOutlet);\n        return this.processSegmentGroup(injector, sortedConfig, child, childOutlet, parentRoute);\n      }),\n      scan((children, outletChildren) => {\n        children.push(...outletChildren);\n        return children;\n      }),\n      defaultIfEmpty(null as TreeNode<ActivatedRouteSnapshot>[] | null),\n      last(),\n      mergeMap((children) => {\n        if (children === null) return noMatch(segmentGroup);\n        // Because we may have matched two outlets to the same empty path segment, we can have\n        // multiple activated results for the same outlet. We should merge the children of\n        // these results so the final return value is only one `TreeNode` per outlet.\n        const mergedChildren = mergeEmptyPathMatches(children);\n        if (typeof ngDevMode === 'undefined' || ngDevMode) {\n          // This should really never happen - we are only taking the first match for each\n          // outlet and merge the empty path matches.\n          checkOutletNameUniqueness(mergedChildren);\n        }\n        sortActivatedRouteSnapshots(mergedChildren);\n        return of(mergedChildren);\n      }),\n    );\n  }\n\n  processSegment(\n    injector: EnvironmentInjector,\n    routes: Route[],\n    segmentGroup: UrlSegmentGroup,\n    segments: UrlSegment[],\n    outlet: string,\n    allowRedirects: boolean,\n    parentRoute: ActivatedRouteSnapshot,\n  ): Observable<TreeNode<ActivatedRouteSnapshot> | NoLeftoversInUrl> {\n    return from(routes).pipe(\n      concatMap((r) => {\n        return this.processSegmentAgainstRoute(\n          r._injector ?? injector,\n          routes,\n          r,\n          segmentGroup,\n          segments,\n          outlet,\n          allowRedirects,\n          parentRoute,\n        ).pipe(\n          catchError((e: any) => {\n            if (e instanceof NoMatch) {\n              return of(null);\n            }\n            throw e;\n          }),\n        );\n      }),\n      first((x): x is TreeNode<ActivatedRouteSnapshot> | NoLeftoversInUrl => !!x),\n      catchError((e) => {\n    