@hybridly/core 0.8.3 → 0.10.0-beta.1

package/dist/index.mjs

@@ -1,8 +1,24 @@
-import { debug, merge, removeTrailingSlash, debounce, random, hasFiles, objectToFormData, match, showResponseErrorModal, when } from '@hybridly/utils';
-import qs from 'qs';
-import axios from 'axios';
-import { parse, stringify } from 'superjson';
+import { t as __exportAll } from "./_chunks/chunk.mjs";
+import { debounce, debug, hasFiles, match, merge, objectToFormData, random, removeTrailingSlash, showResponseErrorModal, when } from "@hybridly/utils";
+import axios from "axios";
+import { parse, stringify } from "superjson";
+import qs from "qs";
 
+//#region src/constants.ts
+var constants_exports = /* @__PURE__ */ __exportAll({
+	DIALOG_KEY_HEADER: () => DIALOG_KEY_HEADER,
+	DIALOG_REDIRECT_HEADER: () => DIALOG_REDIRECT_HEADER,
+	ERROR_BAG_HEADER: () => ERROR_BAG_HEADER,
+	EXCEPT_DATA_HEADER: () => EXCEPT_DATA_HEADER,
+	EXTERNAL_NAVIGATION_HEADER: () => EXTERNAL_NAVIGATION_HEADER,
+	EXTERNAL_NAVIGATION_TARGET_HEADER: () => EXTERNAL_NAVIGATION_TARGET_HEADER,
+	HYBRIDLY_HEADER: () => HYBRIDLY_HEADER,
+	ONLY_DATA_HEADER: () => ONLY_DATA_HEADER,
+	PARTIAL_COMPONENT_HEADER: () => PARTIAL_COMPONENT_HEADER,
+	SCROLL_REGION_ATTRIBUTE: () => SCROLL_REGION_ATTRIBUTE,
+	STORAGE_EXTERNAL_KEY: () => STORAGE_EXTERNAL_KEY,
+	VERSION_HEADER: () => VERSION_HEADER
+});
 const STORAGE_EXTERNAL_KEY = "hybridly:external";
 const HYBRIDLY_HEADER = "x-hybrid";
 const EXTERNAL_NAVIGATION_HEADER = `${HYBRIDLY_HEADER}-external`;
@@ -16,1077 +32,1158 @@ const VERSION_HEADER = `${HYBRIDLY_HEADER}-version`;
 const ERROR_BAG_HEADER = `${HYBRIDLY_HEADER}-error-bag`;
 const SCROLL_REGION_ATTRIBUTE = "scroll-region";
 
-const constants = {
-	__proto__: null,
-	DIALOG_KEY_HEADER: DIALOG_KEY_HEADER,
-	DIALOG_REDIRECT_HEADER: DIALOG_REDIRECT_HEADER,
-	ERROR_BAG_HEADER: ERROR_BAG_HEADER,
-	EXCEPT_DATA_HEADER: EXCEPT_DATA_HEADER,
-	EXTERNAL_NAVIGATION_HEADER: EXTERNAL_NAVIGATION_HEADER,
-	EXTERNAL_NAVIGATION_TARGET_HEADER: EXTERNAL_NAVIGATION_TARGET_HEADER,
-	HYBRIDLY_HEADER: HYBRIDLY_HEADER,
-	ONLY_DATA_HEADER: ONLY_DATA_HEADER,
-	PARTIAL_COMPONENT_HEADER: PARTIAL_COMPONENT_HEADER,
-	SCROLL_REGION_ATTRIBUTE: SCROLL_REGION_ATTRIBUTE,
-	STORAGE_EXTERNAL_KEY: STORAGE_EXTERNAL_KEY,
-	VERSION_HEADER: VERSION_HEADER
+//#endregion
+//#region src/errors.ts
+var NotAHybridResponseError = class extends Error {
+	constructor(response) {
+		super();
+		this.response = response;
+	}
+};
+var NavigationCancelledError = class extends Error {};
+var RoutingNotInitialized = class extends Error {
+	constructor() {
+		super("Routing is not initialized. Make sure the Vite plugin is enabled and that `php artisan route:list` returns no error.");
+	}
+};
+var RouteNotFound = class extends Error {
+	constructor(name) {
+		super(`Route [${name}] does not exist.`);
+	}
+};
+var MissingRouteParameter = class extends Error {
+	constructor(parameter, routeName) {
+		super(`Parameter [${parameter}] is required for route [${routeName}].`);
+	}
 };
 
-class NotAHybridResponseError extends Error {
-  constructor(response) {
-    super();
-    this.response = response;
-  }
-}
-class NavigationCancelledError extends Error {
-}
-class RoutingNotInitialized extends Error {
-  constructor() {
-    super("Routing is not initialized. Make sure the Vite plugin is enabled and that `php artisan route:list` returns no error.");
-  }
-}
-class RouteNotFound extends Error {
-  constructor(name) {
-    super(`Route [${name}] does not exist.`);
-  }
-}
-class MissingRouteParameter extends Error {
-  constructor(parameter, routeName) {
-    super(`Parameter [${parameter}] is required for route [${routeName}].`);
-  }
-}
-
+//#endregion
+//#region src/plugins/plugin.ts
 function definePlugin(plugin) {
-  return plugin;
+	return plugin;
 }
 async function forEachPlugin(cb) {
-  const { plugins } = getRouterContext();
-  for (const plugin of plugins) {
-    await cb(plugin);
-  }
+	const { plugins } = getRouterContext();
+	for (const plugin of plugins) await cb(plugin);
 }
 async function runPluginHooks(hook, ...args) {
-  let result = true;
-  await forEachPlugin(async (plugin) => {
-    if (plugin[hook]) {
-      debug.plugin(plugin.name, `Calling "${hook}" hook.`);
-      result &&= await plugin[hook]?.(...args) !== false;
-    }
-  });
-  return result;
+	let result = true;
+	await forEachPlugin(async (plugin) => {
+		if (plugin[hook]) {
+			debug.plugin(plugin.name, `Calling "${hook}" hook.`);
+			result &&= await plugin[hook]?.(...args) !== false;
+		}
+	});
+	return result;
 }
 async function runGlobalHooks(hook, ...args) {
-  const { hooks } = getRouterContext();
-  if (!hooks[hook]) {
-    return true;
-  }
-  let result = true;
-  for (const fn of hooks[hook]) {
-    debug.hook(`Calling global "${hook}" hooks.`);
-    result = await fn(...args) ?? result;
-  }
-  return result;
+	const { hooks } = getRouterContext();
+	if (!hooks[hook]) return true;
+	let result = true;
+	for (const fn of hooks[hook]) {
+		debug.hook(`Calling global "${hook}" hooks.`);
+		result = await fn(...args) ?? result;
+	}
+	return result;
 }
 async function runHooks(hook, requestHooks, ...args) {
-  const result = await Promise.all([
-    requestHooks?.[hook]?.(...args),
-    runGlobalHooks(hook, ...args),
-    runPluginHooks(hook, ...args)
-  ]);
-  debug.hook(`Called all hooks for [${hook}],`, result);
-  return !result.includes(false);
+	const result = await Promise.all([
+		requestHooks?.[hook]?.(...args),
+		runGlobalHooks(hook, ...args),
+		runPluginHooks(hook, ...args)
+	]);
+	debug.hook(`Called all hooks for [${hook}],`, result);
+	return !result.includes(false);
 }
 
+//#endregion
+//#region src/plugins/hooks.ts
+/**
+* Registers a global hook.
+*/
 function appendCallbackToHooks(hook, fn) {
-  const hooks = getRouterContext().hooks;
-  hooks[hook] = [...hooks[hook] ?? [], fn];
-  return () => {
-    const index = hooks[hook].indexOf(fn);
-    if (index !== -1) {
-      hooks[hook]?.splice(index, 1);
-    }
-  };
-}
+	const hooks = getRouterContext().hooks;
+	hooks[hook] = [...hooks[hook] ?? [], fn];
+	return () => {
+		const index = hooks[hook].indexOf(fn);
+		if (index !== -1) hooks[hook]?.splice(index, 1);
+	};
+}
+/**
+* Registers a global hook.
+*/
 function registerHook(hook, fn, options) {
-  if (options?.once) {
-    const unregister = appendCallbackToHooks(hook, async (...args) => {
-      await fn(...args);
-      unregister();
-    });
-    return unregister;
-  }
-  return appendCallbackToHooks(hook, fn);
+	if (options?.once) {
+		const unregister = appendCallbackToHooks(hook, async (...args) => {
+			await fn(...args);
+			unregister();
+		});
+		return unregister;
+	}
+	return appendCallbackToHooks(hook, fn);
 }
 
+//#endregion
+//#region src/scroll.ts
+/** Saves the current view's scrollbar positions into the history state. */
 function saveScrollPositions() {
-  const regions = getScrollRegions();
-  debug.scroll("Saving scroll positions of:", regions.map((el) => ({ el, scroll: { top: el.scrollTop, left: el.scrollLeft } })));
-  setContext({
-    scrollRegions: regions.map(({ scrollTop, scrollLeft }) => ({
-      top: scrollTop,
-      left: scrollLeft
-    }))
-  });
-  setHistoryState({ replace: true });
-}
+	const regions = getScrollRegions();
+	debug.scroll("Saving scroll positions of:", regions.map((el) => ({
+		el,
+		scroll: {
+			top: el.scrollTop,
+			left: el.scrollLeft
+		}
+	})));
+	setContext({ scrollRegions: regions.map(({ scrollTop, scrollLeft }) => ({
+		top: scrollTop,
+		left: scrollLeft
+	})) });
+	setHistoryState({ replace: true });
+}
+/** Gets DOM elements which scroll positions should be saved. */
 function getScrollRegions() {
-  return Array.from(document?.querySelectorAll(`[${SCROLL_REGION_ATTRIBUTE}]`) ?? []).concat(document.documentElement, document.body);
+	return Array.from(document?.querySelectorAll(`[${SCROLL_REGION_ATTRIBUTE}]`) ?? []).concat(document.documentElement, document.body);
 }
