@loozo/angular-router 0.0.1 → 0.0.3

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

@@ -1,565 +1,392 @@
-const presence = new WeakMap();
+const presence = /* @__PURE__ */ new WeakMap();
 function codecPresence(codec) {
-    return presence.get(codec);
+	return presence.get(codec);
 }
 function validateCodec(codec) {
-    if (codec === null ||
-        (typeof codec !== "object" && typeof codec !== "function") ||
-        typeof codec.parse !== "function" ||
-        typeof codec.stringify !== "function") {
-        throw new TypeError("Codec must have callable parse and stringify methods");
-    }
+	if (codec === null || typeof codec !== "object" && typeof codec !== "function" || typeof codec.parse !== "function" || typeof codec.stringify !== "function") throw new TypeError("Codec must have callable parse and stringify methods");
 }
 const stringParam = {
-    parse(raw) {
-        return raw;
-    },
-    stringify(value) {
-        if (typeof value !== "string") {
-            throw new TypeError("Expected a string");
-        }
-        return value;
-    },
+	parse(raw) {
+		return raw;
+	},
+	stringify(value) {
+		if (typeof value !== "string") throw new TypeError("Expected a string");
+		return value;
+	}
 };
 const numberParam = {
-    parse(raw) {
-        const value = Number(raw);
-        if (raw.trim() === "" || !Number.isFinite(value)) {
-            throw new Error("Expected a finite number");
-        }
-        return value;
-    },
-    stringify(value) {
-        if (typeof value !== "number" || !Number.isFinite(value)) {
-            throw new Error("Expected a finite number");
-        }
-        return String(value);
-    },
+	parse(raw) {
+		const value = Number(raw);
+		if (raw.trim() === "" || !Number.isFinite(value)) throw new Error("Expected a finite number");
+		return value;
+	},
+	stringify(value) {
+		if (typeof value !== "number" || !Number.isFinite(value)) throw new Error("Expected a finite number");
+		return String(value);
+	}
 };
 const booleanParam = {
-    parse(raw) {
-        if (raw === "true") {
-            return true;
-        }
-        if (raw === "false") {
-            return false;
-        }
-        throw new Error("Expected true or false");
-    },
-    stringify(value) {
-        if (value === true) {
-            return "true";
-        }
-        if (value === false) {
-            return "false";
-        }
-        throw new Error("Expected a boolean");
-    },
+	parse(raw) {
+		if (raw === "true") return true;
+		if (raw === "false") return false;
+		throw new Error("Expected true or false");
+	},
+	stringify(value) {
+		if (value === true) return "true";
+		if (value === false) return "false";
+		throw new Error("Expected a boolean");
+	}
 };
 function enumParam(values) {
-    if (!Array.isArray(values)) {
-        throw new TypeError("Enum values must be a string list");
-    }
-    const members = new Set();
-    for (const value of values) {
-        if (typeof value !== "string") {
-            throw new TypeError("Enum values must be strings");
-        }
-        members.add(value);
-    }
-    return {
-        parse(raw) {
-            if (!members.has(raw)) {
-                throw new Error("Unknown enum value");
-            }
-            return raw;
-        },
-        stringify(value) {
-            if (!members.has(value)) {
-                throw new Error("Unknown enum value");
-            }
-            return value;
-        },
-    };
+	if (!Array.isArray(values)) throw new TypeError("Enum values must be a string list");
+	const members = /* @__PURE__ */ new Set();
+	for (const value of values) {
+		if (typeof value !== "string") throw new TypeError("Enum values must be strings");
+		members.add(value);
+	}
+	return {
+		parse(raw) {
+			if (!members.has(raw)) throw new Error("Unknown enum value");
+			return raw;
+		},
+		stringify(value) {
+			if (!members.has(value)) throw new Error("Unknown enum value");
+			return value;
+		}
+	};
 }
 function optionalSearchParam(codec) {
-    validateCodec(codec);
-    const wrapper = {
-        parse(raw) {
-            return codec.parse(raw);
-        },
-        stringify(value) {
-            if (value === undefined) {
-                throw new TypeError("Omitted search has no scalar representation");
-            }
-            return codec.stringify(value);
-        },
-    };
-    presence.set(wrapper, "optional");
-    return wrapper;
+	validateCodec(codec);
+	const wrapper = {
+		parse(raw) {
+			return codec.parse(raw);
+		},
+		stringify(value) {
+			if (value === void 0) throw new TypeError("Omitted search has no scalar representation");
+			return codec.stringify(value);
+		}
+	};
+	presence.set(wrapper, "optional");
+	return wrapper;
 }
 function nullableSearchParam(codec) {
-    validateCodec(codec);
-    if (codecPresence(codec) === "optional") {
-        throw new TypeError("Nullable cannot wrap optional");
-    }
-    const wrapper = {
-        parse(raw) {
-            if (raw === "null") {
-                return null;
-            }
-            return codec.parse(raw);
-        },
-        stringify(value) {
-            if (value === null) {
-                return "null";
-            }
-            return codec.stringify(value);
-        },
-    };
-    presence.set(wrapper, "nullable");
-    return wrapper;
+	validateCodec(codec);
+	if (codecPresence(codec) === "optional") throw new TypeError("Nullable cannot wrap optional");
+	const wrapper = {
+		parse(raw) {
+			if (raw === "null") return null;
+			return codec.parse(raw);
+		},
+		stringify(value) {
+			if (value === null) return "null";
+			return codec.stringify(value);
+		}
+	};
+	presence.set(wrapper, "nullable");
+	return wrapper;
 }
