diff --git a/src/lib/Fallback/Fallback.svelte b/src/lib/Fallback/Fallback.svelte
index 324eb21..1a9c007 100644
--- a/src/lib/Fallback/Fallback.svelte
+++ b/src/lib/Fallback/Fallback.svelte
@@ -1,5 +1,5 @@
 <script lang="ts">
-	import { resolveHashValue } from '$lib/core/RouterEngine.svelte.js';
+	import { resolveHashValue } from '$lib/core/resolveHashValue.js';
 	import { getRouterContext } from '$lib/Router/Router.svelte';
 	import type { RouteStatus } from '$lib/types.js';
 	import type { Snippet } from 'svelte';
diff --git a/src/lib/Link/Link.svelte b/src/lib/Link/Link.svelte
index 744d5d6..9442500 100644
--- a/src/lib/Link/Link.svelte
+++ b/src/lib/Link/Link.svelte
@@ -1,11 +1,11 @@
 <script lang="ts">
 	import { calculateHref } from '$lib/core/calculateHref.js';
-	import { calculateState } from '$lib/core/calculateState.svelte.js';
+	import { calculateState } from '$lib/core/calculateState.js';
 	import { location } from '$lib/core/Location.js';
-	import { resolveHashValue } from '$lib/core/RouterEngine.svelte.js';
+	import { resolveHashValue } from '$lib/core/resolveHashValue.js';
 	import { getLinkContext, type ILinkContext } from '$lib/LinkContext/LinkContext.svelte';
 	import { getRouterContext } from '$lib/Router/Router.svelte';
-	import type { ActiveState, RouteStatus } from '$lib/types.js';
+	import type { ActiveState, Hash, RouteStatus } from '$lib/types.js';
 	import { type Snippet } from 'svelte';
 	import type { HTMLAnchorAttributes } from 'svelte/elements';
 
@@ -41,7 +41,7 @@
 			 * route becomes active.
 			 * - The `prependBasePath` property:  It depends on the parent router to set the base path for the link.
 			 */
-			hash?: boolean | string;
+			hash?: Hash;
 			/**
 			 * Sets the URL to navigate to.  Never use a full URL; always use relative or absolute paths.
 			 */
diff --git a/src/lib/LinkContext/LinkContext.svelte b/src/lib/LinkContext/LinkContext.svelte
index 0c6ce3c..2510644 100644
--- a/src/lib/LinkContext/LinkContext.svelte
+++ b/src/lib/LinkContext/LinkContext.svelte
@@ -36,18 +36,18 @@
 	};
 
 	class _LinkContext implements ILinkContext {
-		replace = $state(false);
-		prependBasePath = $state(false);
-		preserveQuery = $state<ILinkContext['preserveQuery']>(false);
+		replace;
+		prependBasePath;
+		preserveQuery;
 
 		constructor(
 			replace: boolean,
 			prependBasePath: boolean,
-			preserveQuery: ILinkContext['preserveQuery']
+			preserveQuery: PreserveQuery
 		) {
-			this.replace = replace;
-			this.prependBasePath = prependBasePath;
-			this.preserveQuery = preserveQuery;
+			this.replace = $state(replace);
+			this.prependBasePath = $state(prependBasePath);
+			this.preserveQuery = $state(preserveQuery);
 		}
 	}
 
diff --git a/src/lib/Route/Route.svelte b/src/lib/Route/Route.svelte
index 796d06c..41d0b7e 100644
--- a/src/lib/Route/Route.svelte
+++ b/src/lib/Route/Route.svelte
@@ -19,7 +19,7 @@
 <script lang="ts" generics="T extends string | RegExp">
 	import { untrack, type Snippet } from 'svelte';
 	import { getRouterContext } from '../Router/Router.svelte';