+/**
+* Resets the current view's scrollbars positions to the top, and save them
+* in the history state.
+*/
 function resetScrollPositions() {
-  debug.scroll("Resetting scroll positions.");
-  getScrollRegions().forEach((element) => element.scrollTo({
-    top: 0,
-    left: 0
-  }));
-  saveScrollPositions();
-  if (window.location.hash) {
-    debug.scroll(`Hash is present, scrolling to the element of ID ${window.location.hash}.`);
-    document.getElementById(window.location.hash.slice(1))?.scrollIntoView();
-  }
-}
+	debug.scroll("Resetting scroll positions.");
+	getScrollRegions().forEach((element) => element.scrollTo({
+		top: 0,
+		left: 0
+	}));
+	saveScrollPositions();
+	if (window.location.hash) {
+		debug.scroll(`Hash is present, scrolling to the element of ID ${window.location.hash}.`);
+		document.getElementById(window.location.hash.slice(1))?.scrollIntoView();
+	}
+}
+/** Restores the scroll positions stored in the context. */
 async function restoreScrollPositions() {
-  const context = getRouterContext();
-  const regions = getScrollRegions();
-  if (!context.scrollRegions) {
-    debug.scroll("No region found to restore.");
-    return;
-  }
-  context.adapter.executeOnMounted(() => {
-    debug.scroll(`Restoring ${regions.length}/${context.scrollRegions.length} region(s).`);
-    regions.forEach((el, i) => el.scrollTo({
-      top: context.scrollRegions.at(i)?.top ?? el.scrollTop,
-      left: context.scrollRegions.at(i)?.top ?? el.scrollLeft
-    }));
-  });
+	const context = getRouterContext();
+	const regions = getScrollRegions();
+	if (!context.scrollRegions) {
+		debug.scroll("No region found to restore.");
+		return;
+	}
+	context.adapter.executeOnMounted(() => {
+		debug.scroll(`Restoring ${regions.length}/${context.scrollRegions.length} region(s).`);
+		regions.forEach((el, i) => el.scrollTo({
+			top: context.scrollRegions.at(i)?.top ?? el.scrollTop,
+			left: context.scrollRegions.at(i)?.top ?? el.scrollLeft
+		}));
+	});
 }
 
+//#endregion
+//#region src/url.ts
+/** Normalizes the given input to an URL. */
 function normalizeUrl(href, trailingSlash) {
-  return makeUrl(href, { trailingSlash }).toString();
+	return makeUrl(href, { trailingSlash }).toString();
 }
+/**
+* Converts an input to an URL, optionally changing its properties after initialization.
+*/
 function makeUrl(href, transformations = {}) {
-  try {
-    const base = document?.location?.href === "//" ? void 0 : document.location.href;
-    const url = new URL(String(href), base);
-    transformations = typeof transformations === "function" ? transformations(url) ?? {} : transformations ?? {};
-    Object.entries(transformations).forEach(([key, value]) => {
-      if (key === "query") {
-        const currentQueryParameters = merge(
-          qs.parse(url.search, { ignoreQueryPrefix: true }),
-          value,
-          { mergePlainObjects: true }
-        );
-        key = "search";
-        value = qs.stringify(currentQueryParameters, {
-          encodeValuesOnly: true,
-          arrayFormat: "brackets",
-          filter: (_, object) => object instanceof Set ? [...object] : object
-        });
-      }
-      Reflect.set(url, key, value);
-    });
-    if (transformations.trailingSlash === false) {
-      const _url = removeTrailingSlash(url.toString().replace(/\/\?/, "?"));
-      url.toString = () => _url;
-    }
-    return url;
-  } catch (error) {
-    throw new TypeError(`${href} is not resolvable to a valid URL.`);
-  }
-}
+	try {
+		const base = document?.location?.href === "//" ? void 0 : document.location.href;
+		const url = new URL(String(href), base);
+		transformations = typeof transformations === "function" ? transformations(url) ?? {} : transformations ?? {};
+		Object.entries(transformations).forEach(([key, value]) => {
+			if (key === "query") {
+				const currentQueryParameters = merge(qs.parse(url.search, { ignoreQueryPrefix: true }), value, { mergePlainObjects: true });
+				key = "search";
+				value = qs.stringify(currentQueryParameters, {
+					encodeValuesOnly: true,
+					arrayFormat: "brackets",
+					filter: (_, object) => object instanceof Set ? [...object] : object
+				});
+			}
+			Reflect.set(url, key, value);
+		});
+		if (transformations.trailingSlash === false) {
+			const _url = removeTrailingSlash(url.toString().replace(/\/\?/, "?"));
+			url.toString = () => _url;
+		}
+		return url;
+	} catch (error) {
+		throw new TypeError(`${href} is not resolvable to a valid URL.`);
+	}
+}
+/**
+* Checks if the given URLs have the same origin and path.
+*/
 function sameUrls(...hrefs) {
-  if (hrefs.length < 2) {
-    return true;
-  }
-  try {
-    return hrefs.every((href) => {
-      return makeUrl(href, { hash: "" }).toJSON() === makeUrl(hrefs.at(0), { hash: "" }).toJSON();
-    });
-  } catch {
-  }
-  return false;
-}
+	if (hrefs.length < 2) return true;
+	try {
+		return hrefs.every((href) => {
+			return makeUrl(href, { hash: "" }).toJSON() === makeUrl(hrefs.at(0), { hash: "" }).toJSON();
+		});
+	} catch {}
+	return false;
+}
+/**
+* Checks if the given URLs have the same origin, path, and hash.
+*/
 function sameHashes(...hrefs) {
-  if (hrefs.length < 2) {
-    return true;
-  }
-  try {
-    return hrefs.every((href) => {
-      return makeUrl(href).toJSON() === makeUrl(hrefs.at(0)).toJSON();
-    });
-  } catch {
-  }
-  return false;
-}
+	if (hrefs.length < 2) return true;
+	try {
+		return hrefs.every((href) => {
+			return makeUrl(href).toJSON() === makeUrl(hrefs.at(0)).toJSON();
+		});
+	} catch {}
+	return false;
+}
+/**
+* If the back-end did not specify a hash, if the navigation specified one,
+* and both URLs lead to the same endpoint, we update the target URL
+* to use the hash of the initially-requested URL.
+*/
 function fillHash(currentUrl, targetUrl) {
-  currentUrl = makeUrl(currentUrl);
-  targetUrl = makeUrl(targetUrl);
-  if (currentUrl.hash && !targetUrl.hash && sameUrls(targetUrl, currentUrl)) {
-    targetUrl.hash = currentUrl.hash;
-  }
-  return targetUrl.toString();
+	currentUrl = makeUrl(currentUrl);
+	targetUrl = makeUrl(targetUrl);
+	if (currentUrl.hash && !targetUrl.hash && sameUrls(targetUrl, currentUrl)) targetUrl.hash = currentUrl.hash;
+	return targetUrl.toString();
 }
 
+//#endregion
+//#region src/router/history.ts
+/** Puts the given context into the history state. */
 function setHistoryState(options = {}) {
-  if (!window?.history) {
-    throw new Error("The history API is not available, so Hybridly cannot operate.");
-  }
-  const context = getRouterContext();
-  const method = options.replace ? "replaceState" : "pushState";
-  const serialized = serializeContext(context);
-  debug.history("Setting history state:", {
-    method,
-    context
-    // serialized,
-  });
-  try {
-    window.history[method](serialized, "", context.url);
-  } catch (error) {
-    console.error("Hybridly could not save its current state in the history. This is most likely due to a property being non-serializable, such as a proxy or a reference.");
-    throw error;
-  }
-}
+	if (!window?.history) throw new Error("The history API is not available, so Hybridly cannot operate.");
+	const context = getRouterContext();
+	const method = options.replace ? "replaceState" : "pushState";
+	const serialized = serializeContext(context);
+	debug.history("Setting history state:", {
+		method,
+		context
+	});
+	try {
+		window.history[method](serialized, "", context.url);
+	} catch (error) {
+		console.error("Hybridly could not save its current state in the history. This is most likely due to a property being non-serializable, such as a proxy or a reference.");
+		throw error;
+	}
+}
+/** Gets the current history data if it exists. */
 function getHistoryState() {
-  return getRouterContext().serializer.unserialize(window.history.state);
+	return getRouterContext().serializer.unserialize(window.history.state);
 }
+/** Gets the current history state if it exists. */
 function getHistoryMemo(key) {
-  const state = getHistoryState();
-  return key ? state?.memo?.[key] : state?.memo;
+	const state$1 = getHistoryState();
+	return key ? state$1?.memo?.[key] : state$1?.memo;
 }
+/** Register history-related event listeneners. */
 async function registerEventListeners() {
-  const context = getRouterContext();
-  debug.history("Registering [popstate] and [scroll] event listeners.");
-  window?.addEventListener("popstate", async (event) => {
-    debug.history("Navigation detected (popstate event). State:", { state: event.state });
-    if (context.pendingNavigation) {
-      debug.router("Aborting current navigation.", context.pendingNavigation);
-      context.pendingNavigation?.controller?.abort();
-    }
-    const state = context.serializer.unserialize(event.state);
-    await runHooks("backForward", {}, state, context);
-    if (!state) {
-      debug.history("There is no state. Adding hash if any and restoring scroll positions.");
-      return await navigate({
-        type: "initial",
-        payload: {
-          ...context,
-          url: makeUrl(context.url, { hash: window.location.hash }).toString()
-        },
-        preserveScroll: true,
-        preserveState: true,
-        replace: true
-      });
-    }
-    await navigate({
-      type: "back-forward",
-      payload: state,
-      preserveScroll: true,
-      preserveState: !!getInternalRouterContext().dialog || !!state.dialog,
-      updateHistoryState: false
-    });
-  });
-  window?.addEventListener("scroll", (event) => debounce(100, () => {
-    if (event?.target?.hasAttribute?.(SCROLL_REGION_ATTRIBUTE)) {
-      saveScrollPositions();
-    }
-  }), true);
-}
+	const context = getRouterContext();
+	debug.history("Registering [popstate] and [scroll] event listeners.");
+	window?.addEventListener("popstate", async (event) => {
+		debug.history("Navigation detected (popstate event). State:", { state: event.state });
+		if (context.pendingNavigation) {
+			debug.router("Aborting current navigation.", context.pendingNavigation);
+			context.pendingNavigation?.controller?.abort();
+		}
+		const state$1 = context.serializer.unserialize(event.state);
+		await runHooks("backForward", {}, state$1, context);
+		if (!state$1) {
+			debug.history("There is no state. Adding hash if any and restoring scroll positions.");
+			return await navigate({
+				type: "initial",
+				payload: {
+					...context,
+					url: makeUrl(context.url, { hash: window.location.hash }).toString()
+				},
+				preserveScroll: true,
+				preserveState: true,
+				replace: true
+			});
+		}
+		await navigate({
+			type: "back-forward",
+			payload: state$1,
+			preserveScroll: true,
+			preserveState: !!getInternalRouterContext().dialog || !!state$1.dialog,
+			updateHistoryState: false
+		});
+	});
+	window?.addEventListener("scroll", (event) => debounce(100, () => {
+		if ((event?.target)?.hasAttribute?.(SCROLL_REGION_ATTRIBUTE)) saveScrollPositions();
+	}), true);
+}
+/** Checks if the current navigation was made by going back or forward. */
 function isBackForwardNavigation() {
-  if (!window.history.state) {
-    return false;
-  }
-  return window.performance?.getEntriesByType("navigation").at(0)?.type === "back_forward";
+	if (!window.history.state) return false;
+	return (window.performance?.getEntriesByType("navigation").at(0))?.type === "back_forward";
 }