-
 function parsePath(path) {
-    if (typeof path !== "string") {
-        throw new TypeError("Path must be a string");
-    }
-    if (path === "") {
-        return Object.freeze([]);
-    }
-    const segments = [];
-    const scalarNames = new Set();
-    const parts = path.split("/");
-    for (let index = 0; index < parts.length; index += 1) {
-        const part = parts[index];
-        if (part.startsWith("$")) {
-            let name = part.slice(1);
-            let kind = "scalar";
-            if (name.endsWith("[]")) {
-                name = name.slice(0, -2);
-                kind = "catchall";
-            }
-            if (name === "" ||
-                name === "__proto__" ||
-                name.startsWith("...") ||
-                name.includes("?") ||
-                name.includes("*") ||
-                name.includes("[]")) {
-                throw new TypeError(`Invalid parameter name: ${name}`);
-            }
-            if (kind === "catchall" && (index !== parts.length - 1 || scalarNames.has(name))) {
-                throw new TypeError("Catchall must be terminal and cannot repeat a scalar name");
-            }
-            scalarNames.add(name);
-            segments.push(Object.freeze({ kind, name }));
-        }
-        else {
-            if (part === "" ||
-                part === "." ||
-                part === ".." ||
-                part === "*" ||
-                part === "**" ||
-                part.startsWith(":")) {
-                throw new TypeError(`Invalid static segment: ${part}`);
-            }
-            if (!part.isWellFormed()) {
-                throw new TypeError("Static path Unicode must be well formed");
-            }
-            segments.push(Object.freeze({ kind: "static", text: part }));
-        }
-    }
-    return Object.freeze(segments);
+	if (typeof path !== "string") throw new TypeError("Path must be a string");
+	if (path === "") return Object.freeze([]);
+	const segments = [];
+	const scalarNames = /* @__PURE__ */ new Set();
+	const parts = path.split("/");
+	for (let index = 0; index < parts.length; index += 1) {
+		const part = parts[index];
+		if (part.startsWith("$")) {
+			let name = part.slice(1);
+			let kind = "scalar";
+			if (name.endsWith("[]")) {
+				name = name.slice(0, -2);
+				kind = "catchall";
+			}
+			if (name === "" || name === "__proto__" || name.startsWith("...") || name.includes("?") || name.includes("*") || name.includes("[]")) throw new TypeError(`Invalid parameter name: ${name}`);
+			if (kind === "catchall" && (index !== parts.length - 1 || scalarNames.has(name))) throw new TypeError("Catchall must be terminal and cannot repeat a scalar name");
+			scalarNames.add(name);
+			segments.push(Object.freeze({
+				kind,
+				name
+			}));
+		} else {
+			if (part === "" || part === "." || part === ".." || part === "*" || part === "**" || part.startsWith(":")) throw new TypeError(`Invalid static segment: ${part}`);
+			if (!part.isWellFormed()) throw new TypeError("Static path Unicode must be well formed");
+			segments.push(Object.freeze({
+				kind: "static",
+				text: part
+			}));
+		}
+	}
+	return Object.freeze(segments);
 }