-	import { resolveHashValue } from '$lib/core/RouterEngine.svelte.js';
+	import { resolveHashValue } from '$lib/core/resolveHashValue.js';
 	import type { ParameterValue, RouteStatus } from '$lib/types.js';
 
 	type Props = {
diff --git a/src/lib/Router/Router.svelte b/src/lib/Router/Router.svelte
index 1dfb322..7a86adf 100644
--- a/src/lib/Router/Router.svelte
+++ b/src/lib/Router/Router.svelte
@@ -1,5 +1,6 @@
 <script lang="ts" module>
-	import { resolveHashValue, RouterEngine } from '$lib/core/RouterEngine.svelte.js';
+	import { RouterEngine } from '$lib/core/RouterEngine.svelte.js';
+	import { resolveHashValue } from '$lib/core/resolveHashValue.js';
 	import type { RouteStatus } from '$lib/types.js';
 
 	const parentCtxKey = Symbol();
diff --git a/src/lib/RouterTrace/RouterTrace.svelte b/src/lib/RouterTrace/RouterTrace.svelte
index 3eb5713..e79ac51 100644
--- a/src/lib/RouterTrace/RouterTrace.svelte
+++ b/src/lib/RouterTrace/RouterTrace.svelte
@@ -1,10 +1,10 @@
 <script lang="ts">
 	import { traceOptions, getAllChildRouters } from '$lib/core/trace.svelte.js';
 	import {
-		resolveHashValue,
 		routePatternsKey,
 		RouterEngine
 	} from '$lib/core/RouterEngine.svelte.js';
+	import { resolveHashValue } from '$lib/core/resolveHashValue.js';
 	import { getRouterContext } from '$lib/Router/Router.svelte';
 	import type { PatternRouteInfo } from '$lib/types.js';
 	import type { HTMLTableAttributes } from 'svelte/elements';
diff --git a/src/lib/core/LocationFull.ts b/src/lib/core/LocationFull.ts
index d3713c3..3dda21a 100644
--- a/src/lib/core/LocationFull.ts
+++ b/src/lib/core/LocationFull.ts
@@ -2,6 +2,9 @@ import type { BeforeNavigateEvent, Events, NavigationCancelledEvent, NavigationE
 import { LocationLite } from "./LocationLite.svelte.js";
 import { LocationState } from "./LocationState.svelte.js";
 
+/**
+ * Location implementation of the library's full mode feature.
+ */
 export class LocationFull extends LocationLite {
     #eventSubs: Record<Events, Record<number, Function>> = {
         beforeNavigate: {},
diff --git a/src/lib/core/LocationLite.svelte.ts b/src/lib/core/LocationLite.svelte.ts
index 6c14255..e1728d4 100644
--- a/src/lib/core/LocationLite.svelte.ts
+++ b/src/lib/core/LocationLite.svelte.ts
@@ -3,9 +3,9 @@ import { getCompleteStateKey } from "./Location.js";
 import { on } from "svelte/events";
 import { LocationState } from "./LocationState.svelte.js";
 import { routingOptions } from "./options.js";
-import { resolveHashValue } from "./RouterEngine.svelte.js";
+import { resolveHashValue } from "./resolveHashValue.js";
 import { calculateHref } from "./calculateHref.js";
-import { calculateState } from "./calculateState.svelte.js";
+import { calculateState } from "./calculateState.js";
 import { preserveQueryInUrl } from "./preserveQuery.js";
 
 /**
diff --git a/src/lib/core/LocationState.svelte.ts b/src/lib/core/LocationState.svelte.ts
index 3751834..d254b35 100644
--- a/src/lib/core/LocationState.svelte.ts
+++ b/src/lib/core/LocationState.svelte.ts
@@ -1,7 +1,9 @@
-import type { State } from "$lib/types.js";
 import { SvelteURL } from "svelte/reactivity";
 import { isConformantState } from "./isConformantState.js";
 
+/**
+ * Helper class used to manage the reactive data of Location implementations.
+ */
 export class LocationState {
     url = new SvelteURL(globalThis.window?.location?.href);
     state;
diff --git a/src/lib/core/RouterEngine.svelte.ts b/src/lib/core/RouterEngine.svelte.ts
index 82041d5..462253f 100644
--- a/src/lib/core/RouterEngine.svelte.ts
+++ b/src/lib/core/RouterEngine.svelte.ts
@@ -2,6 +2,7 @@ import type { AndUntyped, Hash, PatternRouteInfo, RegexRouteInfo, RouteInfo, Rou
 import { traceOptions, registerRouter, unregisterRouter } from "./trace.svelte.js";
 import { location } from "./Location.js";
 import { routingOptions } from "./options.js";
+import { resolveHashValue } from "./resolveHashValue.js";
 
 /**
  * RouterEngine's options.
@@ -24,18 +25,6 @@ export type RouterEngineOptions = {
     hash?: boolean | string;
 }
 
-/**
- * Resolves the given hash value taking into account the library's routing options.
- * @param hash Hash value to resolve.
- * @returns The resolved hash value.
- */
-export function resolveHashValue(hash: boolean | string | undefined) {
-    if (hash === undefined) {
-        return routingOptions.implicitMode === 'hash';
-    }
-    return hash;
-}
-
 function isRouterEngine(obj: unknown): obj is RouterEngine {
     return obj instanceof RouterEngine;
 }
diff --git a/src/lib/core/calculateHref.ts b/src/lib/core/calculateHref.ts
index 0d37db8..d7e976c 100644
--- a/src/lib/core/calculateHref.ts
+++ b/src/lib/core/calculateHref.ts
@@ -2,7 +2,8 @@ import type { Hash, PreserveQuery } from "$lib/types.js";
 import { dissectHrefs } from "./dissectHrefs.js";
 import { location } from "./Location.js";
 import { mergeQueryParams } from "./preserveQuery.js";
-import { joinPaths, resolveHashValue } from "./RouterEngine.svelte.js";
+import { joinPaths } from "./RouterEngine.svelte.js";
+import { resolveHashValue } from "./resolveHashValue.js";
 
 export type CalculateHrefOptions = {
     /**
@@ -12,28 +13,19 @@ export type CalculateHrefOptions = {
      * the current URL will be appended with the ones from the new URL.
      */
     preserveQuery?: PreserveQuery;
-} & ({
-    /**
-     * Determines the routing universe the new URL will be for.
-     * 
-     * Read the [online documentation](https://wjfe-n-savant.hashnode.space/wjfe-n-savant/routing-modes) to understand 
-     * the concept of routing modes (or universes).
-     */
-    hash: false;
     /**
      * Whether to preserve the current hash in the new URL.  This is only applicable when the `hash` property is set to 
      * `false` (path routing universe).
      */
     preserveHash?: boolean;
-} | {
     /**
      * Determines the routing universe the new URL will be for.
      * 
      * Read the [online documentation](https://wjfe-n-savant.hashnode.space/wjfe-n-savant/routing-modes) to understand 
      * the concept of routing modes (or universes).
      */
-    hash: Exclude<Hash, false>;
-});
+    hash?: Hash;
+};
 
 function calculateMultiHashHref(hashId: string, newPath: string) {
     let idExists = false;
@@ -41,26 +33,48 @@ function calculateMultiHashHref(hashId: string, newPath: string) {
     for (let [id, path] of Object.entries(location.hashPaths)) {
         if (id === hashId) {
             idExists = true;
-            finalUrl += `;${id}=${newPath}`;
-            continue;
+            path = newPath;
         }
         finalUrl += `;${id}=${path}`;
     }
     if (!idExists) {
         finalUrl += `;${hashId}=${newPath}`;
     }
-    return '#' + finalUrl.substring(1);
+    return finalUrl.substring(1);
 }
 
-export function calculateHref(...paths: (string | undefined)[]): string;
-export function calculateHref(options: CalculateHrefOptions, ...paths: (string | undefined)[]): string;
+/**
+ * Combines the given HREF's into a single HREF that also includes any query string parameters that are either carried
+ * by the given HREF's, or preserved from the current environment's URL.
+ *
+ * Calculation is done assuming the resultant HREF will be for the routing universe specified in the library's
+ * `implicitMode` option.
+ * @param hrefs The HREF's used to calculate the final HREF for the routing universe implied by the library's implicit 
+ * mode.
+ */
+export function calculateHref(...hrefs: (string | undefined)[]): string;
+/**
+ * Combines the given HREF's into a single HREF that also includes any query string parameters that are either carried
+ * by the given HREF's, or preserved from the current environment's URL.
+ *
+ * Calculation is done assuming the resultant HREF will be for the routing universe specified by the options' `hash` 
+ * property.  If the option is not specified, then a value will be resolved based on the library's `implicitMode` 
+ * option.
+ * @param options Desired options that control how the resultant HREF is calculated.
+ * @param hrefs The HREF's used to calculate the final HREF for the desired routing universe.
+ */
+export function calculateHref(options: CalculateHrefOptions, ...hrefs: (string | undefined)[]): string;
 export function calculateHref(...allArgs: (CalculateHrefOptions | string | undefined)[]): string {
-    const options = (typeof allArgs[0] === 'object' ? allArgs.shift() : { hash: resolveHashValue(undefined) }) as CalculateHrefOptions;
-    const paths = allArgs as (string | undefined)[];
-    options.preserveQuery ??= false;
-    const dissected = dissectHrefs(...paths);
-    if (options.hash !== false && dissected.hashes.some(h => !!h.length)) {
-        throw new Error("Specifying hashes in the 'href' property is only allowed for path routing.");
+    let options = (typeof allArgs[0] === 'object' ? allArgs.shift() : {}) as CalculateHrefOptions;
+    let {
+        hash = resolveHashValue(undefined),
+        preserveQuery = false,
+        preserveHash = false
+    } = options;
+    const allHrefs = allArgs as (string | undefined)[];
+    const dissected = dissectHrefs(...allHrefs);
+    if (hash !== false && dissected.hashes.some(h => !!h.length)) {
+        throw new Error("Specifying hashes in HREF's is only allowed for path routing.");
     }
     let searchParams: URLSearchParams | undefined;
     let joinedSearchParams = '';
@@ -72,13 +86,12 @@ export function calculateHref(...allArgs: (CalculateHrefOptions | string | undef
     if (joinedSearchParams.length) {
         searchParams = new URLSearchParams(joinedSearchParams.substring(1));
     }
-    searchParams = mergeQueryParams(searchParams, options.preserveQuery);
-    const path = typeof options.hash === 'string' ?
-        calculateMultiHashHref(options.hash, joinPaths(...dissected.paths)) :
+    searchParams = mergeQueryParams(searchParams, preserveQuery);
+    const path = typeof hash === 'string' ?
+        calculateMultiHashHref(hash, joinPaths(...dissected.paths)) :
         joinPaths(...dissected.paths);
-    let hashTag = options.hash === false ?
-        dissected.hashes.find(h => h.length) || ((options.preserveHash ? location.url.hash : '') ?? '') :
+    let hashValue = hash === false ?
+        dissected.hashes.find(h => h.length) || (preserveHash ? location.url.hash.substring(1) : '') :
         path;
-    hashTag = hashTag.length && hashTag[0] !== '#' ? `#${hashTag}` : hashTag;
-    return `${options.hash ? '' : path}${searchParams ? `?${searchParams}` : ''}${hashTag.length ? `${hashTag}` : ''}`;
+    return `${hash ? '' : path}${searchParams ? `?${searchParams}` : ''}${hashValue.length ? `#${hashValue}` : ''}`;
 }
diff --git a/src/lib/core/calculateState.test.ts b/src/lib/core/calculateState.test.ts
index fbef079..3ad46c7 100644
--- a/src/lib/core/calculateState.test.ts
+++ b/src/lib/core/calculateState.test.ts
@@ -1,6 +1,6 @@
 import { init, location } from '$lib/index.js';
 import { describe, test, expect, beforeAll, afterAll, beforeEach, vi } from 'vitest';
-import { calculateState } from './calculateState.svelte.js';
+import { calculateState } from './calculateState.js';
 
 describe('calculateState', () => {
     const initialUrl = "http://example.com/";
diff --git a/src/lib/core/calculateState.svelte.ts b/src/lib/core/calculateState.ts
similarity index 60%
rename from src/lib/core/calculateState.svelte.ts
rename to src/lib/core/calculateState.ts
index 268a5b3..1416a43 100644
--- a/src/lib/core/calculateState.svelte.ts
+++ b/src/lib/core/calculateState.ts
@@ -1,9 +1,16 @@
 import type { Hash, Location, State } from "$lib/types.js";
 import { location } from "./Location.js";
 import { getCompleteStateKey } from "./Location.js";
+import { resolveHashValue } from "./resolveHashValue.js";
 
 type LocationInternal = Location & { [getCompleteStateKey]: () => State };
 
+/**
+ * Calculates the complete state object that should be set in the History API, setting the given state as the state of 
+ * the implicit routing universe, making sure that all states for all other routing universes are preserved.
+ * @param state The desired state for the given hash.
+ */
+export function calculateState(state: any): State;
 /**
  * Calculates the state object that should be set for a given hash value, making sure that all states for all other 
  * routing universes are preserved.
@@ -11,19 +18,24 @@ type LocationInternal = Location & { [getCompleteStateKey]: () => State };
  * @param state The desired state for the given hash.
  * @returns The state object that should be set, accounting for all routing universes.
  */
-export function calculateState(hash: Hash, state: any): State {
+export function calculateState(hash: Hash, state: any): State;
+export function calculateState(hashOrState: any, state?: any): State {
+    let hash: Hash;
+    if (arguments.length === 1) {
+        state = hashOrState;
+        hash = resolveHashValue(undefined);
+    }
+    else {
+        hash = hashOrState;
+    }
     // Get a deep clone of the complete current state using the internal symbol method
     const newState = (location as LocationInternal)[getCompleteStateKey]();
     
     // Set the new state in the appropriate routing universe
     if (typeof hash === 'string') {
-        // For named hash routing (multi-hash mode), set the state for this specific hash name
-        // Preserve all existing named hash universes by only setting the target one
         newState.hash[hash] = state;
     }
     else if (hash) {
-        // For single hash routing (traditional mode), set the single hash state
-        // NOTE: We do NOT preserve other named hash states as we're in traditional mode
         newState.hash = { single: state };
     }
     else {
diff --git a/src/lib/core/index.test.ts b/src/lib/core/index.test.ts
index fb8372c..7315e1b 100644
--- a/src/lib/core/index.test.ts
+++ b/src/lib/core/index.test.ts
@@ -8,7 +8,6 @@ describe('index', () => {
             'RouterEngine',
             'joinPaths',
             'isConformantState',
-            'dissectHrefs',
             'calculateHref',
             'calculateState',
         ];
diff --git a/src/lib/core/index.ts b/src/lib/core/index.ts
index e070237..f1b465b 100644
--- a/src/lib/core/index.ts
+++ b/src/lib/core/index.ts
@@ -1,6 +1,5 @@
 export { location } from "./Location.js";
 export { RouterEngine, joinPaths } from "./RouterEngine.svelte.js";
 export { isConformantState } from "./isConformantState.js";
-export { dissectHrefs } from "./dissectHrefs.js";
 export { calculateHref } from "./calculateHref.js";
-export { calculateState } from "./calculateState.svelte.js";
+export { calculateState } from "./calculateState.js";
diff --git a/src/lib/core/resolveHashValue.ts b/src/lib/core/resolveHashValue.ts
new file mode 100644
index 0000000..f4d19ae
--- /dev/null
+++ b/src/lib/core/resolveHashValue.ts
@@ -0,0 +1,13 @@
+import { routingOptions } from "./options.js";
+
+/**
+ * Resolves the given hash value taking into account the library's routing options.
+ * @param hash Hash value to resolve.
+ * @returns The resolved hash value.
+ */
+export function resolveHashValue(hash: boolean | string | undefined) {
+    if (hash === undefined) {
+        return routingOptions.implicitMode === 'hash';
+    }
+    return hash;
+}
diff --git a/src/lib/index.test.ts b/src/lib/index.test.ts
index 7e2227e..c3fbcd4 100644
--- a/src/lib/index.test.ts
+++ b/src/lib/index.test.ts
@@ -14,9 +14,6 @@ describe('index', () => {
             'init',
             'getRouterContext',
             'setRouterContext',
-            'isConformantState',
-            'calculateHref',
-            'calculateState',
         ];
 
         // Act.
diff --git a/src/lib/index.ts b/src/lib/index.ts
index e2453d4..3b3858b 100644
--- a/src/lib/index.ts
+++ b/src/lib/index.ts
@@ -51,8 +51,5 @@ export * from "$lib/Fallback/Fallback.svelte";
 export { default as Fallback } from "$lib/Fallback/Fallback.svelte";
 export type * from "./types.js";
 export { location } from "./core/Location.js";
-export { isConformantState } from "./core/isConformantState.js";
-export { calculateHref } from "./core/calculateHref.js";
-export { calculateState } from "./core/calculateState.svelte.js";
 export * from './RouterTrace/RouterTrace.svelte';
 export { default as RouterTrace } from './RouterTrace/RouterTrace.svelte';
diff --git a/src/lib/types.ts b/src/lib/types.ts
index 54939e5..b90b26a 100644
--- a/src/lib/types.ts
+++ b/src/lib/types.ts
@@ -131,15 +131,29 @@ export type GoToOptions = {
     preserveQuery?: PreserveQuery;
 }
 
+/**
+ * Defines the options that can be used when calling `Location.navigate`.
+ */
 export type NavigateOptions = Omit<GoToOptions, 'state'> & {
     /**
      * The state data to associate with the new URL and hash value.
      */
     state?: any;
 } & ({
+    /**
+     * The hash value that determines the routing universe in which navigation will take place.
+     */
     hash?: Exclude<Hash, false>;
 } | {
+    /**
+     * The hash value that determines the routing universe in which navigation will take place.
+     */
     hash?: false;
+    /**
+     * Determines whether the current hash value should be preserved when navigating.
+     * 
+     * **IMPORTANT**:  This option is only valid for path routing scenarios.
+     */
     preserveHash?: boolean;
 });