+/** Handles a navigation which was going back or forward. */
 async function handleBackForwardNavigation() {
-  debug.router("Handling a back/forward navigation from an external URL.");
-  const context = getRouterContext();
-  const state = getHistoryState();
-  if (!state) {
-    throw new Error("Tried to handling a back/forward navigation, but there was no state in the history. This should not happen.");
-  }
-  await navigate({
-    type: "back-forward",
-    payload: {
-      ...state,
-      version: context.version
-    },
-    preserveScroll: true,
-    preserveState: false,
-    updateHistoryState: false
-  });
-}
+	debug.router("Handling a back/forward navigation from an external URL.");
+	const context = getRouterContext();
+	const state$1 = getHistoryState();
+	if (!state$1) throw new Error("Tried to handling a back/forward navigation, but there was no state in the history. This should not happen.");
+	await navigate({
+		type: "back-forward",
+		payload: {
+			...state$1,
+			version: context.version
+		},
+		preserveScroll: true,
+		preserveState: false,
+		updateHistoryState: false
+	});
+}
+/** Saves a value into the current history state. */
 function remember(key, value) {
-  debug.history(`Remembering key "${key}" with value`, value);
-  setContext({
-    memo: {
-      ...getHistoryMemo(),
-      [key]: value
-    }
-  }, { propagate: false });
-  setHistoryState({ replace: true });
-}
+	debug.history(`Remembering key "${key}" with value`, value);
+	setContext({ memo: {
+		...getHistoryMemo(),
+		[key]: value
+	} }, { propagate: false });
+	setHistoryState({ replace: true });
+}
+/** Serializes the context so it can be written to the history state. */
 function serializeContext(context) {
-  return context.serializer.serialize({
-    url: context.url,
-    version: context.version,
-    view: context.view,
-    dialog: context.dialog,
-    scrollRegions: context.scrollRegions,
-    memo: context.memo
-  });
+	return context.serializer.serialize({
+		url: context.url,
+		version: context.version,
+		view: context.view,
+		dialog: context.dialog,
+		scrollRegions: context.scrollRegions,
+		memo: context.memo
+	});
 }
 function createSerializer(options) {
-  if (options.serializer) {
-    return options.serializer;
-  }
-  return {
-    serialize: (data) => {
-      debug.history("Serializing data.", data);
-      return stringify(data);
-    },
-    unserialize: (data) => {
-      if (!data) {
-        debug.history("No data to unserialize.");
-        return;
-      }
-      return parse(data);
-    }
-  };
+	if (options.serializer) return options.serializer;
+	return {
+		serialize: (data) => {
+			debug.history("Serializing data.", data);
+			return stringify(data);
+		},
+		unserialize: (data) => {
+			if (!data) {
+				debug.history("No data to unserialize.");
+				return;
+			}
+			return parse(data);
+		}
+	};
 }
 
+//#endregion
+//#region src/routing/route.ts
 function getUrlRegexForRoute(name) {
-  const routing = getRouting();
-  const definition = getRouteDefinition(name);
-  const path = definition.uri.replaceAll("/", "\\/");
-  const domain = definition.domain;
-  const protocolPrefix = routing.url.match(/^\w+:\/\//)?.[0];
-  const origin = domain ? `${protocolPrefix}${domain}${routing.port ? `:${routing.port}` : ""}`.replaceAll("/", "\\/") : routing.url.replaceAll("/", "\\/");
-  const urlPathRegexPattern = path.length > 0 ? `\\/${path.replace(/\/$/g, "")}` : "";
-  let urlRegexPattern = `^${origin.replaceAll(".", "\\.")}${urlPathRegexPattern}\\/?(\\?.*)?$`;
-  urlRegexPattern = urlRegexPattern.replace(/(\\\/?){([^}?]+)(\??)}/g, (_, slash, parameterName, optional) => {
-    const where = definition.wheres?.[parameterName];
-    let regexTemplate = where?.replace(/(^\^)|(\$$)/g, "") || "[^/?]+";
-    regexTemplate = `(?<${parameterName}>${regexTemplate})`;
-    if (optional) {
-      return `(${slash ? "\\/?" : ""}${regexTemplate})?`;
-    }
-    return (slash ? "\\/" : "") + regexTemplate;
-  });
-  return RegExp(urlRegexPattern);
-}
+	const routing = getRouting();
+	const definition = getRouteDefinition(name);
+	const path = definition.uri.replaceAll("/", "\\/");
+	const domain = definition.domain;
+	const protocolPrefix = routing.url.match(/^\w+:\/\//)?.[0];
+	const origin = domain ? `${protocolPrefix}${domain}${routing.port ? `:${routing.port}` : ""}`.replaceAll("/", "\\/") : routing.url.replaceAll("/", "\\/");
+	const urlPathRegexPattern = path.length > 0 ? `\\/${path.replace(/\/$/g, "")}` : "";
+	let urlRegexPattern = `^${origin.replaceAll(".", "\\.")}${urlPathRegexPattern}\\/?(\\?.*)?$`;
+	urlRegexPattern = urlRegexPattern.replace(/(\\\/?){([^}?]+)(\??)}/g, (_, slash, parameterName, optional) => {
+		let regexTemplate = (definition.wheres?.[parameterName])?.replace(/(^\^)|(\$$)/g, "") || "[^/?]+";
+		regexTemplate = `(?<${parameterName}>${regexTemplate})`;
+		if (optional) return `(${slash ? "\\/?" : ""}${regexTemplate})?`;
+		return (slash ? "\\/" : "") + regexTemplate;
+	});
+	return RegExp(urlRegexPattern);
+}
+/**
+* Check if a given URL matches a route based on its name.
+* Additionally you can pass an object of parameters to check if the URL matches the route with the given parameters.
+* Otherwise it will accept and thus return true for any values for the parameters defined by the route.
+* Note: passing additional parameters that are not defined by the route or included in the current URL will cause this to return false.
+*/
 function urlMatchesRoute(fullUrl, name, routeParameters) {
-  const url = makeUrl(fullUrl, { hash: "" }).toString();
-  const parameters = routeParameters || {};
-  const definition = getRouting().routes[name];
-  if (!definition) {
-    return false;
-  }
-  const matches = getUrlRegexForRoute(name).exec(url);
-  if (!matches) {
-    return false;
-  }
-  for (const k in matches.groups) {
-    matches.groups[k] = typeof matches.groups[k] === "string" ? decodeURIComponent(matches.groups[k]) : matches.groups[k];
-  }
-  return Object.keys(parameters).every((parameterName) => {
-    let value = parameters[parameterName];
-    const bindingProperty = definition.bindings?.[parameterName];
-    if (bindingProperty && typeof value === "object") {
-      value = value[bindingProperty];
-    }
-    return matches.groups?.[parameterName] === value.toString();
-  });
+	const url = makeUrl(fullUrl, { hash: "" }).toString();
+	const parameters = routeParameters || {};
+	const definition = getRouting().routes[name];
+	if (!definition) return false;
+	const matches = getUrlRegexForRoute(name).exec(url);
+	if (!matches) return false;
+	for (const k in matches.groups) matches.groups[k] = typeof matches.groups[k] === "string" ? decodeURIComponent(matches.groups[k]) : matches.groups[k];
+	return Object.keys(parameters).every((parameterName) => {
+		let value = parameters[parameterName];
+		const bindingProperty = definition.bindings?.[parameterName];
+		if (bindingProperty && typeof value === "object") value = value[bindingProperty];
+		return matches.groups?.[parameterName] === value.toString();
+	});
 }
 function generateRouteFromName(name, parameters, absolute, shouldThrow) {
-  const url = getUrlFromName(name, parameters);
-  return absolute === false ? url.toString().replace(url.origin, "") : url.toString();
+	const url = getUrlFromName(name, parameters, shouldThrow);
+	return absolute === false ? url.toString().replace(url.origin, "") || "/" : url.toString();
 }
 function getNameFromUrl(url, parameters) {
-  const routing = getRouting();
-  const routes = Object.values(routing.routes).map((x) => x.name);
-  return routes.find((routeName) => {
-    return urlMatchesRoute(url, routeName, parameters);
-  });
+	const routing = getRouting();
+	return Object.values(routing.routes).map((x) => x.name).find((routeName) => {
+		return urlMatchesRoute(url, routeName, parameters);
+	});
 }
 function getUrlFromName(name, parameters, shouldThrow) {
-  const routing = getRouting();
-  const definition = getRouteDefinition(name);
-  const transforms = getRouteTransformable(name, parameters);
-  const url = makeUrl(routing.url, (url2) => ({
-    hostname: definition.domain || url2.hostname,
-    port: routing.port?.toString() || url2.port,
-    trailingSlash: false,
-    ...transforms
-  }));
-  return url;
-}
+	const routing = getRouting();
+	const definition = getRouteDefinition(name);
+	const transforms = getRouteTransformable(name, parameters, shouldThrow);
+	return makeUrl(routing.url, (url) => ({
+		hostname: definition.domain || url.hostname,
+		port: routing.port?.toString() || url.port,
+		trailingSlash: false,
+		...transforms
+	}));
+}
+/**
+* Resolved the value of a route parameter from either the passed parameters or the default parameters.
+*/
 function getRouteParameterValue(routeName, parameterName, routeParameters) {
-  const routing = getRouting();
-  const definition = getRouteDefinition(routeName);
-  const parameters = routeParameters || {};
-  const value = (() => {
-    const value2 = parameters[parameterName];
-    const bindingProperty = definition.bindings?.[parameterName];
-    if (bindingProperty && value2 != null && typeof value2 === "object") {
-      return value2[bindingProperty];
-    }
-    return value2;
-  })();
-  if (value) {
-    const where = definition.wheres?.[parameterName];
-    if (where && !new RegExp(where).test(value)) {
-      console.warn(`[hybridly:routing] Parameter [${parameterName}] does not match the required format [${where}] for route [${routeName}].`);
-    }
-    return value;
-  }
-  if (routing.defaults?.[parameterName]) {
-    return routing.defaults?.[parameterName];
-  }
-}
+	const routing = getRouting();
+	const definition = getRouteDefinition(routeName);
+	const parameters = routeParameters || {};
+	const value = (() => {
+		const value$1 = parameters[parameterName];
+		const bindingProperty = definition.bindings?.[parameterName];
+		if (bindingProperty && value$1 != null && typeof value$1 === "object") return value$1[bindingProperty];
+		return value$1;
+	})();
+	if (value) {
+		const where = definition.wheres?.[parameterName];
+		if (where && !new RegExp(where).test(value)) console.warn(`[hybridly:routing] Parameter [${parameterName}] does not match the required format [${where}] for route [${routeName}].`);
+		return value;
+	}
+	if (routing.defaults?.[parameterName]) return routing.defaults?.[parameterName];
+}
+/**
+* Gets the `UrlTransformable` object for the given route and parameters.
+*/
 function getRouteTransformable(routeName, routeParameters, shouldThrow) {
-  const definition = getRouteDefinition(routeName);
-  const parameters = routeParameters || {};
-  const missing = Object.keys(parameters);
-  const replaceParameter = (match, parameterName, optional) => {
-    const value = getRouteParameterValue(routeName, parameterName, parameters);
-    const found = missing.indexOf(parameterName);
-    if (found >= 0) {
-      missing.splice(found, 1);
-    }
-    if (value) {
-      return value;
-    }
-    if (optional) {
-      return "";
-    }
-    throw new MissingRouteParameter(parameterName, routeName);
-  };
-  const path = definition.uri.replace(/{([^}?]+)(\??)}/g, replaceParameter);
-  const domain = definition.domain?.replace(/{([^}?]+)(\??)}/g, replaceParameter);
-  const remaining = Object.keys(parameters).filter((key) => missing.includes(key)).reduce((obj, key) => ({
-    ...obj,
-    [key]: parameters[key]
-  }), {});
-  return {
-    ...domain && { hostname: domain },
-    pathname: path,
-    search: qs.stringify(remaining, {
-      encodeValuesOnly: true,
-      arrayFormat: "indices",
-      addQueryPrefix: true
-    })
-  };
-}
+	const definition = getRouteDefinition(routeName);
+	const parameters = routeParameters || {};
+	const missing = Object.keys(parameters);
+	const replaceParameter = (match$1, parameterName, optional) => {
+		const value = getRouteParameterValue(routeName, parameterName, parameters);
+		const found = missing.indexOf(parameterName);
+		if (found >= 0) missing.splice(found, 1);
+		if (value) return value;
+		if (optional) return "";
+		if (shouldThrow === false) return "";
+		throw new MissingRouteParameter(parameterName, routeName);
+	};
+	const path = definition.uri.replace(/{([^}?]+)(\??)}/g, replaceParameter);
+	const domain = definition.domain?.replace(/{([^}?]+)(\??)}/g, replaceParameter);
+	const remaining = Object.keys(parameters).filter((key) => missing.includes(key)).reduce((obj, key) => ({
+		...obj,
+		[key]: parameters[key]
+	}), {});
+	return {
+		...domain && { hostname: domain },
+		pathname: path,
+		search: qs.stringify(remaining, {
+			encodeValuesOnly: true,
+			arrayFormat: "indices",
+			addQueryPrefix: true
+		})
+	};
+}
+/**
+* Gets the route definition.
+*/
 function getRouteDefinition(name) {
-  const routing = getRouting();
-  const definition = routing.routes[name];
-  if (!definition) {
-    throw new RouteNotFound(name);
-  }
-  return definition;
+	const definition = getRouting().routes[name];
+	if (!definition) throw new RouteNotFound(name);
+	return definition;
 }
