init

node_modules/@angular/router/fesm2022/router.mjs

@@ -0,0 +1,87 @@
+/**
+ * @license Angular v20.3.11
+ * (c) 2010-2025 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+
+export { ActivatedRoute, ActivatedRouteSnapshot, ActivationEnd, ActivationStart, BaseRouteReuseStrategy, ChildActivationEnd, ChildActivationStart, ChildrenOutletContexts, DefaultTitleStrategy, DefaultUrlSerializer, EventType, GuardsCheckEnd, GuardsCheckStart, NavigationCancel, NavigationCancellationCode, NavigationEnd, NavigationError, NavigationSkipped, NavigationSkippedCode, NavigationStart, OutletContext, PRIMARY_OUTLET, ROUTER_CONFIGURATION, ROUTER_OUTLET_DATA, ROUTES, RedirectCommand, ResolveEnd, ResolveStart, RouteConfigLoadEnd, RouteConfigLoadStart, RouteReuseStrategy, Router, RouterEvent, RouterOutlet, RouterState, RouterStateSnapshot, RoutesRecognized, Scroll, TitleStrategy, UrlHandlingStrategy, UrlSegment, UrlSegmentGroup, UrlSerializer, UrlTree, convertToParamMap, createUrlTreeFromSnapshot, defaultUrlMatcher, ɵEmptyOutletComponent, afterNextNavigation as ɵafterNextNavigation, loadChildren as ɵloadChildren } from './router2.mjs';
+export { NoPreloading, PreloadAllModules, PreloadingStrategy, ROUTER_INITIALIZER, RouterLink, RouterLinkActive, RouterLink as RouterLinkWithHref, RouterModule, RouterPreloader, provideRouter, provideRoutes, withComponentInputBinding, withDebugTracing, withDisabledInitialNavigation, withEnabledBlockingInitialNavigation, withHashLocation, withInMemoryScrolling, withNavigationErrorHandler, withPreloading, withRouterConfig, withViewTransitions, ROUTER_PROVIDERS as ɵROUTER_PROVIDERS } from './router_module.mjs';
+import { inject, Version } from '@angular/core';
+import '@angular/common';
+import 'rxjs';
+import 'rxjs/operators';
+import '@angular/platform-browser';
+
+/**
+ * Maps an array of injectable classes with canMatch functions to an array of equivalent
+ * `CanMatchFn` for use in a `Route` definition.
+ *
+ * Usage {@example router/utils/functional_guards.ts region='CanActivate'}
+ *
+ * @publicApi
+ * @see {@link Route}
+ */
+function mapToCanMatch(providers) {
+    return providers.map((provider) => (...params) => inject(provider).canMatch(...params));
+}
+/**
+ * Maps an array of injectable classes with canActivate functions to an array of equivalent
+ * `CanActivateFn` for use in a `Route` definition.
+ *
+ * Usage {@example router/utils/functional_guards.ts region='CanActivate'}
+ *
+ * @publicApi
+ * @see {@link Route}
+ */
+function mapToCanActivate(providers) {
+    return providers.map((provider) => (...params) => inject(provider).canActivate(...params));
+}
+/**
+ * Maps an array of injectable classes with canActivateChild functions to an array of equivalent
+ * `CanActivateChildFn` for use in a `Route` definition.
+ *
+ * Usage {@example router/utils/functional_guards.ts region='CanActivate'}
+ *
+ * @publicApi
+ * @see {@link Route}
+ */
+function mapToCanActivateChild(providers) {
+    return providers.map((provider) => (...params) => inject(provider).canActivateChild(...params));
+}
+/**
+ * Maps an array of injectable classes with canDeactivate functions to an array of equivalent
+ * `CanDeactivateFn` for use in a `Route` definition.
+ *
+ * Usage {@example router/utils/functional_guards.ts region='CanActivate'}
+ *
+ * @publicApi
+ * @see {@link Route}
+ */
+function mapToCanDeactivate(providers) {
+    return providers.map((provider) => (...params) => inject(provider).canDeactivate(...params));
+}
+/**
+ * Maps an injectable class with a resolve function to an equivalent `ResolveFn`
+ * for use in a `Route` definition.
+ *
+ * Usage {@example router/utils/functional_guards.ts region='Resolve'}
+ *
+ * @publicApi
+ * @see {@link Route}
+ */
+function mapToResolve(provider) {
+    return (...params) => inject(provider).resolve(...params);
+}
+
+/**
+ * @module
+ * @description
+ * Entry point for all public APIs of the router package.
+ */
+/**
+ * @publicApi
+ */
+const VERSION = /* @__PURE__ */ new Version('20.3.11');
+
+export { VERSION, mapToCanActivate, mapToCanActivateChild, mapToCanDeactivate, mapToCanMatch, mapToResolve };
+//# sourceMappingURL=router.mjs.map

