@angular/router 14.0.1 → 14.1.0-next.0

package/fesm2020/router.mjs

@@ -1,14 +1,14 @@
 /**
- * @license Angular v14.0.1
+ * @license Angular v14.1.0-next.0
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
 
-import * as i3 from '@angular/common';
-import { Location, LocationStrategy, PlatformLocation, APP_BASE_HREF, ViewportScroller, HashLocationStrategy, PathLocationStrategy, LOCATION_INITIALIZED } from '@angular/common';
 import * as i0 from '@angular/core';
 import { ɵisObservable, ɵisPromise, EventEmitter, Directive, Attribute, Output, Component, createEnvironmentInjector, ɵisStandalone, ComponentFactoryResolver, InjectionToken, InjectFlags, NgModuleFactory, Injectable, NgModuleRef, ɵConsole, NgZone, ɵcoerceToBoolean, Input, HostListener, HostBinding, Optional, ContentChildren, Injector, Compiler, NgProbeToken, ANALYZE_FOR_ENTRY_COMPONENTS, SkipSelf, Inject, APP_INITIALIZER, APP_BOOTSTRAP_LISTENER, NgModule, ApplicationRef, Version } from '@angular/core';
 import { from, of, BehaviorSubject, combineLatest, throwError, EmptyError, concat, defer, Observable, EMPTY, ConnectableObservable, Subject } from 'rxjs';
+import * as i3 from '@angular/common';
+import { Location, LocationStrategy, PlatformLocation, APP_BASE_HREF, ViewportScroller, HashLocationStrategy, PathLocationStrategy, LOCATION_INITIALIZED } from '@angular/common';
 import { map, switchMap, take, startWith, scan, filter, catchError, concatMap, last as last$1, first, mergeMap, tap, takeLast, mapTo, finalize, refCount, defaultIfEmpty, mergeAll } from 'rxjs/operators';
 import * as i1 from '@angular/platform-browser';
 
@@ -20,627 +20,782 @@ import * as i1 from '@angular/platform-browser';
  * found in the LICENSE file at https://angular.io/license
  */
 /**
- * Base for events the router goes through, as opposed to events tied to a specific
- * route. Fired one time for any given navigation.
- *
- * The following code shows how a class subscribes to router events.
- *
- * ```ts
- * import {Event, RouterEvent, Router} from '@angular/router';
- *
- * class MyService {
- *   constructor(public router: Router) {
- *     router.events.pipe(
- *        filter((e: Event): e is RouterEvent => e instanceof RouterEvent)
- *     ).subscribe((e: RouterEvent) => {
- *       // Do something
- *     });
- *   }
- * }
- * ```
+ * The primary routing outlet.
  *
- * @see `Event`
- * @see [Router events summary](guide/router-reference#router-events)
  * @publicApi
  */
