vue-multi-router 0.1.0

package/dist/index.js

@@ -0,0 +1,1028 @@
+import { computed, defineComponent, getCurrentInstance, h, inject, onBeforeUnmount, provide, ref, shallowRef } from "vue";
+import { RouterLink, RouterView, createRouter, routeLocationKey, routerKey, routerViewLocationKey, viewDepthKey } from "vue-router";
+
+//#region src/history/storage/types.ts
+function isPromise(value) {
+	return value instanceof Promise;
+}
+function resolveValue(value, callback) {
+	if (isPromise(value)) value.then(callback);
+	else callback(value);
+}
+function mapMaybePromise(value, fn) {
+	if (isPromise(value)) return value.then(fn);
+	return fn(value);
+}
+function flatMapMaybePromise(value, fn) {
+	if (isPromise(value)) return value.then(fn);
+	return fn(value);
+}
+
+//#endregion
+//#region src/history/storage/session-storage-adapter.ts
+const STACK_STORAGE_PREFIX = "__multiRouter_stack_";
+const ACTIVE_CONTEXT_STORAGE_KEY = "__multiRouterActiveContext";
+const ACTIVE_HISTORY_CONTEXT_STORAGE_KEY = "__multiRouterActiveHistoryContext";
+var SessionStorageAdapter = class {
+	getStackStorageKey(contextKey) {
+		return `${STACK_STORAGE_PREFIX}${contextKey}`;
+	}
+	saveStack(contextKey, stack) {
+		try {
+			const data = {
+				entries: stack.entries,
+				position: stack.position
+			};
+			sessionStorage.setItem(this.getStackStorageKey(contextKey), JSON.stringify(data));
+		} catch (e) {
+			console.warn("[SessionStorageAdapter] Failed to save stack:", e);
+		}
+	}
+	restoreStack(contextKey) {
+		try {
+			const stored = sessionStorage.getItem(this.getStackStorageKey(contextKey));
+			if (!stored) return null;
+			const data = JSON.parse(stored);
+			if (data && Array.isArray(data.entries) && data.entries.length > 0) {
+				const position = Math.min(Math.max(0, data.position ?? 0), data.entries.length - 1);
+				return {
+					entries: data.entries,
+					position
+				};
+			}
+		} catch (e) {
+			console.warn("[SessionStorageAdapter] Failed to restore stack:", e);
+		}
+		return null;
+	}
+	clearStack(contextKey) {
+		try {
+			sessionStorage.removeItem(this.getStackStorageKey(contextKey));
+		} catch (e) {
+			console.warn("[SessionStorageAdapter] Failed to clear stack:", e);
+		}
+	}
+	saveActiveContext(contextKey) {
+		try {
+			sessionStorage.setItem(ACTIVE_CONTEXT_STORAGE_KEY, contextKey);
+		} catch (e) {
+			console.warn("[SessionStorageAdapter] Failed to save active context:", e);
+		}
+	}
+	getActiveContext() {
+		try {
+			return sessionStorage.getItem(ACTIVE_CONTEXT_STORAGE_KEY);
+		} catch {
+			return null;
+		}
+	}
+	saveActiveHistoryContext(contextKey) {
+		try {
+			sessionStorage.setItem(ACTIVE_HISTORY_CONTEXT_STORAGE_KEY, contextKey);
+		} catch (e) {
+			console.warn("[SessionStorageAdapter] Failed to save active history context:", e);
+		}
+	}
+	getActiveHistoryContext() {
+		try {
+			return sessionStorage.getItem(ACTIVE_HISTORY_CONTEXT_STORAGE_KEY);
+		} catch {
+			return null;
+		}
+	}
+};
+
+//#endregion
+//#region src/history/types.ts
+let NavigationType = /* @__PURE__ */ function(NavigationType$1) {
+	NavigationType$1["pop"] = "pop";
+	NavigationType$1["push"] = "push";
+	return NavigationType$1;
+}({});
+let NavigationDirection = /* @__PURE__ */ function(NavigationDirection$1) {
+	NavigationDirection$1["back"] = "back";
+	NavigationDirection$1["forward"] = "forward";
+	NavigationDirection$1["unknown"] = "";
+	return NavigationDirection$1;
+}({});
+
+//#endregion
+//#region src/history/storage.ts
+var VirtualStackStorage = class {
+	adapter;
+	constructor(adapter) {
+		this.adapter = adapter ?? new SessionStorageAdapter();
+	}
+	save(contextKey, stack) {
+		return this.adapter.saveStack(contextKey, stack);
+	}
+	restore(contextKey) {
+		return this.adapter.restoreStack(contextKey);
+	}
+	clear(contextKey) {
+		return this.adapter.clearStack(contextKey);
+	}
+	saveActiveContext(contextKey) {
+		return this.adapter.saveActiveContext(contextKey);
+	}
+	getActiveContext() {
+		return this.adapter.getActiveContext();
+	}
+	saveActiveHistoryContext(contextKey) {
+		return this.adapter.saveActiveHistoryContext(contextKey);
+	}
+	getActiveHistoryContext() {
+		return this.adapter.getActiveHistoryContext();
+	}
+	resolveValue = resolveValue;
+};
+
+//#endregion
+//#region src/history/virtual-stack.ts
+var VirtualStackManager = class {
+	contexts = /* @__PURE__ */ new Map();
+	storage;
+	constructor(storageAdapter) {
+		this.storage = new VirtualStackStorage(storageAdapter);
+	}
+	has(contextKey) {
+		return this.contexts.has(contextKey);
+	}
+	get(contextKey) {
+		return this.contexts.get(contextKey);
+	}
+	create(contextKey, initialStack, historyEnabled = true) {
+		this.contexts.set(contextKey, {
+			virtualStack: initialStack,
+			listeners: /* @__PURE__ */ new Set(),
+			historyEnabled
+		});
+	}
+	isHistoryEnabled(contextKey) {
+		return this.contexts.get(contextKey)?.historyEnabled ?? true;
+	}
+	remove(contextKey) {
+		this.contexts.delete(contextKey);
+		this.storage.clear(contextKey);
+	}
+	clear() {
+		this.contexts.clear();
+	}
+	getLocation(contextKey, fallback) {
+		const context = this.contexts.get(contextKey);
+		if (!context) return fallback;
+		return context.virtualStack.entries[context.virtualStack.position]?.location ?? fallback;
+	}
+	getState(contextKey) {
+		const context = this.contexts.get(contextKey);
+		if (!context) return {};
+		return context.virtualStack.entries[context.virtualStack.position]?.state ?? {};
+	}
+	push(contextKey, location, state) {
+		const context = this.contexts.get(contextKey);
+		if (!context) throw new Error(`[VirtualStackManager] Context "${contextKey}" not found`);
+		context.virtualStack.entries = context.virtualStack.entries.slice(0, context.virtualStack.position + 1);
+		context.virtualStack.entries.push({
+			location,
+			state
+		});
+		context.virtualStack.position = context.virtualStack.entries.length - 1;
+		this.save(contextKey);
+		return context.virtualStack.position;
+	}
+	replace(contextKey, location, state) {
+		const context = this.contexts.get(contextKey);
+		if (!context) throw new Error(`[VirtualStackManager] Context "${contextKey}" not found`);
+		context.virtualStack.entries[context.virtualStack.position] = {
+			location,
+			state
+		};
+		this.save(contextKey);
+		return context.virtualStack.position;
+	}
+	navigate(contextKey, delta) {
+		const context = this.contexts.get(contextKey);
+		if (!context) return null;
+		const newPosition = context.virtualStack.position + delta;
+		if (newPosition < 0 || newPosition >= context.virtualStack.entries.length) return null;
+		const from = context.virtualStack.entries[context.virtualStack.position].location;
+		context.virtualStack.position = newPosition;
+		const to = context.virtualStack.entries[newPosition].location;
+		this.save(contextKey);
+		return {
+			from,
+			to,
+			newPosition
+		};
+	}
+	setPosition(contextKey, position) {
+		const context = this.contexts.get(contextKey);
+		if (!context) return;
+		if (position >= 0 && position < context.virtualStack.entries.length) {
+			context.virtualStack.position = position;
+			this.save(contextKey);
+		}
+	}
+	ensureEntriesUpTo(contextKey, position, fallbackLocation) {
+		const context = this.contexts.get(contextKey);
+		if (!context) return;
+		while (context.virtualStack.entries.length <= position) context.virtualStack.entries.push({
+			location: fallbackLocation,
+			state: {}
+		});
+	}
+	addListener(contextKey, callback) {
+		const context = this.contexts.get(contextKey);
+		if (!context) throw new Error(`[VirtualStackManager] Context "${contextKey}" not found`);
+		context.listeners.add(callback);
+		return () => context.listeners.delete(callback);
+	}
+	notifyListeners(contextKey, to, from, info) {
+		const context = this.contexts.get(contextKey);
+		if (!context) return;
+		context.listeners.forEach((callback) => callback(to, from, info));
+	}
+	save(contextKey) {
+		const context = this.contexts.get(contextKey);
+		if (context) return this.storage.save(contextKey, context.virtualStack);
+	}
+	restore(contextKey) {
+		return this.storage.restore(contextKey);
+	}
+	saveActiveContext(contextKey) {
+		return this.storage.saveActiveContext(contextKey);
+	}
+	getStoredActiveContext() {
+		return this.storage.getActiveContext();
+	}
+	saveActiveHistoryContext(contextKey) {
+		return this.storage.saveActiveHistoryContext(contextKey);
+	}
+	getStoredActiveHistoryContext() {
+		return this.storage.getActiveHistoryContext();
+	}
+	entries() {
+		return this.contexts.entries();
+	}
+};
+
+//#endregion
+//#region src/history/manager.ts
+var ContextHistoryProxy = class {
+	constructor(contextKey, manager) {
+		this.contextKey = contextKey;
+		this.manager = manager;
+	}
+	get base() {
+		return this.manager.base;
+	}
+	get location() {
+		return this.manager.getContextLocation(this.contextKey);
+	}
+	get state() {
+		return this.manager.getContextState(this.contextKey);
+	}
+	push(to, data) {
+		this.manager.push(this.contextKey, to, data);
+	}
+	replace(to, data) {
+		this.manager.replace(this.contextKey, to, data);
+	}
+	go(delta, triggerListeners) {
+		this.manager.go(this.contextKey, delta, triggerListeners);
+	}
+	listen(callback) {
+		return this.manager.listen(this.contextKey, callback);
+	}
+	createHref(location) {
+		return this.manager.createHref(location);
+	}
+	destroy() {
+		this.manager.removeContextHistory(this.contextKey);
+	}
+};
+const CONTEXT_KEY_STATE = "__multiRouterContext";
+const STACK_INDEX_STATE = "__multiRouterStackIndex";
+var MultiRouterHistoryManager = class {
+	baseHistory;
+	stacks;
+	activeHistoryContextKey = null;
+	historyContextStack = [];
+	baseHistoryCleanup = null;
+	contextSwitchMode;
+	onContextActivate;
+	constructor(historyBuilder, options) {
+		this.baseHistory = historyBuilder();
+		this.stacks = new VirtualStackManager(options?.storageAdapter);
+		this.contextSwitchMode = options?.contextSwitchMode ?? "replace";
+		this.onContextActivate = options?.onContextActivate;
+		this.baseHistoryCleanup = this.baseHistory.listen(this.handlePopState.bind(this));
+	}
+	get base() {
+		return this.baseHistory.base;
+	}
+	get location() {
+		return this.baseHistory.location;
+	}
+	get state() {
+		return this.baseHistory.state;
+	}
+	createContextHistory(contextKey, options) {
+		if (this.stacks.has(contextKey)) return new ContextHistoryProxy(contextKey, this);
+		const { location, initialLocation, historyEnabled = true } = options ?? {};
+		return flatMapMaybePromise(this.stacks.getStoredActiveContext(), (lastActiveContext) => {
+			const isLastActive = lastActiveContext === contextKey;
+			if (location) {
+				const virtualStack = this.createInitialVirtualStack(location);
+				console.debug("[MultiRouterHistory] Created context with forced location", {
+					contextKey,
+					location
+				});
+				return this.finalizeContextCreation(contextKey, virtualStack, isLastActive, historyEnabled);
+			}
+			return mapMaybePromise(this.stacks.restore(contextKey), (restoredStack) => {
+				let virtualStack;
+				if (restoredStack) {
+					if (isLastActive && historyEnabled) {
+						const browserUrl = this.baseHistory.location;
+						restoredStack.entries[restoredStack.position] = {
+							location: browserUrl,
+							state: this.baseHistory.state ?? {}
+						};
+						console.debug("[MultiRouterHistory] Restored from storage with browser URL", {
+							contextKey,
+							browserUrl
+						});
+					} else console.debug("[MultiRouterHistory] Restored from storage", {
+						contextKey,
+						historyEnabled
+					});
+					virtualStack = restoredStack;
+				} else if (isLastActive && historyEnabled) {
+					const browserUrl = this.baseHistory.location;
+					virtualStack = this.createInitialVirtualStack(browserUrl);
+					console.debug("[MultiRouterHistory] Created with browser URL (last active)", {
+						contextKey,
+						browserUrl
+					});
+				} else if (initialLocation) {
+					virtualStack = this.createInitialVirtualStack(initialLocation);
+					console.debug("[MultiRouterHistory] Created with initialLocation", {
+						contextKey,
+						initialLocation
+					});
+				} else {
+					virtualStack = this.createInitialVirtualStack();
+					console.debug("[MultiRouterHistory] Created with default location", { contextKey });
+				}
+				return this.finalizeContextCreation(contextKey, virtualStack, isLastActive, historyEnabled);
+			});
+		});
+	}
+	finalizeContextCreation(contextKey, virtualStack, isLastActive, historyEnabled) {
+		this.stacks.create(contextKey, virtualStack, historyEnabled);
+		if (isLastActive && historyEnabled) {
+			this.activeHistoryContextKey = contextKey;
+			this.restoreUrlFromVirtualStack(contextKey);
+		}
+		return new ContextHistoryProxy(contextKey, this);
+	}
+	tryRestoreActiveHistoryContext(contextKey) {
+		return mapMaybePromise(this.stacks.getStoredActiveHistoryContext(), (storedKey) => {
+			if (storedKey === contextKey && this.stacks.has(contextKey) && this.stacks.isHistoryEnabled(contextKey)) {
+				this.activeHistoryContextKey = contextKey;
+				this.restoreUrlFromVirtualStack(contextKey);
+				return true;
+			}
+			return false;
+		});
+	}
+	removeContextHistory(contextKey) {
+		this.stacks.remove(contextKey);
+		if (this.activeHistoryContextKey === contextKey) this.fallbackToPreviousHistoryContext();
+		this.historyContextStack = this.historyContextStack.filter((k) => k !== contextKey);
+	}
+	setActiveHistoryContext(contextKey) {
+		if (!this.stacks.has(contextKey)) throw new Error(`[MultiRouterHistory] Context "${contextKey}" not registered`);
+		if (this.activeHistoryContextKey === contextKey) return;
+		const previousKey = this.activeHistoryContextKey;
+		if (previousKey) {
+			this.historyContextStack = this.historyContextStack.filter((k) => k !== previousKey);
+			this.historyContextStack.push(previousKey);
+		}
+		this.activeHistoryContextKey = contextKey;
+		this.stacks.saveActiveContext(contextKey);
+		this.stacks.saveActiveHistoryContext(contextKey);
+		this.restoreUrlFromVirtualStack(contextKey);
+		console.debug("[MultiRouterHistory] setActiveHistoryContext", {
+			from: previousKey,
+			to: contextKey
+		});
+	}
+	clearActiveHistoryContext(contextKey) {
+		if (this.activeHistoryContextKey !== contextKey) return;
+		this.fallbackToPreviousHistoryContext();
+	}
+	saveActiveContext(contextKey) {
+		this.stacks.saveActiveContext(contextKey);
+	}
+	getActiveHistoryContextKey() {
+		return this.activeHistoryContextKey;
+	}
+	fallbackToPreviousHistoryContext() {
+		const previousKey = this.historyContextStack.pop();
+		if (previousKey && this.stacks.has(previousKey)) this.activeHistoryContextKey = previousKey;
+		else this.activeHistoryContextKey = null;
+		console.debug("[MultiRouterHistory] fallbackToPreviousHistoryContext", { to: this.activeHistoryContextKey });
+	}
+	createInitialVirtualStack(initialLocation) {
+		return {
+			entries: [{
+				location: initialLocation ?? "/",
+				state: {}
+			}],
+			position: 0
+		};
+	}
+	restoreUrlFromVirtualStack(contextKey) {
+		if (this.contextSwitchMode === "none") return;
+		const context = this.stacks.get(contextKey);
+		if (!context) return;
+		const entry = context.virtualStack.entries[context.virtualStack.position];
+		if (!entry) return;
+		const state = {
+			...entry.state,
+			[CONTEXT_KEY_STATE]: contextKey,
+			[STACK_INDEX_STATE]: context.virtualStack.position
+		};
+		if (this.contextSwitchMode === "push") if (entry.location !== this.baseHistory.location) this.baseHistory.push(entry.location, state);
+		else this.baseHistory.replace(entry.location, state);
+		else this.baseHistory.replace(entry.location, state);
+	}
+	handlePopState(to, from, info) {
+		const stateContextKey = this.baseHistory.state?.[CONTEXT_KEY_STATE];
+		const stateStackIndex = this.baseHistory.state?.[STACK_INDEX_STATE];
+		console.debug("[MultiRouterHistory] popstate raw", {
+			stateContextKey,
+			stateStackIndex,
+			browserTo: to,
+			browserFrom: from,
+			delta: info.delta,
+			virtualStacks: Object.fromEntries(Array.from(this.stacks.entries()).map(([k, v]) => [k, {
+				position: v.virtualStack.position,
+				entries: v.virtualStack.entries.map((e) => e.location)
+			}]))
+		});
+		let ownerContextKey = null;
+		let targetStackIndex = null;
+		if (stateContextKey && this.stacks.has(stateContextKey)) {
+			ownerContextKey = stateContextKey;
+			targetStackIndex = stateStackIndex ?? null;
+		}
+		if (!ownerContextKey) ownerContextKey = this.activeHistoryContextKey;
+		if (!ownerContextKey) return;
+		const context = this.stacks.get(ownerContextKey);
+		let newPosition;
+		if (targetStackIndex !== null) newPosition = targetStackIndex;
+		else newPosition = context.virtualStack.position + info.delta;
+		this.stacks.ensureEntriesUpTo(ownerContextKey, newPosition, to);
+		if (newPosition >= 0 && newPosition < context.virtualStack.entries.length) {
+			const previousLocation = context.virtualStack.entries[context.virtualStack.position]?.location ?? from;
+			this.stacks.setPosition(ownerContextKey, newPosition);
+			const targetLocation = context.virtualStack.entries[newPosition]?.location ?? to;
+			console.debug("[MultiRouterHistory] popstate result", {
+				ownerContext: ownerContextKey,
+				activeContext: this.activeHistoryContextKey,
+				browserUrl: to,
+				contextUrl: targetLocation,
+				targetStackIndex: newPosition,
+				previousLocation,
+				delta: info.delta
+			});
+			if (this.onContextActivate) this.onContextActivate(ownerContextKey);
+			this.stacks.notifyListeners(ownerContextKey, targetLocation, previousLocation, info);
+		}
+	}
+	push(contextKey, to, data) {
+		const stackIndex = this.stacks.push(contextKey, to, data ?? {});
+		const historyEnabled = this.stacks.isHistoryEnabled(contextKey);
+		if (this.activeHistoryContextKey === contextKey && historyEnabled) this.baseHistory.push(to, {
+			...data,
+			[CONTEXT_KEY_STATE]: contextKey,
+			[STACK_INDEX_STATE]: stackIndex
+		});
+		console.debug("[MultiRouterHistory] push", {
+			contextKey,
+			to,
+			stackIndex,
+			isActive: this.activeHistoryContextKey === contextKey,
+			historyEnabled
+		});
+	}
+	replace(contextKey, to, data) {
+		const stackIndex = this.stacks.replace(contextKey, to, data ?? {});
+		const historyEnabled = this.stacks.isHistoryEnabled(contextKey);
+		if (this.activeHistoryContextKey === contextKey && historyEnabled) this.baseHistory.replace(to, {
+			...data,
+			[CONTEXT_KEY_STATE]: contextKey,
+			[STACK_INDEX_STATE]: stackIndex
+		});
+		console.debug("[MultiRouterHistory] replace", {
+			contextKey,
+			to,
+			stackIndex,
+			isActive: this.activeHistoryContextKey === contextKey,
+			historyEnabled
+		});
+	}
+	go(contextKey, delta, triggerListeners = true) {
+		if (!this.stacks.has(contextKey)) throw new Error(`[MultiRouterHistory] Context "${contextKey}" not registered`);
+		if (this.activeHistoryContextKey === contextKey) this.baseHistory.go(delta, triggerListeners);
+		else {
+			const result = this.stacks.navigate(contextKey, delta);
+			if (result && triggerListeners) this.stacks.notifyListeners(contextKey, result.to, result.from, {
+				type: NavigationType.pop,
+				direction: delta < 0 ? NavigationDirection.back : NavigationDirection.forward,
+				delta
+			});
+		}
+	}
+	listen(contextKey, callback) {
+		return this.stacks.addListener(contextKey, callback);
+	}
+	getContextLocation(contextKey) {
+		return this.stacks.getLocation(contextKey, this.baseHistory.location);
+	}
+	getContextState(contextKey) {
+		return this.stacks.getState(contextKey);
+	}
+	createHref(location) {
+		return this.baseHistory.createHref(location);
+	}
+	destroy() {
+		if (this.baseHistoryCleanup) {
+			this.baseHistoryCleanup();
+			this.baseHistoryCleanup = null;
+		}
+		this.stacks.clear();
+		this.baseHistory.destroy();
+	}
+	getLastActiveContextKey() {
+		return this.stacks.getStoredActiveContext();
+	}
+};
+
+//#endregion
+//#region src/contextManager.ts
+var MultiRouterManagerInstance = class {
+	started = false;
+	activeContext = shallowRef();
+	activeHistoryContext = shallowRef();
+	registered = /* @__PURE__ */ new Map();
+	onContextInitListeners = [];
+	historyManager;
+	constructor(app, types, historyManagerOptions, makeRouter) {
+		this.types = types;
+		this.makeRouter = makeRouter;
+		const { historyBuilder, ...historyOptions } = historyManagerOptions;
+		this.historyManager = new MultiRouterHistoryManager(historyBuilder, {
+			...historyOptions,
+			onContextActivate: (contextKey) => {
+				this.setActive(contextKey, false);
+			}
+		});
+	}
+	getHistoryManager() {
+		return this.historyManager;
+	}
+	getActiveContext() {
+		return this.activeContext.value;
+	}
+	getActiveContextRef() {
+		return this.activeContext;
+	}
+	getActiveHistoryContext() {
+		return this.activeHistoryContext.value;
+	}
+	getActiveHistoryContextRef() {
+		return this.activeHistoryContext;
+	}
+	setActive(key, updateHistory) {
+		const item = this.registered.get(key);
+		if (!item) throw new Error(`[MultiRouter] Context "${key}" not found`);
+		let modified = false;
+		if (this.activeContext.value?.key !== key) {
+			this.activeContext.value = {
+				key,
+				context: item
+			};
+			modified = true;
+		}
+		if (updateHistory) {
+			this.historyManager.saveActiveContext(key);
+			if (item.historyEnabled && this.activeHistoryContext.value?.key !== key) {
+				this.activeHistoryContext.value = this.activeContext.value;
+				this.historyManager.setActiveHistoryContext(key);
+			}
+		}
+		if (modified) console.debug("[MultiRouterContextManager] setActive", {
+			key,
+			updateHistory,
+			historyEnabled: item.historyEnabled
+		});
+		return modified;
+	}
+	clearHistoryContext(key) {
+		if (this.activeHistoryContext.value?.key === key) {
+			this.historyManager.clearActiveHistoryContext(key);
+			const newActiveKey = this.historyManager.getActiveHistoryContextKey();
+			if (newActiveKey) {
+				const newContext = this.registered.get(newActiveKey);
+				if (newContext) this.activeHistoryContext.value = {
+					key: newActiveKey,
+					context: newContext
+				};
+			} else this.activeHistoryContext.value = void 0;
+		}
+	}
+	markAsStarted() {
+		this.started = true;
+	}
+	getRouter(key) {
+		return this.registered.get(key).router;
+	}
+	has(key) {
+		return this.registered.has(key);
+	}
+	register(type, key, options) {
+		if (!this.types[type]) throw new Error(`[MultiRouter] Context type "${type}" not found`);
+		const historyEnabled = options?.historyEnabled ?? true;
+		const isDefault = options?.default ?? false;
+		return mapMaybePromise(this.historyManager.createContextHistory(key, {
+			location: options?.location,
+			initialLocation: options?.initialLocation,
+			historyEnabled
+		}), (history) => {
+			const router = this.makeRouter(key, history);
+			this.registered.set(key, {
+				type,
+				router,
+				history,
+				initialized: false,
+				historyEnabled
+			});
+			router.push(history.location).catch((err) => {
+				console.warn("Unexpected error when starting the router:", err);
+			});
+			router.isReady().then(() => {
+				this.markAsStarted();
+				mapMaybePromise(this.historyManager.tryRestoreActiveHistoryContext(key), (restored) => {
+					if (restored && !this.activeHistoryContext.value) {
+						console.debug("[MultiRouterContextManager] Restored activeHistoryContext", { key });
+						this.activeHistoryContext.value = {
+							key,
+							context: this.registered.get(key)
+						};
+					}
+				});
+				mapMaybePromise(this.historyManager.getLastActiveContextKey(), (resolvedLastActiveKey) => {
+					if (resolvedLastActiveKey === key && !this.activeContext.value) {
+						console.debug("[MultiRouterContextManager] Auto-activating last active context", { key });
+						this.setActive(key, true);
+					} else if (isDefault && !resolvedLastActiveKey && !this.activeContext.value) {
+						console.debug("[MultiRouterContextManager] Activating default context", {
+							key,
+							historyEnabled
+						});
+						this.setActive(key, true);
+					}
+				});
+			});
+		});
+	}
+	getContextLocation(key) {
+		return this.historyManager.getContextLocation(key);
+	}
+	getContextHistoryEnabled(key) {
+		return this.registered.get(key)?.historyEnabled ?? true;
+	}
+	unregister(key) {
+		if (this.registered.get(key)) {
+			console.debug("[MultiRouterContextManager] unregister", { key });
+			this.historyManager.removeContextHistory(key);
+			this.registered.delete(key);
+		}
+	}
+	initialize(key) {
+		this.registered.get(key).initialized = true;
+		this.onContextInitListeners.forEach((fn) => fn(key));
+	}
+	onContextInit(fn) {
+		if (this.started) throw new Error("[MultiRouter] adding listener after start is not allowed");
+		this.onContextInitListeners.push(fn);
+	}
+};
+
+//#endregion
+//#region src/symbols.ts
+const multiRouterContextManager = Symbol("multi-router-context-manager");
+const multiRouterContext = Symbol("multi-router-context-key");
+
+//#endregion
+//#region src/injectionSymbols.ts
+const multiRouterContextManagerKey = multiRouterContextManager;
+const multiRouterContextKey = multiRouterContext;
+
+//#endregion
+//#region src/multi-router.ts
+const START_LOCATION_NORMALIZED = {
+	path: "/",
+	name: void 0,
+	params: {},
+	query: {},
+	hash: "",
+	fullPath: "/",
+	matched: [],
+	meta: {},
+	redirectedFrom: void 0
+};
+const getCurrentInstance$1 = () => getCurrentInstance();
+function installContextAwareRouterResolvers(app, contextManager) {
+	if (app._context.provides[routerKey]) throw new Error("Router installed to app, this may cause unexpected behavior");
+	function isVueDevtoolsCall() {
+		return !!(/* @__PURE__ */ new Error()).stack?.includes("chrome-extension://nhdogjmejiglipccpnnnanhbledajbpd");
+	}
+	function getInstanceContextKey() {
+		const instance = getCurrentInstance$1();
+		if (!instance) {
+			if (isVueDevtoolsCall()) return null;
+			throw new Error("No instance found");
+		}
+		const contextKey = instance.provides[multiRouterContext];
+		if (!contextKey) throw new Error("Context key not found");
+		return contextKey;
+	}
+	const routerProperty = {
+		enumerable: true,
+		get() {
+			const contextKey = getInstanceContextKey();
+			if (!contextKey) return null;
+			if (!contextManager.has(contextKey)) {
+				if (isVueDevtoolsCall()) return null;
+				throw new Error(`Router not found for context ${contextKey}`);
+			}
+			return contextManager.getRouter(contextKey);
+		}
+	};
+	const routeProperty = {
+		enumerable: true,
+		get() {
+			const contextKey = getInstanceContextKey();
+			if (!contextKey || !contextManager.has(contextKey)) return null;
+			const currentRoute = contextManager.getRouter(contextKey).currentRoute;
+			const reactiveRoute = {};
+			for (const key in START_LOCATION_NORMALIZED) Object.defineProperty(reactiveRoute, key, {
+				get: () => currentRoute.value[key],
+				enumerable: true
+			});
+			return reactiveRoute;
+		}
+	};
+	Object.defineProperty(app._context.provides, routerKey, routerProperty);
+	Object.defineProperty(app.config.globalProperties, "$router", routerProperty);
+	Object.defineProperty(app._context.provides, routeLocationKey, routeProperty);
+	Object.defineProperty(app.config.globalProperties, "$route", routeProperty);
+	Object.defineProperty(app._context.provides, routerViewLocationKey, {
+		enumerable: true,
+		configurable: true,
+		get() {
+			const contextKey = getInstanceContextKey();
+			if (!contextKey || !contextManager.has(contextKey)) return null;
+			return contextManager.getRouter(contextKey).currentRoute;
+		},
+		set() {}
+	});
+}
+function installComponents(app) {
+	app.component("RouterLink", RouterLink);
+	app.component("RouterView", RouterView);
+}
+const contextTemplateWindows = { window: {
+	canUseAsHistoryContext: true,
+	single: false
+} };
+const contextTemplateTabs = { tab: {
+	canUseAsHistoryContext: true,
+	single: false
+} };
+const contextTemplateMainWithWindows = {
+	main: {
+		canUseAsHistoryContext: true,
+		single: true
+	},
+	...contextTemplateWindows
+};
+const contextTemplateDesktopWithWindows = {
+	desktop: {
+		canUseAsHistoryContext: false,
+		single: true
+	},
+	...contextTemplateWindows
+};
+const contextTemplateTabsWithWindows = {
+	...contextTemplateTabs,
+	...contextTemplateWindows
+};
+function createMultiRouter(options) {
+	let contextManager;
+	return {
+		getByContextName: (name) => {
+			return contextManager.getRouter(name);
+		},
+		install: (app) => {
+			const makeRouter = (contextKey, history) => {
+				const router = createRouter({
+					...options,
+					history
+				});
+				Object.assign(router, { contextKey });
+				return router;
+			};
+			contextManager = new MultiRouterManagerInstance(app, options.types, {
+				historyBuilder: options.history,
+				...options.historyOptions
+			}, makeRouter);
+			app.provide(multiRouterContextManagerKey, contextManager);
+			installComponents(app);
+			installContextAwareRouterResolvers(app, contextManager);
+		}
+	};
+}
+
+//#endregion
+//#region src/components/MultiRouterContext.vue?vue&type=script&lang.ts
+const MultiRouterContextInner = defineComponent({
+	name: "MultiRouterContextInner",
+	props: {
+		type: {
+			type: String,
+			required: true
+		},
+		name: {
+			type: String,
+			required: true
+		},
+		location: {
+			type: String,
+			required: false
+		},
+		initialLocation: {
+			type: String,
+			required: false
+		},
+		historyEnabled: {
+			type: Boolean,
+			default: true
+		},
+		default: {
+			type: Boolean,
+			default: false
+		}
+	},
+	setup(props, { slots }) {
+		const manager = inject(multiRouterContextManagerKey);
+		console.debug("[MultiRouterContext] setup", {
+			type: props.type,
+			name: props.name,
+			location: props.location,
+			initialLocation: props.initialLocation
+		});
+		if (manager.has(props.name)) {
+			console.warn(`[MultiRouterContext] Context "${props.name}" already registered, skipping`);
+			return () => slots.default?.();
+		}
+		manager.register(props.type, props.name, {
+			location: props.location,
+			initialLocation: props.initialLocation,
+			historyEnabled: props.historyEnabled,
+			default: props.default
+		});
+		provide(multiRouterContext, props.name);
+		provide(viewDepthKey, ref(0));
+		onBeforeUnmount(() => {
+			manager.unregister(props.name);
+		});
+		return () => slots.default?.();
+	}
+});
+var MultiRouterContext_vue_vue_type_script_lang_default = defineComponent({
+	name: "MultiRouterContext",
+	props: {
+		type: {
+			type: String,
+			required: true
+		},
+		name: {
+			type: String,
+			required: true
+		},
+		location: {
+			type: String,
+			required: false
+		},
+		initialLocation: {
+			type: String,
+			required: false
+		},
+		historyEnabled: {
+			type: Boolean,
+			default: true
+		},
+		default: {
+			type: Boolean,
+			default: false
+		}
+	},
+	setup(props, { slots }) {
+		return () => h(MultiRouterContextInner, {
+			key: `${props.name}:${props.location ?? ""}`,
+			type: props.type,
+			name: props.name,
+			location: props.location,
+			initialLocation: props.initialLocation,
+			historyEnabled: props.historyEnabled,
+			default: props.default
+		}, slots.default);
+	}
+});
+
+//#endregion
+//#region src/components/MultiRouterContext.vue
+var MultiRouterContext_default = MultiRouterContext_vue_vue_type_script_lang_default;
+
+//#endregion
+//#region src/components/MultiRouterContextActivator.vue?vue&type=script&lang.ts
+var MultiRouterContextActivator_vue_vue_type_script_lang_default = defineComponent({
+	props: { as: {
+		type: String,
+		default: null
+	} },
+	setup(props, { slots }) {
+		const contextKey = inject(multiRouterContextKey);
+		const manager = inject(multiRouterContextManagerKey);
+		if (!contextKey || !manager) {
+			console.warn("[MultiRouterContextActivator] Must be used within MultiRouterContext");
+			return () => slots.default?.();
+		}
+		const onActivate = (e) => {
+			e.stopPropagation();
+			if (manager.setActive(contextKey, true)) console.debug("[MultiRouterContextActivator] activated", contextKey);
+		};
+		return () => {
+			const children = slots.default?.();
+			if (!props.as) {
+				if (children && children.length === 1) return h(children[0], { onMousedown: onActivate });
+				return h("span", { onMousedown: onActivate }, children);
+			}
+			return h(props.as, { onMousedown: onActivate }, children);
+		};
+	}
+});
+
+//#endregion
+//#region src/components/MultiRouterContextActivator.vue
+var MultiRouterContextActivator_default = MultiRouterContextActivator_vue_vue_type_script_lang_default;
+
+//#endregion
+//#region src/composables/useMultiRouterContext.ts
+function useMultiRouterContext() {
+	const manager = inject(multiRouterContextManagerKey);
+	const contextKey = inject(multiRouterContextKey);
+	if (!manager) throw new Error("[useMultiRouterContext] Must be used within MultiRouterContextProvider");
+	if (!contextKey) throw new Error("[useMultiRouterContext] Must be used within MultiRouterContext");
+	const router = computed(() => manager.getRouter(contextKey));
+	const route = computed(() => router.value.currentRoute.value);
+	const isActive = computed(() => manager.getActiveContextRef().value?.key === contextKey);
+	const activeContextKey = computed(() => manager.getActiveContextRef().value?.key);
+	const activeHistoryContextKey = computed(() => manager.getActiveHistoryContextRef().value?.key);
+	const isHistoryActive = computed(() => manager.getActiveHistoryContextRef().value?.key === contextKey);
+	const historyEnabled = computed(() => manager.getContextHistoryEnabled(contextKey));
+	const activate = (updateHistory = true) => {
+		manager.setActive(contextKey, updateHistory);
+	};
+	return {
+		manager,
+		contextKey,
+		router,
+		route,
+		isActive,
+		isHistoryActive,
+		activeContextKey,
+		activeHistoryContextKey,
+		historyEnabled,
+		activate
+	};
+}
+
+//#endregion
+export { MultiRouterContext_default as MultiRouterContext, MultiRouterContextActivator_default as MultiRouterContextActivator, contextTemplateDesktopWithWindows, contextTemplateMainWithWindows, contextTemplateTabs, contextTemplateTabsWithWindows, contextTemplateWindows, createMultiRouter, multiRouterContextKey, multiRouterContextManagerKey, useMultiRouterContext };