-
 function ownRecord(value, label, allowSymbols = false) {
-    if (value === null || typeof value !== "object" || Array.isArray(value)) {
-        throw new TypeError(`${label} must be an own record`);
-    }
-    const prototype = Object.getPrototypeOf(value);
-    if (prototype !== Object.prototype && prototype !== null) {
-        throw new TypeError(`${label} cannot contain inherited entries`);
-    }
-    for (const key of Reflect.ownKeys(value)) {
-        if ((!allowSymbols && typeof key !== "string") ||
-            !Object.prototype.propertyIsEnumerable.call(value, key)) {
-            throw new TypeError(`${label} contains an unsupported key`);
-        }
-    }
-    return value;
+	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new TypeError(`${label} must be an own record`);
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null) throw new TypeError(`${label} cannot contain inherited entries`);
+	for (const key of Reflect.ownKeys(value)) if (!allowSymbols && typeof key !== "string" || !Object.prototype.propertyIsEnumerable.call(value, key)) throw new TypeError(`${label} contains an unsupported key`);
+	return value;
 }
 function checkKeys(record, allowed, label) {
-    for (const key of Object.keys(record)) {
-        if (!allowed.has(key)) {
-            throw new TypeError(`Unknown ${label} key: ${key}`);
-        }
-    }
+	for (const key of Object.keys(record)) if (!allowed.has(key)) throw new TypeError(`Unknown ${label} key: ${key}`);
 }
 function has(record, key) {
-    return Object.hasOwn(record, key);
+	return Object.hasOwn(record, key);
 }