+/**
+* Gets the routing configuration from the current context.
+*/
 function getRouting() {
-  const { routing } = getInternalRouterContext();
-  if (!routing) {
-    throw new RoutingNotInitialized();
-  }
-  return routing;
+	const { routing } = getInternalRouterContext();
+	if (!routing) throw new RoutingNotInitialized();
+	return routing;
 }
+/**
+* Generates a route from the given route name.
+*/
 function route(name, parameters, absolute) {
-  return generateRouteFromName(name, parameters, absolute);
+	return generateRouteFromName(name, parameters, absolute ?? getRouting().absolute ?? true);
 }
 
+//#endregion
+//#region src/routing/current.ts
 function getCurrentUrl() {
-  if (typeof window === "undefined") {
-    return getInternalRouterContext().url;
-  }
-  return window.location.toString();
-}
+	if (typeof window === "undefined") return getInternalRouterContext().url;
+	return window.location.toString();
+}
+/**
+* Determines whether the current route matches the given name and parameters.
+* If multiple routes match, the first one will be returned.
+*
+* @example
+* ```ts
+* currentRouteMatches('tenant.*') // matches all routes starting with 'tenant.'
+* currentRouteMatches('tenant.*.admin') // matches all routes starting with 'tenant.' and ending with '.admin'
+* ```
+*/
 function currentRouteMatches(name, parameters) {
-  const namePattern = `^${name.replaceAll(".", "\\.").replaceAll("*", ".*")}$`;
-  const possibleRoutes = Object.values(getRouting().routes).filter((x) => x.method.includes("GET") && RegExp(namePattern).test(x.name)).map((x) => x.name);
-  const currentUrl = getCurrentUrl();
-  return possibleRoutes.some((routeName) => {
-    return urlMatchesRoute(currentUrl, routeName, parameters);
-  });
+	const namePattern = `^${name.replaceAll(".", "\\.").replaceAll("*", ".*")}$`;
+	const possibleRoutes = Object.values(getRouting().routes).filter((x) => x.method.includes("GET") && RegExp(namePattern).test(x.name)).map((x) => x.name);
+	const currentUrl = getCurrentUrl();
+	return possibleRoutes.some((routeName) => {
+		return urlMatchesRoute(currentUrl, routeName, parameters);
+	});
 }
 function getCurrentRouteName() {
-  return getNameFromUrl(getCurrentUrl());
+	return getNameFromUrl(getCurrentUrl());
 }
 
+//#endregion
+//#region src/routing/index.ts
 function updateRoutingConfiguration(routing) {
-  if (!routing) {
-    return;
-  }
-  setContext({ routing });
+	if (!routing) return;
+	setContext({ routing });
 }
 
+//#endregion
+//#region src/download.ts
+/** Checks if the response wants to redirect to an external URL. */
 function isDownloadResponse(response) {
-  return response.status === 200 && !!response.headers["content-disposition"];
+	return response.status === 200 && !!response.headers["content-disposition"];
 }
+/** Handles a download. */
 async function handleDownloadResponse(response) {
-  const blob = new Blob([response.data], { type: response.headers["content-type"] });
-  const urlObject = window.webkitURL || window.URL;
-  const link = document.createElement("a");
-  link.style.display = "none";
-  link.href = urlObject.createObjectURL(blob);
-  link.download = getFileNameFromContentDispositionHeader(response.headers["content-disposition"]);
-  link.click();
-  setTimeout(() => {
-    urlObject.revokeObjectURL(link.href);
-    link.remove();
-  }, 0);
+	const blob = new Blob([response.data], { type: response.headers["content-type"] });
+	const urlObject = window.webkitURL || window.URL;
+	const link = document.createElement("a");
+	link.style.display = "none";
+	link.href = urlObject.createObjectURL(blob);
+	link.download = getFileNameFromContentDispositionHeader(response.headers["content-disposition"]);
+	link.click();
+	setTimeout(() => {
+		urlObject.revokeObjectURL(link.href);
+		link.remove();
+	}, 0);
 }
 function getFileNameFromContentDispositionHeader(header) {
-  const result = header.split(";")[1]?.trim().split("=")[1];
-  return result?.replace(/^"(.*)"$/, "$1") ?? "";
+	return (header.split(";")[1]?.trim().split("=")[1])?.replace(/^"(.*)"$/, "$1") ?? "";
 }
 
+//#endregion
+//#region src/context/context.ts
 const state = {
-  initialized: false,
-  context: {}
+	initialized: false,
+	context: {}
 };
+/** Gets the current context. */
 function getRouterContext() {
-  return getInternalRouterContext();
+	return getInternalRouterContext();
 }
+/** Gets the current context, but not in read-only. */
 function getInternalRouterContext() {
-  if (!state.initialized) {
-    throw new Error("Hybridly is not initialized.");
-  }
-  return state.context;
+	if (!state.initialized) throw new Error("Hybridly is not initialized.");
+	return state.context;
 }
