@loozo/angular-router 0.0.2 → 0.0.3

package/fesm2022/loozo-angular-router-_generated.mjs

@@ -1,658 +1,533 @@
-import { inject, Injector, runInInjectionContext, DestroyRef, PendingTasks, signal, resourceFromSnapshots } from '@angular/core';
-import { Router, ActivatedRoute, NavigationStart, NavigationEnd, NavigationCancel, NavigationCancellationCode, NavigationSkipped, NavigationError } from '@angular/router';
-import { Observable, isObservable, from } from 'rxjs';
-import { routeMetadata, codecPresence, createUrl } from '@loozo/angular-router/_core';
-
+import { DestroyRef, Injector, PendingTasks, inject, resourceFromSnapshots, runInInjectionContext, signal } from "@angular/core";
+import { ActivatedRoute, NavigationCancel, NavigationCancellationCode, NavigationEnd, NavigationError, NavigationSkipped, NavigationStart, Router } from "@angular/router";
+import { Observable, from, isObservable } from "rxjs";
+import { codecPresence, createUrl, routeMetadata } from "@loozo/angular-router/_core";
 function hasIdentity(snapshot, id) {
-    const data = snapshot.routeConfig?.data;
-    return (!!data &&
-        Object.hasOwn(data, "__loozoAngularRouterRouteId") &&
-        data.__loozoAngularRouterRouteId === id);
+	const data = snapshot.routeConfig?.data;
+	return !!data && Object.hasOwn(data, "__loozoAngularRouterRouteId") && data.__loozoAngularRouterRouteId === id;
 }
 function assertIdentity(snapshot, id) {
-    if (!hasIdentity(snapshot, id)) {
-        throw new Error(`Generated route wiring identity mismatch: ${id}`);
-    }
+	if (!hasIdentity(snapshot, id)) throw new Error(`Generated route wiring identity mismatch: ${id}`);
 }
 function inputError(source, key, reason, cause) {
-    return Object.assign(new Error(`Invalid ${source} input ${key}: ${reason}`, { cause }), {
-        source,
-        key,
-        reason,
-    });
+	return Object.assign(new Error(`Invalid ${source} input ${key}: ${reason}`, { cause }), {
+		source,
+		key,
+		reason
+	});
 }
 function validateRaw(source, key, raws, array) {
-    if (!array && raws.length === 0) {
-        throw inputError(source, key, "missing");
-    }
-    if (!array && raws.length > 1) {
-        throw inputError(source, key, "repeated");
-    }
-    if (raws.some((raw) => typeof raw !== "string")) {
-        throw inputError(source, key, "invalid", new TypeError("Raw input must be a decoded string"));
-    }
+	if (!array && raws.length === 0) throw inputError(source, key, "missing");
+	if (!array && raws.length > 1) throw inputError(source, key, "repeated");
+	if (raws.some((raw) => typeof raw !== "string")) throw inputError(source, key, "invalid", /* @__PURE__ */ new TypeError("Raw input must be a decoded string"));
 }
 function pathJobs(definition, url) {
-    const metadata = routeMetadata(definition);
-    const local = new Map();
-    for (let index = 0; index < metadata.localSegments.length; index += 1) {
-        const segment = metadata.localSegments[index];
-        if (segment.kind === "static") {
-            continue;
-        }
-        let raws = [];
-        const array = segment.kind === "catchall";
-        if (array) {
-            raws = url.slice(index).map((value) => value.path);
-        }
-        else if (index < url.length) {
-            raws = [url[index].path];
-        }
-        validateRaw("path", segment.name, raws, array);
-        // Repeated local scalars intentionally use Angular's last positional occurrence.
-        local.set(segment.name, {
-            source: "path",
-            key: segment.name,
-            raws,
-            array,
-            codec: metadata.localParams[segment.name],
-        });
-    }
-    return [...local.values()];
+	const metadata = routeMetadata(definition);
+	const local = /* @__PURE__ */ new Map();
+	for (let index = 0; index < metadata.localSegments.length; index += 1) {
+		const segment = metadata.localSegments[index];
+		if (segment.kind === "static") continue;
+		let raws = [];
+		const array = segment.kind === "catchall";
+		if (array) raws = url.slice(index).map((value) => value.path);
+		else if (index < url.length) raws = [url[index].path];
+		validateRaw("path", segment.name, raws, array);
+		local.set(segment.name, {
+			source: "path",
+			key: segment.name,
+			raws,
+			array,
+			codec: metadata.localParams[segment.name]
+		});
+	}
+	return [...local.values()];
 }
 function searchJobs(definition, snapshot) {
-    const metadata = routeMetadata(definition);
-    const jobs = [];
-    for (const key of Object.keys(metadata.search)) {
-        const codec = metadata.search[key];
-        const raws = snapshot.queryParamMap.getAll(key);
-        if (raws.length === 0 && codecPresence(codec) === "optional") {
-            continue;
-        }
-        validateRaw("search", key, raws, false);
-        jobs.push({ source: "search", key, raws, array: false, codec });
-    }
-    return jobs;
+	const metadata = routeMetadata(definition);
+	const jobs = [];
+	for (const key of Object.keys(metadata.search)) {
+		const codec = metadata.search[key];
+		const raws = snapshot.queryParamMap.getAll(key);
+		if (raws.length === 0 && codecPresence(codec) === "optional") continue;
+		validateRaw("search", key, raws, false);
+		jobs.push({
+			source: "search",
+			key,
+			raws,
+			array: false,
+			codec
+		});
+	}
+	return jobs;
 }
 async function runJobs(jobs) {
-    const params = Object.create(null);
-    const search = Object.create(null);
-    const pending = [];
-    for (const job of jobs) {
-        // Async boundaries convert every synchronous throw into an observed rejection.
-        pending.push((async () => {
-            try {
-                const elements = [];
-                for (const raw of job.raws) {
-                    elements.push((async () => job.codec.parse(raw))());
-                }
-                const values = await Promise.all(elements);
-                let value = values[0];
-                if (job.array) {
-                    value = Object.freeze(values);
-                }
-                if (job.source === "path") {
-                    params[job.key] = value;
-                }
-                else {
-                    search[job.key] = value;
-                }
-            }
-            catch (cause) {
-                throw inputError(job.source, job.key, "invalid", cause);
-            }
-        })());
-    }
-    await Promise.all(pending);
-    return Object.freeze({ params: Object.freeze(params), search: Object.freeze(search) });
+	const params = Object.create(null);
+	const search = Object.create(null);
+	const pending = [];
+	for (const job of jobs) pending.push((async () => {
+		try {
+			const elements = [];
+			for (const raw of job.raws) elements.push((async () => job.codec.parse(raw))());
+			const values = await Promise.all(elements);
+			let value = values[0];
+			if (job.array) value = Object.freeze(values);
+			if (job.source === "path") params[job.key] = value;
+			else search[job.key] = value;
+		} catch (cause) {
+			throw inputError(job.source, job.key, "invalid", cause);
+		}
+	})());
+	await Promise.all(pending);
+	return Object.freeze({
+		params: Object.freeze(params),
+		search: Object.freeze(search)
+	});
 }