node_modules/@angular/router/fesm2022/router.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.mjs","sources":["../../../../../k8-fastbuild-ST-199a4f3c4e20/bin/packages/router/src/utils/functional_guards.ts","../../../../../k8-fastbuild-ST-199a4f3c4e20/bin/packages/router/src/version.ts"],"sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.dev/license\n */\n\nimport {inject, Type} from '@angular/core';\n\nimport {\n  CanActivate,\n  CanActivateChild,\n  CanActivateChildFn,\n  CanActivateFn,\n  CanDeactivate,\n  CanDeactivateFn,\n  CanMatch,\n  CanMatchFn,\n  Resolve,\n  ResolveFn,\n} from '../models';\n\n/**\n * Maps an array of injectable classes with canMatch functions to an array of equivalent\n * `CanMatchFn` for use in a `Route` definition.\n *\n * Usage {@example router/utils/functional_guards.ts region='CanActivate'}\n *\n * @publicApi\n * @see {@link Route}\n */\nexport function mapToCanMatch(providers: Array<Type<CanMatch>>): CanMatchFn[] {\n  return providers.map(\n    (provider) =>\n      (...params) =>\n        inject(provider).canMatch(...params),\n  );\n}\n\n/**\n * Maps an array of injectable classes with canActivate functions to an array of equivalent\n * `CanActivateFn` for use in a `Route` definition.\n *\n * Usage {@example router/utils/functional_guards.ts region='CanActivate'}\n *\n * @publicApi\n * @see {@link Route}\n */\nexport function mapToCanActivate(providers: Array<Type<CanActivate>>): CanActivateFn[] {\n  return providers.map(\n    (provider) =>\n      (...params) =>\n        inject(provider).canActivate(...params),\n  );\n}\n/**\n * Maps an array of injectable classes with canActivateChild functions to an array of equivalent\n * `CanActivateChildFn` for use in a `Route` definition.\n *\n * Usage {@example router/utils/functional_guards.ts region='CanActivate'}\n *\n * @publicApi\n * @see {@link Route}\n */\nexport function mapToCanActivateChild(\n  providers: Array<Type<CanActivateChild>>,\n): CanActivateChildFn[] {\n  return providers.map(\n    (provider) =>\n      (...params) =>\n        inject(provider).canActivateChild(...params),\n  );\n}\n/**\n * Maps an array of injectable classes with canDeactivate functions to an array of equivalent\n * `CanDeactivateFn` for use in a `Route` definition.\n *\n * Usage {@example router/utils/functional_guards.ts region='CanActivate'}\n *\n * @publicApi\n * @see {@link Route}\n */\nexport function mapToCanDeactivate<T = unknown>(\n  providers: Array<Type<CanDeactivate<T>>>,\n): CanDeactivateFn<T>[] {\n  return providers.map(\n    (provider) =>\n      (...params) =>\n        inject(provider).canDeactivate(...params),\n  );\n}\n/**\n * Maps an injectable class with a resolve function to an equivalent `ResolveFn`\n * for use in a `Route` definition.\n *\n * Usage {@example router/utils/functional_guards.ts region='Resolve'}\n *\n * @publicApi\n * @see {@link Route}\n */\nexport function mapToResolve<T>(provider: Type<Resolve<T>>): ResolveFn<T> {\n  return (...params) => inject(provider).resolve(...params);\n}\n","/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.dev/license\n */\n\n/**\n * @module\n * @description\n * Entry point for all public APIs of the router package.\n */\n\nimport {Version} from '@angular/core';\n\n/**\n * @publicApi\n */\nexport const VERSION = /* @__PURE__ */ new Version('20.3.11');\n"],"names":[],"mappings":";;;;;;;;;;;;;;AAuBA;;;;;;;;AAQG;AACG,SAAU,aAAa,CAAC,SAAgC,EAAA;IAC5D,OAAO,SAAS,CAAC,GAAG,CAClB,CAAC,QAAQ,KACP,CAAC,GAAG,MAAM,KACR,MAAM,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,GAAG,MAAM,CAAC,CACzC;AACH;AAEA;;;;;;;;AAQG;AACG,SAAU,gBAAgB,CAAC,SAAmC,EAAA;IAClE,OAAO,SAAS,CAAC,GAAG,CAClB,CAAC,QAAQ,KACP,CAAC,GAAG,MAAM,KACR,MAAM,CAAC,QAAQ,CAAC,CAAC,WAAW,CAAC,GAAG,MAAM,CAAC,CAC5C;AACH;AACA;;;;;;;;AAQG;AACG,SAAU,qBAAqB,CACnC,SAAwC,EAAA;IAExC,OAAO,SAAS,CAAC,GAAG,CAClB,CAAC,QAAQ,KACP,CAAC,GAAG,MAAM,KACR,MAAM,CAAC,QAAQ,CAAC,CAAC,gBAAgB,CAAC,GAAG,MAAM,CAAC,CACjD;AACH;AACA;;;;;;;;AAQG;AACG,SAAU,kBAAkB,CAChC,SAAwC,EAAA;IAExC,OAAO,SAAS,CAAC,GAAG,CAClB,CAAC,QAAQ,KACP,CAAC,GAAG,MAAM,KACR,MAAM,CAAC,QAAQ,CAAC,CAAC,aAAa,CAAC,GAAG,MAAM,CAAC,CAC9C;AACH;AACA;;;;;;;;AAQG;AACG,SAAU,YAAY,CAAI,QAA0B,EAAA;AACxD,IAAA,OAAO,CAAC,GAAG,MAAM,KAAK,MAAM,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,GAAG,MAAM,CAAC;AAC3D;;AC/FA;;;;AAIG;AAIH;;AAEG;AACU,MAAA,OAAO,mBAAmB,IAAI,OAAO,CAAC,mBAAmB;;;;"}