+/** Initializes the context. */
 async function initializeContext(options) {
-  state.initialized = true;
-  state.context = {
-    ...options.payload,
-    responseErrorModals: options.responseErrorModals,
-    serializer: createSerializer(options),
-    url: makeUrl(options.payload.url).toString(),
-    adapter: {
-      ...options.adapter,
-      updateRoutingConfiguration
-    },
-    scrollRegions: [],
-    plugins: options.plugins ?? [],
-    axios: registerAxios(options.axios ?? axios.create()),
-    routing: options.routing,
-    preloadCache: /* @__PURE__ */ new Map(),
-    hooks: {},
-    memo: {}
-  };
-  await runHooks("initialized", {}, state.context);
-  return getInternalRouterContext();
-}
-function registerAxios(axios2) {
-  axios2.interceptors.response.use(
-    (response) => {
-      if (!isDownloadResponse(response)) {
-        const text = new TextDecoder().decode(response.data);
-        try {
-          response.data = JSON.parse(text);
-        } catch {
-          response.data = text;
-        }
-      }
-      return response;
-    },
-    (error) => Promise.reject(error)
-  );
-  return axios2;
-}
-function setContext(merge = {}, options = {}) {
-  Object.keys(merge).forEach((key) => {
-    Reflect.set(state.context, key, merge[key]);
-  });
-  if (options.propagate !== false) {
-    state.context.adapter.onContextUpdate?.(state.context);
-  }
-  debug.context("Updated context:", { context: state.context, added: merge });
-}
+	state.initialized = true;
+	state.context = {
+		...options.payload,
+		responseErrorModals: options.responseErrorModals,
+		serializer: createSerializer(options),
+		url: makeUrl(options.payload.url).toString(),
+		adapter: {
+			...options.adapter,
+			updateRoutingConfiguration
+		},
+		scrollRegions: [],
+		plugins: options.plugins ?? [],
+		axios: registerAxios(options.axios ?? axios.create()),
+		routing: options.routing,
+		preloadCache: /* @__PURE__ */ new Map(),
+		hooks: {},
+		memo: {}
+	};
+	await runHooks("initialized", {}, state.context);
+	return getInternalRouterContext();
+}
+/**
+* Registers an interceptor that assumes `arraybuffer`
+* responses and converts responses to JSON or text.
+*/
+function registerAxios(axios$1) {
+	axios$1.interceptors.response.use((response) => {
+		if (!isDownloadResponse(response)) {
+			const text = new TextDecoder().decode(response.data);
+			try {
+				response.data = JSON.parse(text);
+			} catch {
+				response.data = text;
+			}
+		}
+		return response;
+	}, (error) => Promise.reject(error));
+	return axios$1;
+}
+/**
+* Mutates properties at the top-level of the context.
+*/
+function setContext(merge$1 = {}, options = {}) {
+	Object.keys(merge$1).forEach((key) => {
+		Reflect.set(state.context, key, merge$1[key]);
+	});
+	if (options.propagate !== false) state.context.adapter.onContextUpdate?.(state.context);
+	debug.context("Updated context:", {
+		context: state.context,
+		added: merge$1
+	});
+}
+/** Gets a payload from the current context. */
 function payloadFromContext() {
-  return {
-    url: getRouterContext().url,
-    version: getRouterContext().version,
-    view: getRouterContext().view,
-    dialog: getRouterContext().dialog
-  };
+	return {
+		url: getRouterContext().url,
+		version: getRouterContext().version,
+		view: getRouterContext().view,
+		dialog: getRouterContext().dialog
+	};
 }
 
+//#endregion
+//#region src/external.ts
+/**
+* Performs an external navigation by saving options to the storage and
+* making a full page reload. Upon loading, the navigation options
+* will be pulled and a hybrid navigation will be made.
+*/
 async function performExternalNavigation(options) {
-  debug.external("Navigating to an external URL:", options);
-  if (options.target === "new-tab") {
-    const link = document.createElement("a");
-    link.style.display = "none";
-    link.target = "_blank";
-    link.href = options.url;
-    link.click();
-    setTimeout(() => link.remove(), 0);
-    return;
-  }
-  window.sessionStorage.setItem(STORAGE_EXTERNAL_KEY, JSON.stringify(options));
-  window.location.href = options.url;
-  if (sameUrls(window.location, options.url)) {
-    debug.external("Manually reloading due to the external URL being the same.");
-    window.location.reload();
-  }
-}
+	debug.external("Navigating to an external URL:", options);
+	if (options.target === "new-tab") {
+		const link = document.createElement("a");
+		link.style.display = "none";
+		link.target = "_blank";
+		link.href = options.url;
+		link.click();
+		setTimeout(() => link.remove(), 0);
+		return;
+	}
+	window.sessionStorage.setItem(STORAGE_EXTERNAL_KEY, JSON.stringify(options));
+	window.location.href = options.url;
+	if (sameUrls(window.location, options.url)) {
+		debug.external("Manually reloading due to the external URL being the same.");
+		window.location.reload();
+	}
+}
+/** Navigates to the given URL without the hybrid protocol. */
 function navigateToExternalUrl(url, data) {
-  document.location.href = makeUrl(url, {
-    search: qs.stringify(data, {
-      encodeValuesOnly: true,
-      arrayFormat: "brackets"
-    })
-  }).toString();
+	document.location.href = makeUrl(url, { search: qs.stringify(data, {
+		encodeValuesOnly: true,
+		arrayFormat: "brackets"
+	}) }).toString();
 }
+/** Checks if the response wants to redirect to an external URL. */
 function isExternalResponse(response) {
-  return response?.status === 409 && !!response?.headers?.[EXTERNAL_NAVIGATION_HEADER];
+	return response?.status === 409 && !!response?.headers?.[EXTERNAL_NAVIGATION_HEADER];
 }
+/**
+* Performs the internal navigation when an external navigation to a hybrid view has been made.
+* This method is meant to be called on router creation.
+*/
 async function handleExternalNavigation() {
-  debug.external("Handling an external navigation.");
-  const options = JSON.parse(window.sessionStorage.getItem(STORAGE_EXTERNAL_KEY) || "{}");
-  window.sessionStorage.removeItem(STORAGE_EXTERNAL_KEY);
-  debug.external("Options from the session storage:", options);
-  setContext({
-    url: makeUrl(getRouterContext().url, { hash: window.location.hash }).toString()
-  });
-  await navigate({
-    type: "initial",
-    preserveState: true,
-    preserveScroll: options.preserveScroll
-  });
-}
+	debug.external("Handling an external navigation.");
+	const options = JSON.parse(window.sessionStorage.getItem(STORAGE_EXTERNAL_KEY) || "{}");
+	window.sessionStorage.removeItem(STORAGE_EXTERNAL_KEY);
+	debug.external("Options from the session storage:", options);
+	setContext({ url: makeUrl(getRouterContext().url, { hash: window.location.hash }).toString() });
+	await navigate({
+		type: "initial",
+		preserveState: true,
+		preserveScroll: options.preserveScroll
+	});
+}
+/** Checks if the navigation being initialized points to an external location. */
 function isExternalNavigation() {
-  try {
-    return window.sessionStorage.getItem(STORAGE_EXTERNAL_KEY) !== null;
-  } catch {
-  }
-  return false;
+	try {
+		return window.sessionStorage.getItem(STORAGE_EXTERNAL_KEY) !== null;
+	} catch {}
+	return false;
 }
 
+//#endregion
+//#region src/dialog/index.ts
+/**
+* Closes the dialog.
+*/
 async function closeDialog(options) {
-  const context = getInternalRouterContext();
-  const url = context.dialog?.redirectUrl ?? context.dialog?.baseUrl;
-  if (!url) {
-    return;
-  }
-  context.adapter.onDialogClose?.(context);
-  if (options?.local === true) {
-    return await performLocalNavigation(url, {
-      preserveScroll: true,
-      preserveState: true,
-      dialog: false,
-      component: context.view.component,
-      properties: context.view.properties,
-      ...options
-    });
-  }
-  return await performHybridNavigation({
-    url,
-    preserveScroll: true,
-    preserveState: true,
-    ...options
-  });
+	const context = getInternalRouterContext();
+	const url = context.dialog?.redirectUrl ?? context.dialog?.baseUrl;
+	if (!url) return;
+	context.adapter.onDialogClose?.(context);
+	if (options?.local === true) return await performLocalNavigation(url, {
+		preserveScroll: true,
+		preserveState: true,
+		dialog: false,
+		component: context.view.component,
+		properties: context.view.properties,
+		...options
+	});
+	return await performHybridNavigation({
+		url,
+		preserveScroll: true,
+		preserveState: true,
+		...options
+	});
 }
 
+//#endregion
+//#region src/router/preload.ts
+/**
+* Checks if there is a preloaded request for the given URL.
+*/
 function isPreloaded(targetUrl) {
-  const context = getInternalRouterContext();
-  return context.preloadCache.has(targetUrl.toString()) ?? false;
+	return getInternalRouterContext().preloadCache.has(targetUrl.toString()) ?? false;
 }
+/**
+* Gets the response of a preloaded request.
+*/
 function getPreloadedRequest(targetUrl) {
-  const context = getInternalRouterContext();
-  return context.preloadCache.get(targetUrl.toString());
+	return getInternalRouterContext().preloadCache.get(targetUrl.toString());
 }
+/**
+* Stores the response of a preloaded request.
+*/
 function storePreloadRequest(targetUrl, response) {
-  const context = getInternalRouterContext();
-  context.preloadCache.set(targetUrl.toString(), response);
+	getInternalRouterContext().preloadCache.set(targetUrl.toString(), response);
 }
+/**
+* Discards a preloaded request.
+*/
 function discardPreloadedRequest(targetUrl) {
-  const context = getInternalRouterContext();
-  return context.preloadCache.delete(targetUrl.toString());
+	return getInternalRouterContext().preloadCache.delete(targetUrl.toString());
 }