-const full = new WeakMap();
-const matching = new WeakMap();
+const full = /* @__PURE__ */ new WeakMap();
+const matching = /* @__PURE__ */ new WeakMap();
 function operation(cache, definition, snapshot, collect) {
-    let snapshots = cache.get(definition);
-    if (!snapshots) {
-        snapshots = new WeakMap();
-        cache.set(definition, snapshots);
-    }
-    const existing = snapshots.get(snapshot);
-    if (existing) {
-        return existing;
-    }
-    // Insert before application code can run; even synchronous reentry joins the same operation.
-    const result = {
-        promise: Promise.resolve().then(() => runJobs(collect())),
-        outcome: undefined,
-    };
-    snapshots.set(snapshot, result);
-    result.promise.then((value) => {
-        result.outcome = { value };
-    }, (cause) => {
-        let error = cause;
-        if (!(error instanceof Error)) {
-            error = new Error("Route input failure", { cause });
-        }
-        result.outcome = { error };
-    });
-    return result;
+	let snapshots = cache.get(definition);
+	if (!snapshots) {
+		snapshots = /* @__PURE__ */ new WeakMap();
+		cache.set(definition, snapshots);
+	}
+	const existing = snapshots.get(snapshot);
+	if (existing) return existing;
+	const result = {
+		promise: Promise.resolve().then(() => runJobs(collect())),
+		outcome: void 0
+	};
+	snapshots.set(snapshot, result);
+	result.promise.then((value) => {
+		result.outcome = { value };
+	}, (cause) => {
+		let error = cause;
+		if (!(error instanceof Error)) error = new Error("Route input failure", { cause });
+		result.outcome = { error };
+	});
+	return result;
 }
 function fullOperation(set, id, snapshot) {
-    assertIdentity(snapshot, id);
-    const binding = set.records[id];
-    return operation(full, binding.definition(), snapshot, () => {
-        const jobs = [];
-        for (const ownerId of binding.owners) {
-            const definition = set.records[ownerId].definition();
-            // Pathless/static owners contribute no positional input. Effective search belongs
-            // to this complete future record; inherited data is never positional authority.
-            if (!routeMetadata(definition).localSegments.some((segment) => segment.kind !== "static")) {
-                continue;
-            }
-            const owner = [...snapshot.pathFromRoot]
-                .reverse()
-                .find((record) => hasIdentity(record, ownerId));
-            if (!owner) {
-                throw new Error(`Generated route ancestor missing: ${ownerId}`);
-            }
-            assertIdentity(owner, ownerId);
-            jobs.push(...pathJobs(definition, owner.url));
-        }
-        jobs.push(...searchJobs(binding.definition(), snapshot));
-        return jobs;
-    });
+	assertIdentity(snapshot, id);
+	const binding = set.records[id];
+	return operation(full, binding.definition(), snapshot, () => {
+		const jobs = [];
+		for (const ownerId of binding.owners) {
+			const definition = set.records[ownerId].definition();
+			if (!routeMetadata(definition).localSegments.some((segment) => segment.kind !== "static")) continue;
+			const owner = [...snapshot.pathFromRoot].reverse().find((record) => hasIdentity(record, ownerId));
+			if (!owner) throw new Error(`Generated route ancestor missing: ${ownerId}`);
+			assertIdentity(owner, ownerId);
+			jobs.push(...pathJobs(definition, owner.url));
+		}
+		jobs.push(...searchJobs(binding.definition(), snapshot));
+		return jobs;
+	});
 }
 function parseInputs(set, id, snapshot) {
-    return fullOperation(set, id, snapshot).promise;
+	return fullOperation(set, id, snapshot).promise;
 }
 function matchingInputs(set, id, snapshot) {
-    assertIdentity(snapshot, id);
-    const definition = set.records[id].definition();
-    return operation(matching, definition, snapshot, () => [
-        ...pathJobs(definition, snapshot.url),
-        ...searchJobs(definition, snapshot),
-    ]).promise;
+	assertIdentity(snapshot, id);
+	const definition = set.records[id].definition();
+	return operation(matching, definition, snapshot, () => [...pathJobs(definition, snapshot.url), ...searchJobs(definition, snapshot)]).promise;
 }