-
-const routes = new WeakMap();
-const configKeys = new Set([
-    "parent",
-    "params",
-    "search",
-    "resolve",
-    "runGuardsAndResolvers",
-    "redirect",
-    "fragments",
-    "canActivate",
-    "canActivateChild",
-    "canMatch",
-    "canDeactivate",
-    "providers",
-    "title",
-    "data",
+const routes = /* @__PURE__ */ new WeakMap();
+const configKeys = /* @__PURE__ */ new Set([
+	"parent",
+	"params",
+	"search",
+	"resolve",
+	"runGuardsAndResolvers",
+	"redirect",
+	"fragments",
+	"canActivate",
+	"canActivateChild",
+	"canMatch",
+	"canDeactivate",
+	"providers",
+	"title",
+	"data"
 ]);
-const policies = new Set([
-    "pathParamsChange",
-    "pathParamsOrQueryParamsChange",
-    "paramsChange",
-    "paramsOrQueryParamsChange",
-    "always",
+const policies = /* @__PURE__ */ new Set([
+	"pathParamsChange",
+	"pathParamsOrQueryParamsChange",
+	"paramsChange",
+	"paramsOrQueryParamsChange",
+	"always"
 ]);
 const identityKey = "__loozoAngularRouterRouteId";
 function routeMetadata(route) {
-    if (route === null || typeof route !== "object" || !routes.has(route)) {
-        throw new TypeError("Expected a genuine route from this package instance");
-    }
-    return routes.get(route);
+	if (route === null || typeof route !== "object" || !routes.has(route)) throw new TypeError("Expected a genuine route from this package instance");
+	return routes.get(route);
 }
 function copyCodecs(value, path) {
-    const record = ownRecord(value, "Codec map");
-    const result = Object.create(null);
-    for (const key of Object.keys(record)) {
-        const codec = record[key];
-        validateCodec(codec);
-        if (path && codecPresence(codec) !== undefined) {
-            throw new TypeError("Search wrappers cannot be path codecs");
-        }
-        result[key] = codec;
-    }
-    return Object.freeze(result);
+	const record = ownRecord(value, "Codec map");
+	const result = Object.create(null);
+	for (const key of Object.keys(record)) {
+		const codec = record[key];
+		validateCodec(codec);
+		if (path && codecPresence(codec) !== void 0) throw new TypeError("Search wrappers cannot be path codecs");
+		result[key] = codec;
+	}
+	return Object.freeze(result);
 }
 function snapshotRedirect(value, source) {
-    const redirect = ownRecord(value, "Redirect");
-    checkKeys(redirect, new Set(["to", "params", "search", "fragment"]), "redirect");
-    const target = routeMetadata(redirect.to);
-    const mapping = Object.create(null);
-    if (has(redirect, "params")) {
-        const supplied = ownRecord(redirect.params, "Redirect params");
-        checkKeys(supplied, new Set(Object.keys(target.params)), "redirect params");
-        for (const key of Object.keys(target.params)) {
-            const sourceKey = supplied[key];
-            if (!has(supplied, key) || typeof sourceKey !== "string" || !has(source.params, sourceKey)) {
-                throw new TypeError(`Missing or invalid redirect mapping: ${key}`);
-            }
-            mapping[key] = sourceKey;
-        }
-    }
-    else {
-        for (const key of Object.keys(target.params)) {
-            if (!has(source.params, key)) {
-                throw new TypeError(`Cannot forward redirect param: ${key}`);
-            }
-            mapping[key] = key;
-        }
-    }
-    const search = ownRecord(redirect.search, "Redirect search");
-    let searchSnapshot;
-    if (search.mode === "replace") {
-        checkKeys(search, new Set(["mode", "values"]), "redirect search");
-        const values = ownRecord(search.values, "Redirect replacement");
-        validateSearchValues(target.search, values);
-        searchSnapshot = { mode: "replace", values: Object.freeze({ ...values }) };
-    }
-    else if (search.mode === "preserve" || search.mode === "drop") {
-        checkKeys(search, new Set(["mode"]), "redirect search");
-        for (const key of Object.keys(target.search)) {
-            if (codecPresence(target.search[key]) === "optional") {
-                continue;
-            }
-            if (search.mode === "drop" ||
-                !has(source.search, key) ||
-                codecPresence(source.search[key]) === "optional") {
-                throw new TypeError(`Redirect cannot guarantee required search: ${key}`);
-            }
-        }
-        searchSnapshot = { mode: search.mode };
-    }
-    else {
-        throw new TypeError("Invalid redirect search policy");
-    }
-    const fragment = ownRecord(redirect.fragment, "Redirect fragment");
-    if (fragment.mode === "replace") {
-        checkKeys(fragment, new Set(["mode", "value"]), "redirect fragment");
-        if (typeof fragment.value !== "string" || !target.fragments.includes(fragment.value)) {
-            throw new TypeError("Redirect fragment must belong to target declaration");
-        }
-    }
-    else if (fragment.mode === "preserve" || fragment.mode === "drop") {
-        checkKeys(fragment, new Set(["mode"]), "redirect fragment");
-    }
-    else {
-        throw new TypeError("Invalid redirect fragment policy");
-    }
-    return Object.freeze({
-        to: redirect.to,
-        params: Object.freeze(mapping),
-        search: Object.freeze(searchSnapshot),
-        fragment: Object.freeze({ ...fragment }),
-    });
+	const redirect = ownRecord(value, "Redirect");
+	checkKeys(redirect, /* @__PURE__ */ new Set([
+		"to",
+		"params",
+		"search",
+		"fragment"
+	]), "redirect");
+	const target = routeMetadata(redirect.to);
+	const mapping = Object.create(null);
+	if (has(redirect, "params")) {
+		const supplied = ownRecord(redirect.params, "Redirect params");
+		checkKeys(supplied, new Set(Object.keys(target.params)), "redirect params");
+		for (const key of Object.keys(target.params)) {
+			const sourceKey = supplied[key];
+			if (!has(supplied, key) || typeof sourceKey !== "string" || !has(source.params, sourceKey)) throw new TypeError(`Missing or invalid redirect mapping: ${key}`);
+			mapping[key] = sourceKey;
+		}
+	} else for (const key of Object.keys(target.params)) {
+		if (!has(source.params, key)) throw new TypeError(`Cannot forward redirect param: ${key}`);
+		mapping[key] = key;
+	}
+	const search = ownRecord(redirect.search, "Redirect search");
+	let searchSnapshot;
+	if (search.mode === "replace") {
+		checkKeys(search, /* @__PURE__ */ new Set(["mode", "values"]), "redirect search");
+		const values = ownRecord(search.values, "Redirect replacement");
+		validateSearchValues(target.search, values);
+		searchSnapshot = {
+			mode: "replace",
+			values: Object.freeze({ ...values })
+		};
+	} else if (search.mode === "preserve" || search.mode === "drop") {
+		checkKeys(search, /* @__PURE__ */ new Set(["mode"]), "redirect search");
+		for (const key of Object.keys(target.search)) {
+			if (codecPresence(target.search[key]) === "optional") continue;
+			if (search.mode === "drop" || !has(source.search, key) || codecPresence(source.search[key]) === "optional") throw new TypeError(`Redirect cannot guarantee required search: ${key}`);
+		}
+		searchSnapshot = { mode: search.mode };
+	} else throw new TypeError("Invalid redirect search policy");
+	const fragment = ownRecord(redirect.fragment, "Redirect fragment");
+	if (fragment.mode === "replace") {
+		checkKeys(fragment, /* @__PURE__ */ new Set(["mode", "value"]), "redirect fragment");
+		if (typeof fragment.value !== "string" || !target.fragments.includes(fragment.value)) throw new TypeError("Redirect fragment must belong to target declaration");
+	} else if (fragment.mode === "preserve" || fragment.mode === "drop") checkKeys(fragment, /* @__PURE__ */ new Set(["mode"]), "redirect fragment");
+	else throw new TypeError("Invalid redirect fragment policy");
+	return Object.freeze({
+		to: redirect.to,
+		params: Object.freeze(mapping),
+		search: Object.freeze(searchSnapshot),
+		fragment: Object.freeze({ ...fragment })
+	});
 }
 function validateSearchValues(codecs, values) {
-    checkKeys(values, new Set(Object.keys(codecs)), "search values");
-    for (const key of Object.keys(codecs)) {
-        if (codecPresence(codecs[key]) !== "optional" && !has(values, key)) {
-            throw new TypeError(`Missing required search: ${key}`);
-        }
-    }
+	checkKeys(values, new Set(Object.keys(codecs)), "search values");
+	for (const key of Object.keys(codecs)) if (codecPresence(codecs[key]) !== "optional" && !has(values, key)) throw new TypeError(`Missing required search: ${key}`);
 }
 function defineRoute(path, config) {
-    const supplied = ownRecord(config, "Route config");
-    checkKeys(supplied, configKeys, "route config");
-    const localSegments = parsePath(path);
-    let parent;
-    let inherited;
-    if (has(supplied, "parent")) {
-        inherited = routeMetadata(supplied.parent);
-        parent = supplied.parent;
-        for (const segment of inherited.segments) {
-            if (segment.kind === "catchall") {
-                throw new TypeError("Catchall declarations cannot have children");
-            }
-        }
-    }
-    const localNames = new Set();
-    for (const segment of localSegments) {
-        if (segment.kind !== "static") {
-            localNames.add(segment.name);
-        }
-    }
-    let localParams = Object.freeze(Object.create(null));
-    if (localNames.size === 0) {
-        if (has(supplied, "params")) {
-            throw new TypeError("Static paths cannot declare params");
-        }
-    }
-    else {
-        localParams = copyCodecs(supplied.params, true);
-        checkKeys(localParams, localNames, "local params");
-        for (const key of localNames) {
-            if (!has(localParams, key)) {
-                throw new TypeError(`Missing local codec: ${key}`);
-            }
-            if (inherited && has(inherited.params, key)) {
-                throw new TypeError(`Inherited param already owned: ${key}`);
-            }
-        }
-    }
-    let localSearch = Object.freeze(Object.create(null));
-    if (has(supplied, "search")) {
-        localSearch = copyCodecs(supplied.search, false);
-    }
-    for (const key of Object.keys(localSearch)) {
-        if (inherited && has(inherited.search, key)) {
-            throw new TypeError(`Inherited search already owned: ${key}`);
-        }
-    }
-    const retained = { ...supplied };
-    const result = { path: path };
-    if (has(supplied, "resolve")) {
-        const resolve = ownRecord(supplied.resolve, "Resolvers", true);
-        const copied = Object.create(null);
-        for (const key of Reflect.ownKeys(resolve)) {
-            if (key === identityKey || typeof resolve[key] !== "function") {
-                throw new TypeError(`Invalid resolver: ${String(key)}`);
-            }
-            copied[key] = resolve[key];
-        }
-        result.resolve = Object.freeze(copied);
-        retained.resolve = result.resolve;
-    }
-    if (has(supplied, "runGuardsAndResolvers")) {
-        const policy = supplied.runGuardsAndResolvers;
-        if (typeof policy !== "function" && (typeof policy !== "string" || !policies.has(policy))) {
-            throw new TypeError("Invalid native rerun policy");
-        }
-        result.runGuardsAndResolvers = policy;
-    }
-    for (const key of ["canActivate", "canActivateChild", "canMatch", "canDeactivate", "providers"]) {
-        if (!has(supplied, key)) {
-            continue;
-        }
-        const list = supplied[key];
-        if (!Array.isArray(list)) {
-            throw new TypeError(`${key} must be an array`);
-        }
-        if (key === "canActivate" || key === "canActivateChild" || key === "canMatch") {
-            for (const callback of list) {
-                if (typeof callback !== "function") {
-                    throw new TypeError(`${key} entries must be callbacks`);
-                }
-            }
-        }
-        else if (key === "canDeactivate") {
-            for (const guard of list) {
-                if (guard === null ||
-                    (typeof guard !== "function" && typeof guard !== "object" && typeof guard !== "string")) {
-                    throw new TypeError("canDeactivate entries must be native callbacks or tokens");
-                }
-            }
-        }
-        retained[key] = Object.freeze([...list]);
-    }
-    if (has(supplied, "title") &&
-        typeof supplied.title !== "string" &&
-        typeof supplied.title !== "function") {
-        throw new TypeError("Invalid native title");
-    }
-    if (has(supplied, "data")) {
-        const data = ownRecord(supplied.data, "Static data", true);
-        if (has(data, identityKey)) {
-            throw new TypeError("Static data cannot set generated identity");
-        }
-        retained.data = Object.freeze({ ...data });
-    }
-    const fragments = [];
-    if (has(supplied, "fragments")) {
-        if (!Array.isArray(supplied.fragments)) {
-            throw new TypeError("Fragments must be a string list");
-        }
-        for (const name of supplied.fragments) {
-            if (typeof name !== "string") {
-                throw new TypeError("Fragment names must be strings");
-            }
-            fragments.push(name);
-        }
-    }
-    retained.fragments = Object.freeze(fragments);
-    retained.params = localParams;
-    retained.search = localSearch;
-    const metadata = {
-        parent,
-        localSegments,
-        segments: Object.freeze([...(inherited?.segments ?? []), ...localSegments]),
-        localParams,
-        localSearch,
-        params: Object.freeze({ ...inherited?.params, ...localParams }),
-        search: Object.freeze({ ...inherited?.search, ...localSearch }),
-        fragments: retained.fragments,
-        config: retained,
-    };
-    if (has(supplied, "redirect")) {
-        if (has(supplied, "canActivate") || has(supplied, "canMatch")) {
-            throw new TypeError("Redirect cannot declare own canActivate or canMatch");
-        }
-        retained.redirect = snapshotRedirect(supplied.redirect, metadata);
-    }
-    Object.freeze(retained);
-    routes.set(result, Object.freeze(metadata));
-    return Object.freeze(result);
+	const supplied = ownRecord(config, "Route config");
+	checkKeys(supplied, configKeys, "route config");
+	const localSegments = parsePath(path);
+	let parent;
+	let inherited;
+	if (has(supplied, "parent")) {
+		inherited = routeMetadata(supplied.parent);
+		parent = supplied.parent;
+		for (const segment of inherited.segments) if (segment.kind === "catchall") throw new TypeError("Catchall declarations cannot have children");
+	}
+	const localNames = /* @__PURE__ */ new Set();
+	for (const segment of localSegments) if (segment.kind !== "static") localNames.add(segment.name);
+	let localParams = Object.freeze(Object.create(null));
+	if (localNames.size === 0) {
+		if (has(supplied, "params")) throw new TypeError("Static paths cannot declare params");
+	} else {
+		localParams = copyCodecs(supplied.params, true);
+		checkKeys(localParams, localNames, "local params");
+		for (const key of localNames) {
+			if (!has(localParams, key)) throw new TypeError(`Missing local codec: ${key}`);
+			if (inherited && has(inherited.params, key)) throw new TypeError(`Inherited param already owned: ${key}`);
+		}
+	}
+	let localSearch = Object.freeze(Object.create(null));
+	if (has(supplied, "search")) localSearch = copyCodecs(supplied.search, false);
+	for (const key of Object.keys(localSearch)) if (inherited && has(inherited.search, key)) throw new TypeError(`Inherited search already owned: ${key}`);
+	const retained = { ...supplied };
+	const result = { path };
+	if (has(supplied, "resolve")) {
+		const resolve = ownRecord(supplied.resolve, "Resolvers", true);
+		const copied = Object.create(null);
+		for (const key of Reflect.ownKeys(resolve)) {
+			if (key === identityKey || typeof resolve[key] !== "function") throw new TypeError(`Invalid resolver: ${String(key)}`);
+			copied[key] = resolve[key];
+		}
+		result.resolve = Object.freeze(copied);
+		retained.resolve = result.resolve;
+	}
+	if (has(supplied, "runGuardsAndResolvers")) {
+		const policy = supplied.runGuardsAndResolvers;
+		if (typeof policy !== "function" && (typeof policy !== "string" || !policies.has(policy))) throw new TypeError("Invalid native rerun policy");
+		result.runGuardsAndResolvers = policy;
+	}
+	for (const key of [
+		"canActivate",
+		"canActivateChild",
+		"canMatch",
+		"canDeactivate",
+		"providers"
+	]) {
+		if (!has(supplied, key)) continue;
+		const list = supplied[key];
+		if (!Array.isArray(list)) throw new TypeError(`${key} must be an array`);
+		if (key === "canActivate" || key === "canActivateChild" || key === "canMatch") {
+			for (const callback of list) if (typeof callback !== "function") throw new TypeError(`${key} entries must be callbacks`);
+		} else if (key === "canDeactivate") {
+			for (const guard of list) if (guard === null || typeof guard !== "function" && typeof guard !== "object" && typeof guard !== "string") throw new TypeError("canDeactivate entries must be native callbacks or tokens");
+		}
+		retained[key] = Object.freeze([...list]);
+	}
+	if (has(supplied, "title") && typeof supplied.title !== "string" && typeof supplied.title !== "function") throw new TypeError("Invalid native title");
+	if (has(supplied, "data")) {
+		const data = ownRecord(supplied.data, "Static data", true);
+		if (has(data, identityKey)) throw new TypeError("Static data cannot set generated identity");
+		retained.data = Object.freeze({ ...data });
+	}
+	const fragments = [];
+	if (has(supplied, "fragments")) {
+		if (!Array.isArray(supplied.fragments)) throw new TypeError("Fragments must be a string list");
+		for (const name of supplied.fragments) {
+			if (typeof name !== "string") throw new TypeError("Fragment names must be strings");
+			fragments.push(name);
+		}
+	}
+	retained.fragments = Object.freeze(fragments);
+	retained.params = localParams;
+	retained.search = localSearch;
+	const metadata = {
+		parent,
+		localSegments,
+		segments: Object.freeze([...inherited?.segments ?? [], ...localSegments]),
+		localParams,
+		localSearch,
+		params: Object.freeze({
+			...inherited?.params,
+			...localParams
+		}),
+		search: Object.freeze({
+			...inherited?.search,
+			...localSearch
+		}),
+		fragments: retained.fragments,
+		config: retained
+	};
+	if (has(supplied, "redirect")) {
+		if (has(supplied, "canActivate") || has(supplied, "canMatch")) throw new TypeError("Redirect cannot declare own canActivate or canMatch");
+		retained.redirect = snapshotRedirect(supplied.redirect, metadata);
+	}
+	Object.freeze(retained);
+	routes.set(result, Object.freeze(metadata));
+	return Object.freeze(result);
 }
-
 function encode(value) {
-    return encodeURIComponent(value).replaceAll("(", "%28").replaceAll(")", "%29");
+	return encodeURIComponent(value).replaceAll("(", "%28").replaceAll(")", "%29");
 }
 function stringify(codec, value, path) {
-    const text = codec.stringify(value);
-    if (typeof text !== "string") {
-        throw new TypeError("Codec stringify must return a string");
-    }
-    if (path && (text === "" || text === "." || text === "..")) {
-        throw new TypeError("Path output cannot be empty, dot or dotdot");
-    }
-    return encode(text);
+	const text = codec.stringify(value);
+	if (typeof text !== "string") throw new TypeError("Codec stringify must return a string");
+	if (path && (text === "" || text === "." || text === "..")) throw new TypeError("Path output cannot be empty, dot or dotdot");
+	return encode(text);
 }
 function createUrl(route, values) {
-    const metadata = routeMetadata(route);
-    const options = ownRecord(values, "URL options");
-    checkKeys(options, new Set(["params", "search", "fragment"]), "URL options");
-    const paramKeys = Object.keys(metadata.params);
-    let params = Object.create(null);
-    if (paramKeys.length === 0) {
-        if (has(options, "params")) {
-            throw new TypeError("Route has no path params");
-        }
-    }
-    else {
-        params = ownRecord(options.params, "Path values");
-        checkKeys(params, new Set(paramKeys), "path values");
-        for (const key of paramKeys) {
-            if (!has(params, key)) {
-                throw new TypeError(`Missing path value: ${key}`);
-            }
-        }
-    }
-    const searchKeys = Object.keys(metadata.search).sort();
-    let search = Object.create(null);
-    if (searchKeys.length === 0) {
-        if (has(options, "search")) {
-            throw new TypeError("Route has no search declarations");
-        }
-    }
-    else {
-        if (has(options, "search")) {
-            search = ownRecord(options.search, "Search values");
-        }
-        validateSearchValues(metadata.search, search);
-    }
-    if (has(options, "fragment")) {
-        if (typeof options.fragment !== "string" || !metadata.fragments.includes(options.fragment)) {
-            throw new TypeError("Fragment must belong to this declaration");
-        }
-    }
-    // Check all cardinalities before invoking application stringifiers.
-    for (const segment of metadata.segments) {
-        if (segment.kind === "catchall" && !Array.isArray(params[segment.name])) {
-            throw new TypeError(`Catchall requires an array: ${segment.name}`);
-        }
-    }
-    const parts = [];
-    for (const segment of metadata.segments) {
-        if (segment.kind === "static") {
-            parts.push(encode(segment.text));
-        }
-        else if (segment.kind === "scalar") {
-            parts.push(stringify(metadata.params[segment.name], params[segment.name], true));
-        }
-        else {
-            for (const value of params[segment.name]) {
-                parts.push(stringify(metadata.params[segment.name], value, true));
-            }
-        }
-    }
-    let url = `/${parts.join("/")}`;
-    const query = [];
-    for (const key of searchKeys) {
-        const codec = metadata.search[key];
-        const optional = codecPresence(codec) === "optional";
-        if (optional && !has(search, key)) {
-            continue;
-        }
-        const value = search[key];
-        if (optional && value === undefined) {
-            continue;
-        }
-        query.push(`${encode(key)}=${stringify(codec, value, false)}`);
-    }
-    if (query.length > 0) {
-        url += `?${query.join("&")}`;
-    }
-    if (has(options, "fragment")) {
-        url += `#${encode(options.fragment)}`;
-    }
-    return url;
+	const metadata = routeMetadata(route);
+	const options = ownRecord(values, "URL options");
+	checkKeys(options, /* @__PURE__ */ new Set([
+		"params",
+		"search",
+		"fragment"
+	]), "URL options");
+	const paramKeys = Object.keys(metadata.params);
+	let params = Object.create(null);
+	if (paramKeys.length === 0) {
+		if (has(options, "params")) throw new TypeError("Route has no path params");
+	} else {
+		params = ownRecord(options.params, "Path values");
+		checkKeys(params, new Set(paramKeys), "path values");
+		for (const key of paramKeys) if (!has(params, key)) throw new TypeError(`Missing path value: ${key}`);
+	}
+	const searchKeys = Object.keys(metadata.search).sort();
+	let search = Object.create(null);
+	if (searchKeys.length === 0) {
+		if (has(options, "search")) throw new TypeError("Route has no search declarations");
+	} else {
+		if (has(options, "search")) search = ownRecord(options.search, "Search values");
+		validateSearchValues(metadata.search, search);
+	}
+	if (has(options, "fragment")) {
+		if (typeof options.fragment !== "string" || !metadata.fragments.includes(options.fragment)) throw new TypeError("Fragment must belong to this declaration");
+	}
+	for (const segment of metadata.segments) if (segment.kind === "catchall" && !Array.isArray(params[segment.name])) throw new TypeError(`Catchall requires an array: ${segment.name}`);
+	const parts = [];
+	for (const segment of metadata.segments) if (segment.kind === "static") parts.push(encode(segment.text));
+	else if (segment.kind === "scalar") parts.push(stringify(metadata.params[segment.name], params[segment.name], true));
+	else for (const value of params[segment.name]) parts.push(stringify(metadata.params[segment.name], value, true));
+	let url = `/${parts.join("/")}`;
+	const query = [];
+	for (const key of searchKeys) {
+		const codec = metadata.search[key];
+		const optional = codecPresence(codec) === "optional";
+		if (optional && !has(search, key)) continue;
+		const value = search[key];
+		if (optional && value === void 0) continue;
+		query.push(`${encode(key)}=${stringify(codec, value, false)}`);
+	}
+	if (query.length > 0) url += `?${query.join("&")}`;
+	if (has(options, "fragment")) url += `#${encode(options.fragment)}`;
+	return url;
 }
-
-/**
- * Generated bundle index. Do not edit.
- */
-
 export { booleanParam, codecPresence, createUrl, defineRoute, enumParam, nullableSearchParam, numberParam, optionalSearchParam, routeMetadata, stringParam };
-//# sourceMappingURL=loozo-angular-router-_core.mjs.map
+
+//# sourceMappingURL=loozo-angular-router-_core.mjs.map