-class RouterEvent {
-    constructor(
-    /** A unique ID that the router assigns to every router navigation. */
-    id, 
-    /** The URL that is the destination for this navigation. */
-    url) {
-        this.id = id;
-        this.url = url;
+const PRIMARY_OUTLET = 'primary';
+class ParamsAsMap {
+    constructor(params) {
+        this.params = params || {};
+    }
+    has(name) {
+        return Object.prototype.hasOwnProperty.call(this.params, name);
+    }
+    get(name) {
+        if (this.has(name)) {
+            const v = this.params[name];
+            return Array.isArray(v) ? v[0] : v;
+        }
+        return null;
+    }
+    getAll(name) {
+        if (this.has(name)) {
+            const v = this.params[name];
+            return Array.isArray(v) ? v : [v];
+        }
+        return [];
+    }
+    get keys() {
+        return Object.keys(this.params);
     }
 }
 /**
- * An event triggered when a navigation starts.
+ * Converts a `Params` instance to a `ParamMap`.
+ * @param params The instance to convert.
+ * @returns The new map instance.
  *
  * @publicApi
  */
-class NavigationStart extends RouterEvent {
-    constructor(
-    /** @docsNotRequired */
-    id, 
-    /** @docsNotRequired */
-    url, 
-    /** @docsNotRequired */
-    navigationTrigger = 'imperative', 
-    /** @docsNotRequired */
-    restoredState = null) {
-        super(id, url);
-        this.type = 0 /* EventType.NavigationStart */;
-        this.navigationTrigger = navigationTrigger;
-        this.restoredState = restoredState;
+function convertToParamMap(params) {
+    return new ParamsAsMap(params);
+}
+const NAVIGATION_CANCELING_ERROR = 'ngNavigationCancelingError';
+function navigationCancelingError(message) {
+    const error = Error('NavigationCancelingError: ' + message);
+    error[NAVIGATION_CANCELING_ERROR] = true;
+    return error;
+}
+function isNavigationCancelingError(error) {
+    return error && error[NAVIGATION_CANCELING_ERROR];
+}
+// Matches the route configuration (`route`) against the actual URL (`segments`).
+function defaultUrlMatcher(segments, segmentGroup, route) {
+    const parts = route.path.split('/');
+    if (parts.length > segments.length) {
+        // The actual URL is shorter than the config, no match
+        return null;
     }
-    /** @docsNotRequired */
-    toString() {
-        return `NavigationStart(id: ${this.id}, url: '${this.url}')`;
+    if (route.pathMatch === 'full' &&
+        (segmentGroup.hasChildren() || parts.length < segments.length)) {
+        // The config is longer than the actual URL but we are looking for a full match, return null
+        return null;
+    }
+    const posParams = {};
+    // Check each config part against the actual URL
+    for (let index = 0; index < parts.length; index++) {
+        const part = parts[index];
+        const segment = segments[index];
+        const isParameter = part.startsWith(':');
+        if (isParameter) {
+            posParams[part.substring(1)] = segment;
+        }
+        else if (part !== segment.path) {
+            // The actual URL part does not match the config, no match
+            return null;
+        }
     }
+    return { consumed: segments.slice(0, parts.length), posParams };
 }
+
 /**
- * An event triggered when a navigation ends successfully.
- *
- * @see `NavigationStart`
- * @see `NavigationCancel`
- * @see `NavigationError`
+ * @license
+ * Copyright Google LLC All Rights Reserved.
  *
- * @publicApi
+ * 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
  */
-class NavigationEnd extends RouterEvent {
-    constructor(
-    /** @docsNotRequired */
-    id, 
-    /** @docsNotRequired */
-    url, 
-    /** @docsNotRequired */
-    urlAfterRedirects) {
-        super(id, url);
-        this.urlAfterRedirects = urlAfterRedirects;
-        this.type = 1 /* EventType.NavigationEnd */;
+function shallowEqualArrays(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; ++i) {
+        if (!shallowEqual(a[i], b[i]))
+            return false;
     }
-    /** @docsNotRequired */
-    toString() {
-        return `NavigationEnd(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}')`;
+    return true;
+}
+function shallowEqual(a, b) {
+    // While `undefined` should never be possible, it would sometimes be the case in IE 11
+    // and pre-chromium Edge. The check below accounts for this edge case.
+    const k1 = a ? Object.keys(a) : undefined;
+    const k2 = b ? Object.keys(b) : undefined;
+    if (!k1 || !k2 || k1.length != k2.length) {
+        return false;
+    }
+    let key;
+    for (let i = 0; i < k1.length; i++) {
+        key = k1[i];
+        if (!equalArraysOrString(a[key], b[key])) {
+            return false;
+        }
     }
+    return true;
 }
 /**
- * An event triggered when a navigation is canceled, directly or indirectly.
- * This can happen for several reasons including when a route guard
- * returns `false` or initiates a redirect by returning a `UrlTree`.
- *
- * @see `NavigationStart`
- * @see `NavigationEnd`
- * @see `NavigationError`
- *
- * @publicApi
+ * Test equality for arrays of strings or a string.
  */
-class NavigationCancel extends RouterEvent {
-    constructor(
-    /** @docsNotRequired */
-    id, 
-    /** @docsNotRequired */
-    url, 
-    /** @docsNotRequired */
-    reason) {
-        super(id, url);
-        this.reason = reason;
-        this.type = 2 /* EventType.NavigationCancel */;
+function equalArraysOrString(a, b) {
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length)
+            return false;
+        const aSorted = [...a].sort();
+        const bSorted = [...b].sort();
+        return aSorted.every((val, index) => bSorted[index] === val);
     }
-    /** @docsNotRequired */
-    toString() {
-        return `NavigationCancel(id: ${this.id}, url: '${this.url}')`;
+    else {
+        return a === b;
     }
 }
 /**
- * An event triggered when a navigation fails due to an unexpected error.
- *
- * @see `NavigationStart`
- * @see `NavigationEnd`
- * @see `NavigationCancel`
- *
- * @publicApi
+ * Flattens single-level nested arrays.
  */
-class NavigationError extends RouterEvent {
-    constructor(
-    /** @docsNotRequired */
-    id, 
-    /** @docsNotRequired */
-    url, 
-    /** @docsNotRequired */
-    error) {
-        super(id, url);
-        this.error = error;
-        this.type = 3 /* EventType.NavigationError */;
-    }
-    /** @docsNotRequired */
-    toString() {
-        return `NavigationError(id: ${this.id}, url: '${this.url}', error: ${this.error})`;
-    }
+function flatten(arr) {
+    return Array.prototype.concat.apply([], arr);
 }
 /**
- * An event triggered when routes are recognized.
- *
- * @publicApi
+ * Return the last element of an array.
  */
-class RoutesRecognized extends RouterEvent {
-    constructor(
-    /** @docsNotRequired */
-    id, 
-    /** @docsNotRequired */
-    url, 
-    /** @docsNotRequired */
-    urlAfterRedirects, 
-    /** @docsNotRequired */
-    state) {
-        super(id, url);
-        this.urlAfterRedirects = urlAfterRedirects;
-        this.state = state;
-        this.type = 4 /* EventType.RoutesRecognized */;
-    }
-    /** @docsNotRequired */
-    toString() {
-        return `RoutesRecognized(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state})`;
-    }
+function last(a) {
+    return a.length > 0 ? a[a.length - 1] : null;
 }
 /**
- * An event triggered at the start of the Guard phase of routing.
- *
- * @see `GuardsCheckEnd`
- *
- * @publicApi
+ * Verifys all booleans in an array are `true`.
  */
-class GuardsCheckStart extends RouterEvent {
-    constructor(
-    /** @docsNotRequired */
-    id, 
-    /** @docsNotRequired */
-    url, 
-    /** @docsNotRequired */
-    urlAfterRedirects, 
-    /** @docsNotRequired */
-    state) {
-        super(id, url);
-        this.urlAfterRedirects = urlAfterRedirects;
-        this.state = state;
-        this.type = 7 /* EventType.GuardsCheckStart */;
+function and(bools) {
+    return !bools.some(v => !v);
+}
+function forEach(map, callback) {
+    for (const prop in map) {
+        if (map.hasOwnProperty(prop)) {
+            callback(map[prop], prop);
+        }
     }
-    toString() {
-        return `GuardsCheckStart(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state})`;
+}
+function wrapIntoObservable(value) {
+    if (ɵisObservable(value)) {
+        return value;
+    }
+    if (ɵisPromise(value)) {
+        // Use `Promise.resolve()` to wrap promise-like instances.
+        // Required ie when a Resolver returns a AngularJS `$q` promise to correctly trigger the
+        // change detection.
+        return from(Promise.resolve(value));
     }
+    return of(value);
 }
+
 /**
- * An event triggered at the end of the Guard phase of routing.
- *
- * @see `GuardsCheckStart`
+ * @license
+ * Copyright Google LLC All Rights Reserved.
  *
- * @publicApi
+ * 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
  */
-class GuardsCheckEnd extends RouterEvent {
-    constructor(
-    /** @docsNotRequired */
-    id, 
-    /** @docsNotRequired */
-    url, 
-    /** @docsNotRequired */
-    urlAfterRedirects, 
-    /** @docsNotRequired */
-    state, 
-    /** @docsNotRequired */
-    shouldActivate) {
-        super(id, url);
-        this.urlAfterRedirects = urlAfterRedirects;
-        this.state = state;
-        this.shouldActivate = shouldActivate;
-        this.type = 8 /* EventType.GuardsCheckEnd */;
+function createEmptyUrlTree() {
+    return new UrlTree(new UrlSegmentGroup([], {}), {}, null);
+}
+const pathCompareMap = {
+    'exact': equalSegmentGroups,
+    'subset': containsSegmentGroup,
+};
+const paramCompareMap = {
+    'exact': equalParams,
+    'subset': containsParams,
+    'ignored': () => true,
+};
+function containsTree(container, containee, options) {
+    return pathCompareMap[options.paths](container.root, containee.root, options.matrixParams) &&
+        paramCompareMap[options.queryParams](container.queryParams, containee.queryParams) &&
+        !(options.fragment === 'exact' && container.fragment !== containee.fragment);
+}
+function equalParams(container, containee) {
+    // TODO: This does not handle array params correctly.
+    return shallowEqual(container, containee);
+}
+function equalSegmentGroups(container, containee, matrixParams) {
+    if (!equalPath(container.segments, containee.segments))
+        return false;
+    if (!matrixParamsMatch(container.segments, containee.segments, matrixParams)) {
+        return false;
     }
-    toString() {
-        return `GuardsCheckEnd(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state}, shouldActivate: ${this.shouldActivate})`;
+    if (container.numberOfChildren !== containee.numberOfChildren)
+        return false;
+    for (const c in containee.children) {
+        if (!container.children[c])
+            return false;
+        if (!equalSegmentGroups(container.children[c], containee.children[c], matrixParams))
+            return false;
+    }
+    return true;
+}
+function containsParams(container, containee) {
+    return Object.keys(containee).length <= Object.keys(container).length &&
+        Object.keys(containee).every(key => equalArraysOrString(container[key], containee[key]));
+}
+function containsSegmentGroup(container, containee, matrixParams) {
+    return containsSegmentGroupHelper(container, containee, containee.segments, matrixParams);
+}
+function containsSegmentGroupHelper(container, containee, containeePaths, matrixParams) {
+    if (container.segments.length > containeePaths.length) {
+        const current = container.segments.slice(0, containeePaths.length);
+        if (!equalPath(current, containeePaths))
+            return false;
+        if (containee.hasChildren())
+            return false;
+        if (!matrixParamsMatch(current, containeePaths, matrixParams))
+            return false;
+        return true;
+    }
+    else if (container.segments.length === containeePaths.length) {
+        if (!equalPath(container.segments, containeePaths))
+            return false;
+        if (!matrixParamsMatch(container.segments, containeePaths, matrixParams))
+            return false;
+        for (const c in containee.children) {
+            if (!container.children[c])
+                return false;
+            if (!containsSegmentGroup(container.children[c], containee.children[c], matrixParams)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    else {
+        const current = containeePaths.slice(0, container.segments.length);
+        const next = containeePaths.slice(container.segments.length);
+        if (!equalPath(container.segments, current))
+            return false;
+        if (!matrixParamsMatch(container.segments, current, matrixParams))
+            return false;
+        if (!container.children[PRIMARY_OUTLET])
+            return false;
+        return containsSegmentGroupHelper(container.children[PRIMARY_OUTLET], containee, next, matrixParams);
     }
 }
+function matrixParamsMatch(containerPaths, containeePaths, options) {
+    return containeePaths.every((containeeSegment, i) => {
+        return paramCompareMap[options](containerPaths[i].parameters, containeeSegment.parameters);
+    });
+}
 /**
- * An event triggered at the start of the Resolve phase of routing.
+ * @description
  *
- * Runs in the "resolve" phase whether or not there is anything to resolve.
- * In future, may change to only run when there are things to be resolved.
+ * Represents the parsed URL.
  *
- * @see `ResolveEnd`
+ * Since a router state is a tree, and the URL is nothing but a serialized state, the URL is a
+ * serialized tree.
+ * UrlTree is a data structure that provides a lot of affordances in dealing with URLs
+ *
+ * @usageNotes
+ * ### Example
+ *
+ * ```
+ * @Component({templateUrl:'template.html'})
+ * class MyComponent {
+ *   constructor(router: Router) {
+ *     const tree: UrlTree =
+ *       router.parseUrl('/team/33/(user/victor//support:help)?debug=true#fragment');
+ *     const f = tree.fragment; // return 'fragment'
+ *     const q = tree.queryParams; // returns {debug: 'true'}
+ *     const g: UrlSegmentGroup = tree.root.children[PRIMARY_OUTLET];
+ *     const s: UrlSegment[] = g.segments; // returns 2 segments 'team' and '33'
+ *     g.children[PRIMARY_OUTLET].segments; // returns 2 segments 'user' and 'victor'
+ *     g.children['support'].segments; // return 1 segment 'help'
+ *   }
+ * }
+ * ```
  *
  * @publicApi
  */
-class ResolveStart extends RouterEvent {
+class UrlTree {
+    /** @internal */
     constructor(
-    /** @docsNotRequired */
-    id, 
-    /** @docsNotRequired */
-    url, 
-    /** @docsNotRequired */
-    urlAfterRedirects, 
-    /** @docsNotRequired */
-    state) {
-        super(id, url);
-        this.urlAfterRedirects = urlAfterRedirects;
-        this.state = state;
-        this.type = 5 /* EventType.ResolveStart */;
+    /** The root segment group of the URL tree */
+    root, 
+    /** The query params of the URL */
+    queryParams, 
+    /** The fragment of the URL */
+    fragment) {
+        this.root = root;
+        this.queryParams = queryParams;
+        this.fragment = fragment;
+    }
+    get queryParamMap() {
+        if (!this._queryParamMap) {
+            this._queryParamMap = convertToParamMap(this.queryParams);
+        }
+        return this._queryParamMap;
     }
+    /** @docsNotRequired */
     toString() {
-        return `ResolveStart(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state})`;
+        return DEFAULT_SERIALIZER.serialize(this);
     }
 }
 /**
- * An event triggered at the end of the Resolve phase of routing.
- * @see `ResolveStart`.
+ * @description
+ *
+ * Represents the parsed URL segment group.
+ *
+ * See `UrlTree` for more information.
  *
  * @publicApi
  */
-class ResolveEnd extends RouterEvent {
+class UrlSegmentGroup {
     constructor(
-    /** @docsNotRequired */
-    id, 
-    /** @docsNotRequired */
-    url, 
-    /** @docsNotRequired */
-    urlAfterRedirects, 
-    /** @docsNotRequired */
-    state) {
-        super(id, url);
-        this.urlAfterRedirects = urlAfterRedirects;
-        this.state = state;
-        this.type = 6 /* EventType.ResolveEnd */;
+    /** The URL segments of this group. See `UrlSegment` for more information */
+    segments, 
+    /** The list of children of this group */
+    children) {
+        this.segments = segments;
+        this.children = children;
+        /** The parent node in the url tree */
+        this.parent = null;
+        forEach(children, (v, k) => v.parent = this);
+    }
+    /** Whether the segment has child segments */
+    hasChildren() {
+        return this.numberOfChildren > 0;
+    }
+    /** Number of child segments */
+    get numberOfChildren() {
+        return Object.keys(this.children).length;
     }
+    /** @docsNotRequired */
     toString() {
-        return `ResolveEnd(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state})`;
+        return serializePaths(this);
     }
 }
 /**
- * An event triggered before lazy loading a route configuration.
+ * @description
  *
- * @see `RouteConfigLoadEnd`
+ * Represents a single URL segment.
  *
- * @publicApi
- */
-class RouteConfigLoadStart {
-    constructor(
-    /** @docsNotRequired */
-    route) {
-        this.route = route;
-        this.type = 9 /* EventType.RouteConfigLoadStart */;
-    }
-    toString() {
-        return `RouteConfigLoadStart(path: ${this.route.path})`;
-    }
-}
-/**
- * An event triggered when a route has been lazy loaded.
+ * A UrlSegment is a part of a URL between the two slashes. It contains a path and the matrix
+ * parameters associated with the segment.
  *
- * @see `RouteConfigLoadStart`
+ * @usageNotes
+ * ### Example
+ *
+ * ```
+ * @Component({templateUrl:'template.html'})
+ * class MyComponent {
+ *   constructor(router: Router) {
+ *     const tree: UrlTree = router.parseUrl('/team;id=33');
+ *     const g: UrlSegmentGroup = tree.root.children[PRIMARY_OUTLET];
+ *     const s: UrlSegment[] = g.segments;
+ *     s[0].path; // returns 'team'
+ *     s[0].parameters; // returns {id: 33}
+ *   }
+ * }
+ * ```
  *
  * @publicApi
  */
-class RouteConfigLoadEnd {
+class UrlSegment {
     constructor(
-    /** @docsNotRequired */
-    route) {
-        this.route = route;
-        this.type = 10 /* EventType.RouteConfigLoadEnd */;
+    /** The path part of a URL segment */
+    path, 
+    /** The matrix parameters associated with a segment */
+    parameters) {
+        this.path = path;
+        this.parameters = parameters;
+    }
+    get parameterMap() {
+        if (!this._parameterMap) {
+            this._parameterMap = convertToParamMap(this.parameters);
+        }
+        return this._parameterMap;
     }
+    /** @docsNotRequired */
     toString() {
-        return `RouteConfigLoadEnd(path: ${this.route.path})`;
+        return serializePath(this);
     }
 }
+function equalSegments(as, bs) {
+    return equalPath(as, bs) && as.every((a, i) => shallowEqual(a.parameters, bs[i].parameters));
+}
+function equalPath(as, bs) {
+    if (as.length !== bs.length)
+        return false;
+    return as.every((a, i) => a.path === bs[i].path);
+}
+function mapChildrenIntoArray(segment, fn) {
+    let res = [];
+    forEach(segment.children, (child, childOutlet) => {
+        if (childOutlet === PRIMARY_OUTLET) {
+            res = res.concat(fn(child, childOutlet));
+        }
+    });
+    forEach(segment.children, (child, childOutlet) => {
+        if (childOutlet !== PRIMARY_OUTLET) {
+            res = res.concat(fn(child, childOutlet));
+        }
+    });
+    return res;
+}
 /**
- * An event triggered at the start of the child-activation
- * part of the Resolve phase of routing.
- * @see  `ChildActivationEnd`
- * @see `ResolveStart`
+ * @description
+ *
+ * Serializes and deserializes a URL string into a URL tree.
+ *
+ * The url serialization strategy is customizable. You can
+ * make all URLs case insensitive by providing a custom UrlSerializer.
+ *
+ * See `DefaultUrlSerializer` for an example of a URL serializer.
  *
  * @publicApi
  */
-class ChildActivationStart {
-    constructor(
-    /** @docsNotRequired */
-    snapshot) {
-        this.snapshot = snapshot;
-        this.type = 11 /* EventType.ChildActivationStart */;
-    }
-    toString() {
-        const path = this.snapshot.routeConfig && this.snapshot.routeConfig.path || '';
-        return `ChildActivationStart(path: '${path}')`;
-    }
+class UrlSerializer {
 }
 /**
- * An event triggered at the end of the child-activation part
- * of the Resolve phase of routing.
- * @see `ChildActivationStart`
- * @see `ResolveStart`
+ * @description
+ *
+ * A default implementation of the `UrlSerializer`.
+ *
+ * Example URLs:
+ *
+ * ```
+ * /inbox/33(popup:compose)
+ * /inbox/33;open=true/messages/44
+ * ```
+ *
+ * DefaultUrlSerializer uses parentheses to serialize secondary segments (e.g., popup:compose), the
+ * colon syntax to specify the outlet, and the ';parameter=value' syntax (e.g., open=true) to
+ * specify route specific parameters.
+ *
  * @publicApi
  */
-class ChildActivationEnd {
-    constructor(
-    /** @docsNotRequired */
-    snapshot) {
-        this.snapshot = snapshot;
-        this.type = 12 /* EventType.ChildActivationEnd */;
+class DefaultUrlSerializer {
+    /** Parses a url into a `UrlTree` */
+    parse(url) {
+        const p = new UrlParser(url);
+        return new UrlTree(p.parseRootSegment(), p.parseQueryParams(), p.parseFragment());
     }
-    toString() {
-        const path = this.snapshot.routeConfig && this.snapshot.routeConfig.path || '';
-        return `ChildActivationEnd(path: '${path}')`;
+    /** Converts a `UrlTree` into a url */
+    serialize(tree) {
+        const segment = `/${serializeSegment(tree.root, true)}`;
+        const query = serializeQueryParams(tree.queryParams);
+        const fragment = typeof tree.fragment === `string` ? `#${encodeUriFragment(tree.fragment)}` : '';
+        return `${segment}${query}${fragment}`;
+    }
+}
+const DEFAULT_SERIALIZER = new DefaultUrlSerializer();
+function serializePaths(segment) {
+    return segment.segments.map(p => serializePath(p)).join('/');
+}
+function serializeSegment(segment, root) {
+    if (!segment.hasChildren()) {
+        return serializePaths(segment);
+    }
+    if (root) {
+        const primary = segment.children[PRIMARY_OUTLET] ?
+            serializeSegment(segment.children[PRIMARY_OUTLET], false) :
+            '';
+        const children = [];
+        forEach(segment.children, (v, k) => {
+            if (k !== PRIMARY_OUTLET) {
+                children.push(`${k}:${serializeSegment(v, false)}`);
+            }
+        });
+        return children.length > 0 ? `${primary}(${children.join('//')})` : primary;
+    }
+    else {
+        const children = mapChildrenIntoArray(segment, (v, k) => {
+            if (k === PRIMARY_OUTLET) {
+                return [serializeSegment(segment.children[PRIMARY_OUTLET], false)];
+            }
+            return [`${k}:${serializeSegment(v, false)}`];
+        });
+        // use no parenthesis if the only child is a primary outlet route
+        if (Object.keys(segment.children).length === 1 && segment.children[PRIMARY_OUTLET] != null) {
+            return `${serializePaths(segment)}/${children[0]}`;
+        }
+        return `${serializePaths(segment)}/(${children.join('//')})`;
     }
 }
 /**
- * An event triggered at the start of the activation part
- * of the Resolve phase of routing.
- * @see `ActivationEnd`
- * @see `ResolveStart`
+ * Encodes a URI string with the default encoding. This function will only ever be called from
+ * `encodeUriQuery` or `encodeUriSegment` as it's the base set of encodings to be used. We need
+ * a custom encoding because encodeURIComponent is too aggressive and encodes stuff that doesn't
+ * have to be encoded per https://url.spec.whatwg.org.
+ */
+function encodeUriString(s) {
+    return encodeURIComponent(s)
+        .replace(/%40/g, '@')
+        .replace(/%3A/gi, ':')
+        .replace(/%24/g, '$')
+        .replace(/%2C/gi, ',');
+}
+/**
+ * This function should be used to encode both keys and values in a query string key/value. In
+ * the following URL, you need to call encodeUriQuery on "k" and "v":
  *
- * @publicApi
+ * http://www.site.org/html;mk=mv?k=v#f
  */
-class ActivationStart {
-    constructor(
-    /** @docsNotRequired */
-    snapshot) {
-        this.snapshot = snapshot;
-        this.type = 13 /* EventType.ActivationStart */;
-    }
-    toString() {
-        const path = this.snapshot.routeConfig && this.snapshot.routeConfig.path || '';
-        return `ActivationStart(path: '${path}')`;
-    }
+function encodeUriQuery(s) {
+    return encodeUriString(s).replace(/%3B/gi, ';');
 }
 /**
- * An event triggered at the end of the activation part
- * of the Resolve phase of routing.
- * @see `ActivationStart`
- * @see `ResolveStart`
+ * This function should be used to encode a URL fragment. In the following URL, you need to call
+ * encodeUriFragment on "f":
  *
- * @publicApi
+ * http://www.site.org/html;mk=mv?k=v#f
  */
-class ActivationEnd {
-    constructor(
-    /** @docsNotRequired */
-    snapshot) {
-        this.snapshot = snapshot;
-        this.type = 14 /* EventType.ActivationEnd */;
-    }
-    toString() {
-        const path = this.snapshot.routeConfig && this.snapshot.routeConfig.path || '';
-        return `ActivationEnd(path: '${path}')`;
-    }
+function encodeUriFragment(s) {
+    return encodeURI(s);
 }
 /**
- * An event triggered by scrolling.
+ * This function should be run on any URI segment as well as the key and value in a key/value
+ * pair for matrix params. In the following URL, you need to call encodeUriSegment on "html",
+ * "mk", and "mv":
  *
- * @publicApi
+ * http://www.site.org/html;mk=mv?k=v#f
  */
-class Scroll {
-    constructor(
-    /** @docsNotRequired */
-    routerEvent, 
-    /** @docsNotRequired */
-    position, 
-    /** @docsNotRequired */
-    anchor) {
-        this.routerEvent = routerEvent;
-        this.position = position;
-        this.anchor = anchor;
-        this.type = 15 /* EventType.Scroll */;
-    }
-    toString() {
-        const pos = this.position ? `${this.position[0]}, ${this.position[1]}` : null;
-        return `Scroll(anchor: '${this.anchor}', position: '${pos}')`;
-    }
+function encodeUriSegment(s) {
+    return encodeUriString(s).replace(/\(/g, '%28').replace(/\)/g, '%29').replace(/%26/gi, '&');
 }
-function stringifyEvent(routerEvent) {
-    if (!('type' in routerEvent)) {
-        return `Unknown Router Event: ${routerEvent.constructor.name}`;
-    }
-    switch (routerEvent.type) {
-        case 14 /* EventType.ActivationEnd */:
-            return `ActivationEnd(path: '${routerEvent.snapshot.routeConfig?.path || ''}')`;
-        case 13 /* EventType.ActivationStart */:
-            return `ActivationStart(path: '${routerEvent.snapshot.routeConfig?.path || ''}')`;
-        case 12 /* EventType.ChildActivationEnd */:
-            return `ChildActivationEnd(path: '${routerEvent.snapshot.routeConfig?.path || ''}')`;
-        case 11 /* EventType.ChildActivationStart */:
-            return `ChildActivationStart(path: '${routerEvent.snapshot.routeConfig?.path || ''}')`;
-        case 8 /* EventType.GuardsCheckEnd */:
-            return `GuardsCheckEnd(id: ${routerEvent.id}, url: '${routerEvent.url}', urlAfterRedirects: '${routerEvent.urlAfterRedirects}', state: ${routerEvent.state}, shouldActivate: ${routerEvent.shouldActivate})`;
-        case 7 /* EventType.GuardsCheckStart */:
-            return `GuardsCheckStart(id: ${routerEvent.id}, url: '${routerEvent.url}', urlAfterRedirects: '${routerEvent.urlAfterRedirects}', state: ${routerEvent.state})`;
-        case 2 /* EventType.NavigationCancel */:
-            return `NavigationCancel(id: ${routerEvent.id}, url: '${routerEvent.url}')`;
-        case 1 /* EventType.NavigationEnd */:
-            return `NavigationEnd(id: ${routerEvent.id}, url: '${routerEvent.url}', urlAfterRedirects: '${routerEvent.urlAfterRedirects}')`;
-        case 3 /* EventType.NavigationError */:
-            return `NavigationError(id: ${routerEvent.id}, url: '${routerEvent.url}', error: ${routerEvent.error})`;
-        case 0 /* EventType.NavigationStart */:
-            return `NavigationStart(id: ${routerEvent.id}, url: '${routerEvent.url}')`;
-        case 6 /* EventType.ResolveEnd */:
-            return `ResolveEnd(id: ${routerEvent.id}, url: '${routerEvent.url}', urlAfterRedirects: '${routerEvent.urlAfterRedirects}', state: ${routerEvent.state})`;
-        case 5 /* EventType.ResolveStart */:
-            return `ResolveStart(id: ${routerEvent.id}, url: '${routerEvent.url}', urlAfterRedirects: '${routerEvent.urlAfterRedirects}', state: ${routerEvent.state})`;
-        case 10 /* EventType.RouteConfigLoadEnd */:
-            return `RouteConfigLoadEnd(path: ${routerEvent.route.path})`;
-        case 9 /* EventType.RouteConfigLoadStart */:
-            return `RouteConfigLoadStart(path: ${routerEvent.route.path})`;
-        case 4 /* EventType.RoutesRecognized */:
-            return `RoutesRecognized(id: ${routerEvent.id}, url: '${routerEvent.url}', urlAfterRedirects: '${routerEvent.urlAfterRedirects}', state: ${routerEvent.state})`;
-        case 15 /* EventType.Scroll */:
-            const pos = routerEvent.position ? `${routerEvent.position[0]}, ${routerEvent.position[1]}` : null;
-            return `Scroll(anchor: '${routerEvent.anchor}', position: '${pos}')`;
-    }
+function decode(s) {
+    return decodeURIComponent(s);
 }
-
-/**
- * @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.io/license
- */
-/**
- * The primary routing outlet.
- *
- * @publicApi
- */
-const PRIMARY_OUTLET = 'primary';
-class ParamsAsMap {
-    constructor(params) {
-        this.params = params || {};
-    }
-    has(name) {
-        return Object.prototype.hasOwnProperty.call(this.params, name);
-    }
-    get(name) {
-        if (this.has(name)) {
-            const v = this.params[name];
-            return Array.isArray(v) ? v[0] : v;
-        }
-        return null;
-    }
-    getAll(name) {
-        if (this.has(name)) {
-            const v = this.params[name];
-            return Array.isArray(v) ? v : [v];
-        }
-        return [];
-    }
-    get keys() {
-        return Object.keys(this.params);
-    }
+// Query keys/values should have the "+" replaced first, as "+" in a query string is " ".
+// decodeURIComponent function will not decode "+" as a space.
+function decodeQuery(s) {
+    return decode(s.replace(/\+/g, '%20'));
 }
-/**
- * Converts a `Params` instance to a `ParamMap`.
- * @param params The instance to convert.
- * @returns The new map instance.
- *
- * @publicApi
- */
-function convertToParamMap(params) {
-    return new ParamsAsMap(params);
+function serializePath(path) {
+    return `${encodeUriSegment(path.path)}${serializeMatrixParams(path.parameters)}`;
 }
-const NAVIGATION_CANCELING_ERROR = 'ngNavigationCancelingError';
-function navigationCancelingError(message) {
-    const error = Error('NavigationCancelingError: ' + message);
-    error[NAVIGATION_CANCELING_ERROR] = true;
-    return error;
+function serializeMatrixParams(params) {
+    return Object.keys(params)
+        .map(key => `;${encodeUriSegment(key)}=${encodeUriSegment(params[key])}`)
+        .join('');
 }
-function isNavigationCancelingError(error) {
-    return error && error[NAVIGATION_CANCELING_ERROR];
+function serializeQueryParams(params) {
+    const strParams = Object.keys(params)
+        .map((name) => {
+        const value = params[name];
+        return Array.isArray(value) ?
+            value.map(v => `${encodeUriQuery(name)}=${encodeUriQuery(v)}`).join('&') :
+            `${encodeUriQuery(name)}=${encodeUriQuery(value)}`;
+    })
+        .filter(s => !!s);
+    return strParams.length ? `?${strParams.join('&')}` : '';
 }
-// Matches the route configuration (`route`) against the actual URL (`segments`).
-function defaultUrlMatcher(segments, segmentGroup, route) {
-    const parts = route.path.split('/');
-    if (parts.length > segments.length) {
-        // The actual URL is shorter than the config, no match
-        return null;
-    }
-    if (route.pathMatch === 'full' &&
-        (segmentGroup.hasChildren() || parts.length < segments.length)) {
-        // The config is longer than the actual URL but we are looking for a full match, return null
-        return null;
+const SEGMENT_RE = /^[^\/()?;=#]+/;
+function matchSegments(str) {
+    const match = str.match(SEGMENT_RE);
+    return match ? match[0] : '';
+}
+const QUERY_PARAM_RE = /^[^=?&#]+/;
+// Return the name of the query param at the start of the string or an empty string
+function matchQueryParams(str) {
+    const match = str.match(QUERY_PARAM_RE);
+    return match ? match[0] : '';
+}
+const QUERY_PARAM_VALUE_RE = /^[^&#]+/;
+// Return the value of the query param at the start of the string or an empty string
+function matchUrlQueryParamValue(str) {
+    const match = str.match(QUERY_PARAM_VALUE_RE);
+    return match ? match[0] : '';
+}
+class UrlParser {
+    constructor(url) {
+        this.url = url;
+        this.remaining = url;
     }
-    const posParams = {};
-    // Check each config part against the actual URL
-    for (let index = 0; index < parts.length; index++) {
-        const part = parts[index];
-        const segment = segments[index];
-        const isParameter = part.startsWith(':');
-        if (isParameter) {
-            posParams[part.substring(1)] = segment;
-        }
-        else if (part !== segment.path) {
-            // The actual URL part does not match the config, no match
-            return null;
+    parseRootSegment() {
+        this.consumeOptional('/');
+        if (this.remaining === '' || this.peekStartsWith('?') || this.peekStartsWith('#')) {
+            return new UrlSegmentGroup([], {});
         }
+        // The root segment group never has segments
+        return new UrlSegmentGroup([], this.parseChildren());
     }
-    return { consumed: segments.slice(0, parts.length), posParams };
-}
-
-/**
- * @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.io/license
- */
-function shallowEqualArrays(a, b) {
-    if (a.length !== b.length)
-        return false;
-    for (let i = 0; i < a.length; ++i) {
-        if (!shallowEqual(a[i], b[i]))
-            return false;
+    parseQueryParams() {
+        const params = {};
+        if (this.consumeOptional('?')) {
+            do {
+                this.parseQueryParam(params);
+            } while (this.consumeOptional('&'));
+        }
+        return params;
     }
-    return true;
-}
-function shallowEqual(a, b) {
-    // While `undefined` should never be possible, it would sometimes be the case in IE 11
-    // and pre-chromium Edge. The check below accounts for this edge case.
-    const k1 = a ? Object.keys(a) : undefined;
-    const k2 = b ? Object.keys(b) : undefined;
-    if (!k1 || !k2 || k1.length != k2.length) {
-        return false;
+    parseFragment() {
+        return this.consumeOptional('#') ? decodeURIComponent(this.remaining) : null;
     }
-    let key;
-    for (let i = 0; i < k1.length; i++) {
-        key = k1[i];
-        if (!equalArraysOrString(a[key], b[key])) {
-            return false;
+    parseChildren() {
+        if (this.remaining === '') {
+            return {};
+        }
+        this.consumeOptional('/');
+        const segments = [];
+        if (!this.peekStartsWith('(')) {
+            segments.push(this.parseSegment());
+        }
+        while (this.peekStartsWith('/') && !this.peekStartsWith('//') && !this.peekStartsWith('/(')) {
+            this.capture('/');
+            segments.push(this.parseSegment());
+        }
+        let children = {};
+        if (this.peekStartsWith('/(')) {
+            this.capture('/');
+            children = this.parseParens(true);
+        }
+        let res = {};
+        if (this.peekStartsWith('(')) {
+            res = this.parseParens(false);
         }
+        if (segments.length > 0 || Object.keys(children).length > 0) {
+            res[PRIMARY_OUTLET] = new UrlSegmentGroup(segments, children);
+        }
+        return res;
     }
-    return true;
-}
-/**
- * Test equality for arrays of strings or a string.
- */
-function equalArraysOrString(a, b) {
-    if (Array.isArray(a) && Array.isArray(b)) {
-        if (a.length !== b.length)
-            return false;
-        const aSorted = [...a].sort();
-        const bSorted = [...b].sort();
-        return aSorted.every((val, index) => bSorted[index] === val);
+    // parse a segment with its matrix parameters
+    // ie `name;k1=v1;k2`
+    parseSegment() {
+        const path = matchSegments(this.remaining);
+        if (path === '' && this.peekStartsWith(';')) {
+            throw new Error(`Empty path url segment cannot have parameters: '${this.remaining}'.`);
+        }
+        this.capture(path);
+        return new UrlSegment(decode(path), this.parseMatrixParams());
     }
-    else {
-        return a === b;
+    parseMatrixParams() {
+        const params = {};
+        while (this.consumeOptional(';')) {
+            this.parseParam(params);
+        }
+        return params;
+    }
+    parseParam(params) {
+        const key = matchSegments(this.remaining);
+        if (!key) {
+            return;
+        }
+        this.capture(key);
+        let value = '';
+        if (this.consumeOptional('=')) {
+            const valueMatch = matchSegments(this.remaining);
+            if (valueMatch) {
+                value = valueMatch;
+                this.capture(value);
+            }
+        }
+        params[decode(key)] = decode(value);
+    }
+    // Parse a single query parameter `name[=value]`
+    parseQueryParam(params) {
+        const key = matchQueryParams(this.remaining);
+        if (!key) {
+            return;
+        }
+        this.capture(key);
+        let value = '';
+        if (this.consumeOptional('=')) {
+            const valueMatch = matchUrlQueryParamValue(this.remaining);
+            if (valueMatch) {
+                value = valueMatch;
+                this.capture(value);
+            }
+        }
+        const decodedKey = decodeQuery(key);
+        const decodedVal = decodeQuery(value);
+        if (params.hasOwnProperty(decodedKey)) {
+            // Append to existing values
+            let currentVal = params[decodedKey];
+            if (!Array.isArray(currentVal)) {
+                currentVal = [currentVal];
+                params[decodedKey] = currentVal;
+            }
+            currentVal.push(decodedVal);
+        }
+        else {
+            // Create a new value
+            params[decodedKey] = decodedVal;
+        }
+    }
+    // parse `(a/b//outlet_name:c/d)`
+    parseParens(allowPrimary) {
+        const segments = {};
+        this.capture('(');
+        while (!this.consumeOptional(')') && this.remaining.length > 0) {
+            const path = matchSegments(this.remaining);
+            const next = this.remaining[path.length];
+            // if is is not one of these characters, then the segment was unescaped
+            // or the group was not closed
+            if (next !== '/' && next !== ')' && next !== ';') {
+                throw new Error(`Cannot parse url '${this.url}'`);
+            }
+            let outletName = undefined;
+            if (path.indexOf(':') > -1) {
+                outletName = path.slice(0, path.indexOf(':'));
+                this.capture(outletName);
+                this.capture(':');
+            }
+            else if (allowPrimary) {
+                outletName = PRIMARY_OUTLET;
+            }
+            const children = this.parseChildren();
+            segments[outletName] = Object.keys(children).length === 1 ? children[PRIMARY_OUTLET] :
+                new UrlSegmentGroup([], children);
+            this.consumeOptional('//');
+        }
+        return segments;
+    }
+    peekStartsWith(str) {
+        return this.remaining.startsWith(str);
+    }
+    // Consumes the prefix when it is present and returns whether it has been consumed
+    consumeOptional(str) {
+        if (this.peekStartsWith(str)) {
+            this.remaining = this.remaining.substring(str.length);
+            return true;
+        }
+        return false;
+    }
+    capture(str) {
+        if (!this.consumeOptional(str)) {
+            throw new Error(`Expected "${str}".`);
+        }
     }
 }
+function createRoot(rootCandidate) {
+    return rootCandidate.segments.length > 0 ?
+        new UrlSegmentGroup([], { [PRIMARY_OUTLET]: rootCandidate }) :
+        rootCandidate;
+}
 /**
- * Flattens single-level nested arrays.
- */
-function flatten(arr) {
-    return Array.prototype.concat.apply([], arr);
-}
-/**
- * Return the last element of an array.
- */
-function last(a) {
-    return a.length > 0 ? a[a.length - 1] : null;
-}
-/**
- * Verifys all booleans in an array are `true`.
+ * Recursively merges primary segment children into their parents and also drops empty children
+ * (those which have no segments and no children themselves). The latter prevents serializing a
+ * group into something like `/a(aux:)`, where `aux` is an empty child segment.
  */
-function and(bools) {
-    return !bools.some(v => !v);
-}
-function forEach(map, callback) {
-    for (const prop in map) {
-        if (map.hasOwnProperty(prop)) {
-            callback(map[prop], prop);
+function squashSegmentGroup(segmentGroup) {
+    const newChildren = {};
+    for (const childOutlet of Object.keys(segmentGroup.children)) {
+        const child = segmentGroup.children[childOutlet];
+        const childCandidate = squashSegmentGroup(child);
+        // don't add empty children
+        if (childCandidate.segments.length > 0 || childCandidate.hasChildren()) {
+            newChildren[childOutlet] = childCandidate;
         }
     }
+    const s = new UrlSegmentGroup(segmentGroup.segments, newChildren);
+    return mergeTrivialChildren(s);
 }
-function wrapIntoObservable(value) {
-    if (ɵisObservable(value)) {
-        return value;
-    }
-    if (ɵisPromise(value)) {
-        // Use `Promise.resolve()` to wrap promise-like instances.
-        // Required ie when a Resolver returns a AngularJS `$q` promise to correctly trigger the
-        // change detection.
-        return from(Promise.resolve(value));
+/**
+ * When possible, merges the primary outlet child into the parent `UrlSegmentGroup`.
+ *
+ * When a segment group has only one child which is a primary outlet, merges that child into the
+ * parent. That is, the child segment group's segments are merged into the `s` and the child's
+ * children become the children of `s`. Think of this like a 'squash', merging the child segment
+ * group into the parent.
+ */
+function mergeTrivialChildren(s) {
+    if (s.numberOfChildren === 1 && s.children[PRIMARY_OUTLET]) {
+        const c = s.children[PRIMARY_OUTLET];
+        return new UrlSegmentGroup(s.segments.concat(c.segments), c.children);
     }
-    return of(value);
+    return s;
 }
 
 /**
@@ -650,998 +805,1009 @@ function wrapIntoObservable(value) {
  * 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
  */
-function createEmptyUrlTree() {
-    return new UrlTree(new UrlSegmentGroup([], {}), {}, null);
-}
-const pathCompareMap = {
-    'exact': equalSegmentGroups,
-    'subset': containsSegmentGroup,
-};
-const paramCompareMap = {
-    'exact': equalParams,
-    'subset': containsParams,
-    'ignored': () => true,
-};
-function containsTree(container, containee, options) {
-    return pathCompareMap[options.paths](container.root, containee.root, options.matrixParams) &&
-        paramCompareMap[options.queryParams](container.queryParams, containee.queryParams) &&
-        !(options.fragment === 'exact' && container.fragment !== containee.fragment);
-}
-function equalParams(container, containee) {
-    // TODO: This does not handle array params correctly.
-    return shallowEqual(container, containee);
-}
-function equalSegmentGroups(container, containee, matrixParams) {
-    if (!equalPath(container.segments, containee.segments))
-        return false;
-    if (!matrixParamsMatch(container.segments, containee.segments, matrixParams)) {
-        return false;
-    }
-    if (container.numberOfChildren !== containee.numberOfChildren)
-        return false;
-    for (const c in containee.children) {
-        if (!container.children[c])
-            return false;
-        if (!equalSegmentGroups(container.children[c], containee.children[c], matrixParams))
-            return false;
-    }
-    return true;
-}
-function containsParams(container, containee) {
-    return Object.keys(containee).length <= Object.keys(container).length &&
-        Object.keys(containee).every(key => equalArraysOrString(container[key], containee[key]));
-}
-function containsSegmentGroup(container, containee, matrixParams) {
-    return containsSegmentGroupHelper(container, containee, containee.segments, matrixParams);
-}
-function containsSegmentGroupHelper(container, containee, containeePaths, matrixParams) {
-    if (container.segments.length > containeePaths.length) {
-        const current = container.segments.slice(0, containeePaths.length);
-        if (!equalPath(current, containeePaths))
-            return false;
-        if (containee.hasChildren())
-            return false;
-        if (!matrixParamsMatch(current, containeePaths, matrixParams))
-            return false;
-        return true;
-    }
-    else if (container.segments.length === containeePaths.length) {
-        if (!equalPath(container.segments, containeePaths))
-            return false;
-        if (!matrixParamsMatch(container.segments, containeePaths, matrixParams))
-            return false;
-        for (const c in containee.children) {
-            if (!container.children[c])
-                return false;
-            if (!containsSegmentGroup(container.children[c], containee.children[c], matrixParams)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    else {
-        const current = containeePaths.slice(0, container.segments.length);
-        const next = containeePaths.slice(container.segments.length);
-        if (!equalPath(container.segments, current))
-            return false;
-        if (!matrixParamsMatch(container.segments, current, matrixParams))
-            return false;
-        if (!container.children[PRIMARY_OUTLET])
-            return false;
-        return containsSegmentGroupHelper(container.children[PRIMARY_OUTLET], containee, next, matrixParams);
-    }
-}
-function matrixParamsMatch(containerPaths, containeePaths, options) {
-    return containeePaths.every((containeeSegment, i) => {
-        return paramCompareMap[options](containerPaths[i].parameters, containeeSegment.parameters);
-    });
-}
 /**
- * @description
+ * Creates a `UrlTree` relative to an `ActivatedRouteSnapshot`.
  *
- * Represents the parsed URL.
+ * @publicApi
  *
- * Since a router state is a tree, and the URL is nothing but a serialized state, the URL is a
- * serialized tree.
- * UrlTree is a data structure that provides a lot of affordances in dealing with URLs
+ *
+ * @param relativeTo The `ActivatedRouteSnapshot` to apply the commands to
+ * @param commands An array of URL fragments with which to construct the new URL tree.
+ * If the path is static, can be the literal URL string. For a dynamic path, pass an array of path
+ * segments, followed by the parameters for each segment.
+ * The fragments are applied to the one provided in the `relativeTo` parameter.
+ * @param queryParams The query parameters for the `UrlTree`. `null` if the `UrlTree` does not have
+ *     any query parameters.
+ * @param fragment The fragment for the `UrlTree`. `null` if the `UrlTree` does not have a fragment.
  *
  * @usageNotes
- * ### Example
  *
  * ```
- * @Component({templateUrl:'template.html'})
- * class MyComponent {
- *   constructor(router: Router) {
- *     const tree: UrlTree =
- *       router.parseUrl('/team/33/(user/victor//support:help)?debug=true#fragment');
- *     const f = tree.fragment; // return 'fragment'
- *     const q = tree.queryParams; // returns {debug: 'true'}
- *     const g: UrlSegmentGroup = tree.root.children[PRIMARY_OUTLET];
- *     const s: UrlSegment[] = g.segments; // returns 2 segments 'team' and '33'
- *     g.children[PRIMARY_OUTLET].segments; // returns 2 segments 'user' and 'victor'
- *     g.children['support'].segments; // return 1 segment 'help'
- *   }
- * }
- * ```
+ * // create /team/33/user/11
+ * createUrlTreeFromSnapshot(snapshot, ['/team', 33, 'user', 11]);
  *
- * @publicApi
- */
-class UrlTree {
-    /** @internal */
-    constructor(
-    /** The root segment group of the URL tree */
-    root, 
-    /** The query params of the URL */
-    queryParams, 
-    /** The fragment of the URL */
-    fragment) {
-        this.root = root;
-        this.queryParams = queryParams;
-        this.fragment = fragment;
-    }
-    get queryParamMap() {
-        if (!this._queryParamMap) {
-            this._queryParamMap = convertToParamMap(this.queryParams);
-        }
-        return this._queryParamMap;
-    }
-    /** @docsNotRequired */
-    toString() {
-        return DEFAULT_SERIALIZER.serialize(this);
-    }
-}
-/**
- * @description
+ * // create /team/33;expand=true/user/11
+ * createUrlTreeFromSnapshot(snapshot, ['/team', 33, {expand: true}, 'user', 11]);
  *
- * Represents the parsed URL segment group.
+ * // you can collapse static segments like this (this works only with the first passed-in value):
+ * createUrlTreeFromSnapshot(snapshot, ['/team/33/user', userId]);
  *
- * See `UrlTree` for more information.
+ * // If the first segment can contain slashes, and you do not want the router to split it,
+ * // you can do the following:
+ * createUrlTreeFromSnapshot(snapshot, [{segmentPath: '/one/two'}]);
  *
- * @publicApi
- */
-class UrlSegmentGroup {
-    constructor(
-    /** The URL segments of this group. See `UrlSegment` for more information */
-    segments, 
-    /** The list of children of this group */
-    children) {
-        this.segments = segments;
-        this.children = children;
-        /** The parent node in the url tree */
-        this.parent = null;
-        forEach(children, (v, k) => v.parent = this);
-    }
-    /** Whether the segment has child segments */
-    hasChildren() {
-        return this.numberOfChildren > 0;
-    }
-    /** Number of child segments */
-    get numberOfChildren() {
-        return Object.keys(this.children).length;
-    }
-    /** @docsNotRequired */
-    toString() {
-        return serializePaths(this);
-    }
-}
-/**
- * @description
+ * // create /team/33/(user/11//right:chat)
+ * createUrlTreeFromSnapshot(snapshot, ['/team', 33, {outlets: {primary: 'user/11', right:
+ * 'chat'}}], null, null);
  *
- * Represents a single URL segment.
+ * // remove the right secondary node
+ * createUrlTreeFromSnapshot(snapshot, ['/team', 33, {outlets: {primary: 'user/11', right: null}}]);
  *
- * A UrlSegment is a part of a URL between the two slashes. It contains a path and the matrix
- * parameters associated with the segment.
+ * // For the examples below, assume the current URL is for the `/team/33/user/11` and the
+ * `ActivatedRouteSnapshot` points to `user/11`:
  *
- * @usageNotes
- * ### Example
+ * // navigate to /team/33/user/11/details
+ * createUrlTreeFromSnapshot(snapshot, ['details']);
  *
- * ```
- * @Component({templateUrl:'template.html'})
- * class MyComponent {
- *   constructor(router: Router) {
- *     const tree: UrlTree = router.parseUrl('/team;id=33');
- *     const g: UrlSegmentGroup = tree.root.children[PRIMARY_OUTLET];
- *     const s: UrlSegment[] = g.segments;
- *     s[0].path; // returns 'team'
- *     s[0].parameters; // returns {id: 33}
- *   }
- * }
- * ```
+ * // navigate to /team/33/user/22
+ * createUrlTreeFromSnapshot(snapshot, ['../22']);
  *
- * @publicApi
+ * // navigate to /team/44/user/22
+ * createUrlTreeFromSnapshot(snapshot, ['../../team/44/user/22']);
+ * ```
  */
-class UrlSegment {
-    constructor(
-    /** The path part of a URL segment */
-    path, 
-    /** The matrix parameters associated with a segment */
-    parameters) {
-        this.path = path;
-        this.parameters = parameters;
-    }
-    get parameterMap() {
-        if (!this._parameterMap) {
-            this._parameterMap = convertToParamMap(this.parameters);
-        }
-        return this._parameterMap;
+function createUrlTreeFromSnapshot(relativeTo, commands, queryParams = null, fragment = null) {
+    const relativeToUrlSegmentGroup = createSegmentGroupFromRoute(relativeTo);
+    return createUrlTreeFromSegmentGroup(relativeToUrlSegmentGroup, commands, queryParams, fragment);
+}
+function createSegmentGroupFromRoute(route) {
+    let targetGroup;
+    function createSegmentGroupFromRouteRecursive(currentRoute) {
+        const childOutlets = {};
+        for (const childSnapshot of currentRoute.children) {
+            const root = createSegmentGroupFromRouteRecursive(childSnapshot);
+            childOutlets[childSnapshot.outlet] = root;
+        }
+        const segmentGroup = new UrlSegmentGroup(currentRoute.url, childOutlets);
+        if (currentRoute === route) {
+            targetGroup = segmentGroup;
+        }
+        return segmentGroup;
+    }
+    const rootCandidate = createSegmentGroupFromRouteRecursive(route.root);
+    const rootSegmentGroup = createRoot(rootCandidate);
+    return targetGroup ?? rootSegmentGroup;
+}
+function createUrlTreeFromSegmentGroup(relativeTo, commands, queryParams, fragment) {
+    let root = relativeTo;
+    while (root.parent) {
+        root = root.parent;
+    }
+    // There are no commands so the `UrlTree` goes to the same path as the one created from the
+    // `UrlSegmentGroup`. All we need to do is update the `queryParams` and `fragment` without
+    // applying any other logic.
+    if (commands.length === 0) {
+        return tree(root, root, root, queryParams, fragment);
     }
-    /** @docsNotRequired */
-    toString() {
-        return serializePath(this);
+    const nav = computeNavigation(commands);
+    if (nav.toRoot()) {
+        return tree(root, root, new UrlSegmentGroup([], {}), queryParams, fragment);
     }
+    const position = findStartingPositionForTargetGroup(nav, root, relativeTo);
+    const newSegmentGroup = position.processChildren ?
+        updateSegmentGroupChildren(position.segmentGroup, position.index, nav.commands) :
+        updateSegmentGroup(position.segmentGroup, position.index, nav.commands);
+    return tree(root, position.segmentGroup, newSegmentGroup, queryParams, fragment);
 }
-function equalSegments(as, bs) {
-    return equalPath(as, bs) && as.every((a, i) => shallowEqual(a.parameters, bs[i].parameters));
-}
-function equalPath(as, bs) {
-    if (as.length !== bs.length)
-        return false;
-    return as.every((a, i) => a.path === bs[i].path);
-}
-function mapChildrenIntoArray(segment, fn) {
-    let res = [];
-    forEach(segment.children, (child, childOutlet) => {
-        if (childOutlet === PRIMARY_OUTLET) {
-            res = res.concat(fn(child, childOutlet));
-        }
-    });
-    forEach(segment.children, (child, childOutlet) => {
-        if (childOutlet !== PRIMARY_OUTLET) {
-            res = res.concat(fn(child, childOutlet));
+function createUrlTree(route, urlTree, commands, queryParams, fragment) {
+    if (commands.length === 0) {
+        return tree(urlTree.root, urlTree.root, urlTree.root, queryParams, fragment);
+    }
+    const nav = computeNavigation(commands);
+    if (nav.toRoot()) {
+        return tree(urlTree.root, urlTree.root, new UrlSegmentGroup([], {}), queryParams, fragment);
+    }
+    function createTreeUsingPathIndex(lastPathIndex) {
+        const startingPosition = findStartingPosition(nav, urlTree, route.snapshot?._urlSegment, lastPathIndex);
+        const segmentGroup = startingPosition.processChildren ?
+            updateSegmentGroupChildren(startingPosition.segmentGroup, startingPosition.index, nav.commands) :
+            updateSegmentGroup(startingPosition.segmentGroup, startingPosition.index, nav.commands);
+        return tree(urlTree.root, startingPosition.segmentGroup, segmentGroup, queryParams, fragment);
+    }
+    // Note: The types should disallow `snapshot` from being `undefined` but due to test mocks, this
+    // may be the case. Since we try to access it at an earlier point before the refactor to add the
+    // warning for `relativeLinkResolution: 'legacy'`, this may cause failures in tests where it
+    // didn't before.
+    const result = createTreeUsingPathIndex(route.snapshot?._lastPathIndex);
+    // Check if application is relying on `relativeLinkResolution: 'legacy'`
+    if (typeof ngDevMode === 'undefined' || !!ngDevMode) {
+        const correctedResult = createTreeUsingPathIndex(route.snapshot?._correctedLastPathIndex);
+        if (correctedResult.toString() !== result.toString()) {
+            console.warn(`relativeLinkResolution: 'legacy' is deprecated and will be removed in a future version of Angular. The link to ${result.toString()} will change to ${correctedResult.toString()} if the code is not updated before then.`);
         }
-    });
-    return res;
+    }
+    return result;
 }
-/**
- * @description
- *
- * Serializes and deserializes a URL string into a URL tree.
- *
- * The url serialization strategy is customizable. You can
- * make all URLs case insensitive by providing a custom UrlSerializer.
- *
- * See `DefaultUrlSerializer` for an example of a URL serializer.
- *
- * @publicApi
- */
-class UrlSerializer {
+function isMatrixParams(command) {
+    return typeof command === 'object' && command != null && !command.outlets && !command.segmentPath;
 }
 /**
- * @description
- *
- * A default implementation of the `UrlSerializer`.
- *
- * Example URLs:
- *
- * ```
- * /inbox/33(popup:compose)
- * /inbox/33;open=true/messages/44
- * ```
- *
- * DefaultUrlSerializer uses parentheses to serialize secondary segments (e.g., popup:compose), the
- * colon syntax to specify the outlet, and the ';parameter=value' syntax (e.g., open=true) to
- * specify route specific parameters.
- *
- * @publicApi
+ * Determines if a given command has an `outlets` map. When we encounter a command
+ * with an outlets k/v map, we need to apply each outlet individually to the existing segment.
  */
-class DefaultUrlSerializer {
-    /** Parses a url into a `UrlTree` */
-    parse(url) {
-        const p = new UrlParser(url);
-        return new UrlTree(p.parseRootSegment(), p.parseQueryParams(), p.parseFragment());
-    }
-    /** Converts a `UrlTree` into a url */
-    serialize(tree) {
-        const segment = `/${serializeSegment(tree.root, true)}`;
-        const query = serializeQueryParams(tree.queryParams);
-        const fragment = typeof tree.fragment === `string` ? `#${encodeUriFragment(tree.fragment)}` : '';
-        return `${segment}${query}${fragment}`;
-    }
-}
-const DEFAULT_SERIALIZER = new DefaultUrlSerializer();
-function serializePaths(segment) {
-    return segment.segments.map(p => serializePath(p)).join('/');
+function isCommandWithOutlets(command) {
+    return typeof command === 'object' && command != null && command.outlets;
 }
-function serializeSegment(segment, root) {
-    if (!segment.hasChildren()) {
-        return serializePaths(segment);
-    }
-    if (root) {
-        const primary = segment.children[PRIMARY_OUTLET] ?
-            serializeSegment(segment.children[PRIMARY_OUTLET], false) :
-            '';
-        const children = [];
-        forEach(segment.children, (v, k) => {
-            if (k !== PRIMARY_OUTLET) {
-                children.push(`${k}:${serializeSegment(v, false)}`);
-            }
+function tree(oldRoot, oldSegmentGroup, newSegmentGroup, queryParams, fragment) {
+    let qp = {};
+    if (queryParams) {
+        forEach(queryParams, (value, name) => {
+            qp[name] = Array.isArray(value) ? value.map((v) => `${v}`) : `${value}`;
         });
-        return children.length > 0 ? `${primary}(${children.join('//')})` : primary;
+    }
+    let rootCandidate;
+    if (oldRoot === oldSegmentGroup) {
+        rootCandidate = newSegmentGroup;
     }
     else {
-        const children = mapChildrenIntoArray(segment, (v, k) => {
-            if (k === PRIMARY_OUTLET) {
-                return [serializeSegment(segment.children[PRIMARY_OUTLET], false)];
-            }
-            return [`${k}:${serializeSegment(v, false)}`];
-        });
-        // use no parenthesis if the only child is a primary outlet route
-        if (Object.keys(segment.children).length === 1 && segment.children[PRIMARY_OUTLET] != null) {
-            return `${serializePaths(segment)}/${children[0]}`;
-        }
-        return `${serializePaths(segment)}/(${children.join('//')})`;
+        rootCandidate = replaceSegment(oldRoot, oldSegmentGroup, newSegmentGroup);
     }
+    const newRoot = createRoot(squashSegmentGroup(rootCandidate));
+    return new UrlTree(newRoot, qp, fragment);
 }
 /**
- * Encodes a URI string with the default encoding. This function will only ever be called from
- * `encodeUriQuery` or `encodeUriSegment` as it's the base set of encodings to be used. We need
- * a custom encoding because encodeURIComponent is too aggressive and encodes stuff that doesn't
- * have to be encoded per https://url.spec.whatwg.org.
- */
-function encodeUriString(s) {
-    return encodeURIComponent(s)
-        .replace(/%40/g, '@')
-        .replace(/%3A/gi, ':')
-        .replace(/%24/g, '$')
-        .replace(/%2C/gi, ',');
-}
-/**
- * This function should be used to encode both keys and values in a query string key/value. In
- * the following URL, you need to call encodeUriQuery on "k" and "v":
- *
- * http://www.site.org/html;mk=mv?k=v#f
+ * Replaces the `oldSegment` which is located in some child of the `current` with the `newSegment`.
+ * This also has the effect of creating new `UrlSegmentGroup` copies to update references. This
+ * shouldn't be necessary but the fallback logic for an invalid ActivatedRoute in the creation uses
+ * the Router's current url tree. If we don't create new segment groups, we end up modifying that
+ * value.
  */
-function encodeUriQuery(s) {
-    return encodeUriString(s).replace(/%3B/gi, ';');
+function replaceSegment(current, oldSegment, newSegment) {
+    const children = {};
+    forEach(current.children, (c, outletName) => {
+        if (c === oldSegment) {
+            children[outletName] = newSegment;
+        }
+        else {
+            children[outletName] = replaceSegment(c, oldSegment, newSegment);
+        }
+    });
+    return new UrlSegmentGroup(current.segments, children);
 }
-/**
- * This function should be used to encode a URL fragment. In the following URL, you need to call
- * encodeUriFragment on "f":
- *
- * http://www.site.org/html;mk=mv?k=v#f
- */
-function encodeUriFragment(s) {
-    return encodeURI(s);
-}
-/**
- * This function should be run on any URI segment as well as the key and value in a key/value
- * pair for matrix params. In the following URL, you need to call encodeUriSegment on "html",
- * "mk", and "mv":
- *
- * http://www.site.org/html;mk=mv?k=v#f
- */
-function encodeUriSegment(s) {
-    return encodeUriString(s).replace(/\(/g, '%28').replace(/\)/g, '%29').replace(/%26/gi, '&');
-}
-function decode(s) {
-    return decodeURIComponent(s);
-}
-// Query keys/values should have the "+" replaced first, as "+" in a query string is " ".
-// decodeURIComponent function will not decode "+" as a space.
-function decodeQuery(s) {
-    return decode(s.replace(/\+/g, '%20'));
+class Navigation {
+    constructor(isAbsolute, numberOfDoubleDots, commands) {
+        this.isAbsolute = isAbsolute;
+        this.numberOfDoubleDots = numberOfDoubleDots;
+        this.commands = commands;
+        if (isAbsolute && commands.length > 0 && isMatrixParams(commands[0])) {
+            throw new Error('Root segment cannot have matrix parameters');
+        }
+        const cmdWithOutlet = commands.find(isCommandWithOutlets);
+        if (cmdWithOutlet && cmdWithOutlet !== last(commands)) {
+            throw new Error('{outlets:{}} has to be the last command');
+        }
+    }
+    toRoot() {
+        return this.isAbsolute && this.commands.length === 1 && this.commands[0] == '/';
+    }
 }
-function serializePath(path) {
-    return `${encodeUriSegment(path.path)}${serializeMatrixParams(path.parameters)}`;
+/** Transforms commands to a normalized `Navigation` */
+function computeNavigation(commands) {
+    if ((typeof commands[0] === 'string') && commands.length === 1 && commands[0] === '/') {
+        return new Navigation(true, 0, commands);
+    }
+    let numberOfDoubleDots = 0;
+    let isAbsolute = false;
+    const res = commands.reduce((res, cmd, cmdIdx) => {
+        if (typeof cmd === 'object' && cmd != null) {
+            if (cmd.outlets) {
+                const outlets = {};
+                forEach(cmd.outlets, (commands, name) => {
+                    outlets[name] = typeof commands === 'string' ? commands.split('/') : commands;
+                });
+                return [...res, { outlets }];
+            }
+            if (cmd.segmentPath) {
+                return [...res, cmd.segmentPath];
+            }
+        }
+        if (!(typeof cmd === 'string')) {
+            return [...res, cmd];
+        }
+        if (cmdIdx === 0) {
+            cmd.split('/').forEach((urlPart, partIndex) => {
+                if (partIndex == 0 && urlPart === '.') {
+                    // skip './a'
+                }
+                else if (partIndex == 0 && urlPart === '') { //  '/a'
+                    isAbsolute = true;
+                }
+                else if (urlPart === '..') { //  '../a'
+                    numberOfDoubleDots++;
+                }
+                else if (urlPart != '') {
+                    res.push(urlPart);
+                }
+            });
+            return res;
+        }
+        return [...res, cmd];
+    }, []);
+    return new Navigation(isAbsolute, numberOfDoubleDots, res);
 }
-function serializeMatrixParams(params) {
-    return Object.keys(params)
-        .map(key => `;${encodeUriSegment(key)}=${encodeUriSegment(params[key])}`)
-        .join('');
+class Position {
+    constructor(segmentGroup, processChildren, index) {
+        this.segmentGroup = segmentGroup;
+        this.processChildren = processChildren;
+        this.index = index;
+    }
 }
-function serializeQueryParams(params) {
-    const strParams = Object.keys(params)
-        .map((name) => {
-        const value = params[name];
-        return Array.isArray(value) ?
-            value.map(v => `${encodeUriQuery(name)}=${encodeUriQuery(v)}`).join('&') :
-            `${encodeUriQuery(name)}=${encodeUriQuery(value)}`;
-    })
-        .filter(s => !!s);
-    return strParams.length ? `?${strParams.join('&')}` : '';
+function findStartingPositionForTargetGroup(nav, root, target) {
+    if (nav.isAbsolute) {
+        return new Position(root, true, 0);
+    }
+    if (!target) {
+        // `NaN` is used only to maintain backwards compatibility with incorrectly mocked
+        // `ActivatedRouteSnapshot` in tests. In prior versions of this code, the position here was
+        // determined based on an internal property that was rarely mocked, resulting in `NaN`. In
+        // reality, this code path should _never_ be touched since `target` is not allowed to be falsey.
+        return new Position(root, false, NaN);
+    }
+    if (target.parent === null) {
+        return new Position(target, true, 0);
+    }
+    const modifier = isMatrixParams(nav.commands[0]) ? 0 : 1;
+    const index = target.segments.length - 1 + modifier;
+    return createPositionApplyingDoubleDots(target, index, nav.numberOfDoubleDots);
 }
-const SEGMENT_RE = /^[^\/()?;=#]+/;
-function matchSegments(str) {
-    const match = str.match(SEGMENT_RE);
-    return match ? match[0] : '';
+function findStartingPosition(nav, tree, segmentGroup, lastPathIndex) {
+    if (nav.isAbsolute) {
+        return new Position(tree.root, true, 0);
+    }
+    if (lastPathIndex === -1) {
+        // Pathless ActivatedRoute has _lastPathIndex === -1 but should not process children
+        // see issue #26224, #13011, #35687
+        // However, if the ActivatedRoute is the root we should process children like above.
+        const processChildren = segmentGroup === tree.root;
+        return new Position(segmentGroup, processChildren, 0);
+    }
+    const modifier = isMatrixParams(nav.commands[0]) ? 0 : 1;
+    const index = lastPathIndex + modifier;
+    return createPositionApplyingDoubleDots(segmentGroup, index, nav.numberOfDoubleDots);
 }
-const QUERY_PARAM_RE = /^[^=?&#]+/;
-// Return the name of the query param at the start of the string or an empty string
-function matchQueryParams(str) {
-    const match = str.match(QUERY_PARAM_RE);
-    return match ? match[0] : '';
+function createPositionApplyingDoubleDots(group, index, numberOfDoubleDots) {
+    let g = group;
+    let ci = index;
+    let dd = numberOfDoubleDots;
+    while (dd > ci) {
+        dd -= ci;
+        g = g.parent;
+        if (!g) {
+            throw new Error('Invalid number of \'../\'');
+        }
+        ci = g.segments.length;
+    }
+    return new Position(g, false, ci - dd);
 }
-const QUERY_PARAM_VALUE_RE = /^[^&#]+/;
-// Return the value of the query param at the start of the string or an empty string
-function matchUrlQueryParamValue(str) {
-    const match = str.match(QUERY_PARAM_VALUE_RE);
-    return match ? match[0] : '';
+function getOutlets(commands) {
+    if (isCommandWithOutlets(commands[0])) {
+        return commands[0].outlets;
+    }
+    return { [PRIMARY_OUTLET]: commands };
 }
-class UrlParser {
-    constructor(url) {
-        this.url = url;
-        this.remaining = url;
+function updateSegmentGroup(segmentGroup, startIndex, commands) {
+    if (!segmentGroup) {
+        segmentGroup = new UrlSegmentGroup([], {});
     }
-    parseRootSegment() {
-        this.consumeOptional('/');
-        if (this.remaining === '' || this.peekStartsWith('?') || this.peekStartsWith('#')) {
-            return new UrlSegmentGroup([], {});
-        }
-        // The root segment group never has segments
-        return new UrlSegmentGroup([], this.parseChildren());
+    if (segmentGroup.segments.length === 0 && segmentGroup.hasChildren()) {
+        return updateSegmentGroupChildren(segmentGroup, startIndex, commands);
     }
-    parseQueryParams() {
-        const params = {};
-        if (this.consumeOptional('?')) {
-            do {
-                this.parseQueryParam(params);
-            } while (this.consumeOptional('&'));
-        }
-        return params;
+    const m = prefixedWith(segmentGroup, startIndex, commands);
+    const slicedCommands = commands.slice(m.commandIndex);
+    if (m.match && m.pathIndex < segmentGroup.segments.length) {
+        const g = new UrlSegmentGroup(segmentGroup.segments.slice(0, m.pathIndex), {});
+        g.children[PRIMARY_OUTLET] =
+            new UrlSegmentGroup(segmentGroup.segments.slice(m.pathIndex), segmentGroup.children);
+        return updateSegmentGroupChildren(g, 0, slicedCommands);
     }
-    parseFragment() {
-        return this.consumeOptional('#') ? decodeURIComponent(this.remaining) : null;
+    else if (m.match && slicedCommands.length === 0) {
+        return new UrlSegmentGroup(segmentGroup.segments, {});
     }
-    parseChildren() {
-        if (this.remaining === '') {
-            return {};
-        }
-        this.consumeOptional('/');
-        const segments = [];
-        if (!this.peekStartsWith('(')) {
-            segments.push(this.parseSegment());
-        }
-        while (this.peekStartsWith('/') && !this.peekStartsWith('//') && !this.peekStartsWith('/(')) {
-            this.capture('/');
-            segments.push(this.parseSegment());
-        }
-        let children = {};
-        if (this.peekStartsWith('/(')) {
-            this.capture('/');
-            children = this.parseParens(true);
-        }
-        let res = {};
-        if (this.peekStartsWith('(')) {
-            res = this.parseParens(false);
-        }
-        if (segments.length > 0 || Object.keys(children).length > 0) {
-            res[PRIMARY_OUTLET] = new UrlSegmentGroup(segments, children);
-        }
-        return res;
+    else if (m.match && !segmentGroup.hasChildren()) {
+        return createNewSegmentGroup(segmentGroup, startIndex, commands);
     }
-    // parse a segment with its matrix parameters
-    // ie `name;k1=v1;k2`
-    parseSegment() {
-        const path = matchSegments(this.remaining);
-        if (path === '' && this.peekStartsWith(';')) {
-            throw new Error(`Empty path url segment cannot have parameters: '${this.remaining}'.`);
-        }
-        this.capture(path);
-        return new UrlSegment(decode(path), this.parseMatrixParams());
+    else if (m.match) {
+        return updateSegmentGroupChildren(segmentGroup, 0, slicedCommands);
     }
-    parseMatrixParams() {
-        const params = {};
-        while (this.consumeOptional(';')) {
-            this.parseParam(params);
-        }
-        return params;
+    else {
+        return createNewSegmentGroup(segmentGroup, startIndex, commands);
     }
-    parseParam(params) {
-        const key = matchSegments(this.remaining);
-        if (!key) {
-            return;
-        }
-        this.capture(key);
-        let value = '';
-        if (this.consumeOptional('=')) {
-            const valueMatch = matchSegments(this.remaining);
-            if (valueMatch) {
-                value = valueMatch;
-                this.capture(value);
+}
+function updateSegmentGroupChildren(segmentGroup, startIndex, commands) {
+    if (commands.length === 0) {
+        return new UrlSegmentGroup(segmentGroup.segments, {});
+    }
+    else {
+        const outlets = getOutlets(commands);
+        const children = {};
+        forEach(outlets, (commands, outlet) => {
+            if (typeof commands === 'string') {
+                commands = [commands];
+            }
+            if (commands !== null) {
+                children[outlet] = updateSegmentGroup(segmentGroup.children[outlet], startIndex, commands);
+            }
+        });
+        forEach(segmentGroup.children, (child, childOutlet) => {
+            if (outlets[childOutlet] === undefined) {
+                children[childOutlet] = child;
             }
+        });
+        return new UrlSegmentGroup(segmentGroup.segments, children);
+    }
+}
+function prefixedWith(segmentGroup, startIndex, commands) {
+    let currentCommandIndex = 0;
+    let currentPathIndex = startIndex;
+    const noMatch = { match: false, pathIndex: 0, commandIndex: 0 };
+    while (currentPathIndex < segmentGroup.segments.length) {
+        if (currentCommandIndex >= commands.length)
+            return noMatch;
+        const path = segmentGroup.segments[currentPathIndex];
+        const command = commands[currentCommandIndex];
+        // Do not try to consume command as part of the prefixing if it has outlets because it can
+        // contain outlets other than the one being processed. Consuming the outlets command would
+        // result in other outlets being ignored.
+        if (isCommandWithOutlets(command)) {
+            break;
         }
-        params[decode(key)] = decode(value);
+        const curr = `${command}`;
+        const next = currentCommandIndex < commands.length - 1 ? commands[currentCommandIndex + 1] : null;
+        if (currentPathIndex > 0 && curr === undefined)
+            break;
+        if (curr && next && (typeof next === 'object') && next.outlets === undefined) {
+            if (!compare(curr, next, path))
+                return noMatch;
+            currentCommandIndex += 2;
+        }
+        else {
+            if (!compare(curr, {}, path))
+                return noMatch;
+            currentCommandIndex++;
+        }
+        currentPathIndex++;
     }
-    // Parse a single query parameter `name[=value]`
-    parseQueryParam(params) {
-        const key = matchQueryParams(this.remaining);
-        if (!key) {
-            return;
+    return { match: true, pathIndex: currentPathIndex, commandIndex: currentCommandIndex };
+}
+function createNewSegmentGroup(segmentGroup, startIndex, commands) {
+    const paths = segmentGroup.segments.slice(0, startIndex);
+    let i = 0;
+    while (i < commands.length) {
+        const command = commands[i];
+        if (isCommandWithOutlets(command)) {
+            const children = createNewSegmentChildren(command.outlets);
+            return new UrlSegmentGroup(paths, children);
         }
-        this.capture(key);
-        let value = '';
-        if (this.consumeOptional('=')) {
-            const valueMatch = matchUrlQueryParamValue(this.remaining);
-            if (valueMatch) {
-                value = valueMatch;
-                this.capture(value);
-            }
+        // if we start with an object literal, we need to reuse the path part from the segment
+        if (i === 0 && isMatrixParams(commands[0])) {
+            const p = segmentGroup.segments[startIndex];
+            paths.push(new UrlSegment(p.path, stringify(commands[0])));
+            i++;
+            continue;
         }
-        const decodedKey = decodeQuery(key);
-        const decodedVal = decodeQuery(value);
-        if (params.hasOwnProperty(decodedKey)) {
-            // Append to existing values
-            let currentVal = params[decodedKey];
-            if (!Array.isArray(currentVal)) {
-                currentVal = [currentVal];
-                params[decodedKey] = currentVal;
-            }
-            currentVal.push(decodedVal);
+        const curr = isCommandWithOutlets(command) ? command.outlets[PRIMARY_OUTLET] : `${command}`;
+        const next = (i < commands.length - 1) ? commands[i + 1] : null;
+        if (curr && next && isMatrixParams(next)) {
+            paths.push(new UrlSegment(curr, stringify(next)));
+            i += 2;
         }
         else {
-            // Create a new value
-            params[decodedKey] = decodedVal;
+            paths.push(new UrlSegment(curr, {}));
+            i++;
         }
     }
-    // parse `(a/b//outlet_name:c/d)`
-    parseParens(allowPrimary) {
-        const segments = {};
-        this.capture('(');
-        while (!this.consumeOptional(')') && this.remaining.length > 0) {
-            const path = matchSegments(this.remaining);
-            const next = this.remaining[path.length];
-            // if is is not one of these characters, then the segment was unescaped
-            // or the group was not closed
-            if (next !== '/' && next !== ')' && next !== ';') {
-                throw new Error(`Cannot parse url '${this.url}'`);
-            }
-            let outletName = undefined;
-            if (path.indexOf(':') > -1) {
-                outletName = path.slice(0, path.indexOf(':'));
-                this.capture(outletName);
-                this.capture(':');
-            }
-            else if (allowPrimary) {
-                outletName = PRIMARY_OUTLET;
-            }
-            const children = this.parseChildren();
-            segments[outletName] = Object.keys(children).length === 1 ? children[PRIMARY_OUTLET] :
-                new UrlSegmentGroup([], children);
-            this.consumeOptional('//');
+    return new UrlSegmentGroup(paths, {});
+}
+function createNewSegmentChildren(outlets) {
+    const children = {};
+    forEach(outlets, (commands, outlet) => {
+        if (typeof commands === 'string') {
+            commands = [commands];
         }
-        return segments;
+        if (commands !== null) {
+            children[outlet] = createNewSegmentGroup(new UrlSegmentGroup([], {}), 0, commands);
+        }
+    });
+    return children;
+}
+function stringify(params) {
+    const res = {};
+    forEach(params, (v, k) => res[k] = `${v}`);
+    return res;
+}
+function compare(path, params, segment) {
+    return path == segment.path && shallowEqual(params, segment.parameters);
+}
+
+/**
+ * @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.io/license
+ */
+/**
+ * Base for events the router goes through, as opposed to events tied to a specific
+ * route. Fired one time for any given navigation.
+ *
+ * The following code shows how a class subscribes to router events.
+ *
+ * ```ts
+ * import {Event, RouterEvent, Router} from '@angular/router';
+ *
+ * class MyService {
+ *   constructor(public router: Router) {
+ *     router.events.pipe(
+ *        filter((e: Event): e is RouterEvent => e instanceof RouterEvent)
+ *     ).subscribe((e: RouterEvent) => {
+ *       // Do something
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * @see `Event`
+ * @see [Router events summary](guide/router-reference#router-events)
+ * @publicApi
+ */
+class RouterEvent {
+    constructor(
+    /** A unique ID that the router assigns to every router navigation. */
+    id, 
+    /** The URL that is the destination for this navigation. */
+    url) {
+        this.id = id;
+        this.url = url;
+    }
+}
+/**
+ * An event triggered when a navigation starts.
+ *
+ * @publicApi
+ */
+class NavigationStart extends RouterEvent {
+    constructor(
+    /** @docsNotRequired */
+    id, 
+    /** @docsNotRequired */
+    url, 
+    /** @docsNotRequired */
+    navigationTrigger = 'imperative', 
+    /** @docsNotRequired */
+    restoredState = null) {
+        super(id, url);
+        this.type = 0 /* EventType.NavigationStart */;
+        this.navigationTrigger = navigationTrigger;
+        this.restoredState = restoredState;
+    }
+    /** @docsNotRequired */
+    toString() {
+        return `NavigationStart(id: ${this.id}, url: '${this.url}')`;
+    }
+}
+/**
+ * An event triggered when a navigation ends successfully.
+ *
+ * @see `NavigationStart`
+ * @see `NavigationCancel`
+ * @see `NavigationError`
+ *
+ * @publicApi
+ */
+class NavigationEnd extends RouterEvent {
+    constructor(
+    /** @docsNotRequired */
+    id, 
+    /** @docsNotRequired */
+    url, 
+    /** @docsNotRequired */
+    urlAfterRedirects) {
+        super(id, url);
+        this.urlAfterRedirects = urlAfterRedirects;
+        this.type = 1 /* EventType.NavigationEnd */;
     }
-    peekStartsWith(str) {
-        return this.remaining.startsWith(str);
+    /** @docsNotRequired */
+    toString() {
+        return `NavigationEnd(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}')`;
     }
-    // Consumes the prefix when it is present and returns whether it has been consumed
-    consumeOptional(str) {
-        if (this.peekStartsWith(str)) {
-            this.remaining = this.remaining.substring(str.length);
-            return true;
-        }
-        return false;
+}
+/**
+ * An event triggered when a navigation is canceled, directly or indirectly.
+ * This can happen for several reasons including when a route guard
+ * returns `false` or initiates a redirect by returning a `UrlTree`.
+ *
+ * @see `NavigationStart`
+ * @see `NavigationEnd`
+ * @see `NavigationError`
+ *
+ * @publicApi
+ */
+class NavigationCancel extends RouterEvent {
+    constructor(
+    /** @docsNotRequired */
+    id, 
+    /** @docsNotRequired */
+    url, 
+    /** @docsNotRequired */
+    reason) {
+        super(id, url);
+        this.reason = reason;
+        this.type = 2 /* EventType.NavigationCancel */;
     }
-    capture(str) {
-        if (!this.consumeOptional(str)) {
-            throw new Error(`Expected "${str}".`);
-        }
+    /** @docsNotRequired */
+    toString() {
+        return `NavigationCancel(id: ${this.id}, url: '${this.url}')`;
     }
 }
-
 /**
- * @license
- * Copyright Google LLC All Rights Reserved.
+ * An event triggered when a navigation fails due to an unexpected error.
  *
- * 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
+ * @see `NavigationStart`
+ * @see `NavigationEnd`
+ * @see `NavigationCancel`
+ *
+ * @publicApi
  */
-class Tree {
-    constructor(root) {
-        this._root = root;
-    }
-    get root() {
-        return this._root.value;
+class NavigationError extends RouterEvent {
+    constructor(
+    /** @docsNotRequired */
+    id, 
+    /** @docsNotRequired */
+    url, 
+    /** @docsNotRequired */
+    error) {
+        super(id, url);
+        this.error = error;
+        this.type = 3 /* EventType.NavigationError */;
     }
-    /**
-     * @internal
-     */
-    parent(t) {
-        const p = this.pathFromRoot(t);
-        return p.length > 1 ? p[p.length - 2] : null;
+    /** @docsNotRequired */
+    toString() {
+        return `NavigationError(id: ${this.id}, url: '${this.url}', error: ${this.error})`;
     }
-    /**
-     * @internal
-     */
-    children(t) {
-        const n = findNode(t, this._root);
-        return n ? n.children.map(t => t.value) : [];
+}
+/**
+ * An event triggered when routes are recognized.
+ *
+ * @publicApi
+ */
+class RoutesRecognized extends RouterEvent {
+    constructor(
+    /** @docsNotRequired */
+    id, 
+    /** @docsNotRequired */
+    url, 
+    /** @docsNotRequired */
+    urlAfterRedirects, 
+    /** @docsNotRequired */
+    state) {
+        super(id, url);
+        this.urlAfterRedirects = urlAfterRedirects;
+        this.state = state;
+        this.type = 4 /* EventType.RoutesRecognized */;
     }
-    /**
-     * @internal
-     */
-    firstChild(t) {
-        const n = findNode(t, this._root);
-        return n && n.children.length > 0 ? n.children[0].value : null;
+    /** @docsNotRequired */
+    toString() {
+        return `RoutesRecognized(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state})`;
     }
-    /**
-     * @internal
-     */
-    siblings(t) {
-        const p = findPath(t, this._root);
-        if (p.length < 2)
-            return [];
-        const c = p[p.length - 2].children.map(c => c.value);
-        return c.filter(cc => cc !== t);
+}
+/**
+ * An event triggered at the start of the Guard phase of routing.
+ *
+ * @see `GuardsCheckEnd`
+ *
+ * @publicApi
+ */
+class GuardsCheckStart extends RouterEvent {
+    constructor(
+    /** @docsNotRequired */
+    id, 
+    /** @docsNotRequired */
+    url, 
+    /** @docsNotRequired */
+    urlAfterRedirects, 
+    /** @docsNotRequired */
+    state) {
+        super(id, url);
+        this.urlAfterRedirects = urlAfterRedirects;
+        this.state = state;
+        this.type = 7 /* EventType.GuardsCheckStart */;
     }
-    /**
-     * @internal
-     */
-    pathFromRoot(t) {
-        return findPath(t, this._root).map(s => s.value);
+    toString() {
+        return `GuardsCheckStart(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state})`;
     }
 }
-// DFS for the node matching the value
-function findNode(value, node) {
-    if (value === node.value)
-        return node;
-    for (const child of node.children) {
-        const node = findNode(value, child);
-        if (node)
-            return node;
+/**
+ * An event triggered at the end of the Guard phase of routing.
+ *
+ * @see `GuardsCheckStart`
+ *
+ * @publicApi
+ */
+class GuardsCheckEnd extends RouterEvent {
+    constructor(
+    /** @docsNotRequired */
+    id, 
+    /** @docsNotRequired */
+    url, 
+    /** @docsNotRequired */
+    urlAfterRedirects, 
+    /** @docsNotRequired */
+    state, 
+    /** @docsNotRequired */
+    shouldActivate) {
+        super(id, url);
+        this.urlAfterRedirects = urlAfterRedirects;
+        this.state = state;
+        this.shouldActivate = shouldActivate;
+        this.type = 8 /* EventType.GuardsCheckEnd */;
+    }
+    toString() {
+        return `GuardsCheckEnd(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state}, shouldActivate: ${this.shouldActivate})`;
     }
-    return null;
 }
-// Return the path to the node with the given value using DFS
-function findPath(value, node) {
-    if (value === node.value)
-        return [node];
-    for (const child of node.children) {
-        const path = findPath(value, child);
-        if (path.length) {
-            path.unshift(node);
-            return path;
-        }
+/**
+ * An event triggered at the start of the Resolve phase of routing.
+ *
+ * Runs in the "resolve" phase whether or not there is anything to resolve.
+ * In future, may change to only run when there are things to be resolved.
+ *
+ * @see `ResolveEnd`
+ *
+ * @publicApi
+ */
+class ResolveStart extends RouterEvent {
+    constructor(
+    /** @docsNotRequired */
+    id, 
+    /** @docsNotRequired */
+    url, 
+    /** @docsNotRequired */
+    urlAfterRedirects, 
+    /** @docsNotRequired */
+    state) {
+        super(id, url);
+        this.urlAfterRedirects = urlAfterRedirects;
+        this.state = state;
+        this.type = 5 /* EventType.ResolveStart */;
+    }
+    toString() {
+        return `ResolveStart(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state})`;
     }
-    return [];
 }
-class TreeNode {
-    constructor(value, children) {
-        this.value = value;
-        this.children = children;
+/**
+ * An event triggered at the end of the Resolve phase of routing.
+ * @see `ResolveStart`.
+ *
+ * @publicApi
+ */
+class ResolveEnd extends RouterEvent {
+    constructor(
+    /** @docsNotRequired */
+    id, 
+    /** @docsNotRequired */
+    url, 
+    /** @docsNotRequired */
+    urlAfterRedirects, 
+    /** @docsNotRequired */
+    state) {
+        super(id, url);
+        this.urlAfterRedirects = urlAfterRedirects;
+        this.state = state;
+        this.type = 6 /* EventType.ResolveEnd */;
     }
     toString() {
-        return `TreeNode(${this.value})`;
-    }
-}
-// Return the list of T indexed by outlet name
-function nodeChildrenAsMap(node) {
-    const map = {};
-    if (node) {
-        node.children.forEach(child => map[child.value.outlet] = child);
+        return `ResolveEnd(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state})`;
     }
-    return map;
 }
-
 /**
- * @license
- * Copyright Google LLC All Rights Reserved.
+ * An event triggered before lazy loading a route configuration.
  *
- * 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
+ * @see `RouteConfigLoadEnd`
+ *
+ * @publicApi
  */
+class RouteConfigLoadStart {
+    constructor(
+    /** @docsNotRequired */
+    route) {
+        this.route = route;
+        this.type = 9 /* EventType.RouteConfigLoadStart */;
+    }
+    toString() {
+        return `RouteConfigLoadStart(path: ${this.route.path})`;
+    }
+}
 /**
- * Represents the state of the router as a tree of activated routes.
- *
- * @usageNotes
- *
- * Every node in the route tree is an `ActivatedRoute` instance
- * that knows about the "consumed" URL segments, the extracted parameters,
- * and the resolved data.
- * Use the `ActivatedRoute` properties to traverse the tree from any node.
- *
- * The following fragment shows how a component gets the root node
- * of the current state to establish its own route tree:
- *
- * ```
- * @Component({templateUrl:'template.html'})
- * class MyComponent {
- *   constructor(router: Router) {
- *     const state: RouterState = router.routerState;
- *     const root: ActivatedRoute = state.root;
- *     const child = root.firstChild;
- *     const id: Observable<string> = child.params.map(p => p.id);
- *     //...
- *   }
- * }
- * ```
+ * An event triggered when a route has been lazy loaded.
  *
- * @see `ActivatedRoute`
- * @see [Getting route information](guide/router#getting-route-information)
+ * @see `RouteConfigLoadStart`
  *
  * @publicApi
  */
-class RouterState extends Tree {
-    /** @internal */
-    constructor(root, 
-    /** The current snapshot of the router state */
-    snapshot) {
-        super(root);
-        this.snapshot = snapshot;
-        setRouterState(this, root);
+class RouteConfigLoadEnd {
+    constructor(
+    /** @docsNotRequired */
+    route) {
+        this.route = route;
+        this.type = 10 /* EventType.RouteConfigLoadEnd */;
     }
     toString() {
-        return this.snapshot.toString();
+        return `RouteConfigLoadEnd(path: ${this.route.path})`;
     }
 }
-function createEmptyState(urlTree, rootComponent) {
-    const snapshot = createEmptyStateSnapshot(urlTree, rootComponent);
-    const emptyUrl = new BehaviorSubject([new UrlSegment('', {})]);
-    const emptyParams = new BehaviorSubject({});
-    const emptyData = new BehaviorSubject({});
-    const emptyQueryParams = new BehaviorSubject({});
-    const fragment = new BehaviorSubject('');
-    const activated = new ActivatedRoute(emptyUrl, emptyParams, emptyQueryParams, fragment, emptyData, PRIMARY_OUTLET, rootComponent, snapshot.root);
-    activated.snapshot = snapshot.root;
-    return new RouterState(new TreeNode(activated, []), snapshot);
-}
-function createEmptyStateSnapshot(urlTree, rootComponent) {
-    const emptyParams = {};
-    const emptyData = {};
-    const emptyQueryParams = {};
-    const fragment = '';
-    const activated = new ActivatedRouteSnapshot([], emptyParams, emptyQueryParams, fragment, emptyData, PRIMARY_OUTLET, rootComponent, null, urlTree.root, -1, {});
-    return new RouterStateSnapshot('', new TreeNode(activated, []));
-}
 /**
- * Provides access to information about a route associated with a component
- * that is loaded in an outlet.
- * Use to traverse the `RouterState` tree and extract information from nodes.
- *
- * The following example shows how to construct a component using information from a
- * currently activated route.
- *
- * Note: the observables in this class only emit when the current and previous values differ based
- * on shallow equality. For example, changing deeply nested properties in resolved `data` will not
- * cause the `ActivatedRoute.data` `Observable` to emit a new value.
- *
- * {@example router/activated-route/module.ts region="activated-route"
- *     header="activated-route.component.ts"}
- *
- * @see [Getting route information](guide/router#getting-route-information)
+ * An event triggered at the start of the child-activation
+ * part of the Resolve phase of routing.
+ * @see  `ChildActivationEnd`
+ * @see `ResolveStart`
  *
  * @publicApi
  */
-class ActivatedRoute {
-    /** @internal */
+class ChildActivationStart {
     constructor(
-    /** An observable of the URL segments matched by this route. */
-    url, 
-    /** An observable of the matrix parameters scoped to this route. */
-    params, 
-    /** An observable of the query parameters shared by all the routes. */
-    queryParams, 
-    /** An observable of the URL fragment shared by all the routes. */
-    fragment, 
-    /** An observable of the static and resolved data of this route. */
-    data, 
-    /** The outlet name of the route, a constant. */
-    outlet, 
-    /** The component of the route, a constant. */
-    component, futureSnapshot) {
-        this.url = url;
-        this.params = params;
-        this.queryParams = queryParams;
-        this.fragment = fragment;
-        this.data = data;
-        this.outlet = outlet;
-        this.component = component;
-        this._futureSnapshot = futureSnapshot;
+    /** @docsNotRequired */
+    snapshot) {
+        this.snapshot = snapshot;
+        this.type = 11 /* EventType.ChildActivationStart */;
     }
-    /** The configuration used to match this route. */
-    get routeConfig() {
-        return this._futureSnapshot.routeConfig;
+    toString() {
+        const path = this.snapshot.routeConfig && this.snapshot.routeConfig.path || '';
+        return `ChildActivationStart(path: '${path}')`;
     }
-    /** The root of the router state. */
-    get root() {
-        return this._routerState.root;
+}
+/**
+ * An event triggered at the end of the child-activation part
+ * of the Resolve phase of routing.
+ * @see `ChildActivationStart`
+ * @see `ResolveStart`
+ * @publicApi
+ */
+class ChildActivationEnd {
+    constructor(
+    /** @docsNotRequired */
+    snapshot) {
+        this.snapshot = snapshot;
+        this.type = 12 /* EventType.ChildActivationEnd */;
     }
-    /** The parent of this route in the router state tree. */
-    get parent() {
-        return this._routerState.parent(this);
+    toString() {
+        const path = this.snapshot.routeConfig && this.snapshot.routeConfig.path || '';
+        return `ChildActivationEnd(path: '${path}')`;
     }
-    /** The first child of this route in the router state tree. */
-    get firstChild() {
-        return this._routerState.firstChild(this);
+}
+/**
+ * An event triggered at the start of the activation part
+ * of the Resolve phase of routing.
+ * @see `ActivationEnd`
+ * @see `ResolveStart`
+ *
+ * @publicApi
+ */
+class ActivationStart {
+    constructor(
+    /** @docsNotRequired */
+    snapshot) {
+        this.snapshot = snapshot;
+        this.type = 13 /* EventType.ActivationStart */;
     }
-    /** The children of this route in the router state tree. */
-    get children() {
-        return this._routerState.children(this);
+    toString() {
+        const path = this.snapshot.routeConfig && this.snapshot.routeConfig.path || '';
+        return `ActivationStart(path: '${path}')`;
     }
-    /** The path from the root of the router state tree to this route. */
-    get pathFromRoot() {
-        return this._routerState.pathFromRoot(this);
+}
+/**
+ * An event triggered at the end of the activation part
+ * of the Resolve phase of routing.
+ * @see `ActivationStart`
+ * @see `ResolveStart`
+ *
+ * @publicApi
+ */
+class ActivationEnd {
+    constructor(
+    /** @docsNotRequired */
+    snapshot) {
+        this.snapshot = snapshot;
+        this.type = 14 /* EventType.ActivationEnd */;
     }
-    /**
-     * An Observable that contains a map of the required and optional parameters
-     * specific to the route.
-     * The map supports retrieving single and multiple values from the same parameter.
-     */
-    get paramMap() {
-        if (!this._paramMap) {
-            this._paramMap = this.params.pipe(map((p) => convertToParamMap(p)));
-        }
-        return this._paramMap;
+    toString() {
+        const path = this.snapshot.routeConfig && this.snapshot.routeConfig.path || '';
+        return `ActivationEnd(path: '${path}')`;
     }
-    /**
-     * An Observable that contains a map of the query parameters available to all routes.
-     * The map supports retrieving single and multiple values from the query parameter.
-     */
-    get queryParamMap() {
-        if (!this._queryParamMap) {
-            this._queryParamMap =
-                this.queryParams.pipe(map((p) => convertToParamMap(p)));
-        }
-        return this._queryParamMap;
+}
+/**
+ * An event triggered by scrolling.
+ *
+ * @publicApi
+ */
+class Scroll {
+    constructor(
+    /** @docsNotRequired */
+    routerEvent, 
+    /** @docsNotRequired */
+    position, 
+    /** @docsNotRequired */
+    anchor) {
+        this.routerEvent = routerEvent;
+        this.position = position;
+        this.anchor = anchor;
+        this.type = 15 /* EventType.Scroll */;
     }
     toString() {
-        return this.snapshot ? this.snapshot.toString() : `Future(${this._futureSnapshot})`;
+        const pos = this.position ? `${this.position[0]}, ${this.position[1]}` : null;
+        return `Scroll(anchor: '${this.anchor}', position: '${pos}')`;
     }
 }
-/**
- * Returns the inherited params, data, and resolve for a given route.
- * By default, this only inherits values up to the nearest path-less or component-less route.
- * @internal
- */
-function inheritedParamsDataResolve(route, paramsInheritanceStrategy = 'emptyOnly') {
-    const pathFromRoot = route.pathFromRoot;
-    let inheritingStartingFrom = 0;
-    if (paramsInheritanceStrategy !== 'always') {
-        inheritingStartingFrom = pathFromRoot.length - 1;
-        while (inheritingStartingFrom >= 1) {
-            const current = pathFromRoot[inheritingStartingFrom];
-            const parent = pathFromRoot[inheritingStartingFrom - 1];
-            // current route is an empty path => inherits its parent's params and data
-            if (current.routeConfig && current.routeConfig.path === '') {
-                inheritingStartingFrom--;
-                // parent is componentless => current route should inherit its params and data
-            }
-            else if (!parent.component) {
-                inheritingStartingFrom--;
-            }
-            else {
-                break;
-            }
-        }
+function stringifyEvent(routerEvent) {
+    if (!('type' in routerEvent)) {
+        return `Unknown Router Event: ${routerEvent.constructor.name}`;
+    }
+    switch (routerEvent.type) {
+        case 14 /* EventType.ActivationEnd */:
+            return `ActivationEnd(path: '${routerEvent.snapshot.routeConfig?.path || ''}')`;
+        case 13 /* EventType.ActivationStart */:
+            return `ActivationStart(path: '${routerEvent.snapshot.routeConfig?.path || ''}')`;
+        case 12 /* EventType.ChildActivationEnd */:
+            return `ChildActivationEnd(path: '${routerEvent.snapshot.routeConfig?.path || ''}')`;
+        case 11 /* EventType.ChildActivationStart */:
+            return `ChildActivationStart(path: '${routerEvent.snapshot.routeConfig?.path || ''}')`;
+        case 8 /* EventType.GuardsCheckEnd */:
+            return `GuardsCheckEnd(id: ${routerEvent.id}, url: '${routerEvent.url}', urlAfterRedirects: '${routerEvent.urlAfterRedirects}', state: ${routerEvent.state}, shouldActivate: ${routerEvent.shouldActivate})`;
+        case 7 /* EventType.GuardsCheckStart */:
+            return `GuardsCheckStart(id: ${routerEvent.id}, url: '${routerEvent.url}', urlAfterRedirects: '${routerEvent.urlAfterRedirects}', state: ${routerEvent.state})`;
+        case 2 /* EventType.NavigationCancel */:
+            return `NavigationCancel(id: ${routerEvent.id}, url: '${routerEvent.url}')`;
+        case 1 /* EventType.NavigationEnd */:
+            return `NavigationEnd(id: ${routerEvent.id}, url: '${routerEvent.url}', urlAfterRedirects: '${routerEvent.urlAfterRedirects}')`;
+        case 3 /* EventType.NavigationError */:
+            return `NavigationError(id: ${routerEvent.id}, url: '${routerEvent.url}', error: ${routerEvent.error})`;
+        case 0 /* EventType.NavigationStart */:
+            return `NavigationStart(id: ${routerEvent.id}, url: '${routerEvent.url}')`;
+        case 6 /* EventType.ResolveEnd */:
+            return `ResolveEnd(id: ${routerEvent.id}, url: '${routerEvent.url}', urlAfterRedirects: '${routerEvent.urlAfterRedirects}', state: ${routerEvent.state})`;
+        case 5 /* EventType.ResolveStart */:
+            return `ResolveStart(id: ${routerEvent.id}, url: '${routerEvent.url}', urlAfterRedirects: '${routerEvent.urlAfterRedirects}', state: ${routerEvent.state})`;
+        case 10 /* EventType.RouteConfigLoadEnd */:
+            return `RouteConfigLoadEnd(path: ${routerEvent.route.path})`;
+        case 9 /* EventType.RouteConfigLoadStart */:
+            return `RouteConfigLoadStart(path: ${routerEvent.route.path})`;
+        case 4 /* EventType.RoutesRecognized */:
+            return `RoutesRecognized(id: ${routerEvent.id}, url: '${routerEvent.url}', urlAfterRedirects: '${routerEvent.urlAfterRedirects}', state: ${routerEvent.state})`;
+        case 15 /* EventType.Scroll */:
+            const pos = routerEvent.position ? `${routerEvent.position[0]}, ${routerEvent.position[1]}` : null;
+            return `Scroll(anchor: '${routerEvent.anchor}', position: '${pos}')`;
     }
-    return flattenInherited(pathFromRoot.slice(inheritingStartingFrom));
-}
-/** @internal */
-function flattenInherited(pathFromRoot) {
-    return pathFromRoot.reduce((res, curr) => {
-        const params = { ...res.params, ...curr.params };
-        const data = { ...res.data, ...curr.data };
-        const resolve = { ...curr.data, ...res.resolve, ...curr.routeConfig?.data, ...curr._resolvedData };
-        return { params, data, resolve };
-    }, { params: {}, data: {}, resolve: {} });
 }
+
 /**
- * @description
- *
- * Contains the information about a route associated with a component loaded in an
- * outlet at a particular moment in time. ActivatedRouteSnapshot can also be used to
- * traverse the router state tree.
- *
- * The following example initializes a component with route information extracted
- * from the snapshot of the root node at the time of creation.
- *
- * ```
- * @Component({templateUrl:'./my-component.html'})
- * class MyComponent {
- *   constructor(route: ActivatedRoute) {
- *     const id: string = route.snapshot.params.id;
- *     const url: string = route.snapshot.url.join('');
- *     const user = route.snapshot.data.user;
- *   }
- * }
- * ```
+ * @license
+ * Copyright Google LLC All Rights Reserved.
  *
- * @publicApi
+ * 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
  */
-class ActivatedRouteSnapshot {
-    /** @internal */
-    constructor(
-    /** The URL segments matched by this route */
-    url, 
+class Tree {
+    constructor(root) {
+        this._root = root;
+    }
+    get root() {
+        return this._root.value;
+    }
     /**
-     *  The matrix parameters scoped to this route.
-     *
-     *  You can compute all params (or data) in the router state or to get params outside
-     *  of an activated component by traversing the `RouterState` tree as in the following
-     *  example:
-     *  ```
-     *  collectRouteParams(router: Router) {
-     *    let params = {};
-     *    let stack: ActivatedRouteSnapshot[] = [router.routerState.snapshot.root];
-     *    while (stack.length > 0) {
-     *      const route = stack.pop()!;
-     *      params = {...params, ...route.params};
-     *      stack.push(...route.children);
-     *    }
-     *    return params;
-     *  }
-     *  ```
+     * @internal
      */
-    params, 
-    /** The query parameters shared by all the routes */
-    queryParams, 
-    /** The URL fragment shared by all the routes */
-    fragment, 
-    /** The static and resolved data of this route */
-    data, 
-    /** The outlet name of the route */
-    outlet, 
-    /** The component of the route */
-    component, routeConfig, urlSegment, lastPathIndex, resolve, correctedLastPathIndex) {
-        this.url = url;
-        this.params = params;
-        this.queryParams = queryParams;
-        this.fragment = fragment;
-        this.data = data;
-        this.outlet = outlet;
-        this.component = component;
-        this.routeConfig = routeConfig;
-        this._urlSegment = urlSegment;
-        this._lastPathIndex = lastPathIndex;
-        this._correctedLastPathIndex = correctedLastPathIndex ?? lastPathIndex;
-        this._resolve = resolve;
+    parent(t) {
+        const p = this.pathFromRoot(t);
+        return p.length > 1 ? p[p.length - 2] : null;
     }
-    /** The root of the router state */
-    get root() {
-        return this._routerState.root;
+    /**
+     * @internal
+     */
+    children(t) {
+        const n = findNode(t, this._root);
+        return n ? n.children.map(t => t.value) : [];
     }
-    /** The parent of this route in the router state tree */
-    get parent() {
-        return this._routerState.parent(this);
+    /**
+     * @internal
+     */
+    firstChild(t) {
+        const n = findNode(t, this._root);
+        return n && n.children.length > 0 ? n.children[0].value : null;
     }
-    /** The first child of this route in the router state tree */
-    get firstChild() {
-        return this._routerState.firstChild(this);
+    /**
+     * @internal
+     */
+    siblings(t) {
+        const p = findPath(t, this._root);
+        if (p.length < 2)
+            return [];
+        const c = p[p.length - 2].children.map(c => c.value);
+        return c.filter(cc => cc !== t);
     }
-    /** The children of this route in the router state tree */
-    get children() {
-        return this._routerState.children(this);
+    /**
+     * @internal
+     */
+    pathFromRoot(t) {
+        return findPath(t, this._root).map(s => s.value);
     }
-    /** The path from the root of the router state tree to this route */
-    get pathFromRoot() {
-        return this._routerState.pathFromRoot(this);
+}
+// DFS for the node matching the value
+function findNode(value, node) {
+    if (value === node.value)
+        return node;
+    for (const child of node.children) {
+        const node = findNode(value, child);
+        if (node)
+            return node;
     }
-    get paramMap() {
-        if (!this._paramMap) {
-            this._paramMap = convertToParamMap(this.params);
+    return null;
+}
+// Return the path to the node with the given value using DFS
+function findPath(value, node) {
+    if (value === node.value)
+        return [node];
+    for (const child of node.children) {
+        const path = findPath(value, child);
+        if (path.length) {
+            path.unshift(node);
+            return path;
         }
-        return this._paramMap;
     }
-    get queryParamMap() {
-        if (!this._queryParamMap) {
-            this._queryParamMap = convertToParamMap(this.queryParams);
-        }
-        return this._queryParamMap;
+    return [];
+}
+class TreeNode {
+    constructor(value, children) {
+        this.value = value;
+        this.children = children;
     }
     toString() {
-        const url = this.url.map(segment => segment.toString()).join('/');
-        const matched = this.routeConfig ? this.routeConfig.path : '';
-        return `Route(url:'${url}', path:'${matched}')`;
+        return `TreeNode(${this.value})`;
+    }
+}
+// Return the list of T indexed by outlet name
+function nodeChildrenAsMap(node) {
+    const map = {};
+    if (node) {
+        node.children.forEach(child => map[child.value.outlet] = child);
     }
+    return map;
 }
+
 /**
- * @description
+ * @license
+ * Copyright Google LLC All Rights Reserved.
  *
- * Represents the state of the router at a moment in time.
+ * 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
+ */
+/**
+ * Represents the state of the router as a tree of activated routes.
+ *
+ * @usageNotes
  *
- * This is a tree of activated route snapshots. Every node in this tree knows about
- * the "consumed" URL segments, the extracted parameters, and the resolved data.
+ * Every node in the route tree is an `ActivatedRoute` instance
+ * that knows about the "consumed" URL segments, the extracted parameters,
+ * and the resolved data.
+ * Use the `ActivatedRoute` properties to traverse the tree from any node.
  *
- * The following example shows how a component is initialized with information
- * from the snapshot of the root node's state at the time of creation.
+ * The following fragment shows how a component gets the root node
+ * of the current state to establish its own route tree:
  *
  * ```
  * @Component({templateUrl:'template.html'})
  * class MyComponent {
  *   constructor(router: Router) {
  *     const state: RouterState = router.routerState;
- *     const snapshot: RouterStateSnapshot = state.snapshot;
- *     const root: ActivatedRouteSnapshot = snapshot.root;
+ *     const root: ActivatedRoute = state.root;
  *     const child = root.firstChild;
  *     const id: Observable<string> = child.params.map(p => p.id);
  *     //...
@@ -1649,423 +1815,418 @@ class ActivatedRouteSnapshot {
  * }
  * ```
  *
+ * @see `ActivatedRoute`
+ * @see [Getting route information](guide/router#getting-route-information)
+ *
  * @publicApi
  */
-class RouterStateSnapshot extends Tree {
+class RouterState extends Tree {
     /** @internal */
-    constructor(
-    /** The url from which this snapshot was created */
-    url, root) {
+    constructor(root, 
+    /** The current snapshot of the router state */
+    snapshot) {
         super(root);
-        this.url = url;
+        this.snapshot = snapshot;
         setRouterState(this, root);
     }
     toString() {
-        return serializeNode(this._root);
+        return this.snapshot.toString();
     }
 }
-function setRouterState(state, node) {
-    node.value._routerState = state;
-    node.children.forEach(c => setRouterState(state, c));
-}
-function serializeNode(node) {
-    const c = node.children.length > 0 ? ` { ${node.children.map(serializeNode).join(', ')} } ` : '';
-    return `${node.value}${c}`;
-}
-/**
- * The expectation is that the activate route is created with the right set of parameters.
- * So we push new values into the observables only when they are not the initial values.
- * And we detect that by checking if the snapshot field is set.
- */
-function advanceActivatedRoute(route) {
-    if (route.snapshot) {
-        const currentSnapshot = route.snapshot;
-        const nextSnapshot = route._futureSnapshot;
-        route.snapshot = nextSnapshot;
-        if (!shallowEqual(currentSnapshot.queryParams, nextSnapshot.queryParams)) {
-            route.queryParams.next(nextSnapshot.queryParams);
-        }
-        if (currentSnapshot.fragment !== nextSnapshot.fragment) {
-            route.fragment.next(nextSnapshot.fragment);
-        }
-        if (!shallowEqual(currentSnapshot.params, nextSnapshot.params)) {
-            route.params.next(nextSnapshot.params);
-        }
-        if (!shallowEqualArrays(currentSnapshot.url, nextSnapshot.url)) {
-            route.url.next(nextSnapshot.url);
-        }
-        if (!shallowEqual(currentSnapshot.data, nextSnapshot.data)) {
-            route.data.next(nextSnapshot.data);
-        }
-    }
-    else {
-        route.snapshot = route._futureSnapshot;
-        // this is for resolved data
-        route.data.next(route._futureSnapshot.data);
-    }
+function createEmptyState(urlTree, rootComponent) {
+    const snapshot = createEmptyStateSnapshot(urlTree, rootComponent);
+    const emptyUrl = new BehaviorSubject([new UrlSegment('', {})]);
+    const emptyParams = new BehaviorSubject({});
+    const emptyData = new BehaviorSubject({});
+    const emptyQueryParams = new BehaviorSubject({});
+    const fragment = new BehaviorSubject('');
+    const activated = new ActivatedRoute(emptyUrl, emptyParams, emptyQueryParams, fragment, emptyData, PRIMARY_OUTLET, rootComponent, snapshot.root);
+    activated.snapshot = snapshot.root;
+    return new RouterState(new TreeNode(activated, []), snapshot);
 }
-function equalParamsAndUrlSegments(a, b) {
-    const equalUrlParams = shallowEqual(a.params, b.params) && equalSegments(a.url, b.url);
-    const parentsMismatch = !a.parent !== !b.parent;
-    return equalUrlParams && !parentsMismatch &&
-        (!a.parent || equalParamsAndUrlSegments(a.parent, b.parent));
+function createEmptyStateSnapshot(urlTree, rootComponent) {
+    const emptyParams = {};
+    const emptyData = {};
+    const emptyQueryParams = {};
+    const fragment = '';
+    const activated = new ActivatedRouteSnapshot([], emptyParams, emptyQueryParams, fragment, emptyData, PRIMARY_OUTLET, rootComponent, null, urlTree.root, -1, {});
+    return new RouterStateSnapshot('', new TreeNode(activated, []));
 }
-
 /**
- * @license
- * Copyright Google LLC All Rights Reserved.
+ * Provides access to information about a route associated with a component
+ * that is loaded in an outlet.
+ * Use to traverse the `RouterState` tree and extract information from nodes.
  *
- * 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
- */
-function createRouterState(routeReuseStrategy, curr, prevState) {
-    const root = createNode(routeReuseStrategy, curr._root, prevState ? prevState._root : undefined);
-    return new RouterState(root, curr);
-}
-function createNode(routeReuseStrategy, curr, prevState) {
-    // reuse an activated route that is currently displayed on the screen
-    if (prevState && routeReuseStrategy.shouldReuseRoute(curr.value, prevState.value.snapshot)) {
-        const value = prevState.value;
-        value._futureSnapshot = curr.value;
-        const children = createOrReuseChildren(routeReuseStrategy, curr, prevState);
-        return new TreeNode(value, children);
-    }
-    else {
-        if (routeReuseStrategy.shouldAttach(curr.value)) {
-            // retrieve an activated route that is used to be displayed, but is not currently displayed
-            const detachedRouteHandle = routeReuseStrategy.retrieve(curr.value);
-            if (detachedRouteHandle !== null) {
-                const tree = detachedRouteHandle.route;
-                tree.value._futureSnapshot = curr.value;
-                tree.children = curr.children.map(c => createNode(routeReuseStrategy, c));
-                return tree;
-            }
-        }
-        const value = createActivatedRoute(curr.value);
-        const children = curr.children.map(c => createNode(routeReuseStrategy, c));
-        return new TreeNode(value, children);
-    }
-}
-function createOrReuseChildren(routeReuseStrategy, curr, prevState) {
-    return curr.children.map(child => {
-        for (const p of prevState.children) {
-            if (routeReuseStrategy.shouldReuseRoute(child.value, p.value.snapshot)) {
-                return createNode(routeReuseStrategy, child, p);
-            }
-        }
-        return createNode(routeReuseStrategy, child);
-    });
-}
-function createActivatedRoute(c) {
-    return new ActivatedRoute(new BehaviorSubject(c.url), new BehaviorSubject(c.params), new BehaviorSubject(c.queryParams), new BehaviorSubject(c.fragment), new BehaviorSubject(c.data), c.outlet, c.component, c);
-}
-
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
+ * The following example shows how to construct a component using information from a
+ * currently activated route.
  *
- * 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
+ * Note: the observables in this class only emit when the current and previous values differ based
+ * on shallow equality. For example, changing deeply nested properties in resolved `data` will not
+ * cause the `ActivatedRoute.data` `Observable` to emit a new value.
+ *
+ * {@example router/activated-route/module.ts region="activated-route"
+ *     header="activated-route.component.ts"}
+ *
+ * @see [Getting route information](guide/router#getting-route-information)
+ *
+ * @publicApi
  */
-function createUrlTree(route, urlTree, commands, queryParams, fragment) {
-    if (commands.length === 0) {
-        return tree(urlTree.root, urlTree.root, urlTree.root, queryParams, fragment);
-    }
-    const nav = computeNavigation(commands);
-    if (nav.toRoot()) {
-        return tree(urlTree.root, urlTree.root, new UrlSegmentGroup([], {}), queryParams, fragment);
-    }
-    function createTreeUsingPathIndex(lastPathIndex) {
-        const startingPosition = findStartingPosition(nav, urlTree, route.snapshot?._urlSegment, lastPathIndex);
-        const segmentGroup = startingPosition.processChildren ?
-            updateSegmentGroupChildren(startingPosition.segmentGroup, startingPosition.index, nav.commands) :
-            updateSegmentGroup(startingPosition.segmentGroup, startingPosition.index, nav.commands);
-        return tree(urlTree.root, startingPosition.segmentGroup, segmentGroup, queryParams, fragment);
-    }
-    // Note: The types should disallow `snapshot` from being `undefined` but due to test mocks, this
-    // may be the case. Since we try to access it at an earlier point before the refactor to add the
-    // warning for `relativeLinkResolution: 'legacy'`, this may cause failures in tests where it
-    // didn't before.
-    const result = createTreeUsingPathIndex(route.snapshot?._lastPathIndex);
-    // Check if application is relying on `relativeLinkResolution: 'legacy'`
-    if (typeof ngDevMode === 'undefined' || !!ngDevMode) {
-        const correctedResult = createTreeUsingPathIndex(route.snapshot?._correctedLastPathIndex);
-        if (correctedResult.toString() !== result.toString()) {
-            console.warn(`relativeLinkResolution: 'legacy' is deprecated and will be removed in a future version of Angular. The link to ${result.toString()} will change to ${correctedResult.toString()} if the code is not updated before then.`);
-        }
+class ActivatedRoute {
+    /** @internal */
+    constructor(
+    /** An observable of the URL segments matched by this route. */
+    url, 
+    /** An observable of the matrix parameters scoped to this route. */
+    params, 
+    /** An observable of the query parameters shared by all the routes. */
+    queryParams, 
+    /** An observable of the URL fragment shared by all the routes. */
+    fragment, 
+    /** An observable of the static and resolved data of this route. */
+    data, 
+    /** The outlet name of the route, a constant. */
+    outlet, 
+    /** The component of the route, a constant. */
+    component, futureSnapshot) {
+        this.url = url;
+        this.params = params;
+        this.queryParams = queryParams;
+        this.fragment = fragment;
+        this.data = data;
+        this.outlet = outlet;
+        this.component = component;
+        this._futureSnapshot = futureSnapshot;
     }
-    return result;
-}
-function isMatrixParams(command) {
-    return typeof command === 'object' && command != null && !command.outlets && !command.segmentPath;
-}
-/**
- * Determines if a given command has an `outlets` map. When we encounter a command
- * with an outlets k/v map, we need to apply each outlet individually to the existing segment.
- */
-function isCommandWithOutlets(command) {
-    return typeof command === 'object' && command != null && command.outlets;
-}
-function tree(oldRoot, oldSegmentGroup, newSegmentGroup, queryParams, fragment) {
-    let qp = {};
-    if (queryParams) {
-        forEach(queryParams, (value, name) => {
-            qp[name] = Array.isArray(value) ? value.map((v) => `${v}`) : `${value}`;
-        });
+    /** The configuration used to match this route. */
+    get routeConfig() {
+        return this._futureSnapshot.routeConfig;
     }
-    if (oldRoot === oldSegmentGroup) {
-        return new UrlTree(newSegmentGroup, qp, fragment);
+    /** The root of the router state. */
+    get root() {
+        return this._routerState.root;
     }
-    const newRoot = replaceSegment(oldRoot, oldSegmentGroup, newSegmentGroup);
-    return new UrlTree(newRoot, qp, fragment);
-}
-function replaceSegment(current, oldSegment, newSegment) {
-    const children = {};
-    forEach(current.children, (c, outletName) => {
-        if (c === oldSegment) {
-            children[outletName] = newSegment;
-        }
-        else {
-            children[outletName] = replaceSegment(c, oldSegment, newSegment);
-        }
-    });
-    return new UrlSegmentGroup(current.segments, children);
-}
-class Navigation {
-    constructor(isAbsolute, numberOfDoubleDots, commands) {
-        this.isAbsolute = isAbsolute;
-        this.numberOfDoubleDots = numberOfDoubleDots;
-        this.commands = commands;
-        if (isAbsolute && commands.length > 0 && isMatrixParams(commands[0])) {
-            throw new Error('Root segment cannot have matrix parameters');
+    /** The parent of this route in the router state tree. */
+    get parent() {
+        return this._routerState.parent(this);
+    }
+    /** The first child of this route in the router state tree. */
+    get firstChild() {
+        return this._routerState.firstChild(this);
+    }
+    /** The children of this route in the router state tree. */
+    get children() {
+        return this._routerState.children(this);
+    }
+    /** The path from the root of the router state tree to this route. */
+    get pathFromRoot() {
+        return this._routerState.pathFromRoot(this);
+    }
+    /**
+     * An Observable that contains a map of the required and optional parameters
+     * specific to the route.
+     * The map supports retrieving single and multiple values from the same parameter.
+     */
+    get paramMap() {
+        if (!this._paramMap) {
+            this._paramMap = this.params.pipe(map((p) => convertToParamMap(p)));
         }
-        const cmdWithOutlet = commands.find(isCommandWithOutlets);
-        if (cmdWithOutlet && cmdWithOutlet !== last(commands)) {
-            throw new Error('{outlets:{}} has to be the last command');
+        return this._paramMap;
+    }
+    /**
+     * An Observable that contains a map of the query parameters available to all routes.
+     * The map supports retrieving single and multiple values from the query parameter.
+     */
+    get queryParamMap() {
+        if (!this._queryParamMap) {
+            this._queryParamMap =
+                this.queryParams.pipe(map((p) => convertToParamMap(p)));
         }
+        return this._queryParamMap;
     }
-    toRoot() {
-        return this.isAbsolute && this.commands.length === 1 && this.commands[0] == '/';
+    toString() {
+        return this.snapshot ? this.snapshot.toString() : `Future(${this._futureSnapshot})`;
     }
 }
-/** Transforms commands to a normalized `Navigation` */
-function computeNavigation(commands) {
-    if ((typeof commands[0] === 'string') && commands.length === 1 && commands[0] === '/') {
-        return new Navigation(true, 0, commands);
-    }
-    let numberOfDoubleDots = 0;
-    let isAbsolute = false;
-    const res = commands.reduce((res, cmd, cmdIdx) => {
-        if (typeof cmd === 'object' && cmd != null) {
-            if (cmd.outlets) {
-                const outlets = {};
-                forEach(cmd.outlets, (commands, name) => {
-                    outlets[name] = typeof commands === 'string' ? commands.split('/') : commands;
-                });
-                return [...res, { outlets }];
+/**
+ * Returns the inherited params, data, and resolve for a given route.
+ * By default, this only inherits values up to the nearest path-less or component-less route.
+ * @internal
+ */
+function inheritedParamsDataResolve(route, paramsInheritanceStrategy = 'emptyOnly') {
+    const pathFromRoot = route.pathFromRoot;
+    let inheritingStartingFrom = 0;
+    if (paramsInheritanceStrategy !== 'always') {
+        inheritingStartingFrom = pathFromRoot.length - 1;
+        while (inheritingStartingFrom >= 1) {
+            const current = pathFromRoot[inheritingStartingFrom];
+            const parent = pathFromRoot[inheritingStartingFrom - 1];
+            // current route is an empty path => inherits its parent's params and data
+            if (current.routeConfig && current.routeConfig.path === '') {
+                inheritingStartingFrom--;
+                // parent is componentless => current route should inherit its params and data
             }
-            if (cmd.segmentPath) {
-                return [...res, cmd.segmentPath];
+            else if (!parent.component) {
+                inheritingStartingFrom--;
+            }
+            else {
+                break;
             }
         }
-        if (!(typeof cmd === 'string')) {
-            return [...res, cmd];
-        }
-        if (cmdIdx === 0) {
-            cmd.split('/').forEach((urlPart, partIndex) => {
-                if (partIndex == 0 && urlPart === '.') {
-                    // skip './a'
-                }
-                else if (partIndex == 0 && urlPart === '') { //  '/a'
-                    isAbsolute = true;
-                }
-                else if (urlPart === '..') { //  '../a'
-                    numberOfDoubleDots++;
-                }
-                else if (urlPart != '') {
-                    res.push(urlPart);
-                }
-            });
-            return res;
-        }
-        return [...res, cmd];
-    }, []);
-    return new Navigation(isAbsolute, numberOfDoubleDots, res);
-}
-class Position {
-    constructor(segmentGroup, processChildren, index) {
-        this.segmentGroup = segmentGroup;
-        this.processChildren = processChildren;
-        this.index = index;
     }
+    return flattenInherited(pathFromRoot.slice(inheritingStartingFrom));
 }
-function findStartingPosition(nav, tree, segmentGroup, lastPathIndex) {
-    if (nav.isAbsolute) {
-        return new Position(tree.root, true, 0);
-    }
-    if (lastPathIndex === -1) {
-        // Pathless ActivatedRoute has _lastPathIndex === -1 but should not process children
-        // see issue #26224, #13011, #35687
-        // However, if the ActivatedRoute is the root we should process children like above.
-        const processChildren = segmentGroup === tree.root;
-        return new Position(segmentGroup, processChildren, 0);
-    }
-    const modifier = isMatrixParams(nav.commands[0]) ? 0 : 1;
-    const index = lastPathIndex + modifier;
-    return createPositionApplyingDoubleDots(segmentGroup, index, nav.numberOfDoubleDots);
+/** @internal */
+function flattenInherited(pathFromRoot) {
+    return pathFromRoot.reduce((res, curr) => {
+        const params = { ...res.params, ...curr.params };
+        const data = { ...res.data, ...curr.data };
+        const resolve = { ...curr.data, ...res.resolve, ...curr.routeConfig?.data, ...curr._resolvedData };
+        return { params, data, resolve };
+    }, { params: {}, data: {}, resolve: {} });
 }
-function createPositionApplyingDoubleDots(group, index, numberOfDoubleDots) {
-    let g = group;
-    let ci = index;
-    let dd = numberOfDoubleDots;
-    while (dd > ci) {
-        dd -= ci;
-        g = g.parent;
-        if (!g) {
-            throw new Error('Invalid number of \'../\'');
-        }
-        ci = g.segments.length;
+/**
+ * @description
+ *
+ * Contains the information about a route associated with a component loaded in an
+ * outlet at a particular moment in time. ActivatedRouteSnapshot can also be used to
+ * traverse the router state tree.
+ *
+ * The following example initializes a component with route information extracted
+ * from the snapshot of the root node at the time of creation.
+ *
+ * ```
+ * @Component({templateUrl:'./my-component.html'})
+ * class MyComponent {
+ *   constructor(route: ActivatedRoute) {
+ *     const id: string = route.snapshot.params.id;
+ *     const url: string = route.snapshot.url.join('');
+ *     const user = route.snapshot.data.user;
+ *   }
+ * }
+ * ```
+ *
+ * @publicApi
+ */
+class ActivatedRouteSnapshot {
+    /** @internal */
+    constructor(
+    /** The URL segments matched by this route */
+    url, 
+    /**
+     *  The matrix parameters scoped to this route.
+     *
+     *  You can compute all params (or data) in the router state or to get params outside
+     *  of an activated component by traversing the `RouterState` tree as in the following
+     *  example:
+     *  ```
+     *  collectRouteParams(router: Router) {
+     *    let params = {};
+     *    let stack: ActivatedRouteSnapshot[] = [router.routerState.snapshot.root];
+     *    while (stack.length > 0) {
+     *      const route = stack.pop()!;
+     *      params = {...params, ...route.params};
+     *      stack.push(...route.children);
+     *    }
+     *    return params;
+     *  }
+     *  ```
+     */
+    params, 
+    /** The query parameters shared by all the routes */
+    queryParams, 
+    /** The URL fragment shared by all the routes */
+    fragment, 
+    /** The static and resolved data of this route */
+    data, 
+    /** The outlet name of the route */
+    outlet, 
+    /** The component of the route */
+    component, routeConfig, urlSegment, lastPathIndex, resolve, correctedLastPathIndex) {
+        this.url = url;
+        this.params = params;
+        this.queryParams = queryParams;
+        this.fragment = fragment;
+        this.data = data;
+        this.outlet = outlet;
+        this.component = component;
+        this.routeConfig = routeConfig;
+        this._urlSegment = urlSegment;
+        this._lastPathIndex = lastPathIndex;
+        this._correctedLastPathIndex = correctedLastPathIndex ?? lastPathIndex;
+        this._resolve = resolve;
     }
-    return new Position(g, false, ci - dd);
-}
-function getOutlets(commands) {
-    if (isCommandWithOutlets(commands[0])) {
-        return commands[0].outlets;
+    /** The root of the router state */
+    get root() {
+        return this._routerState.root;
     }
-    return { [PRIMARY_OUTLET]: commands };
-}
-function updateSegmentGroup(segmentGroup, startIndex, commands) {
-    if (!segmentGroup) {
-        segmentGroup = new UrlSegmentGroup([], {});
+    /** The parent of this route in the router state tree */
+    get parent() {
+        return this._routerState.parent(this);
     }
-    if (segmentGroup.segments.length === 0 && segmentGroup.hasChildren()) {
-        return updateSegmentGroupChildren(segmentGroup, startIndex, commands);
+    /** The first child of this route in the router state tree */
+    get firstChild() {
+        return this._routerState.firstChild(this);
     }
-    const m = prefixedWith(segmentGroup, startIndex, commands);
-    const slicedCommands = commands.slice(m.commandIndex);
-    if (m.match && m.pathIndex < segmentGroup.segments.length) {
-        const g = new UrlSegmentGroup(segmentGroup.segments.slice(0, m.pathIndex), {});
-        g.children[PRIMARY_OUTLET] =
-            new UrlSegmentGroup(segmentGroup.segments.slice(m.pathIndex), segmentGroup.children);
-        return updateSegmentGroupChildren(g, 0, slicedCommands);
+    /** The children of this route in the router state tree */
+    get children() {
+        return this._routerState.children(this);
     }
-    else if (m.match && slicedCommands.length === 0) {
-        return new UrlSegmentGroup(segmentGroup.segments, {});
+    /** The path from the root of the router state tree to this route */
+    get pathFromRoot() {
+        return this._routerState.pathFromRoot(this);
     }
-    else if (m.match && !segmentGroup.hasChildren()) {
-        return createNewSegmentGroup(segmentGroup, startIndex, commands);
+    get paramMap() {
+        if (!this._paramMap) {
+            this._paramMap = convertToParamMap(this.params);
+        }
+        return this._paramMap;
     }
-    else if (m.match) {
-        return updateSegmentGroupChildren(segmentGroup, 0, slicedCommands);
+    get queryParamMap() {
+        if (!this._queryParamMap) {
+            this._queryParamMap = convertToParamMap(this.queryParams);
+        }
+        return this._queryParamMap;
     }
-    else {
-        return createNewSegmentGroup(segmentGroup, startIndex, commands);
+    toString() {
+        const url = this.url.map(segment => segment.toString()).join('/');
+        const matched = this.routeConfig ? this.routeConfig.path : '';
+        return `Route(url:'${url}', path:'${matched}')`;
     }
 }
-function updateSegmentGroupChildren(segmentGroup, startIndex, commands) {
-    if (commands.length === 0) {
-        return new UrlSegmentGroup(segmentGroup.segments, {});
+/**
+ * @description
+ *
+ * Represents the state of the router at a moment in time.
+ *
+ * This is a tree of activated route snapshots. Every node in this tree knows about
+ * the "consumed" URL segments, the extracted parameters, and the resolved data.
+ *
+ * The following example shows how a component is initialized with information
+ * from the snapshot of the root node's state at the time of creation.
+ *
+ * ```
+ * @Component({templateUrl:'template.html'})
+ * class MyComponent {
+ *   constructor(router: Router) {
+ *     const state: RouterState = router.routerState;
+ *     const snapshot: RouterStateSnapshot = state.snapshot;
+ *     const root: ActivatedRouteSnapshot = snapshot.root;
+ *     const child = root.firstChild;
+ *     const id: Observable<string> = child.params.map(p => p.id);
+ *     //...
+ *   }
+ * }
+ * ```
+ *
+ * @publicApi
+ */
+class RouterStateSnapshot extends Tree {
+    /** @internal */
+    constructor(
+    /** The url from which this snapshot was created */
+    url, root) {
+        super(root);
+        this.url = url;
+        setRouterState(this, root);
     }
-    else {
-        const outlets = getOutlets(commands);
-        const children = {};
-        forEach(outlets, (commands, outlet) => {
-            if (typeof commands === 'string') {
-                commands = [commands];
-            }
-            if (commands !== null) {
-                children[outlet] = updateSegmentGroup(segmentGroup.children[outlet], startIndex, commands);
-            }
-        });
-        forEach(segmentGroup.children, (child, childOutlet) => {
-            if (outlets[childOutlet] === undefined) {
-                children[childOutlet] = child;
-            }
-        });
-        return new UrlSegmentGroup(segmentGroup.segments, children);
+    toString() {
+        return serializeNode(this._root);
     }
 }
-function prefixedWith(segmentGroup, startIndex, commands) {
-    let currentCommandIndex = 0;
-    let currentPathIndex = startIndex;
-    const noMatch = { match: false, pathIndex: 0, commandIndex: 0 };
-    while (currentPathIndex < segmentGroup.segments.length) {
-        if (currentCommandIndex >= commands.length)
-            return noMatch;
-        const path = segmentGroup.segments[currentPathIndex];
-        const command = commands[currentCommandIndex];
-        // Do not try to consume command as part of the prefixing if it has outlets because it can
-        // contain outlets other than the one being processed. Consuming the outlets command would
-        // result in other outlets being ignored.
-        if (isCommandWithOutlets(command)) {
-            break;
-        }
-        const curr = `${command}`;
-        const next = currentCommandIndex < commands.length - 1 ? commands[currentCommandIndex + 1] : null;
-        if (currentPathIndex > 0 && curr === undefined)
-            break;
-        if (curr && next && (typeof next === 'object') && next.outlets === undefined) {
-            if (!compare(curr, next, path))
-                return noMatch;
-            currentCommandIndex += 2;
-        }
-        else {
-            if (!compare(curr, {}, path))
-                return noMatch;
-            currentCommandIndex++;
-        }
-        currentPathIndex++;
-    }
-    return { match: true, pathIndex: currentPathIndex, commandIndex: currentCommandIndex };
+function setRouterState(state, node) {
+    node.value._routerState = state;
+    node.children.forEach(c => setRouterState(state, c));
 }
-function createNewSegmentGroup(segmentGroup, startIndex, commands) {
-    const paths = segmentGroup.segments.slice(0, startIndex);
-    let i = 0;
-    while (i < commands.length) {
-        const command = commands[i];
-        if (isCommandWithOutlets(command)) {
-            const children = createNewSegmentChildren(command.outlets);
-            return new UrlSegmentGroup(paths, children);
+function serializeNode(node) {
+    const c = node.children.length > 0 ? ` { ${node.children.map(serializeNode).join(', ')} } ` : '';
+    return `${node.value}${c}`;
+}
+/**
+ * The expectation is that the activate route is created with the right set of parameters.
+ * So we push new values into the observables only when they are not the initial values.
+ * And we detect that by checking if the snapshot field is set.
+ */
+function advanceActivatedRoute(route) {
+    if (route.snapshot) {
+        const currentSnapshot = route.snapshot;
+        const nextSnapshot = route._futureSnapshot;
+        route.snapshot = nextSnapshot;
+        if (!shallowEqual(currentSnapshot.queryParams, nextSnapshot.queryParams)) {
+            route.queryParams.next(nextSnapshot.queryParams);
         }
-        // if we start with an object literal, we need to reuse the path part from the segment
-        if (i === 0 && isMatrixParams(commands[0])) {
-            const p = segmentGroup.segments[startIndex];
-            paths.push(new UrlSegment(p.path, stringify(commands[0])));
-            i++;
-            continue;
+        if (currentSnapshot.fragment !== nextSnapshot.fragment) {
+            route.fragment.next(nextSnapshot.fragment);
         }
-        const curr = isCommandWithOutlets(command) ? command.outlets[PRIMARY_OUTLET] : `${command}`;
-        const next = (i < commands.length - 1) ? commands[i + 1] : null;
-        if (curr && next && isMatrixParams(next)) {
-            paths.push(new UrlSegment(curr, stringify(next)));
-            i += 2;
+        if (!shallowEqual(currentSnapshot.params, nextSnapshot.params)) {
+            route.params.next(nextSnapshot.params);
         }
-        else {
-            paths.push(new UrlSegment(curr, {}));
-            i++;
+        if (!shallowEqualArrays(currentSnapshot.url, nextSnapshot.url)) {
+            route.url.next(nextSnapshot.url);
+        }
+        if (!shallowEqual(currentSnapshot.data, nextSnapshot.data)) {
+            route.data.next(nextSnapshot.data);
         }
     }
-    return new UrlSegmentGroup(paths, {});
+    else {
+        route.snapshot = route._futureSnapshot;
+        // this is for resolved data
+        route.data.next(route._futureSnapshot.data);
+    }
 }
-function createNewSegmentChildren(outlets) {
-    const children = {};
-    forEach(outlets, (commands, outlet) => {
-        if (typeof commands === 'string') {
-            commands = [commands];
+function equalParamsAndUrlSegments(a, b) {
+    const equalUrlParams = shallowEqual(a.params, b.params) && equalSegments(a.url, b.url);
+    const parentsMismatch = !a.parent !== !b.parent;
+    return equalUrlParams && !parentsMismatch &&
+        (!a.parent || equalParamsAndUrlSegments(a.parent, b.parent));
+}
+
+/**
+ * @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.io/license
+ */
+function createRouterState(routeReuseStrategy, curr, prevState) {
+    const root = createNode(routeReuseStrategy, curr._root, prevState ? prevState._root : undefined);
+    return new RouterState(root, curr);
+}
+function createNode(routeReuseStrategy, curr, prevState) {
+    // reuse an activated route that is currently displayed on the screen
+    if (prevState && routeReuseStrategy.shouldReuseRoute(curr.value, prevState.value.snapshot)) {
+        const value = prevState.value;
+        value._futureSnapshot = curr.value;
+        const children = createOrReuseChildren(routeReuseStrategy, curr, prevState);
+        return new TreeNode(value, children);
+    }
+    else {
+        if (routeReuseStrategy.shouldAttach(curr.value)) {
+            // retrieve an activated route that is used to be displayed, but is not currently displayed
+            const detachedRouteHandle = routeReuseStrategy.retrieve(curr.value);
+            if (detachedRouteHandle !== null) {
+                const tree = detachedRouteHandle.route;
+                tree.value._futureSnapshot = curr.value;
+                tree.children = curr.children.map(c => createNode(routeReuseStrategy, c));
+                return tree;
+            }
         }
-        if (commands !== null) {
-            children[outlet] = createNewSegmentGroup(new UrlSegmentGroup([], {}), 0, commands);
+        const value = createActivatedRoute(curr.value);
+        const children = curr.children.map(c => createNode(routeReuseStrategy, c));
+        return new TreeNode(value, children);
+    }
+}
+function createOrReuseChildren(routeReuseStrategy, curr, prevState) {
+    return curr.children.map(child => {
+        for (const p of prevState.children) {
+            if (routeReuseStrategy.shouldReuseRoute(child.value, p.value.snapshot)) {
+                return createNode(routeReuseStrategy, child, p);
+            }
         }
+        return createNode(routeReuseStrategy, child);
     });
-    return children;
-}
-function stringify(params) {
-    const res = {};
-    forEach(params, (v, k) => res[k] = `${v}`);
-    return res;
 }
-function compare(path, params, segment) {
-    return path == segment.path && shallowEqual(params, segment.parameters);
+function createActivatedRoute(c) {
+    return new ActivatedRoute(new BehaviorSubject(c.url), new BehaviorSubject(c.params), new BehaviorSubject(c.queryParams), new BehaviorSubject(c.fragment), new BehaviorSubject(c.data), c.outlet, c.component, c);
 }
 
 /**
@@ -2328,9 +2489,9 @@ class RouterOutlet {
         this.activateEvents.emit(this.activated.instance);
     }
 }
-RouterOutlet.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: RouterOutlet, deps: [{ token: ChildrenOutletContexts }, { token: i0.ViewContainerRef }, { token: 'name', attribute: true }, { token: i0.ChangeDetectorRef }, { token: i0.EnvironmentInjector }], target: i0.ɵɵFactoryTarget.Directive });
-RouterOutlet.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.0.1", type: RouterOutlet, selector: "router-outlet", outputs: { activateEvents: "activate", deactivateEvents: "deactivate", attachEvents: "attach", detachEvents: "detach" }, exportAs: ["outlet"], ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: RouterOutlet, decorators: [{
+RouterOutlet.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterOutlet, deps: [{ token: ChildrenOutletContexts }, { token: i0.ViewContainerRef }, { token: 'name', attribute: true }, { token: i0.ChangeDetectorRef }, { token: i0.EnvironmentInjector }], target: i0.ɵɵFactoryTarget.Directive });
+RouterOutlet.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.1.0-next.0", type: RouterOutlet, selector: "router-outlet", outputs: { activateEvents: "activate", deactivateEvents: "deactivate", attachEvents: "attach", detachEvents: "detach" }, exportAs: ["outlet"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterOutlet, decorators: [{
             type: Directive,
             args: [{ selector: 'router-outlet', exportAs: 'outlet' }]
         }], ctorParameters: function () { return [{ type: ChildrenOutletContexts }, { type: i0.ViewContainerRef }, { type: undefined, decorators: [{
@@ -2387,9 +2548,9 @@ function isComponentFactoryResolver(item) {
  */
 class ɵEmptyOutletComponent {
 }
-ɵEmptyOutletComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: ɵEmptyOutletComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-ɵEmptyOutletComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.0.1", type: ɵEmptyOutletComponent, selector: "ng-component", ngImport: i0, template: `<router-outlet></router-outlet>`, isInline: true, dependencies: [{ kind: "directive", type: RouterOutlet, selector: "router-outlet", outputs: ["activate", "deactivate", "attach", "detach"], exportAs: ["outlet"] }] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: ɵEmptyOutletComponent, decorators: [{
+ɵEmptyOutletComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: ɵEmptyOutletComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+ɵEmptyOutletComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.0-next.0", type: ɵEmptyOutletComponent, selector: "ng-component", ngImport: i0, template: `<router-outlet></router-outlet>`, isInline: true, dependencies: [{ kind: "directive", type: RouterOutlet, selector: "router-outlet", outputs: ["activate", "deactivate", "attach", "detach"], exportAs: ["outlet"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: ɵEmptyOutletComponent, decorators: [{
             type: Component,
             args: [{ template: `<router-outlet></router-outlet>` }]
         }] });
@@ -3073,9 +3234,7 @@ class ApplyRedirects {
         return new Error(`Cannot match any routes. URL Segment: '${e.segmentGroup}'`);
     }
     createUrlTree(rootCandidate, queryParams, fragment) {
-        const root = rootCandidate.segments.length > 0 ?
-            new UrlSegmentGroup([], { [PRIMARY_OUTLET]: rootCandidate }) :
-            rootCandidate;
+        const root = createRoot(rootCandidate);
         return new UrlTree(root, queryParams, fragment);
     }
     expandSegmentGroup(injector, routes, segmentGroup, outlet) {
@@ -3327,39 +3486,6 @@ class ApplyRedirects {
         return redirectToUrlSegment;
     }
 }
-/**
- * When possible, merges the primary outlet child into the parent `UrlSegmentGroup`.
- *
- * When a segment group has only one child which is a primary outlet, merges that child into the
- * parent. That is, the child segment group's segments are merged into the `s` and the child's
- * children become the children of `s`. Think of this like a 'squash', merging the child segment
- * group into the parent.
- */
-function mergeTrivialChildren(s) {
-    if (s.numberOfChildren === 1 && s.children[PRIMARY_OUTLET]) {
-        const c = s.children[PRIMARY_OUTLET];
-        return new UrlSegmentGroup(s.segments.concat(c.segments), c.children);
-    }
-    return s;
-}
-/**
- * Recursively merges primary segment children into their parents and also drops empty children
- * (those which have no segments and no children themselves). The latter prevents serializing a
- * group into something like `/a(aux:)`, where `aux` is an empty child segment.
- */
-function squashSegmentGroup(segmentGroup) {
-    const newChildren = {};
-    for (const childOutlet of Object.keys(segmentGroup.children)) {
-        const child = segmentGroup.children[childOutlet];
-        const childCandidate = squashSegmentGroup(child);
-        // don't add empty children
-        if (childCandidate.segments.length > 0 || childCandidate.hasChildren()) {
-            newChildren[childOutlet] = childCandidate;
-        }
-    }
-    const s = new UrlSegmentGroup(segmentGroup.segments, newChildren);
-    return mergeTrivialChildren(s);
-}
 
 /**
  * @license
@@ -4186,9 +4312,9 @@ class RouterConfigLoader {
         }));
     }
 }
-RouterConfigLoader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: RouterConfigLoader, deps: [{ token: i0.Injector }, { token: i0.Compiler }], target: i0.ɵɵFactoryTarget.Injectable });
-RouterConfigLoader.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: RouterConfigLoader });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: RouterConfigLoader, decorators: [{
+RouterConfigLoader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterConfigLoader, deps: [{ token: i0.Injector }, { token: i0.Compiler }], target: i0.ɵɵFactoryTarget.Injectable });
+RouterConfigLoader.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterConfigLoader });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterConfigLoader, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i0.Compiler }]; } });
 
@@ -5193,9 +5319,9 @@ class Router {
         return { navigationId };
     }
 }
-Router.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: Router, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
-Router.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: Router });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: Router, decorators: [{
+Router.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: Router, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
+Router.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: Router });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: Router, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: i0.Type }, { type: UrlSerializer }, { type: ChildrenOutletContexts }, { type: i3.Location }, { type: i0.Injector }, { type: i0.Compiler }, { type: undefined }]; } });
 function validateCommands(commands) {
@@ -5394,9 +5520,9 @@ class RouterLink {
         });
     }
 }
-RouterLink.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: RouterLink, deps: [{ token: Router }, { token: ActivatedRoute }, { token: 'tabindex', attribute: true }, { token: i0.Renderer2 }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
-RouterLink.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.0.1", type: RouterLink, selector: ":not(a):not(area)[routerLink]", inputs: { queryParams: "queryParams", fragment: "fragment", queryParamsHandling: "queryParamsHandling", preserveFragment: "preserveFragment", skipLocationChange: "skipLocationChange", replaceUrl: "replaceUrl", state: "state", relativeTo: "relativeTo", routerLink: "routerLink" }, host: { listeners: { "click": "onClick()" } }, usesOnChanges: true, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: RouterLink, decorators: [{
+RouterLink.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterLink, deps: [{ token: Router }, { token: ActivatedRoute }, { token: 'tabindex', attribute: true }, { token: i0.Renderer2 }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+RouterLink.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.1.0-next.0", type: RouterLink, selector: ":not(a):not(area)[routerLink]", inputs: { queryParams: "queryParams", fragment: "fragment", queryParamsHandling: "queryParamsHandling", preserveFragment: "preserveFragment", skipLocationChange: "skipLocationChange", replaceUrl: "replaceUrl", state: "state", relativeTo: "relativeTo", routerLink: "routerLink" }, host: { listeners: { "click": "onClick()" } }, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterLink, decorators: [{
             type: Directive,
             args: [{ selector: ':not(a):not(area)[routerLink]' }]
         }], ctorParameters: function () { return [{ type: Router }, { type: ActivatedRoute }, { type: undefined, decorators: [{
@@ -5513,9 +5639,9 @@ class RouterLinkWithHref {
         });
     }
 }
-RouterLinkWithHref.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: RouterLinkWithHref, deps: [{ token: Router }, { token: ActivatedRoute }, { token: i3.LocationStrategy }], target: i0.ɵɵFactoryTarget.Directive });
-RouterLinkWithHref.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.0.1", type: RouterLinkWithHref, selector: "a[routerLink],area[routerLink]", inputs: { target: "target", queryParams: "queryParams", fragment: "fragment", queryParamsHandling: "queryParamsHandling", preserveFragment: "preserveFragment", skipLocationChange: "skipLocationChange", replaceUrl: "replaceUrl", state: "state", relativeTo: "relativeTo", routerLink: "routerLink" }, host: { listeners: { "click": "onClick($event.button,$event.ctrlKey,$event.shiftKey,$event.altKey,$event.metaKey)" }, properties: { "attr.target": "this.target", "attr.href": "this.href" } }, usesOnChanges: true, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: RouterLinkWithHref, decorators: [{
+RouterLinkWithHref.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterLinkWithHref, deps: [{ token: Router }, { token: ActivatedRoute }, { token: i3.LocationStrategy }], target: i0.ɵɵFactoryTarget.Directive });
+RouterLinkWithHref.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.1.0-next.0", type: RouterLinkWithHref, selector: "a[routerLink],area[routerLink]", inputs: { target: "target", queryParams: "queryParams", fragment: "fragment", queryParamsHandling: "queryParamsHandling", preserveFragment: "preserveFragment", skipLocationChange: "skipLocationChange", replaceUrl: "replaceUrl", state: "state", relativeTo: "relativeTo", routerLink: "routerLink" }, host: { listeners: { "click": "onClick($event.button,$event.ctrlKey,$event.shiftKey,$event.altKey,$event.metaKey)" }, properties: { "attr.target": "this.target", "attr.href": "this.href" } }, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterLinkWithHref, decorators: [{
             type: Directive,
             args: [{ selector: 'a[routerLink],area[routerLink]' }]
         }], ctorParameters: function () { return [{ type: Router }, { type: ActivatedRoute }, { type: i3.LocationStrategy }]; }, propDecorators: { target: [{
@@ -5740,9 +5866,9 @@ class RouterLinkActive {
             this.links.some(isActiveCheckFn) || this.linksWithHrefs.some(isActiveCheckFn);
     }
 }
-RouterLinkActive.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: RouterLinkActive, deps: [{ token: Router }, { token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.ChangeDetectorRef }, { token: RouterLink, optional: true }, { token: RouterLinkWithHref, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
-RouterLinkActive.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.0.1", type: RouterLinkActive, selector: "[routerLinkActive]", inputs: { routerLinkActiveOptions: "routerLinkActiveOptions", ariaCurrentWhenActive: "ariaCurrentWhenActive", routerLinkActive: "routerLinkActive" }, outputs: { isActiveChange: "isActiveChange" }, queries: [{ propertyName: "links", predicate: RouterLink, descendants: true }, { propertyName: "linksWithHrefs", predicate: RouterLinkWithHref, descendants: true }], exportAs: ["routerLinkActive"], usesOnChanges: true, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: RouterLinkActive, decorators: [{
+RouterLinkActive.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterLinkActive, deps: [{ token: Router }, { token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.ChangeDetectorRef }, { token: RouterLink, optional: true }, { token: RouterLinkWithHref, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+RouterLinkActive.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.1.0-next.0", type: RouterLinkActive, selector: "[routerLinkActive]", inputs: { routerLinkActiveOptions: "routerLinkActiveOptions", ariaCurrentWhenActive: "ariaCurrentWhenActive", routerLinkActive: "routerLinkActive" }, outputs: { isActiveChange: "isActiveChange" }, queries: [{ propertyName: "links", predicate: RouterLink, descendants: true }, { propertyName: "linksWithHrefs", predicate: RouterLinkWithHref, descendants: true }], exportAs: ["routerLinkActive"], usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterLinkActive, decorators: [{
             type: Directive,
             args: [{
                     selector: '[routerLinkActive]',
@@ -5845,9 +5971,9 @@ class DefaultTitleStrategy extends TitleStrategy {
         }
     }
 }
-DefaultTitleStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: DefaultTitleStrategy, deps: [{ token: i1.Title }], target: i0.ɵɵFactoryTarget.Injectable });
-DefaultTitleStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: DefaultTitleStrategy, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: DefaultTitleStrategy, decorators: [{
+DefaultTitleStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: DefaultTitleStrategy, deps: [{ token: i1.Title }], target: i0.ɵɵFactoryTarget.Injectable });
+DefaultTitleStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: DefaultTitleStrategy, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: DefaultTitleStrategy, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: function () { return [{ type: i1.Title }]; } });
@@ -5980,9 +6106,9 @@ class RouterPreloader {
         });
     }
 }
-RouterPreloader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: RouterPreloader, deps: [{ token: Router }, { token: i0.Compiler }, { token: i0.EnvironmentInjector }, { token: PreloadingStrategy }, { token: RouterConfigLoader }], target: i0.ɵɵFactoryTarget.Injectable });
-RouterPreloader.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: RouterPreloader });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: RouterPreloader, decorators: [{
+RouterPreloader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterPreloader, deps: [{ token: Router }, { token: i0.Compiler }, { token: i0.EnvironmentInjector }, { token: PreloadingStrategy }, { token: RouterConfigLoader }], target: i0.ɵɵFactoryTarget.Injectable });
+RouterPreloader.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterPreloader });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterPreloader, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: Router }, { type: i0.Compiler }, { type: i0.EnvironmentInjector }, { type: PreloadingStrategy }, { type: RouterConfigLoader }]; } });
 
@@ -6068,9 +6194,9 @@ class RouterScroller {
         }
     }
 }
-RouterScroller.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: RouterScroller, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
-RouterScroller.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: RouterScroller });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: RouterScroller, decorators: [{
+RouterScroller.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterScroller, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
+RouterScroller.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterScroller });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterScroller, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: Router }, { type: i3.ViewportScroller }, { type: undefined }]; } });
 
@@ -6212,10 +6338,10 @@ class RouterModule {
         return { ngModule: RouterModule, providers: [provideRoutes(routes)] };
     }
 }
-RouterModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: RouterModule, deps: [{ token: ROUTER_FORROOT_GUARD, optional: true }, { token: Router, optional: true }], target: i0.ɵɵFactoryTarget.NgModule });
-RouterModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.0.1", ngImport: i0, type: RouterModule, declarations: [RouterOutlet, RouterLink, RouterLinkWithHref, RouterLinkActive, ɵEmptyOutletComponent], exports: [RouterOutlet, RouterLink, RouterLinkWithHref, RouterLinkActive, ɵEmptyOutletComponent] });
-RouterModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: RouterModule });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: RouterModule, decorators: [{
+RouterModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterModule, deps: [{ token: ROUTER_FORROOT_GUARD, optional: true }, { token: Router, optional: true }], target: i0.ɵɵFactoryTarget.NgModule });
+RouterModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterModule, declarations: [RouterOutlet, RouterLink, RouterLinkWithHref, RouterLinkActive, ɵEmptyOutletComponent], exports: [RouterOutlet, RouterLink, RouterLinkWithHref, RouterLinkActive, ɵEmptyOutletComponent] });
+RouterModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterModule, decorators: [{
             type: NgModule,
             args: [{
                     declarations: ROUTER_DIRECTIVES,
@@ -6392,9 +6518,9 @@ class RouterInitializer {
         this.destroyed = true;
     }
 }
-RouterInitializer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: RouterInitializer, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
-RouterInitializer.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: RouterInitializer });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: RouterInitializer, decorators: [{
+RouterInitializer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterInitializer, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+RouterInitializer.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterInitializer });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0-next.0", ngImport: i0, type: RouterInitializer, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
 function getAppInitializer(r) {
@@ -6434,7 +6560,7 @@ function provideRouterInitializer() {
 /**
  * @publicApi
  */
-const VERSION = new Version('14.0.1');
+const VERSION = new Version('14.1.0-next.0');
 
 /**
  * @license
@@ -6473,5 +6599,5 @@ const VERSION = new Version('14.0.1');
  * Generated bundle index. Do not edit.
  */
 
-export { ActivatedRoute, ActivatedRouteSnapshot, ActivationEnd, ActivationStart, BaseRouteReuseStrategy, ChildActivationEnd, ChildActivationStart, ChildrenOutletContexts, DefaultTitleStrategy, DefaultUrlSerializer, GuardsCheckEnd, GuardsCheckStart, NavigationCancel, NavigationEnd, NavigationError, NavigationStart, NoPreloading, OutletContext, PRIMARY_OUTLET, PreloadAllModules, PreloadingStrategy, ROUTER_CONFIGURATION, ROUTER_INITIALIZER, ROUTES, ResolveEnd, ResolveStart, RouteConfigLoadEnd, RouteConfigLoadStart, RouteReuseStrategy, Router, RouterEvent, RouterLink, RouterLinkActive, RouterLinkWithHref, RouterModule, RouterOutlet, RouterPreloader, RouterState, RouterStateSnapshot, RoutesRecognized, Scroll, TitleStrategy, UrlHandlingStrategy, UrlSegment, UrlSegmentGroup, UrlSerializer, UrlTree, VERSION, convertToParamMap, provideRoutes, ɵEmptyOutletComponent, ROUTER_PROVIDERS as ɵROUTER_PROVIDERS, assignExtraOptionsToRouter as ɵassignExtraOptionsToRouter, flatten as ɵflatten };
+export { ActivatedRoute, ActivatedRouteSnapshot, ActivationEnd, ActivationStart, BaseRouteReuseStrategy, ChildActivationEnd, ChildActivationStart, ChildrenOutletContexts, DefaultTitleStrategy, DefaultUrlSerializer, GuardsCheckEnd, GuardsCheckStart, NavigationCancel, NavigationEnd, NavigationError, NavigationStart, NoPreloading, OutletContext, PRIMARY_OUTLET, PreloadAllModules, PreloadingStrategy, ROUTER_CONFIGURATION, ROUTER_INITIALIZER, ROUTES, ResolveEnd, ResolveStart, RouteConfigLoadEnd, RouteConfigLoadStart, RouteReuseStrategy, Router, RouterEvent, RouterLink, RouterLinkActive, RouterLinkWithHref, RouterModule, RouterOutlet, RouterPreloader, RouterState, RouterStateSnapshot, RoutesRecognized, Scroll, TitleStrategy, UrlHandlingStrategy, UrlSegment, UrlSegmentGroup, UrlSerializer, UrlTree, VERSION, convertToParamMap, createUrlTreeFromSnapshot, provideRoutes, ɵEmptyOutletComponent, ROUTER_PROVIDERS as ɵROUTER_PROVIDERS, assignExtraOptionsToRouter as ɵassignExtraOptionsToRouter, flatten as ɵflatten };
 //# sourceMappingURL=router.mjs.map