-
 function isPromiseResult(value) {
-    return !!value && typeof value.then === "function";
+	return !!value && typeof value.then === "function";
 }
 function bridge(inputs, callback) {
-    const injector = inject(Injector);
-    return new Observable((subscriber) => {
-        let subscription;
-        inputs().then((value) => {
-            if (subscriber.closed) {
-                return;
-            }
-            try {
-                const result = runInInjectionContext(injector, () => callback(value));
-                if (isObservable(result)) {
-                    subscription = result.subscribe(subscriber);
-                }
-                else if (isPromiseResult(result)) {
-                    subscription = from(Promise.resolve(result)).subscribe(subscriber);
-                }
-                else {
-                    subscriber.next(result);
-                    subscriber.complete();
-                }
-            }
-            catch (error) {
-                subscriber.error(error);
-            }
-        }, (error) => subscriber.error(error));
-        return () => subscription?.unsubscribe();
-    });
+	const injector = inject(Injector);
+	return new Observable((subscriber) => {
+		let subscription;
+		inputs().then((value) => {
+			if (subscriber.closed) return;
+			try {
+				const result = runInInjectionContext(injector, () => callback(value));
+				if (isObservable(result)) subscription = result.subscribe(subscriber);
+				else if (isPromiseResult(result)) subscription = from(Promise.resolve(result)).subscribe(subscriber);
+				else {
+					subscriber.next(result);
+					subscriber.complete();
+				}
+			} catch (error) {
+				subscriber.error(error);
+			}
+		}, (error) => subscriber.error(error));
+		return () => subscription?.unsubscribe();
+	});
 }
 function callbacks(set, id) {
-    const config = routeMetadata(set.records[id].definition()).config;
-    const result = {};
-    const activate = config.canActivate;
-    if (activate) {
-        result.canActivate = activate.map((callback) => (snapshot, state) => {
-            assertIdentity(snapshot, id);
-            return bridge(() => parseInputs(set, id, snapshot), (inputs) => callback(inputs, snapshot, state));
-        });
-    }
-    const children = config.canActivateChild;
-    if (children) {
-        result.canActivateChild = children.map((callback) => (child, state) => {
-            let parent;
-            // The native ancestry includes child itself; only proper ancestors can declare this guard.
-            for (let index = child.pathFromRoot.length - 2; index >= 0; index -= 1) {
-                const ancestor = child.pathFromRoot[index];
-                if (hasIdentity(ancestor, id)) {
-                    parent = ancestor;
-                    break;
-                }
-            }
-            if (!parent) {
-                throw new Error(`Generated guard ancestor missing: ${id}`);
-            }
-            assertIdentity(parent, id);
-            return bridge(() => parseInputs(set, id, parent), (inputs) => callback(inputs, child, state));
-        });
-    }
-    const matching = config.canMatch;
-    if (matching) {
-        result.canMatch = matching.map((callback) => (route, segments, snapshot) => {
-            assertIdentity(snapshot, id);
-            return bridge(() => matchingInputs(set, id, snapshot), (inputs) => callback(inputs, route, segments, snapshot));
-        });
-    }
-    const resolvers = config.resolve;
-    if (resolvers) {
-        const resolve = Object.create(null);
-        for (const key of Reflect.ownKeys(resolvers)) {
-            resolve[key] = (snapshot, state) => {
-                assertIdentity(snapshot, id);
-                return bridge(() => parseInputs(set, id, snapshot), (inputs) => resolvers[key](inputs, snapshot, state));
-            };
-        }
-        result.resolve = resolve;
-    }
-    return result;
+	const config = routeMetadata(set.records[id].definition()).config;
+	const result = {};
+	const activate = config.canActivate;
+	if (activate) result.canActivate = activate.map((callback) => (snapshot, state) => {
+		assertIdentity(snapshot, id);
+		return bridge(() => parseInputs(set, id, snapshot), (inputs) => callback(inputs, snapshot, state));
+	});
+	const children = config.canActivateChild;
+	if (children) result.canActivateChild = children.map((callback) => (child, state) => {
+		let parent;
+		for (let index = child.pathFromRoot.length - 2; index >= 0; index -= 1) {
+			const ancestor = child.pathFromRoot[index];
+			if (hasIdentity(ancestor, id)) {
+				parent = ancestor;
+				break;
+			}
+		}
+		if (!parent) throw new Error(`Generated guard ancestor missing: ${id}`);
+		assertIdentity(parent, id);
+		return bridge(() => parseInputs(set, id, parent), (inputs) => callback(inputs, child, state));
+	});
+	const matching = config.canMatch;
+	if (matching) result.canMatch = matching.map((callback) => (route, segments, snapshot) => {
+		assertIdentity(snapshot, id);
+		return bridge(() => matchingInputs(set, id, snapshot), (inputs) => callback(inputs, route, segments, snapshot));
+	});
+	const resolvers = config.resolve;
+	if (resolvers) {
+		const resolve = Object.create(null);
+		for (const key of Reflect.ownKeys(resolvers)) resolve[key] = (snapshot, state) => {
+			assertIdentity(snapshot, id);
+			return bridge(() => parseInputs(set, id, snapshot), (inputs) => resolvers[key](inputs, snapshot, state));
+		};
+		result.resolve = resolve;
+	}
+	return result;
 }
 function redirect(definition) {
-    return async (snapshot) => {
-        const router = inject(Router);
-        const source = routeMetadata(definition());
-        const config = source.config.redirect;
-        const target = routeMetadata(config.to);
-        const raw = new Map();
-        for (let index = 0; index < source.segments.length; index += 1) {
-            const segment = source.segments[index];
-            if (segment.kind === "scalar") {
-                raw.set(segment.name, {
-                    values: snapshot.url.slice(index, index + 1).map((value) => value.path),
-                    array: false,
-                });
-            }
-            else if (segment.kind === "catchall") {
-                raw.set(segment.name, {
-                    values: snapshot.url.slice(index).map((value) => value.path),
-                    array: true,
-                });
-            }
-        }
-        const jobs = [];
-        for (const key of new Set(Object.values(config.params))) {
-            const input = raw.get(key);
-            const raws = input?.values ?? [];
-            const array = input?.array ?? false;
-            validateRaw("path", key, raws, array);
-            jobs.push({ source: "path", key, raws, array, codec: source.params[key] });
-        }
-        if (config.search.mode === "preserve") {
-            for (const key of Object.keys(target.search)) {
-                const codec = target.search[key];
-                const raws = snapshot.queryParamMap.getAll(key);
-                if (raws.length === 0 && codecPresence(codec) === "optional") {
-                    continue;
-                }
-                validateRaw("search", key, raws, false);
-                jobs.push({ source: "search", key, raws, array: false, codec });
-            }
-        }
-        // Every demand is prechecked. Async wrappers observe even synchronous preserved-search
-        // throws after earlier source jobs launch, without detaching those later rejections.
-        const logical = await runJobs(jobs);
-        const params = Object.create(null);
-        for (const [key, sourceKey] of Object.entries(config.params)) {
-            params[key] = logical.params[sourceKey];
-        }
-        const path = createUrlForPath(config.to, params);
-        const replacement = Object.create(null);
-        if (config.search.mode === "replace") {
-            const values = config.search.values;
-            for (const key of Object.keys(target.search).sort()) {
-                const codec = target.search[key];
-                if (codecPresence(codec) === "optional" &&
-                    (!Object.hasOwn(values, key) || values[key] === undefined)) {
-                    continue;
-                }
-                const raw = codec.stringify(values[key]);
-                if (typeof raw !== "string") {
-                    throw new TypeError(`Redirect search codec must stringify to a string: ${key}`);
-                }
-                replacement[key] = raw;
-            }
-        }
-        // No native conversion before demanded codecs and destination stringification succeed.
-        const tree = router.parseUrl(path);
-        if (config.search.mode === "preserve") {
-            tree.queryParams = { ...snapshot.queryParams };
-        }
-        else if (config.search.mode === "replace") {
-            tree.queryParams = replacement;
-        }
-        if (config.fragment.mode === "preserve") {
-            tree.fragment = snapshot.fragment;
-        }
-        else if (config.fragment.mode === "replace") {
-            tree.fragment = config.fragment.value;
-        }
-        return tree;
-    };
+	return async (snapshot) => {
+		const router = inject(Router);
+		const source = routeMetadata(definition());
+		const config = source.config.redirect;
+		const target = routeMetadata(config.to);
+		const raw = /* @__PURE__ */ new Map();
+		for (let index = 0; index < source.segments.length; index += 1) {
+			const segment = source.segments[index];
+			if (segment.kind === "scalar") raw.set(segment.name, {
+				values: snapshot.url.slice(index, index + 1).map((value) => value.path),
+				array: false
+			});
+			else if (segment.kind === "catchall") raw.set(segment.name, {
+				values: snapshot.url.slice(index).map((value) => value.path),
+				array: true
+			});
+		}
+		const jobs = [];
+		for (const key of new Set(Object.values(config.params))) {
+			const input = raw.get(key);
+			const raws = input?.values ?? [];
+			const array = input?.array ?? false;
+			validateRaw("path", key, raws, array);
+			jobs.push({
+				source: "path",
+				key,
+				raws,
+				array,
+				codec: source.params[key]
+			});
+		}
+		if (config.search.mode === "preserve") for (const key of Object.keys(target.search)) {
+			const codec = target.search[key];
+			const raws = snapshot.queryParamMap.getAll(key);
+			if (raws.length === 0 && codecPresence(codec) === "optional") continue;
+			validateRaw("search", key, raws, false);
+			jobs.push({
+				source: "search",
+				key,
+				raws,
+				array: false,
+				codec
+			});
+		}
+		const logical = await runJobs(jobs);
+		const params = Object.create(null);
+		for (const [key, sourceKey] of Object.entries(config.params)) params[key] = logical.params[sourceKey];
+		const path = createUrlForPath(config.to, params);
+		const replacement = Object.create(null);
+		if (config.search.mode === "replace") {
+			const values = config.search.values;
+			for (const key of Object.keys(target.search).sort()) {
+				const codec = target.search[key];
+				if (codecPresence(codec) === "optional" && (!Object.hasOwn(values, key) || values[key] === void 0)) continue;
+				const raw = codec.stringify(values[key]);
+				if (typeof raw !== "string") throw new TypeError(`Redirect search codec must stringify to a string: ${key}`);
+				replacement[key] = raw;
+			}
+		}
+		const tree = router.parseUrl(path);
+		if (config.search.mode === "preserve") tree.queryParams = { ...snapshot.queryParams };
+		else if (config.search.mode === "replace") tree.queryParams = replacement;
+		if (config.fragment.mode === "preserve") tree.fragment = snapshot.fragment;
+		else if (config.fragment.mode === "replace") tree.fragment = config.fragment.value;
+		return tree;
+	};
 }
 function createUrlForPath(definition, params) {
-    const metadata = routeMetadata(definition);
-    const parts = [];
-    function encode(raw) {
-        if (raw === "" || raw === "." || raw === "..") {
-            throw new TypeError("Invalid redirect path value");
-        }
-        return encodeURIComponent(raw).replace(/\(/g, "%28").replace(/\)/g, "%29");
-    }
-    for (const segment of metadata.segments) {
-        if (segment.kind === "static") {
-            parts.push(encode(segment.text));
-        }
-        else if (segment.kind === "scalar") {
-            const raw = metadata.params[segment.name].stringify(params[segment.name]);
-            if (typeof raw !== "string") {
-                throw new TypeError("Redirect codec must stringify to a string");
-            }
-            parts.push(encode(raw));
-        }
-        else {
-            const values = params[segment.name];
-            if (!Array.isArray(values)) {
-                throw new TypeError("Redirect catchall requires an array");
-            }
-            for (const value of values) {
-                const raw = metadata.params[segment.name].stringify(value);
-                if (typeof raw !== "string") {
-                    throw new TypeError("Redirect codec must stringify to a string");
-                }
-                parts.push(encode(raw));
-            }
-        }
-    }
-    return `/${parts.join("/")}`;
+	const metadata = routeMetadata(definition);
+	const parts = [];
+	function encode(raw) {
+		if (raw === "" || raw === "." || raw === "..") throw new TypeError("Invalid redirect path value");
+		return encodeURIComponent(raw).replace(/\(/g, "%28").replace(/\)/g, "%29");
+	}
+	for (const segment of metadata.segments) if (segment.kind === "static") parts.push(encode(segment.text));
+	else if (segment.kind === "scalar") {
+		const raw = metadata.params[segment.name].stringify(params[segment.name]);
+		if (typeof raw !== "string") throw new TypeError("Redirect codec must stringify to a string");
+		parts.push(encode(raw));
+	} else {
+		const values = params[segment.name];
+		if (!Array.isArray(values)) throw new TypeError("Redirect catchall requires an array");
+		for (const value of values) {
+			const raw = metadata.params[segment.name].stringify(value);
+			if (typeof raw !== "string") throw new TypeError("Redirect codec must stringify to a string");
+			parts.push(encode(raw));
+		}
+	}
+	return `/${parts.join("/")}`;
 }