+/** Preloads a hybrid request. */
 async function performPreloadRequest(options) {
-  const context = getRouterContext();
-  const url = makeUrl(options.url ?? context.url);
-  if (isPreloaded(url)) {
-    debug.router("This request is already preloaded.");
-    return false;
-  }
-  if (context.pendingNavigation) {
-    debug.router("A navigation is pending, preload aborted.");
-    return false;
-  }
-  if (options.method !== "GET") {
-    debug.router("Cannot preload non-GET requests.");
-    return false;
-  }
-  debug.router(`Preloading response for [${url.toString()}]`);
-  try {
-    const response = await performHybridRequest(url, options);
-    if (!isHybridResponse(response)) {
-      debug.router("Preload result was invalid.");
-      return false;
-    }
-    storePreloadRequest(url, response);
-    return true;
-  } catch (error) {
-    debug.router("Preloading failed.");
-    return false;
-  }
+	const context = getRouterContext();
+	const url = makeUrl(options.url ?? context.url);
+	if (isPreloaded(url)) {
+		debug.router("This request is already preloaded.");
+		return false;
+	}
+	if (context.pendingNavigation) {
+		debug.router("A navigation is pending, preload aborted.");
+		return false;
+	}
+	if (options.method !== "GET") {
+		debug.router("Cannot preload non-GET requests.");
+		return false;
+	}
+	debug.router(`Preloading response for [${url.toString()}]`);
+	try {
+		const response = await performHybridRequest(url, options);
+		if (!isHybridResponse(response)) {
+			debug.router("Preload result was invalid.");
+			return false;
+		}
+		storePreloadRequest(url, response);
+		return true;
+	} catch (error) {
+		debug.router("Preloading failed.");
+		return false;
+	}
 }
 
+//#endregion
+//#region src/router/router.ts
+/**
+* The hybridly router.
+* This is the core function that you can use to navigate in
+* your application. Make sure the routes you call return a
+* hybrid response, otherwise you need to call `external`.
+*
+* @example
+* router.get('/posts/edit', { post })
+*/
 const router = {
-  abort: async () => getRouterContext().pendingNavigation?.controller.abort(),
-  active: () => !!getRouterContext().pendingNavigation,
-  navigate: async (options) => await performHybridNavigation(options),
-  reload: async (options) => await performHybridNavigation({ preserveScroll: true, preserveState: true, replace: true, ...options }),
-  get: async (url, options = {}) => await performHybridNavigation({ ...options, url, method: "GET" }),
-  post: async (url, options = {}) => await performHybridNavigation({ preserveState: true, ...options, url, method: "POST" }),
-  put: async (url, options = {}) => await performHybridNavigation({ preserveState: true, ...options, url, method: "PUT" }),
-  patch: async (url, options = {}) => await performHybridNavigation({ preserveState: true, ...options, url, method: "PATCH" }),
-  delete: async (url, options = {}) => await performHybridNavigation({ preserveState: true, ...options, url, method: "DELETE" }),
-  local: async (url, options = {}) => await performLocalNavigation(url, options),
-  preload: async (url, options = {}) => await performPreloadRequest({ ...options, url, method: "GET" }),
-  external: (url, data = {}) => navigateToExternalUrl(url, data),
-  to: async (name, parameters, options) => {
-    const url = generateRouteFromName(name, parameters);
-    const method = getRouteDefinition(name).method.at(0);
-    return await performHybridNavigation({ url, ...options, method });
-  },
-  matches: (name, parameters) => currentRouteMatches(name, parameters),
-  current: () => getCurrentRouteName(),
-  dialog: {
-    close: (options) => closeDialog(options)
-  },
-  history: {
-    get: (key) => getHistoryMemo(key),
-    remember: (key, value) => remember(key, value)
-  }
+	abort: async () => getRouterContext().pendingNavigation?.controller.abort(),
+	active: () => !!getRouterContext().pendingNavigation,
+	navigate: async (options) => await performHybridNavigation(options),
+	reload: async (options) => await performHybridNavigation({
+		preserveScroll: true,
+		preserveState: true,
+		replace: true,
+		...options
+	}),
+	get: async (url, options = {}) => await performHybridNavigation({
+		...options,
+		url,
+		method: "GET"
+	}),
+	post: async (url, options = {}) => await performHybridNavigation({
+		preserveState: true,
+		...options,
+		url,
+		method: "POST"
+	}),
+	put: async (url, options = {}) => await performHybridNavigation({
+		preserveState: true,
+		...options,
+		url,
+		method: "PUT"
+	}),
+	patch: async (url, options = {}) => await performHybridNavigation({
+		preserveState: true,
+		...options,
+		url,
+		method: "PATCH"
+	}),
+	delete: async (url, options = {}) => await performHybridNavigation({
+		preserveState: true,
+		...options,
+		url,
+		method: "DELETE"
+	}),
+	local: async (url, options = {}) => await performLocalNavigation(url, options),
+	preload: async (url, options = {}) => await performPreloadRequest({
+		...options,
+		url,
+		method: "GET"
+	}),
+	external: (url, data = {}) => navigateToExternalUrl(url, data),
+	to: async (name, parameters, options) => {
+		const url = generateRouteFromName(name, parameters);
+		const method = getRouteDefinition(name).method.at(0);
+		return await performHybridNavigation({
+			url,
+			...options,
+			method
+		});
+	},
+	matches: (name, parameters) => currentRouteMatches(name, parameters),
+	current: () => getCurrentRouteName(),
+	dialog: { close: (options) => closeDialog(options) },
+	history: {
+		get: (key) => getHistoryMemo(key),
+		remember: (key, value) => remember(key, value)
+	}
 };
+/** Creates the hybridly router. */
 async function createRouter(options) {
-  await initializeContext(options);
-  return await initializeRouter();
+	await initializeContext(options);
+	return await initializeRouter();
 }
