shared-lib-angular 1.0.0

package/.jest-cache/jest-transform-cache-9a3a3745ceefdbbde8dc96f3a11cb645-79ef2876fae7ca75eedb2aa53dc48338/cf/router2_cf9d43bf1bbddffad92ce6f986903a05

@@ -0,0 +1,4525 @@
+ded0a1db03e3adf98d05c398c2662453
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from2, except, desc) => {
+  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+    for (let key of __getOwnPropNames(from2))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var router2_exports = {};
+__export(router2_exports, {
+  ActivatedRoute: () => ActivatedRoute,
+  ActivatedRouteSnapshot: () => ActivatedRouteSnapshot,
+  ActivationEnd: () => ActivationEnd,
+  ActivationStart: () => ActivationStart,
+  BaseRouteReuseStrategy: () => BaseRouteReuseStrategy,
+  CREATE_VIEW_TRANSITION: () => CREATE_VIEW_TRANSITION,
+  ChildActivationEnd: () => ChildActivationEnd,
+  ChildActivationStart: () => ChildActivationStart,
+  ChildrenOutletContexts: () => ChildrenOutletContexts,
+  DefaultTitleStrategy: () => DefaultTitleStrategy,
+  DefaultUrlSerializer: () => DefaultUrlSerializer,
+  EventType: () => EventType,
+  GuardsCheckEnd: () => GuardsCheckEnd,
+  GuardsCheckStart: () => GuardsCheckStart,
+  IMPERATIVE_NAVIGATION: () => IMPERATIVE_NAVIGATION,
+  INPUT_BINDER: () => INPUT_BINDER,
+  NAVIGATION_ERROR_HANDLER: () => NAVIGATION_ERROR_HANDLER,
+  NavigationCancel: () => NavigationCancel,
+  NavigationCancellationCode: () => NavigationCancellationCode,
+  NavigationEnd: () => NavigationEnd,
+  NavigationError: () => NavigationError,
+  NavigationSkipped: () => NavigationSkipped,
+  NavigationSkippedCode: () => NavigationSkippedCode,
+  NavigationStart: () => NavigationStart,
+  NavigationTransitions: () => NavigationTransitions,
+  OutletContext: () => OutletContext,
+  PRIMARY_OUTLET: () => PRIMARY_OUTLET,
+  ROUTER_CONFIGURATION: () => ROUTER_CONFIGURATION,
+  ROUTER_OUTLET_DATA: () => ROUTER_OUTLET_DATA,
+  ROUTES: () => ROUTES,
+  RedirectCommand: () => RedirectCommand,
+  ResolveEnd: () => ResolveEnd,
+  ResolveStart: () => ResolveStart,
+  RouteConfigLoadEnd: () => RouteConfigLoadEnd,
+  RouteConfigLoadStart: () => RouteConfigLoadStart,
+  RouteReuseStrategy: () => RouteReuseStrategy,
+  RoutedComponentInputBinder: () => RoutedComponentInputBinder,
+  Router: () => Router,
+  RouterConfigLoader: () => RouterConfigLoader,
+  RouterEvent: () => RouterEvent,
+  RouterOutlet: () => RouterOutlet,
+  RouterState: () => RouterState,
+  RouterStateSnapshot: () => RouterStateSnapshot,
+  RoutesRecognized: () => RoutesRecognized,
+  Scroll: () => Scroll,
+  TitleStrategy: () => TitleStrategy,
+  UrlHandlingStrategy: () => UrlHandlingStrategy,
+  UrlSegment: () => UrlSegment,
+  UrlSegmentGroup: () => UrlSegmentGroup,
+  UrlSerializer: () => UrlSerializer,
+  UrlTree: () => UrlTree,
+  VIEW_TRANSITION_OPTIONS: () => VIEW_TRANSITION_OPTIONS,
+  afterNextNavigation: () => afterNextNavigation,
+  convertToParamMap: () => convertToParamMap,
+  createUrlTreeFromSnapshot: () => createUrlTreeFromSnapshot,
+  createViewTransition: () => createViewTransition,
+  defaultUrlMatcher: () => defaultUrlMatcher,
+  isUrlTree: () => isUrlTree,
+  loadChildren: () => loadChildren,
+  stringifyEvent: () => stringifyEvent,
+  \u0275EmptyOutletComponent: () => \u0275EmptyOutletComponent
+});
+module.exports = __toCommonJS(router2_exports);
+var import_common = require("@angular/common");
+var i0 = __toESM(require("@angular/core"), 1);
+var import_core = require("@angular/core");
+var import_rxjs = require("rxjs");
+var import_operators = require("rxjs/operators");
+var i1 = __toESM(require("@angular/platform-browser"), 1);
+/**
+ * @license Angular v20.3.16
+ * (c) 2010-2025 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+var _a, _b;
+const PRIMARY_OUTLET = "primary";
+const RouteTitleKey = /* @__PURE__ */ Symbol("RouteTitle");
+class ParamsAsMap {
+  constructor(params) {
+    __publicField(this, "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);
+  }
+}
+function convertToParamMap(params) {
+  return new ParamsAsMap(params);
+}
+function defaultUrlMatcher(segments, segmentGroup, route) {
+  const parts = route.path.split("/");
+  if (parts.length > segments.length) {
+    return null;
+  }
+  if (route.pathMatch === "full" && (segmentGroup.hasChildren() || parts.length < segments.length)) {
+    return null;
+  }
+  const posParams = {};
+  for (let index = 0; index < parts.length; index++) {
+    const part = parts[index];
+    const segment = segments[index];
+    const isParameter = part[0] === ":";
+    if (isParameter) {
+      posParams[part.substring(1)] = segment;
+    } else if (part !== segment.path) {
+      return null;
+    }
+  }
+  return { consumed: segments.slice(0, parts.length), posParams };
+}
+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;
+  }
+  return true;
+}
+function shallowEqual(a, b) {
+  const k1 = a ? getDataKeys(a) : void 0;
+  const k2 = b ? getDataKeys(b) : void 0;
+  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;
+}
+function getDataKeys(obj) {
+  return [...Object.keys(obj), ...Object.getOwnPropertySymbols(obj)];
+}
+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);
+  } else {
+    return a === b;
+  }
+}
+function last(a) {
+  return a.length > 0 ? a[a.length - 1] : null;
+}
+function wrapIntoObservable(value) {
+  if ((0, import_rxjs.isObservable)(value)) {
+    return value;
+  }
+  if ((0, import_core.\u0275isPromise)(value)) {
+    return (0, import_rxjs.from)(Promise.resolve(value));
+  }
+  return (0, import_rxjs.of)(value);
+}
+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) {
+  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);
+  });
+}
+class UrlTree {
+  constructor(root = new UrlSegmentGroup([], {}), queryParams = {}, fragment = null) {
+    __publicField(this, "root");
+    __publicField(this, "queryParams");
+    __publicField(this, "fragment");
+    /** @internal */
+    __publicField(this, "_queryParamMap");
+    this.root = root;
+    this.queryParams = queryParams;
+    this.fragment = fragment;
+    if (typeof ngDevMode === "undefined" || ngDevMode) {
+      if (root.segments.length > 0) {
+        throw new import_core.\u0275RuntimeError(4015, "The root `UrlSegmentGroup` should not contain `segments`. Instead, these segments belong in the `children` so they can be associated with a named outlet.");
+      }
+    }
+  }
+  get queryParamMap() {
+    var _a2;
+    (_a2 = this._queryParamMap) != null ? _a2 : this._queryParamMap = convertToParamMap(this.queryParams);
+    return this._queryParamMap;
+  }
+  /** @docsNotRequired */
+  toString() {
+    return DEFAULT_SERIALIZER.serialize(this);
+  }
+}
+class UrlSegmentGroup {
+  constructor(segments, children) {
+    __publicField(this, "segments");
+    __publicField(this, "children");
+    /** The parent node in the url tree */
+    __publicField(this, "parent", null);
+    this.segments = segments;
+    this.children = children;
+    Object.values(children).forEach((v) => 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);
+  }
+}
+class UrlSegment {
+  constructor(path, parameters) {
+    __publicField(this, "path");
+    __publicField(this, "parameters");
+    /** @internal */
+    __publicField(this, "_parameterMap");
+    this.path = path;
+    this.parameters = parameters;
+  }
+  get parameterMap() {
+    var _a2;
+    (_a2 = this._parameterMap) != null ? _a2 : this._parameterMap = convertToParamMap(this.parameters);
+    return this._parameterMap;
+  }
+  /** @docsNotRequired */
+  toString() {
+    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 = [];
+  Object.entries(segment.children).forEach(([childOutlet, child]) => {
+    if (childOutlet === PRIMARY_OUTLET) {
+      res = res.concat(fn(child, childOutlet));
+    }
+  });
+  Object.entries(segment.children).forEach(([childOutlet, child]) => {
+    if (childOutlet !== PRIMARY_OUTLET) {
+      res = res.concat(fn(child, childOutlet));
+    }
+  });
+  return res;
+}
+const _UrlSerializer = class _UrlSerializer {
+};
+__publicField(_UrlSerializer, "\u0275fac", i0.\u0275\u0275ngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _UrlSerializer, deps: [], target: i0.\u0275\u0275FactoryTarget.Injectable }));
+__publicField(_UrlSerializer, "\u0275prov", i0.\u0275\u0275ngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _UrlSerializer, providedIn: "root", useFactory: () => new DefaultUrlSerializer() }));
+let UrlSerializer = _UrlSerializer;
+i0.\u0275\u0275ngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: UrlSerializer, decorators: [{
+  type: import_core.Injectable,
+  args: [{ providedIn: "root", useFactory: () => new DefaultUrlSerializer() }]
+}] });
+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(tree2) {
+    const segment = `/${serializeSegment(tree2.root, true)}`;
+    const query = serializeQueryParams(tree2.queryParams);
+    const fragment = typeof tree2.fragment === `string` ? `#${encodeUriFragment(tree2.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 = [];
+    Object.entries(segment.children).forEach(([k, v]) => {
+      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)}`];
+    });
+    if (Object.keys(segment.children).length === 1 && segment.children[PRIMARY_OUTLET] != null) {
+      return `${serializePaths(segment)}/${children[0]}`;
+    }
+    return `${serializePaths(segment)}/(${children.join("//")})`;
+  }
+}
+function encodeUriString(s) {
+  return encodeURIComponent(s).replace(/%40/g, "@").replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",");
+}
+function encodeUriQuery(s) {
+  return encodeUriString(s).replace(/%3B/gi, ";");
+}
+function encodeUriFragment(s) {
+  return encodeURI(s);
+}
+function encodeUriSegment(s) {
+  return encodeUriString(s).replace(/\(/g, "%28").replace(/\)/g, "%29").replace(/%26/gi, "&");
+}
+function decode(s) {
+  return decodeURIComponent(s);
+}
+function decodeQuery(s) {
+  return decode(s.replace(/\+/g, "%20"));
+}
+function serializePath(path) {
+  return `${encodeUriSegment(path.path)}${serializeMatrixParams(path.parameters)}`;
+}
+function serializeMatrixParams(params) {
+  return Object.entries(params).map(([key, value]) => `;${encodeUriSegment(key)}=${encodeUriSegment(value)}`).join("");
+}
+function serializeQueryParams(params) {
+  const strParams = Object.entries(params).map(([name, value]) => {
+    return Array.isArray(value) ? value.map((v) => `${encodeUriQuery(name)}=${encodeUriQuery(v)}`).join("&") : `${encodeUriQuery(name)}=${encodeUriQuery(value)}`;
+  }).filter((s) => s);
+  return strParams.length ? `?${strParams.join("&")}` : "";
+}
+const SEGMENT_RE = /^[^\/()?;#]+/;
+function matchSegments(str) {
+  const match2 = str.match(SEGMENT_RE);
+  return match2 ? match2[0] : "";
+}
+const MATRIX_PARAM_SEGMENT_RE = /^[^\/()?;=#]+/;
+function matchMatrixKeySegments(str) {
+  const match2 = str.match(MATRIX_PARAM_SEGMENT_RE);
+  return match2 ? match2[0] : "";
+}
+const QUERY_PARAM_RE = /^[^=?&#]+/;
+function matchQueryParams(str) {
+  const match2 = str.match(QUERY_PARAM_RE);
+  return match2 ? match2[0] : "";
+}
+const QUERY_PARAM_VALUE_RE = /^[^&#]+/;
+function matchUrlQueryParamValue(str) {
+  const match2 = str.match(QUERY_PARAM_VALUE_RE);
+  return match2 ? match2[0] : "";
+}
+class UrlParser {
+  constructor(url) {
+    __publicField(this, "url");
+    __publicField(this, "remaining");
+    this.url = url;
+    this.remaining = url;
+  }
+  parseRootSegment() {
+    this.consumeOptional("/");
+    if (this.remaining === "" || this.peekStartsWith("?") || this.peekStartsWith("#")) {
+      return new UrlSegmentGroup([], {});
+    }
+    return new UrlSegmentGroup([], this.parseChildren());
+  }
+  parseQueryParams() {
+    const params = {};
+    if (this.consumeOptional("?")) {
+      do {
+        this.parseQueryParam(params);
+      } while (this.consumeOptional("&"));
+    }
+    return params;
+  }
+  parseFragment() {
+    return this.consumeOptional("#") ? decodeURIComponent(this.remaining) : null;
+  }
+  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;
+  }
+  // parse a segment with its matrix parameters
+  // ie `name;k1=v1;k2`
+  parseSegment() {
+    const path = matchSegments(this.remaining);
+    if (path === "" && this.peekStartsWith(";")) {
+      throw new import_core.\u0275RuntimeError(4009, (typeof ngDevMode === "undefined" || ngDevMode) && `Empty path url segment cannot have parameters: '${this.remaining}'.`);
+    }
+    this.capture(path);
+    return new UrlSegment(decode(path), this.parseMatrixParams());
+  }
+  parseMatrixParams() {
+    const params = {};
+    while (this.consumeOptional(";")) {
+      this.parseParam(params);
+    }
+    return params;
+  }
+  parseParam(params) {
+    const key = matchMatrixKeySegments(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)) {
+      let currentVal = params[decodedKey];
+      if (!Array.isArray(currentVal)) {
+        currentVal = [currentVal];
+        params[decodedKey] = currentVal;
+      }
+      currentVal.push(decodedVal);
+    } else {
+      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 (next !== "/" && next !== ")" && next !== ";") {
+        throw new import_core.\u0275RuntimeError(4010, (typeof ngDevMode === "undefined" || ngDevMode) && `Cannot parse url '${this.url}'`);
+      }
+      let outletName;
+      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 != null ? outletName : PRIMARY_OUTLET] = Object.keys(children).length === 1 && children[PRIMARY_OUTLET] ? 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 import_core.\u0275RuntimeError(4011, (typeof ngDevMode === "undefined" || ngDevMode) && `Expected "${str}".`);
+    }
+  }
+}
+function createRoot(rootCandidate) {
+  return rootCandidate.segments.length > 0 ? new UrlSegmentGroup([], { [PRIMARY_OUTLET]: rootCandidate }) : rootCandidate;
+}
+function squashSegmentGroup(segmentGroup) {
+  const newChildren = {};
+  for (const [childOutlet, child] of Object.entries(segmentGroup.children)) {
+    const childCandidate = squashSegmentGroup(child);
+    if (childOutlet === PRIMARY_OUTLET && childCandidate.segments.length === 0 && childCandidate.hasChildren()) {
+      for (const [grandChildOutlet, grandChild] of Object.entries(childCandidate.children)) {
+        newChildren[grandChildOutlet] = grandChild;
+      }
+    } else if (childCandidate.segments.length > 0 || childCandidate.hasChildren()) {
+      newChildren[childOutlet] = childCandidate;
+    }
+  }
+  const s = new UrlSegmentGroup(segmentGroup.segments, newChildren);
+  return mergeTrivialChildren(s);
+}
+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;
+}
+function isUrlTree(v) {
+  return v instanceof UrlTree;
+}
+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 != null ? targetGroup : rootSegmentGroup;
+}
+function createUrlTreeFromSegmentGroup(relativeTo, commands, queryParams, fragment) {
+  let root = relativeTo;
+  while (root.parent) {
+    root = root.parent;
+  }
+  if (commands.length === 0) {
+    return tree(root, root, root, queryParams, fragment);
+  }
+  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 isMatrixParams(command) {
+  return typeof command === "object" && command != null && !command.outlets && !command.segmentPath;
+}
+function isCommandWithOutlets(command) {
+  return typeof command === "object" && command != null && command.outlets;
+}
+function tree(oldRoot, oldSegmentGroup, newSegmentGroup, queryParams, fragment) {
+  let qp = {};
+  if (queryParams) {
+    Object.entries(queryParams).forEach(([name, value]) => {
+      qp[name] = Array.isArray(value) ? value.map((v) => `${v}`) : `${value}`;
+    });
+  }
+  let rootCandidate;
+  if (oldRoot === oldSegmentGroup) {
+    rootCandidate = newSegmentGroup;
+  } else {
+    rootCandidate = replaceSegment(oldRoot, oldSegmentGroup, newSegmentGroup);
+  }
+  const newRoot = createRoot(squashSegmentGroup(rootCandidate));
+  return new UrlTree(newRoot, qp, fragment);
+}
+function replaceSegment(current, oldSegment, newSegment) {
+  const children = {};
+  Object.entries(current.children).forEach(([outletName, c]) => {
+    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) {
+    __publicField(this, "isAbsolute");
+    __publicField(this, "numberOfDoubleDots");
+    __publicField(this, "commands");
+    this.isAbsolute = isAbsolute;
+    this.numberOfDoubleDots = numberOfDoubleDots;
+    this.commands = commands;
+    if (isAbsolute && commands.length > 0 && isMatrixParams(commands[0])) {
+      throw new import_core.\u0275RuntimeError(4003, (typeof ngDevMode === "undefined" || ngDevMode) && "Root segment cannot have matrix parameters");
+    }
+    const cmdWithOutlet = commands.find(isCommandWithOutlets);
+    if (cmdWithOutlet && cmdWithOutlet !== last(commands)) {
+      throw new import_core.\u0275RuntimeError(4004, (typeof ngDevMode === "undefined" || ngDevMode) && "{outlets:{}} has to be the last command");
+    }
+  }
+  toRoot() {
+    return this.isAbsolute && this.commands.length === 1 && this.commands[0] == "/";
+  }
+}
+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((res2, cmd, cmdIdx) => {
+    if (typeof cmd === "object" && cmd != null) {
+      if (cmd.outlets) {
+        const outlets = {};
+        Object.entries(cmd.outlets).forEach(([name, commands2]) => {
+          outlets[name] = typeof commands2 === "string" ? commands2.split("/") : commands2;
+        });
+        return [...res2, { outlets }];
+      }
+      if (cmd.segmentPath) {
+        return [...res2, cmd.segmentPath];
+      }
+    }
+    if (!(typeof cmd === "string")) {
+      return [...res2, cmd];
+    }
+    if (cmdIdx === 0) {
+      cmd.split("/").forEach((urlPart, partIndex) => {
+        if (partIndex == 0 && urlPart === ".") ;
+        else if (partIndex == 0 && urlPart === "") {
+          isAbsolute = true;
+        } else if (urlPart === "..") {
+          numberOfDoubleDots++;
+        } else if (urlPart != "") {
+          res2.push(urlPart);
+        }
+      });
+      return res2;
+    }
+    return [...res2, cmd];
+  }, []);
+  return new Navigation(isAbsolute, numberOfDoubleDots, res);
+}
+class Position {
+  constructor(segmentGroup, processChildren, index) {
+    __publicField(this, "segmentGroup");
+    __publicField(this, "processChildren");
+    __publicField(this, "index");
+    this.segmentGroup = segmentGroup;
+    this.processChildren = processChildren;
+    this.index = index;
+  }
+}
+function findStartingPositionForTargetGroup(nav, root, target) {
+  if (nav.isAbsolute) {
+    return new Position(root, true, 0);
+  }
+  if (!target) {
+    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);
+}
+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 import_core.\u0275RuntimeError(4005, (typeof ngDevMode === "undefined" || ngDevMode) && "Invalid number of '../'");
+    }
+    ci = g.segments.length;
+  }
+  return new Position(g, false, ci - dd);
+}
+function getOutlets(commands) {
+  if (isCommandWithOutlets(commands[0])) {
+    return commands[0].outlets;
+  }
+  return { [PRIMARY_OUTLET]: commands };
+}
+function updateSegmentGroup(segmentGroup, startIndex, commands) {
+  segmentGroup != null ? segmentGroup : segmentGroup = new UrlSegmentGroup([], {});
+  if (segmentGroup.segments.length === 0 && segmentGroup.hasChildren()) {
+    return updateSegmentGroupChildren(segmentGroup, startIndex, commands);
+  }
+  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);
+  } else if (m.match && slicedCommands.length === 0) {
+    return new UrlSegmentGroup(segmentGroup.segments, {});
+  } else if (m.match && !segmentGroup.hasChildren()) {
+    return createNewSegmentGroup(segmentGroup, startIndex, commands);
+  } else if (m.match) {
+    return updateSegmentGroupChildren(segmentGroup, 0, slicedCommands);
+  } else {
+    return createNewSegmentGroup(segmentGroup, startIndex, commands);
+  }
+}
+function updateSegmentGroupChildren(segmentGroup, startIndex, commands) {
+  if (commands.length === 0) {
+    return new UrlSegmentGroup(segmentGroup.segments, {});
+  } else {
+    const outlets = getOutlets(commands);
+    const children = {};
+    if (Object.keys(outlets).some((o) => o !== PRIMARY_OUTLET) && segmentGroup.children[PRIMARY_OUTLET] && segmentGroup.numberOfChildren === 1 && segmentGroup.children[PRIMARY_OUTLET].segments.length === 0) {
+      const childrenOfEmptyChild = updateSegmentGroupChildren(segmentGroup.children[PRIMARY_OUTLET], startIndex, commands);
+      return new UrlSegmentGroup(segmentGroup.segments, childrenOfEmptyChild.children);
+    }
+    Object.entries(outlets).forEach(([outlet, commands2]) => {
+      if (typeof commands2 === "string") {
+        commands2 = [commands2];
+      }
+      if (commands2 !== null) {
+        children[outlet] = updateSegmentGroup(segmentGroup.children[outlet], startIndex, commands2);
+      }
+    });
+    Object.entries(segmentGroup.children).forEach(([childOutlet, child]) => {
+      if (outlets[childOutlet] === void 0) {
+        children[childOutlet] = child;
+      }
+    });
+    return new UrlSegmentGroup(segmentGroup.segments, children);
+  }
+}
+function prefixedWith(segmentGroup, startIndex, commands) {
+  let currentCommandIndex = 0;
+  let currentPathIndex = startIndex;
+  const noMatch2 = { match: false, pathIndex: 0, commandIndex: 0 };
+  while (currentPathIndex < segmentGroup.segments.length) {
+    if (currentCommandIndex >= commands.length)
+      return noMatch2;
+    const path = segmentGroup.segments[currentPathIndex];
+    const command = commands[currentCommandIndex];
+    if (isCommandWithOutlets(command)) {
+      break;
+    }
+    const curr = `${command}`;
+    const next = currentCommandIndex < commands.length - 1 ? commands[currentCommandIndex + 1] : null;
+    if (currentPathIndex > 0 && curr === void 0)
+      break;
+    if (curr && next && typeof next === "object" && next.outlets === void 0) {
+      if (!compare(curr, next, path))
+        return noMatch2;
+      currentCommandIndex += 2;
+    } else {
+      if (!compare(curr, {}, path))
+        return noMatch2;
+      currentCommandIndex++;
+    }
+    currentPathIndex++;
+  }
+  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);
+    }
+    if (i === 0 && isMatrixParams(commands[0])) {
+      const p = segmentGroup.segments[startIndex];
+      paths.push(new UrlSegment(p.path, stringify(commands[0])));
+      i++;
+      continue;
+    }
+    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 {
+      paths.push(new UrlSegment(curr, {}));
+      i++;
+    }
+  }
+  return new UrlSegmentGroup(paths, {});
+}
+function createNewSegmentChildren(outlets) {
+  const children = {};
+  Object.entries(outlets).forEach(([outlet, commands]) => {
+    if (typeof commands === "string") {
+      commands = [commands];
+    }
+    if (commands !== null) {
+      children[outlet] = createNewSegmentGroup(new UrlSegmentGroup([], {}), 0, commands);
+    }
+  });
+  return children;
+}
+function stringify(params) {
+  const res = {};
+  Object.entries(params).forEach(([k, v]) => res[k] = `${v}`);
+  return res;
+}
+function compare(path, params, segment) {
+  return path == segment.path && shallowEqual(params, segment.parameters);
+}
+const IMPERATIVE_NAVIGATION = "imperative";
+var EventType;
+(function(EventType2) {
+  EventType2[EventType2["NavigationStart"] = 0] = "NavigationStart";
+  EventType2[EventType2["NavigationEnd"] = 1] = "NavigationEnd";
+  EventType2[EventType2["NavigationCancel"] = 2] = "NavigationCancel";
+  EventType2[EventType2["NavigationError"] = 3] = "NavigationError";
+  EventType2[EventType2["RoutesRecognized"] = 4] = "RoutesRecognized";
+  EventType2[EventType2["ResolveStart"] = 5] = "ResolveStart";
+  EventType2[EventType2["ResolveEnd"] = 6] = "ResolveEnd";
+  EventType2[EventType2["GuardsCheckStart"] = 7] = "GuardsCheckStart";
+  EventType2[EventType2["GuardsCheckEnd"] = 8] = "GuardsCheckEnd";
+  EventType2[EventType2["RouteConfigLoadStart"] = 9] = "RouteConfigLoadStart";
+  EventType2[EventType2["RouteConfigLoadEnd"] = 10] = "RouteConfigLoadEnd";
+  EventType2[EventType2["ChildActivationStart"] = 11] = "ChildActivationStart";
+  EventType2[EventType2["ChildActivationEnd"] = 12] = "ChildActivationEnd";
+  EventType2[EventType2["ActivationStart"] = 13] = "ActivationStart";
+  EventType2[EventType2["ActivationEnd"] = 14] = "ActivationEnd";
+  EventType2[EventType2["Scroll"] = 15] = "Scroll";
+  EventType2[EventType2["NavigationSkipped"] = 16] = "NavigationSkipped";
+})(EventType || (EventType = {}));
+class RouterEvent {
+  constructor(id, url) {
+    __publicField(this, "id");
+    __publicField(this, "url");
+    this.id = id;
+    this.url = url;
+  }
+}
+class NavigationStart extends RouterEvent {
+  constructor(id, url, navigationTrigger = "imperative", restoredState = null) {
+    super(id, url);
+    __publicField(this, "type", EventType.NavigationStart);
+    /**
+     * Identifies the call or event that triggered the navigation.
+     * An `imperative` trigger is a call to `router.navigateByUrl()` or `router.navigate()`.
+     *
+     * @see {@link NavigationEnd}
+     * @see {@link NavigationCancel}
+     * @see {@link NavigationError}
+     */
+    __publicField(this, "navigationTrigger");
+    /**
+     * The navigation state that was previously supplied to the `pushState` call,
+     * when the navigation is triggered by a `popstate` event. Otherwise null.
+     *
+     * The state object is defined by `NavigationExtras`, and contains any
+     * developer-defined state value, as well as a unique ID that
+     * the router assigns to every router transition/navigation.
+     *
+     * From the perspective of the router, the router never "goes back".
+     * When the user clicks on the back button in the browser,
+     * a new navigation ID is created.
+     *
+     * Use the ID in this previous-state object to differentiate between a newly created
+     * state and one returned to by a `popstate` event, so that you can restore some
+     * remembered state, such as scroll position.
+     *
+     */
+    __publicField(this, "restoredState");
+    this.navigationTrigger = navigationTrigger;
+    this.restoredState = restoredState;
+  }
+  /** @docsNotRequired */
+  toString() {
+    return `NavigationStart(id: ${this.id}, url: '${this.url}')`;
+  }
+}
+class NavigationEnd extends RouterEvent {
+  constructor(id, url, urlAfterRedirects) {
+    super(id, url);
+    __publicField(this, "urlAfterRedirects");
+    __publicField(this, "type", EventType.NavigationEnd);
+    this.urlAfterRedirects = urlAfterRedirects;
+  }
+  /** @docsNotRequired */
+  toString() {
+    return `NavigationEnd(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}')`;
+  }
+}
+var NavigationCancellationCode;
+(function(NavigationCancellationCode2) {
+  NavigationCancellationCode2[NavigationCancellationCode2["Redirect"] = 0] = "Redirect";
+  NavigationCancellationCode2[NavigationCancellationCode2["SupersededByNewNavigation"] = 1] = "SupersededByNewNavigation";
+  NavigationCancellationCode2[NavigationCancellationCode2["NoDataFromResolver"] = 2] = "NoDataFromResolver";
+  NavigationCancellationCode2[NavigationCancellationCode2["GuardRejected"] = 3] = "GuardRejected";
+  NavigationCancellationCode2[NavigationCancellationCode2["Aborted"] = 4] = "Aborted";
+})(NavigationCancellationCode || (NavigationCancellationCode = {}));
+var NavigationSkippedCode;
+(function(NavigationSkippedCode2) {
+  NavigationSkippedCode2[NavigationSkippedCode2["IgnoredSameUrlNavigation"] = 0] = "IgnoredSameUrlNavigation";
+  NavigationSkippedCode2[NavigationSkippedCode2["IgnoredByUrlHandlingStrategy"] = 1] = "IgnoredByUrlHandlingStrategy";
+})(NavigationSkippedCode || (NavigationSkippedCode = {}));
+class NavigationCancel extends RouterEvent {
+  constructor(id, url, reason, code) {
+    super(id, url);
+    __publicField(this, "reason");
+    __publicField(this, "code");
+    __publicField(this, "type", EventType.NavigationCancel);
+    this.reason = reason;
+    this.code = code;
+  }
+  /** @docsNotRequired */
+  toString() {
+    return `NavigationCancel(id: ${this.id}, url: '${this.url}')`;
+  }
+}
+class NavigationSkipped extends RouterEvent {
+  constructor(id, url, reason, code) {
+    super(id, url);
+    __publicField(this, "reason");
+    __publicField(this, "code");
+    __publicField(this, "type", EventType.NavigationSkipped);
+    this.reason = reason;
+    this.code = code;
+  }
+}
+class NavigationError extends RouterEvent {
+  constructor(id, url, error, target) {
+    super(id, url);
+    __publicField(this, "error");
+    __publicField(this, "target");
+    __publicField(this, "type", EventType.NavigationError);
+    this.error = error;
+    this.target = target;
+  }
+  /** @docsNotRequired */
+  toString() {
+    return `NavigationError(id: ${this.id}, url: '${this.url}', error: ${this.error})`;
+  }
+}
+class RoutesRecognized extends RouterEvent {
+  constructor(id, url, urlAfterRedirects, state) {
+    super(id, url);
+    __publicField(this, "urlAfterRedirects");
+    __publicField(this, "state");
+    __publicField(this, "type", EventType.RoutesRecognized);
+    this.urlAfterRedirects = urlAfterRedirects;
+    this.state = state;
+  }
+  /** @docsNotRequired */
+  toString() {
+    return `RoutesRecognized(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state})`;
+  }
+}
+class GuardsCheckStart extends RouterEvent {
+  constructor(id, url, urlAfterRedirects, state) {
+    super(id, url);
+    __publicField(this, "urlAfterRedirects");
+    __publicField(this, "state");
+    __publicField(this, "type", EventType.GuardsCheckStart);
+    this.urlAfterRedirects = urlAfterRedirects;
+    this.state = state;
+  }
+  toString() {
+    return `GuardsCheckStart(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state})`;
+  }
+}
+class GuardsCheckEnd extends RouterEvent {
+  constructor(id, url, urlAfterRedirects, state, shouldActivate) {
+    super(id, url);
+    __publicField(this, "urlAfterRedirects");
+    __publicField(this, "state");
+    __publicField(this, "shouldActivate");
+    __publicField(this, "type", EventType.GuardsCheckEnd);
+    this.urlAfterRedirects = urlAfterRedirects;
+    this.state = state;
+    this.shouldActivate = shouldActivate;
+  }
+  toString() {
+    return `GuardsCheckEnd(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state}, shouldActivate: ${this.shouldActivate})`;
+  }
+}
+class ResolveStart extends RouterEvent {
+  constructor(id, url, urlAfterRedirects, state) {
+    super(id, url);
+    __publicField(this, "urlAfterRedirects");
+    __publicField(this, "state");
+    __publicField(this, "type", EventType.ResolveStart);
+    this.urlAfterRedirects = urlAfterRedirects;
+    this.state = state;
+  }
+  toString() {
+    return `ResolveStart(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state})`;
+  }
+}
+class ResolveEnd extends RouterEvent {
+  constructor(id, url, urlAfterRedirects, state) {
+    super(id, url);
+    __publicField(this, "urlAfterRedirects");
+    __publicField(this, "state");
+    __publicField(this, "type", EventType.ResolveEnd);
+    this.urlAfterRedirects = urlAfterRedirects;
+    this.state = state;
+  }
+  toString() {
+    return `ResolveEnd(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state})`;
+  }
+}
+class RouteConfigLoadStart {
+  constructor(route) {
+    __publicField(this, "route");
+    __publicField(this, "type", EventType.RouteConfigLoadStart);
+    this.route = route;
+  }
+  toString() {
+    return `RouteConfigLoadStart(path: ${this.route.path})`;
+  }
+}
+class RouteConfigLoadEnd {
+  constructor(route) {
+    __publicField(this, "route");
+    __publicField(this, "type", EventType.RouteConfigLoadEnd);
+    this.route = route;
+  }
+  toString() {
+    return `RouteConfigLoadEnd(path: ${this.route.path})`;
+  }
+}
+class ChildActivationStart {
+  constructor(snapshot) {
+    __publicField(this, "snapshot");
+    __publicField(this, "type", EventType.ChildActivationStart);
+    this.snapshot = snapshot;
+  }
+  toString() {
+    const path = this.snapshot.routeConfig && this.snapshot.routeConfig.path || "";
+    return `ChildActivationStart(path: '${path}')`;
+  }
+}
+class ChildActivationEnd {
+  constructor(snapshot) {
+    __publicField(this, "snapshot");
+    __publicField(this, "type", EventType.ChildActivationEnd);
+    this.snapshot = snapshot;
+  }
+  toString() {
+    const path = this.snapshot.routeConfig && this.snapshot.routeConfig.path || "";
+    return `ChildActivationEnd(path: '${path}')`;
+  }
+}
+class ActivationStart {
+  constructor(snapshot) {
+    __publicField(this, "snapshot");
+    __publicField(this, "type", EventType.ActivationStart);
+    this.snapshot = snapshot;
+  }
+  toString() {
+    const path = this.snapshot.routeConfig && this.snapshot.routeConfig.path || "";
+    return `ActivationStart(path: '${path}')`;
+  }
+}
+class ActivationEnd {
+  constructor(snapshot) {
+    __publicField(this, "snapshot");
+    __publicField(this, "type", EventType.ActivationEnd);
+    this.snapshot = snapshot;
+  }
+  toString() {
+    const path = this.snapshot.routeConfig && this.snapshot.routeConfig.path || "";
+    return `ActivationEnd(path: '${path}')`;
+  }
+}
+class Scroll {
+  constructor(routerEvent, position, anchor) {
+    __publicField(this, "routerEvent");
+    __publicField(this, "position");
+    __publicField(this, "anchor");
+    __publicField(this, "type", EventType.Scroll);
+    this.routerEvent = routerEvent;
+    this.position = position;
+    this.anchor = anchor;
+  }
+  toString() {
+    const pos = this.position ? `${this.position[0]}, ${this.position[1]}` : null;
+    return `Scroll(anchor: '${this.anchor}', position: '${pos}')`;
+  }
+}
+class BeforeActivateRoutes {
+}
+class RedirectRequest {
+  constructor(url, navigationBehaviorOptions) {
+    __publicField(this, "url");
+    __publicField(this, "navigationBehaviorOptions");
+    this.url = url;
+    this.navigationBehaviorOptions = navigationBehaviorOptions;
+  }
+}
+function isPublicRouterEvent(e) {
+  return !(e instanceof BeforeActivateRoutes) && !(e instanceof RedirectRequest);
+}
+function stringifyEvent(routerEvent) {
+  var _a2, _b2, _c, _d;
+  switch (routerEvent.type) {
+    case EventType.ActivationEnd:
+      return `ActivationEnd(path: '${((_a2 = routerEvent.snapshot.routeConfig) == null ? void 0 : _a2.path) || ""}')`;
+    case EventType.ActivationStart:
+      return `ActivationStart(path: '${((_b2 = routerEvent.snapshot.routeConfig) == null ? void 0 : _b2.path) || ""}')`;
+    case EventType.ChildActivationEnd:
+      return `ChildActivationEnd(path: '${((_c = routerEvent.snapshot.routeConfig) == null ? void 0 : _c.path) || ""}')`;
+    case EventType.ChildActivationStart:
+      return `ChildActivationStart(path: '${((_d = routerEvent.snapshot.routeConfig) == null ? void 0 : _d.path) || ""}')`;
+    case EventType.GuardsCheckEnd:
+      return `GuardsCheckEnd(id: ${routerEvent.id}, url: '${routerEvent.url}', urlAfterRedirects: '${routerEvent.urlAfterRedirects}', state: ${routerEvent.state}, shouldActivate: ${routerEvent.shouldActivate})`;
+    case EventType.GuardsCheckStart:
+      return `GuardsCheckStart(id: ${routerEvent.id}, url: '${routerEvent.url}', urlAfterRedirects: '${routerEvent.urlAfterRedirects}', state: ${routerEvent.state})`;
+    case EventType.NavigationCancel:
+      return `NavigationCancel(id: ${routerEvent.id}, url: '${routerEvent.url}')`;
+    case EventType.NavigationSkipped:
+      return `NavigationSkipped(id: ${routerEvent.id}, url: '${routerEvent.url}')`;
+    case EventType.NavigationEnd:
+      return `NavigationEnd(id: ${routerEvent.id}, url: '${routerEvent.url}', urlAfterRedirects: '${routerEvent.urlAfterRedirects}')`;
+    case EventType.NavigationError:
+      return `NavigationError(id: ${routerEvent.id}, url: '${routerEvent.url}', error: ${routerEvent.error})`;
+    case EventType.NavigationStart:
+      return `NavigationStart(id: ${routerEvent.id}, url: '${routerEvent.url}')`;
+    case EventType.ResolveEnd:
+      return `ResolveEnd(id: ${routerEvent.id}, url: '${routerEvent.url}', urlAfterRedirects: '${routerEvent.urlAfterRedirects}', state: ${routerEvent.state})`;
+    case EventType.ResolveStart:
+      return `ResolveStart(id: ${routerEvent.id}, url: '${routerEvent.url}', urlAfterRedirects: '${routerEvent.urlAfterRedirects}', state: ${routerEvent.state})`;
+    case EventType.RouteConfigLoadEnd:
+      return `RouteConfigLoadEnd(path: ${routerEvent.route.path})`;
+    case EventType.RouteConfigLoadStart:
+      return `RouteConfigLoadStart(path: ${routerEvent.route.path})`;
+    case EventType.RoutesRecognized:
+      return `RoutesRecognized(id: ${routerEvent.id}, url: '${routerEvent.url}', urlAfterRedirects: '${routerEvent.urlAfterRedirects}', state: ${routerEvent.state})`;
+    case EventType.Scroll:
+      const pos = routerEvent.position ? `${routerEvent.position[0]}, ${routerEvent.position[1]}` : null;
+      return `Scroll(anchor: '${routerEvent.anchor}', position: '${pos}')`;
+  }
+}
+function getOrCreateRouteInjectorIfNeeded(route, currentInjector) {
+  var _a2;
+  if (route.providers && !route._injector) {
+    route._injector = (0, import_core.createEnvironmentInjector)(route.providers, currentInjector, `Route: ${route.path}`);
+  }
+  return (_a2 = route._injector) != null ? _a2 : currentInjector;
+}
+function validateConfig(config, parentPath = "", requireStandaloneComponents = false) {
+  for (let i = 0; i < config.length; i++) {
+    const route = config[i];
+    const fullPath = getFullPath(parentPath, route);
+    validateNode(route, fullPath, requireStandaloneComponents);
+  }
+}
+function assertStandalone(fullPath, component) {
+  if (component && (0, import_core.\u0275isNgModule)(component)) {
+    throw new import_core.\u0275RuntimeError(4014, `Invalid configuration of route '${fullPath}'. You are using 'loadComponent' with a module, but it must be used with standalone components. Use 'loadChildren' instead.`);
+  } else if (component && !(0, import_core.isStandalone)(component)) {
+    throw new import_core.\u0275RuntimeError(4014, `Invalid configuration of route '${fullPath}'. The component must be standalone.`);
+  }
+}
+function validateNode(route, fullPath, requireStandaloneComponents) {
+  if (typeof ngDevMode === "undefined" || ngDevMode) {
+    if (!route) {
+      throw new import_core.\u0275RuntimeError(4014, `
+      Invalid configuration of route '${fullPath}': Encountered undefined route.
+      The reason might be an extra comma.
+
+      Example:
+      const routes: Routes = [
+        { path: '', redirectTo: '/dashboard', pathMatch: 'full' },
+        { path: 'dashboard',  component: DashboardComponent },, << two commas
+        { path: 'detail/:id', component: HeroDetailComponent }
+      ];
+    `);
+    }
+    if (Array.isArray(route)) {
+      throw new import_core.\u0275RuntimeError(4014, `Invalid configuration of route '${fullPath}': Array cannot be specified`);
+    }
+    if (!route.redirectTo && !route.component && !route.loadComponent && !route.children && !route.loadChildren && route.outlet && route.outlet !== PRIMARY_OUTLET) {
+      throw new import_core.\u0275RuntimeError(4014, `Invalid configuration of route '${fullPath}': a componentless route without children or loadChildren cannot have a named outlet set`);
+    }
+    if (route.redirectTo && route.children) {
+      throw new import_core.\u0275RuntimeError(4014, `Invalid configuration of route '${fullPath}': redirectTo and children cannot be used together`);
+    }
+    if (route.redirectTo && route.loadChildren) {
+      throw new import_core.\u0275RuntimeError(4014, `Invalid configuration of route '${fullPath}': redirectTo and loadChildren cannot be used together`);
+    }
+    if (route.children && route.loadChildren) {
+      throw new import_core.\u0275RuntimeError(4014, `Invalid configuration of route '${fullPath}': children and loadChildren cannot be used together`);
+    }
+    if (route.component && route.loadComponent) {
+      throw new import_core.\u0275RuntimeError(4014, `Invalid configuration of route '${fullPath}': component and loadComponent cannot be used together`);
+    }
+    if (route.redirectTo) {
+      if (route.component || route.loadComponent) {
+        throw new import_core.\u0275RuntimeError(4014, `Invalid configuration of route '${fullPath}': redirectTo and component/loadComponent cannot be used together`);
+      }
+      if (route.canMatch || route.canActivate) {
+        throw new import_core.\u0275RuntimeError(4014, `Invalid configuration of route '${fullPath}': redirectTo and ${route.canMatch ? "canMatch" : "canActivate"} cannot be used together.Redirects happen before guards are executed.`);
+      }
+    }
+    if (route.path && route.matcher) {
+      throw new import_core.\u0275RuntimeError(4014, `Invalid configuration of route '${fullPath}': path and matcher cannot be used together`);
+    }
+    if (route.redirectTo === void 0 && !route.component && !route.loadComponent && !route.children && !route.loadChildren) {
+      throw new import_core.\u0275RuntimeError(4014, `Invalid configuration of route '${fullPath}'. One of the following must be provided: component, loadComponent, redirectTo, children or loadChildren`);
+    }
+    if (route.path === void 0 && route.matcher === void 0) {
+      throw new import_core.\u0275RuntimeError(4014, `Invalid configuration of route '${fullPath}': routes must have either a path or a matcher specified`);
+    }
+    if (typeof route.path === "string" && route.path.charAt(0) === "/") {
+      throw new import_core.\u0275RuntimeError(4014, `Invalid configuration of route '${fullPath}': path cannot start with a slash`);
+    }
+    if (route.path === "" && route.redirectTo !== void 0 && route.pathMatch === void 0) {
+      const exp = `The default value of 'pathMatch' is 'prefix', but often the intent is to use 'full'.`;
+      throw new import_core.\u0275RuntimeError(4014, `Invalid configuration of route '{path: "${fullPath}", redirectTo: "${route.redirectTo}"}': please provide 'pathMatch'. ${exp}`);
+    }
+    if (requireStandaloneComponents) {
+      assertStandalone(fullPath, route.component);
+    }
+  }
+  if (route.children) {
+    validateConfig(route.children, fullPath, requireStandaloneComponents);
+  }
+}
+function getFullPath(parentPath, currentRoute) {
+  if (!currentRoute) {
+    return parentPath;
+  }
+  if (!parentPath && !currentRoute.path) {
+    return "";
+  } else if (parentPath && !currentRoute.path) {
+    return `${parentPath}/`;
+  } else if (!parentPath && currentRoute.path) {
+    return currentRoute.path;
+  } else {
+    return `${parentPath}/${currentRoute.path}`;
+  }
+}
+function getOutlet(route) {
+  return route.outlet || PRIMARY_OUTLET;
+}
+function sortByMatchingOutlets(routes, outletName) {
+  const sortedConfig = routes.filter((r) => getOutlet(r) === outletName);
+  sortedConfig.push(...routes.filter((r) => getOutlet(r) !== outletName));
+  return sortedConfig;
+}
+function getClosestRouteInjector(snapshot) {
+  var _a2;
+  if (!snapshot)
+    return null;
+  if ((_a2 = snapshot.routeConfig) == null ? void 0 : _a2._injector) {
+    return snapshot.routeConfig._injector;
+  }
+  for (let s = snapshot.parent; s; s = s.parent) {
+    const route = s.routeConfig;
+    if (route == null ? void 0 : route._loadedInjector)
+      return route._loadedInjector;
+    if (route == null ? void 0 : route._injector)
+      return route._injector;
+  }
+  return null;
+}
+class OutletContext {
+  constructor(rootInjector) {
+    __publicField(this, "rootInjector");
+    __publicField(this, "outlet", null);
+    __publicField(this, "route", null);
+    __publicField(this, "children");
+    __publicField(this, "attachRef", null);
+    this.rootInjector = rootInjector;
+    this.children = new ChildrenOutletContexts(this.rootInjector);
+  }
+  get injector() {
+    var _a2, _b2;
+    return (_b2 = getClosestRouteInjector((_a2 = this.route) == null ? void 0 : _a2.snapshot)) != null ? _b2 : this.rootInjector;
+  }
+}
+const _ChildrenOutletContexts = class _ChildrenOutletContexts {
+  /** @docs-private */
+  constructor(rootInjector) {
+    __publicField(this, "rootInjector");
+    // contexts for child outlets, by name.
+    __publicField(this, "contexts", /* @__PURE__ */ new Map());
+    this.rootInjector = rootInjector;
+  }
+  /** Called when a `RouterOutlet` directive is instantiated */
+  onChildOutletCreated(childName, outlet) {
+    const context = this.getOrCreateContext(childName);
+    context.outlet = outlet;
+    this.contexts.set(childName, context);
+  }
+  /**
+   * Called when a `RouterOutlet` directive is destroyed.
+   * We need to keep the context as the outlet could be destroyed inside a NgIf and might be
+   * re-created later.
+   */
+  onChildOutletDestroyed(childName) {
+    const context = this.getContext(childName);
+    if (context) {
+      context.outlet = null;
+      context.attachRef = null;
+    }
+  }
+  /**
+   * Called when the corresponding route is deactivated during navigation.
+   * Because the component get destroyed, all children outlet are destroyed.
+   */
+  onOutletDeactivated() {
+    const contexts = this.contexts;
+    this.contexts = /* @__PURE__ */ new Map();
+    return contexts;
+  }
+  onOutletReAttached(contexts) {
+    this.contexts = contexts;
+  }
+  getOrCreateContext(childName) {
+    let context = this.getContext(childName);
+    if (!context) {
+      context = new OutletContext(this.rootInjector);
+      this.contexts.set(childName, context);
+    }
+    return context;
+  }
+  getContext(childName) {
+    return this.contexts.get(childName) || null;
+  }
+};
+__publicField(_ChildrenOutletContexts, "\u0275fac", i0.\u0275\u0275ngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _ChildrenOutletContexts, deps: [{ token: i0.EnvironmentInjector }], target: i0.\u0275\u0275FactoryTarget.Injectable }));
+__publicField(_ChildrenOutletContexts, "\u0275prov", i0.\u0275\u0275ngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _ChildrenOutletContexts, providedIn: "root" }));
+let ChildrenOutletContexts = _ChildrenOutletContexts;
+i0.\u0275\u0275ngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: ChildrenOutletContexts, decorators: [{
+  type: import_core.Injectable,
+  args: [{ providedIn: "root" }]
+}], ctorParameters: () => [{ type: i0.EnvironmentInjector }] });
+class Tree {
+  constructor(root) {
+    /** @internal */
+    __publicField(this, "_root");
+    this._root = root;
+  }
+  get root() {
+    return this._root.value;
+  }
+  /**
+   * @internal
+   */
+  parent(t) {
+    const p = this.pathFromRoot(t);
+    return p.length > 1 ? p[p.length - 2] : null;
+  }
+  /**
+   * @internal
+   */
+  children(t) {
+    const n = findNode(t, this._root);
+    return n ? n.children.map((t2) => t2.value) : [];
+  }
+  /**
+   * @internal
+   */
+  firstChild(t) {
+    const n = findNode(t, this._root);
+    return n && n.children.length > 0 ? n.children[0].value : null;
+  }
+  /**
+   * @internal
+   */
+  siblings(t) {
+    const p = findPath(t, this._root);
+    if (p.length < 2)
+      return [];
+    const c = p[p.length - 2].children.map((c2) => c2.value);
+    return c.filter((cc) => cc !== t);
+  }
+  /**
+   * @internal
+   */
+  pathFromRoot(t) {
+    return findPath(t, this._root).map((s) => s.value);
+  }
+}
+function findNode(value, node) {
+  if (value === node.value)
+    return node;
+  for (const child of node.children) {
+    const node2 = findNode(value, child);
+    if (node2)
+      return node2;
+  }
+  return null;
+}
+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 [];
+}
+class TreeNode {
+  constructor(value, children) {
+    __publicField(this, "value");
+    __publicField(this, "children");
+    this.value = value;
+    this.children = children;
+  }
+  toString() {
+    return `TreeNode(${this.value})`;
+  }
+}
+function nodeChildrenAsMap(node) {
+  const map2 = {};
+  if (node) {
+    node.children.forEach((child) => map2[child.value.outlet] = child);
+  }
+  return map2;
+}
+class RouterState extends Tree {
+  /** @internal */
+  constructor(root, snapshot) {
+    super(root);
+    __publicField(this, "snapshot");
+    this.snapshot = snapshot;
+    setRouterState(this, root);
+  }
+  toString() {
+    return this.snapshot.toString();
+  }
+}
+function createEmptyState(rootComponent) {
+  const snapshot = createEmptyStateSnapshot(rootComponent);
+  const emptyUrl = new import_rxjs.BehaviorSubject([new UrlSegment("", {})]);
+  const emptyParams = new import_rxjs.BehaviorSubject({});
+  const emptyData = new import_rxjs.BehaviorSubject({});
+  const emptyQueryParams = new import_rxjs.BehaviorSubject({});
+  const fragment = new import_rxjs.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(rootComponent) {
+  const emptyParams = {};
+  const emptyData = {};
+  const emptyQueryParams = {};
+  const fragment = "";
+  const activated = new ActivatedRouteSnapshot([], emptyParams, emptyQueryParams, fragment, emptyData, PRIMARY_OUTLET, rootComponent, null, {});
+  return new RouterStateSnapshot("", new TreeNode(activated, []));
+}
+class ActivatedRoute {
+  /** @internal */
+  constructor(urlSubject, paramsSubject, queryParamsSubject, fragmentSubject, dataSubject, outlet, component, futureSnapshot) {
+    __publicField(this, "urlSubject");
+    __publicField(this, "paramsSubject");
+    __publicField(this, "queryParamsSubject");
+    __publicField(this, "fragmentSubject");
+    __publicField(this, "dataSubject");
+    __publicField(this, "outlet");
+    __publicField(this, "component");
+    /** The current snapshot of this route */
+    __publicField(this, "snapshot");
+    /** @internal */
+    __publicField(this, "_futureSnapshot");
+    /** @internal */
+    __publicField(this, "_routerState");
+    /** @internal */
+    __publicField(this, "_paramMap");
+    /** @internal */
+    __publicField(this, "_queryParamMap");
+    /** An Observable of the resolved route title */
+    __publicField(this, "title");
+    /** An observable of the URL segments matched by this route. */
+    __publicField(this, "url");
+    /** An observable of the matrix parameters scoped to this route. */
+    __publicField(this, "params");
+    /** An observable of the query parameters shared by all the routes. */
+    __publicField(this, "queryParams");
+    /** An observable of the URL fragment shared by all the routes. */
+    __publicField(this, "fragment");
+    /** An observable of the static and resolved data of this route. */
+    __publicField(this, "data");
+    var _a2, _b2;
+    this.urlSubject = urlSubject;
+    this.paramsSubject = paramsSubject;
+    this.queryParamsSubject = queryParamsSubject;
+    this.fragmentSubject = fragmentSubject;
+    this.dataSubject = dataSubject;
+    this.outlet = outlet;
+    this.component = component;
+    this._futureSnapshot = futureSnapshot;
+    this.title = (_b2 = (_a2 = this.dataSubject) == null ? void 0 : _a2.pipe((0, import_operators.map)((d) => d[RouteTitleKey]))) != null ? _b2 : (0, import_rxjs.of)(void 0);
+    this.url = urlSubject;
+    this.params = paramsSubject;
+    this.queryParams = queryParamsSubject;
+    this.fragment = fragmentSubject;
+    this.data = dataSubject;
+  }
+  /** The configuration used to match this route. */
+  get routeConfig() {
+    return this._futureSnapshot.routeConfig;
+  }
+  /** The root of the router state. */
+  get root() {
+    return this._routerState.root;
+  }
+  /** 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() {
+    var _a2;
+    (_a2 = this._paramMap) != null ? _a2 : this._paramMap = this.params.pipe((0, import_operators.map)((p) => convertToParamMap(p)));
+    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() {
+    var _a2;
+    (_a2 = this._queryParamMap) != null ? _a2 : this._queryParamMap = this.queryParams.pipe((0, import_operators.map)((p) => convertToParamMap(p)));
+    return this._queryParamMap;
+  }
+  toString() {
+    return this.snapshot ? this.snapshot.toString() : `Future(${this._futureSnapshot})`;
+  }
+}
+function getInherited(route, parent, paramsInheritanceStrategy = "emptyOnly") {
+  var _a2, _b2;
+  let inherited;
+  const { routeConfig } = route;
+  if (parent !== null && (paramsInheritanceStrategy === "always" || // inherit parent data if route is empty path
+  (routeConfig == null ? void 0 : routeConfig.path) === "" || // inherit parent data if parent was componentless
+  !parent.component && !((_a2 = parent.routeConfig) == null ? void 0 : _a2.loadComponent))) {
+    inherited = {
+      params: __spreadValues(__spreadValues({}, parent.params), route.params),
+      data: __spreadValues(__spreadValues({}, parent.data), route.data),
+      resolve: __spreadValues(__spreadValues(__spreadValues(__spreadValues({}, route.data), parent.data), routeConfig == null ? void 0 : routeConfig.data), route._resolvedData)
+    };
+  } else {
+    inherited = {
+      params: __spreadValues({}, route.params),
+      data: __spreadValues({}, route.data),
+      resolve: __spreadValues(__spreadValues({}, route.data), (_b2 = route._resolvedData) != null ? _b2 : {})
+    };
+  }
+  if (routeConfig && hasStaticTitle(routeConfig)) {
+    inherited.resolve[RouteTitleKey] = routeConfig.title;
+  }
+  return inherited;
+}
+class ActivatedRouteSnapshot {
+  /** @internal */
+  constructor(url, params, queryParams, fragment, data, outlet, component, routeConfig, resolve) {
+    __publicField(this, "url");
+    __publicField(this, "params");
+    __publicField(this, "queryParams");
+    __publicField(this, "fragment");
+    __publicField(this, "data");
+    __publicField(this, "outlet");
+    __publicField(this, "component");
+    /** The configuration used to match this route **/
+    __publicField(this, "routeConfig");
+    /** @internal */
+    __publicField(this, "_resolve");
+    /** @internal */
+    __publicField(this, "_resolvedData");
+    /** @internal */
+    __publicField(this, "_routerState");
+    /** @internal */
+    __publicField(this, "_paramMap");
+    /** @internal */
+    __publicField(this, "_queryParamMap");
+    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._resolve = resolve;
+  }
+  /** The resolved route title */
+  get title() {
+    var _a2;
+    return (_a2 = this.data) == null ? void 0 : _a2[RouteTitleKey];
+  }
+  /** The root of the router state */
+  get root() {
+    return this._routerState.root;
+  }
+  /** 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);
+  }
+  get paramMap() {
+    var _a2;
+    (_a2 = this._paramMap) != null ? _a2 : this._paramMap = convertToParamMap(this.params);
+    return this._paramMap;
+  }
+  get queryParamMap() {
+    var _a2;
+    (_a2 = this._queryParamMap) != null ? _a2 : this._queryParamMap = convertToParamMap(this.queryParams);
+    return this._queryParamMap;
+  }
+  toString() {
+    const url = this.url.map((segment) => segment.toString()).join("/");
+    const matched = this.routeConfig ? this.routeConfig.path : "";
+    return `Route(url:'${url}', path:'${matched}')`;
+  }
+}
+class RouterStateSnapshot extends Tree {
+  /** @internal */
+  constructor(url, root) {
+    super(root);
+    __publicField(this, "url");
+    this.url = url;
+    setRouterState(this, root);
+  }
+  toString() {
+    return serializeNode(this._root);
+  }
+}
+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}`;
+}
+function advanceActivatedRoute(route) {
+  if (route.snapshot) {
+    const currentSnapshot = route.snapshot;
+    const nextSnapshot = route._futureSnapshot;
+    route.snapshot = nextSnapshot;
+    if (!shallowEqual(currentSnapshot.queryParams, nextSnapshot.queryParams)) {
+      route.queryParamsSubject.next(nextSnapshot.queryParams);
+    }
+    if (currentSnapshot.fragment !== nextSnapshot.fragment) {
+      route.fragmentSubject.next(nextSnapshot.fragment);
+    }
+    if (!shallowEqual(currentSnapshot.params, nextSnapshot.params)) {
+      route.paramsSubject.next(nextSnapshot.params);
+    }
+    if (!shallowEqualArrays(currentSnapshot.url, nextSnapshot.url)) {
+      route.urlSubject.next(nextSnapshot.url);
+    }
+    if (!shallowEqual(currentSnapshot.data, nextSnapshot.data)) {
+      route.dataSubject.next(nextSnapshot.data);
+    }
+  } else {
+    route.snapshot = route._futureSnapshot;
+    route.dataSubject.next(route._futureSnapshot.data);
+  }
+}
+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 hasStaticTitle(config) {
+  return typeof config.title === "string" || config.title === null;
+}
+const ROUTER_OUTLET_DATA = new import_core.InjectionToken(ngDevMode ? "RouterOutlet data" : "");
+const _RouterOutlet = class _RouterOutlet {
+  constructor() {
+    __publicField(this, "activated", null);
+    __publicField(this, "_activatedRoute", null);
+    /**
+     * The name of the outlet
+     *
+     */
+    __publicField(this, "name", PRIMARY_OUTLET);
+    __publicField(this, "activateEvents", new import_core.EventEmitter());
+    __publicField(this, "deactivateEvents", new import_core.EventEmitter());
+    /**
+     * Emits an attached component instance when the `RouteReuseStrategy` instructs to re-attach a
+     * previously detached subtree.
+     **/
+    __publicField(this, "attachEvents", new import_core.EventEmitter());
+    /**
+     * Emits a detached component instance when the `RouteReuseStrategy` instructs to detach the
+     * subtree.
+     */
+    __publicField(this, "detachEvents", new import_core.EventEmitter());
+    /**
+     * Data that will be provided to the child injector through the `ROUTER_OUTLET_DATA` token.
+     *
+     * When unset, the value of the token is `undefined` by default.
+     */
+    __publicField(this, "routerOutletData", (0, import_core.input)(...ngDevMode ? [void 0, { debugName: "routerOutletData" }] : []));
+    __publicField(this, "parentContexts", (0, import_core.inject)(ChildrenOutletContexts));
+    __publicField(this, "location", (0, import_core.inject)(import_core.ViewContainerRef));
+    __publicField(this, "changeDetector", (0, import_core.inject)(import_core.ChangeDetectorRef));
+    __publicField(this, "inputBinder", (0, import_core.inject)(INPUT_BINDER, { optional: true }));
+    /** @docs-private */
+    __publicField(this, "supportsBindingToComponentInputs", true);
+  }
+  /** @internal */
+  get activatedComponentRef() {
+    return this.activated;
+  }
+  /** @docs-private */
+  ngOnChanges(changes) {
+    if (changes["name"]) {
+      const { firstChange, previousValue } = changes["name"];
+      if (firstChange) {
+        return;
+      }
+      if (this.isTrackedInParentContexts(previousValue)) {
+        this.deactivate();
+        this.parentContexts.onChildOutletDestroyed(previousValue);
+      }
+      this.initializeOutletWithName();
+    }
+  }
+  /** @docs-private */
+  ngOnDestroy() {
+    var _a2;
+    if (this.isTrackedInParentContexts(this.name)) {
+      this.parentContexts.onChildOutletDestroyed(this.name);
+    }
+    (_a2 = this.inputBinder) == null ? void 0 : _a2.unsubscribeFromRouteData(this);
+  }
+  isTrackedInParentContexts(outletName) {
+    var _a2;
+    return ((_a2 = this.parentContexts.getContext(outletName)) == null ? void 0 : _a2.outlet) === this;
+  }
+  /** @docs-private */
+  ngOnInit() {
+    this.initializeOutletWithName();
+  }
+  initializeOutletWithName() {
+    this.parentContexts.onChildOutletCreated(this.name, this);
+    if (this.activated) {
+      return;
+    }
+    const context = this.parentContexts.getContext(this.name);
+    if (context == null ? void 0 : context.route) {
+      if (context.attachRef) {
+        this.attach(context.attachRef, context.route);
+      } else {
+        this.activateWith(context.route, context.injector);
+      }
+    }
+  }
+  get isActivated() {
+    return !!this.activated;
+  }
+  /**
+   * @returns The currently activated component instance.
+   * @throws An error if the outlet is not activated.
+   */
+  get component() {
+    if (!this.activated)
+      throw new import_core.\u0275RuntimeError(4012, (typeof ngDevMode === "undefined" || ngDevMode) && "Outlet is not activated");
+    return this.activated.instance;
+  }
+  get activatedRoute() {
+    if (!this.activated)
+      throw new import_core.\u0275RuntimeError(4012, (typeof ngDevMode === "undefined" || ngDevMode) && "Outlet is not activated");
+    return this._activatedRoute;
+  }
+  get activatedRouteData() {
+    if (this._activatedRoute) {
+      return this._activatedRoute.snapshot.data;
+    }
+    return {};
+  }
+  /**
+   * Called when the `RouteReuseStrategy` instructs to detach the subtree
+   */
+  detach() {
+    if (!this.activated)
+      throw new import_core.\u0275RuntimeError(4012, (typeof ngDevMode === "undefined" || ngDevMode) && "Outlet is not activated");
+    this.location.detach();
+    const cmp = this.activated;
+    this.activated = null;
+    this._activatedRoute = null;
+    this.detachEvents.emit(cmp.instance);
+    return cmp;
+  }
+  /**
+   * Called when the `RouteReuseStrategy` instructs to re-attach a previously detached subtree
+   */
+  attach(ref, activatedRoute) {
+    var _a2;
+    this.activated = ref;
+    this._activatedRoute = activatedRoute;
+    this.location.insert(ref.hostView);
+    (_a2 = this.inputBinder) == null ? void 0 : _a2.bindActivatedRouteToOutletComponent(this);
+    this.attachEvents.emit(ref.instance);
+  }
+  deactivate() {
+    if (this.activated) {
+      const c = this.component;
+      this.activated.destroy();
+      this.activated = null;
+      this._activatedRoute = null;
+      this.deactivateEvents.emit(c);
+    }
+  }
+  activateWith(activatedRoute, environmentInjector) {
+    var _a2;
+    if (this.isActivated) {
+      throw new import_core.\u0275RuntimeError(4013, (typeof ngDevMode === "undefined" || ngDevMode) && "Cannot activate an already activated outlet");
+    }
+    this._activatedRoute = activatedRoute;
+    const location = this.location;
+    const snapshot = activatedRoute.snapshot;
+    const component = snapshot.component;
+    const childContexts = this.parentContexts.getOrCreateContext(this.name).children;
+    const injector = new OutletInjector(activatedRoute, childContexts, location.injector, this.routerOutletData);
+    this.activated = location.createComponent(component, {
+      index: location.length,
+      injector,
+      environmentInjector
+    });
+    this.changeDetector.markForCheck();
+    (_a2 = this.inputBinder) == null ? void 0 : _a2.bindActivatedRouteToOutletComponent(this);
+    this.activateEvents.emit(this.activated.instance);
+  }
+};
+__publicField(_RouterOutlet, "\u0275fac", i0.\u0275\u0275ngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _RouterOutlet, deps: [], target: i0.\u0275\u0275FactoryTarget.Directive }));
+__publicField(_RouterOutlet, "\u0275dir", i0.\u0275\u0275ngDeclareDirective({ minVersion: "17.1.0", version: "20.3.16", type: _RouterOutlet, isStandalone: true, selector: "router-outlet", inputs: { name: { classPropertyName: "name", publicName: "name", isSignal: false, isRequired: false, transformFunction: null }, routerOutletData: { classPropertyName: "routerOutletData", publicName: "routerOutletData", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { activateEvents: "activate", deactivateEvents: "deactivate", attachEvents: "attach", detachEvents: "detach" }, exportAs: ["outlet"], usesOnChanges: true, ngImport: i0 }));
+let RouterOutlet = _RouterOutlet;
+i0.\u0275\u0275ngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: RouterOutlet, decorators: [{
+  type: import_core.Directive,
+  args: [{
+    selector: "router-outlet",
+    exportAs: "outlet"
+  }]
+}], propDecorators: { name: [{
+  type: import_core.Input
+}], activateEvents: [{
+  type: import_core.Output,
+  args: ["activate"]
+}], deactivateEvents: [{
+  type: import_core.Output,
+  args: ["deactivate"]
+}], attachEvents: [{
+  type: import_core.Output,
+  args: ["attach"]
+}], detachEvents: [{
+  type: import_core.Output,
+  args: ["detach"]
+}], routerOutletData: [{ type: i0.Input, args: [{ isSignal: true, alias: "routerOutletData", required: false }] }] } });
+class OutletInjector {
+  constructor(route, childContexts, parent, outletData) {
+    __publicField(this, "route");
+    __publicField(this, "childContexts");
+    __publicField(this, "parent");
+    __publicField(this, "outletData");
+    this.route = route;
+    this.childContexts = childContexts;
+    this.parent = parent;
+    this.outletData = outletData;
+  }
+  get(token, notFoundValue) {
+    if (token === ActivatedRoute) {
+      return this.route;
+    }
+    if (token === ChildrenOutletContexts) {
+      return this.childContexts;
+    }
+    if (token === ROUTER_OUTLET_DATA) {
+      return this.outletData;
+    }
+    return this.parent.get(token, notFoundValue);
+  }
+}
+const INPUT_BINDER = new import_core.InjectionToken("");
+const _RoutedComponentInputBinder = class _RoutedComponentInputBinder {
+  constructor() {
+    __publicField(this, "outletDataSubscriptions", /* @__PURE__ */ new Map());
+  }
+  bindActivatedRouteToOutletComponent(outlet) {
+    this.unsubscribeFromRouteData(outlet);
+    this.subscribeToRouteData(outlet);
+  }
+  unsubscribeFromRouteData(outlet) {
+    var _a2;
+    (_a2 = this.outletDataSubscriptions.get(outlet)) == null ? void 0 : _a2.unsubscribe();
+    this.outletDataSubscriptions.delete(outlet);
+  }
+  subscribeToRouteData(outlet) {
+    const { activatedRoute } = outlet;
+    const dataSubscription = (0, import_rxjs.combineLatest)([
+      activatedRoute.queryParams,
+      activatedRoute.params,
+      activatedRoute.data
+    ]).pipe((0, import_operators.switchMap)(([queryParams, params, data], index) => {
+      data = __spreadValues(__spreadValues(__spreadValues({}, queryParams), params), data);
+      if (index === 0) {
+        return (0, import_rxjs.of)(data);
+      }
+      return Promise.resolve(data);
+    })).subscribe((data) => {
+      if (!outlet.isActivated || !outlet.activatedComponentRef || outlet.activatedRoute !== activatedRoute || activatedRoute.component === null) {
+        this.unsubscribeFromRouteData(outlet);
+        return;
+      }
+      const mirror = (0, import_core.reflectComponentType)(activatedRoute.component);
+      if (!mirror) {
+        this.unsubscribeFromRouteData(outlet);
+        return;
+      }
+      for (const { templateName } of mirror.inputs) {
+        outlet.activatedComponentRef.setInput(templateName, data[templateName]);
+      }
+    });
+    this.outletDataSubscriptions.set(outlet, dataSubscription);
+  }
+};
+__publicField(_RoutedComponentInputBinder, "\u0275fac", i0.\u0275\u0275ngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _RoutedComponentInputBinder, deps: [], target: i0.\u0275\u0275FactoryTarget.Injectable }));
+__publicField(_RoutedComponentInputBinder, "\u0275prov", i0.\u0275\u0275ngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _RoutedComponentInputBinder }));
+let RoutedComponentInputBinder = _RoutedComponentInputBinder;
+i0.\u0275\u0275ngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: RoutedComponentInputBinder, decorators: [{
+  type: import_core.Injectable
+}] });
+const _\u0275EmptyOutletComponent = class _\u0275EmptyOutletComponent {
+};
+__publicField(_\u0275EmptyOutletComponent, "\u0275fac", i0.\u0275\u0275ngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _\u0275EmptyOutletComponent, deps: [], target: i0.\u0275\u0275FactoryTarget.Component }));
+__publicField(_\u0275EmptyOutletComponent, "\u0275cmp", i0.\u0275\u0275ngDeclareComponent({ minVersion: "14.0.0", version: "20.3.16", type: _\u0275EmptyOutletComponent, isStandalone: true, selector: "ng-component", exportAs: ["emptyRouterOutlet"], ngImport: i0, template: `<router-outlet/>`, isInline: true, dependencies: [{ kind: "directive", type: RouterOutlet, selector: "router-outlet", inputs: ["name", "routerOutletData"], outputs: ["activate", "deactivate", "attach", "detach"], exportAs: ["outlet"] }] }));
+let \u0275EmptyOutletComponent = _\u0275EmptyOutletComponent;
+i0.\u0275\u0275ngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: \u0275EmptyOutletComponent, decorators: [{
+  type: import_core.Component,
+  args: [{
+    template: `<router-outlet/>`,
+    imports: [RouterOutlet],
+    // Used to avoid component ID collisions with user code.
+    exportAs: "emptyRouterOutlet"
+  }]
+}] });
+function standardizeConfig(r) {
+  const children = r.children && r.children.map(standardizeConfig);
+  const c = children ? __spreadProps(__spreadValues({}, r), { children }) : __spreadValues({}, r);
+  if (!c.component && !c.loadComponent && (children || c.loadChildren) && c.outlet && c.outlet !== PRIMARY_OUTLET) {
+    c.component = \u0275EmptyOutletComponent;
+  }
+  return c;
+}
+function createRouterState(routeReuseStrategy, curr, prevState) {
+  const root = createNode(routeReuseStrategy, curr._root, prevState ? prevState._root : void 0);
+  return new RouterState(root, curr);
+}
+function createNode(routeReuseStrategy, curr, prevState) {
+  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)) {
+      const detachedRouteHandle = routeReuseStrategy.retrieve(curr.value);
+      if (detachedRouteHandle !== null) {
+        const tree2 = detachedRouteHandle.route;
+        tree2.value._futureSnapshot = curr.value;
+        tree2.children = curr.children.map((c) => createNode(routeReuseStrategy, c));
+        return tree2;
+      }
+    }
+    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 import_rxjs.BehaviorSubject(c.url), new import_rxjs.BehaviorSubject(c.params), new import_rxjs.BehaviorSubject(c.queryParams), new import_rxjs.BehaviorSubject(c.fragment), new import_rxjs.BehaviorSubject(c.data), c.outlet, c.component, c);
+}
+class RedirectCommand {
+  constructor(redirectTo, navigationBehaviorOptions) {
+    __publicField(this, "redirectTo");
+    __publicField(this, "navigationBehaviorOptions");
+    this.redirectTo = redirectTo;
+    this.navigationBehaviorOptions = navigationBehaviorOptions;
+  }
+}
+const NAVIGATION_CANCELING_ERROR = "ngNavigationCancelingError";
+function redirectingNavigationError(urlSerializer, redirect) {
+  const { redirectTo, navigationBehaviorOptions } = isUrlTree(redirect) ? { redirectTo: redirect, navigationBehaviorOptions: void 0 } : redirect;
+  const error = navigationCancelingError(ngDevMode && `Redirecting to "${urlSerializer.serialize(redirectTo)}"`, NavigationCancellationCode.Redirect);
+  error.url = redirectTo;
+  error.navigationBehaviorOptions = navigationBehaviorOptions;
+  return error;
+}
+function navigationCancelingError(message, code) {
+  const error = new Error(`NavigationCancelingError: ${message || ""}`);
+  error[NAVIGATION_CANCELING_ERROR] = true;
+  error.cancellationCode = code;
+  return error;
+}
+function isRedirectingNavigationCancelingError(error) {
+  return isNavigationCancelingError(error) && isUrlTree(error.url);
+}
+function isNavigationCancelingError(error) {
+  return !!error && error[NAVIGATION_CANCELING_ERROR];
+}
+let warnedAboutUnsupportedInputBinding = false;
+const activateRoutes = (rootContexts, routeReuseStrategy, forwardEvent, inputBindingEnabled) => (0, import_operators.map)((t) => {
+  new ActivateRoutes(routeReuseStrategy, t.targetRouterState, t.currentRouterState, forwardEvent, inputBindingEnabled).activate(rootContexts);
+  return t;
+});
+class ActivateRoutes {
+  constructor(routeReuseStrategy, futureState, currState, forwardEvent, inputBindingEnabled) {
+    __publicField(this, "routeReuseStrategy");
+    __publicField(this, "futureState");
+    __publicField(this, "currState");
+    __publicField(this, "forwardEvent");
+    __publicField(this, "inputBindingEnabled");
+    this.routeReuseStrategy = routeReuseStrategy;
+    this.futureState = futureState;
+    this.currState = currState;
+    this.forwardEvent = forwardEvent;
+    this.inputBindingEnabled = inputBindingEnabled;
+  }
+  activate(parentContexts) {
+    const futureRoot = this.futureState._root;
+    const currRoot = this.currState ? this.currState._root : null;
+    this.deactivateChildRoutes(futureRoot, currRoot, parentContexts);
+    advanceActivatedRoute(this.futureState.root);
+    this.activateChildRoutes(futureRoot, currRoot, parentContexts);
+  }
+  // De-activate the child route that are not re-used for the future state
+  deactivateChildRoutes(futureNode, currNode, contexts) {
+    const children = nodeChildrenAsMap(currNode);
+    futureNode.children.forEach((futureChild) => {
+      const childOutletName = futureChild.value.outlet;
+      this.deactivateRoutes(futureChild, children[childOutletName], contexts);
+      delete children[childOutletName];
+    });
+    Object.values(children).forEach((v) => {
+      this.deactivateRouteAndItsChildren(v, contexts);
+    });
+  }
+  deactivateRoutes(futureNode, currNode, parentContext) {
+    const future = futureNode.value;
+    const curr = currNode ? currNode.value : null;
+    if (future === curr) {
+      if (future.component) {
+        const context = parentContext.getContext(future.outlet);
+        if (context) {
+          this.deactivateChildRoutes(futureNode, currNode, context.children);
+        }
+      } else {
+        this.deactivateChildRoutes(futureNode, currNode, parentContext);
+      }
+    } else {
+      if (curr) {
+        this.deactivateRouteAndItsChildren(currNode, parentContext);
+      }
+    }
+  }
+  deactivateRouteAndItsChildren(route, parentContexts) {
+    if (route.value.component && this.routeReuseStrategy.shouldDetach(route.value.snapshot)) {
+      this.detachAndStoreRouteSubtree(route, parentContexts);
+    } else {
+      this.deactivateRouteAndOutlet(route, parentContexts);
+    }
+  }
+  detachAndStoreRouteSubtree(route, parentContexts) {
+    const context = parentContexts.getContext(route.value.outlet);
+    const contexts = context && route.value.component ? context.children : parentContexts;
+    const children = nodeChildrenAsMap(route);
+    for (const treeNode of Object.values(children)) {
+      this.deactivateRouteAndItsChildren(treeNode, contexts);
+    }
+    if (context && context.outlet) {
+      const componentRef = context.outlet.detach();
+      const contexts2 = context.children.onOutletDeactivated();
+      this.routeReuseStrategy.store(route.value.snapshot, { componentRef, route, contexts: contexts2 });
+    }
+  }
+  deactivateRouteAndOutlet(route, parentContexts) {
+    const context = parentContexts.getContext(route.value.outlet);
+    const contexts = context && route.value.component ? context.children : parentContexts;
+    const children = nodeChildrenAsMap(route);
+    for (const treeNode of Object.values(children)) {
+      this.deactivateRouteAndItsChildren(treeNode, contexts);
+    }
+    if (context) {
+      if (context.outlet) {
+        context.outlet.deactivate();
+        context.children.onOutletDeactivated();
+      }
+      context.attachRef = null;
+      context.route = null;
+    }
+  }
+  activateChildRoutes(futureNode, currNode, contexts) {
+    const children = nodeChildrenAsMap(currNode);
+    futureNode.children.forEach((c) => {
+      this.activateRoutes(c, children[c.value.outlet], contexts);
+      this.forwardEvent(new ActivationEnd(c.value.snapshot));
+    });
+    if (futureNode.children.length) {
+      this.forwardEvent(new ChildActivationEnd(futureNode.value.snapshot));
+    }
+  }
+  activateRoutes(futureNode, currNode, parentContexts) {
+    const future = futureNode.value;
+    const curr = currNode ? currNode.value : null;
+    advanceActivatedRoute(future);
+    if (future === curr) {
+      if (future.component) {
+        const context = parentContexts.getOrCreateContext(future.outlet);
+        this.activateChildRoutes(futureNode, currNode, context.children);
+      } else {
+        this.activateChildRoutes(futureNode, currNode, parentContexts);
+      }
+    } else {
+      if (future.component) {
+        const context = parentContexts.getOrCreateContext(future.outlet);
+        if (this.routeReuseStrategy.shouldAttach(future.snapshot)) {
+          const stored = this.routeReuseStrategy.retrieve(future.snapshot);
+          this.routeReuseStrategy.store(future.snapshot, null);
+          context.children.onOutletReAttached(stored.contexts);
+          context.attachRef = stored.componentRef;
+          context.route = stored.route.value;
+          if (context.outlet) {
+            context.outlet.attach(stored.componentRef, stored.route.value);
+          }
+          advanceActivatedRoute(stored.route.value);
+          this.activateChildRoutes(futureNode, null, context.children);
+        } else {
+          context.attachRef = null;
+          context.route = future;
+          if (context.outlet) {
+            context.outlet.activateWith(future, context.injector);
+          }
+          this.activateChildRoutes(futureNode, null, context.children);
+        }
+      } else {
+        this.activateChildRoutes(futureNode, null, parentContexts);
+      }
+    }
+    if (typeof ngDevMode === "undefined" || ngDevMode) {
+      const context = parentContexts.getOrCreateContext(future.outlet);
+      const outlet = context.outlet;
+      if (outlet && this.inputBindingEnabled && !outlet.supportsBindingToComponentInputs && !warnedAboutUnsupportedInputBinding) {
+        console.warn(`'withComponentInputBinding' feature is enabled but this application is using an outlet that may not support binding to component inputs.`);
+        warnedAboutUnsupportedInputBinding = true;
+      }
+    }
+  }
+}
+class CanActivate {
+  constructor(path) {
+    __publicField(this, "path");
+    __publicField(this, "route");
+    this.path = path;
+    this.route = this.path[this.path.length - 1];
+  }
+}
+class CanDeactivate {
+  constructor(component, route) {
+    __publicField(this, "component");
+    __publicField(this, "route");
+    this.component = component;
+    this.route = route;
+  }
+}
+function getAllRouteGuards(future, curr, parentContexts) {
+  const futureRoot = future._root;
+  const currRoot = curr ? curr._root : null;
+  return getChildRouteGuards(futureRoot, currRoot, parentContexts, [futureRoot.value]);
+}
+function getCanActivateChild(p) {
+  const canActivateChild = p.routeConfig ? p.routeConfig.canActivateChild : null;
+  if (!canActivateChild || canActivateChild.length === 0)
+    return null;
+  return { node: p, guards: canActivateChild };
+}
+function getTokenOrFunctionIdentity(tokenOrFunction, injector) {
+  const NOT_FOUND = /* @__PURE__ */ Symbol();
+  const result = injector.get(tokenOrFunction, NOT_FOUND);
+  if (result === NOT_FOUND) {
+    if (typeof tokenOrFunction === "function" && !(0, import_core.\u0275isInjectable)(tokenOrFunction)) {
+      return tokenOrFunction;
+    } else {
+      return injector.get(tokenOrFunction);
+    }
+  }
+  return result;
+}
+function getChildRouteGuards(futureNode, currNode, contexts, futurePath, checks = {
+  canDeactivateChecks: [],
+  canActivateChecks: []
+}) {
+  const prevChildren = nodeChildrenAsMap(currNode);
+  futureNode.children.forEach((c) => {
+    getRouteGuards(c, prevChildren[c.value.outlet], contexts, futurePath.concat([c.value]), checks);
+    delete prevChildren[c.value.outlet];
+  });
+  Object.entries(prevChildren).forEach(([k, v]) => deactivateRouteAndItsChildren(v, contexts.getContext(k), checks));
+  return checks;
+}
+function getRouteGuards(futureNode, currNode, parentContexts, futurePath, checks = {
+  canDeactivateChecks: [],
+  canActivateChecks: []
+}) {
+  const future = futureNode.value;
+  const curr = currNode ? currNode.value : null;
+  const context = parentContexts ? parentContexts.getContext(futureNode.value.outlet) : null;
+  if (curr && future.routeConfig === curr.routeConfig) {
+    const shouldRun = shouldRunGuardsAndResolvers(curr, future, future.routeConfig.runGuardsAndResolvers);
+    if (shouldRun) {
+      checks.canActivateChecks.push(new CanActivate(futurePath));
+    } else {
+      future.data = curr.data;
+      future._resolvedData = curr._resolvedData;
+    }
+    if (future.component) {
+      getChildRouteGuards(futureNode, currNode, context ? context.children : null, futurePath, checks);
+    } else {
+      getChildRouteGuards(futureNode, currNode, parentContexts, futurePath, checks);
+    }
+    if (shouldRun && context && context.outlet && context.outlet.isActivated) {
+      checks.canDeactivateChecks.push(new CanDeactivate(context.outlet.component, curr));
+    }
+  } else {
+    if (curr) {
+      deactivateRouteAndItsChildren(currNode, context, checks);
+    }
+    checks.canActivateChecks.push(new CanActivate(futurePath));
+    if (future.component) {
+      getChildRouteGuards(futureNode, null, context ? context.children : null, futurePath, checks);
+    } else {
+      getChildRouteGuards(futureNode, null, parentContexts, futurePath, checks);
+    }
+  }
+  return checks;
+}
+function shouldRunGuardsAndResolvers(curr, future, mode) {
+  if (typeof mode === "function") {
+    return mode(curr, future);
+  }
+  switch (mode) {
+    case "pathParamsChange":
+      return !equalPath(curr.url, future.url);
+    case "pathParamsOrQueryParamsChange":
+      return !equalPath(curr.url, future.url) || !shallowEqual(curr.queryParams, future.queryParams);
+    case "always":
+      return true;
+    case "paramsOrQueryParamsChange":
+      return !equalParamsAndUrlSegments(curr, future) || !shallowEqual(curr.queryParams, future.queryParams);
+    case "paramsChange":
+    default:
+      return !equalParamsAndUrlSegments(curr, future);
+  }
+}
+function deactivateRouteAndItsChildren(route, context, checks) {
+  const children = nodeChildrenAsMap(route);
+  const r = route.value;
+  Object.entries(children).forEach(([childName, node]) => {
+    if (!r.component) {
+      deactivateRouteAndItsChildren(node, context, checks);
+    } else if (context) {
+      deactivateRouteAndItsChildren(node, context.children.getContext(childName), checks);
+    } else {
+      deactivateRouteAndItsChildren(node, null, checks);
+    }
+  });
+  if (!r.component) {
+    checks.canDeactivateChecks.push(new CanDeactivate(null, r));
+  } else if (context && context.outlet && context.outlet.isActivated) {
+    checks.canDeactivateChecks.push(new CanDeactivate(context.outlet.component, r));
+  } else {
+    checks.canDeactivateChecks.push(new CanDeactivate(null, r));
+  }
+}
+function isFunction(v) {
+  return typeof v === "function";
+}
+function isBoolean(v) {
+  return typeof v === "boolean";
+}
+function isCanLoad(guard) {
+  return guard && isFunction(guard.canLoad);
+}
+function isCanActivate(guard) {
+  return guard && isFunction(guard.canActivate);
+}
+function isCanActivateChild(guard) {
+  return guard && isFunction(guard.canActivateChild);
+}
+function isCanDeactivate(guard) {
+  return guard && isFunction(guard.canDeactivate);
+}
+function isCanMatch(guard) {
+  return guard && isFunction(guard.canMatch);
+}
+function isEmptyError(e) {
+  return e instanceof import_rxjs.EmptyError || (e == null ? void 0 : e.name) === "EmptyError";
+}
+const INITIAL_VALUE = /* @__PURE__ */ Symbol("INITIAL_VALUE");
+function prioritizedGuardValue() {
+  return (0, import_operators.switchMap)((obs) => {
+    return (0, import_rxjs.combineLatest)(obs.map((o) => o.pipe((0, import_operators.take)(1), (0, import_operators.startWith)(INITIAL_VALUE)))).pipe((0, import_operators.map)((results) => {
+      for (const result of results) {
+        if (result === true) {
+          continue;
+        } else if (result === INITIAL_VALUE) {
+          return INITIAL_VALUE;
+        } else if (result === false || isRedirect(result)) {
+          return result;
+        }
+      }
+      return true;
+    }), (0, import_operators.filter)((item) => item !== INITIAL_VALUE), (0, import_operators.take)(1));
+  });
+}
+function isRedirect(val) {
+  return isUrlTree(val) || val instanceof RedirectCommand;
+}
+function checkGuards(injector, forwardEvent) {
+  return (0, import_operators.mergeMap)((t) => {
+    const { targetSnapshot, currentSnapshot, guards: { canActivateChecks, canDeactivateChecks } } = t;
+    if (canDeactivateChecks.length === 0 && canActivateChecks.length === 0) {
+      return (0, import_rxjs.of)(__spreadProps(__spreadValues({}, t), { guardsResult: true }));
+    }
+    return runCanDeactivateChecks(canDeactivateChecks, targetSnapshot, currentSnapshot, injector).pipe((0, import_operators.mergeMap)((canDeactivate) => {
+      return canDeactivate && isBoolean(canDeactivate) ? runCanActivateChecks(targetSnapshot, canActivateChecks, injector, forwardEvent) : (0, import_rxjs.of)(canDeactivate);
+    }), (0, import_operators.map)((guardsResult) => __spreadProps(__spreadValues({}, t), { guardsResult })));
+  });
+}
+function runCanDeactivateChecks(checks, futureRSS, currRSS, injector) {
+  return (0, import_rxjs.from)(checks).pipe((0, import_operators.mergeMap)((check) => runCanDeactivate(check.component, check.route, currRSS, futureRSS, injector)), (0, import_operators.first)((result) => {
+    return result !== true;
+  }, true));
+}
+function runCanActivateChecks(futureSnapshot, checks, injector, forwardEvent) {
+  return (0, import_rxjs.from)(checks).pipe((0, import_operators.concatMap)((check) => {
+    return (0, import_rxjs.concat)(fireChildActivationStart(check.route.parent, forwardEvent), fireActivationStart(check.route, forwardEvent), runCanActivateChild(futureSnapshot, check.path, injector), runCanActivate(futureSnapshot, check.route, injector));
+  }), (0, import_operators.first)((result) => {
+    return result !== true;
+  }, true));
+}
+function fireActivationStart(snapshot, forwardEvent) {
+  if (snapshot !== null && forwardEvent) {
+    forwardEvent(new ActivationStart(snapshot));
+  }
+  return (0, import_rxjs.of)(true);
+}
+function fireChildActivationStart(snapshot, forwardEvent) {
+  if (snapshot !== null && forwardEvent) {
+    forwardEvent(new ChildActivationStart(snapshot));
+  }
+  return (0, import_rxjs.of)(true);
+}
+function runCanActivate(futureRSS, futureARS, injector) {
+  const canActivate = futureARS.routeConfig ? futureARS.routeConfig.canActivate : null;
+  if (!canActivate || canActivate.length === 0)
+    return (0, import_rxjs.of)(true);
+  const canActivateObservables = canActivate.map((canActivate2) => {
+    return (0, import_rxjs.defer)(() => {
+      var _a2;
+      const closestInjector = (_a2 = getClosestRouteInjector(futureARS)) != null ? _a2 : injector;
+      const guard = getTokenOrFunctionIdentity(canActivate2, closestInjector);
+      const guardVal = isCanActivate(guard) ? guard.canActivate(futureARS, futureRSS) : (0, import_core.runInInjectionContext)(closestInjector, () => guard(futureARS, futureRSS));
+      return wrapIntoObservable(guardVal).pipe((0, import_operators.first)());
+    });
+  });
+  return (0, import_rxjs.of)(canActivateObservables).pipe(prioritizedGuardValue());
+}
+function runCanActivateChild(futureRSS, path, injector) {
+  const futureARS = path[path.length - 1];
+  const canActivateChildGuards = path.slice(0, path.length - 1).reverse().map((p) => getCanActivateChild(p)).filter((_) => _ !== null);
+  const canActivateChildGuardsMapped = canActivateChildGuards.map((d) => {
+    return (0, import_rxjs.defer)(() => {
+      const guardsMapped = d.guards.map((canActivateChild) => {
+        var _a2;
+        const closestInjector = (_a2 = getClosestRouteInjector(d.node)) != null ? _a2 : injector;
+        const guard = getTokenOrFunctionIdentity(canActivateChild, closestInjector);
+        const guardVal = isCanActivateChild(guard) ? guard.canActivateChild(futureARS, futureRSS) : (0, import_core.runInInjectionContext)(closestInjector, () => guard(futureARS, futureRSS));
+        return wrapIntoObservable(guardVal).pipe((0, import_operators.first)());
+      });
+      return (0, import_rxjs.of)(guardsMapped).pipe(prioritizedGuardValue());
+    });
+  });
+  return (0, import_rxjs.of)(canActivateChildGuardsMapped).pipe(prioritizedGuardValue());
+}
+function runCanDeactivate(component, currARS, currRSS, futureRSS, injector) {
+  const canDeactivate = currARS && currARS.routeConfig ? currARS.routeConfig.canDeactivate : null;
+  if (!canDeactivate || canDeactivate.length === 0)
+    return (0, import_rxjs.of)(true);
+  const canDeactivateObservables = canDeactivate.map((c) => {
+    var _a2;
+    const closestInjector = (_a2 = getClosestRouteInjector(currARS)) != null ? _a2 : injector;
+    const guard = getTokenOrFunctionIdentity(c, closestInjector);
+    const guardVal = isCanDeactivate(guard) ? guard.canDeactivate(component, currARS, currRSS, futureRSS) : (0, import_core.runInInjectionContext)(closestInjector, () => guard(component, currARS, currRSS, futureRSS));
+    return wrapIntoObservable(guardVal).pipe((0, import_operators.first)());
+  });
+  return (0, import_rxjs.of)(canDeactivateObservables).pipe(prioritizedGuardValue());
+}
+function runCanLoadGuards(injector, route, segments, urlSerializer) {
+  const canLoad = route.canLoad;
+  if (canLoad === void 0 || canLoad.length === 0) {
+    return (0, import_rxjs.of)(true);
+  }
+  const canLoadObservables = canLoad.map((injectionToken) => {
+    const guard = getTokenOrFunctionIdentity(injectionToken, injector);
+    const guardVal = isCanLoad(guard) ? guard.canLoad(route, segments) : (0, import_core.runInInjectionContext)(injector, () => guard(route, segments));
+    return wrapIntoObservable(guardVal);
+  });
+  return (0, import_rxjs.of)(canLoadObservables).pipe(prioritizedGuardValue(), redirectIfUrlTree(urlSerializer));
+}
+function redirectIfUrlTree(urlSerializer) {
+  return (0, import_rxjs.pipe)((0, import_operators.tap)((result) => {
+    if (typeof result === "boolean")
+      return;
+    throw redirectingNavigationError(urlSerializer, result);
+  }), (0, import_operators.map)((result) => result === true));
+}
+function runCanMatchGuards(injector, route, segments, urlSerializer) {
+  const canMatch = route.canMatch;
+  if (!canMatch || canMatch.length === 0)
+    return (0, import_rxjs.of)(true);
+  const canMatchObservables = canMatch.map((injectionToken) => {
+    const guard = getTokenOrFunctionIdentity(injectionToken, injector);
+    const guardVal = isCanMatch(guard) ? guard.canMatch(route, segments) : (0, import_core.runInInjectionContext)(injector, () => guard(route, segments));
+    return wrapIntoObservable(guardVal);
+  });
+  return (0, import_rxjs.of)(canMatchObservables).pipe(prioritizedGuardValue(), redirectIfUrlTree(urlSerializer));
+}
+class NoMatch {
+  constructor(segmentGroup) {
+    __publicField(this, "segmentGroup");
+    this.segmentGroup = segmentGroup || null;
+  }
+}
+class AbsoluteRedirect extends Error {
+  constructor(urlTree) {
+    super();
+    __publicField(this, "urlTree");
+    this.urlTree = urlTree;
+  }
+}
+function noMatch$1(segmentGroup) {
+  return (0, import_rxjs.throwError)(new NoMatch(segmentGroup));
+}
+function namedOutletsRedirect(redirectTo) {
+  return (0, import_rxjs.throwError)(new import_core.\u0275RuntimeError(4e3, (typeof ngDevMode === "undefined" || ngDevMode) && `Only absolute redirects can have named outlets. redirectTo: '${redirectTo}'`));
+}
+function canLoadFails(route) {
+  return (0, import_rxjs.throwError)(navigationCancelingError((typeof ngDevMode === "undefined" || ngDevMode) && `Cannot load children because the guard of the route "path: '${route.path}'" returned false`, NavigationCancellationCode.GuardRejected));
+}
+class ApplyRedirects {
+  constructor(urlSerializer, urlTree) {
+    __publicField(this, "urlSerializer");
+    __publicField(this, "urlTree");
+    this.urlSerializer = urlSerializer;
+    this.urlTree = urlTree;
+  }
+  lineralizeSegments(route, urlTree) {
+    let res = [];
+    let c = urlTree.root;
+    while (true) {
+      res = res.concat(c.segments);
+      if (c.numberOfChildren === 0) {
+        return (0, import_rxjs.of)(res);
+      }
+      if (c.numberOfChildren > 1 || !c.children[PRIMARY_OUTLET]) {
+        return namedOutletsRedirect(`${route.redirectTo}`);
+      }
+      c = c.children[PRIMARY_OUTLET];
+    }
+  }
+  applyRedirectCommands(segments, redirectTo, posParams, currentSnapshot, injector) {
+    return getRedirectResult(redirectTo, currentSnapshot, injector).pipe((0, import_operators.map)((redirect) => {
+      if (redirect instanceof UrlTree) {
+        throw new AbsoluteRedirect(redirect);
+      }
+      const newTree = this.applyRedirectCreateUrlTree(redirect, this.urlSerializer.parse(redirect), segments, posParams);
+      if (redirect[0] === "/") {
+        throw new AbsoluteRedirect(newTree);
+      }
+      return newTree;
+    }));
+  }
+  applyRedirectCreateUrlTree(redirectTo, urlTree, segments, posParams) {
+    const newRoot = this.createSegmentGroup(redirectTo, urlTree.root, segments, posParams);
+    return new UrlTree(newRoot, this.createQueryParams(urlTree.queryParams, this.urlTree.queryParams), urlTree.fragment);
+  }
+  createQueryParams(redirectToParams, actualParams) {
+    const res = {};
+    Object.entries(redirectToParams).forEach(([k, v]) => {
+      const copySourceValue = typeof v === "string" && v[0] === ":";
+      if (copySourceValue) {
+        const sourceName = v.substring(1);
+        res[k] = actualParams[sourceName];
+      } else {
+        res[k] = v;
+      }
+    });
+    return res;
+  }
+  createSegmentGroup(redirectTo, group, segments, posParams) {
+    const updatedSegments = this.createSegments(redirectTo, group.segments, segments, posParams);
+    let children = {};
+    Object.entries(group.children).forEach(([name, child]) => {
+      children[name] = this.createSegmentGroup(redirectTo, child, segments, posParams);
+    });
+    return new UrlSegmentGroup(updatedSegments, children);
+  }
+  createSegments(redirectTo, redirectToSegments, actualSegments, posParams) {
+    return redirectToSegments.map((s) => s.path[0] === ":" ? this.findPosParam(redirectTo, s, posParams) : this.findOrReturn(s, actualSegments));
+  }
+  findPosParam(redirectTo, redirectToUrlSegment, posParams) {
+    const pos = posParams[redirectToUrlSegment.path.substring(1)];
+    if (!pos)
+      throw new import_core.\u0275RuntimeError(4001, (typeof ngDevMode === "undefined" || ngDevMode) && `Cannot redirect to '${redirectTo}'. Cannot find '${redirectToUrlSegment.path}'.`);
+    return pos;
+  }
+  findOrReturn(redirectToUrlSegment, actualSegments) {
+    let idx = 0;
+    for (const s of actualSegments) {
+      if (s.path === redirectToUrlSegment.path) {
+        actualSegments.splice(idx);
+        return s;
+      }
+      idx++;
+    }
+    return redirectToUrlSegment;
+  }
+}
+function getRedirectResult(redirectTo, currentSnapshot, injector) {
+  if (typeof redirectTo === "string") {
+    return (0, import_rxjs.of)(redirectTo);
+  }
+  const redirectToFn = redirectTo;
+  const { queryParams, fragment, routeConfig, url, outlet, params, data, title } = currentSnapshot;
+  return wrapIntoObservable((0, import_core.runInInjectionContext)(injector, () => redirectToFn({ params, data, queryParams, fragment, routeConfig, url, outlet, title })));
+}
+const noMatch = {
+  matched: false,
+  consumedSegments: [],
+  remainingSegments: [],
+  parameters: {},
+  positionalParamSegments: {}
+};
+function matchWithChecks(segmentGroup, route, segments, injector, urlSerializer) {
+  const result = match(segmentGroup, route, segments);
+  if (!result.matched) {
+    return (0, import_rxjs.of)(result);
+  }
+  injector = getOrCreateRouteInjectorIfNeeded(route, injector);
+  return runCanMatchGuards(injector, route, segments, urlSerializer).pipe((0, import_operators.map)((v) => v === true ? result : __spreadValues({}, noMatch)));
+}
+function match(segmentGroup, route, segments) {
+  var _a2, _b2;
+  if (route.path === "**") {
+    return createWildcardMatchResult(segments);
+  }
+  if (route.path === "") {
+    if (route.pathMatch === "full" && (segmentGroup.hasChildren() || segments.length > 0)) {
+      return __spreadValues({}, noMatch);
+    }
+    return {
+      matched: true,
+      consumedSegments: [],
+      remainingSegments: segments,
+      parameters: {},
+      positionalParamSegments: {}
+    };
+  }
+  const matcher = route.matcher || defaultUrlMatcher;
+  const res = matcher(segments, segmentGroup, route);
+  if (!res)
+    return __spreadValues({}, noMatch);
+  const posParams = {};
+  Object.entries((_a2 = res.posParams) != null ? _a2 : {}).forEach(([k, v]) => {
+    posParams[k] = v.path;
+  });
+  const parameters = res.consumed.length > 0 ? __spreadValues(__spreadValues({}, posParams), res.consumed[res.consumed.length - 1].parameters) : posParams;
+  return {
+    matched: true,
+    consumedSegments: res.consumed,
+    remainingSegments: segments.slice(res.consumed.length),
+    // TODO(atscott): investigate combining parameters and positionalParamSegments
+    parameters,
+    positionalParamSegments: (_b2 = res.posParams) != null ? _b2 : {}
+  };
+}
+function createWildcardMatchResult(segments) {
+  return {
+    matched: true,
+    parameters: segments.length > 0 ? last(segments).parameters : {},
+    consumedSegments: segments,
+    remainingSegments: [],
+    positionalParamSegments: {}
+  };
+}
+function split(segmentGroup, consumedSegments, slicedSegments, config) {
+  if (slicedSegments.length > 0 && containsEmptyPathMatchesWithNamedOutlets(segmentGroup, slicedSegments, config)) {
+    const s2 = new UrlSegmentGroup(consumedSegments, createChildrenForEmptyPaths(config, new UrlSegmentGroup(slicedSegments, segmentGroup.children)));
+    return { segmentGroup: s2, slicedSegments: [] };
+  }
+  if (slicedSegments.length === 0 && containsEmptyPathMatches(segmentGroup, slicedSegments, config)) {
+    const s2 = new UrlSegmentGroup(segmentGroup.segments, addEmptyPathsToChildrenIfNeeded(segmentGroup, slicedSegments, config, segmentGroup.children));
+    return { segmentGroup: s2, slicedSegments };
+  }
+  const s = new UrlSegmentGroup(segmentGroup.segments, segmentGroup.children);
+  return { segmentGroup: s, slicedSegments };
+}
+function addEmptyPathsToChildrenIfNeeded(segmentGroup, slicedSegments, routes, children) {
+  const res = {};
+  for (const r of routes) {
+    if (emptyPathMatch(segmentGroup, slicedSegments, r) && !children[getOutlet(r)]) {
+      const s = new UrlSegmentGroup([], {});
+      res[getOutlet(r)] = s;
+    }
+  }
+  return __spreadValues(__spreadValues({}, children), res);
+}
+function createChildrenForEmptyPaths(routes, primarySegment) {
+  const res = {};
+  res[PRIMARY_OUTLET] = primarySegment;
+  for (const r of routes) {
+    if (r.path === "" && getOutlet(r) !== PRIMARY_OUTLET) {
+      const s = new UrlSegmentGroup([], {});
+      res[getOutlet(r)] = s;
+    }
+  }
+  return res;
+}
+function containsEmptyPathMatchesWithNamedOutlets(segmentGroup, slicedSegments, routes) {
+  return routes.some((r) => emptyPathMatch(segmentGroup, slicedSegments, r) && getOutlet(r) !== PRIMARY_OUTLET);
+}
+function containsEmptyPathMatches(segmentGroup, slicedSegments, routes) {
+  return routes.some((r) => emptyPathMatch(segmentGroup, slicedSegments, r));
+}
+function emptyPathMatch(segmentGroup, slicedSegments, r) {
+  if ((segmentGroup.hasChildren() || slicedSegments.length > 0) && r.pathMatch === "full") {
+    return false;
+  }
+  return r.path === "";
+}
+function noLeftoversInUrl(segmentGroup, segments, outlet) {
+  return segments.length === 0 && !segmentGroup.children[outlet];
+}
+class NoLeftoversInUrl {
+}
+function recognize$1(injector, configLoader, rootComponentType, config, urlTree, urlSerializer, paramsInheritanceStrategy = "emptyOnly") {
+  return new Recognizer(injector, configLoader, rootComponentType, config, urlTree, paramsInheritanceStrategy, urlSerializer).recognize();
+}
+const MAX_ALLOWED_REDIRECTS = 31;
+class Recognizer {
+  constructor(injector, configLoader, rootComponentType, config, urlTree, paramsInheritanceStrategy, urlSerializer) {
+    __publicField(this, "injector");
+    __publicField(this, "configLoader");
+    __publicField(this, "rootComponentType");
+    __publicField(this, "config");
+    __publicField(this, "urlTree");
+    __publicField(this, "paramsInheritanceStrategy");
+    __publicField(this, "urlSerializer");
+    __publicField(this, "applyRedirects");
+    __publicField(this, "absoluteRedirectCount", 0);
+    __publicField(this, "allowRedirects", true);
+    this.injector = injector;
+    this.configLoader = configLoader;
+    this.rootComponentType = rootComponentType;
+    this.config = config;
+    this.urlTree = urlTree;
+    this.paramsInheritanceStrategy = paramsInheritanceStrategy;
+    this.urlSerializer = urlSerializer;
+    this.applyRedirects = new ApplyRedirects(this.urlSerializer, this.urlTree);
+  }
+  noMatchError(e) {
+    return new import_core.\u0275RuntimeError(4002, typeof ngDevMode === "undefined" || ngDevMode ? `Cannot match any routes. URL Segment: '${e.segmentGroup}'` : `'${e.segmentGroup}'`);
+  }
+  recognize() {
+    const rootSegmentGroup = split(this.urlTree.root, [], [], this.config).segmentGroup;
+    return this.match(rootSegmentGroup).pipe((0, import_operators.map)(({ children, rootSnapshot }) => {
+      const rootNode = new TreeNode(rootSnapshot, children);
+      const routeState = new RouterStateSnapshot("", rootNode);
+      const tree2 = createUrlTreeFromSnapshot(rootSnapshot, [], this.urlTree.queryParams, this.urlTree.fragment);
+      tree2.queryParams = this.urlTree.queryParams;
+      routeState.url = this.urlSerializer.serialize(tree2);
+      return { state: routeState, tree: tree2 };
+    }));
+  }
+  match(rootSegmentGroup) {
+    const rootSnapshot = new ActivatedRouteSnapshot([], Object.freeze({}), Object.freeze(__spreadValues({}, this.urlTree.queryParams)), this.urlTree.fragment, Object.freeze({}), PRIMARY_OUTLET, this.rootComponentType, null, {});
+    return this.processSegmentGroup(this.injector, this.config, rootSegmentGroup, PRIMARY_OUTLET, rootSnapshot).pipe((0, import_operators.map)((children) => {
+      return { children, rootSnapshot };
+    }), (0, import_operators.catchError)((e) => {
+      if (e instanceof AbsoluteRedirect) {
+        this.urlTree = e.urlTree;
+        return this.match(e.urlTree.root);
+      }
+      if (e instanceof NoMatch) {
+        throw this.noMatchError(e);
+      }
+      throw e;
+    }));
+  }
+  processSegmentGroup(injector, config, segmentGroup, outlet, parentRoute) {
+    if (segmentGroup.segments.length === 0 && segmentGroup.hasChildren()) {
+      return this.processChildren(injector, config, segmentGroup, parentRoute);
+    }
+    return this.processSegment(injector, config, segmentGroup, segmentGroup.segments, outlet, true, parentRoute).pipe((0, import_operators.map)((child) => child instanceof TreeNode ? [child] : []));
+  }
+  /**
+   * Matches every child outlet in the `segmentGroup` to a `Route` in the config. Returns `null` if
+   * we cannot find a match for _any_ of the children.
+   *
+   * @param config - The `Routes` to match against
+   * @param segmentGroup - The `UrlSegmentGroup` whose children need to be matched against the
+   *     config.
+   */
+  processChildren(injector, config, segmentGroup, parentRoute) {
+    const childOutlets = [];
+    for (const child of Object.keys(segmentGroup.children)) {
+      if (child === "primary") {
+        childOutlets.unshift(child);
+      } else {
+        childOutlets.push(child);
+      }
+    }
+    return (0, import_rxjs.from)(childOutlets).pipe((0, import_operators.concatMap)((childOutlet) => {
+      const child = segmentGroup.children[childOutlet];
+      const sortedConfig = sortByMatchingOutlets(config, childOutlet);
+      return this.processSegmentGroup(injector, sortedConfig, child, childOutlet, parentRoute);
+    }), (0, import_operators.scan)((children, outletChildren) => {
+      children.push(...outletChildren);
+      return children;
+    }), (0, import_operators.defaultIfEmpty)(null), (0, import_operators.last)(), (0, import_operators.mergeMap)((children) => {
+      if (children === null)
+        return noMatch$1(segmentGroup);
+      const mergedChildren = mergeEmptyPathMatches(children);
+      if (typeof ngDevMode === "undefined" || ngDevMode) {
+        checkOutletNameUniqueness(mergedChildren);
+      }
+      sortActivatedRouteSnapshots(mergedChildren);
+      return (0, import_rxjs.of)(mergedChildren);
+    }));
+  }
+  processSegment(injector, routes, segmentGroup, segments, outlet, allowRedirects, parentRoute) {
+    return (0, import_rxjs.from)(routes).pipe((0, import_operators.concatMap)((r) => {
+      var _a2;
+      return this.processSegmentAgainstRoute((_a2 = r._injector) != null ? _a2 : injector, routes, r, segmentGroup, segments, outlet, allowRedirects, parentRoute).pipe((0, import_operators.catchError)((e) => {
+        if (e instanceof NoMatch) {
+          return (0, import_rxjs.of)(null);
+        }
+        throw e;
+      }));
+    }), (0, import_operators.first)((x) => !!x), (0, import_operators.catchError)((e) => {
+      if (isEmptyError(e)) {
+        if (noLeftoversInUrl(segmentGroup, segments, outlet)) {
+          return (0, import_rxjs.of)(new NoLeftoversInUrl());
+        }
+        return noMatch$1(segmentGroup);
+      }
+      throw e;
+    }));
+  }
+  processSegmentAgainstRoute(injector, routes, route, rawSegment, segments, outlet, allowRedirects, parentRoute) {
+    if (getOutlet(route) !== outlet && (outlet === PRIMARY_OUTLET || !emptyPathMatch(rawSegment, segments, route))) {
+      return noMatch$1(rawSegment);
+    }
+    if (route.redirectTo === void 0) {
+      return this.matchSegmentAgainstRoute(injector, rawSegment, route, segments, outlet, parentRoute);
+    }
+    if (this.allowRedirects && allowRedirects) {
+      return this.expandSegmentAgainstRouteUsingRedirect(injector, rawSegment, routes, route, segments, outlet, parentRoute);
+    }
+    return noMatch$1(rawSegment);
+  }
+  expandSegmentAgainstRouteUsingRedirect(injector, segmentGroup, routes, route, segments, outlet, parentRoute) {
+    var _a2, _b2;
+    const { matched, parameters, consumedSegments, positionalParamSegments, remainingSegments } = match(segmentGroup, route, segments);
+    if (!matched)
+      return noMatch$1(segmentGroup);
+    if (typeof route.redirectTo === "string" && route.redirectTo[0] === "/") {
+      this.absoluteRedirectCount++;
+      if (this.absoluteRedirectCount > MAX_ALLOWED_REDIRECTS) {
+        if (ngDevMode) {
+          throw new import_core.\u0275RuntimeError(4016, `Detected possible infinite redirect when redirecting from '${this.urlTree}' to '${route.redirectTo}'.
+This is currently a dev mode only error but will become a call stack size exceeded error in production in a future major version.`);
+        }
+        this.allowRedirects = false;
+      }
+    }
+    const currentSnapshot = new ActivatedRouteSnapshot(segments, parameters, Object.freeze(__spreadValues({}, this.urlTree.queryParams)), this.urlTree.fragment, getData(route), getOutlet(route), (_b2 = (_a2 = route.component) != null ? _a2 : route._loadedComponent) != null ? _b2 : null, route, getResolve(route));
+    const inherited = getInherited(currentSnapshot, parentRoute, this.paramsInheritanceStrategy);
+    currentSnapshot.params = Object.freeze(inherited.params);
+    currentSnapshot.data = Object.freeze(inherited.data);
+    const newTree$ = this.applyRedirects.applyRedirectCommands(consumedSegments, route.redirectTo, positionalParamSegments, currentSnapshot, injector);
+    return newTree$.pipe((0, import_operators.switchMap)((newTree) => this.applyRedirects.lineralizeSegments(route, newTree)), (0, import_operators.mergeMap)((newSegments) => {
+      return this.processSegment(injector, routes, segmentGroup, newSegments.concat(remainingSegments), outlet, false, parentRoute);
+    }));
+  }
+  matchSegmentAgainstRoute(injector, rawSegment, route, segments, outlet, parentRoute) {
+    const matchResult = matchWithChecks(rawSegment, route, segments, injector, this.urlSerializer);
+    if (route.path === "**") {
+      rawSegment.children = {};
+    }
+    return matchResult.pipe((0, import_operators.switchMap)((result) => {
+      var _a2;
+      if (!result.matched) {
+        return noMatch$1(rawSegment);
+      }
+      injector = (_a2 = route._injector) != null ? _a2 : injector;
+      return this.getChildConfig(injector, route, segments).pipe((0, import_operators.switchMap)(({ routes: childConfig }) => {
+        var _a3, _b2, _c;
+        const childInjector = (_a3 = route._loadedInjector) != null ? _a3 : injector;
+        const { parameters, consumedSegments, remainingSegments } = result;
+        const snapshot = new ActivatedRouteSnapshot(consumedSegments, parameters, Object.freeze(__spreadValues({}, this.urlTree.queryParams)), this.urlTree.fragment, getData(route), getOutlet(route), (_c = (_b2 = route.component) != null ? _b2 : route._loadedComponent) != null ? _c : null, route, getResolve(route));
+        const inherited = getInherited(snapshot, parentRoute, this.paramsInheritanceStrategy);
+        snapshot.params = Object.freeze(inherited.params);
+        snapshot.data = Object.freeze(inherited.data);
+        const { segmentGroup, slicedSegments } = split(rawSegment, consumedSegments, remainingSegments, childConfig);
+        if (slicedSegments.length === 0 && segmentGroup.hasChildren()) {
+          return this.processChildren(childInjector, childConfig, segmentGroup, snapshot).pipe((0, import_operators.map)((children) => {
+            return new TreeNode(snapshot, children);
+          }));
+        }
+        if (childConfig.length === 0 && slicedSegments.length === 0) {
+          return (0, import_rxjs.of)(new TreeNode(snapshot, []));
+        }
+        const matchedOnOutlet = getOutlet(route) === outlet;
+        return this.processSegment(childInjector, childConfig, segmentGroup, slicedSegments, matchedOnOutlet ? PRIMARY_OUTLET : outlet, true, snapshot).pipe((0, import_operators.map)((child) => {
+          return new TreeNode(snapshot, child instanceof TreeNode ? [child] : []);
+        }));
+      }));
+    }));
+  }
+  getChildConfig(injector, route, segments) {
+    if (route.children) {
+      return (0, import_rxjs.of)({ routes: route.children, injector });
+    }
+    if (route.loadChildren) {
+      if (route._loadedRoutes !== void 0) {
+        return (0, import_rxjs.of)({ routes: route._loadedRoutes, injector: route._loadedInjector });
+      }
+      return runCanLoadGuards(injector, route, segments, this.urlSerializer).pipe((0, import_operators.mergeMap)((shouldLoadResult) => {
+        if (shouldLoadResult) {
+          return this.configLoader.loadChildren(injector, route).pipe((0, import_operators.tap)((cfg) => {
+            route._loadedRoutes = cfg.routes;
+            route._loadedInjector = cfg.injector;
+          }));
+        }
+        return canLoadFails(route);
+      }));
+    }
+    return (0, import_rxjs.of)({ routes: [], injector });
+  }
+}
+function sortActivatedRouteSnapshots(nodes) {
+  nodes.sort((a, b) => {
+    if (a.value.outlet === PRIMARY_OUTLET)
+      return -1;
+    if (b.value.outlet === PRIMARY_OUTLET)
+      return 1;
+    return a.value.outlet.localeCompare(b.value.outlet);
+  });
+}
+function hasEmptyPathConfig(node) {
+  const config = node.value.routeConfig;
+  return config && config.path === "";
+}
+function mergeEmptyPathMatches(nodes) {
+  const result = [];
+  const mergedNodes = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    if (!hasEmptyPathConfig(node)) {
+      result.push(node);
+      continue;
+    }
+    const duplicateEmptyPathNode = result.find((resultNode) => node.value.routeConfig === resultNode.value.routeConfig);
+    if (duplicateEmptyPathNode !== void 0) {
+      duplicateEmptyPathNode.children.push(...node.children);
+      mergedNodes.add(duplicateEmptyPathNode);
+    } else {
+      result.push(node);
+    }
+  }
+  for (const mergedNode of mergedNodes) {
+    const mergedChildren = mergeEmptyPathMatches(mergedNode.children);
+    result.push(new TreeNode(mergedNode.value, mergedChildren));
+  }
+  return result.filter((n) => !mergedNodes.has(n));
+}
+function checkOutletNameUniqueness(nodes) {
+  const names = {};
+  nodes.forEach((n) => {
+    const routeWithSameOutletName = names[n.value.outlet];
+    if (routeWithSameOutletName) {
+      const p = routeWithSameOutletName.url.map((s) => s.toString()).join("/");
+      const c = n.value.url.map((s) => s.toString()).join("/");
+      throw new import_core.\u0275RuntimeError(4006, (typeof ngDevMode === "undefined" || ngDevMode) && `Two segments cannot have the same outlet name: '${p}' and '${c}'.`);
+    }
+    names[n.value.outlet] = n.value;
+  });
+}
+function getData(route) {
+  return route.data || {};
+}
+function getResolve(route) {
+  return route.resolve || {};
+}
+function recognize(injector, configLoader, rootComponentType, config, serializer, paramsInheritanceStrategy) {
+  return (0, import_operators.mergeMap)((t) => recognize$1(injector, configLoader, rootComponentType, config, t.extractedUrl, serializer, paramsInheritanceStrategy).pipe((0, import_operators.map)(({ state: targetSnapshot, tree: urlAfterRedirects }) => {
+    return __spreadProps(__spreadValues({}, t), { targetSnapshot, urlAfterRedirects });
+  })));
+}
+function resolveData(paramsInheritanceStrategy, injector) {
+  return (0, import_operators.mergeMap)((t) => {
+    const { targetSnapshot, guards: { canActivateChecks } } = t;
+    if (!canActivateChecks.length) {
+      return (0, import_rxjs.of)(t);
+    }
+    const routesWithResolversToRun = new Set(canActivateChecks.map((check) => check.route));
+    const routesNeedingDataUpdates = /* @__PURE__ */ new Set();
+    for (const route of routesWithResolversToRun) {
+      if (routesNeedingDataUpdates.has(route)) {
+        continue;
+      }
+      for (const newRoute of flattenRouteTree(route)) {
+        routesNeedingDataUpdates.add(newRoute);
+      }
+    }
+    let routesProcessed = 0;
+    return (0, import_rxjs.from)(routesNeedingDataUpdates).pipe((0, import_operators.concatMap)((route) => {
+      if (routesWithResolversToRun.has(route)) {
+        return runResolve(route, targetSnapshot, paramsInheritanceStrategy, injector);
+      } else {
+        route.data = getInherited(route, route.parent, paramsInheritanceStrategy).resolve;
+        return (0, import_rxjs.of)(void 0);
+      }
+    }), (0, import_operators.tap)(() => routesProcessed++), (0, import_operators.takeLast)(1), (0, import_operators.mergeMap)((_) => routesProcessed === routesNeedingDataUpdates.size ? (0, import_rxjs.of)(t) : import_rxjs.EMPTY));
+  });
+}
+function flattenRouteTree(route) {
+  const descendants = route.children.map((child) => flattenRouteTree(child)).flat();
+  return [route, ...descendants];
+}
+function runResolve(futureARS, futureRSS, paramsInheritanceStrategy, injector) {
+  const config = futureARS.routeConfig;
+  const resolve = futureARS._resolve;
+  if ((config == null ? void 0 : config.title) !== void 0 && !hasStaticTitle(config)) {
+    resolve[RouteTitleKey] = config.title;
+  }
+  return (0, import_rxjs.defer)(() => {
+    futureARS.data = getInherited(futureARS, futureARS.parent, paramsInheritanceStrategy).resolve;
+    return resolveNode(resolve, futureARS, futureRSS, injector).pipe((0, import_operators.map)((resolvedData) => {
+      futureARS._resolvedData = resolvedData;
+      futureARS.data = __spreadValues(__spreadValues({}, futureARS.data), resolvedData);
+      return null;
+    }));
+  });
+}
+function resolveNode(resolve, futureARS, futureRSS, injector) {
+  const keys = getDataKeys(resolve);
+  if (keys.length === 0) {
+    return (0, import_rxjs.of)({});
+  }
+  const data = {};
+  return (0, import_rxjs.from)(keys).pipe((0, import_operators.mergeMap)((key) => getResolver(resolve[key], futureARS, futureRSS, injector).pipe((0, import_operators.first)(), (0, import_operators.tap)((value) => {
+    if (value instanceof RedirectCommand) {
+      throw redirectingNavigationError(new DefaultUrlSerializer(), value);
+    }
+    data[key] = value;
+  }))), (0, import_operators.takeLast)(1), (0, import_operators.map)(() => data), (0, import_operators.catchError)((e) => isEmptyError(e) ? import_rxjs.EMPTY : (0, import_rxjs.throwError)(e)));
+}
+function getResolver(injectionToken, futureARS, futureRSS, injector) {
+  var _a2;
+  const closestInjector = (_a2 = getClosestRouteInjector(futureARS)) != null ? _a2 : injector;
+  const resolver = getTokenOrFunctionIdentity(injectionToken, closestInjector);
+  const resolverValue = resolver.resolve ? resolver.resolve(futureARS, futureRSS) : (0, import_core.runInInjectionContext)(closestInjector, () => resolver(futureARS, futureRSS));
+  return wrapIntoObservable(resolverValue);
+}
+function switchTap(next) {
+  return (0, import_operators.switchMap)((v) => {
+    const nextResult = next(v);
+    if (nextResult) {
+      return (0, import_rxjs.from)(nextResult).pipe((0, import_operators.map)(() => v));
+    }
+    return (0, import_rxjs.of)(v);
+  });
+}
+const _TitleStrategy = class _TitleStrategy {
+  /**
+   * @returns The `title` of the deepest primary route.
+   */
+  buildTitle(snapshot) {
+    var _a2;
+    let pageTitle;
+    let route = snapshot.root;
+    while (route !== void 0) {
+      pageTitle = (_a2 = this.getResolvedTitleForRoute(route)) != null ? _a2 : pageTitle;
+      route = route.children.find((child) => child.outlet === PRIMARY_OUTLET);
+    }
+    return pageTitle;
+  }
+  /**
+   * Given an `ActivatedRouteSnapshot`, returns the final value of the
+   * `Route.title` property, which can either be a static string or a resolved value.
+   */
+  getResolvedTitleForRoute(snapshot) {
+    return snapshot.data[RouteTitleKey];
+  }
+};
+__publicField(_TitleStrategy, "\u0275fac", i0.\u0275\u0275ngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _TitleStrategy, deps: [], target: i0.\u0275\u0275FactoryTarget.Injectable }));
+__publicField(_TitleStrategy, "\u0275prov", i0.\u0275\u0275ngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _TitleStrategy, providedIn: "root", useFactory: () => (0, import_core.inject)(DefaultTitleStrategy) }));
+let TitleStrategy = _TitleStrategy;
+i0.\u0275\u0275ngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: TitleStrategy, decorators: [{
+  type: import_core.Injectable,
+  args: [{ providedIn: "root", useFactory: () => (0, import_core.inject)(DefaultTitleStrategy) }]
+}] });
+const _DefaultTitleStrategy = class _DefaultTitleStrategy extends TitleStrategy {
+  constructor(title) {
+    super();
+    __publicField(this, "title");
+    this.title = title;
+  }
+  /**
+   * Sets the title of the browser to the given value.
+   *
+   * @param title The `pageTitle` from the deepest primary route.
+   */
+  updateTitle(snapshot) {
+    const title = this.buildTitle(snapshot);
+    if (title !== void 0) {
+      this.title.setTitle(title);
+    }
+  }
+};
+__publicField(_DefaultTitleStrategy, "\u0275fac", i0.\u0275\u0275ngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _DefaultTitleStrategy, deps: [{ token: i1.Title }], target: i0.\u0275\u0275FactoryTarget.Injectable }));
+__publicField(_DefaultTitleStrategy, "\u0275prov", i0.\u0275\u0275ngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _DefaultTitleStrategy, providedIn: "root" }));
+let DefaultTitleStrategy = _DefaultTitleStrategy;
+i0.\u0275\u0275ngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: DefaultTitleStrategy, decorators: [{
+  type: import_core.Injectable,
+  args: [{ providedIn: "root" }]
+}], ctorParameters: () => [{ type: i1.Title }] });
+const ROUTER_CONFIGURATION = new import_core.InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "router config" : "", {
+  providedIn: "root",
+  factory: () => ({})
+});
+const ROUTES = new import_core.InjectionToken(ngDevMode ? "ROUTES" : "");
+const _RouterConfigLoader = class _RouterConfigLoader {
+  constructor() {
+    __publicField(this, "componentLoaders", /* @__PURE__ */ new WeakMap());
+    __publicField(this, "childrenLoaders", /* @__PURE__ */ new WeakMap());
+    __publicField(this, "onLoadStartListener");
+    __publicField(this, "onLoadEndListener");
+    __publicField(this, "compiler", (0, import_core.inject)(import_core.Compiler));
+  }
+  loadComponent(injector, route) {
+    if (this.componentLoaders.get(route)) {
+      return this.componentLoaders.get(route);
+    } else if (route._loadedComponent) {
+      return (0, import_rxjs.of)(route._loadedComponent);
+    }
+    if (this.onLoadStartListener) {
+      this.onLoadStartListener(route);
+    }
+    const loadRunner = wrapIntoObservable((0, import_core.runInInjectionContext)(injector, () => route.loadComponent())).pipe((0, import_operators.map)(maybeUnwrapDefaultExport), (0, import_operators.switchMap)(maybeResolveResources), (0, import_operators.tap)((component) => {
+      var _a2;
+      if (this.onLoadEndListener) {
+        this.onLoadEndListener(route);
+      }
+      (typeof ngDevMode === "undefined" || ngDevMode) && assertStandalone((_a2 = route.path) != null ? _a2 : "", component);
+      route._loadedComponent = component;
+    }), (0, import_operators.finalize)(() => {
+      this.componentLoaders.delete(route);
+    }));
+    const loader = new import_rxjs.ConnectableObservable(loadRunner, () => new import_rxjs.Subject()).pipe((0, import_operators.refCount)());
+    this.componentLoaders.set(route, loader);
+    return loader;
+  }
+  loadChildren(parentInjector, route) {
+    if (this.childrenLoaders.get(route)) {
+      return this.childrenLoaders.get(route);
+    } else if (route._loadedRoutes) {
+      return (0, import_rxjs.of)({ routes: route._loadedRoutes, injector: route._loadedInjector });
+    }
+    if (this.onLoadStartListener) {
+      this.onLoadStartListener(route);
+    }
+    const moduleFactoryOrRoutes$ = loadChildren(route, this.compiler, parentInjector, this.onLoadEndListener);
+    const loadRunner = moduleFactoryOrRoutes$.pipe((0, import_operators.finalize)(() => {
+      this.childrenLoaders.delete(route);
+    }));
+    const loader = new import_rxjs.ConnectableObservable(loadRunner, () => new import_rxjs.Subject()).pipe((0, import_operators.refCount)());
+    this.childrenLoaders.set(route, loader);
+    return loader;
+  }
+};
+__publicField(_RouterConfigLoader, "\u0275fac", i0.\u0275\u0275ngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _RouterConfigLoader, deps: [], target: i0.\u0275\u0275FactoryTarget.Injectable }));
+__publicField(_RouterConfigLoader, "\u0275prov", i0.\u0275\u0275ngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _RouterConfigLoader, providedIn: "root" }));
+let RouterConfigLoader = _RouterConfigLoader;
+i0.\u0275\u0275ngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: RouterConfigLoader, decorators: [{
+  type: import_core.Injectable,
+  args: [{ providedIn: "root" }]
+}] });
+function loadChildren(route, compiler, parentInjector, onLoadEndListener) {
+  return wrapIntoObservable((0, import_core.runInInjectionContext)(parentInjector, () => route.loadChildren())).pipe((0, import_operators.map)(maybeUnwrapDefaultExport), (0, import_operators.switchMap)(maybeResolveResources), (0, import_operators.mergeMap)((t) => {
+    if (t instanceof import_core.NgModuleFactory || Array.isArray(t)) {
+      return (0, import_rxjs.of)(t);
+    } else {
+      return (0, import_rxjs.from)(compiler.compileModuleAsync(t));
+    }
+  }), (0, import_operators.map)((factoryOrRoutes) => {
+    if (onLoadEndListener) {
+      onLoadEndListener(route);
+    }
+    let injector;
+    let rawRoutes;
+    let requireStandaloneComponents = false;
+    if (Array.isArray(factoryOrRoutes)) {
+      rawRoutes = factoryOrRoutes;
+      requireStandaloneComponents = true;
+    } else {
+      injector = factoryOrRoutes.create(parentInjector).injector;
+      rawRoutes = injector.get(ROUTES, [], { optional: true, self: true }).flat();
+    }
+    const routes = rawRoutes.map(standardizeConfig);
+    (typeof ngDevMode === "undefined" || ngDevMode) && validateConfig(routes, route.path, requireStandaloneComponents);
+    return { routes, injector };
+  }));
+}
+function isWrappedDefaultExport(value) {
+  return value && typeof value === "object" && "default" in value;
+}
+function maybeUnwrapDefaultExport(input2) {
+  return isWrappedDefaultExport(input2) ? input2["default"] : input2;
+}
+function maybeResolveResources(value) {
+  if ((typeof ngJitMode === "undefined" || ngJitMode) && typeof fetch === "function") {
+    return (0, import_core.\u0275resolveComponentResources)(fetch).catch((error) => {
+      console.error(error);
+      return Promise.resolve();
+    }).then(() => value);
+  }
+  return (0, import_rxjs.of)(value);
+}
+const _UrlHandlingStrategy = class _UrlHandlingStrategy {
+};
+__publicField(_UrlHandlingStrategy, "\u0275fac", i0.\u0275\u0275ngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _UrlHandlingStrategy, deps: [], target: i0.\u0275\u0275FactoryTarget.Injectable }));
+__publicField(_UrlHandlingStrategy, "\u0275prov", i0.\u0275\u0275ngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _UrlHandlingStrategy, providedIn: "root", useFactory: () => (0, import_core.inject)(DefaultUrlHandlingStrategy) }));
+let UrlHandlingStrategy = _UrlHandlingStrategy;
+i0.\u0275\u0275ngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: UrlHandlingStrategy, decorators: [{
+  type: import_core.Injectable,
+  args: [{ providedIn: "root", useFactory: () => (0, import_core.inject)(DefaultUrlHandlingStrategy) }]
+}] });
+const _DefaultUrlHandlingStrategy = class _DefaultUrlHandlingStrategy {
+  shouldProcessUrl(url) {
+    return true;
+  }
+  extract(url) {
+    return url;
+  }
+  merge(newUrlPart, wholeUrl) {
+    return newUrlPart;
+  }
+};
+__publicField(_DefaultUrlHandlingStrategy, "\u0275fac", i0.\u0275\u0275ngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _DefaultUrlHandlingStrategy, deps: [], target: i0.\u0275\u0275FactoryTarget.Injectable }));
+__publicField(_DefaultUrlHandlingStrategy, "\u0275prov", i0.\u0275\u0275ngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _DefaultUrlHandlingStrategy, providedIn: "root" }));
+let DefaultUrlHandlingStrategy = _DefaultUrlHandlingStrategy;
+i0.\u0275\u0275ngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: DefaultUrlHandlingStrategy, decorators: [{
+  type: import_core.Injectable,
+  args: [{ providedIn: "root" }]
+}] });
+const CREATE_VIEW_TRANSITION = new import_core.InjectionToken(ngDevMode ? "view transition helper" : "");
+const VIEW_TRANSITION_OPTIONS = new import_core.InjectionToken(ngDevMode ? "view transition options" : "");
+function createViewTransition(injector, from2, to) {
+  const transitionOptions = injector.get(VIEW_TRANSITION_OPTIONS);
+  const document = injector.get(import_common.DOCUMENT);
+  if (!document.startViewTransition || transitionOptions.skipNextTransition) {
+    transitionOptions.skipNextTransition = false;
+    return new Promise((resolve) => setTimeout(resolve));
+  }
+  let resolveViewTransitionStarted;
+  const viewTransitionStarted = new Promise((resolve) => {
+    resolveViewTransitionStarted = resolve;
+  });
+  const transition = document.startViewTransition(() => {
+    resolveViewTransitionStarted();
+    return createRenderPromise(injector);
+  });
+  transition.ready.catch((error) => {
+    if (typeof ngDevMode === "undefined" || ngDevMode) {
+      console.error(error);
+    }
+  });
+  const { onViewTransitionCreated } = transitionOptions;
+  if (onViewTransitionCreated) {
+    (0, import_core.runInInjectionContext)(injector, () => onViewTransitionCreated({ transition, from: from2, to }));
+  }
+  return viewTransitionStarted;
+}
+function createRenderPromise(injector) {
+  return new Promise((resolve) => {
+    (0, import_core.afterNextRender)({ read: () => setTimeout(resolve) }, { injector });
+  });
+}
+const NAVIGATION_ERROR_HANDLER = new import_core.InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "navigation error handler" : "");
+const _NavigationTransitions = class _NavigationTransitions {
+  constructor() {
+    // Some G3 targets expect the navigation object to be mutated (and not getting a new reference on changes).
+    __publicField(this, "currentNavigation", (0, import_core.signal)(null, ...ngDevMode ? [{ debugName: "currentNavigation", equal: () => false }] : [{ equal: () => false }]));
+    __publicField(this, "currentTransition", null);
+    __publicField(this, "lastSuccessfulNavigation", null);
+    /**
+     * These events are used to communicate back to the Router about the state of the transition. The
+     * Router wants to respond to these events in various ways. Because the `NavigationTransition`
+     * class is not public, this event subject is not publicly exposed.
+     */
+    __publicField(this, "events", new import_rxjs.Subject());
+    /**
+     * Used to abort the current transition with an error.
+     */
+    __publicField(this, "transitionAbortWithErrorSubject", new import_rxjs.Subject());
+    __publicField(this, "configLoader", (0, import_core.inject)(RouterConfigLoader));
+    __publicField(this, "environmentInjector", (0, import_core.inject)(import_core.EnvironmentInjector));
+    __publicField(this, "destroyRef", (0, import_core.inject)(import_core.DestroyRef));
+    __publicField(this, "urlSerializer", (0, import_core.inject)(UrlSerializer));
+    __publicField(this, "rootContexts", (0, import_core.inject)(ChildrenOutletContexts));
+    __publicField(this, "location", (0, import_core.inject)(import_common.Location));
+    __publicField(this, "inputBindingEnabled", (0, import_core.inject)(INPUT_BINDER, { optional: true }) !== null);
+    __publicField(this, "titleStrategy", (0, import_core.inject)(TitleStrategy));
+    __publicField(this, "options", (0, import_core.inject)(ROUTER_CONFIGURATION, { optional: true }) || {});
+    __publicField(this, "paramsInheritanceStrategy", this.options.paramsInheritanceStrategy || "emptyOnly");
+    __publicField(this, "urlHandlingStrategy", (0, import_core.inject)(UrlHandlingStrategy));
+    __publicField(this, "createViewTransition", (0, import_core.inject)(CREATE_VIEW_TRANSITION, { optional: true }));
+    __publicField(this, "navigationErrorHandler", (0, import_core.inject)(NAVIGATION_ERROR_HANDLER, { optional: true }));
+    __publicField(this, "navigationId", 0);
+    __publicField(this, "transitions");
+    /**
+     * Hook that enables you to pause navigation after the preactivation phase.
+     * Used by `RouterModule`.
+     *
+     * @internal
+     */
+    __publicField(this, "afterPreactivation", () => (0, import_rxjs.of)(void 0));
+    /** @internal */
+    __publicField(this, "rootComponentType", null);
+    __publicField(this, "destroyed", false);
+    const onLoadStart = (r) => this.events.next(new RouteConfigLoadStart(r));
+    const onLoadEnd = (r) => this.events.next(new RouteConfigLoadEnd(r));
+    this.configLoader.onLoadEndListener = onLoadEnd;
+    this.configLoader.onLoadStartListener = onLoadStart;
+    this.destroyRef.onDestroy(() => {
+      this.destroyed = true;
+    });
+  }
+  get hasRequestedNavigation() {
+    return this.navigationId !== 0;
+  }
+  complete() {
+    var _a2;
+    (_a2 = this.transitions) == null ? void 0 : _a2.complete();
+  }
+  handleNavigationRequest(request) {
+    const id = ++this.navigationId;
+    (0, import_core.untracked)(() => {
+      var _a2;
+      (_a2 = this.transitions) == null ? void 0 : _a2.next(__spreadProps(__spreadValues({}, request), {
+        extractedUrl: this.urlHandlingStrategy.extract(request.rawUrl),
+        targetSnapshot: null,
+        targetRouterState: null,
+        guards: { canActivateChecks: [], canDeactivateChecks: [] },
+        guardsResult: null,
+        abortController: new AbortController(),
+        id
+      }));
+    });
+  }
+  setupNavigations(router) {
+    this.transitions = new import_rxjs.BehaviorSubject(null);
+    return this.transitions.pipe(
+      (0, import_operators.filter)((t) => t !== null),
+      // Using switchMap so we cancel executing navigations when a new one comes in
+      (0, import_operators.switchMap)((overallTransitionState) => {
+        let completedOrAborted = false;
+        return (0, import_rxjs.of)(overallTransitionState).pipe(
+          (0, import_operators.switchMap)((t) => {
+            var _a2;
+            if (this.navigationId > overallTransitionState.id) {
+              const cancellationReason = typeof ngDevMode === "undefined" || ngDevMode ? `Navigation ID ${overallTransitionState.id} is not equal to the current navigation id ${this.navigationId}` : "";
+              this.cancelNavigationTransition(overallTransitionState, cancellationReason, NavigationCancellationCode.SupersededByNewNavigation);
+              return import_rxjs.EMPTY;
+            }
+            this.currentTransition = overallTransitionState;
+            this.currentNavigation.set({
+              id: t.id,
+              initialUrl: t.rawUrl,
+              extractedUrl: t.extractedUrl,
+              targetBrowserUrl: typeof t.extras.browserUrl === "string" ? this.urlSerializer.parse(t.extras.browserUrl) : t.extras.browserUrl,
+              trigger: t.source,
+              extras: t.extras,
+              previousNavigation: !this.lastSuccessfulNavigation ? null : __spreadProps(__spreadValues({}, this.lastSuccessfulNavigation), {
+                previousNavigation: null
+              }),
+              abort: () => t.abortController.abort()
+            });
+            const urlTransition = !router.navigated || this.isUpdatingInternalState() || this.isUpdatedBrowserUrl();
+            const onSameUrlNavigation = (_a2 = t.extras.onSameUrlNavigation) != null ? _a2 : router.onSameUrlNavigation;
+            if (!urlTransition && onSameUrlNavigation !== "reload") {
+              const reason = typeof ngDevMode === "undefined" || ngDevMode ? `Navigation to ${t.rawUrl} was ignored because it is the same as the current Router URL.` : "";
+              this.events.next(new NavigationSkipped(t.id, this.urlSerializer.serialize(t.rawUrl), reason, NavigationSkippedCode.IgnoredSameUrlNavigation));
+              t.resolve(false);
+              return import_rxjs.EMPTY;
+            }
+            if (this.urlHandlingStrategy.shouldProcessUrl(t.rawUrl)) {
+              return (0, import_rxjs.of)(t).pipe(
+                // Fire NavigationStart event
+                (0, import_operators.switchMap)((t2) => {
+                  this.events.next(new NavigationStart(t2.id, this.urlSerializer.serialize(t2.extractedUrl), t2.source, t2.restoredState));
+                  if (t2.id !== this.navigationId) {
+                    return import_rxjs.EMPTY;
+                  }
+                  return Promise.resolve(t2);
+                }),
+                // Recognize
+                recognize(this.environmentInjector, this.configLoader, this.rootComponentType, router.config, this.urlSerializer, this.paramsInheritanceStrategy),
+                // Update URL if in `eager` update mode
+                (0, import_operators.tap)((t2) => {
+                  overallTransitionState.targetSnapshot = t2.targetSnapshot;
+                  overallTransitionState.urlAfterRedirects = t2.urlAfterRedirects;
+                  this.currentNavigation.update((nav) => {
+                    nav.finalUrl = t2.urlAfterRedirects;
+                    return nav;
+                  });
+                  const routesRecognized = new RoutesRecognized(t2.id, this.urlSerializer.serialize(t2.extractedUrl), this.urlSerializer.serialize(t2.urlAfterRedirects), t2.targetSnapshot);
+                  this.events.next(routesRecognized);
+                })
+              );
+            } else if (urlTransition && this.urlHandlingStrategy.shouldProcessUrl(t.currentRawUrl)) {
+              const { id, extractedUrl, source, restoredState, extras } = t;
+              const navStart = new NavigationStart(id, this.urlSerializer.serialize(extractedUrl), source, restoredState);
+              this.events.next(navStart);
+              const targetSnapshot = createEmptyState(this.rootComponentType).snapshot;
+              this.currentTransition = overallTransitionState = __spreadProps(__spreadValues({}, t), {
+                targetSnapshot,
+                urlAfterRedirects: extractedUrl,
+                extras: __spreadProps(__spreadValues({}, extras), { skipLocationChange: false, replaceUrl: false })
+              });
+              this.currentNavigation.update((nav) => {
+                nav.finalUrl = extractedUrl;
+                return nav;
+              });
+              return (0, import_rxjs.of)(overallTransitionState);
+            } else {
+              const reason = typeof ngDevMode === "undefined" || ngDevMode ? `Navigation was ignored because the UrlHandlingStrategy indicated neither the current URL ${t.currentRawUrl} nor target URL ${t.rawUrl} should be processed.` : "";
+              this.events.next(new NavigationSkipped(t.id, this.urlSerializer.serialize(t.extractedUrl), reason, NavigationSkippedCode.IgnoredByUrlHandlingStrategy));
+              t.resolve(false);
+              return import_rxjs.EMPTY;
+            }
+          }),
+          // --- GUARDS ---
+          (0, import_operators.tap)((t) => {
+            const guardsStart = new GuardsCheckStart(t.id, this.urlSerializer.serialize(t.extractedUrl), this.urlSerializer.serialize(t.urlAfterRedirects), t.targetSnapshot);
+            this.events.next(guardsStart);
+          }),
+          (0, import_operators.map)((t) => {
+            this.currentTransition = overallTransitionState = __spreadProps(__spreadValues({}, t), {
+              guards: getAllRouteGuards(t.targetSnapshot, t.currentSnapshot, this.rootContexts)
+            });
+            return overallTransitionState;
+          }),
+          checkGuards(this.environmentInjector, (evt) => this.events.next(evt)),
+          (0, import_operators.tap)((t) => {
+            overallTransitionState.guardsResult = t.guardsResult;
+            if (t.guardsResult && typeof t.guardsResult !== "boolean") {
+              throw redirectingNavigationError(this.urlSerializer, t.guardsResult);
+            }
+            const guardsEnd = new GuardsCheckEnd(t.id, this.urlSerializer.serialize(t.extractedUrl), this.urlSerializer.serialize(t.urlAfterRedirects), t.targetSnapshot, !!t.guardsResult);
+            this.events.next(guardsEnd);
+          }),
+          (0, import_operators.filter)((t) => {
+            if (!t.guardsResult) {
+              this.cancelNavigationTransition(t, "", NavigationCancellationCode.GuardRejected);
+              return false;
+            }
+            return true;
+          }),
+          // --- RESOLVE ---
+          switchTap((t) => {
+            if (t.guards.canActivateChecks.length === 0) {
+              return void 0;
+            }
+            return (0, import_rxjs.of)(t).pipe((0, import_operators.tap)((t2) => {
+              const resolveStart = new ResolveStart(t2.id, this.urlSerializer.serialize(t2.extractedUrl), this.urlSerializer.serialize(t2.urlAfterRedirects), t2.targetSnapshot);
+              this.events.next(resolveStart);
+            }), (0, import_operators.switchMap)((t2) => {
+              let dataResolved = false;
+              return (0, import_rxjs.of)(t2).pipe(resolveData(this.paramsInheritanceStrategy, this.environmentInjector), (0, import_operators.tap)({
+                next: () => dataResolved = true,
+                complete: () => {
+                  if (!dataResolved) {
+                    this.cancelNavigationTransition(t2, typeof ngDevMode === "undefined" || ngDevMode ? `At least one route resolver didn't emit any value.` : "", NavigationCancellationCode.NoDataFromResolver);
+                  }
+                }
+              }));
+            }), (0, import_operators.tap)((t2) => {
+              const resolveEnd = new ResolveEnd(t2.id, this.urlSerializer.serialize(t2.extractedUrl), this.urlSerializer.serialize(t2.urlAfterRedirects), t2.targetSnapshot);
+              this.events.next(resolveEnd);
+            }));
+          }),
+          // --- LOAD COMPONENTS ---
+          switchTap((t) => {
+            const loadComponents = (route) => {
+              var _a2, _b2;
+              const loaders = [];
+              if ((_a2 = route.routeConfig) == null ? void 0 : _a2.loadComponent) {
+                const injector = (_b2 = getClosestRouteInjector(route)) != null ? _b2 : this.environmentInjector;
+                loaders.push(this.configLoader.loadComponent(injector, route.routeConfig).pipe((0, import_operators.tap)((loadedComponent) => {
+                  route.component = loadedComponent;
+                }), (0, import_operators.map)(() => void 0)));
+              }
+              for (const child of route.children) {
+                loaders.push(...loadComponents(child));
+              }
+              return loaders;
+            };
+            return (0, import_rxjs.combineLatest)(loadComponents(t.targetSnapshot.root)).pipe((0, import_operators.defaultIfEmpty)(null), (0, import_operators.take)(1));
+          }),
+          switchTap(() => this.afterPreactivation()),
+          (0, import_operators.switchMap)(() => {
+            var _a2;
+            const { currentSnapshot, targetSnapshot } = overallTransitionState;
+            const viewTransitionStarted = (_a2 = this.createViewTransition) == null ? void 0 : _a2.call(this, this.environmentInjector, currentSnapshot.root, targetSnapshot.root);
+            return viewTransitionStarted ? (0, import_rxjs.from)(viewTransitionStarted).pipe((0, import_operators.map)(() => overallTransitionState)) : (0, import_rxjs.of)(overallTransitionState);
+          }),
+          (0, import_operators.map)((t) => {
+            const targetRouterState = createRouterState(router.routeReuseStrategy, t.targetSnapshot, t.currentRouterState);
+            this.currentTransition = overallTransitionState = __spreadProps(__spreadValues({}, t), { targetRouterState });
+            this.currentNavigation.update((nav) => {
+              nav.targetRouterState = targetRouterState;
+              return nav;
+            });
+            return overallTransitionState;
+          }),
+          (0, import_operators.tap)(() => {
+            this.events.next(new BeforeActivateRoutes());
+          }),
+          activateRoutes(this.rootContexts, router.routeReuseStrategy, (evt) => this.events.next(evt), this.inputBindingEnabled),
+          // Ensure that if some observable used to drive the transition doesn't
+          // complete, the navigation still finalizes This should never happen, but
+          // this is done as a safety measure to avoid surfacing this error (#49567).
+          (0, import_operators.take)(1),
+          (0, import_operators.takeUntil)(new import_rxjs.Observable((subscriber) => {
+            const abortSignal = overallTransitionState.abortController.signal;
+            const handler = () => subscriber.next();
+            abortSignal.addEventListener("abort", handler);
+            return () => abortSignal.removeEventListener("abort", handler);
+          }).pipe(
+            // Ignore aborts if we are already completed, canceled, or are in the activation stage (we have targetRouterState)
+            (0, import_operators.filter)(() => !completedOrAborted && !overallTransitionState.targetRouterState),
+            (0, import_operators.tap)(() => {
+              this.cancelNavigationTransition(overallTransitionState, overallTransitionState.abortController.signal.reason + "", NavigationCancellationCode.Aborted);
+            })
+          )),
+          (0, import_operators.tap)({
+            next: (t) => {
+              var _a2;
+              completedOrAborted = true;
+              this.lastSuccessfulNavigation = (0, import_core.untracked)(this.currentNavigation);
+              this.events.next(new NavigationEnd(t.id, this.urlSerializer.serialize(t.extractedUrl), this.urlSerializer.serialize(t.urlAfterRedirects)));
+              (_a2 = this.titleStrategy) == null ? void 0 : _a2.updateTitle(t.targetRouterState.snapshot);
+              t.resolve(true);
+            },
+            complete: () => {
+              completedOrAborted = true;
+            }
+          }),
+          // There used to be a lot more logic happening directly within the
+          // transition Observable. Some of this logic has been refactored out to
+          // other places but there may still be errors that happen there. This gives
+          // us a way to cancel the transition from the outside. This may also be
+          // required in the future to support something like the abort signal of the
+          // Navigation API where the navigation gets aborted from outside the
+          // transition.
+          (0, import_operators.takeUntil)(this.transitionAbortWithErrorSubject.pipe((0, import_operators.tap)((err) => {
+            throw err;
+          }))),
+          (0, import_operators.finalize)(() => {
+            var _a2;
+            if (!completedOrAborted) {
+              const cancelationReason = typeof ngDevMode === "undefined" || ngDevMode ? `Navigation ID ${overallTransitionState.id} is not equal to the current navigation id ${this.navigationId}` : "";
+              this.cancelNavigationTransition(overallTransitionState, cancelationReason, NavigationCancellationCode.SupersededByNewNavigation);
+            }
+            if (((_a2 = this.currentTransition) == null ? void 0 : _a2.id) === overallTransitionState.id) {
+              this.currentNavigation.set(null);
+              this.currentTransition = null;
+            }
+          }),
+          (0, import_operators.catchError)((e) => {
+            var _a2;
+            if (this.destroyed) {
+              overallTransitionState.resolve(false);
+              return import_rxjs.EMPTY;
+            }
+            completedOrAborted = true;
+            if (isNavigationCancelingError(e)) {
+              this.events.next(new NavigationCancel(overallTransitionState.id, this.urlSerializer.serialize(overallTransitionState.extractedUrl), e.message, e.cancellationCode));
+              if (!isRedirectingNavigationCancelingError(e)) {
+                overallTransitionState.resolve(false);
+              } else {
+                this.events.next(new RedirectRequest(e.url, e.navigationBehaviorOptions));
+              }
+            } else {
+              const navigationError = new NavigationError(overallTransitionState.id, this.urlSerializer.serialize(overallTransitionState.extractedUrl), e, (_a2 = overallTransitionState.targetSnapshot) != null ? _a2 : void 0);
+              try {
+                const navigationErrorHandlerResult = (0, import_core.runInInjectionContext)(this.environmentInjector, () => {
+                  var _a3;
+                  return (_a3 = this.navigationErrorHandler) == null ? void 0 : _a3.call(this, navigationError);
+                });
+                if (navigationErrorHandlerResult instanceof RedirectCommand) {
+                  const { message, cancellationCode } = redirectingNavigationError(this.urlSerializer, navigationErrorHandlerResult);
+                  this.events.next(new NavigationCancel(overallTransitionState.id, this.urlSerializer.serialize(overallTransitionState.extractedUrl), message, cancellationCode));
+                  this.events.next(new RedirectRequest(navigationErrorHandlerResult.redirectTo, navigationErrorHandlerResult.navigationBehaviorOptions));
+                } else {
+                  this.events.next(navigationError);
+                  throw e;
+                }
+              } catch (ee) {
+                if (this.options.resolveNavigationPromiseOnError) {
+                  overallTransitionState.resolve(false);
+                } else {
+                  overallTransitionState.reject(ee);
+                }
+              }
+            }
+            return import_rxjs.EMPTY;
+          })
+        );
+      })
+    );
+  }
+  cancelNavigationTransition(t, reason, code) {
+    const navCancel = new NavigationCancel(t.id, this.urlSerializer.serialize(t.extractedUrl), reason, code);
+    this.events.next(navCancel);
+    t.resolve(false);
+  }
+  /**
+   * @returns Whether we're navigating to somewhere that is not what the Router is
+   * currently set to.
+   */
+  isUpdatingInternalState() {
+    var _a2, _b2;
+    return ((_a2 = this.currentTransition) == null ? void 0 : _a2.extractedUrl.toString()) !== ((_b2 = this.currentTransition) == null ? void 0 : _b2.currentUrlTree.toString());
+  }
+  /**
+   * @returns Whether we're updating the browser URL to something new (navigation is going
+   * to somewhere not displayed in the URL bar and we will update the URL
+   * bar if navigation succeeds).
+   */
+  isUpdatedBrowserUrl() {
+    var _a2;
+    const currentBrowserUrl = this.urlHandlingStrategy.extract(this.urlSerializer.parse(this.location.path(true)));
+    const currentNavigation = (0, import_core.untracked)(this.currentNavigation);
+    const targetBrowserUrl = (_a2 = currentNavigation == null ? void 0 : currentNavigation.targetBrowserUrl) != null ? _a2 : currentNavigation == null ? void 0 : currentNavigation.extractedUrl;
+    return currentBrowserUrl.toString() !== (targetBrowserUrl == null ? void 0 : targetBrowserUrl.toString()) && !(currentNavigation == null ? void 0 : currentNavigation.extras.skipLocationChange);
+  }
+};
+__publicField(_NavigationTransitions, "\u0275fac", i0.\u0275\u0275ngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _NavigationTransitions, deps: [], target: i0.\u0275\u0275FactoryTarget.Injectable }));
+__publicField(_NavigationTransitions, "\u0275prov", i0.\u0275\u0275ngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _NavigationTransitions, providedIn: "root" }));
+let NavigationTransitions = _NavigationTransitions;
+i0.\u0275\u0275ngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: NavigationTransitions, decorators: [{
+  type: import_core.Injectable,
+  args: [{ providedIn: "root" }]
+}], ctorParameters: () => [] });
+function isBrowserTriggeredNavigation(source) {
+  return source !== IMPERATIVE_NAVIGATION;
+}
+const _RouteReuseStrategy = class _RouteReuseStrategy {
+};
+__publicField(_RouteReuseStrategy, "\u0275fac", i0.\u0275\u0275ngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _RouteReuseStrategy, deps: [], target: i0.\u0275\u0275FactoryTarget.Injectable }));
+__publicField(_RouteReuseStrategy, "\u0275prov", i0.\u0275\u0275ngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _RouteReuseStrategy, providedIn: "root", useFactory: () => (0, import_core.inject)(DefaultRouteReuseStrategy) }));
+let RouteReuseStrategy = _RouteReuseStrategy;
+i0.\u0275\u0275ngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: RouteReuseStrategy, decorators: [{
+  type: import_core.Injectable,
+  args: [{ providedIn: "root", useFactory: () => (0, import_core.inject)(DefaultRouteReuseStrategy) }]
+}] });
+class BaseRouteReuseStrategy {
+  /**
+   * Whether the given route should detach for later reuse.
+   * Always returns false for `BaseRouteReuseStrategy`.
+   * */
+  shouldDetach(route) {
+    return false;
+  }
+  /**
+   * A no-op; the route is never stored since this strategy never detaches routes for later re-use.
+   */
+  store(route, detachedTree) {
+  }
+  /** Returns `false`, meaning the route (and its subtree) is never reattached */
+  shouldAttach(route) {
+    return false;
+  }
+  /** Returns `null` because this strategy does not store routes for later re-use. */
+  retrieve(route) {
+    return null;
+  }
+  /**
+   * Determines if a route should be reused.
+   * This strategy returns `true` when the future route config and current route config are
+   * identical.
+   */
+  shouldReuseRoute(future, curr) {
+    return future.routeConfig === curr.routeConfig;
+  }
+}
+const _DefaultRouteReuseStrategy = class _DefaultRouteReuseStrategy extends BaseRouteReuseStrategy {
+};
+__publicField(_DefaultRouteReuseStrategy, "\u0275fac", i0.\u0275\u0275ngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _DefaultRouteReuseStrategy, deps: null, target: i0.\u0275\u0275FactoryTarget.Injectable }));
+__publicField(_DefaultRouteReuseStrategy, "\u0275prov", i0.\u0275\u0275ngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _DefaultRouteReuseStrategy, providedIn: "root" }));
+let DefaultRouteReuseStrategy = _DefaultRouteReuseStrategy;
+i0.\u0275\u0275ngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: DefaultRouteReuseStrategy, decorators: [{
+  type: import_core.Injectable,
+  args: [{ providedIn: "root" }]
+}] });
+const _StateManager = class _StateManager {
+  constructor() {
+    __publicField(this, "urlSerializer", (0, import_core.inject)(UrlSerializer));
+    __publicField(this, "options", (0, import_core.inject)(ROUTER_CONFIGURATION, { optional: true }) || {});
+    __publicField(this, "canceledNavigationResolution", this.options.canceledNavigationResolution || "replace");
+    __publicField(this, "location", (0, import_core.inject)(import_common.Location));
+    __publicField(this, "urlHandlingStrategy", (0, import_core.inject)(UrlHandlingStrategy));
+    __publicField(this, "urlUpdateStrategy", this.options.urlUpdateStrategy || "deferred");
+    __publicField(this, "currentUrlTree", new UrlTree());
+    __publicField(this, "rawUrlTree", this.currentUrlTree);
+    __publicField(this, "routerState", createEmptyState(null));
+    __publicField(this, "stateMemento", this.createStateMemento());
+  }
+  /**
+   * Returns the currently activated `UrlTree`.
+   *
+   * This `UrlTree` shows only URLs that the `Router` is configured to handle (through
+   * `UrlHandlingStrategy`).
+   *
+   * The value is set after finding the route config tree to activate but before activating the
+   * route.
+   */
+  getCurrentUrlTree() {
+    return this.currentUrlTree;
+  }
+  /**
+   * Returns a `UrlTree` that is represents what the browser is actually showing.
+   *
+   * In the life of a navigation transition:
+   * 1. When a navigation begins, the raw `UrlTree` is updated to the full URL that's being
+   * navigated to.
+   * 2. During a navigation, redirects are applied, which might only apply to _part_ of the URL (due
+   * to `UrlHandlingStrategy`).
+   * 3. Just before activation, the raw `UrlTree` is updated to include the redirects on top of the
+   * original raw URL.
+   *
+   * Note that this is _only_ here to support `UrlHandlingStrategy.extract` and
+   * `UrlHandlingStrategy.shouldProcessUrl`. Without those APIs, the current `UrlTree` would not
+   * deviated from the raw `UrlTree`.
+   *
+   * For `extract`, a raw `UrlTree` is needed because `extract` may only return part
+   * of the navigation URL. Thus, the current `UrlTree` may only represent _part_ of the browser
+   * URL. When a navigation gets cancelled and the router needs to reset the URL or a new navigation
+   * occurs, it needs to know the _whole_ browser URL, not just the part handled by
+   * `UrlHandlingStrategy`.
+   * For `shouldProcessUrl`, when the return is `false`, the router ignores the navigation but
+   * still updates the raw `UrlTree` with the assumption that the navigation was caused by the
+   * location change listener due to a URL update by the AngularJS router. In this case, the router
+   * still need to know what the browser's URL is for future navigations.
+   */
+  getRawUrlTree() {
+    return this.rawUrlTree;
+  }
+  createBrowserPath({ finalUrl, initialUrl, targetBrowserUrl }) {
+    const rawUrl = finalUrl !== void 0 ? this.urlHandlingStrategy.merge(finalUrl, initialUrl) : initialUrl;
+    const url = targetBrowserUrl != null ? targetBrowserUrl : rawUrl;
+    const path = url instanceof UrlTree ? this.urlSerializer.serialize(url) : url;
+    return path;
+  }
+  commitTransition({ targetRouterState, finalUrl, initialUrl }) {
+    if (finalUrl && targetRouterState) {
+      this.currentUrlTree = finalUrl;
+      this.rawUrlTree = this.urlHandlingStrategy.merge(finalUrl, initialUrl);
+      this.routerState = targetRouterState;
+    } else {
+      this.rawUrlTree = initialUrl;
+    }
+  }
+  /** Returns the current RouterState. */
+  getRouterState() {
+    return this.routerState;
+  }
+  updateStateMemento() {
+    this.stateMemento = this.createStateMemento();
+  }
+  createStateMemento() {
+    return {
+      rawUrlTree: this.rawUrlTree,
+      currentUrlTree: this.currentUrlTree,
+      routerState: this.routerState
+    };
+  }
+  resetInternalState({ finalUrl }) {
+    this.routerState = this.stateMemento.routerState;
+    this.currentUrlTree = this.stateMemento.currentUrlTree;
+    this.rawUrlTree = this.urlHandlingStrategy.merge(this.currentUrlTree, finalUrl != null ? finalUrl : this.rawUrlTree);
+  }
+};
+__publicField(_StateManager, "\u0275fac", i0.\u0275\u0275ngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _StateManager, deps: [], target: i0.\u0275\u0275FactoryTarget.Injectable }));
+__publicField(_StateManager, "\u0275prov", i0.\u0275\u0275ngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _StateManager, providedIn: "root", useFactory: () => (0, import_core.inject)(HistoryStateManager) }));
+let StateManager = _StateManager;
+i0.\u0275\u0275ngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: StateManager, decorators: [{
+  type: import_core.Injectable,
+  args: [{ providedIn: "root", useFactory: () => (0, import_core.inject)(HistoryStateManager) }]
+}] });
+const _HistoryStateManager = class _HistoryStateManager extends StateManager {
+  constructor() {
+    super(...arguments);
+    /**
+     * The id of the currently active page in the router.
+     * Updated to the transition's target id on a successful navigation.
+     *
+     * This is used to track what page the router last activated. When an attempted navigation fails,
+     * the router can then use this to compute how to restore the state back to the previously active
+     * page.
+     */
+    __publicField(this, "currentPageId", 0);
+    __publicField(this, "lastSuccessfulId", -1);
+  }
+  restoredState() {
+    return this.location.getState();
+  }
+  /**
+   * The ɵrouterPageId of whatever page is currently active in the browser history. This is
+   * important for computing the target page id for new navigations because we need to ensure each
+   * page id in the browser history is 1 more than the previous entry.
+   */
+  get browserPageId() {
+    var _a2, _b2;
+    if (this.canceledNavigationResolution !== "computed") {
+      return this.currentPageId;
+    }
+    return (_b2 = (_a2 = this.restoredState()) == null ? void 0 : _a2.\u0275routerPageId) != null ? _b2 : this.currentPageId;
+  }
+  registerNonRouterCurrentEntryChangeListener(listener) {
+    return this.location.subscribe((event) => {
+      if (event["type"] === "popstate") {
+        setTimeout(() => {
+          listener(event["url"], event.state, "popstate");
+        });
+      }
+    });
+  }
+  handleRouterEvent(e, currentTransition) {
+    if (e instanceof NavigationStart) {
+      this.updateStateMemento();
+    } else if (e instanceof NavigationSkipped) {
+      this.commitTransition(currentTransition);
+    } else if (e instanceof RoutesRecognized) {
+      if (this.urlUpdateStrategy === "eager") {
+        if (!currentTransition.extras.skipLocationChange) {
+          this.setBrowserUrl(this.createBrowserPath(currentTransition), currentTransition);
+        }
+      }
+    } else if (e instanceof BeforeActivateRoutes) {
+      this.commitTransition(currentTransition);
+      if (this.urlUpdateStrategy === "deferred" && !currentTransition.extras.skipLocationChange) {
+        this.setBrowserUrl(this.createBrowserPath(currentTransition), currentTransition);
+      }
+    } else if (e instanceof NavigationCancel && e.code !== NavigationCancellationCode.SupersededByNewNavigation && e.code !== NavigationCancellationCode.Redirect) {
+      this.restoreHistory(currentTransition);
+    } else if (e instanceof NavigationError) {
+      this.restoreHistory(currentTransition, true);
+    } else if (e instanceof NavigationEnd) {
+      this.lastSuccessfulId = e.id;
+      this.currentPageId = this.browserPageId;
+    }
+  }
+  setBrowserUrl(path, { extras, id }) {
+    const { replaceUrl, state } = extras;
+    if (this.location.isCurrentPathEqualTo(path) || !!replaceUrl) {
+      const currentBrowserPageId = this.browserPageId;
+      const newState = __spreadValues(__spreadValues({}, state), this.generateNgRouterState(id, currentBrowserPageId));
+      this.location.replaceState(path, "", newState);
+    } else {
+      const newState = __spreadValues(__spreadValues({}, state), this.generateNgRouterState(id, this.browserPageId + 1));
+      this.location.go(path, "", newState);
+    }
+  }
+  /**
+   * Performs the necessary rollback action to restore the browser URL to the
+   * state before the transition.
+   */
+  restoreHistory(navigation, restoringFromCaughtError = false) {
+    if (this.canceledNavigationResolution === "computed") {
+      const currentBrowserPageId = this.browserPageId;
+      const targetPagePosition = this.currentPageId - currentBrowserPageId;
+      if (targetPagePosition !== 0) {
+        this.location.historyGo(targetPagePosition);
+      } else if (this.getCurrentUrlTree() === navigation.finalUrl && targetPagePosition === 0) {
+        this.resetInternalState(navigation);
+        this.resetUrlToCurrentUrlTree();
+      } else ;
+    } else if (this.canceledNavigationResolution === "replace") {
+      if (restoringFromCaughtError) {
+        this.resetInternalState(navigation);
+      }
+      this.resetUrlToCurrentUrlTree();
+    }
+  }
+  resetUrlToCurrentUrlTree() {
+    this.location.replaceState(this.urlSerializer.serialize(this.getRawUrlTree()), "", this.generateNgRouterState(this.lastSuccessfulId, this.currentPageId));
+  }
+  generateNgRouterState(navigationId, routerPageId) {
+    if (this.canceledNavigationResolution === "computed") {
+      return { navigationId, \u0275routerPageId: routerPageId };
+    }
+    return { navigationId };
+  }
+};
+__publicField(_HistoryStateManager, "\u0275fac", i0.\u0275\u0275ngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _HistoryStateManager, deps: null, target: i0.\u0275\u0275FactoryTarget.Injectable }));
+__publicField(_HistoryStateManager, "\u0275prov", i0.\u0275\u0275ngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _HistoryStateManager, providedIn: "root" }));
+let HistoryStateManager = _HistoryStateManager;
+i0.\u0275\u0275ngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: HistoryStateManager, decorators: [{
+  type: import_core.Injectable,
+  args: [{ providedIn: "root" }]
+}] });
+function afterNextNavigation(router, action) {
+  router.events.pipe((0, import_operators.filter)((e) => e instanceof NavigationEnd || e instanceof NavigationCancel || e instanceof NavigationError || e instanceof NavigationSkipped), (0, import_operators.map)((e) => {
+    if (e instanceof NavigationEnd || e instanceof NavigationSkipped) {
+      return 0;
+    }
+    const redirecting = e instanceof NavigationCancel ? e.code === NavigationCancellationCode.Redirect || e.code === NavigationCancellationCode.SupersededByNewNavigation : false;
+    return redirecting ? 2 : 1;
+  }), (0, import_operators.filter)(
+    (result) => result !== 2
+    /* NavigationResult.REDIRECTING */
+  ), (0, import_operators.take)(1)).subscribe(() => {
+    action();
+  });
+}
+const exactMatchOptions = {
+  paths: "exact",
+  fragment: "ignored",
+  matrixParams: "ignored",
+  queryParams: "exact"
+};
+const subsetMatchOptions = {
+  paths: "subset",
+  fragment: "ignored",
+  matrixParams: "ignored",
+  queryParams: "subset"
+};
+const _Router = class _Router {
+  constructor() {
+    __publicField(this, "disposed", false);
+    __publicField(this, "nonRouterCurrentEntryChangeSubscription");
+    __publicField(this, "console", (0, import_core.inject)(import_core.\u0275Console));
+    __publicField(this, "stateManager", (0, import_core.inject)(StateManager));
+    __publicField(this, "options", (0, import_core.inject)(ROUTER_CONFIGURATION, { optional: true }) || {});
+    __publicField(this, "pendingTasks", (0, import_core.inject)(import_core.\u0275PendingTasksInternal));
+    __publicField(this, "urlUpdateStrategy", this.options.urlUpdateStrategy || "deferred");
+    __publicField(this, "navigationTransitions", (0, import_core.inject)(NavigationTransitions));
+    __publicField(this, "urlSerializer", (0, import_core.inject)(UrlSerializer));
+    __publicField(this, "location", (0, import_core.inject)(import_common.Location));
+    __publicField(this, "urlHandlingStrategy", (0, import_core.inject)(UrlHandlingStrategy));
+    __publicField(this, "injector", (0, import_core.inject)(import_core.EnvironmentInjector));
+    /**
+     * The private `Subject` type for the public events exposed in the getter. This is used internally
+     * to push events to. The separate field allows us to expose separate types in the public API
+     * (i.e., an Observable rather than the Subject).
+     */
+    __publicField(this, "_events", new import_rxjs.Subject());
+    /**
+     * True if at least one navigation event has occurred,
+     * false otherwise.
+     */
+    __publicField(this, "navigated", false);
+    /**
+     * A strategy for re-using routes.
+     *
+     * @deprecated Configure using `providers` instead:
+     *   `{provide: RouteReuseStrategy, useClass: MyStrategy}`.
+     */
+    __publicField(this, "routeReuseStrategy", (0, import_core.inject)(RouteReuseStrategy));
+    /**
+     * How to handle a navigation request to the current URL.
+     *
+     *
+     * @deprecated Configure this through `provideRouter` or `RouterModule.forRoot` instead.
+     * @see {@link withRouterConfig}
+     * @see {@link provideRouter}
+     * @see {@link RouterModule}
+     */
+    __publicField(this, "onSameUrlNavigation", this.options.onSameUrlNavigation || "ignore");
+    __publicField(this, "config", (_b = (_a = (0, import_core.inject)(ROUTES, { optional: true })) == null ? void 0 : _a.flat()) != null ? _b : []);
+    /**
+     * Indicates whether the application has opted in to binding Router data to component inputs.
+     *
+     * This option is enabled by the `withComponentInputBinding` feature of `provideRouter` or
+     * `bindToComponentInputs` in the `ExtraOptions` of `RouterModule.forRoot`.
+     */
+    __publicField(this, "componentInputBindingEnabled", !!(0, import_core.inject)(INPUT_BINDER, { optional: true }));
+    /**
+     * Signal of the current `Navigation` object when the router is navigating, and `null` when idle.
+     *
+     * Note: The current navigation becomes to null after the NavigationEnd event is emitted.
+     */
+    __publicField(this, "currentNavigation", this.navigationTransitions.currentNavigation.asReadonly());
+    __publicField(this, "eventsSubscription", new import_rxjs.Subscription());
+    this.resetConfig(this.config);
+    this.navigationTransitions.setupNavigations(this).subscribe({
+      error: (e) => {
+        this.console.warn(ngDevMode ? `Unhandled Navigation Error: ${e}` : e);
+      }
+    });
+    this.subscribeToNavigationEvents();
+  }
+  get currentUrlTree() {
+    return this.stateManager.getCurrentUrlTree();
+  }
+  get rawUrlTree() {
+    return this.stateManager.getRawUrlTree();
+  }
+  /**
+   * An event stream for routing events.
+   */
+  get events() {
+    return this._events;
+  }
+  /**
+   * The current state of routing in this NgModule.
+   */
+  get routerState() {
+    return this.stateManager.getRouterState();
+  }
+  subscribeToNavigationEvents() {
+    const subscription = this.navigationTransitions.events.subscribe((e) => {
+      try {
+        const currentTransition = this.navigationTransitions.currentTransition;
+        const currentNavigation = (0, import_core.untracked)(this.navigationTransitions.currentNavigation);
+        if (currentTransition !== null && currentNavigation !== null) {
+          this.stateManager.handleRouterEvent(e, currentNavigation);
+          if (e instanceof NavigationCancel && e.code !== NavigationCancellationCode.Redirect && e.code !== NavigationCancellationCode.SupersededByNewNavigation) {
+            this.navigated = true;
+          } else if (e instanceof NavigationEnd) {
+            this.navigated = true;
+          } else if (e instanceof RedirectRequest) {
+            const opts = e.navigationBehaviorOptions;
+            const mergedTree = this.urlHandlingStrategy.merge(e.url, currentTransition.currentRawUrl);
+            const extras = __spreadValues({
+              browserUrl: currentTransition.extras.browserUrl,
+              info: currentTransition.extras.info,
+              skipLocationChange: currentTransition.extras.skipLocationChange,
+              // The URL is already updated at this point if we have 'eager' URL
+              // updates or if the navigation was triggered by the browser (back
+              // button, URL bar, etc). We want to replace that item in history
+              // if the navigation is rejected.
+              replaceUrl: currentTransition.extras.replaceUrl || this.urlUpdateStrategy === "eager" || isBrowserTriggeredNavigation(currentTransition.source)
+            }, opts);
+            this.scheduleNavigation(mergedTree, IMPERATIVE_NAVIGATION, null, extras, {
+              resolve: currentTransition.resolve,
+              reject: currentTransition.reject,
+              promise: currentTransition.promise
+            });
+          }
+        }
+        if (isPublicRouterEvent(e)) {
+          this._events.next(e);
+        }
+      } catch (e2) {
+        this.navigationTransitions.transitionAbortWithErrorSubject.next(e2);
+      }
+    });
+    this.eventsSubscription.add(subscription);
+  }
+  /** @internal */
+  resetRootComponentType(rootComponentType) {
+    this.routerState.root.component = rootComponentType;
+    this.navigationTransitions.rootComponentType = rootComponentType;
+  }
+  /**
+   * Sets up the location change listener and performs the initial navigation.
+   */
+  initialNavigation() {
+    this.setUpLocationChangeListener();
+    if (!this.navigationTransitions.hasRequestedNavigation) {
+      this.navigateToSyncWithBrowser(this.location.path(true), IMPERATIVE_NAVIGATION, this.stateManager.restoredState());
+    }
+  }
+  /**
+   * Sets up the location change listener. This listener detects navigations triggered from outside
+   * the Router (the browser back/forward buttons, for example) and schedules a corresponding Router
+   * navigation so that the correct events, guards, etc. are triggered.
+   */
+  setUpLocationChangeListener() {
+    var _a2;
+    (_a2 = this.nonRouterCurrentEntryChangeSubscription) != null ? _a2 : this.nonRouterCurrentEntryChangeSubscription = this.stateManager.registerNonRouterCurrentEntryChangeListener((url, state, source) => {
+      this.navigateToSyncWithBrowser(url, source, state);
+    });
+  }
+  /**
+   * Schedules a router navigation to synchronize Router state with the browser state.
+   *
+   * This is done as a response to a popstate event and the initial navigation. These
+   * two scenarios represent times when the browser URL/state has been updated and
+   * the Router needs to respond to ensure its internal state matches.
+   */
+  navigateToSyncWithBrowser(url, source, state) {
+    const extras = { replaceUrl: true };
+    const restoredState = (state == null ? void 0 : state.navigationId) ? state : null;
+    if (state) {
+      const stateCopy = __spreadValues({}, state);
+      delete stateCopy.navigationId;
+      delete stateCopy.\u0275routerPageId;
+      if (Object.keys(stateCopy).length !== 0) {
+        extras.state = stateCopy;
+      }
+    }
+    const urlTree = this.parseUrl(url);
+    this.scheduleNavigation(urlTree, source, restoredState, extras).catch((e) => {
+      if (this.disposed) {
+        return;
+      }
+      this.injector.get(import_core.\u0275INTERNAL_APPLICATION_ERROR_HANDLER)(e);
+    });
+  }
+  /** The current URL. */
+  get url() {
+    return this.serializeUrl(this.currentUrlTree);
+  }
+  /**
+   * Returns the current `Navigation` object when the router is navigating,
+   * and `null` when idle.
+   *
+   * @deprecated 20.2 Use the `currentNavigation` signal instead.
+   */
+  getCurrentNavigation() {
+    return (0, import_core.untracked)(this.navigationTransitions.currentNavigation);
+  }
+  /**
+   * The `Navigation` object of the most recent navigation to succeed and `null` if there
+   *     has not been a successful navigation yet.
+   */
+  get lastSuccessfulNavigation() {
+    return this.navigationTransitions.lastSuccessfulNavigation;
+  }
+  /**
+   * Resets the route configuration used for navigation and generating links.
+   *
+   * @param config The route array for the new configuration.
+   *
+   * @usageNotes
+   *
+   * ```ts
+   * router.resetConfig([
+   *  { path: 'team/:id', component: TeamCmp, children: [
+   *    { path: 'simple', component: SimpleCmp },
+   *    { path: 'user/:name', component: UserCmp }
+   *  ]}
+   * ]);
+   * ```
+   */
+  resetConfig(config) {
+    (typeof ngDevMode === "undefined" || ngDevMode) && validateConfig(config);
+    this.config = config.map(standardizeConfig);
+    this.navigated = false;
+  }
+  /** @docs-private */
+  ngOnDestroy() {
+    this.dispose();
+  }
+  /** Disposes of the router. */
+  dispose() {
+    this._events.unsubscribe();
+    this.navigationTransitions.complete();
+    if (this.nonRouterCurrentEntryChangeSubscription) {
+      this.nonRouterCurrentEntryChangeSubscription.unsubscribe();
+      this.nonRouterCurrentEntryChangeSubscription = void 0;
+    }
+    this.disposed = true;
+    this.eventsSubscription.unsubscribe();
+  }
+  /**
+   * Appends URL segments to the current URL tree to create a new URL tree.
+   *
+   * @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 current URL tree or the one provided  in the `relativeTo`
+   * property of the options object, if supplied.
+   * @param navigationExtras Options that control the navigation strategy.
+   * @returns The new URL tree.
+   *
+   * @usageNotes
+   *
+   * ```
+   * // create /team/33/user/11
+   * router.createUrlTree(['/team', 33, 'user', 11]);
+   *
+   * // create /team/33;expand=true/user/11
+   * router.createUrlTree(['/team', 33, {expand: true}, 'user', 11]);
+   *
+   * // you can collapse static segments like this (this works only with the first passed-in value):
+   * router.createUrlTree(['/team/33/user', userId]);
+   *
+   * // If the first segment can contain slashes, and you do not want the router to split it,
+   * // you can do the following:
+   * router.createUrlTree([{segmentPath: '/one/two'}]);
+   *
+   * // create /team/33/(user/11//right:chat)
+   * router.createUrlTree(['/team', 33, {outlets: {primary: 'user/11', right: 'chat'}}]);
+   *
+   * // remove the right secondary node
+   * router.createUrlTree(['/team', 33, {outlets: {primary: 'user/11', right: null}}]);
+   *
+   * // assuming the current url is `/team/33/user/11` and the route points to `user/11`
+   *
+   * // navigate to /team/33/user/11/details
+   * router.createUrlTree(['details'], {relativeTo: route});
+   *
+   * // navigate to /team/33/user/22
+   * router.createUrlTree(['../22'], {relativeTo: route});
+   *
+   * // navigate to /team/44/user/22
+   * router.createUrlTree(['../../team/44/user/22'], {relativeTo: route});
+   *
+   * Note that a value of `null` or `undefined` for `relativeTo` indicates that the
+   * tree should be created relative to the root.
+   * ```
+   */
+  createUrlTree(commands, navigationExtras = {}) {
+    const { relativeTo, queryParams, fragment, queryParamsHandling, preserveFragment } = navigationExtras;
+    const f = preserveFragment ? this.currentUrlTree.fragment : fragment;
+    let q = null;
+    switch (queryParamsHandling != null ? queryParamsHandling : this.options.defaultQueryParamsHandling) {
+      case "merge":
+        q = __spreadValues(__spreadValues({}, this.currentUrlTree.queryParams), queryParams);
+        break;
+      case "preserve":
+        q = this.currentUrlTree.queryParams;
+        break;
+      default:
+        q = queryParams || null;
+    }
+    if (q !== null) {
+      q = this.removeEmptyProps(q);
+    }
+    let relativeToUrlSegmentGroup;
+    try {
+      const relativeToSnapshot = relativeTo ? relativeTo.snapshot : this.routerState.snapshot.root;
+      relativeToUrlSegmentGroup = createSegmentGroupFromRoute(relativeToSnapshot);
+    } catch (e) {
+      if (typeof commands[0] !== "string" || commands[0][0] !== "/") {
+        commands = [];
+      }
+      relativeToUrlSegmentGroup = this.currentUrlTree.root;
+    }
+    return createUrlTreeFromSegmentGroup(relativeToUrlSegmentGroup, commands, q, f != null ? f : null);
+  }
+  /**
+   * Navigates to a view using an absolute route path.
+   *
+   * @param url An absolute path for a defined route. The function does not apply any delta to the
+   *     current URL.
+   * @param extras An object containing properties that modify the navigation strategy.
+   *
+   * @returns A Promise that resolves to 'true' when navigation succeeds,
+   * to 'false' when navigation fails, or is rejected on error.
+   *
+   * @usageNotes
+   *
+   * The following calls request navigation to an absolute path.
+   *
+   * ```ts
+   * router.navigateByUrl("/team/33/user/11");
+   *
+   * // Navigate without updating the URL
+   * router.navigateByUrl("/team/33/user/11", { skipLocationChange: true });
+   * ```
+   *
+   * @see [Routing and Navigation guide](guide/routing/common-router-tasks)
+   *
+   */
+  navigateByUrl(url, extras = {
+    skipLocationChange: false
+  }) {
+    const urlTree = isUrlTree(url) ? url : this.parseUrl(url);
+    const mergedTree = this.urlHandlingStrategy.merge(urlTree, this.rawUrlTree);
+    return this.scheduleNavigation(mergedTree, IMPERATIVE_NAVIGATION, null, extras);
+  }
+  /**
+   * Navigate based on the provided array of commands and a starting point.
+   * If no starting route is provided, the navigation is absolute.
+   *
+   * @param commands An array of URL fragments with which to construct the target URL.
+   * 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 current URL or the one provided  in the `relativeTo` property
+   * of the options object, if supplied.
+   * @param extras An options object that determines how the URL should be constructed or
+   *     interpreted.
+   *
+   * @returns A Promise that resolves to `true` when navigation succeeds, or `false` when navigation
+   *     fails. The Promise is rejected when an error occurs if `resolveNavigationPromiseOnError` is
+   * not `true`.
+   *
+   * @usageNotes
+   *
+   * The following calls request navigation to a dynamic route path relative to the current URL.
+   *
+   * ```ts
+   * router.navigate(['team', 33, 'user', 11], {relativeTo: route});
+   *
+   * // Navigate without updating the URL, overriding the default behavior
+   * router.navigate(['team', 33, 'user', 11], {relativeTo: route, skipLocationChange: true});
+   * ```
+   *
+   * @see [Routing and Navigation guide](guide/routing/common-router-tasks)
+   *
+   */
+  navigate(commands, extras = { skipLocationChange: false }) {
+    validateCommands(commands);
+    return this.navigateByUrl(this.createUrlTree(commands, extras), extras);
+  }
+  /** Serializes a `UrlTree` into a string */
+  serializeUrl(url) {
+    return this.urlSerializer.serialize(url);
+  }
+  /** Parses a string into a `UrlTree` */
+  parseUrl(url) {
+    try {
+      return this.urlSerializer.parse(url);
+    } catch (e) {
+      this.console.warn((0, import_core.\u0275formatRuntimeError)(4018, ngDevMode && `Error parsing URL ${url}. Falling back to '/' instead. 
+` + e));
+      return this.urlSerializer.parse("/");
+    }
+  }
+  isActive(url, matchOptions) {
+    let options;
+    if (matchOptions === true) {
+      options = __spreadValues({}, exactMatchOptions);
+    } else if (matchOptions === false) {
+      options = __spreadValues({}, subsetMatchOptions);
+    } else {
+      options = matchOptions;
+    }
+    if (isUrlTree(url)) {
+      return containsTree(this.currentUrlTree, url, options);
+    }
+    const urlTree = this.parseUrl(url);
+    return containsTree(this.currentUrlTree, urlTree, options);
+  }
+  removeEmptyProps(params) {
+    return Object.entries(params).reduce((result, [key, value]) => {
+      if (value !== null && value !== void 0) {
+        result[key] = value;
+      }
+      return result;
+    }, {});
+  }
+  scheduleNavigation(rawUrl, source, restoredState, extras, priorPromise) {
+    if (this.disposed) {
+      return Promise.resolve(false);
+    }
+    let resolve;
+    let reject;
+    let promise;
+    if (priorPromise) {
+      resolve = priorPromise.resolve;
+      reject = priorPromise.reject;
+      promise = priorPromise.promise;
+    } else {
+      promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+      });
+    }
+    const taskId = this.pendingTasks.add();
+    afterNextNavigation(this, () => {
+      queueMicrotask(() => this.pendingTasks.remove(taskId));
+    });
+    this.navigationTransitions.handleNavigationRequest({
+      source,
+      restoredState,
+      currentUrlTree: this.currentUrlTree,
+      currentRawUrl: this.currentUrlTree,
+      rawUrl,
+      extras,
+      resolve,
+      reject,
+      promise,
+      currentSnapshot: this.routerState.snapshot,
+      currentRouterState: this.routerState
+    });
+    return promise.catch((e) => {
+      return Promise.reject(e);
+    });
+  }
+};
+__publicField(_Router, "\u0275fac", i0.\u0275\u0275ngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _Router, deps: [], target: i0.\u0275\u0275FactoryTarget.Injectable }));
+__publicField(_Router, "\u0275prov", i0.\u0275\u0275ngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: _Router, providedIn: "root" }));
+let Router = _Router;
+i0.\u0275\u0275ngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: Router, decorators: [{
+  type: import_core.Injectable,
+  args: [{ providedIn: "root" }]
+}], ctorParameters: () => [] });
+function validateCommands(commands) {
+  for (let i = 0; i < commands.length; i++) {
+    const cmd = commands[i];
+    if (cmd == null) {
+      throw new import_core.\u0275RuntimeError(4008, (typeof ngDevMode === "undefined" || ngDevMode) && `The requested path contains ${cmd} segment at index ${i}`);
+    }
+  }
+}