-
-// Shared parsing has no view/task lifetime. Each handle owns its visibility and relevance.
 function observeRoute(set, id) {
-    const activated = inject(ActivatedRoute);
-    const router = inject(Router);
-    const destroy = inject(DestroyRef);
-    const tasks = inject(PendingTasks);
-    assertIdentity(activated.snapshot, id);
-    const paired = signal({
-        status: "loading",
-        value: undefined,
-    }, /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "paired" }] : /* istanbul ignore next */ []));
-    const data = signal({
-        status: "loading",
-        value: undefined,
-    }, /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "data" }] : /* istanbul ignore next */ []));
-    let survivor;
-    let work;
-    let commitment = -1;
-    let pending;
-    let visible = false;
-    let destroyed = false;
-    let release;
-    let acquiring = false;
-    function track() {
-        if (release || destroyed || acquiring) {
-            return;
-        }
-        // Native add synchronously notifies stability observers before returning ownership.
-        acquiring = true;
-        const cleanup = tasks.add();
-        acquiring = false;
-        if (destroyed) {
-            cleanup();
-            return;
-        }
-        release = cleanup;
-    }
-    function untrack() {
-        const cleanup = release;
-        release = undefined;
-        cleanup?.();
-    }
-    function publish() {
-        if (!visible || destroyed || !work) {
-            return;
-        }
-        if (!work.outcome) {
-            paired.set({ status: "loading", value: undefined });
-            track();
-            return;
-        }
-        if ("value" in work.outcome) {
-            paired.set({ status: "resolved", value: work.outcome.value });
-        }
-        else {
-            paired.set({ status: "error", error: work.outcome.error });
-        }
-        // A synchronous paired write always precedes package task removal.
-        untrack();
-    }
-    function adopt(snapshot) {
-        assertIdentity(snapshot, id);
-        if (snapshot === survivor) {
-            return;
-        }
-        survivor = snapshot;
-        const joined = fullOperation(set, id, snapshot);
-        work = joined;
-        if (!joined.outcome) {
-            track();
-        }
-        joined.promise.then(() => {
-            if (work === joined) {
-                publish();
-            }
-        }, () => {
-            if (work === joined) {
-                publish();
-            }
-        });
-    }
-    function reconcile() {
-        const successful = router.lastSuccessfulNavigation();
-        if (successful && successful.id > commitment) {
-            commitment = successful.id;
-            adopt(activated.snapshot);
-        }
-    }
-    function restore() {
-        if (destroyed) {
-            return;
-        }
-        reconcile();
-        if (!survivor) {
-            adopt(activated.snapshot);
-        }
-        const local = Object.create(null);
-        const resolvers = routeMetadata(set.records[id].definition()).config.resolve ?? {};
-        for (const key of Reflect.ownKeys(resolvers)) {
-            if (Object.hasOwn(survivor.data, key)) {
-                local[key] = survivor.data[key];
-            }
-        }
-        data.set({ status: "resolved", value: Object.freeze(local) });
-        visible = true;
-        publish();
-    }
-    function idleHandoff() {
-        queueMicrotask(() => {
-            if (destroyed || visible) {
-                return;
-            }
-            const current = router.currentNavigation();
-            const successful = router.lastSuccessfulNavigation();
-            if (!current || current.id === successful?.id) {
-                pending = undefined;
-                restore();
-            }
-        });
-    }
-    function eligible(id) {
-        const current = router.currentNavigation();
-        const successful = router.lastSuccessfulNavigation();
-        if (current && current.id > id && current.id !== successful?.id) {
-            return false;
-        }
-        return pending === undefined || pending === id;
-    }
-    // Subscribe before reading native phase: constructors can run inside event delivery.
-    const subscription = router.events.subscribe((event) => {
-        if (destroyed) {
-            return;
-        }
-        if (event instanceof NavigationStart) {
-            pending = event.id;
-            visible = false;
-            reconcile();
-            paired.set({ status: "loading", value: undefined });
-            data.set({ status: "loading", value: undefined });
-        }
-        else if (event instanceof NavigationEnd) {
-            // Even an old End may expose a newer true survivor; it cannot settle a newer Start.
-            reconcile();
-            if (eligible(event.id)) {
-                pending = undefined;
-                restore();
-            }
-        }
-        else if (event instanceof NavigationCancel) {
-            reconcile();
-            if (event.code === NavigationCancellationCode.Redirect ||
-                event.code === NavigationCancellationCode.SupersededByNewNavigation) {
-                return;
-            }
-            if (eligible(event.id)) {
-                pending = undefined;
-                restore();
-            }
-        }
-        else if (event instanceof NavigationSkipped) {
-            reconcile();
-            if (eligible(event.id)) {
-                pending = undefined;
-                restore();
-            }
-        }
-        else if (event instanceof NavigationError && eligible(event.id)) {
-            reconcile();
-            pending = undefined;
-            visible = false;
-            let error = event.error;
-            if (!(error instanceof Error)) {
-                error = new Error("Navigation failure", { cause: event.error });
-            }
-            paired.set({ status: "error", error });
-            data.set({ status: "error", error });
-            untrack();
-        }
-    });
-    destroy.onDestroy(() => {
-        destroyed = true;
-        visible = false;
-        subscription.unsubscribe();
-        untrack();
-    });
-    // Synchronous task handoff prevents whenStable resolving before a missed-terminal microtask.
-    track();
-    if (!destroyed) {
-        const current = router.currentNavigation();
-        const successful = router.lastSuccessfulNavigation();
-        if (!current || current.id === successful?.id) {
-            restore();
-        }
-        else {
-            pending = current.id;
-            idleHandoff();
-        }
-    }
-    function project(key) {
-        const state = paired();
-        if (state.status === "error") {
-            return state;
-        }
-        return { status: state.status, value: state.value?.[key] };
-    }
-    return {
-        params: resourceFromSnapshots(() => project("params")),
-        search: resourceFromSnapshots(() => project("search")),
-        data: resourceFromSnapshots(() => data()),
-    };
+	const activated = inject(ActivatedRoute);
+	const router = inject(Router);
+	const destroy = inject(DestroyRef);
+	const tasks = inject(PendingTasks);
+	assertIdentity(activated.snapshot, id);
+	const paired = signal({
+		status: "loading",
+		value: void 0
+	}, ...ngDevMode ? [{ debugName: "paired" }] : /* istanbul ignore next */ []);
+	const data = signal({
+		status: "loading",
+		value: void 0
+	}, ...ngDevMode ? [{ debugName: "data" }] : /* istanbul ignore next */ []);
+	let survivor;
+	let work;
+	let commitment = -1;
+	let pending;
+	let visible = false;
+	let destroyed = false;
+	let release;
+	let acquiring = false;
+	function track() {
+		if (release || destroyed || acquiring) return;
+		acquiring = true;
+		const cleanup = tasks.add();
+		acquiring = false;
+		if (destroyed) {
+			cleanup();
+			return;
+		}
+		release = cleanup;
+	}
+	function untrack() {
+		const cleanup = release;
+		release = void 0;
+		cleanup?.();
+	}
+	function publish() {
+		if (!visible || destroyed || !work) return;
+		if (!work.outcome) {
+			paired.set({
+				status: "loading",
+				value: void 0
+			});
+			track();
+			return;
+		}
+		if ("value" in work.outcome) paired.set({
+			status: "resolved",
+			value: work.outcome.value
+		});
+		else paired.set({
+			status: "error",
+			error: work.outcome.error
+		});
+		untrack();
+	}
+	function adopt(snapshot) {
+		assertIdentity(snapshot, id);
+		if (snapshot === survivor) return;
+		survivor = snapshot;
+		const joined = fullOperation(set, id, snapshot);
+		work = joined;
+		if (!joined.outcome) track();
+		joined.promise.then(() => {
+			if (work === joined) publish();
+		}, () => {
+			if (work === joined) publish();
+		});
+	}
+	function reconcile() {
+		const successful = router.lastSuccessfulNavigation();
+		if (successful && successful.id > commitment) {
+			commitment = successful.id;
+			adopt(activated.snapshot);
+		}
+	}
+	function restore() {
+		if (destroyed) return;
+		reconcile();
+		if (!survivor) adopt(activated.snapshot);
+		const local = Object.create(null);
+		const resolvers = routeMetadata(set.records[id].definition()).config.resolve ?? {};
+		for (const key of Reflect.ownKeys(resolvers)) if (Object.hasOwn(survivor.data, key)) local[key] = survivor.data[key];
+		data.set({
+			status: "resolved",
+			value: Object.freeze(local)
+		});
+		visible = true;
+		publish();
+	}
+	function idleHandoff() {
+		queueMicrotask(() => {
+			if (destroyed || visible) return;
+			const current = router.currentNavigation();
+			const successful = router.lastSuccessfulNavigation();
+			if (!current || current.id === successful?.id) {
+				pending = void 0;
+				restore();
+			}
+		});
+	}
+	function eligible(id) {
+		const current = router.currentNavigation();
+		const successful = router.lastSuccessfulNavigation();
+		if (current && current.id > id && current.id !== successful?.id) return false;
+		return pending === void 0 || pending === id;
+	}
+	const subscription = router.events.subscribe((event) => {
+		if (destroyed) return;
+		if (event instanceof NavigationStart) {
+			pending = event.id;
+			visible = false;
+			reconcile();
+			paired.set({
+				status: "loading",
+				value: void 0
+			});
+			data.set({
+				status: "loading",
+				value: void 0
+			});
+		} else if (event instanceof NavigationEnd) {
+			reconcile();
+			if (eligible(event.id)) {
+				pending = void 0;
+				restore();
+			}
+		} else if (event instanceof NavigationCancel) {
+			reconcile();
+			if (event.code === NavigationCancellationCode.Redirect || event.code === NavigationCancellationCode.SupersededByNewNavigation) return;
+			if (eligible(event.id)) {
+				pending = void 0;
+				restore();
+			}
+		} else if (event instanceof NavigationSkipped) {
+			reconcile();
+			if (eligible(event.id)) {
+				pending = void 0;
+				restore();
+			}
+		} else if (event instanceof NavigationError && eligible(event.id)) {
+			reconcile();
+			pending = void 0;
+			visible = false;
+			let error = event.error;
+			if (!(error instanceof Error)) error = new Error("Navigation failure", { cause: event.error });
+			paired.set({
+				status: "error",
+				error
+			});
+			data.set({
+				status: "error",
+				error
+			});
+			untrack();
+		}
+	});
+	destroy.onDestroy(() => {
+		destroyed = true;
+		visible = false;
+		subscription.unsubscribe();
+		untrack();
+	});
+	track();
+	if (!destroyed) {
+		const current = router.currentNavigation();
+		const successful = router.lastSuccessfulNavigation();
+		if (!current || current.id === successful?.id) restore();
+		else {
+			pending = current.id;
+			idleHandoff();
+		}
+	}
+	function project(key) {
+		const state = paired();
+		if (state.status === "error") return state;
+		return {
+			status: state.status,
+			value: state.value?.[key]
+		};
+	}
+	return {
+		params: resourceFromSnapshots(() => project("params")),
+		search: resourceFromSnapshots(() => project("search")),
+		data: resourceFromSnapshots(() => data())
+	};
 }