+/** Performs every action necessary to make a hybrid navigation. */
 async function performHybridNavigation(options) {
-  const navigationId = random();
-  const context = getRouterContext();
-  debug.router("Making a hybrid navigation:", { context, options, navigationId });
-  try {
-    if (!options.method) {
-      debug.router("Setting method to GET because none was provided.");
-      options.method = "GET";
-    }
-    options.method = options.method.toUpperCase();
-    if ((hasFiles(options.data) || options.useFormData) && !(options.data instanceof FormData)) {
-      options.data = objectToFormData(options.data);
-      debug.router("Converted data to FormData.", options.data);
-    }
-    if (!(options.data instanceof FormData) && options.method === "GET" && Object.keys(options.data ?? {}).length) {
-      debug.router("Transforming data to query parameters.", options.data);
-      options.url = makeUrl(options.url ?? context.url, {
-        query: options.data
-      });
-      options.data = {};
-    }
-    if (["PUT", "PATCH", "DELETE"].includes(options.method) && options.spoof !== false) {
-      debug.router(`Automatically spoofing method ${options.method}.`);
-      if (options.data instanceof FormData) {
-        options.data.append("_method", options.method);
-      } else if (typeof options.data === "undefined") {
-        options.data = { _method: options.method };
-      } else if (options.data instanceof Object && Object.keys(options.data).length >= 0) {
-        Object.assign(options.data, { _method: options.method });
-      } else {
-        debug.router("Could not spoof method because body type is not supported.", options.data);
-      }
-      options.method = "POST";
-    }
-    if (!await runHooks("before", options.hooks, options, context)) {
-      debug.router('"before" event returned false, aborting the navigation.');
-      throw new NavigationCancelledError('The navigation was cancelled by the "before" event.');
-    }
-    if (context.pendingNavigation) {
-      debug.router("Aborting current navigation.", context.pendingNavigation);
-      context.pendingNavigation?.controller?.abort();
-    }
-    saveScrollPositions();
-    const targetUrl = makeUrl(options.url ?? context.url, options.transformUrl);
-    const abortController = new AbortController();
-    setContext({
-      pendingNavigation: {
-        id: navigationId,
-        url: targetUrl,
-        controller: abortController,
-        status: "pending",
-        options
-      }
-    });
-    await runHooks("start", options.hooks, context);
-    debug.router("Making request with axios.");
-    const response = await performHybridRequest(targetUrl, options, abortController);
-    const result = await runHooks("data", options.hooks, response, context);
-    if (result === false) {
-      return { response };
-    }
-    if (isExternalResponse(response)) {
-      debug.router("The response is explicitely external.");
-      await performExternalNavigation({
-        url: fillHash(targetUrl, response.headers[EXTERNAL_NAVIGATION_HEADER]),
-        preserveScroll: options.preserveScroll === true,
-        target: response.headers[EXTERNAL_NAVIGATION_TARGET_HEADER] ?? "current"
-      });
-      return { response };
-    }
-    if (isDownloadResponse(response)) {
-      debug.router("The response returns a file to download.");
-      await handleDownloadResponse(response);
-      return { response };
-    }
-    if (!isHybridResponse(response)) {
-      throw new NotAHybridResponseError(response);
-    }
-    debug.router("The response respects the Hybridly protocol.");
-    const payload = response.data;
-    if (payload.view && (options.only?.length ?? options.except?.length) && payload.view.component === context.view.component) {
-      debug.router(`Merging ${options.only ? '"only"' : '"except"'} properties.`, payload.view.properties);
-      const mergedPayloadProperties = merge(context.view.properties, payload.view.properties);
-      if (options.errorBag) {
-        mergedPayloadProperties.errors[options.errorBag] = payload.view.properties.errors[options.errorBag] ?? {};
-      } else {
-        mergedPayloadProperties.errors = payload.view.properties.errors;
-      }
-      payload.view.properties = mergedPayloadProperties;
-      debug.router("Merged properties:", payload.view.properties);
-    }
-    await navigate({
-      type: "server",
-      payload: {
-        ...payload,
-        url: fillHash(targetUrl, payload.url)
-      },
-      preserveScroll: options.preserveScroll,
-      preserveState: options.preserveState,
-      preserveUrl: options.preserveUrl,
-      replace: options.replace === true || options.preserveUrl || sameUrls(payload.url, window.location.href) && !sameHashes(payload.url, window.location.href)
-    });
-    if (Object.keys(context.view.properties.errors ?? {}).length > 0) {
-      const errors = (() => {
-        if (options.errorBag && typeof context.view.properties.errors === "object") {
-          return context.view.properties.errors[options.errorBag] ?? {};
-        }
-        return context.view.properties.errors;
-      })();
-      debug.router("The request returned validation errors.", errors);
-      setContext({
-        pendingNavigation: {
-          ...context.pendingNavigation,
-          status: "error"
-        }
-      });
-      await runHooks("error", options.hooks, errors, context);
-    } else {
-      setContext({
-        pendingNavigation: {
-          ...context.pendingNavigation,
-          status: "success"
-        }
-      });
-      await runHooks("success", options.hooks, payload, context);
-    }
-    return { response };
-  } catch (error) {
-    await match(error.constructor.name, {
-      NavigationCancelledError: async () => {
-        debug.router('The request was cancelled through the "before" hook.', error);
-        await runHooks("abort", options.hooks, context);
-      },
-      AbortError: async () => {
-        debug.router("The request was aborted.", error);
-        await runHooks("abort", options.hooks, context);
-      },
-      NotAHybridResponseError: async () => {
-        debug.router("The response was not hybrid.");
-        console.error(error);
-        await runHooks("invalid", options.hooks, error, context);
-        if (context.responseErrorModals) {
-          showResponseErrorModal(error.response.data);
-        }
-      },
-      default: async () => {
-        if (error?.name === "CanceledError") {
-          debug.router("The request was cancelled.", error);
-          await runHooks("abort", options.hooks, context);
-        } else {
-          debug.router("An unknown error occured.", error);
-          console.error(error);
-          await runHooks("exception", options.hooks, error, context);
-        }
-      }
-    });
-    await runHooks("fail", options.hooks, context);
-    return {
-      error: {
-        type: error.constructor.name,
-        actual: error
-      }
-    };
-  } finally {
-    debug.router("Ending navigation.");
-    await runHooks("after", options.hooks, context);
-    if (context.pendingNavigation?.id === navigationId) {
-      setContext({ pendingNavigation: void 0 });
-    }
-  }
-}
+	const navigationId = random();
+	const context = getRouterContext();
+	debug.router("Making a hybrid navigation:", {
+		context,
+		options,
+		navigationId
+	});
+	try {
+		if (!options.method) {
+			debug.router("Setting method to GET because none was provided.");
+			options.method = "GET";
+		}
+		options.method = options.method.toUpperCase();
+		if ((hasFiles(options.data) || options.useFormData) && !(options.data instanceof FormData)) {
+			options.data = objectToFormData(options.data);
+			debug.router("Converted data to FormData.", options.data);
+		}
+		if (!(options.data instanceof FormData) && options.method === "GET" && Object.keys(options.data ?? {}).length) {
+			debug.router("Transforming data to query parameters.", options.data);
+			options.url = makeUrl(options.url ?? context.url, { query: options.data });
+			options.data = {};
+		}
+		if ([
+			"PUT",
+			"PATCH",
+			"DELETE"
+		].includes(options.method) && options.spoof !== false) {
+			debug.router(`Automatically spoofing method ${options.method}.`);
+			if (options.data instanceof FormData) options.data.append("_method", options.method);
+			else if (typeof options.data === "undefined") options.data = { _method: options.method };
+			else if (options.data instanceof Object && Object.keys(options.data).length >= 0) Object.assign(options.data, { _method: options.method });
+			else debug.router("Could not spoof method because body type is not supported.", options.data);
+			options.method = "POST";
+		}
+		if (!await runHooks("before", options.hooks, options, context)) {
+			debug.router("\"before\" event returned false, aborting the navigation.");
+			throw new NavigationCancelledError("The navigation was cancelled by the \"before\" event.");
+		}
+		if (context.pendingNavigation) {
+			debug.router("Aborting current navigation.", context.pendingNavigation);
+			context.pendingNavigation?.controller?.abort();
+		}
+		saveScrollPositions();
+		const targetUrl = makeUrl(options.url ?? context.url, options.transformUrl);
+		const abortController = new AbortController();
+		setContext({ pendingNavigation: {
+			id: navigationId,
+			url: targetUrl,
+			controller: abortController,
+			status: "pending",
+			options
+		} });
+		await runHooks("start", options.hooks, context);
+		debug.router("Making request with axios.");
+		const response = await performHybridRequest(targetUrl, options, abortController);
+		if (await runHooks("data", options.hooks, response, context) === false) return { response };
+		if (isExternalResponse(response)) {
+			debug.router("The response is explicitely external.");
+			await performExternalNavigation({
+				url: fillHash(targetUrl, response.headers[EXTERNAL_NAVIGATION_HEADER]),
+				preserveScroll: options.preserveScroll === true,
+				target: response.headers[EXTERNAL_NAVIGATION_TARGET_HEADER] ?? "current"
+			});
+			return { response };
+		}
+		if (isDownloadResponse(response)) {
+			debug.router("The response returns a file to download.");
+			await handleDownloadResponse(response);
+			return { response };
+		}
+		if (!isHybridResponse(response)) throw new NotAHybridResponseError(response);
+		debug.router("The response respects the Hybridly protocol.");
+		const payload = response.data;
+		if (payload.view && (options.only?.length ?? options.except?.length) && payload.view.component === context.view.component) {
+			debug.router(`Merging ${options.only ? "\"only\"" : "\"except\""} properties.`, payload.view.properties);
+			const mergedPayloadProperties = merge(context.view.properties, payload.view.properties);
+			if (options.errorBag) mergedPayloadProperties.errors[options.errorBag] = payload.view.properties.errors[options.errorBag] ?? {};
+			else mergedPayloadProperties.errors = payload.view.properties.errors;
+			payload.view.properties = mergedPayloadProperties;
+			debug.router("Merged properties:", payload.view.properties);
+		}
+		await navigate({
+			type: "server",
+			payload: {
+				...payload,
+				url: fillHash(targetUrl, payload.url)
+			},
+			preserveScroll: options.preserveScroll,
+			preserveState: options.preserveState,
+			preserveUrl: options.preserveUrl,
+			replace: options.replace === true || options.preserveUrl || sameUrls(payload.url, window.location.href) && !sameHashes(payload.url, window.location.href)
+		});
+		if (Object.keys(context.view.properties.errors ?? {}).length > 0) {
+			const errors = (() => {
+				if (options.errorBag && typeof context.view.properties.errors === "object") return context.view.properties.errors[options.errorBag] ?? {};
+				return context.view.properties.errors;
+			})();
+			debug.router("The request returned validation errors.", errors);
+			setContext({ pendingNavigation: {
+				...context.pendingNavigation,
+				status: "error"
+			} });
+			await runHooks("error", options.hooks, errors, context);
+		} else {
+			setContext({ pendingNavigation: {
+				...context.pendingNavigation,
+				status: "success"
+			} });
+			await runHooks("success", options.hooks, payload, context);
+		}
+		return { response };
+	} catch (error) {
+		await match(error.constructor.name, {
+			NavigationCancelledError: async () => {
+				debug.router("The request was cancelled through the \"before\" hook.", error);
+				await runHooks("abort", options.hooks, context);
+			},
+			AbortError: async () => {
+				debug.router("The request was aborted.", error);
+				await runHooks("abort", options.hooks, context);
+			},
+			NotAHybridResponseError: async () => {
+				debug.router("The response was not hybrid.");
+				console.error(error);
+				await runHooks("invalid", options.hooks, error, context);
+				if (context.responseErrorModals) showResponseErrorModal(error.response.data);
+			},
+			default: async () => {
+				if (error?.name === "CanceledError") {
+					debug.router("The request was cancelled.", error);
+					await runHooks("abort", options.hooks, context);
+				} else {
+					debug.router("An unknown error occured.", error);
+					console.error(error);
+					await runHooks("exception", options.hooks, error, context);
+				}
+			}
+		});
+		await runHooks("fail", options.hooks, context);
+		return { error: {
+			type: error.constructor.name,
+			actual: error
+		} };
+	} finally {
+		debug.router("Ending navigation.");
+		await runHooks("after", options.hooks, context);
+		if (context.pendingNavigation?.id === navigationId) setContext({ pendingNavigation: void 0 });
+	}
+}
+/** Checks if the response contains a hybrid header. */
 function isHybridResponse(response) {
-  return !!response?.headers[HYBRIDLY_HEADER];
+	return !!response?.headers[HYBRIDLY_HEADER];
 }