node_modules/@angular/router/fesm2022/testing.mjs

@@ -0,0 +1,203 @@
+/**
+ * @license Angular v20.3.11
+ * (c) 2010-2025 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+
+import * as i0 from '@angular/core';
+import { NgModule, Injectable, signal, Component, ViewChild } from '@angular/core';
+import { TestBed } from '@angular/core/testing';
+import { ROUTES, ROUTER_CONFIGURATION, RouterOutlet, Router, afterNextNavigation } from './router2.mjs';
+export { ɵEmptyOutletComponent as ɵɵEmptyOutletComponent } from './router2.mjs';
+import { RouterModule, ROUTER_PROVIDERS, withPreloading, NoPreloading } from './router_module.mjs';
+export { RouterLink as ɵɵRouterLink, RouterLinkActive as ɵɵRouterLinkActive } from './router_module.mjs';
+import { provideLocationMocks } from '@angular/common/testing';
+import '@angular/common';
+import 'rxjs';
+import 'rxjs/operators';
+import '@angular/platform-browser';
+
+/**
+ * @description
+ *
+ * Sets up the router to be used for testing.
+ *
+ * The modules sets up the router to be used for testing.
+ * It provides spy implementations of `Location` and `LocationStrategy`.
+ *
+ * @usageNotes
+ * ### Example
+ *
+ * ```ts
+ * beforeEach(() => {
+ *   TestBed.configureTestingModule({
+ *     imports: [
+ *       RouterModule.forRoot(
+ *         [{path: '', component: BlankCmp}, {path: 'simple', component: SimpleCmp}]
+ *       )
+ *     ]
+ *   });
+ * });
+ * ```
+ *
+ * @publicApi
+ * @deprecated Use `provideRouter` or `RouterModule`/`RouterModule.forRoot` instead.
+ * This module was previously used to provide a helpful collection of test fakes,
+ * most notably those for `Location` and `LocationStrategy`.  These are generally not
+ * required anymore, as `MockPlatformLocation` is provided in `TestBed` by default.
+ * However, you can use them directly with `provideLocationMocks`.
+ */
+class RouterTestingModule {
+    static withRoutes(routes, config) {
+        return {
+            ngModule: RouterTestingModule,
+            providers: [
+                { provide: ROUTES, multi: true, useValue: routes },
+                { provide: ROUTER_CONFIGURATION, useValue: config ? config : {} },
+            ],
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: RouterTestingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.11", ngImport: i0, type: RouterTestingModule, exports: [RouterModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: RouterTestingModule, providers: [
+            ROUTER_PROVIDERS,
+            provideLocationMocks(),
+            withPreloading(NoPreloading).ɵproviders,
+            { provide: ROUTES, multi: true, useValue: [] },
+        ], imports: [RouterModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: RouterTestingModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    exports: [RouterModule],
+                    providers: [
+                        ROUTER_PROVIDERS,
+                        provideLocationMocks(),
+                        withPreloading(NoPreloading).ɵproviders,
+                        { provide: ROUTES, multi: true, useValue: [] },
+                    ],
+                }]
+        }] });
+
+class RootFixtureService {
+    fixture;
+    harness;
+    createHarness() {
+        if (this.harness) {
+            throw new Error('Only one harness should be created per test.');
+        }
+        this.harness = new RouterTestingHarness(this.getRootFixture());
+        return this.harness;
+    }
+    getRootFixture() {
+        if (this.fixture !== undefined) {
+            return this.fixture;
+        }
+        this.fixture = TestBed.createComponent(RootCmp);
+        this.fixture.detectChanges();
+        return this.fixture;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: RootFixtureService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: RootFixtureService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: RootFixtureService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+class RootCmp {
+    outlet;
+    routerOutletData = signal(undefined, ...(ngDevMode ? [{ debugName: "routerOutletData" }] : []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: RootCmp, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.11", type: RootCmp, isStandalone: true, selector: "ng-component", viewQueries: [{ propertyName: "outlet", first: true, predicate: RouterOutlet, descendants: true }], ngImport: i0, template: '<router-outlet [routerOutletData]="routerOutletData()"></router-outlet>', isInline: true, dependencies: [{ kind: "directive", type: RouterOutlet, selector: "router-outlet", inputs: ["name", "routerOutletData"], outputs: ["activate", "deactivate", "attach", "detach"], exportAs: ["outlet"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: RootCmp, decorators: [{
+            type: Component,
+            args: [{
+                    template: '<router-outlet [routerOutletData]="routerOutletData()"></router-outlet>',
+                    imports: [RouterOutlet],
+                }]
+        }], propDecorators: { outlet: [{
+                type: ViewChild,
+                args: [RouterOutlet]
+            }] } });
+/**
+ * A testing harness for the `Router` to reduce the boilerplate needed to test routes and routed
+ * components.
+ *
+ * @publicApi
+ */
+class RouterTestingHarness {
+    /**
+     * Creates a `RouterTestingHarness` instance.
+     *
+     * The `RouterTestingHarness` also creates its own root component with a `RouterOutlet` for the
+     * purposes of rendering route components.
+     *
+     * Throws an error if an instance has already been created.
+     * Use of this harness also requires `destroyAfterEach: true` in the `ModuleTeardownOptions`
+     *
+     * @param initialUrl The target of navigation to trigger before returning the harness.
+     */
+    static async create(initialUrl) {
+        const harness = TestBed.inject(RootFixtureService).createHarness();
+        if (initialUrl !== undefined) {
+            await harness.navigateByUrl(initialUrl);
+        }
+        return harness;
+    }
+    /**
+     * Fixture of the root component of the RouterTestingHarness
+     */
+    fixture;
+    /** @internal */
+    constructor(fixture) {
+        this.fixture = fixture;
+    }
+    /** Instructs the root fixture to run change detection. */
+    detectChanges() {
+        this.fixture.detectChanges();
+    }
+    /** The `DebugElement` of the `RouterOutlet` component. `null` if the outlet is not activated. */
+    get routeDebugElement() {
+        const outlet = this.fixture.componentInstance.outlet;
+        if (!outlet || !outlet.isActivated) {
+            return null;
+        }
+        return this.fixture.debugElement.query((v) => v.componentInstance === outlet.component);
+    }
+    /** The native element of the `RouterOutlet` component. `null` if the outlet is not activated. */
+    get routeNativeElement() {
+        return this.routeDebugElement?.nativeElement ?? null;
+    }
+    async navigateByUrl(url, requiredRoutedComponentType) {
+        const router = TestBed.inject(Router);
+        let resolveFn;
+        const redirectTrackingPromise = new Promise((resolve) => {
+            resolveFn = resolve;
+        });
+        afterNextNavigation(TestBed.inject(Router), resolveFn);
+        await router.navigateByUrl(url);
+        await redirectTrackingPromise;
+        this.fixture.detectChanges();
+        const outlet = this.fixture.componentInstance.outlet;
+        // The outlet might not be activated if the user is testing a navigation for a guard that
+        // rejects
+        if (outlet && outlet.isActivated && outlet.activatedRoute.component) {
+            const activatedComponent = outlet.component;
+            if (requiredRoutedComponentType !== undefined &&
+                !(activatedComponent instanceof requiredRoutedComponentType)) {
+                throw new Error(`Unexpected routed component type. Expected ${requiredRoutedComponentType.name} but got ${activatedComponent.constructor.name}`);
+            }
+            return activatedComponent;
+        }
+        else {
+            if (requiredRoutedComponentType !== undefined) {
+                throw new Error(`Unexpected routed component type. Expected ${requiredRoutedComponentType.name} but the navigation did not activate any component.`);
+            }
+            return null;
+        }
+    }
+}
+
+export { RouterTestingHarness, RouterTestingModule, RouterOutlet as ɵɵRouterOutlet };
+//# sourceMappingURL=testing.mjs.map

node_modules/@angular/router/fesm2022/upgrade.mjs

@@ -0,0 +1,141 @@
+/**
+ * @license Angular v20.3.11
+ * (c) 2010-2025 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+
+import { Location } from '@angular/common';
+import { APP_BOOTSTRAP_LISTENER } from '@angular/core';
+import { UpgradeModule } from '@angular/upgrade/static';
+import { Router } from './router2.mjs';
+import 'rxjs';
+import 'rxjs/operators';
+import '@angular/platform-browser';
+
+/**
+ * Creates an initializer that sets up `ngRoute` integration
+ * along with setting up the Angular router.
+ *
+ * @usageNotes
+ *
+ * For standalone applications:
+ * ```ts
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [RouterUpgradeInitializer],
+ * };
+ * ```
+ *
+ * For NgModule based applications:
+ * ```ts
+ * @NgModule({
+ *  imports: [
+ *   RouterModule.forRoot(SOME_ROUTES),
+ *   UpgradeModule
+ * ],
+ * providers: [
+ *   RouterUpgradeInitializer
+ * ]
+ * })
+ * export class AppModule {
+ *   ngDoBootstrap() {}
+ * }
+ * ```
+ *
+ * @publicApi
+ */
+const RouterUpgradeInitializer = {
+    provide: APP_BOOTSTRAP_LISTENER,
+    multi: true,
+    useFactory: locationSyncBootstrapListener,
+    deps: [UpgradeModule],
+};
+/**
+ * @internal
+ */
+function locationSyncBootstrapListener(ngUpgrade) {
+    return () => {
+        setUpLocationSync(ngUpgrade);
+    };
+}
+/**
+ * Sets up a location change listener to trigger `history.pushState`.
+ * Works around the problem that `onPopState` does not trigger `history.pushState`.
+ * Must be called *after* calling `UpgradeModule.bootstrap`.
+ *
+ * @param ngUpgrade The upgrade NgModule.
+ * @param urlType The location strategy.
+ * @see {@link /api/common/HashLocationStrategy HashLocationStrategy}
+ * @see {@link /api/common/PathLocationStrategy PathLocationStrategy}
+ *
+ * @publicApi
+ */
+function setUpLocationSync(ngUpgrade, urlType = 'path') {
+    if (!ngUpgrade.$injector) {
+        throw new Error(`
+        RouterUpgradeInitializer can be used only after UpgradeModule.bootstrap has been called.
+        Remove RouterUpgradeInitializer and call setUpLocationSync after UpgradeModule.bootstrap.
+      `);
+    }
+    const router = ngUpgrade.injector.get(Router);
+    const location = ngUpgrade.injector.get(Location);
+    ngUpgrade.$injector
+        .get('$rootScope')
+        .$on('$locationChangeStart', (event, newUrl, oldUrl, newState, oldState) => {
+        // Navigations coming from Angular router have a navigationId state
+        // property. Don't trigger Angular router navigation again if it is
+        // caused by a URL change from the current Angular router
+        // navigation.
+        const currentNavigationId = router.getCurrentNavigation()?.id;
+        const newStateNavigationId = newState?.navigationId;
+        if (newStateNavigationId !== undefined && newStateNavigationId === currentNavigationId) {
+            return;
+        }
+        let url;
+        if (urlType === 'path') {
+            url = resolveUrl(newUrl);
+        }
+        else if (urlType === 'hash') {
+            // Remove the first hash from the URL
+            const hashIdx = newUrl.indexOf('#');
+            url = resolveUrl(newUrl.substring(0, hashIdx) + newUrl.substring(hashIdx + 1));
+        }
+        else {
+            throw 'Invalid URLType passed to setUpLocationSync: ' + urlType;
+        }
+        const path = location.normalize(url.pathname);
+        router.navigateByUrl(path + url.search + url.hash);
+    });
+}
+/**
+ * Normalizes and parses a URL.
+ *
+ * - Normalizing means that a relative URL will be resolved into an absolute URL in the context of
+ *   the application document.
+ * - Parsing means that the anchor's `protocol`, `hostname`, `port`, `pathname` and related
+ *   properties are all populated to reflect the normalized URL.
+ *
+ * While this approach has wide compatibility, it doesn't work as expected on IE. On IE, normalizing
+ * happens similar to other browsers, but the parsed components will not be set. (E.g. if you assign
+ * `a.href = 'foo'`, then `a.protocol`, `a.host`, etc. will not be correctly updated.)
+ * We work around that by performing the parsing in a 2nd step by taking a previously normalized URL
+ * and assigning it again. This correctly populates all properties.
+ *
+ * See
+ * https://github.com/angular/angular.js/blob/2c7400e7d07b0f6cec1817dab40b9250ce8ebce6/src/ng/urlUtils.js#L26-L33
+ * for more info.
+ */
+let anchor;
+function resolveUrl(url) {
+    anchor ??= document.createElement('a');
+    anchor.setAttribute('href', url);
+    anchor.setAttribute('href', anchor.href);
+    return {
+        // IE does not start `pathname` with `/` like other browsers.
+        pathname: `/${anchor.pathname.replace(/^\//, '')}`,
+        search: anchor.search,
+        hash: anchor.hash,
+    };
+}
+
+export { RouterUpgradeInitializer, locationSyncBootstrapListener, setUpLocationSync };
+//# sourceMappingURL=upgrade.mjs.map