-
-const destinations = new WeakMap();
+const destinations = /* @__PURE__ */ new WeakMap();
 function createDestination(getSet, id) {
-    const destination = Object.freeze({});
-    destinations.set(destination, { getSet, id });
-    return destination;
+	const destination = Object.freeze({});
+	destinations.set(destination, {
+		getSet,
+		id
+	});
+	return destination;
 }
 function nativeOptions(definition) {
-    const config = routeMetadata(definition).config;
-    const options = {};
-    for (const key of ["providers", "title", "data", "canDeactivate", "runGuardsAndResolvers"]) {
-        if (Object.hasOwn(config, key)) {
-            options[key] = config[key];
-        }
-    }
-    return options;
+	const config = routeMetadata(definition).config;
+	const options = {};
+	for (const key of [
+		"providers",
+		"title",
+		"data",
+		"canDeactivate",
+		"runGuardsAndResolvers"
+	]) if (Object.hasOwn(config, key)) options[key] = config[key];
+	return options;
 }
 function injectGeneratedRoute(set, id) {
-    const router = inject(Router);
-    const view = observeRoute(set, id);
-    function url(args) {
-        if (args.length !== 1 && args.length !== 2) {
-            throw new TypeError("Expected values or a selected destination and values");
-        }
-        let target = id;
-        let values = args[0];
-        if (args.length === 2) {
-            const selector = args[0];
-            values = args[1];
-            if (typeof selector === "string") {
-                if (selector !== ".") {
-                    if (Object.hasOwn(set.absolute, selector)) {
-                        target = set.absolute[selector];
-                    }
-                    else if (Object.hasOwn(set.relative[id], selector)) {
-                        target = set.relative[id][selector];
-                    }
-                    else {
-                        throw new TypeError(`Unknown generated selector: ${selector}`);
-                    }
-                }
-            }
-            else {
-                if (typeof selector !== "object" || selector === null) {
-                    throw new TypeError("Expected a literal selector or genuine generated destination");
-                }
-                const destination = destinations.get(selector);
-                if (!destination ||
-                    destination.getSet() !== set ||
-                    !Object.hasOwn(set.records, destination.id)) {
-                    throw new TypeError("Expected a destination from the same generated set");
-                }
-                target = destination.id;
-            }
-        }
-        return createUrl(set.destinations[target](), values);
-    }
-    return {
-        params: view.params,
-        search: view.search,
-        data: view.data,
-        link: ((...args) => router.parseUrl(url(args))),
-        navigate: ((...args) => router.navigateByUrl(url(args))),
-    };
+	const router = inject(Router);
+	const view = observeRoute(set, id);
+	function url(args) {
+		if (args.length !== 1 && args.length !== 2) throw new TypeError("Expected values or a selected destination and values");
+		let target = id;
+		let values = args[0];
+		if (args.length === 2) {
+			const selector = args[0];
+			values = args[1];
+			if (typeof selector === "string") {
+				if (selector !== ".") {
+					if (Object.hasOwn(set.absolute, selector)) target = set.absolute[selector];
+					else if (Object.hasOwn(set.relative[id], selector)) target = set.relative[id][selector];
+					else throw new TypeError(`Unknown generated selector: ${selector}`);
+				}
+			} else {
+				if (typeof selector !== "object" || selector === null) throw new TypeError("Expected a literal selector or genuine generated destination");
+				const destination = destinations.get(selector);
+				if (!destination || destination.getSet() !== set || !Object.hasOwn(set.records, destination.id)) throw new TypeError("Expected a destination from the same generated set");
+				target = destination.id;
+			}
+		}
+		return createUrl(set.destinations[target](), values);
+	}
+	return {
+		params: view.params,
+		search: view.search,
+		data: view.data,
+		link: ((...args) => router.parseUrl(url(args))),
+		navigate: ((...args) => router.navigateByUrl(url(args)))
+	};
 }
-
-/**
- * Generated bundle index. Do not edit.
- */
-
 export { assertIdentity, callbacks, createDestination, injectGeneratedRoute, nativeOptions, parseInputs, redirect };
-//# sourceMappingURL=loozo-angular-router-_generated.mjs.map
+
+//# sourceMappingURL=loozo-angular-router-_generated.mjs.map