+/**
+* Makes an internal navigation that swaps the view and updates the context.
+* @internal
+*/
 async function navigate(options) {
-  const context = getRouterContext();
-  options.hasDialog ??= !!options.payload?.dialog;
-  debug.router("Making an internal navigation:", { context, options });
-  await runHooks("navigating", {}, options, context);
-  options.payload ??= payloadFromContext();
-  options.payload.view ??= payloadFromContext().view;
-  function evaluateConditionalOption(option) {
-    return typeof option === "function" ? option(options) : option;
-  }
-  const shouldPreserveState = evaluateConditionalOption(options.preserveState);
-  const shouldPreserveScroll = evaluateConditionalOption(options.preserveScroll);
-  const shouldReplaceHistory = evaluateConditionalOption(options.replace);
-  const shouldReplaceUrl = evaluateConditionalOption(options.preserveUrl);
-  const shouldPreserveView = !options.payload.view.component;
-  if (shouldPreserveState && getHistoryMemo() && options.payload.view.component === context.view.component) {
-    debug.history("Setting the memo from this history entry into the current context.");
-    setContext({ memo: getHistoryMemo() });
-  }
-  if (shouldReplaceUrl) {
-    debug.router(`Preserving the current URL (${context.url}) instead of navigating to ${options.payload.url}`);
-    options.payload.url = context.url;
-  }
-  const payload = shouldPreserveView ? {
-    view: {
-      component: context.view.component,
-      properties: merge(context.view.properties, options.payload.view.properties),
-      deferred: context.view.deferred
-    },
-    url: context.url,
-    version: options.payload.version,
-    dialog: context.dialog
-  } : options.payload;
-  setContext({ ...payload, memo: {} });
-  if (options.updateHistoryState !== false) {
-    debug.router(`Target URL is ${context.url}, current window URL is ${window.location.href}.`, { shouldReplaceHistory });
-    setHistoryState({ replace: shouldReplaceHistory });
-  }
-  if (context.view.deferred?.length) {
-    debug.router("Request has deferred properties, queueing a partial reload:", context.view.deferred);
-    context.adapter.executeOnMounted(async () => {
-      await performHybridNavigation({
-        preserveScroll: true,
-        preserveState: true,
-        replace: true,
-        only: context.view.deferred
-      });
-    });
-  }
-  const viewComponent = !shouldPreserveView ? await context.adapter.resolveComponent(context.view.component) : void 0;
-  if (viewComponent) {
-    debug.router(`Component [${context.view.component}] resolved to:`, viewComponent);
-  }
-  await context.adapter.onViewSwap({
-    component: viewComponent,
-    dialog: context.dialog,
-    properties: options.payload?.view?.properties,
-    preserveState: shouldPreserveState,
-    onMounted: (hookOptions) => runHooks("mounted", {}, { ...options, ...hookOptions }, context)
-  });
-  if (options.type === "back-forward") {
-    restoreScrollPositions();
-  } else if (!shouldPreserveScroll) {
-    resetScrollPositions();
-  }
-  await runHooks("navigated", {}, options, context);
+	const context = getRouterContext();
+	options.hasDialog ??= !!options.payload?.dialog;
+	debug.router("Making an internal navigation:", {
+		context,
+		options
+	});
+	await runHooks("navigating", {}, options, context);
+	options.payload ??= payloadFromContext();
+	options.payload.view ??= payloadFromContext().view;
+	function evaluateConditionalOption(option) {
+		return typeof option === "function" ? option(options) : option;
+	}
+	const shouldPreserveState = evaluateConditionalOption(options.preserveState);
+	const shouldPreserveScroll = evaluateConditionalOption(options.preserveScroll);
+	const shouldReplaceHistory = evaluateConditionalOption(options.replace);
+	const shouldReplaceUrl = evaluateConditionalOption(options.preserveUrl);
+	const shouldPreserveView = !options.payload.view.component;
+	if (shouldPreserveState && getHistoryMemo() && options.payload.view.component === context.view.component) {
+		debug.history("Setting the memo from this history entry into the current context.");
+		setContext({ memo: getHistoryMemo() });
+	}
+	if (shouldReplaceUrl) {
+		debug.router(`Preserving the current URL (${context.url}) instead of navigating to ${options.payload.url}`);
+		options.payload.url = context.url;
+	}
+	setContext({
+		...shouldPreserveView ? {
+			view: {
+				component: context.view.component,
+				properties: merge(context.view.properties, options.payload.view.properties),
+				deferred: context.view.deferred
+			},
+			url: context.url,
+			version: options.payload.version,
+			dialog: context.dialog
+		} : options.payload,
+		memo: {}
+	});
+	if (options.updateHistoryState !== false) {
+		debug.router(`Target URL is ${context.url}, current window URL is ${window.location.href}.`, { shouldReplaceHistory });
+		setHistoryState({ replace: shouldReplaceHistory });
+	}
+	if (context.view.deferred?.length) {
+		debug.router("Request has deferred properties, queueing a partial reload:", context.view.deferred);
+		context.adapter.executeOnMounted(async () => {
+			await performHybridNavigation({
+				preserveScroll: true,
+				preserveState: true,
+				replace: true,
+				only: context.view.deferred
+			});
+		});
+	}
+	const viewComponent = !shouldPreserveView ? await context.adapter.resolveComponent(context.view.component) : void 0;
+	if (viewComponent) debug.router(`Component [${context.view.component}] resolved to:`, viewComponent);
+	await context.adapter.onViewSwap({
+		component: viewComponent,
+		dialog: context.dialog,
+		properties: options.payload?.view?.properties,
+		preserveState: shouldPreserveState,
+		onMounted: (hookOptions) => runHooks("mounted", {}, {
+			...options,
+			...hookOptions
+		}, context)
+	});
+	if (options.type === "back-forward") restoreScrollPositions();
+	else if (!shouldPreserveScroll) resetScrollPositions();
+	await runHooks("navigated", {}, options, context);
 }
 async function performHybridRequest(targetUrl, options, abortController) {
-  const context = getInternalRouterContext();
-  const preloaded = options.method === "GET" ? getPreloadedRequest(targetUrl) : false;
-  if (preloaded) {
-    debug.router(`Found a pre-loaded request for [${targetUrl}]`);
-    discardPreloadedRequest(targetUrl);
-    return preloaded;
-  }
-  return await context.axios.request({
-    url: targetUrl.toString(),
-    method: options.method,
-    data: options.method === "GET" ? {} : options.data,
-    params: options.method === "GET" ? options.data : {},
-    signal: abortController?.signal,
-    headers: {
-      ...options.headers,
-      ...context.dialog ? { [DIALOG_KEY_HEADER]: context.dialog.key } : {},
-      ...context.dialog ? { [DIALOG_REDIRECT_HEADER]: context.dialog.redirectUrl ?? "" } : {},
-      ...when(options.only !== void 0 || options.except !== void 0, {
-        [PARTIAL_COMPONENT_HEADER]: context.view.component,
-        ...when(options.only, { [ONLY_DATA_HEADER]: JSON.stringify(options.only) }, {}),
-        ...when(options.except, { [EXCEPT_DATA_HEADER]: JSON.stringify(options.except) }, {})
-      }, {}),
-      ...when(options.errorBag, { [ERROR_BAG_HEADER]: options.errorBag }, {}),
-      ...when(context.version, { [VERSION_HEADER]: context.version }, {}),
-      [HYBRIDLY_HEADER]: true,
-      "X-Requested-With": "XMLHttpRequest",
-      "Accept": "text/html, application/xhtml+xml"
-    },
-    responseType: "arraybuffer",
-    validateStatus: () => true,
-    onUploadProgress: async (event) => {
-      await runHooks("progress", options.hooks, {
-        event,
-        percentage: Math.round(event.loaded / (event.total ?? 0) * 100)
-      }, context);
-    }
-  });
-}
+	const context = getInternalRouterContext();
+	const preloaded = options.method === "GET" ? getPreloadedRequest(targetUrl) : false;
+	if (preloaded) {
+		debug.router(`Found a pre-loaded request for [${targetUrl}]`);
+		discardPreloadedRequest(targetUrl);
+		return preloaded;
+	}
+	return await context.axios.request({
+		url: targetUrl.toString(),
+		method: options.method,
+		data: options.method === "GET" ? {} : options.data,
+		params: options.method === "GET" ? options.data : {},
+		signal: abortController?.signal,
+		headers: {
+			...options.headers,
+			...context.dialog ? { [DIALOG_KEY_HEADER]: context.dialog.key } : {},
+			...context.dialog ? { [DIALOG_REDIRECT_HEADER]: context.dialog.redirectUrl ?? "" } : {},
+			...when(options.only !== void 0 || options.except !== void 0, {
+				[PARTIAL_COMPONENT_HEADER]: context.view.component,
+				...when(options.only, { [ONLY_DATA_HEADER]: JSON.stringify(options.only) }, {}),
+				...when(options.except, { [EXCEPT_DATA_HEADER]: JSON.stringify(options.except) }, {})
+			}, {}),
+			...when(options.errorBag, { [ERROR_BAG_HEADER]: options.errorBag }, {}),
+			...when(context.version, { [VERSION_HEADER]: context.version }, {}),
+			[HYBRIDLY_HEADER]: true,
+			"X-Requested-With": "XMLHttpRequest",
+			"Accept": "text/html, application/xhtml+xml"
+		},
+		responseType: "arraybuffer",
+		validateStatus: () => true,
+		onUploadProgress: async (event) => {
+			await runHooks("progress", options.hooks, {
+				event,
+				percentage: Math.round(event.loaded / (event.total ?? 0) * 100)
+			}, context);
+		}
+	});
+}
+/** Initializes the router by reading the context and registering events if necessary. */
 async function initializeRouter() {
-  const context = getRouterContext();
-  if (isBackForwardNavigation()) {
-    handleBackForwardNavigation();
-  } else if (isExternalNavigation()) {
-    handleExternalNavigation();
-  } else {
-    debug.router("Handling the initial navigation.");
-    setContext({
-      url: makeUrl(context.url, { hash: window.location.hash }).toString()
-    });
-    await navigate({
-      type: "initial",
-      preserveState: true,
-      replace: sameUrls(context.url, window.location.href)
-    });
-  }
-  registerEventListeners();
-  await runHooks("ready", {}, context);
-  return context;
-}
+	const context = getRouterContext();
+	if (isBackForwardNavigation()) handleBackForwardNavigation();
+	else if (isExternalNavigation()) handleExternalNavigation();
+	else {
+		debug.router("Handling the initial navigation.");
+		setContext({ url: makeUrl(context.url, { hash: window.location.hash }).toString() });
+		await navigate({
+			type: "initial",
+			preserveState: true,
+			replace: sameUrls(context.url, window.location.href)
+		});
+	}
+	registerEventListeners();
+	await runHooks("ready", {}, context);
+	return context;
+}
+/** Performs a local navigation to the given component without a round-trip. */
 async function performLocalNavigation(targetUrl, options) {
-  const context = getRouterContext();
-  const url = normalizeUrl(targetUrl);
-  return await navigate({
-    ...options,
-    type: "local",
-    payload: {
-      version: context.version,
-      dialog: options?.dialog === false ? void 0 : options?.dialog ?? context.dialog,
-      url,
-      view: {
-        component: options?.component ?? context.view.component,
-        properties: options?.properties ?? context.view.properties,
-        deferred: []
-      }
-    }
-  });
+	const context = getRouterContext();
+	const url = normalizeUrl(targetUrl);
+	return await navigate({
+		...options,
+		type: "local",
+		payload: {
+			version: context.version,
+			dialog: options?.dialog === false ? void 0 : options?.dialog ?? context.dialog,
+			url,
+			view: {
+				component: options?.component ?? context.view.component,
+				properties: options?.properties ?? context.view.properties,
+				deferred: []
+			}
+		}
+	});
 }
 
+//#endregion
+//#region src/authorization.ts
+/**
+* Checks whether the given data has the authorization for the given action.
+* If the data object has no authorization definition corresponding to the given action, this method will return `false`.
+*/
 function can(resource, action) {
-  return resource.authorization?.[action] ?? false;
+	return resource.authorization?.[action] ?? false;
 }
 
-export { can, constants, createRouter, definePlugin, getRouterContext, makeUrl, registerHook, route, router, sameUrls };
+//#endregion
+export { can, constants_exports as constants, createRouter, definePlugin, getRouterContext, makeUrl, registerHook, route, router, sameUrls };