From 4e7883e3d82d86336384e52523aec17bb88112fa Mon Sep 17 00:00:00 2001
From: Evan Sutherland <stackoverfloweth@gmail.com>
Date: Mon, 23 Mar 2026 10:16:06 -0500
Subject: [PATCH] POC vite+ migration

---
 .vite-hooks/pre-commit                        |    1 +
 AGENTS.md                                     |   76 +
 eslint.config.js                              |   19 -
 oxlintrc.json                                 |  681 ++++
 package-lock.json                             | 2816 ++++++++++-------
 package.json                                  |   67 +-
 src/.DS_Store                                 |  Bin 0 -> 6148 bytes
 src/components/routerLink.browser.spec.ts     | 1397 ++++----
 src/components/routerLink.ts                  |  229 +-
 src/components/routerView.browser.spec.ts     |  784 ++---
 src/components/routerView.spec.ts             |   40 +-
 src/components/routerView.ts                  |  151 +-
 .../useQueryValue.browser.spec.ts             |  282 +-
 src/compositions/useQueryValue.spec-d.ts      |   62 +-
 src/compositions/useRoute.browser.spec.ts     |  128 +-
 src/compositions/useRoute.spec-d.ts           |  166 +-
 src/guards/routes.spec-d.ts                   |  100 +-
 src/services/arrayOf.spec.ts                  |   54 +-
 src/services/combineHash.spec.ts              |   60 +-
 src/services/combineMeta.spec.ts              |   44 +-
 src/services/combinePath.spec-d.ts            |  114 +-
 src/services/combinePath.spec.ts              |   60 +-
 src/services/combineQuery.spec.ts             |   60 +-
 src/services/combineState.spec.ts             |   30 +-
 src/services/combineUrl.spec.ts               |   64 +-
 src/services/component.browser.spec.ts        |  151 +-
 src/services/createExternalRoute.spec.ts      |   82 +-
 src/services/createIsExternal.spec.ts         |   46 +-
 src/services/createResolvedRoute.spec.ts      |   96 +-
 src/services/createRoute.spec-d.ts            | 1292 ++++----
 src/services/createRoute.spec.ts              |  475 +--
 src/services/createRouteRedirects.spec.ts     |  184 +-
 src/services/createRouter.browser.spec.ts     |  124 +-
 src/services/createRouter.spec-d.ts           |  382 +--
 src/services/createRouter.spec.ts             | 1275 ++++----
 src/services/createRouter.ts                  |  450 +--
 .../createRouterHistory.browser.spec.ts       |   46 +-
 .../createRouterPlugin.browser.spec.ts        |  194 +-
 src/services/createRouterPlugin.spec-d.ts     |   60 +-
 src/services/createRouterRoute.spec.ts        |   76 +-
 src/services/createUrl.spec.ts                | 1117 +++----
 src/services/getInitialUrl.browser.spec.ts    |   28 +-
 src/services/getInitialUrl.spec.ts            |   12 +-
 src/services/getMatchesForUrl.spec.ts         |  194 +-
 src/services/getRouteHooks.spec.ts            |   80 +-
 src/services/getRoutesForRouter.spec.ts       |  160 +-
 src/services/getRoutesForRouter.ts            |   99 +-
 src/services/history.browser.spec.ts          |  214 +-
 src/services/history.ts                       |  531 ++--
 src/services/hooks.browser.spec.ts            |  509 +--
 src/services/hooks.spec.ts                    |  316 +-
 src/services/insertBaseRoute.spec.ts          |   34 +-
 src/services/params.spec.ts                   |  338 +-
 src/services/paramsFinder.spec.ts             |  127 +-
 src/services/queryParamFilter.spec.ts         |   52 +-
 src/services/routeRegex.spec.ts               |  329 +-
 src/services/state.spec.ts                    |  140 +-
 src/services/tupleOf.spec.ts                  |   73 +-
 src/services/unionOf.spec.ts                  |  126 +-
 src/services/urlParser.spec.ts                |  245 +-
 src/services/valibot.spec-d.ts                |   32 +-
 src/services/valibot.spec.ts                  |   96 +-
 src/services/valibot.ts                       |  220 +-
 src/services/withParams.spec-d.ts             |  247 +-
 src/services/withParams.spec.ts               |  226 +-
 src/services/zod.spec-d.ts                    |   32 +-
 src/services/zod.spec.ts                      |  174 +-
 src/services/zod.ts                           |  232 +-
 src/tests/hooks.spec.ts                       |   85 +-
 src/tests/routeProps.browser.spec.ts          |  156 +-
 src/tests/routeProps.spec.ts                  |   88 +-
 src/types/redirects.spec-d.ts                 |  104 +-
 src/types/register.spec.ts                    |   12 +-
 src/types/resolved.spec-d.ts                  |   40 +-
 src/types/route.spec-d.ts                     |   79 +-
 src/types/routeTitle.browser.spec.ts          |  194 +-
 src/types/routeWithParams.spec-d.ts           |   30 +-
 src/types/routesMap.spec-ts.ts                |   62 +-
 src/utilities/checkDuplicateNames.spec.ts     |   68 +-
 src/utilities/checkDuplicateParams.spec.ts    |   92 +-
 src/utilities/components.spec.ts              |   16 +-
 src/utilities/guards.spec.ts                  |   94 +-
 src/utilities/isBrowser.browser.spec.ts       |   10 +-
 src/utilities/isBrowser.spec.ts               |   10 +-
 src/utilities/prefetch.spec.ts                |   62 +-
 src/utilities/trailingSlashes.spec.ts         |  142 +-
 src/utilities/urlSearchParams.spec.ts         |   37 +-
 vite.config.js                                |   51 +-
 88 files changed, 10915 insertions(+), 8918 deletions(-)
 create mode 100755 .vite-hooks/pre-commit
 create mode 100644 AGENTS.md
 delete mode 100644 eslint.config.js
 create mode 100644 oxlintrc.json
 create mode 100644 src/.DS_Store

diff --git a/.vite-hooks/pre-commit b/.vite-hooks/pre-commit
new file mode 100755
index 00000000..85fb65b4
--- /dev/null
+++ b/.vite-hooks/pre-commit
@@ -0,0 +1 @@
+vp staged
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 00000000..f190a523
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,76 @@
+<!--VITE PLUS START-->
+
+# Using Vite+, the Unified Toolchain for the Web
+
+This project is using Vite+, a unified toolchain built on top of Vite, Rolldown, Vitest, tsdown, Oxlint, Oxfmt, and Vite Task. Vite+ wraps runtime management, package management, and frontend tooling in a single global CLI called `vp`. Vite+ is distinct from Vite, but it invokes Vite through `vp dev` and `vp build`.
+
+## Vite+ Workflow
+
+`vp` is a global binary that handles the full development lifecycle. Run `vp help` to print a list of commands and `vp <command> --help` for information about a specific command.
+
+### Start
+
+- create - Create a new project from a template
+- migrate - Migrate an existing project to Vite+
+- config - Configure hooks and agent integration
+- staged - Run linters on staged files
+- install (`i`) - Install dependencies
+- env - Manage Node.js versions
+
+### Develop
+
+- dev - Run the development server
+- check - Run format, lint, and TypeScript type checks
+- lint - Lint code
+- fmt - Format code
+- test - Run tests
+
+### Execute
+
+- run - Run monorepo tasks
+- exec - Execute a command from local `node_modules/.bin`
+- dlx - Execute a package binary without installing it as a dependency
+- cache - Manage the task cache
+
+### Build
+
+- build - Build for production
+- pack - Build libraries
+- preview - Preview production build
+
+### Manage Dependencies
+
+Vite+ automatically detects and wraps the underlying package manager such as pnpm, npm, or Yarn through the `packageManager` field in `package.json` or package manager-specific lockfiles.
+
+- add - Add packages to dependencies
+- remove (`rm`, `un`, `uninstall`) - Remove packages from dependencies
+- update (`up`) - Update packages to latest versions
+- dedupe - Deduplicate dependencies
+- outdated - Check for outdated packages
+- list (`ls`) - List installed packages
+- why (`explain`) - Show why a package is installed
+- info (`view`, `show`) - View package information from the registry
+- link (`ln`) / unlink - Manage local package links
+- pm - Forward a command to the package manager
+
+### Maintain
+
+- upgrade - Update `vp` itself to the latest version
+
+These commands map to their corresponding tools. For example, `vp dev --port 3000` runs Vite's dev server and works the same as Vite. `vp test` runs JavaScript tests through the bundled Vitest. The version of all tools can be checked using `vp --version`. This is useful when researching documentation, features, and bugs.
+
+## Common Pitfalls
+
+- **Using the package manager directly:** Do not use pnpm, npm, or Yarn directly. Vite+ can handle all package manager operations.
+- **Always use Vite commands to run tools:** Don't attempt to run `vp vitest` or `vp oxlint`. They do not exist. Use `vp test` and `vp lint` instead.
+- **Running scripts:** Vite+ built-in commands (`vp dev`, `vp build`, `vp test`, etc.) always run the Vite+ built-in tool, not any `package.json` script of the same name. To run a custom script that shares a name with a built-in command, use `vp run <script>`. For example, if you have a custom `dev` script that runs multiple services concurrently, run it with `vp run dev`, not `vp dev` (which always starts Vite's dev server).
+- **Do not install Vitest, Oxlint, Oxfmt, or tsdown directly:** Vite+ wraps these tools. They must not be installed directly. You cannot upgrade these tools by installing their latest versions. Always use Vite+ commands.
+- **Use Vite+ wrappers for one-off binaries:** Use `vp dlx` instead of package-manager-specific `dlx`/`npx` commands.
+- **Import JavaScript modules from `vite-plus`:** Instead of importing from `vite` or `vitest`, all modules should be imported from the project's `vite-plus` dependency. For example, `import { defineConfig } from 'vite-plus';` or `import { expect, test, vi } from 'vite-plus/test';`. You must not install `vitest` to import test utilities.
+- **Type-Aware Linting:** There is no need to install `oxlint-tsgolint`, `vp lint --type-aware` works out of the box.
+
+## Review Checklist for Agents
+
+- [ ] Run `vp install` after pulling remote changes and before getting started.
+- [ ] Run `vp check` and `vp test` to validate changes.
+<!--VITE PLUS END-->
diff --git a/eslint.config.js b/eslint.config.js
deleted file mode 100644
index e016bc1d..00000000
--- a/eslint.config.js
+++ /dev/null
@@ -1,19 +0,0 @@
-import config from '@kitbag/eslint-config'
-
-/** @type {import('eslint').Linter.Config[]} */
-export default [
-  ...config,
-  {
-    rules: {
-      '@typescript-eslint/no-confusing-void-expression': ['off'],
-      '@typescript-eslint/only-throw-error': ['off'],
-      '@typescript-eslint/no-explicit-any': ['off'],
-    },
-  },
-  {
-    files: ['**/*.spec-d.ts'],
-    rules: {
-      '@typescript-eslint/no-unused-vars': ['off'],
-    },
-  },
-]
diff --git a/oxlintrc.json b/oxlintrc.json
new file mode 100644
index 00000000..d4e8027e
--- /dev/null
+++ b/oxlintrc.json
@@ -0,0 +1,681 @@
+{
+  "$schema": "https://raw.githubusercontent.com/nicolo-ribaudo/oxc/oxlint-v0.17.0/npm/oxlint/configuration_schema.json",
+  "plugins": ["oxc", "typescript", "unicorn", "react", "vue"],
+  "jsPlugins": ["@stylistic/eslint-plugin"],
+  "categories": {
+    "correctness": "warn"
+  },
+  "options": {
+    "typeAware": true,
+    "typeCheck": true
+  },
+  "env": {
+    "browser": true,
+    "builtin": true,
+    "es2024": true
+  },
+  "rules": {
+    "@typescript-eslint/await-thenable": "error",
+    "@typescript-eslint/ban-ts-comment": [
+      "error",
+      {
+        "minimumDescriptionLength": 10
+      }
+    ],
+    "no-array-constructor": "error",
+    "@typescript-eslint/no-array-delete": "error",
+    "@typescript-eslint/no-base-to-string": "error",
+    "@typescript-eslint/no-confusing-void-expression": "off",
+    "@typescript-eslint/no-deprecated": "error",
+    "@typescript-eslint/no-duplicate-enum-values": "error",
+    "@typescript-eslint/no-duplicate-type-constituents": "error",
+    "@typescript-eslint/no-dynamic-delete": "error",
+    "@typescript-eslint/no-empty-object-type": "error",
+    "@typescript-eslint/no-explicit-any": "off",
+    "@typescript-eslint/no-extra-non-null-assertion": "error",
+    "@typescript-eslint/no-extraneous-class": "error",
+    "@typescript-eslint/no-floating-promises": "error",
+    "@typescript-eslint/no-for-in-array": "error",
+    "@typescript-eslint/no-implied-eval": "error",
+    "@typescript-eslint/no-invalid-void-type": "error",
+    "@typescript-eslint/no-meaningless-void-operator": "error",
+    "@typescript-eslint/no-misused-new": "error",
+    "@typescript-eslint/no-misused-promises": "error",
+    "@typescript-eslint/no-misused-spread": "error",
+    "@typescript-eslint/no-mixed-enums": "error",
+    "@typescript-eslint/no-namespace": "error",
+    "@typescript-eslint/no-non-null-asserted-nullish-coalescing": "error",
+    "@typescript-eslint/no-non-null-asserted-optional-chain": "error",
+    "@typescript-eslint/no-non-null-assertion": "error",
+    "@typescript-eslint/no-redundant-type-constituents": "error",
+    "@typescript-eslint/no-require-imports": "error",
+    "@typescript-eslint/no-this-alias": "error",
+    "@typescript-eslint/no-unnecessary-boolean-literal-compare": "error",
+    "@typescript-eslint/no-unnecessary-condition": "error",
+    "@typescript-eslint/no-unnecessary-template-expression": "error",
+    "@typescript-eslint/no-unnecessary-type-arguments": "error",
+    "@typescript-eslint/no-unnecessary-type-assertion": "error",
+    "@typescript-eslint/no-unnecessary-type-constraint": "error",
+    "@typescript-eslint/no-unnecessary-type-conversion": "error",
+    "@typescript-eslint/no-unnecessary-type-parameters": "error",
+    "@typescript-eslint/no-unsafe-argument": "error",
+    "@typescript-eslint/no-unsafe-assignment": "error",
+    "@typescript-eslint/no-unsafe-call": "error",
+    "@typescript-eslint/no-unsafe-declaration-merging": "error",
+    "@typescript-eslint/no-unsafe-enum-comparison": "error",
+    "@typescript-eslint/no-unsafe-function-type": "error",
+    "@typescript-eslint/no-unsafe-member-access": "error",
+    "@typescript-eslint/no-unsafe-return": "error",
+    "@typescript-eslint/no-unsafe-unary-minus": "error",
+    "no-unused-expressions": "error",
+    "no-unused-vars": "error",
+    "no-useless-constructor": "error",
+    "@typescript-eslint/no-useless-default-assignment": "error",
+    "@typescript-eslint/no-wrapper-object-types": "error",
+    "@typescript-eslint/only-throw-error": "off",
+    "@typescript-eslint/prefer-as-const": "error",
+    "@typescript-eslint/prefer-literal-enum-member": "error",
+    "@typescript-eslint/prefer-namespace-keyword": "error",
+    "@typescript-eslint/prefer-promise-reject-errors": "error",
+    "@typescript-eslint/prefer-reduce-type-parameter": "error",
+    "@typescript-eslint/prefer-return-this-type": "error",
+    "@typescript-eslint/related-getter-setter-pairs": "error",
+    "@typescript-eslint/require-await": "error",
+    "@typescript-eslint/restrict-plus-operands": [
+      "error",
+      {
+        "allowAny": false,
+        "allowBoolean": false,
+        "allowNullish": false,
+        "allowNumberAndString": false,
+        "allowRegExp": false
+      }
+    ],
+    "@typescript-eslint/restrict-template-expressions": [
+      "error",
+      {
+        "allowAny": false,
+        "allowBoolean": false,
+        "allowNever": false,
+        "allowNullish": false,
+        "allowNumber": false,
+        "allowRegExp": false
+      }
+    ],
+    "@typescript-eslint/return-await": ["error", "error-handling-correctness-only"],
+    "@typescript-eslint/triple-slash-reference": "error",
+    "@typescript-eslint/unbound-method": "error",
+    "@typescript-eslint/unified-signatures": "error",
+    "@typescript-eslint/use-unknown-in-catch-callback-variable": "error",
+    "@typescript-eslint/adjacent-overload-signatures": "error",
+    "@typescript-eslint/array-type": "error",
+    "@typescript-eslint/ban-tslint-comment": "error",
+    "@typescript-eslint/class-literal-property-style": "error",
+    "@typescript-eslint/consistent-generic-constructors": "error",
+    "@typescript-eslint/consistent-indexed-object-style": "error",
+    "@typescript-eslint/consistent-type-assertions": "error",
+    "@typescript-eslint/consistent-type-definitions": "error",
+    "@typescript-eslint/no-confusing-non-null-assertion": "error",
+    "no-empty-function": "error",
+    "@typescript-eslint/no-inferrable-types": "error",
+    "@typescript-eslint/non-nullable-type-assertion-style": "error",
+    "@typescript-eslint/prefer-find": "error",
+    "@typescript-eslint/prefer-for-of": "error",
+    "@typescript-eslint/prefer-function-type": "error",
+    "@typescript-eslint/prefer-includes": "error",
+    "@typescript-eslint/prefer-nullish-coalescing": "error",
+    "@typescript-eslint/prefer-optional-chain": "error",
+    "@typescript-eslint/prefer-regexp-exec": "error",
+    "@typescript-eslint/prefer-string-starts-ends-with": "error",
+    "@stylistic/array-bracket-spacing": ["error", "never"],
+    "@stylistic/arrow-parens": [
+      "error",
+      "as-needed",
+      {
+        "requireForBlockBody": true
+      }
+    ],
+    "@stylistic/arrow-spacing": [
+      "error",
+      {
+        "after": true,
+        "before": true
+      }
+    ],
+    "@stylistic/block-spacing": ["error", "always"],
+    "@stylistic/brace-style": [
+      "error",
+      "stroustrup",
+      {
+        "allowSingleLine": true
+      }
+    ],
+    "@stylistic/comma-dangle": ["error", "always-multiline"],
+    "@stylistic/comma-spacing": [
+      "error",
+      {
+        "after": true,
+        "before": false
+      }
+    ],
+    "@stylistic/comma-style": ["error", "last"],
+    "@stylistic/computed-property-spacing": [
+      "error",
+      "never",
+      {
+        "enforceForClassMembers": true
+      }
+    ],
+    "@stylistic/dot-location": ["error", "property"],
+    "@stylistic/eol-last": "error",
+    "@stylistic/indent": [
+      "error",
+      2,
+      {
+        "ArrayExpression": 1,
+        "CallExpression": {
+          "arguments": 1
+        },
+        "flatTernaryExpressions": false,
+        "FunctionDeclaration": {
+          "body": 1,
+          "parameters": 1
+        },
+        "FunctionExpression": {
+          "body": 1,
+          "parameters": 1
+        },
+        "ignoreComments": false,
+        "ignoredNodes": [
+          "TSUnionType",
+          "TSIntersectionType",
+          "TSTypeParameterInstantiation",
+          "FunctionExpression > .params[decorators.length > 0]",
+          "FunctionExpression > .params > :matches(Decorator, :not(:first-child))"
+        ],
+        "ImportDeclaration": 1,
+        "MemberExpression": 1,
+        "ObjectExpression": 1,
+        "offsetTernaryExpressions": true,
+        "outerIIFEBody": 1,
+        "SwitchCase": 1,
+        "tabLength": 2,
+        "VariableDeclarator": 1
+      }
+    ],
+    "@stylistic/indent-binary-ops": ["error", 2],
+    "@stylistic/key-spacing": [
+      "error",
+      {
+        "afterColon": true,
+        "beforeColon": false
+      }
+    ],
+    "@stylistic/keyword-spacing": [
+      "error",
+      {
+        "after": true,
+        "before": true
+      }
+    ],
+    "@stylistic/lines-between-class-members": [
+      "error",
+      "always",
+      {
+        "exceptAfterSingleLine": true
+      }
+    ],
+    "@stylistic/max-statements-per-line": [
+      "error",
+      {
+        "max": 1
+      }
+    ],
+    "@stylistic/member-delimiter-style": [
+      "error",
+      {
+        "multiline": {
+          "delimiter": "none",
+          "requireLast": false
+        },
+        "multilineDetection": "brackets",
+        "overrides": {
+          "interface": {
+            "multiline": {
+              "delimiter": "none",
+              "requireLast": false
+            }
+          }
+        },
+        "singleline": {
+          "delimiter": "comma"
+        }
+      }
+    ],
+    "@stylistic/multiline-ternary": ["error", "always-multiline"],
+    "@stylistic/new-parens": "error",
+    "@stylistic/no-extra-parens": ["error", "functions"],
+    "@stylistic/no-floating-decimal": "error",
+    "@stylistic/no-mixed-operators": [
+      "error",
+      {
+        "allowSamePrecedence": true,
+        "groups": [
+          ["==", "!=", "===", "!==", ">", ">=", "<", "<="],
+          ["&&", "||"],
+          ["in", "instanceof"]
+        ]
+      }
+    ],
+    "@stylistic/no-mixed-spaces-and-tabs": "error",
+    "@stylistic/no-multi-spaces": "error",
+    "@stylistic/no-multiple-empty-lines": [
+      "error",
+      {
+        "max": 1,
+        "maxBOF": 0,
+        "maxEOF": 0
+      }
+    ],
+    "@stylistic/no-tabs": "error",
+    "@stylistic/no-trailing-spaces": "error",
+    "@stylistic/no-whitespace-before-property": "error",
+    "@stylistic/object-curly-spacing": ["error", "always"],
+    "@stylistic/operator-linebreak": ["error", "before"],
+    "@stylistic/padded-blocks": [
+      "error",
+      {
+        "blocks": "never",
+        "classes": "never",
+        "switches": "never"
+      }
+    ],
+    "@stylistic/quote-props": ["error", "consistent-as-needed"],
+    "@stylistic/quotes": [
+      "error",
+      "single",
+      {
+        "allowTemplateLiterals": true,
+        "avoidEscape": false
+      }
+    ],
+    "@stylistic/rest-spread-spacing": ["error", "never"],
+    "@stylistic/semi": ["error", "never"],
+    "@stylistic/semi-spacing": [
+      "error",
+      {
+        "after": true,
+        "before": false
+      }
+    ],
+    "@stylistic/space-before-blocks": ["error", "always"],
+    "@stylistic/space-before-function-paren": [
+      "error",
+      {
+        "anonymous": "always",
+        "asyncArrow": "always",
+        "named": "never"
+      }
+    ],
+    "@stylistic/space-in-parens": ["error", "never"],
+    "@stylistic/space-infix-ops": "error",
+    "@stylistic/space-unary-ops": [
+      "error",
+      {
+        "nonwords": false,
+        "words": true
+      }
+    ],
+    "@stylistic/spaced-comment": [
+      "error",
+      "always",
+      {
+        "block": {
+          "balanced": true,
+          "exceptions": ["*"],
+          "markers": ["!"]
+        },
+        "line": {
+          "exceptions": ["/", "#"],
+          "markers": ["/"]
+        }
+      }
+    ],
+    "@stylistic/template-curly-spacing": "error",
+    "@stylistic/template-tag-spacing": ["error", "never"],
+    "@stylistic/type-annotation-spacing": ["error", {}],
+    "@stylistic/type-generic-spacing": "error",
+    "@stylistic/type-named-tuple-spacing": "error",
+    "@stylistic/wrap-iife": [
+      "error",
+      "any",
+      {
+        "functionPrototypeMethods": true
+      }
+    ],
+    "@stylistic/yield-star-spacing": ["error", "both"],
+    "@stylistic/jsx-closing-bracket-location": "error",
+    "@stylistic/jsx-closing-tag-location": "error",
+    "@stylistic/jsx-curly-brace-presence": [
+      "error",
+      {
+        "propElementValues": "always"
+      }
+    ],
+    "@stylistic/jsx-curly-newline": "error",
+    "@stylistic/jsx-curly-spacing": ["error", "never"],
+    "@stylistic/jsx-equals-spacing": "error",
+    "@stylistic/jsx-first-prop-new-line": "error",
+    "@stylistic/jsx-function-call-newline": ["error", "multiline"],
+    "@stylistic/jsx-indent-props": ["error", 2],
+    "@stylistic/jsx-max-props-per-line": [
+      "error",
+      {
+        "maximum": 1,
+        "when": "multiline"
+      }
+    ],
+    "@stylistic/jsx-one-expression-per-line": [
+      "error",
+      {
+        "allow": "single-child"
+      }
+    ],
+    "@stylistic/jsx-quotes": "error",
+    "@stylistic/jsx-tag-spacing": [
+      "error",
+      {
+        "afterOpening": "never",
+        "beforeClosing": "never",
+        "beforeSelfClosing": "always",
+        "closingSlash": "never"
+      }
+    ],
+    "@stylistic/jsx-wrap-multilines": [
+      "error",
+      {
+        "arrow": "parens-new-line",
+        "assignment": "parens-new-line",
+        "condition": "parens-new-line",
+        "declaration": "parens-new-line",
+        "logical": "parens-new-line",
+        "prop": "parens-new-line",
+        "propertyValue": "parens-new-line",
+        "return": "parens-new-line"
+      }
+    ],
+    "vue/no-arrow-functions-in-watch": "error",
+    "vue/no-deprecated-destroyed-lifecycle": "error",
+    "vue/no-export-in-script-setup": "error",
+    "vue/no-lifecycle-after-await": "error",
+    "vue/prefer-import-from-vue": "error",
+    "vue/valid-define-emits": "error",
+    "vue/valid-define-props": "error",
+    "vue/no-multiple-slot-args": "warn"
+  },
+  "overrides": [
+    {
+      "files": ["**/*.ts", "**/*.tsx", "**/*.mts", "**/*.cts"],
+      "rules": {
+        "constructor-super": "off",
+        "getter-return": "off",
+        "no-class-assign": "off",
+        "no-const-assign": "off",
+        "no-dupe-class-members": "off",
+        "no-dupe-keys": "off",
+        "no-func-assign": "off",
+        "no-import-assign": "off",
+        "no-new-native-nonconstructor": "off",
+        "no-obj-calls": "off",
+        "no-redeclare": "off",
+        "no-setter-return": "off",
+        "no-this-before-super": "off",
+        "no-undef": "off",
+        "no-unreachable": "off",
+        "no-unsafe-negation": "off",
+        "no-var": "error",
+        "no-with": "off",
+        "prefer-const": "error",
+        "prefer-rest-params": "error",
+        "prefer-spread": "error"
+      }
+    },
+    {
+      "files": ["**/*.{ts,vue}"],
+      "rules": {
+        "no-duplicate-imports": "warn",
+        "@typescript-eslint/array-type": "warn",
+        "@typescript-eslint/consistent-type-definitions": "off",
+        "@typescript-eslint/explicit-function-return-type": [
+          "warn",
+          {
+            "allowExpressions": true
+          }
+        ],
+        "@typescript-eslint/no-empty-object-type": "off",
+        "@typescript-eslint/no-floating-promises": "off",
+        "@typescript-eslint/no-inferrable-types": "off",
+        "@typescript-eslint/no-unsafe-argument": "off",
+        "@typescript-eslint/no-unsafe-assignment": "off",
+        "@typescript-eslint/no-unsafe-call": "off",
+        "@typescript-eslint/no-unsafe-member-access": "off",
+        "@typescript-eslint/no-unsafe-return": "off",
+        "@typescript-eslint/non-nullable-type-assertion-style": "warn",
+        "@typescript-eslint/parameter-properties": "warn",
+        "@typescript-eslint/prefer-enum-initializers": "warn",
+        "@typescript-eslint/prefer-nullish-coalescing": [
+          "warn",
+          {
+            "ignoreConditionalTests": true
+          }
+        ],
+        "@typescript-eslint/prefer-readonly": "warn",
+        "@typescript-eslint/require-array-sort-compare": "warn",
+        "@typescript-eslint/require-await": "off",
+        "@typescript-eslint/restrict-template-expressions": "off",
+        "@typescript-eslint/switch-exhaustiveness-check": "warn",
+        "@typescript-eslint/unbound-method": "off",
+        "@typescript-eslint/unified-signatures": "off",
+        "@stylistic/arrow-parens": ["warn", "always"],
+        "@stylistic/array-bracket-newline": ["warn", "consistent"],
+        "@stylistic/array-element-newline": [
+          "warn",
+          {
+            "consistent": true,
+            "multiline": true
+          }
+        ],
+        "@stylistic/brace-style": ["warn", "1tbs"],
+        "@stylistic/comma-dangle": [
+          "warn",
+          {
+            "arrays": "always-multiline",
+            "objects": "always-multiline",
+            "imports": "never",
+            "exports": "never",
+            "functions": "always-multiline"
+          }
+        ],
+        "@stylistic/comma-spacing": "warn",
+        "@stylistic/curly-newline": [
+          "warn",
+          {
+            "multiline": true,
+            "consistent": true
+          }
+        ],
+        "@stylistic/dot-location": ["warn", "property"],
+        "@stylistic/func-call-spacing": "warn",
+        "@stylistic/function-call-spacing": "warn",
+        "@stylistic/implicit-arrow-linebreak": "warn",
+        "@stylistic/key-spacing": [
+          "warn",
+          {
+            "afterColon": true
+          }
+        ],
+        "@stylistic/keyword-spacing": [
+          "warn",
+          {
+            "before": true,
+            "after": true
+          }
+        ],
+        "@stylistic/member-delimiter-style": [
+          "warn",
+          {
+            "multiline": {
+              "delimiter": "comma",
+              "requireLast": true
+            },
+            "singleline": {
+              "delimiter": "comma",
+              "requireLast": false
+            }
+          }
+        ],
+        "@stylistic/newline-per-chained-call": [
+          "warn",
+          {
+            "ignoreChainWithDepth": 2
+          }
+        ],
+        "@stylistic/no-confusing-arrow": "warn",
+        "@stylistic/object-curly-newline": [
+          "warn",
+          {
+            "multiline": true,
+            "consistent": true
+          }
+        ],
+        "@stylistic/object-curly-spacing": ["warn", "always"],
+        "@stylistic/operator-linebreak": [
+          "warn",
+          "none",
+          {
+            "overrides": {
+              "||": "before",
+              "&&": "before"
+            }
+          }
+        ],
+        "@stylistic/object-property-newline": [
+          "warn",
+          {
+            "allowAllPropertiesOnSameLine": true
+          }
+        ],
+        "@stylistic/one-var-declaration-per-line": "warn",
+        "@stylistic/quotes": [
+          "warn",
+          "single",
+          {
+            "avoidEscape": true
+          }
+        ],
+        "@stylistic/space-before-function-paren": [
+          "warn",
+          {
+            "anonymous": "never",
+            "named": "never",
+            "asyncArrow": "always"
+          }
+        ],
+        "@stylistic/spaced-comment": [
+          "warn",
+          "always",
+          {
+            "markers": ["/"]
+          }
+        ],
+        "@stylistic/switch-colon-spacing": "warn",
+        "no-empty-function": "off",
+        "no-unused-vars": [
+          "warn",
+          {
+            "ignoreRestSiblings": true
+          }
+        ]
+      },
+      "jsPlugins": ["@stylistic/eslint-plugin"]
+    },
+    {
+      "files": ["**/*.vue"],
+      "rules": {
+        "@stylistic/indent": "off",
+        "vue/no-multiple-slot-args": "warn",
+        "vue/no-this-in-before-route-enter": "warn"
+      },
+      "jsPlugins": ["@stylistic/eslint-plugin"]
+    },
+    {
+      "files": ["**/*.js"],
+      "rules": {
+        "@typescript-eslint/await-thenable": "off",
+        "@typescript-eslint/consistent-return": "off",
+        "@typescript-eslint/consistent-type-exports": "off",
+        "@typescript-eslint/no-array-delete": "off",
+        "@typescript-eslint/no-base-to-string": "off",
+        "@typescript-eslint/no-confusing-void-expression": "off",
+        "@typescript-eslint/no-deprecated": "off",
+        "@typescript-eslint/no-duplicate-type-constituents": "off",
+        "@typescript-eslint/no-floating-promises": "off",
+        "@typescript-eslint/no-for-in-array": "off",
+        "@typescript-eslint/no-implied-eval": "off",
+        "@typescript-eslint/no-meaningless-void-operator": "off",
+        "@typescript-eslint/no-misused-promises": "off",
+        "@typescript-eslint/no-misused-spread": "off",
+        "@typescript-eslint/no-mixed-enums": "off",
+        "@typescript-eslint/no-redundant-type-constituents": "off",
+        "@typescript-eslint/no-unnecessary-boolean-literal-compare": "off",
+        "@typescript-eslint/no-unnecessary-condition": "off",
+        "@typescript-eslint/no-unnecessary-qualifier": "off",
+        "@typescript-eslint/no-unnecessary-template-expression": "off",
+        "@typescript-eslint/no-unnecessary-type-arguments": "off",
+        "@typescript-eslint/no-unnecessary-type-assertion": "off",
+        "@typescript-eslint/no-unnecessary-type-conversion": "off",
+        "@typescript-eslint/no-unnecessary-type-parameters": "off",
+        "@typescript-eslint/no-unsafe-argument": "off",
+        "@typescript-eslint/no-unsafe-assignment": "off",
+        "@typescript-eslint/no-unsafe-call": "off",
+        "@typescript-eslint/no-unsafe-enum-comparison": "off",
+        "@typescript-eslint/no-unsafe-member-access": "off",
+        "@typescript-eslint/no-unsafe-return": "off",
+        "@typescript-eslint/no-unsafe-type-assertion": "off",
+        "@typescript-eslint/no-unsafe-unary-minus": "off",
+        "@typescript-eslint/no-useless-default-assignment": "off",
+        "@typescript-eslint/non-nullable-type-assertion-style": "off",
+        "@typescript-eslint/only-throw-error": "off",
+        "@typescript-eslint/prefer-find": "off",
+        "@typescript-eslint/prefer-includes": "off",
+        "@typescript-eslint/prefer-nullish-coalescing": "off",
+        "@typescript-eslint/prefer-optional-chain": "off",
+        "@typescript-eslint/prefer-promise-reject-errors": "off",
+        "@typescript-eslint/prefer-readonly": "off",
+        "@typescript-eslint/prefer-readonly-parameter-types": "off",
+        "@typescript-eslint/prefer-reduce-type-parameter": "off",
+        "@typescript-eslint/prefer-regexp-exec": "off",
+        "@typescript-eslint/prefer-return-this-type": "off",
+        "@typescript-eslint/prefer-string-starts-ends-with": "off",
+        "@typescript-eslint/promise-function-async": "off",
+        "@typescript-eslint/related-getter-setter-pairs": "off",
+        "@typescript-eslint/require-array-sort-compare": "off",
+        "@typescript-eslint/require-await": "off",
+        "@typescript-eslint/restrict-plus-operands": "off",
+        "@typescript-eslint/restrict-template-expressions": "off",
+        "@typescript-eslint/return-await": "off",
+        "@typescript-eslint/strict-boolean-expressions": "off",
+        "@typescript-eslint/strict-void-return": "off",
+        "@typescript-eslint/switch-exhaustiveness-check": "off",
+        "@typescript-eslint/unbound-method": "off",
+        "@typescript-eslint/use-unknown-in-catch-callback-variable": "off"
+      }
+    },
+    {
+      "files": ["**/*.spec-d.ts"],
+      "rules": {
+        "no-unused-vars": "off"
+      }
+    }
+  ]
+}
diff --git a/package-lock.json b/package-lock.json
index 03b596ea..6db8ce91 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -13,21 +13,20 @@
         "@vue/devtools-api": "^8.0.7"
       },
       "devDependencies": {
-        "@kitbag/eslint-config": "1.0.2",
+        "@stylistic/eslint-plugin": "^5.10.0",
         "@vitejs/plugin-vue": "^6.0.5",
         "@vue/test-utils": "^2.4.6",
-        "eslint": "^9.39.4",
-        "globals": "^17.4.0",
         "happy-dom": "^20.8.4",
         "typedoc": "^0.28.17",
         "typedoc-plugin-markdown": "^4.11.0",
         "typedoc-vitepress-theme": "^1.1.2",
         "typescript": "^5.9.3",
         "valibot": "^1.0.0",
-        "vite": "^8.0.0",
+        "vite": "npm:@voidzero-dev/vite-plus-core@latest",
         "vite-plugin-dts": "^4.5.4",
+        "vite-plus": "latest",
         "vitepress": "^1.6.4",
-        "vitest": "^4.1.0",
+        "vitest": "npm:@voidzero-dev/vite-plus-test@latest",
         "vue-tsc": "^3.2.5",
         "zod": "4.0.0"
       },
@@ -452,171 +451,121 @@
       "integrity": "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
       }
     },
     "node_modules/@eslint/config-array": {
-      "version": "0.21.2",
-      "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.21.2.tgz",
-      "integrity": "sha512-nJl2KGTlrf9GjLimgIru+V/mzgSK0ABCDQRvxw5BjURL7WfH5uoWmizbH7QB6MmnMBd8cIC9uceWnezL1VZWWw==",
+      "version": "0.23.3",
+      "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.23.3.tgz",
+      "integrity": "sha512-j+eEWmB6YYLwcNOdlwQ6L2OsptI/LO6lNBuLIqe5R7RetD658HLoF+Mn7LzYmAWWNNzdC6cqP+L6r8ujeYXWLw==",
       "dev": true,
       "license": "Apache-2.0",
+      "peer": true,
       "dependencies": {
-        "@eslint/object-schema": "^2.1.7",
+        "@eslint/object-schema": "^3.0.3",
         "debug": "^4.3.1",
-        "minimatch": "^3.1.5"
+        "minimatch": "^10.2.4"
       },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": "^20.19.0 || ^22.13.0 || >=24"
       }
     },
-    "node_modules/@eslint/config-array/node_modules/brace-expansion": {
-      "version": "1.1.12",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
-      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+    "node_modules/@eslint/config-array/node_modules/balanced-match": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",
+      "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
-      }
-    },
-    "node_modules/@eslint/config-array/node_modules/minimatch": {
-      "version": "3.1.5",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
-      "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "brace-expansion": "^1.1.7"
-      },
-      "engines": {
-        "node": "*"
-      }
-    },
-    "node_modules/@eslint/config-helpers": {
-      "version": "0.4.2",
-      "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.4.2.tgz",
-      "integrity": "sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@eslint/core": "^0.17.0"
-      },
+      "peer": true,
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": "18 || 20 || >=22"
       }
     },
-    "node_modules/@eslint/core": {
-      "version": "0.17.0",
-      "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.17.0.tgz",
-      "integrity": "sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==",
+    "node_modules/@eslint/config-array/node_modules/brace-expansion": {
+      "version": "5.0.4",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.4.tgz",
+      "integrity": "sha512-h+DEnpVvxmfVefa4jFbCf5HdH5YMDXRsmKflpf1pILZWRFlTbJpxeU55nJl4Smt5HQaGzg1o6RHFPJaOqnmBDg==",
       "dev": true,
-      "license": "Apache-2.0",
+      "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "@types/json-schema": "^7.0.15"
+        "balanced-match": "^4.0.2"
       },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": "18 || 20 || >=22"
       }
     },
-    "node_modules/@eslint/eslintrc": {
-      "version": "3.3.5",
-      "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.5.tgz",
-      "integrity": "sha512-4IlJx0X0qftVsN5E+/vGujTRIFtwuLbNsVUe7TO6zYPDR1O6nFwvwhIKEKSrl6dZchmYBITazxKoUYOjdtjlRg==",
+    "node_modules/@eslint/config-array/node_modules/minimatch": {
+      "version": "10.2.4",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.4.tgz",
+      "integrity": "sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg==",
       "dev": true,
-      "license": "MIT",
+      "license": "BlueOak-1.0.0",
+      "peer": true,
       "dependencies": {
-        "ajv": "^6.14.0",
-        "debug": "^4.3.2",
-        "espree": "^10.0.1",
-        "globals": "^14.0.0",
-        "ignore": "^5.2.0",
-        "import-fresh": "^3.2.1",
-        "js-yaml": "^4.1.1",
-        "minimatch": "^3.1.5",
-        "strip-json-comments": "^3.1.1"
+        "brace-expansion": "^5.0.2"
       },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": "18 || 20 || >=22"
       },
       "funding": {
-        "url": "https://opencollective.com/eslint"
+        "url": "https://github.com/sponsors/isaacs"
       }
     },
-    "node_modules/@eslint/eslintrc/node_modules/brace-expansion": {
-      "version": "1.1.12",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
-      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+    "node_modules/@eslint/config-helpers": {
+      "version": "0.5.3",
+      "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.5.3.tgz",
+      "integrity": "sha512-lzGN0onllOZCGroKJmRwY6QcEHxbjBw1gwB8SgRSqK8YbbtEXMvKynsXc3553ckIEBxsbMBU7oOZXKIPGZNeZw==",
       "dev": true,
-      "license": "MIT",
+      "license": "Apache-2.0",
+      "peer": true,
       "dependencies": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
-      }
-    },
-    "node_modules/@eslint/eslintrc/node_modules/globals": {
-      "version": "14.0.0",
-      "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz",
-      "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
+        "@eslint/core": "^1.1.1"
       },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+      "engines": {
+        "node": "^20.19.0 || ^22.13.0 || >=24"
       }
     },
-    "node_modules/@eslint/eslintrc/node_modules/minimatch": {
-      "version": "3.1.5",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
-      "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+    "node_modules/@eslint/core": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/@eslint/core/-/core-1.1.1.tgz",
+      "integrity": "sha512-QUPblTtE51/7/Zhfv8BDwO0qkkzQL7P/aWWbqcf4xWLEYn1oKjdO0gglQBB4GAsu7u6wjijbCmzsUTy6mnk6oQ==",
       "dev": true,
-      "license": "ISC",
+      "license": "Apache-2.0",
+      "peer": true,
       "dependencies": {
-        "brace-expansion": "^1.1.7"
+        "@types/json-schema": "^7.0.15"
       },
       "engines": {
-        "node": "*"
-      }
-    },
-    "node_modules/@eslint/js": {
-      "version": "9.39.4",
-      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.39.4.tgz",
-      "integrity": "sha512-nE7DEIchvtiFTwBw4Lfbu59PG+kCofhjsKaCWzxTpt4lfRjRMqG6uMBzKXuEcyXhOHoUp9riAm7/aWYGhXZ9cw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "url": "https://eslint.org/donate"
+        "node": "^20.19.0 || ^22.13.0 || >=24"
       }
     },
     "node_modules/@eslint/object-schema": {
-      "version": "2.1.7",
-      "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.7.tgz",
-      "integrity": "sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==",
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-3.0.3.tgz",
+      "integrity": "sha512-iM869Pugn9Nsxbh/YHRqYiqd23AmIbxJOcpUMOuWCVNdoQJ5ZtwL6h3t0bcZzJUlC3Dq9jCFCESBZnX0GTv7iQ==",
       "dev": true,
       "license": "Apache-2.0",
+      "peer": true,
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": "^20.19.0 || ^22.13.0 || >=24"
       }
     },
     "node_modules/@eslint/plugin-kit": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.4.1.tgz",
-      "integrity": "sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==",
+      "version": "0.6.1",
+      "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.6.1.tgz",
+      "integrity": "sha512-iH1B076HoAshH1mLpHMgwdGeTs0CYwL0SPMkGuSebZrwBp16v415e9NZXg2jtrqPVQjf6IANe2Vtlr5KswtcZQ==",
       "dev": true,
       "license": "Apache-2.0",
+      "peer": true,
       "dependencies": {
-        "@eslint/core": "^0.17.0",
+        "@eslint/core": "^1.1.1",
         "levn": "^0.4.1"
       },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": "^20.19.0 || ^22.13.0 || >=24"
       }
     },
     "node_modules/@gerrit0/mini-shiki": {
@@ -659,44 +608,33 @@
       "integrity": "sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==",
       "dev": true,
       "license": "Apache-2.0",
+      "peer": true,
       "engines": {
         "node": ">=18.18.0"
       }
     },
     "node_modules/@humanfs/node": {
-      "version": "0.16.6",
-      "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.6.tgz",
-      "integrity": "sha512-YuI2ZHQL78Q5HbhDiBA1X4LmYdXCKCMQIfw0pw7piHJwyREFebJUvrQN4cMssyES6x+vfUbx1CIpaQUKYdQZOw==",
+      "version": "0.16.7",
+      "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.7.tgz",
+      "integrity": "sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ==",
       "dev": true,
       "license": "Apache-2.0",
+      "peer": true,
       "dependencies": {
         "@humanfs/core": "^0.19.1",
-        "@humanwhocodes/retry": "^0.3.0"
+        "@humanwhocodes/retry": "^0.4.0"
       },
       "engines": {
         "node": ">=18.18.0"
       }
     },
-    "node_modules/@humanfs/node/node_modules/@humanwhocodes/retry": {
-      "version": "0.3.1",
-      "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.3.1.tgz",
-      "integrity": "sha512-JBxkERygn7Bv/GbN5Rv8Ul6LVknS+5Bp6RgDC/O8gEBU/yeH5Ui5C/OlWrTb6qct7LjjfT6Re2NxB0ln0yYybA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=18.18"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/nzakas"
-      }
-    },
     "node_modules/@humanwhocodes/module-importer": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz",
       "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==",
       "dev": true,
       "license": "Apache-2.0",
+      "peer": true,
       "engines": {
         "node": ">=12.22"
       },
@@ -706,11 +644,12 @@
       }
     },
     "node_modules/@humanwhocodes/retry": {
-      "version": "0.4.2",
-      "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.2.tgz",
-      "integrity": "sha512-xeO57FpIu4p1Ri3Jq/EXq4ClRm86dVF2z/+kvFnyqVYRavTZmaFaUBbWCOuuTh0o/g7DSsk6kc2vrS4Vl5oPOQ==",
+      "version": "0.4.3",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.3.tgz",
+      "integrity": "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==",
       "dev": true,
       "license": "Apache-2.0",
+      "peer": true,
       "engines": {
         "node": ">=18.18"
       },
@@ -760,196 +699,6 @@
       "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
       "license": "MIT"
     },
-    "node_modules/@kitbag/eslint-config": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/@kitbag/eslint-config/-/eslint-config-1.0.2.tgz",
-      "integrity": "sha512-ZZAgXmybXGNtnSRH1Ckr1GEThhIaKeOuXnyQ3Pa4Ot2k4Ca/ZmJrqc8VBSIMAGx/Ade/RjQRZBMXJACS7f5vqg==",
-      "dev": true,
-      "dependencies": {
-        "@stylistic/eslint-plugin": "^2.10.1",
-        "eslint-plugin-vue": "^9.30.0",
-        "typescript-eslint": "^8.13.0"
-      },
-      "peerDependencies": {
-        "eslint": ">= 9"
-      }
-    },
-    "node_modules/@kitbag/eslint-config/node_modules/eslint-plugin-vue": {
-      "version": "9.33.0",
-      "resolved": "https://registry.npmjs.org/eslint-plugin-vue/-/eslint-plugin-vue-9.33.0.tgz",
-      "integrity": "sha512-174lJKuNsuDIlLpjeXc5E2Tss8P44uIimAfGD0b90k0NoirJqpG7stLuU9Vp/9ioTOrQdWVREc4mRd1BD+CvGw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@eslint-community/eslint-utils": "^4.4.0",
-        "globals": "^13.24.0",
-        "natural-compare": "^1.4.0",
-        "nth-check": "^2.1.1",
-        "postcss-selector-parser": "^6.0.15",
-        "semver": "^7.6.3",
-        "vue-eslint-parser": "^9.4.3",
-        "xml-name-validator": "^4.0.0"
-      },
-      "engines": {
-        "node": "^14.17.0 || >=16.0.0"
-      },
-      "peerDependencies": {
-        "eslint": "^6.2.0 || ^7.0.0 || ^8.0.0 || ^9.0.0"
-      }
-    },
-    "node_modules/@kitbag/eslint-config/node_modules/globals": {
-      "version": "13.24.0",
-      "resolved": "https://registry.npmjs.org/globals/-/globals-13.24.0.tgz",
-      "integrity": "sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "type-fest": "^0.20.2"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/@kitbag/eslint-config/node_modules/ignore": {
-      "version": "7.0.5",
-      "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.5.tgz",
-      "integrity": "sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 4"
-      }
-    },
-    "node_modules/@kitbag/eslint-config/node_modules/typescript-eslint": {
-      "version": "8.54.0",
-      "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.54.0.tgz",
-      "integrity": "sha512-CKsJ+g53QpsNPqbzUsfKVgd3Lny4yKZ1pP4qN3jdMOg/sisIDLGyDMezycquXLE5JsEU0wp3dGNdzig0/fmSVQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@typescript-eslint/eslint-plugin": "8.54.0",
-        "@typescript-eslint/parser": "8.54.0",
-        "@typescript-eslint/typescript-estree": "8.54.0",
-        "@typescript-eslint/utils": "8.54.0"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "eslint": "^8.57.0 || ^9.0.0",
-        "typescript": ">=4.8.4 <6.0.0"
-      }
-    },
-    "node_modules/@kitbag/eslint-config/node_modules/typescript-eslint/node_modules/@typescript-eslint/eslint-plugin": {
-      "version": "8.54.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.54.0.tgz",
-      "integrity": "sha512-hAAP5io/7csFStuOmR782YmTthKBJ9ND3WVL60hcOjvtGFb+HJxH4O5huAcmcZ9v9G8P+JETiZ/G1B8MALnWZQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@eslint-community/regexpp": "^4.12.2",
-        "@typescript-eslint/scope-manager": "8.54.0",
-        "@typescript-eslint/type-utils": "8.54.0",
-        "@typescript-eslint/utils": "8.54.0",
-        "@typescript-eslint/visitor-keys": "8.54.0",
-        "ignore": "^7.0.5",
-        "natural-compare": "^1.4.0",
-        "ts-api-utils": "^2.4.0"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "@typescript-eslint/parser": "^8.54.0",
-        "eslint": "^8.57.0 || ^9.0.0",
-        "typescript": ">=4.8.4 <6.0.0"
-      }
-    },
-    "node_modules/@kitbag/eslint-config/node_modules/typescript-eslint/node_modules/@typescript-eslint/eslint-plugin/node_modules/@typescript-eslint/type-utils": {
-      "version": "8.54.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.54.0.tgz",
-      "integrity": "sha512-hiLguxJWHjjwL6xMBwD903ciAwd7DmK30Y9Axs/etOkftC3ZNN9K44IuRD/EB08amu+Zw6W37x9RecLkOo3pMA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@typescript-eslint/types": "8.54.0",
-        "@typescript-eslint/typescript-estree": "8.54.0",
-        "@typescript-eslint/utils": "8.54.0",
-        "debug": "^4.4.3",
-        "ts-api-utils": "^2.4.0"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "eslint": "^8.57.0 || ^9.0.0",
-        "typescript": ">=4.8.4 <6.0.0"
-      }
-    },
-    "node_modules/@kitbag/eslint-config/node_modules/typescript-eslint/node_modules/@typescript-eslint/parser": {
-      "version": "8.54.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.54.0.tgz",
-      "integrity": "sha512-BtE0k6cjwjLZoZixN0t5AKP0kSzlGu7FctRXYuPAm//aaiZhmfq1JwdYpYr1brzEspYyFeF+8XF5j2VK6oalrA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@typescript-eslint/scope-manager": "8.54.0",
-        "@typescript-eslint/types": "8.54.0",
-        "@typescript-eslint/typescript-estree": "8.54.0",
-        "@typescript-eslint/visitor-keys": "8.54.0",
-        "debug": "^4.4.3"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "eslint": "^8.57.0 || ^9.0.0",
-        "typescript": ">=4.8.4 <6.0.0"
-      }
-    },
-    "node_modules/@kitbag/eslint-config/node_modules/typescript-eslint/node_modules/@typescript-eslint/utils": {
-      "version": "8.54.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.54.0.tgz",
-      "integrity": "sha512-9Cnda8GS57AQakvRyG0PTejJNlA2xhvyNtEVIMlDWOOeEyBkYWhGPnfrIAnqxLMTSTo6q8g12XVjjev5l1NvMA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@eslint-community/eslint-utils": "^4.9.1",
-        "@typescript-eslint/scope-manager": "8.54.0",
-        "@typescript-eslint/types": "8.54.0",
-        "@typescript-eslint/typescript-estree": "8.54.0"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "eslint": "^8.57.0 || ^9.0.0",
-        "typescript": ">=4.8.4 <6.0.0"
-      }
-    },
     "node_modules/@microsoft/api-extractor": {
       "version": "7.51.1",
       "resolved": "https://registry.npmjs.org/@microsoft/api-extractor/-/api-extractor-7.51.1.tgz",
@@ -1142,21 +891,27 @@
         "url": "https://github.com/sponsors/Boshen"
       }
     },
-    "node_modules/@pkgjs/parseargs": {
-      "version": "0.11.0",
-      "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz",
-      "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==",
+    "node_modules/@oxfmt/binding-android-arm-eabi": {
+      "version": "0.41.0",
+      "resolved": "https://registry.npmjs.org/@oxfmt/binding-android-arm-eabi/-/binding-android-arm-eabi-0.41.0.tgz",
+      "integrity": "sha512-REfrqeMKGkfMP+m/ScX4f5jJBSmVNYcpoDF8vP8f8eYPDuPGZmzp56NIUsYmx3h7f6NzC6cE3gqh8GDWrJHCKw==",
+      "cpu": [
+        "arm"
+      ],
       "dev": true,
       "license": "MIT",
       "optional": true,
+      "os": [
+        "android"
+      ],
       "engines": {
-        "node": ">=14"
+        "node": "^20.19.0 || >=22.12.0"
       }
     },
-    "node_modules/@rolldown/binding-android-arm64": {
-      "version": "1.0.0-rc.9",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm64/-/binding-android-arm64-1.0.0-rc.9.tgz",
-      "integrity": "sha512-lcJL0bN5hpgJfSIz/8PIf02irmyL43P+j1pTCfbD1DbLkmGRuFIA4DD3B3ZOvGqG0XiVvRznbKtN0COQVaKUTg==",
+    "node_modules/@oxfmt/binding-android-arm64": {
+      "version": "0.41.0",
+      "resolved": "https://registry.npmjs.org/@oxfmt/binding-android-arm64/-/binding-android-arm64-0.41.0.tgz",
+      "integrity": "sha512-s0b1dxNgb2KomspFV2LfogC2XtSJB42POXF4bMCLJyvQmAGos4ZtjGPfQreToQEaY0FQFjz3030ggI36rF1q5g==",
       "cpu": [
         "arm64"
       ],
@@ -1170,10 +925,10 @@
         "node": "^20.19.0 || >=22.12.0"
       }
     },
-    "node_modules/@rolldown/binding-darwin-arm64": {
-      "version": "1.0.0-rc.9",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-arm64/-/binding-darwin-arm64-1.0.0-rc.9.tgz",
-      "integrity": "sha512-J7Zk3kLYFsLtuH6U+F4pS2sYVzac0qkjcO5QxHS7OS7yZu2LRs+IXo+uvJ/mvpyUljDJ3LROZPoQfgBIpCMhdQ==",
+    "node_modules/@oxfmt/binding-darwin-arm64": {
+      "version": "0.41.0",
+      "resolved": "https://registry.npmjs.org/@oxfmt/binding-darwin-arm64/-/binding-darwin-arm64-0.41.0.tgz",
+      "integrity": "sha512-EGXGualADbv/ZmamE7/2DbsrYmjoPlAmHEpTL4vapLF4EfVD6fr8/uQDFnPJkUBjiSWFJZtFNsGeN1B6V3owmA==",
       "cpu": [
         "arm64"
       ],
@@ -1187,10 +942,10 @@
         "node": "^20.19.0 || >=22.12.0"
       }
     },
-    "node_modules/@rolldown/binding-darwin-x64": {
-      "version": "1.0.0-rc.9",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-x64/-/binding-darwin-x64-1.0.0-rc.9.tgz",
-      "integrity": "sha512-iwtmmghy8nhfRGeNAIltcNXzD0QMNaaA5U/NyZc1Ia4bxrzFByNMDoppoC+hl7cDiUq5/1CnFthpT9n+UtfFyg==",
+    "node_modules/@oxfmt/binding-darwin-x64": {
+      "version": "0.41.0",
+      "resolved": "https://registry.npmjs.org/@oxfmt/binding-darwin-x64/-/binding-darwin-x64-0.41.0.tgz",
+      "integrity": "sha512-WxySJEvdQQYMmyvISH3qDpTvoS0ebnIP63IMxLLWowJyPp/AAH0hdWtlo+iGNK5y3eVfa5jZguwNaQkDKWpGSw==",
       "cpu": [
         "x64"
       ],
@@ -1204,10 +959,10 @@
         "node": "^20.19.0 || >=22.12.0"
       }
     },
-    "node_modules/@rolldown/binding-freebsd-x64": {
-      "version": "1.0.0-rc.9",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-freebsd-x64/-/binding-freebsd-x64-1.0.0-rc.9.tgz",
-      "integrity": "sha512-DLFYI78SCiZr5VvdEplsVC2Vx53lnA4/Ga5C65iyldMVaErr86aiqCoNBLl92PXPfDtUYjUh+xFFor40ueNs4Q==",
+    "node_modules/@oxfmt/binding-freebsd-x64": {
+      "version": "0.41.0",
+      "resolved": "https://registry.npmjs.org/@oxfmt/binding-freebsd-x64/-/binding-freebsd-x64-0.41.0.tgz",
+      "integrity": "sha512-Y2kzMkv3U3oyuYaR4wTfGjOTYTXiFC/hXmG0yVASKkbh02BJkvD98Ij8bIevr45hNZ0DmZEgqiXF+9buD4yMYQ==",
       "cpu": [
         "x64"
       ],
@@ -1221,10 +976,10 @@
         "node": "^20.19.0 || >=22.12.0"
       }
     },
-    "node_modules/@rolldown/binding-linux-arm-gnueabihf": {
-      "version": "1.0.0-rc.9",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.0.0-rc.9.tgz",
-      "integrity": "sha512-CsjTmTwd0Hri6iTw/DRMK7kOZ7FwAkrO4h8YWKoX/kcj833e4coqo2wzIFywtch/8Eb5enQ/lwLM7w6JX1W5RQ==",
+    "node_modules/@oxfmt/binding-linux-arm-gnueabihf": {
+      "version": "0.41.0",
+      "resolved": "https://registry.npmjs.org/@oxfmt/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-0.41.0.tgz",
+      "integrity": "sha512-ptazDjdUyhket01IjPTT6ULS1KFuBfTUU97osTP96X5y/0oso+AgAaJzuH81oP0+XXyrWIHbRzozSAuQm4p48g==",
       "cpu": [
         "arm"
       ],
@@ -1238,12 +993,12 @@
         "node": "^20.19.0 || >=22.12.0"
       }
     },
-    "node_modules/@rolldown/binding-linux-arm64-gnu": {
-      "version": "1.0.0-rc.9",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.0.0-rc.9.tgz",
-      "integrity": "sha512-2x9O2JbSPxpxMDhP9Z74mahAStibTlrBMW0520+epJH5sac7/LwZW5Bmg/E6CXuEF53JJFW509uP+lSedaUNxg==",
+    "node_modules/@oxfmt/binding-linux-arm-musleabihf": {
+      "version": "0.41.0",
+      "resolved": "https://registry.npmjs.org/@oxfmt/binding-linux-arm-musleabihf/-/binding-linux-arm-musleabihf-0.41.0.tgz",
+      "integrity": "sha512-UkoL2OKxFD+56bPEBcdGn+4juTW4HRv/T6w1dIDLnvKKWr6DbarB/mtHXlADKlFiJubJz8pRkttOR7qjYR6lTA==",
       "cpu": [
-        "arm64"
+        "arm"
       ],
       "dev": true,
       "license": "MIT",
@@ -1255,10 +1010,10 @@
         "node": "^20.19.0 || >=22.12.0"
       }
     },
-    "node_modules/@rolldown/binding-linux-arm64-musl": {
-      "version": "1.0.0-rc.9",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.0.0-rc.9.tgz",
-      "integrity": "sha512-JA1QRW31ogheAIRhIg9tjMfsYbglXXYGNPLdPEYrwFxdbkQCAzvpSCSHCDWNl4hTtrol8WeboCSEpjdZK8qrCg==",
+    "node_modules/@oxfmt/binding-linux-arm64-gnu": {
+      "version": "0.41.0",
+      "resolved": "https://registry.npmjs.org/@oxfmt/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-0.41.0.tgz",
+      "integrity": "sha512-gofu0PuumSOHYczD8p62CPY4UF6ee+rSLZJdUXkpwxg6pILiwSDBIouPskjF/5nF3A7QZTz2O9KFNkNxxFN9tA==",
       "cpu": [
         "arm64"
       ],
@@ -1272,12 +1027,12 @@
         "node": "^20.19.0 || >=22.12.0"
       }
     },
-    "node_modules/@rolldown/binding-linux-ppc64-gnu": {
-      "version": "1.0.0-rc.9",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-1.0.0-rc.9.tgz",
-      "integrity": "sha512-aOKU9dJheda8Kj8Y3w9gnt9QFOO+qKPAl8SWd7JPHP+Cu0EuDAE5wokQubLzIDQWg2myXq2XhTpOVS07qqvT+w==",
+    "node_modules/@oxfmt/binding-linux-arm64-musl": {
+      "version": "0.41.0",
+      "resolved": "https://registry.npmjs.org/@oxfmt/binding-linux-arm64-musl/-/binding-linux-arm64-musl-0.41.0.tgz",
+      "integrity": "sha512-VfVZxL0+6RU86T8F8vKiDBa+iHsr8PAjQmKGBzSCAX70b6x+UOMFl+2dNihmKmUwqkCazCPfYjt6SuAPOeQJ3g==",
       "cpu": [
-        "ppc64"
+        "arm64"
       ],
       "dev": true,
       "license": "MIT",
@@ -1289,12 +1044,12 @@
         "node": "^20.19.0 || >=22.12.0"
       }
     },
-    "node_modules/@rolldown/binding-linux-s390x-gnu": {
-      "version": "1.0.0-rc.9",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-1.0.0-rc.9.tgz",
-      "integrity": "sha512-OalO94fqj7IWRn3VdXWty75jC5dk4C197AWEuMhIpvVv2lw9fiPhud0+bW2ctCxb3YoBZor71QHbY+9/WToadA==",
+    "node_modules/@oxfmt/binding-linux-ppc64-gnu": {
+      "version": "0.41.0",
+      "resolved": "https://registry.npmjs.org/@oxfmt/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-0.41.0.tgz",
+      "integrity": "sha512-bwzokz2eGvdfJbc0i+zXMJ4BBjQPqg13jyWpEEZDOrBCQ91r8KeY2Mi2kUeuMTZNFXju+jcAbAbpyJxRGla0eg==",
       "cpu": [
-        "s390x"
+        "ppc64"
       ],
       "dev": true,
       "license": "MIT",
@@ -1306,12 +1061,12 @@
         "node": "^20.19.0 || >=22.12.0"
       }
     },
-    "node_modules/@rolldown/binding-linux-x64-gnu": {
-      "version": "1.0.0-rc.9",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.0.0-rc.9.tgz",
-      "integrity": "sha512-cVEl1vZtBsBZna3YMjGXNvnYYrOJ7RzuWvZU0ffvJUexWkukMaDuGhUXn0rjnV0ptzGVkvc+vW9Yqy6h8YX4pg==",
+    "node_modules/@oxfmt/binding-linux-riscv64-gnu": {
+      "version": "0.41.0",
+      "resolved": "https://registry.npmjs.org/@oxfmt/binding-linux-riscv64-gnu/-/binding-linux-riscv64-gnu-0.41.0.tgz",
+      "integrity": "sha512-POLM//PCH9uqDeNDwWL3b3DkMmI3oI2cU6hwc2lnztD1o7dzrQs3R9nq555BZ6wI7t2lyhT9CS+CRaz5X0XqLA==",
       "cpu": [
-        "x64"
+        "riscv64"
       ],
       "dev": true,
       "license": "MIT",
@@ -1323,12 +1078,12 @@
         "node": "^20.19.0 || >=22.12.0"
       }
     },
-    "node_modules/@rolldown/binding-linux-x64-musl": {
-      "version": "1.0.0-rc.9",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.0.0-rc.9.tgz",
-      "integrity": "sha512-UzYnKCIIc4heAKgI4PZ3dfBGUZefGCJ1TPDuLHoCzgrMYPb5Rv6TLFuYtyM4rWyHM7hymNdsg5ik2C+UD9VDbA==",
+    "node_modules/@oxfmt/binding-linux-riscv64-musl": {
+      "version": "0.41.0",
+      "resolved": "https://registry.npmjs.org/@oxfmt/binding-linux-riscv64-musl/-/binding-linux-riscv64-musl-0.41.0.tgz",
+      "integrity": "sha512-NNK7PzhFqLUwx/G12Xtm6scGv7UITvyGdAR5Y+TlqsG+essnuRWR4jRNODWRjzLZod0T3SayRbnkSIWMBov33w==",
       "cpu": [
-        "x64"
+        "riscv64"
       ],
       "dev": true,
       "license": "MIT",
@@ -1340,136 +1095,129 @@
         "node": "^20.19.0 || >=22.12.0"
       }
     },
-    "node_modules/@rolldown/binding-openharmony-arm64": {
-      "version": "1.0.0-rc.9",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-openharmony-arm64/-/binding-openharmony-arm64-1.0.0-rc.9.tgz",
-      "integrity": "sha512-+6zoiF+RRyf5cdlFQP7nm58mq7+/2PFaY2DNQeD4B87N36JzfF/l9mdBkkmTvSYcYPE8tMh/o3cRlsx1ldLfog==",
+    "node_modules/@oxfmt/binding-linux-s390x-gnu": {
+      "version": "0.41.0",
+      "resolved": "https://registry.npmjs.org/@oxfmt/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-0.41.0.tgz",
+      "integrity": "sha512-qVf/zDC5cN9eKe4qI/O/m445er1IRl6swsSl7jHkqmOSVfknwCe5JXitYjZca+V/cNJSU/xPlC5EFMabMMFDpw==",
       "cpu": [
-        "arm64"
+        "s390x"
       ],
       "dev": true,
       "license": "MIT",
       "optional": true,
       "os": [
-        "openharmony"
+        "linux"
       ],
       "engines": {
         "node": "^20.19.0 || >=22.12.0"
       }
     },
-    "node_modules/@rolldown/binding-wasm32-wasi": {
-      "version": "1.0.0-rc.9",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-wasm32-wasi/-/binding-wasm32-wasi-1.0.0-rc.9.tgz",
-      "integrity": "sha512-rgFN6sA/dyebil3YTlL2evvi/M+ivhfnyxec7AccTpRPccno/rPoNlqybEZQBkcbZu8Hy+eqNJCqfBR8P7Pg8g==",
+    "node_modules/@oxfmt/binding-linux-x64-gnu": {
+      "version": "0.41.0",
+      "resolved": "https://registry.npmjs.org/@oxfmt/binding-linux-x64-gnu/-/binding-linux-x64-gnu-0.41.0.tgz",
+      "integrity": "sha512-ojxYWu7vUb6ysYqVCPHuAPVZHAI40gfZ0PDtZAMwVmh2f0V8ExpPIKoAKr7/8sNbAXJBBpZhs2coypIo2jJX4w==",
       "cpu": [
-        "wasm32"
+        "x64"
       ],
       "dev": true,
       "license": "MIT",
       "optional": true,
-      "dependencies": {
-        "@napi-rs/wasm-runtime": "^1.1.1"
-      },
+      "os": [
+        "linux"
+      ],
       "engines": {
-        "node": ">=14.0.0"
+        "node": "^20.19.0 || >=22.12.0"
       }
     },
-    "node_modules/@rolldown/binding-win32-arm64-msvc": {
-      "version": "1.0.0-rc.9",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.0.0-rc.9.tgz",
-      "integrity": "sha512-lHVNUG/8nlF1IQk1C0Ci574qKYyty2goMiPlRqkC5R+3LkXDkL5Dhx8ytbxq35m+pkHVIvIxviD+TWLdfeuadA==",
+    "node_modules/@oxfmt/binding-linux-x64-musl": {
+      "version": "0.41.0",
+      "resolved": "https://registry.npmjs.org/@oxfmt/binding-linux-x64-musl/-/binding-linux-x64-musl-0.41.0.tgz",
+      "integrity": "sha512-O2exZLBxoCMIv2vlvcbkdedazJPTdG0VSup+0QUCfYQtx751zCZNboX2ZUOiQ/gDTdhtXvSiot0h6GEGkOyalA==",
       "cpu": [
-        "arm64"
+        "x64"
       ],
       "dev": true,
       "license": "MIT",
       "optional": true,
       "os": [
-        "win32"
+        "linux"
       ],
       "engines": {
         "node": "^20.19.0 || >=22.12.0"
       }
     },
-    "node_modules/@rolldown/binding-win32-x64-msvc": {
-      "version": "1.0.0-rc.9",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.0.0-rc.9.tgz",
-      "integrity": "sha512-G0oA4+w1iY5AGi5HcDTxWsoxF509hrFIPB2rduV5aDqS9FtDg1CAfa7V34qImbjfhIcA8C+RekocJZA96EarwQ==",
+    "node_modules/@oxfmt/binding-openharmony-arm64": {
+      "version": "0.41.0",
+      "resolved": "https://registry.npmjs.org/@oxfmt/binding-openharmony-arm64/-/binding-openharmony-arm64-0.41.0.tgz",
+      "integrity": "sha512-N+31/VoL+z+NNBt8viy3I4NaIdPbiYeOnB884LKqvXldaE2dRztdPv3q5ipfZYv0RwFp7JfqS4I27K/DSHCakg==",
       "cpu": [
-        "x64"
+        "arm64"
       ],
       "dev": true,
       "license": "MIT",
       "optional": true,
       "os": [
-        "win32"
+        "openharmony"
       ],
       "engines": {
         "node": "^20.19.0 || >=22.12.0"
       }
     },
-    "node_modules/@rolldown/pluginutils": {
-      "version": "1.0.0-rc.2",
-      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-rc.2.tgz",
-      "integrity": "sha512-izyXV/v+cHiRfozX62W9htOAvwMo4/bXKDrQ+vom1L1qRuexPock/7VZDAhnpHCLNejd3NJ6hiab+tO0D44Rgw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@rollup/pluginutils": {
-      "version": "5.1.4",
-      "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-5.1.4.tgz",
-      "integrity": "sha512-USm05zrsFxYLPdWWq+K3STlWiT/3ELn3RcV5hJMghpeAIhxfsUIg6mt12CBJBInWMV4VneoV7SfGv8xIwo2qNQ==",
+    "node_modules/@oxfmt/binding-win32-arm64-msvc": {
+      "version": "0.41.0",
+      "resolved": "https://registry.npmjs.org/@oxfmt/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-0.41.0.tgz",
+      "integrity": "sha512-Z7NAtu/RN8kjCQ1y5oDD0nTAeRswh3GJ93qwcW51srmidP7XPBmZbLlwERu1W5veCevQJtPS9xmkpcDTYsGIwQ==",
+      "cpu": [
+        "arm64"
+      ],
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "@types/estree": "^1.0.0",
-        "estree-walker": "^2.0.2",
-        "picomatch": "^4.0.2"
-      },
+      "optional": true,
+      "os": [
+        "win32"
+      ],
       "engines": {
-        "node": ">=14.0.0"
-      },
-      "peerDependencies": {
-        "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0"
-      },
-      "peerDependenciesMeta": {
-        "rollup": {
-          "optional": true
-        }
+        "node": "^20.19.0 || >=22.12.0"
       }
     },
-    "node_modules/@rollup/rollup-android-arm-eabi": {
-      "version": "4.50.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.50.0.tgz",
-      "integrity": "sha512-lVgpeQyy4fWN5QYebtW4buT/4kn4p4IJ+kDNB4uYNT5b8c8DLJDg6titg20NIg7E8RWwdWZORW6vUFfrLyG3KQ==",
+    "node_modules/@oxfmt/binding-win32-ia32-msvc": {
+      "version": "0.41.0",
+      "resolved": "https://registry.npmjs.org/@oxfmt/binding-win32-ia32-msvc/-/binding-win32-ia32-msvc-0.41.0.tgz",
+      "integrity": "sha512-uNxxP3l4bJ6VyzIeRqCmBU2Q0SkCFgIhvx9/9dJ9V8t/v+jP1IBsuaLwCXGR8JPHtkj4tFp+RHtUmU2ZYAUpMA==",
       "cpu": [
-        "arm"
+        "ia32"
       ],
       "dev": true,
       "license": "MIT",
       "optional": true,
       "os": [
-        "android"
-      ]
+        "win32"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-android-arm64": {
-      "version": "4.50.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.50.0.tgz",
-      "integrity": "sha512-2O73dR4Dc9bp+wSYhviP6sDziurB5/HCym7xILKifWdE9UsOe2FtNcM+I4xZjKrfLJnq5UR8k9riB87gauiQtw==",
+    "node_modules/@oxfmt/binding-win32-x64-msvc": {
+      "version": "0.41.0",
+      "resolved": "https://registry.npmjs.org/@oxfmt/binding-win32-x64-msvc/-/binding-win32-x64-msvc-0.41.0.tgz",
+      "integrity": "sha512-49ZSpbZ1noozyPapE8SUOSm3IN0Ze4b5nkO+4+7fq6oEYQQJFhE0saj5k/Gg4oewVPdjn0L3ZFeWk2Vehjcw7A==",
       "cpu": [
-        "arm64"
+        "x64"
       ],
       "dev": true,
       "license": "MIT",
       "optional": true,
       "os": [
-        "android"
-      ]
+        "win32"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-darwin-arm64": {
-      "version": "4.50.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.50.0.tgz",
-      "integrity": "sha512-vwSXQN8T4sKf1RHr1F0s98Pf8UPz7pS6P3LG9NSmuw0TVh7EmaE+5Ny7hJOZ0M2yuTctEsHHRTMi2wuHkdS6Hg==",
+    "node_modules/@oxlint-tsgolint/darwin-arm64": {
+      "version": "0.17.1",
+      "resolved": "https://registry.npmjs.org/@oxlint-tsgolint/darwin-arm64/-/darwin-arm64-0.17.1.tgz",
+      "integrity": "sha512-JNWNwyvSDcUQSBlQRl10XrCeNcN66TMvDw3gIDQeop5SNa1F7wFhsEx4zitYb7fGHwGh9095tsNttmuCaNXCbw==",
       "cpu": [
         "arm64"
       ],
@@ -1480,10 +1228,10 @@
         "darwin"
       ]
     },
-    "node_modules/@rollup/rollup-darwin-x64": {
-      "version": "4.50.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.50.0.tgz",
-      "integrity": "sha512-cQp/WG8HE7BCGyFVuzUg0FNmupxC+EPZEwWu2FCGGw5WDT1o2/YlENbm5e9SMvfDFR6FRhVCBePLqj0o8MN7Vw==",
+    "node_modules/@oxlint-tsgolint/darwin-x64": {
+      "version": "0.17.1",
+      "resolved": "https://registry.npmjs.org/@oxlint-tsgolint/darwin-x64/-/darwin-x64-0.17.1.tgz",
+      "integrity": "sha512-SluNf6CW88pgGPqQUGC5GoK5qESWo2ct1PRDbza3vbf9SK2npx3igvylGQIgE9qYYOcjgnVdLOJ0+q0gItgUmQ==",
       "cpu": [
         "x64"
       ],
@@ -1494,10 +1242,10 @@
         "darwin"
       ]
     },
-    "node_modules/@rollup/rollup-freebsd-arm64": {
-      "version": "4.50.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.50.0.tgz",
-      "integrity": "sha512-UR1uTJFU/p801DvvBbtDD7z9mQL8J80xB0bR7DqW7UGQHRm/OaKzp4is7sQSdbt2pjjSS72eAtRh43hNduTnnQ==",
+    "node_modules/@oxlint-tsgolint/linux-arm64": {
+      "version": "0.17.1",
+      "resolved": "https://registry.npmjs.org/@oxlint-tsgolint/linux-arm64/-/linux-arm64-0.17.1.tgz",
+      "integrity": "sha512-BJxQ7/cdo2dNdGIBs2PIR6BaPA7cPfe+r1HE/uY+K7g2ygip+0LHB3GUO9GaNDZuWpsnDyjLYYowEGrVK8dokA==",
       "cpu": [
         "arm64"
       ],
@@ -1505,13 +1253,13 @@
       "license": "MIT",
       "optional": true,
       "os": [
-        "freebsd"
+        "linux"
       ]
     },
-    "node_modules/@rollup/rollup-freebsd-x64": {
-      "version": "4.50.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.50.0.tgz",
-      "integrity": "sha512-G/DKyS6PK0dD0+VEzH/6n/hWDNPDZSMBmqsElWnCRGrYOb2jC0VSupp7UAHHQ4+QILwkxSMaYIbQ72dktp8pKA==",
+    "node_modules/@oxlint-tsgolint/linux-x64": {
+      "version": "0.17.1",
+      "resolved": "https://registry.npmjs.org/@oxlint-tsgolint/linux-x64/-/linux-x64-0.17.1.tgz",
+      "integrity": "sha512-s6UjmuaJbZ4zz/wJKdEw/s5mc0t41rgwxQJCSHPuzMumMK6ylrB7nydhDf8ObTtzhTIZdAS/2S/uayJmDcGbxw==",
       "cpu": [
         "x64"
       ],
@@ -1519,55 +1267,58 @@
       "license": "MIT",
       "optional": true,
       "os": [
-        "freebsd"
+        "linux"
       ]
     },
-    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
-      "version": "4.50.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.50.0.tgz",
-      "integrity": "sha512-u72Mzc6jyJwKjJbZZcIYmd9bumJu7KNmHYdue43vT1rXPm2rITwmPWF0mmPzLm9/vJWxIRbao/jrQmxTO0Sm9w==",
+    "node_modules/@oxlint-tsgolint/win32-arm64": {
+      "version": "0.17.1",
+      "resolved": "https://registry.npmjs.org/@oxlint-tsgolint/win32-arm64/-/win32-arm64-0.17.1.tgz",
+      "integrity": "sha512-EO/Oj0ixHX+UQdu9hM7YUzibZI888MvPUo/DF8lSxFBt4JNEt8qGkwJEbCYjB/1LhUNmPHzSw2Tr9dCFVfW9nw==",
       "cpu": [
-        "arm"
+        "arm64"
       ],
       "dev": true,
       "license": "MIT",
       "optional": true,
       "os": [
-        "linux"
+        "win32"
       ]
     },
-    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
-      "version": "4.50.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.50.0.tgz",
-      "integrity": "sha512-S4UefYdV0tnynDJV1mdkNawp0E5Qm2MtSs330IyHgaccOFrwqsvgigUD29uT+B/70PDY1eQ3t40+xf6wIvXJyg==",
+    "node_modules/@oxlint-tsgolint/win32-x64": {
+      "version": "0.17.1",
+      "resolved": "https://registry.npmjs.org/@oxlint-tsgolint/win32-x64/-/win32-x64-0.17.1.tgz",
+      "integrity": "sha512-jhv7XktAJ1sMRSb//yDYTauFSZ06H81i2SLEBPaSUKxSKoPMK8p1ACUJlnmwZX2MgapRLEj1Ml22B6+HiM2YIA==",
       "cpu": [
-        "arm"
+        "x64"
       ],
       "dev": true,
       "license": "MIT",
       "optional": true,
       "os": [
-        "linux"
+        "win32"
       ]
     },
-    "node_modules/@rollup/rollup-linux-arm64-gnu": {
-      "version": "4.50.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.50.0.tgz",
-      "integrity": "sha512-1EhkSvUQXJsIhk4msxP5nNAUWoB4MFDHhtc4gAYvnqoHlaL9V3F37pNHabndawsfy/Tp7BPiy/aSa6XBYbaD1g==",
+    "node_modules/@oxlint/binding-android-arm-eabi": {
+      "version": "1.56.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-android-arm-eabi/-/binding-android-arm-eabi-1.56.0.tgz",
+      "integrity": "sha512-IyfYPthZyiSKwAv/dLjeO18SaK8MxLI9Yss2JrRDyweQAkuL3LhEy7pwIwI7uA3KQc1Vdn20kdmj3q0oUIQL6A==",
       "cpu": [
-        "arm64"
+        "arm"
       ],
       "dev": true,
       "license": "MIT",
       "optional": true,
       "os": [
-        "linux"
-      ]
+        "android"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-linux-arm64-musl": {
-      "version": "4.50.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.50.0.tgz",
-      "integrity": "sha512-EtBDIZuDtVg75xIPIK1l5vCXNNCIRM0OBPUG+tbApDuJAy9mKago6QxX+tfMzbCI6tXEhMuZuN1+CU8iDW+0UQ==",
+    "node_modules/@oxlint/binding-android-arm64": {
+      "version": "1.56.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-android-arm64/-/binding-android-arm64-1.56.0.tgz",
+      "integrity": "sha512-Ga5zYrzH6vc/VFxhn6MmyUnYEfy9vRpwTIks99mY3j6Nz30yYpIkWryI0QKPCgvGUtDSXVLEaMum5nA+WrNOSg==",
       "cpu": [
         "arm64"
       ],
@@ -1575,120 +1326,855 @@
       "license": "MIT",
       "optional": true,
       "os": [
-        "linux"
-      ]
+        "android"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-linux-loongarch64-gnu": {
-      "version": "4.50.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loongarch64-gnu/-/rollup-linux-loongarch64-gnu-4.50.0.tgz",
-      "integrity": "sha512-BGYSwJdMP0hT5CCmljuSNx7+k+0upweM2M4YGfFBjnFSZMHOLYR0gEEj/dxyYJ6Zc6AiSeaBY8dWOa11GF/ppQ==",
+    "node_modules/@oxlint/binding-darwin-arm64": {
+      "version": "1.56.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-darwin-arm64/-/binding-darwin-arm64-1.56.0.tgz",
+      "integrity": "sha512-ogmbdJysnw/D4bDcpf1sPLpFThZ48lYp4aKYm10Z/6Nh1SON6NtnNhTNOlhEY296tDFItsZUz+2tgcSYqh8Eyw==",
       "cpu": [
-        "loong64"
+        "arm64"
       ],
       "dev": true,
       "license": "MIT",
       "optional": true,
       "os": [
-        "linux"
-      ]
+        "darwin"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
-      "version": "4.50.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.50.0.tgz",
-      "integrity": "sha512-I1gSMzkVe1KzAxKAroCJL30hA4DqSi+wGc5gviD0y3IL/VkvcnAqwBf4RHXHyvH66YVHxpKO8ojrgc4SrWAnLg==",
+    "node_modules/@oxlint/binding-darwin-x64": {
+      "version": "1.56.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-darwin-x64/-/binding-darwin-x64-1.56.0.tgz",
+      "integrity": "sha512-x8QE1h+RAtQ2g+3KPsP6Fk/tdz6zJQUv5c7fTrJxXV3GHOo+Ry5p/PsogU4U+iUZg0rj6hS+E4xi+mnwwlDCWQ==",
       "cpu": [
-        "ppc64"
+        "x64"
       ],
       "dev": true,
       "license": "MIT",
       "optional": true,
       "os": [
-        "linux"
-      ]
+        "darwin"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
-      "version": "4.50.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.50.0.tgz",
-      "integrity": "sha512-bSbWlY3jZo7molh4tc5dKfeSxkqnf48UsLqYbUhnkdnfgZjgufLS/NTA8PcP/dnvct5CCdNkABJ56CbclMRYCA==",
+    "node_modules/@oxlint/binding-freebsd-x64": {
+      "version": "1.56.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-freebsd-x64/-/binding-freebsd-x64-1.56.0.tgz",
+      "integrity": "sha512-6G+WMZvwJpMvY7my+/SHEjb7BTk/PFbePqLpmVmUJRIsJMy/UlyYqjpuh0RCgYYkPLcnXm1rUM04kbTk8yS1Yg==",
       "cpu": [
-        "riscv64"
+        "x64"
       ],
       "dev": true,
       "license": "MIT",
       "optional": true,
       "os": [
-        "linux"
-      ]
+        "freebsd"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-linux-riscv64-musl": {
-      "version": "4.50.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.50.0.tgz",
-      "integrity": "sha512-LSXSGumSURzEQLT2e4sFqFOv3LWZsEF8FK7AAv9zHZNDdMnUPYH3t8ZlaeYYZyTXnsob3htwTKeWtBIkPV27iQ==",
+    "node_modules/@oxlint/binding-linux-arm-gnueabihf": {
+      "version": "1.56.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.56.0.tgz",
+      "integrity": "sha512-YYHBsk/sl7fYwQOok+6W5lBPeUEvisznV/HZD2IfZmF3Bns6cPC3Z0vCtSEOaAWTjYWN3jVsdu55jMxKlsdlhg==",
       "cpu": [
-        "riscv64"
+        "arm"
       ],
       "dev": true,
       "license": "MIT",
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-linux-s390x-gnu": {
-      "version": "4.50.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.50.0.tgz",
-      "integrity": "sha512-CxRKyakfDrsLXiCyucVfVWVoaPA4oFSpPpDwlMcDFQvrv3XY6KEzMtMZrA+e/goC8xxp2WSOxHQubP8fPmmjOQ==",
+    "node_modules/@oxlint/binding-linux-arm-musleabihf": {
+      "version": "1.56.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-linux-arm-musleabihf/-/binding-linux-arm-musleabihf-1.56.0.tgz",
+      "integrity": "sha512-+AZK8rOUr78y8WT6XkDb04IbMRqauNV+vgT6f8ZLOH8wnpQ9i7Nol0XLxAu+Cq7Sb+J9wC0j6Km5hG8rj47/yQ==",
       "cpu": [
-        "s390x"
+        "arm"
       ],
       "dev": true,
       "license": "MIT",
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-linux-x64-gnu": {
-      "version": "4.50.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.50.0.tgz",
-      "integrity": "sha512-8PrJJA7/VU8ToHVEPu14FzuSAqVKyo5gg/J8xUerMbyNkWkO9j2ExBho/68RnJsMGNJq4zH114iAttgm7BZVkA==",
+    "node_modules/@oxlint/binding-linux-arm64-gnu": {
+      "version": "1.56.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.56.0.tgz",
+      "integrity": "sha512-urse2SnugwJRojUkGSSeH2LPMaje5Q50yQtvtL9HFckiyeqXzoFwOAZqD5TR29R2lq7UHidfFDM9EGcchcbb8A==",
       "cpu": [
-        "x64"
+        "arm64"
       ],
       "dev": true,
       "license": "MIT",
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-linux-x64-musl": {
-      "version": "4.50.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.50.0.tgz",
-      "integrity": "sha512-SkE6YQp+CzpyOrbw7Oc4MgXFvTw2UIBElvAvLCo230pyxOLmYwRPwZ/L5lBe/VW/qT1ZgND9wJfOsdy0XptRvw==",
+    "node_modules/@oxlint/binding-linux-arm64-musl": {
+      "version": "1.56.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.56.0.tgz",
+      "integrity": "sha512-rkTZkBfJ4TYLjansjSzL6mgZOdN5IvUnSq3oNJSLwBcNvy3dlgQtpHPrRxrCEbbcp7oQ6If0tkNaqfOsphYZ9g==",
       "cpu": [
-        "x64"
+        "arm64"
       ],
       "dev": true,
       "license": "MIT",
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-openharmony-arm64": {
-      "version": "4.50.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.50.0.tgz",
-      "integrity": "sha512-PZkNLPfvXeIOgJWA804zjSFH7fARBBCpCXxgkGDRjjAhRLOR8o0IGS01ykh5GYfod4c2yiiREuDM8iZ+pVsT+Q==",
+    "node_modules/@oxlint/binding-linux-ppc64-gnu": {
+      "version": "1.56.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-1.56.0.tgz",
+      "integrity": "sha512-uqL1kMH3u69/e1CH2EJhP3CP28jw2ExLsku4o8RVAZ7fySo9zOyI2fy9pVlTAp4voBLVgzndXi3SgtdyCTa2aA==",
       "cpu": [
-        "arm64"
+        "ppc64"
       ],
       "dev": true,
       "license": "MIT",
       "optional": true,
       "os": [
-        "openharmony"
-      ]
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@oxlint/binding-linux-riscv64-gnu": {
+      "version": "1.56.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-linux-riscv64-gnu/-/binding-linux-riscv64-gnu-1.56.0.tgz",
+      "integrity": "sha512-j0CcMBOgV6KsRaBdsebIeiy7hCjEvq2KdEsiULf2LZqAq0v1M1lWjelhCV57LxsqaIGChXFuFJ0RiFrSRHPhSg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@oxlint/binding-linux-riscv64-musl": {
+      "version": "1.56.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-linux-riscv64-musl/-/binding-linux-riscv64-musl-1.56.0.tgz",
+      "integrity": "sha512-7VDOiL8cDG3DQ/CY3yKjbV1c4YPvc4vH8qW09Vv+5ukq3l/Kcyr6XGCd5NvxUmxqDb2vjMpM+eW/4JrEEsUetA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@oxlint/binding-linux-s390x-gnu": {
+      "version": "1.56.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-1.56.0.tgz",
+      "integrity": "sha512-JGRpX0M+ikD3WpwJ7vKcHKV6Kg0dT52BW2Eu2BupXotYeqGXBrbY+QPkAyKO6MNgKozyTNaRh3r7g+VWgyAQYQ==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@oxlint/binding-linux-x64-gnu": {
+      "version": "1.56.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.56.0.tgz",
+      "integrity": "sha512-dNaICPvtmuxFP/VbqdofrLqdS3bM/AKJN3LMJD52si44ea7Be1cBk6NpfIahaysG9Uo+L98QKddU9CD5L8UHnQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@oxlint/binding-linux-x64-musl": {
+      "version": "1.56.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-linux-x64-musl/-/binding-linux-x64-musl-1.56.0.tgz",
+      "integrity": "sha512-pF1vOtM+GuXmbklM1hV8WMsn6tCNPvkUzklj/Ej98JhlanbmA2RB1BILgOpwSuCTRTIYx2MXssmEyQQ90QF5aA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@oxlint/binding-openharmony-arm64": {
+      "version": "1.56.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-openharmony-arm64/-/binding-openharmony-arm64-1.56.0.tgz",
+      "integrity": "sha512-bp8NQ4RE6fDIFLa4bdBiOA+TAvkNkg+rslR+AvvjlLTYXLy9/uKAYLQudaQouWihLD/hgkrXIKKzXi5IXOewwg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@oxlint/binding-win32-arm64-msvc": {
+      "version": "1.56.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.56.0.tgz",
+      "integrity": "sha512-PxT4OJDfMOQBzo3OlzFb9gkoSD+n8qSBxyVq2wQSZIHFQYGEqIRTo9M0ZStvZm5fdhMqaVYpOnJvH2hUMEDk/g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@oxlint/binding-win32-ia32-msvc": {
+      "version": "1.56.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-win32-ia32-msvc/-/binding-win32-ia32-msvc-1.56.0.tgz",
+      "integrity": "sha512-PTRy6sIEPqy2x8PTP1baBNReN/BNEFmde0L+mYeHmjXE1Vlcc9+I5nsqENsB2yAm5wLkzPoTNCMY/7AnabT4/A==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@oxlint/binding-win32-x64-msvc": {
+      "version": "1.56.0",
+      "resolved": "https://registry.npmjs.org/@oxlint/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.56.0.tgz",
+      "integrity": "sha512-ZHa0clocjLmIDr+1LwoWtxRcoYniAvERotvwKUYKhH41NVfl0Y4LNbyQkwMZzwDvKklKGvGZ5+DAG58/Ik47tQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@pkgjs/parseargs": {
+      "version": "0.11.0",
+      "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz",
+      "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@polka/url": {
+      "version": "1.0.0-next.29",
+      "resolved": "https://registry.npmjs.org/@polka/url/-/url-1.0.0-next.29.tgz",
+      "integrity": "sha512-wwQAWhWSuHaag8c4q/KN/vCoeOJYshAIvMQwD4GpSb3OiZklFfvAgmj0VCBBImRpuF/aFgIRzllXlVX93Jevww==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@rolldown/binding-android-arm64": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm64/-/binding-android-arm64-1.0.0-rc.9.tgz",
+      "integrity": "sha512-lcJL0bN5hpgJfSIz/8PIf02irmyL43P+j1pTCfbD1DbLkmGRuFIA4DD3B3ZOvGqG0XiVvRznbKtN0COQVaKUTg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-darwin-arm64": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-arm64/-/binding-darwin-arm64-1.0.0-rc.9.tgz",
+      "integrity": "sha512-J7Zk3kLYFsLtuH6U+F4pS2sYVzac0qkjcO5QxHS7OS7yZu2LRs+IXo+uvJ/mvpyUljDJ3LROZPoQfgBIpCMhdQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-darwin-x64": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-x64/-/binding-darwin-x64-1.0.0-rc.9.tgz",
+      "integrity": "sha512-iwtmmghy8nhfRGeNAIltcNXzD0QMNaaA5U/NyZc1Ia4bxrzFByNMDoppoC+hl7cDiUq5/1CnFthpT9n+UtfFyg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-freebsd-x64": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-freebsd-x64/-/binding-freebsd-x64-1.0.0-rc.9.tgz",
+      "integrity": "sha512-DLFYI78SCiZr5VvdEplsVC2Vx53lnA4/Ga5C65iyldMVaErr86aiqCoNBLl92PXPfDtUYjUh+xFFor40ueNs4Q==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-arm-gnueabihf": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.0.0-rc.9.tgz",
+      "integrity": "sha512-CsjTmTwd0Hri6iTw/DRMK7kOZ7FwAkrO4h8YWKoX/kcj833e4coqo2wzIFywtch/8Eb5enQ/lwLM7w6JX1W5RQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-arm64-gnu": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.0.0-rc.9.tgz",
+      "integrity": "sha512-2x9O2JbSPxpxMDhP9Z74mahAStibTlrBMW0520+epJH5sac7/LwZW5Bmg/E6CXuEF53JJFW509uP+lSedaUNxg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-arm64-musl": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.0.0-rc.9.tgz",
+      "integrity": "sha512-JA1QRW31ogheAIRhIg9tjMfsYbglXXYGNPLdPEYrwFxdbkQCAzvpSCSHCDWNl4hTtrol8WeboCSEpjdZK8qrCg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-ppc64-gnu": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-1.0.0-rc.9.tgz",
+      "integrity": "sha512-aOKU9dJheda8Kj8Y3w9gnt9QFOO+qKPAl8SWd7JPHP+Cu0EuDAE5wokQubLzIDQWg2myXq2XhTpOVS07qqvT+w==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-s390x-gnu": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-1.0.0-rc.9.tgz",
+      "integrity": "sha512-OalO94fqj7IWRn3VdXWty75jC5dk4C197AWEuMhIpvVv2lw9fiPhud0+bW2ctCxb3YoBZor71QHbY+9/WToadA==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-x64-gnu": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.0.0-rc.9.tgz",
+      "integrity": "sha512-cVEl1vZtBsBZna3YMjGXNvnYYrOJ7RzuWvZU0ffvJUexWkukMaDuGhUXn0rjnV0ptzGVkvc+vW9Yqy6h8YX4pg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-x64-musl": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.0.0-rc.9.tgz",
+      "integrity": "sha512-UzYnKCIIc4heAKgI4PZ3dfBGUZefGCJ1TPDuLHoCzgrMYPb5Rv6TLFuYtyM4rWyHM7hymNdsg5ik2C+UD9VDbA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-openharmony-arm64": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-openharmony-arm64/-/binding-openharmony-arm64-1.0.0-rc.9.tgz",
+      "integrity": "sha512-+6zoiF+RRyf5cdlFQP7nm58mq7+/2PFaY2DNQeD4B87N36JzfF/l9mdBkkmTvSYcYPE8tMh/o3cRlsx1ldLfog==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-wasm32-wasi": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-wasm32-wasi/-/binding-wasm32-wasi-1.0.0-rc.9.tgz",
+      "integrity": "sha512-rgFN6sA/dyebil3YTlL2evvi/M+ivhfnyxec7AccTpRPccno/rPoNlqybEZQBkcbZu8Hy+eqNJCqfBR8P7Pg8g==",
+      "cpu": [
+        "wasm32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@napi-rs/wasm-runtime": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/@rolldown/binding-win32-arm64-msvc": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.0.0-rc.9.tgz",
+      "integrity": "sha512-lHVNUG/8nlF1IQk1C0Ci574qKYyty2goMiPlRqkC5R+3LkXDkL5Dhx8ytbxq35m+pkHVIvIxviD+TWLdfeuadA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-win32-x64-msvc": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.0.0-rc.9.tgz",
+      "integrity": "sha512-G0oA4+w1iY5AGi5HcDTxWsoxF509hrFIPB2rduV5aDqS9FtDg1CAfa7V34qImbjfhIcA8C+RekocJZA96EarwQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/pluginutils": {
+      "version": "1.0.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-rc.2.tgz",
+      "integrity": "sha512-izyXV/v+cHiRfozX62W9htOAvwMo4/bXKDrQ+vom1L1qRuexPock/7VZDAhnpHCLNejd3NJ6hiab+tO0D44Rgw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@rollup/pluginutils": {
+      "version": "5.1.4",
+      "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-5.1.4.tgz",
+      "integrity": "sha512-USm05zrsFxYLPdWWq+K3STlWiT/3ELn3RcV5hJMghpeAIhxfsUIg6mt12CBJBInWMV4VneoV7SfGv8xIwo2qNQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.0",
+        "estree-walker": "^2.0.2",
+        "picomatch": "^4.0.2"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "peerDependencies": {
+        "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "rollup": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.50.0.tgz",
+      "integrity": "sha512-lVgpeQyy4fWN5QYebtW4buT/4kn4p4IJ+kDNB4uYNT5b8c8DLJDg6titg20NIg7E8RWwdWZORW6vUFfrLyG3KQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.50.0.tgz",
+      "integrity": "sha512-2O73dR4Dc9bp+wSYhviP6sDziurB5/HCym7xILKifWdE9UsOe2FtNcM+I4xZjKrfLJnq5UR8k9riB87gauiQtw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.50.0.tgz",
+      "integrity": "sha512-vwSXQN8T4sKf1RHr1F0s98Pf8UPz7pS6P3LG9NSmuw0TVh7EmaE+5Ny7hJOZ0M2yuTctEsHHRTMi2wuHkdS6Hg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.50.0.tgz",
+      "integrity": "sha512-cQp/WG8HE7BCGyFVuzUg0FNmupxC+EPZEwWu2FCGGw5WDT1o2/YlENbm5e9SMvfDFR6FRhVCBePLqj0o8MN7Vw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.50.0.tgz",
+      "integrity": "sha512-UR1uTJFU/p801DvvBbtDD7z9mQL8J80xB0bR7DqW7UGQHRm/OaKzp4is7sQSdbt2pjjSS72eAtRh43hNduTnnQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.50.0.tgz",
+      "integrity": "sha512-G/DKyS6PK0dD0+VEzH/6n/hWDNPDZSMBmqsElWnCRGrYOb2jC0VSupp7UAHHQ4+QILwkxSMaYIbQ72dktp8pKA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.50.0.tgz",
+      "integrity": "sha512-u72Mzc6jyJwKjJbZZcIYmd9bumJu7KNmHYdue43vT1rXPm2rITwmPWF0mmPzLm9/vJWxIRbao/jrQmxTO0Sm9w==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.50.0.tgz",
+      "integrity": "sha512-S4UefYdV0tnynDJV1mdkNawp0E5Qm2MtSs330IyHgaccOFrwqsvgigUD29uT+B/70PDY1eQ3t40+xf6wIvXJyg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.50.0.tgz",
+      "integrity": "sha512-1EhkSvUQXJsIhk4msxP5nNAUWoB4MFDHhtc4gAYvnqoHlaL9V3F37pNHabndawsfy/Tp7BPiy/aSa6XBYbaD1g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.50.0.tgz",
+      "integrity": "sha512-EtBDIZuDtVg75xIPIK1l5vCXNNCIRM0OBPUG+tbApDuJAy9mKago6QxX+tfMzbCI6tXEhMuZuN1+CU8iDW+0UQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loongarch64-gnu": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loongarch64-gnu/-/rollup-linux-loongarch64-gnu-4.50.0.tgz",
+      "integrity": "sha512-BGYSwJdMP0hT5CCmljuSNx7+k+0upweM2M4YGfFBjnFSZMHOLYR0gEEj/dxyYJ6Zc6AiSeaBY8dWOa11GF/ppQ==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.50.0.tgz",
+      "integrity": "sha512-I1gSMzkVe1KzAxKAroCJL30hA4DqSi+wGc5gviD0y3IL/VkvcnAqwBf4RHXHyvH66YVHxpKO8ojrgc4SrWAnLg==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.50.0.tgz",
+      "integrity": "sha512-bSbWlY3jZo7molh4tc5dKfeSxkqnf48UsLqYbUhnkdnfgZjgufLS/NTA8PcP/dnvct5CCdNkABJ56CbclMRYCA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.50.0.tgz",
+      "integrity": "sha512-LSXSGumSURzEQLT2e4sFqFOv3LWZsEF8FK7AAv9zHZNDdMnUPYH3t8ZlaeYYZyTXnsob3htwTKeWtBIkPV27iQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.50.0.tgz",
+      "integrity": "sha512-CxRKyakfDrsLXiCyucVfVWVoaPA4oFSpPpDwlMcDFQvrv3XY6KEzMtMZrA+e/goC8xxp2WSOxHQubP8fPmmjOQ==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.50.0.tgz",
+      "integrity": "sha512-8PrJJA7/VU8ToHVEPu14FzuSAqVKyo5gg/J8xUerMbyNkWkO9j2ExBho/68RnJsMGNJq4zH114iAttgm7BZVkA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.50.0.tgz",
+      "integrity": "sha512-SkE6YQp+CzpyOrbw7Oc4MgXFvTw2UIBElvAvLCo230pyxOLmYwRPwZ/L5lBe/VW/qT1ZgND9wJfOsdy0XptRvw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.50.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.50.0.tgz",
+      "integrity": "sha512-PZkNLPfvXeIOgJWA804zjSFH7fARBBCpCXxgkGDRjjAhRLOR8o0IGS01ykh5GYfod4c2yiiREuDM8iZ+pVsT+Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
     },
     "node_modules/@rollup/rollup-win32-arm64-msvc": {
       "version": "4.50.0",
@@ -2054,47 +2540,24 @@
       "license": "MIT"
     },
     "node_modules/@stylistic/eslint-plugin": {
-      "version": "2.12.1",
-      "resolved": "https://registry.npmjs.org/@stylistic/eslint-plugin/-/eslint-plugin-2.12.1.tgz",
-      "integrity": "sha512-fubZKIHSPuo07FgRTn6S4Nl0uXPRPYVNpyZzIDGfp7Fny6JjNus6kReLD7NI380JXi4HtUTSOZ34LBuNPO1XLQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@typescript-eslint/utils": "^8.13.0",
-        "eslint-visitor-keys": "^4.2.0",
-        "espree": "^10.3.0",
-        "estraverse": "^5.3.0",
-        "picomatch": "^4.0.2"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "peerDependencies": {
-        "eslint": ">=8.40.0"
-      }
-    },
-    "node_modules/@stylistic/eslint-plugin/node_modules/@typescript-eslint/utils": {
-      "version": "8.54.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.54.0.tgz",
-      "integrity": "sha512-9Cnda8GS57AQakvRyG0PTejJNlA2xhvyNtEVIMlDWOOeEyBkYWhGPnfrIAnqxLMTSTo6q8g12XVjjev5l1NvMA==",
+      "version": "5.10.0",
+      "resolved": "https://registry.npmjs.org/@stylistic/eslint-plugin/-/eslint-plugin-5.10.0.tgz",
+      "integrity": "sha512-nPK52ZHvot8Ju/0A4ucSX1dcPV2/1clx0kLcH5wDmrE4naKso7TUC/voUyU1O9OTKTrR6MYip6LP0ogEMQ9jPQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.9.1",
-        "@typescript-eslint/scope-manager": "8.54.0",
-        "@typescript-eslint/types": "8.54.0",
-        "@typescript-eslint/typescript-estree": "8.54.0"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
+        "@typescript-eslint/types": "^8.56.0",
+        "eslint-visitor-keys": "^4.2.1",
+        "espree": "^10.4.0",
+        "estraverse": "^5.3.0",
+        "picomatch": "^4.0.3"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
       },
       "peerDependencies": {
-        "eslint": "^8.57.0 || ^9.0.0",
-        "typescript": ">=4.8.4 <6.0.0"
+        "eslint": "^9.0.0 || ^10.0.0"
       }
     },
     "node_modules/@tybys/wasm-util": {
@@ -2133,6 +2596,14 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@types/esrecurse": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/@types/esrecurse/-/esrecurse-4.3.1.tgz",
+      "integrity": "sha512-xJBAbDifo5hpffDBuHl0Y8ywswbiAp/Wi7Y/GtAgSlZyIABppyurxVueOPE8LUQOxdlgi6Zqce7uoEpqNTeiUw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
     "node_modules/@types/estree": {
       "version": "1.0.8",
       "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
@@ -2155,7 +2626,8 @@
       "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
       "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/@types/linkify-it": {
       "version": "5.0.0",
@@ -2233,268 +2705,446 @@
         "@types/node": "*"
       }
     },
-    "node_modules/@typescript-eslint/project-service": {
-      "version": "8.54.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.54.0.tgz",
-      "integrity": "sha512-YPf+rvJ1s7MyiWM4uTRhE4DvBXrEV+d8oC3P9Y2eT7S+HBS0clybdMIPnhiATi9vZOYDc7OQ1L/i6ga6NFYK/g==",
+    "node_modules/@typescript-eslint/types": {
+      "version": "8.57.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.57.1.tgz",
+      "integrity": "sha512-S29BOBPJSFUiblEl6RzPPjJt6w25A6XsBqRVDt53tA/tlL8q7ceQNZHTjPeONt/3S7KRI4quk+yP9jK2WjBiPQ==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "@typescript-eslint/tsconfig-utils": "^8.54.0",
-        "@typescript-eslint/types": "^8.54.0",
-        "debug": "^4.4.3"
-      },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
       },
       "funding": {
         "type": "opencollective",
         "url": "https://opencollective.com/typescript-eslint"
-      },
-      "peerDependencies": {
-        "typescript": ">=4.8.4 <6.0.0"
       }
     },
-    "node_modules/@typescript-eslint/scope-manager": {
-      "version": "8.54.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.54.0.tgz",
-      "integrity": "sha512-27rYVQku26j/PbHYcVfRPonmOlVI6gihHtXFbTdB5sb6qA0wdAQAbyXFVarQ5t4HRojIz64IV90YtsjQSSGlQg==",
+    "node_modules/@ungap/structured-clone": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.3.0.tgz",
+      "integrity": "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/@vitejs/plugin-vue": {
+      "version": "6.0.5",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-vue/-/plugin-vue-6.0.5.tgz",
+      "integrity": "sha512-bL3AxKuQySfk1iGcBsQnoRVexTPJq0Z/ixFVM8OhVJAP6ZXXXLtM7NFKWhLl30Kg7uTBqIaPXbh+nuQCuBDedg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/types": "8.54.0",
-        "@typescript-eslint/visitor-keys": "8.54.0"
+        "@rolldown/pluginutils": "1.0.0-rc.2"
       },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "peerDependencies": {
+        "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0",
+        "vue": "^3.2.25"
+      }
+    },
+    "node_modules/@vitest/expect": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-4.1.0.tgz",
+      "integrity": "sha512-EIxG7k4wlWweuCLG9Y5InKFwpMEOyrMb6ZJ1ihYu02LVj/bzUwn2VMU+13PinsjRW75XnITeFrQBMH5+dLvCDA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@standard-schema/spec": "^1.1.0",
+        "@types/chai": "^5.2.2",
+        "@vitest/spy": "4.1.0",
+        "@vitest/utils": "4.1.0",
+        "chai": "^6.2.2",
+        "tinyrainbow": "^3.0.3"
       },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
+        "url": "https://opencollective.com/vitest"
       }
     },
-    "node_modules/@typescript-eslint/tsconfig-utils": {
-      "version": "8.54.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.54.0.tgz",
-      "integrity": "sha512-dRgOyT2hPk/JwxNMZDsIXDgyl9axdJI3ogZ2XWhBPsnZUv+hPesa5iuhdYt2gzwA9t8RE5ytOJ6xB0moV0Ujvw==",
+    "node_modules/@vitest/mocker": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-4.1.0.tgz",
+      "integrity": "sha512-evxREh+Hork43+Y4IOhTo+h5lGmVRyjqI739Rz4RlUPqwrkFFDF6EMvOOYjTx4E8Tl6gyCLRL8Mu7Ry12a13Tw==",
       "dev": true,
       "license": "MIT",
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      "dependencies": {
+        "@vitest/spy": "4.1.0",
+        "estree-walker": "^3.0.3",
+        "magic-string": "^0.30.21"
       },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
+        "url": "https://opencollective.com/vitest"
       },
       "peerDependencies": {
-        "typescript": ">=4.8.4 <6.0.0"
+        "msw": "^2.4.9",
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0-0"
+      },
+      "peerDependenciesMeta": {
+        "msw": {
+          "optional": true
+        },
+        "vite": {
+          "optional": true
+        }
       }
     },
-    "node_modules/@typescript-eslint/types": {
-      "version": "8.54.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.54.0.tgz",
-      "integrity": "sha512-PDUI9R1BVjqu7AUDsRBbKMtwmjWcn4J3le+5LpcFgWULN3LvHC5rkc9gCVxbrsrGmO1jfPybN5s6h4Jy+OnkAA==",
+    "node_modules/@vitest/mocker/node_modules/estree-walker": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",
+      "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
       "dev": true,
       "license": "MIT",
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      "dependencies": {
+        "@types/estree": "^1.0.0"
+      }
+    },
+    "node_modules/@vitest/pretty-format": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-4.1.0.tgz",
+      "integrity": "sha512-3RZLZlh88Ib0J7NQTRATfc/3ZPOnSUn2uDBUoGNn5T36+bALixmzphN26OUD3LRXWkJu4H0s5vvUeqBiw+kS0A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tinyrainbow": "^3.0.3"
       },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
+        "url": "https://opencollective.com/vitest"
       }
     },
-    "node_modules/@typescript-eslint/typescript-estree": {
-      "version": "8.54.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.54.0.tgz",
-      "integrity": "sha512-BUwcskRaPvTk6fzVWgDPdUndLjB87KYDrN5EYGetnktoeAvPtO4ONHlAZDnj5VFnUANg0Sjm7j4usBlnoVMHwA==",
+    "node_modules/@vitest/runner": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-4.1.0.tgz",
+      "integrity": "sha512-Duvx2OzQ7d6OjchL+trw+aSrb9idh7pnNfxrklo14p3zmNL4qPCDeIJAK+eBKYjkIwG96Bc6vYuxhqDXQOWpoQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/project-service": "8.54.0",
-        "@typescript-eslint/tsconfig-utils": "8.54.0",
-        "@typescript-eslint/types": "8.54.0",
-        "@typescript-eslint/visitor-keys": "8.54.0",
-        "debug": "^4.4.3",
-        "minimatch": "^9.0.5",
-        "semver": "^7.7.3",
-        "tinyglobby": "^0.2.15",
-        "ts-api-utils": "^2.4.0"
+        "@vitest/utils": "4.1.0",
+        "pathe": "^2.0.3"
       },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/snapshot": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-4.1.0.tgz",
+      "integrity": "sha512-0Vy9euT1kgsnj1CHttwi9i9o+4rRLEaPRSOJ5gyv579GJkNpgJK+B4HSv/rAWixx2wdAFci1X4CEPjiu2bXIMg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "4.1.0",
+        "@vitest/utils": "4.1.0",
+        "magic-string": "^0.30.21",
+        "pathe": "^2.0.3"
       },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/spy": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-4.1.0.tgz",
+      "integrity": "sha512-pz77k+PgNpyMDv2FV6qmk5ZVau6c3R8HC8v342T2xlFxQKTrSeYw9waIJG8KgV9fFwAtTu4ceRzMivPTH6wSxw==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/utils": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-4.1.0.tgz",
+      "integrity": "sha512-XfPXT6a8TZY3dcGY8EdwsBulFCIw+BeeX0RZn2x/BtiY/75YGh8FeWGG8QISN/WhaqSrE2OrlDgtF8q5uhOTmw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "4.1.0",
+        "convert-source-map": "^2.0.0",
+        "tinyrainbow": "^3.0.3"
       },
-      "peerDependencies": {
-        "typescript": ">=4.8.4 <6.0.0"
+      "funding": {
+        "url": "https://opencollective.com/vitest"
       }
     },
-    "node_modules/@typescript-eslint/visitor-keys": {
-      "version": "8.54.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.54.0.tgz",
-      "integrity": "sha512-VFlhGSl4opC0bprJiItPQ1RfUhGDIBokcPwaFH4yiBCaNPeld/9VeXbiPO1cLyorQi1G1vL+ecBk1x8o1axORA==",
+    "node_modules/@voidzero-dev/vite-plus-core": {
+      "version": "0.1.13",
+      "resolved": "https://registry.npmjs.org/@voidzero-dev/vite-plus-core/-/vite-plus-core-0.1.13.tgz",
+      "integrity": "sha512-72dAIYgGrrmh4ap5Tbvzo0EYCrmVRoPQjz3NERpZ34CWCjFB8+WAyBkxG631Jz9/qC1TR/ZThjOKbdYXQ5z9Aw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/types": "8.54.0",
-        "eslint-visitor-keys": "^4.2.1"
+        "@oxc-project/runtime": "=0.120.0",
+        "@oxc-project/types": "=0.120.0",
+        "lightningcss": "^1.30.2",
+        "postcss": "^8.5.6"
       },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@arethetypeswrong/core": "^0.18.1",
+        "@tsdown/css": "0.21.4",
+        "@tsdown/exe": "0.21.4",
+        "@types/node": "^20.19.0 || >=22.12.0",
+        "@vitejs/devtools": "^0.1.0",
+        "esbuild": "^0.27.0",
+        "jiti": ">=1.21.0",
+        "less": "^4.0.0",
+        "publint": "^0.3.0",
+        "sass": "^1.70.0",
+        "sass-embedded": "^1.70.0",
+        "stylus": ">=0.54.8",
+        "sugarss": "^5.0.0",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "typescript": "^5.0.0",
+        "unplugin-unused": "^0.5.0",
+        "yaml": "^2.4.2"
       },
+      "peerDependenciesMeta": {
+        "@arethetypeswrong/core": {
+          "optional": true
+        },
+        "@tsdown/css": {
+          "optional": true
+        },
+        "@tsdown/exe": {
+          "optional": true
+        },
+        "@types/node": {
+          "optional": true
+        },
+        "@vitejs/devtools": {
+          "optional": true
+        },
+        "esbuild": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "publint": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "typescript": {
+          "optional": true
+        },
+        "unplugin-unused": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@voidzero-dev/vite-plus-core/node_modules/@oxc-project/runtime": {
+      "version": "0.120.0",
+      "resolved": "https://registry.npmjs.org/@oxc-project/runtime/-/runtime-0.120.0.tgz",
+      "integrity": "sha512-7fvACzS46TkHuzA+Tag8ac40qfwURXRTdc4AtyItF59AoNPOO/QjPMqPyvJH8CaUdGu0ntWDX1CCUNyLMxxX5g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@voidzero-dev/vite-plus-core/node_modules/@oxc-project/types": {
+      "version": "0.120.0",
+      "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.120.0.tgz",
+      "integrity": "sha512-k1YNu55DuvAip/MGE1FTsIuU3FUCn6v/ujG9V7Nq5Df/kX2CWb13hhwD0lmJGMGqE+bE1MXvv9SZVnMzEXlWcg==",
+      "dev": true,
+      "license": "MIT",
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/typescript-eslint"
+        "url": "https://github.com/sponsors/Boshen"
       }
     },
-    "node_modules/@ungap/structured-clone": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.3.0.tgz",
-      "integrity": "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==",
+    "node_modules/@voidzero-dev/vite-plus-darwin-arm64": {
+      "version": "0.1.13",
+      "resolved": "https://registry.npmjs.org/@voidzero-dev/vite-plus-darwin-arm64/-/vite-plus-darwin-arm64-0.1.13.tgz",
+      "integrity": "sha512-GgQ5dW1VR/Vuc8cRDsdpLMdly2rHiq8ihNKIh1eu8hR85bDjDxE4DSXeadCDMWC0bHTjQiR1HqApzjoPYsVF/w==",
+      "cpu": [
+        "arm64"
+      ],
       "dev": true,
-      "license": "ISC"
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@voidzero-dev/vite-plus-darwin-x64": {
+      "version": "0.1.13",
+      "resolved": "https://registry.npmjs.org/@voidzero-dev/vite-plus-darwin-x64/-/vite-plus-darwin-x64-0.1.13.tgz",
+      "integrity": "sha512-X4ZXbjIhNg5jxEkPVn7kJZEVIvNiOCWztrY67nHD94yqsWLy2Hs7yo+DhrpEQihsnlZ1hRRtwDirdCncvEulUg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@vitejs/plugin-vue": {
-      "version": "6.0.5",
-      "resolved": "https://registry.npmjs.org/@vitejs/plugin-vue/-/plugin-vue-6.0.5.tgz",
-      "integrity": "sha512-bL3AxKuQySfk1iGcBsQnoRVexTPJq0Z/ixFVM8OhVJAP6ZXXXLtM7NFKWhLl30Kg7uTBqIaPXbh+nuQCuBDedg==",
+    "node_modules/@voidzero-dev/vite-plus-linux-arm64-gnu": {
+      "version": "0.1.13",
+      "resolved": "https://registry.npmjs.org/@voidzero-dev/vite-plus-linux-arm64-gnu/-/vite-plus-linux-arm64-gnu-0.1.13.tgz",
+      "integrity": "sha512-oPtwztuF1cierDWA68beais5mwm6dXsmOOvccn6ZHjNpKXig84LvgIoY4bMazA3Z0SE9nWqxmP0kePiO5SoiuA==",
+      "cpu": [
+        "arm64"
+      ],
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "@rolldown/pluginutils": "1.0.0-rc.2"
-      },
+      "optional": true,
+      "os": [
+        "linux"
+      ],
       "engines": {
         "node": "^20.19.0 || >=22.12.0"
-      },
-      "peerDependencies": {
-        "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0",
-        "vue": "^3.2.25"
       }
     },
-    "node_modules/@vitest/expect": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-4.1.0.tgz",
-      "integrity": "sha512-EIxG7k4wlWweuCLG9Y5InKFwpMEOyrMb6ZJ1ihYu02LVj/bzUwn2VMU+13PinsjRW75XnITeFrQBMH5+dLvCDA==",
+    "node_modules/@voidzero-dev/vite-plus-linux-x64-gnu": {
+      "version": "0.1.13",
+      "resolved": "https://registry.npmjs.org/@voidzero-dev/vite-plus-linux-x64-gnu/-/vite-plus-linux-x64-gnu-0.1.13.tgz",
+      "integrity": "sha512-RgNHwTXrnYjt60K0g083VxOjaJNXHvZXViBQd/oC7RUwGUvxuHkraq/4mWaI69Pffx2KpyykxgCrtmhWq5Tgjg==",
+      "cpu": [
+        "x64"
+      ],
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "@standard-schema/spec": "^1.1.0",
-        "@types/chai": "^5.2.2",
-        "@vitest/spy": "4.1.0",
-        "@vitest/utils": "4.1.0",
-        "chai": "^6.2.2",
-        "tinyrainbow": "^3.0.3"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
       }
     },
-    "node_modules/@vitest/mocker": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-4.1.0.tgz",
-      "integrity": "sha512-evxREh+Hork43+Y4IOhTo+h5lGmVRyjqI739Rz4RlUPqwrkFFDF6EMvOOYjTx4E8Tl6gyCLRL8Mu7Ry12a13Tw==",
+    "node_modules/@voidzero-dev/vite-plus-test": {
+      "version": "0.1.13",
+      "resolved": "https://registry.npmjs.org/@voidzero-dev/vite-plus-test/-/vite-plus-test-0.1.13.tgz",
+      "integrity": "sha512-P3n9adJZsaIUGlgbzyT2YvlA1yr2lCYhNjrZsiLAKMVyQzk2D++ptTre3SnYf9j1TQeMP1VonRXGjtZhTf8wHg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@vitest/spy": "4.1.0",
-        "estree-walker": "^3.0.3",
-        "magic-string": "^0.30.21"
+        "@standard-schema/spec": "^1.1.0",
+        "@types/chai": "^5.2.2",
+        "@voidzero-dev/vite-plus-core": "0.1.13",
+        "es-module-lexer": "^1.7.0",
+        "obug": "^2.1.1",
+        "pixelmatch": "^7.1.0",
+        "pngjs": "^7.0.0",
+        "sirv": "^3.0.2",
+        "std-env": "^4.0.0",
+        "tinybench": "^2.9.0",
+        "tinyexec": "^1.0.2",
+        "tinyglobby": "^0.2.15",
+        "ws": "^8.18.3"
       },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
+      "engines": {
+        "node": "^20.0.0 || ^22.0.0 || >=24.0.0"
       },
       "peerDependencies": {
-        "msw": "^2.4.9",
+        "@edge-runtime/vm": "*",
+        "@opentelemetry/api": "^1.9.0",
+        "@types/node": "^20.0.0 || ^22.0.0 || >=24.0.0",
+        "@vitest/ui": "4.1.0",
+        "happy-dom": "*",
+        "jsdom": "*",
         "vite": "^6.0.0 || ^7.0.0 || ^8.0.0-0"
       },
       "peerDependenciesMeta": {
-        "msw": {
+        "@edge-runtime/vm": {
           "optional": true
         },
-        "vite": {
+        "@opentelemetry/api": {
+          "optional": true
+        },
+        "@types/node": {
+          "optional": true
+        },
+        "@vitest/ui": {
           "optional": true
+        },
+        "happy-dom": {
+          "optional": true
+        },
+        "jsdom": {
+          "optional": true
+        },
+        "vite": {
+          "optional": false
         }
       }
     },
-    "node_modules/@vitest/mocker/node_modules/estree-walker": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",
-      "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/estree": "^1.0.0"
-      }
-    },
-    "node_modules/@vitest/pretty-format": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-4.1.0.tgz",
-      "integrity": "sha512-3RZLZlh88Ib0J7NQTRATfc/3ZPOnSUn2uDBUoGNn5T36+bALixmzphN26OUD3LRXWkJu4H0s5vvUeqBiw+kS0A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "tinyrainbow": "^3.0.3"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
-      }
-    },
-    "node_modules/@vitest/runner": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-4.1.0.tgz",
-      "integrity": "sha512-Duvx2OzQ7d6OjchL+trw+aSrb9idh7pnNfxrklo14p3zmNL4qPCDeIJAK+eBKYjkIwG96Bc6vYuxhqDXQOWpoQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@vitest/utils": "4.1.0",
-        "pathe": "^2.0.3"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
-      }
-    },
-    "node_modules/@vitest/snapshot": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-4.1.0.tgz",
-      "integrity": "sha512-0Vy9euT1kgsnj1CHttwi9i9o+4rRLEaPRSOJ5gyv579GJkNpgJK+B4HSv/rAWixx2wdAFci1X4CEPjiu2bXIMg==",
+    "node_modules/@voidzero-dev/vite-plus-test/node_modules/es-module-lexer": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz",
+      "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==",
       "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@vitest/pretty-format": "4.1.0",
-        "@vitest/utils": "4.1.0",
-        "magic-string": "^0.30.21",
-        "pathe": "^2.0.3"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
-      }
+      "license": "MIT"
     },
-    "node_modules/@vitest/spy": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-4.1.0.tgz",
-      "integrity": "sha512-pz77k+PgNpyMDv2FV6qmk5ZVau6c3R8HC8v342T2xlFxQKTrSeYw9waIJG8KgV9fFwAtTu4ceRzMivPTH6wSxw==",
+    "node_modules/@voidzero-dev/vite-plus-win32-arm64-msvc": {
+      "version": "0.1.13",
+      "resolved": "https://registry.npmjs.org/@voidzero-dev/vite-plus-win32-arm64-msvc/-/vite-plus-win32-arm64-msvc-0.1.13.tgz",
+      "integrity": "sha512-+oygKTgglu0HkA4y9kFs8/BbHFsvShkHuL+8bK++Zek3x2ArKHRjCMgcYUXyj6nYufMIL2ba/Und7aHUK2ZGiQ==",
+      "cpu": [
+        "arm64"
+      ],
       "dev": true,
       "license": "MIT",
-      "funding": {
-        "url": "https://opencollective.com/vitest"
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
       }
     },
-    "node_modules/@vitest/utils": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-4.1.0.tgz",
-      "integrity": "sha512-XfPXT6a8TZY3dcGY8EdwsBulFCIw+BeeX0RZn2x/BtiY/75YGh8FeWGG8QISN/WhaqSrE2OrlDgtF8q5uhOTmw==",
+    "node_modules/@voidzero-dev/vite-plus-win32-x64-msvc": {
+      "version": "0.1.13",
+      "resolved": "https://registry.npmjs.org/@voidzero-dev/vite-plus-win32-x64-msvc/-/vite-plus-win32-x64-msvc-0.1.13.tgz",
+      "integrity": "sha512-+7zTnX/HqYCaBKmSLHjmCXQBRSSIJ6EFry55+4C0R4AMyayfn9w3LL0/NuVeCNkG69u3FnkRuwkqdWpzxztoHQ==",
+      "cpu": [
+        "x64"
+      ],
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "@vitest/pretty-format": "4.1.0",
-        "convert-source-map": "^2.0.0",
-        "tinyrainbow": "^3.0.3"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
       }
     },
     "node_modules/@volar/language-core": {
@@ -2844,6 +3494,7 @@
       "integrity": "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.1",
         "fast-json-stable-stringify": "^2.0.0",
@@ -2990,13 +3641,6 @@
         "url": "https://github.com/sponsors/antfu"
       }
     },
-    "node_modules/boolbase": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz",
-      "integrity": "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==",
-      "dev": true,
-      "license": "ISC"
-    },
     "node_modules/brace-expansion": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
@@ -3007,14 +3651,14 @@
         "balanced-match": "^1.0.0"
       }
     },
-    "node_modules/callsites": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
-      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
+    "node_modules/cac": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/cac/-/cac-7.0.0.tgz",
+      "integrity": "sha512-tixWYgm5ZoOD+3g6UTea91eow5z6AAHaho3g0V9CNSNb45gM8SmflpAc+GRd1InC4AqN/07Unrgp56Y94N9hJQ==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": ">=6"
+        "node": ">=20.19.0"
       }
     },
     "node_modules/ccount": {
@@ -3038,23 +3682,6 @@
         "node": ">=18"
       }
     },
-    "node_modules/chalk": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
-      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^4.1.0",
-        "supports-color": "^7.1.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/chalk?sponsor=1"
-      }
-    },
     "node_modules/character-entities-html4": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/character-entities-html4/-/character-entities-html4-2.1.0.tgz",
@@ -3188,19 +3815,6 @@
         "node": ">= 8"
       }
     },
-    "node_modules/cssesc": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz",
-      "integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "cssesc": "bin/cssesc"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
     "node_modules/csstype": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz",
@@ -3237,7 +3851,8 @@
       "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
       "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/dequal": {
       "version": "2.0.3",
@@ -3354,6 +3969,7 @@
       "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=10"
       },
@@ -3362,33 +3978,31 @@
       }
     },
     "node_modules/eslint": {
-      "version": "9.39.4",
-      "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.39.4.tgz",
-      "integrity": "sha512-XoMjdBOwe/esVgEvLmNsD3IRHkm7fbKIUGvrleloJXUZgDHig2IPWNniv+GwjyJXzuNqVjlr5+4yVUZjycJwfQ==",
+      "version": "10.1.0",
+      "resolved": "https://registry.npmjs.org/eslint/-/eslint-10.1.0.tgz",
+      "integrity": "sha512-S9jlY/ELKEUwwQnqWDO+f+m6sercqOPSqXM5Go94l7DOmxHVDgmSFGWEzeE/gwgTAr0W103BWt0QLe/7mabIvA==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.8.0",
-        "@eslint-community/regexpp": "^4.12.1",
-        "@eslint/config-array": "^0.21.2",
-        "@eslint/config-helpers": "^0.4.2",
-        "@eslint/core": "^0.17.0",
-        "@eslint/eslintrc": "^3.3.5",
-        "@eslint/js": "9.39.4",
-        "@eslint/plugin-kit": "^0.4.1",
+        "@eslint-community/regexpp": "^4.12.2",
+        "@eslint/config-array": "^0.23.3",
+        "@eslint/config-helpers": "^0.5.3",
+        "@eslint/core": "^1.1.1",
+        "@eslint/plugin-kit": "^0.6.1",
         "@humanfs/node": "^0.16.6",
         "@humanwhocodes/module-importer": "^1.0.1",
         "@humanwhocodes/retry": "^0.4.2",
         "@types/estree": "^1.0.6",
         "ajv": "^6.14.0",
-        "chalk": "^4.0.0",
         "cross-spawn": "^7.0.6",
         "debug": "^4.3.2",
         "escape-string-regexp": "^4.0.0",
-        "eslint-scope": "^8.4.0",
-        "eslint-visitor-keys": "^4.2.1",
-        "espree": "^10.4.0",
-        "esquery": "^1.5.0",
+        "eslint-scope": "^9.1.2",
+        "eslint-visitor-keys": "^5.0.1",
+        "espree": "^11.2.0",
+        "esquery": "^1.7.0",
         "esutils": "^2.0.2",
         "fast-deep-equal": "^3.1.3",
         "file-entry-cache": "^8.0.0",
@@ -3398,8 +4012,7 @@
         "imurmurhash": "^0.1.4",
         "is-glob": "^4.0.0",
         "json-stable-stringify-without-jsonify": "^1.0.1",
-        "lodash.merge": "^4.6.2",
-        "minimatch": "^3.1.5",
+        "minimatch": "^10.2.4",
         "natural-compare": "^1.4.0",
         "optionator": "^0.9.3"
       },
@@ -3407,7 +4020,7 @@
         "eslint": "bin/eslint.js"
       },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": "^20.19.0 || ^22.13.0 || >=24"
       },
       "funding": {
         "url": "https://eslint.org/donate"
@@ -3422,17 +4035,20 @@
       }
     },
     "node_modules/eslint-scope": {
-      "version": "8.4.0",
-      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.4.0.tgz",
-      "integrity": "sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==",
+      "version": "9.1.2",
+      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-9.1.2.tgz",
+      "integrity": "sha512-xS90H51cKw0jltxmvmHy2Iai1LIqrfbw57b79w/J7MfvDfkIkFZ+kj6zC3BjtUwh150HsSSdxXZcsuv72miDFQ==",
       "dev": true,
       "license": "BSD-2-Clause",
+      "peer": true,
       "dependencies": {
+        "@types/esrecurse": "^4.3.1",
+        "@types/estree": "^1.0.8",
         "esrecurse": "^4.3.0",
         "estraverse": "^5.2.0"
       },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": "^20.19.0 || ^22.13.0 || >=24"
       },
       "funding": {
         "url": "https://opencollective.com/eslint"
@@ -3451,28 +4067,79 @@
         "url": "https://opencollective.com/eslint"
       }
     },
+    "node_modules/eslint/node_modules/balanced-match": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",
+      "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": "18 || 20 || >=22"
+      }
+    },
     "node_modules/eslint/node_modules/brace-expansion": {
-      "version": "1.1.12",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
-      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+      "version": "5.0.4",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.4.tgz",
+      "integrity": "sha512-h+DEnpVvxmfVefa4jFbCf5HdH5YMDXRsmKflpf1pILZWRFlTbJpxeU55nJl4Smt5HQaGzg1o6RHFPJaOqnmBDg==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
+        "balanced-match": "^4.0.2"
+      },
+      "engines": {
+        "node": "18 || 20 || >=22"
+      }
+    },
+    "node_modules/eslint/node_modules/eslint-visitor-keys": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-5.0.1.tgz",
+      "integrity": "sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "peer": true,
+      "engines": {
+        "node": "^20.19.0 || ^22.13.0 || >=24"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/eslint/node_modules/espree": {
+      "version": "11.2.0",
+      "resolved": "https://registry.npmjs.org/espree/-/espree-11.2.0.tgz",
+      "integrity": "sha512-7p3DrVEIopW1B1avAGLuCSh1jubc01H2JHc8B4qqGblmg5gI9yumBgACjWo4JlIc04ufug4xJ3SQI8HkS/Rgzw==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "peer": true,
+      "dependencies": {
+        "acorn": "^8.16.0",
+        "acorn-jsx": "^5.3.2",
+        "eslint-visitor-keys": "^5.0.1"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.13.0 || >=24"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
       }
     },
     "node_modules/eslint/node_modules/minimatch": {
-      "version": "3.1.5",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
-      "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+      "version": "10.2.4",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.4.tgz",
+      "integrity": "sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg==",
       "dev": true,
-      "license": "ISC",
+      "license": "BlueOak-1.0.0",
+      "peer": true,
       "dependencies": {
-        "brace-expansion": "^1.1.7"
+        "brace-expansion": "^5.0.2"
       },
       "engines": {
-        "node": "*"
+        "node": "18 || 20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
       }
     },
     "node_modules/espree": {
@@ -3499,6 +4166,7 @@
       "integrity": "sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g==",
       "dev": true,
       "license": "BSD-3-Clause",
+      "peer": true,
       "dependencies": {
         "estraverse": "^5.1.0"
       },
@@ -3512,6 +4180,7 @@
       "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
       "dev": true,
       "license": "BSD-2-Clause",
+      "peer": true,
       "dependencies": {
         "estraverse": "^5.2.0"
       },
@@ -3541,6 +4210,7 @@
       "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
       "dev": true,
       "license": "BSD-2-Clause",
+      "peer": true,
       "engines": {
         "node": ">=0.10.0"
       }
@@ -3574,14 +4244,16 @@
       "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
       "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/fast-levenshtein": {
       "version": "2.0.6",
       "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
       "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/fast-uri": {
       "version": "3.0.6",
@@ -3624,6 +4296,7 @@
       "integrity": "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "flat-cache": "^4.0.0"
       },
@@ -3637,6 +4310,7 @@
       "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "locate-path": "^6.0.0",
         "path-exists": "^4.0.0"
@@ -3654,6 +4328,7 @@
       "integrity": "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "flatted": "^3.2.9",
         "keyv": "^4.5.4"
@@ -3663,11 +4338,12 @@
       }
     },
     "node_modules/flatted": {
-      "version": "3.3.2",
-      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.2.tgz",
-      "integrity": "sha512-AiwGJM8YcNOaobumgtng+6NHuOqC3A7MixFeDafM3X9cIUM+xUXoS5Vfgf+OihAYe20fxqNM9yPBXJzRtZ/4eA==",
+      "version": "3.4.2",
+      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.4.2.tgz",
+      "integrity": "sha512-PjDse7RzhcPkIJwy5t7KPWQSZ9cAbzQXcafsetQoD7sOJRQlGikNbx7yZp2OotDnJyrDcbyRq3Ttb18iYOqkxA==",
       "dev": true,
-      "license": "ISC"
+      "license": "ISC",
+      "peer": true
     },
     "node_modules/focus-trap": {
       "version": "7.6.4",
@@ -3763,6 +4439,7 @@
       "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
       "dev": true,
       "license": "ISC",
+      "peer": true,
       "dependencies": {
         "is-glob": "^4.0.3"
       },
@@ -3770,19 +4447,6 @@
         "node": ">=10.13.0"
       }
     },
-    "node_modules/globals": {
-      "version": "17.4.0",
-      "resolved": "https://registry.npmjs.org/globals/-/globals-17.4.0.tgz",
-      "integrity": "sha512-hjrNztw/VajQwOLsMNT1cbJiH2muO3OROCHnbehc8eY5JyD2gqz4AcMHPqgaOR59DjgUjYAYLeH699g/eWi2jw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
     "node_modules/graceful-fs": {
       "version": "4.2.11",
       "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
@@ -3915,27 +4579,11 @@
       "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">= 4"
       }
     },
-    "node_modules/import-fresh": {
-      "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
-      "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "parent-module": "^1.0.0",
-        "resolve-from": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
     "node_modules/import-lazy": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/import-lazy/-/import-lazy-4.0.0.tgz",
@@ -3952,6 +4600,7 @@
       "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=0.8.19"
       }
@@ -3985,6 +4634,7 @@
       "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=0.10.0"
       }
@@ -4005,6 +4655,7 @@
       "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "is-extglob": "^2.1.1"
       },
@@ -4087,39 +4738,29 @@
         "node": ">=14"
       }
     },
-    "node_modules/js-yaml": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
-      "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "argparse": "^2.0.1"
-      },
-      "bin": {
-        "js-yaml": "bin/js-yaml.js"
-      }
-    },
     "node_modules/json-buffer": {
       "version": "3.0.1",
       "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
       "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/json-schema-traverse": {
       "version": "0.4.1",
       "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
       "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/json-stable-stringify-without-jsonify": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
       "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/jsonfile": {
       "version": "6.1.0",
@@ -4140,6 +4781,7 @@
       "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "json-buffer": "3.0.1"
       }
@@ -4157,6 +4799,7 @@
       "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "prelude-ls": "^1.2.1",
         "type-check": "~0.4.0"
@@ -4460,6 +5103,7 @@
       "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "p-locate": "^5.0.0"
       },
@@ -4477,13 +5121,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/lodash.merge": {
-      "version": "4.6.2",
-      "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
-      "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/lru-cache": {
       "version": "10.4.3",
       "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
@@ -4727,6 +5364,16 @@
         "pathe": "^2.0.1"
       }
     },
+    "node_modules/mrmime": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/mrmime/-/mrmime-2.0.1.tgz",
+      "integrity": "sha512-Y3wQdFg2Va6etvQ5I82yUhGdsKrcYox6p7FfL1LbK2J4V01F9TGlepTIhnK24t7koZibmg82KGglhA1XK5IsLQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      }
+    },
     "node_modules/ms": {
       "version": "2.1.3",
       "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
@@ -4764,7 +5411,8 @@
       "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
       "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/nopt": {
       "version": "7.2.1",
@@ -4782,19 +5430,6 @@
         "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
       }
     },
-    "node_modules/nth-check": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.1.1.tgz",
-      "integrity": "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "boolbase": "^1.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/fb55/nth-check?sponsor=1"
-      }
-    },
     "node_modules/obug": {
       "version": "2.1.1",
       "resolved": "https://registry.npmjs.org/obug/-/obug-2.1.1.tgz",
@@ -4824,6 +5459,7 @@
       "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "deep-is": "^0.1.3",
         "fast-levenshtein": "^2.0.6",
@@ -4836,12 +5472,116 @@
         "node": ">= 0.8.0"
       }
     },
+    "node_modules/oxfmt": {
+      "version": "0.41.0",
+      "resolved": "https://registry.npmjs.org/oxfmt/-/oxfmt-0.41.0.tgz",
+      "integrity": "sha512-sKLdJZdQ3bw6x9qKiT7+eID4MNEXlDHf5ZacfIircrq6Qwjk0L6t2/JQlZZrVHTXJawK3KaMuBoJnEJPcqCEdg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tinypool": "2.1.0"
+      },
+      "bin": {
+        "oxfmt": "bin/oxfmt"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/Boshen"
+      },
+      "optionalDependencies": {
+        "@oxfmt/binding-android-arm-eabi": "0.41.0",
+        "@oxfmt/binding-android-arm64": "0.41.0",
+        "@oxfmt/binding-darwin-arm64": "0.41.0",
+        "@oxfmt/binding-darwin-x64": "0.41.0",
+        "@oxfmt/binding-freebsd-x64": "0.41.0",
+        "@oxfmt/binding-linux-arm-gnueabihf": "0.41.0",
+        "@oxfmt/binding-linux-arm-musleabihf": "0.41.0",
+        "@oxfmt/binding-linux-arm64-gnu": "0.41.0",
+        "@oxfmt/binding-linux-arm64-musl": "0.41.0",
+        "@oxfmt/binding-linux-ppc64-gnu": "0.41.0",
+        "@oxfmt/binding-linux-riscv64-gnu": "0.41.0",
+        "@oxfmt/binding-linux-riscv64-musl": "0.41.0",
+        "@oxfmt/binding-linux-s390x-gnu": "0.41.0",
+        "@oxfmt/binding-linux-x64-gnu": "0.41.0",
+        "@oxfmt/binding-linux-x64-musl": "0.41.0",
+        "@oxfmt/binding-openharmony-arm64": "0.41.0",
+        "@oxfmt/binding-win32-arm64-msvc": "0.41.0",
+        "@oxfmt/binding-win32-ia32-msvc": "0.41.0",
+        "@oxfmt/binding-win32-x64-msvc": "0.41.0"
+      }
+    },
+    "node_modules/oxlint": {
+      "version": "1.56.0",
+      "resolved": "https://registry.npmjs.org/oxlint/-/oxlint-1.56.0.tgz",
+      "integrity": "sha512-Q+5Mj5PVaH/R6/fhMMFzw4dT+KPB+kQW4kaL8FOIq7tfhlnEVp6+3lcWqFruuTNlUo9srZUW3qH7Id4pskeR6g==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "oxlint": "bin/oxlint"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/Boshen"
+      },
+      "optionalDependencies": {
+        "@oxlint/binding-android-arm-eabi": "1.56.0",
+        "@oxlint/binding-android-arm64": "1.56.0",
+        "@oxlint/binding-darwin-arm64": "1.56.0",
+        "@oxlint/binding-darwin-x64": "1.56.0",
+        "@oxlint/binding-freebsd-x64": "1.56.0",
+        "@oxlint/binding-linux-arm-gnueabihf": "1.56.0",
+        "@oxlint/binding-linux-arm-musleabihf": "1.56.0",
+        "@oxlint/binding-linux-arm64-gnu": "1.56.0",
+        "@oxlint/binding-linux-arm64-musl": "1.56.0",
+        "@oxlint/binding-linux-ppc64-gnu": "1.56.0",
+        "@oxlint/binding-linux-riscv64-gnu": "1.56.0",
+        "@oxlint/binding-linux-riscv64-musl": "1.56.0",
+        "@oxlint/binding-linux-s390x-gnu": "1.56.0",
+        "@oxlint/binding-linux-x64-gnu": "1.56.0",
+        "@oxlint/binding-linux-x64-musl": "1.56.0",
+        "@oxlint/binding-openharmony-arm64": "1.56.0",
+        "@oxlint/binding-win32-arm64-msvc": "1.56.0",
+        "@oxlint/binding-win32-ia32-msvc": "1.56.0",
+        "@oxlint/binding-win32-x64-msvc": "1.56.0"
+      },
+      "peerDependencies": {
+        "oxlint-tsgolint": ">=0.15.0"
+      },
+      "peerDependenciesMeta": {
+        "oxlint-tsgolint": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/oxlint-tsgolint": {
+      "version": "0.17.1",
+      "resolved": "https://registry.npmjs.org/oxlint-tsgolint/-/oxlint-tsgolint-0.17.1.tgz",
+      "integrity": "sha512-gJc7hb1ZQFbWjRDYpu1XG+5IRdr1S/Jz/W2ohcpaqIXuDmHU0ujGiM0x05J0nIfwMF3HOEcANi/+j6T0Uecdpg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "tsgolint": "bin/tsgolint.js"
+      },
+      "optionalDependencies": {
+        "@oxlint-tsgolint/darwin-arm64": "0.17.1",
+        "@oxlint-tsgolint/darwin-x64": "0.17.1",
+        "@oxlint-tsgolint/linux-arm64": "0.17.1",
+        "@oxlint-tsgolint/linux-x64": "0.17.1",
+        "@oxlint-tsgolint/win32-arm64": "0.17.1",
+        "@oxlint-tsgolint/win32-x64": "0.17.1"
+      }
+    },
     "node_modules/p-limit": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
       "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "yocto-queue": "^0.1.0"
       },
@@ -4858,6 +5598,7 @@
       "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "p-limit": "^3.0.2"
       },
@@ -4875,19 +5616,6 @@
       "dev": true,
       "license": "BlueOak-1.0.0"
     },
-    "node_modules/parent-module": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
-      "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "callsites": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=6"
-      }
-    },
     "node_modules/path-browserify": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-1.0.1.tgz",
@@ -4901,6 +5629,7 @@
       "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=8"
       }
@@ -4971,6 +5700,19 @@
         "url": "https://github.com/sponsors/jonschlinkert"
       }
     },
+    "node_modules/pixelmatch": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/pixelmatch/-/pixelmatch-7.1.0.tgz",
+      "integrity": "sha512-1wrVzJ2STrpmONHKBy228LM1b84msXDUoAzVEl0R8Mz4Ce6EPr+IVtxm8+yvrqLYMHswREkjYFaMxnyGnaY3Ng==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "pngjs": "^7.0.0"
+      },
+      "bin": {
+        "pixelmatch": "bin/pixelmatch"
+      }
+    },
     "node_modules/pkg-types": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/pkg-types/-/pkg-types-2.1.0.tgz",
@@ -4983,6 +5725,16 @@
         "pathe": "^2.0.3"
       }
     },
+    "node_modules/pngjs": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/pngjs/-/pngjs-7.0.0.tgz",
+      "integrity": "sha512-LKWqWJRhstyYo9pGvgor/ivk2w94eSjE3RGVuzLGlr3NmD8bf7RcYGze1mNdEHRP6TRP6rMuDHk5t44hnTRyow==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.19.0"
+      }
+    },
     "node_modules/postcss": {
       "version": "8.5.8",
       "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.8.tgz",
@@ -5011,20 +5763,6 @@
         "node": "^10 || ^12 || >=14"
       }
     },
-    "node_modules/postcss-selector-parser": {
-      "version": "6.1.2",
-      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz",
-      "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "cssesc": "^3.0.0",
-        "util-deprecate": "^1.0.2"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
     "node_modules/preact": {
       "version": "10.25.4",
       "resolved": "https://registry.npmjs.org/preact/-/preact-10.25.4.tgz",
@@ -5042,6 +5780,7 @@
       "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">= 0.8.0"
       }
@@ -5160,16 +5899,6 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/resolve-from": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
-      "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=4"
-      }
-    },
     "node_modules/rfdc": {
       "version": "1.4.1",
       "resolved": "https://registry.npmjs.org/rfdc/-/rfdc-1.4.1.tgz",
@@ -5362,6 +6091,21 @@
         "url": "https://github.com/sponsors/isaacs"
       }
     },
+    "node_modules/sirv": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/sirv/-/sirv-3.0.2.tgz",
+      "integrity": "sha512-2wcC/oGxHis/BoHkkPwldgiPSYcpZK3JU28WoMVv55yHJgcZ8rlXvuG9iZggz+sU1d4bRgIGASwyWqjxu3FM0g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@polka/url": "^1.0.0-next.24",
+        "mrmime": "^2.0.0",
+        "totalist": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/source-map": {
       "version": "0.6.1",
       "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
@@ -5578,19 +6322,6 @@
         "node": ">=16"
       }
     },
-    "node_modules/supports-color": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
-      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "has-flag": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/supports-preserve-symlinks-flag": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
@@ -5645,6 +6376,16 @@
         "url": "https://github.com/sponsors/SuperchupuDev"
       }
     },
+    "node_modules/tinypool": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-2.1.0.tgz",
+      "integrity": "sha512-Pugqs6M0m7Lv1I7FtxN4aoyToKg1C4tu+/381vH35y8oENM/Ai7f7C4StcoK4/+BSw9ebcS8jRiVrORFKCALLw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^20.0.0 || >=22.0.0"
+      }
+    },
     "node_modules/tinyrainbow": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-3.1.0.tgz",
@@ -5655,6 +6396,16 @@
         "node": ">=14.0.0"
       }
     },
+    "node_modules/totalist": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/totalist/-/totalist-3.0.1.tgz",
+      "integrity": "sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/trim-lines": {
       "version": "3.0.1",
       "resolved": "https://registry.npmjs.org/trim-lines/-/trim-lines-3.0.1.tgz",
@@ -5666,19 +6417,6 @@
         "url": "https://github.com/sponsors/wooorm"
       }
     },
-    "node_modules/ts-api-utils": {
-      "version": "2.4.0",
-      "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-2.4.0.tgz",
-      "integrity": "sha512-3TaVTaAv2gTiMB35i3FiGJaRfwb3Pyn/j3m/bfAvGe8FB7CF6u+LMYqYlDh7reQf7UNvoTvdfAqHGmPGOSsPmA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18.12"
-      },
-      "peerDependencies": {
-        "typescript": ">=4.8.4"
-      }
-    },
     "node_modules/tslib": {
       "version": "2.8.1",
       "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
@@ -5693,6 +6431,7 @@
       "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "prelude-ls": "^1.2.1"
       },
@@ -5700,19 +6439,6 @@
         "node": ">= 0.8.0"
       }
     },
-    "node_modules/type-fest": {
-      "version": "0.20.2",
-      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz",
-      "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==",
-      "dev": true,
-      "license": "(MIT OR CC0-1.0)",
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
     "node_modules/typedoc": {
       "version": "0.28.17",
       "resolved": "https://registry.npmjs.org/typedoc/-/typedoc-0.28.17.tgz",
@@ -5887,13 +6613,6 @@
         "punycode": "^2.1.0"
       }
     },
-    "node_modules/util-deprecate": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
-      "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/valibot": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/valibot/-/valibot-1.0.0.tgz",
@@ -6045,6 +6764,50 @@
         }
       }
     },
+    "node_modules/vite-plus": {
+      "version": "0.1.13",
+      "resolved": "https://registry.npmjs.org/vite-plus/-/vite-plus-0.1.13.tgz",
+      "integrity": "sha512-DP87+eRFhYYDdcjm2nr3DOKt0cv6mIXCNXn+zc59YHgR0Wh7uL2E/55mjusJ7ajwcXenpGW+c4KPeoqhQAbhxg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@oxc-project/types": "=0.120.0",
+        "@voidzero-dev/vite-plus-core": "0.1.13",
+        "@voidzero-dev/vite-plus-test": "0.1.13",
+        "cac": "^7.0.0",
+        "cross-spawn": "^7.0.5",
+        "oxfmt": "=0.41.0",
+        "oxlint": "=1.56.0",
+        "oxlint-tsgolint": "=0.17.1",
+        "picocolors": "^1.1.1"
+      },
+      "bin": {
+        "oxfmt": "bin/oxfmt",
+        "oxlint": "bin/oxlint",
+        "vp": "bin/vp"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "optionalDependencies": {
+        "@voidzero-dev/vite-plus-darwin-arm64": "0.1.13",
+        "@voidzero-dev/vite-plus-darwin-x64": "0.1.13",
+        "@voidzero-dev/vite-plus-linux-arm64-gnu": "0.1.13",
+        "@voidzero-dev/vite-plus-linux-x64-gnu": "0.1.13",
+        "@voidzero-dev/vite-plus-win32-arm64-msvc": "0.1.13",
+        "@voidzero-dev/vite-plus-win32-x64-msvc": "0.1.13"
+      }
+    },
+    "node_modules/vite-plus/node_modules/@oxc-project/types": {
+      "version": "0.120.0",
+      "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.120.0.tgz",
+      "integrity": "sha512-k1YNu55DuvAip/MGE1FTsIuU3FUCn6v/ujG9V7Nq5Df/kX2CWb13hhwD0lmJGMGqE+bE1MXvv9SZVnMzEXlWcg==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/Boshen"
+      }
+    },
     "node_modules/vitepress": {
       "version": "1.6.4",
       "resolved": "https://registry.npmjs.org/vitepress/-/vitepress-1.6.4.tgz",
@@ -6762,79 +7525,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/vue-eslint-parser": {
-      "version": "9.4.3",
-      "resolved": "https://registry.npmjs.org/vue-eslint-parser/-/vue-eslint-parser-9.4.3.tgz",
-      "integrity": "sha512-2rYRLWlIpaiN8xbPiDyXZXRgLGOtWxERV7ND5fFAv5qo1D2N9Fu9MNajBNc6o13lZ+24DAWCkQCvj4klgmcITg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "debug": "^4.3.4",
-        "eslint-scope": "^7.1.1",
-        "eslint-visitor-keys": "^3.3.0",
-        "espree": "^9.3.1",
-        "esquery": "^1.4.0",
-        "lodash": "^4.17.21",
-        "semver": "^7.3.6"
-      },
-      "engines": {
-        "node": "^14.17.0 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/mysticatea"
-      },
-      "peerDependencies": {
-        "eslint": ">=6.0.0"
-      }
-    },
-    "node_modules/vue-eslint-parser/node_modules/eslint-scope": {
-      "version": "7.2.2",
-      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.2.2.tgz",
-      "integrity": "sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "esrecurse": "^4.3.0",
-        "estraverse": "^5.2.0"
-      },
-      "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
-    },
-    "node_modules/vue-eslint-parser/node_modules/eslint-visitor-keys": {
-      "version": "3.4.3",
-      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
-      "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
-    },
-    "node_modules/vue-eslint-parser/node_modules/espree": {
-      "version": "9.6.1",
-      "resolved": "https://registry.npmjs.org/espree/-/espree-9.6.1.tgz",
-      "integrity": "sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "acorn": "^8.9.0",
-        "acorn-jsx": "^5.3.2",
-        "eslint-visitor-keys": "^3.4.1"
-      },
-      "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
-    },
     "node_modules/vue-tsc": {
       "version": "3.2.5",
       "resolved": "https://registry.npmjs.org/vue-tsc/-/vue-tsc-3.2.5.tgz",
@@ -6924,6 +7614,7 @@
       "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=0.10.0"
       }
@@ -7045,16 +7736,6 @@
         }
       }
     },
-    "node_modules/xml-name-validator": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-4.0.0.tgz",
-      "integrity": "sha512-ICP2e+jsHvAj2E2lIHxa5tjXRlKDJo4IdvPvCXbXQGdzSfmSpNVyIKMvoZHjDY9DP0zV17iI85o90vRFXNccRw==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=12"
-      }
-    },
     "node_modules/yallist": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
@@ -7081,6 +7762,7 @@
       "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=10"
       },
diff --git a/package.json b/package.json
index 7d987f4e..5170f406 100644
--- a/package.json
+++ b/package.json
@@ -1,37 +1,24 @@
 {
   "name": "@kitbag/router",
-  "private": false,
   "version": "0.24.1",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/kitbagjs/router/issues"
-  },
+  "private": false,
   "keywords": [
-    "typescript",
     "router",
-    "vue",
-    "vue-router",
+    "typed",
     "types",
-    "typed"
+    "typescript",
+    "vue",
+    "vue-router"
   ],
   "homepage": "https://github.com/kitbagjs/router#readme",
-  "scripts": {
-    "build": "vite build",
-    "build:watch": "vite build --watch --minify=false",
-    "dev": "vite build --watch --minify=false",
-    "test": "vitest",
-    "lint": "eslint ./src",
-    "lint:fix": "eslint ./src --fix",
-    "types": "vue-tsc --noEmit",
-    "docs:dev": "vitepress dev docs",
-    "docs:build": "vitepress build docs",
-    "docs:preview": "vitepress preview docs",
-    "docs:generate": "vite build && typedoc && sleep 5 && node ./scripts/api.js"
+  "bugs": {
+    "url": "https://github.com/kitbagjs/router/issues"
   },
-  "type": "module",
+  "license": "MIT",
   "files": [
     "dist"
   ],
+  "type": "module",
   "main": "./dist/kitbag-router.umd.cjs",
   "module": "./dist/kitbag-router.js",
   "types": "./dist/kitbag-router.d.ts",
@@ -41,22 +28,39 @@
       "require": "./dist/kitbag-router.umd.cjs"
     }
   },
+  "scripts": {
+    "build": "vp build",
+    "build:watch": "vp build --watch --minify=false",
+    "dev": "vp build --watch --minify=false",
+    "test": "vp test",
+    "lint": "vp lint ./src",
+    "lint:fix": "vp lint ./src --fix",
+    "types": "vue-tsc --noEmit",
+    "docs:dev": "vitepress dev docs",
+    "docs:build": "vitepress build docs",
+    "docs:preview": "vitepress preview docs",
+    "docs:generate": "vp build && typedoc && sleep 5 && node ./scripts/api.js",
+    "prepare": "vp config"
+  },
+  "dependencies": {
+    "@standard-schema/spec": "^1.0.0",
+    "@vue/devtools-api": "^8.0.7"
+  },
   "devDependencies": {
-    "@kitbag/eslint-config": "1.0.2",
+    "@stylistic/eslint-plugin": "^5.10.0",
     "@vitejs/plugin-vue": "^6.0.5",
     "@vue/test-utils": "^2.4.6",
-    "eslint": "^9.39.4",
-    "globals": "^17.4.0",
     "happy-dom": "^20.8.4",
     "typedoc": "^0.28.17",
     "typedoc-plugin-markdown": "^4.11.0",
     "typedoc-vitepress-theme": "^1.1.2",
     "typescript": "^5.9.3",
     "valibot": "^1.0.0",
-    "vite": "^8.0.0",
+    "vite": "npm:@voidzero-dev/vite-plus-core@latest",
     "vite-plugin-dts": "^4.5.4",
+    "vite-plus": "latest",
     "vitepress": "^1.6.4",
-    "vitest": "^4.1.0",
+    "vitest": "npm:@voidzero-dev/vite-plus-test@latest",
     "vue-tsc": "^3.2.5",
     "zod": "4.0.0"
   },
@@ -69,8 +73,9 @@
       "optional": true
     }
   },
-  "dependencies": {
-    "@standard-schema/spec": "^1.0.0",
-    "@vue/devtools-api": "^8.0.7"
-  }
+  "overrides": {
+    "vite": "npm:@voidzero-dev/vite-plus-core@latest",
+    "vitest": "npm:@voidzero-dev/vite-plus-test@latest"
+  },
+  "packageManager": "npm@11.12.0"
 }
diff --git a/src/.DS_Store b/src/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..d94ae9c73dfa6504c490a6a4fc68fb779b71597b
GIT binary patch
literal 6148
zcmeHK!D`z;5S?|LT5bsV(14GETmx0p5HP(6$N7P%B!{#(RwP<cMQbd%A{c|t=@0cw
z@;!aCyD>@JTyiMI%)rbW&(27ix3KFWA~l>RABcKH<Utu*U6{WJud}X6%SE<;$~;3;
zK`FGNaxGf||04sucW>#MG~Lh?cC~*$qgj#b;v3enx3rBty+uY!Wn7ojIM*?vzvF41
zl~oYjtJYR~`%TC5Iy;@O(RW=()ufu2!^!NDe|^?Ek01O=e4eHCxcBZv7u6&y(wQm9
zk`yUlF0vxg^-#}?q%^gWUGTbHZ`|uI7Kel51OF%(ED!v};4pyy@p!rPyuJPRpU%cV
z@|!~6;oBgJzno>)!pi=F_o$<1y{^*45e9?-VPHcUaHpfUv!VS-Tf%@a@OlRLeDI-+
zp~J?aIXYm>2mov&Yy>{f5?tdu3>`KWu>w)H6lhD88!?nEN8ERLp~J?aEhpuM59Qvh
z+=Qac+wpwgq>~CQiWLTgfu{`c><8)b{eSxM{BM%P2m`{vW-_4Kqi8flZ|-hg>yqzU
sA9@94;k?G;ssxU?ijm7#aUW^~ai1Mv=&-Sf2t@t}7#hR~1OJqPKf4oAp#T5?

literal 0
HcmV?d00001

diff --git a/src/components/routerLink.browser.spec.ts b/src/components/routerLink.browser.spec.ts
index e2791cdb..e98a53af 100644
--- a/src/components/routerLink.browser.spec.ts
+++ b/src/components/routerLink.browser.spec.ts
@@ -1,37 +1,37 @@
-import { flushPromises, mount } from '@vue/test-utils'
-import { describe, expect, test, vi } from 'vitest'
-import { defineAsyncComponent, h, nextTick, ref } from 'vue'
-import echo from '@/components/echo'
-import { createRoute } from '@/services/createRoute'
-import { createRouter } from '@/services/createRouter'
-import { PrefetchConfig } from '@/types/prefetch'
-import { getPrefetchConfigValue } from '@/utilities/prefetch'
-import { component } from '@/utilities/testHelpers'
-import { visibilityObserverKey } from '@/compositions/useVisibilityObserver'
-import { VisibilityObserver } from '@/services/createVisibilityObserver'
-import { UrlString } from '@/types/urlString'
-import { RouterPushOptions } from '@/types/routerPush'
-import { RouterLink } from '@/main'
-
-test('renders an anchor tag with the correct href and slot content', () => {
-  const path = '/path/[paramName]'
-  const paramValue = 'ABC'
-  const content = 'hello world'
-  const href = new URL(path.replace('[paramName]', paramValue), window.location.origin)
+import { flushPromises, mount } from "@vue/test-utils";
+import { describe, expect, test, vi } from "vite-plus/test";
+import { defineAsyncComponent, h, nextTick, ref } from "vue";
+import echo from "@/components/echo";
+import { createRoute } from "@/services/createRoute";
+import { createRouter } from "@/services/createRouter";
+import { PrefetchConfig } from "@/types/prefetch";
+import { getPrefetchConfigValue } from "@/utilities/prefetch";
+import { component } from "@/utilities/testHelpers";
+import { visibilityObserverKey } from "@/compositions/useVisibilityObserver";
+import { VisibilityObserver } from "@/services/createVisibilityObserver";
+import { UrlString } from "@/types/urlString";
+import { RouterPushOptions } from "@/types/routerPush";
+import { RouterLink } from "@/main";
+
+test("renders an anchor tag with the correct href and slot content", () => {
+  const path = "/path/[paramName]";
+  const paramValue = "ABC";
+  const content = "hello world";
+  const href = new URL(path.replace("[paramName]", paramValue), window.location.origin);
 
   const route = createRoute({
-    name: 'parent',
+    name: "parent",
     path,
     component,
-  })
+  });
 
   const router = createRouter([route], {
     initialUrl: path,
-  })
+  });
 
   const wrapper = mount(RouterLink, {
     props: {
-      to: (resolve) => resolve('parent', { paramName: paramValue }),
+      to: (resolve) => resolve("parent", { paramName: paramValue }),
     },
     slots: {
       default: content,
@@ -39,924 +39,980 @@ test('renders an anchor tag with the correct href and slot content', () => {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  const anchor = wrapper.find('a')
-  const element = anchor.element as HTMLAnchorElement
-  expect(element).toBeInstanceOf(HTMLAnchorElement)
-  expect(element.href).toBe(href.toString())
-  expect(element.innerHTML).toBe(content)
-})
+  const anchor = wrapper.find("a");
+  const element = anchor.element as HTMLAnchorElement;
+  expect(element).toBeInstanceOf(HTMLAnchorElement);
+  expect(element.href).toBe(href.toString());
+  expect(element.innerHTML).toBe(content);
+});
 
-test('calls router.push with url and push options from props', async () => {
+test("calls router.push with url and push options from props", async () => {
   const propOptions: RouterPushOptions = {
     replace: true,
     query: {
-      foo: 'bar',
+      foo: "bar",
     },
-    hash: 'hash',
+    hash: "hash",
     state: {
-      zoo: 'jar',
+      zoo: "jar",
     },
-  }
-
-  const router = createRouter([
-    createRoute({
-      name: 'routeA',
-      path: '/routeA',
-      component: { render: () => h(RouterLink, { to: (resolve) => resolve('routeB'), ...propOptions }) },
-    }),
-    createRoute({
-      name: 'routeB',
-      path: '/routeB',
-      component,
-    }),
-  ], {
-    initialUrl: '/routeA',
-  })
+  };
+
+  const router = createRouter(
+    [
+      createRoute({
+        name: "routeA",
+        path: "/routeA",
+        component: {
+          render: () => h(RouterLink, { to: (resolve) => resolve("routeB"), ...propOptions }),
+        },
+      }),
+      createRoute({
+        name: "routeB",
+        path: "/routeB",
+        component,
+      }),
+    ],
+    {
+      initialUrl: "/routeA",
+    },
+  );
 
-  await router.start()
+  await router.start();
 
-  const spy = vi.spyOn(router, 'push')
+  const spy = vi.spyOn(router, "push");
 
   const root = {
-    template: '<RouterView />',
-  }
+    template: "<RouterView />",
+  };
 
   const wrapper = mount(root, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  wrapper.find('a').trigger('click')
+  wrapper.find("a").trigger("click");
 
-  const [, pushOptions] = spy.mock.lastCall ?? []
+  const [, pushOptions] = spy.mock.lastCall ?? [];
 
   expect(pushOptions).toMatchObject({
     replace: true,
     query: new URLSearchParams({
-      foo: 'bar',
+      foo: "bar",
     }),
-    hash: 'hash',
+    hash: "hash",
     state: {
-      zoo: 'jar',
+      zoo: "jar",
     },
-  })
-})
+  });
+});
 
-test('calls router.push with url and push options from resolve callback', async () => {
+test("calls router.push with url and push options from resolve callback", async () => {
   const resolveOptions: RouterPushOptions = {
     query: {
-      foo: 'bar',
+      foo: "bar",
     },
-    hash: 'hash',
+    hash: "hash",
     state: {
-      zoo: 'jar',
+      zoo: "jar",
     },
-  }
-
-  const router = createRouter([
-    createRoute({
-      name: 'routeA',
-      path: '/routeA',
-      component: { render: () => h(RouterLink, { to: (resolve) => resolve('routeB', {}, resolveOptions) }) },
-    }),
-    createRoute({
-      name: 'routeB',
-      path: '/routeB',
-      state: {
-        zoo: String,
-      },
-      component,
-    }),
-  ], {
-    initialUrl: '/routeA',
-  })
+  };
+
+  const router = createRouter(
+    [
+      createRoute({
+        name: "routeA",
+        path: "/routeA",
+        component: {
+          render: () => h(RouterLink, { to: (resolve) => resolve("routeB", {}, resolveOptions) }),
+        },
+      }),
+      createRoute({
+        name: "routeB",
+        path: "/routeB",
+        state: {
+          zoo: String,
+        },
+        component,
+      }),
+    ],
+    {
+      initialUrl: "/routeA",
+    },
+  );
 
-  await router.start()
+  await router.start();
 
   const root = {
-    template: '<RouterView />',
-  }
+    template: "<RouterView />",
+  };
 
   const wrapper = mount(root, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  wrapper.find('a').trigger('click')
+  wrapper.find("a").trigger("click");
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(router.route.query.toString()).toBe('foo=bar')
-  expect(router.route.hash).toBe('#hash')
-  expect(router.route.state).toMatchObject({ zoo: 'jar' })
-})
+  expect(router.route.query.toString()).toBe("foo=bar");
+  expect(router.route.hash).toBe("#hash");
+  expect(router.route.state).toMatchObject({ zoo: "jar" });
+});
 
-test('given push options from both resolve callback and props, combines query and state, overrides hash and replace', async () => {
+test("given push options from both resolve callback and props, combines query and state, overrides hash and replace", async () => {
   const propOptions: RouterPushOptions = {
     query: {
-      prop: 'foo',
+      prop: "foo",
     },
-    hash: 'propHash',
+    hash: "propHash",
     state: {
-      prop: 'jar',
+      prop: "jar",
     },
-  }
+  };
 
   const resolveOptions: RouterPushOptions = {
     query: {
-      resolve: 'foo',
+      resolve: "foo",
     },
-    hash: 'resolveHash',
+    hash: "resolveHash",
     state: {
-      resolve: 'jar',
+      resolve: "jar",
     },
-  }
-
-  const router = createRouter([
-    createRoute({
-      name: 'routeA',
-      path: '/routeA',
-      component: { render: () => h(RouterLink, { to: (resolve) => resolve('routeB', {}, resolveOptions), ...propOptions }) },
-    }),
-    createRoute({
-      name: 'routeB',
-      path: '/routeB',
-      state: {
-        prop: String,
-        resolve: String,
-      },
-      component,
-    }),
-  ], {
-    initialUrl: '/routeA',
-  })
+  };
+
+  const router = createRouter(
+    [
+      createRoute({
+        name: "routeA",
+        path: "/routeA",
+        component: {
+          render: () =>
+            h(RouterLink, {
+              to: (resolve) => resolve("routeB", {}, resolveOptions),
+              ...propOptions,
+            }),
+        },
+      }),
+      createRoute({
+        name: "routeB",
+        path: "/routeB",
+        state: {
+          prop: String,
+          resolve: String,
+        },
+        component,
+      }),
+    ],
+    {
+      initialUrl: "/routeA",
+    },
+  );
 
-  await router.start()
+  await router.start();
 
   const root = {
-    template: '<RouterView />',
-  }
+    template: "<RouterView />",
+  };
 
   const wrapper = mount(root, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  wrapper.find('a').trigger('click')
+  wrapper.find("a").trigger("click");
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(router.route.query.toString()).toBe('resolve=foo&prop=foo')
-  expect(router.route.hash).toBe('#propHash')
+  expect(router.route.query.toString()).toBe("resolve=foo&prop=foo");
+  expect(router.route.hash).toBe("#propHash");
   expect(router.route.state).toMatchObject({
-    resolve: 'jar',
-    prop: 'jar',
-  })
-})
+    resolve: "jar",
+    prop: "jar",
+  });
+});
 
 test.each([
-  { name: 'metaKey', triggerOptions: { metaKey: true } },
-  { name: 'ctrlKey', triggerOptions: { ctrlKey: true } },
-  { name: 'shiftKey', triggerOptions: { shiftKey: true } },
-  { name: 'altKey', triggerOptions: { altKey: true } },
-])('does not call router.push when $name is held during click', async ({ triggerOptions }) => {
-  const router = createRouter([
-    createRoute({
-      name: 'routeA',
-      path: '/routeA',
-      component: { render: () => h(RouterLink, { to: (resolve) => resolve('routeB') }) },
-    }),
-    createRoute({
-      name: 'routeB',
-      path: '/routeB',
-      component,
-    }),
-  ], {
-    initialUrl: '/routeA',
-  })
+  { name: "metaKey", triggerOptions: { metaKey: true } },
+  { name: "ctrlKey", triggerOptions: { ctrlKey: true } },
+  { name: "shiftKey", triggerOptions: { shiftKey: true } },
+  { name: "altKey", triggerOptions: { altKey: true } },
+])("does not call router.push when $name is held during click", async ({ triggerOptions }) => {
+  const router = createRouter(
+    [
+      createRoute({
+        name: "routeA",
+        path: "/routeA",
+        component: { render: () => h(RouterLink, { to: (resolve) => resolve("routeB") }) },
+      }),
+      createRoute({
+        name: "routeB",
+        path: "/routeB",
+        component,
+      }),
+    ],
+    {
+      initialUrl: "/routeA",
+    },
+  );
 
-  await router.start()
+  await router.start();
 
-  const spy = vi.spyOn(router, 'push')
+  const spy = vi.spyOn(router, "push");
 
   const root = {
-    template: '<RouterView />',
-  }
+    template: "<RouterView />",
+  };
 
   const wrapper = mount(root, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  wrapper.find('a').trigger('click', triggerOptions)
+  wrapper.find("a").trigger("click", triggerOptions);
 
-  expect(spy).not.toHaveBeenCalled()
-})
+  expect(spy).not.toHaveBeenCalled();
+});
 
-test('does not call router.push when middle mouse button is clicked', async () => {
-  const router = createRouter([
-    createRoute({
-      name: 'routeA',
-      path: '/routeA',
-      component: { render: () => h(RouterLink, { to: (resolve) => resolve('routeB') }) },
-    }),
-    createRoute({
-      name: 'routeB',
-      path: '/routeB',
-      component,
-    }),
-  ], {
-    initialUrl: '/routeA',
-  })
+test("does not call router.push when middle mouse button is clicked", async () => {
+  const router = createRouter(
+    [
+      createRoute({
+        name: "routeA",
+        path: "/routeA",
+        component: { render: () => h(RouterLink, { to: (resolve) => resolve("routeB") }) },
+      }),
+      createRoute({
+        name: "routeB",
+        path: "/routeB",
+        component,
+      }),
+    ],
+    {
+      initialUrl: "/routeA",
+    },
+  );
 
-  await router.start()
+  await router.start();
 
-  const spy = vi.spyOn(router, 'push')
+  const spy = vi.spyOn(router, "push");
 
   const root = {
-    template: '<RouterView />',
-  }
+    template: "<RouterView />",
+  };
 
   const wrapper = mount(root, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  wrapper.find('a').trigger('click', { button: 1 })
+  wrapper.find("a").trigger("click", { button: 1 });
 
-  expect(spy).not.toHaveBeenCalled()
-})
+  expect(spy).not.toHaveBeenCalled();
+});
 
 test('does not call router.push when anchor has target="_blank"', async () => {
-  const router = createRouter([
-    createRoute({
-      name: 'routeA',
-      path: '/routeA',
-      component: { render: () => h(RouterLink, { to: (resolve) => resolve('routeB'), target: '_blank' }) },
-    }),
-    createRoute({
-      name: 'routeB',
-      path: '/routeB',
-      component,
-    }),
-  ], {
-    initialUrl: '/routeA',
-  })
+  const router = createRouter(
+    [
+      createRoute({
+        name: "routeA",
+        path: "/routeA",
+        component: {
+          render: () => h(RouterLink, { to: (resolve) => resolve("routeB"), target: "_blank" }),
+        },
+      }),
+      createRoute({
+        name: "routeB",
+        path: "/routeB",
+        component,
+      }),
+    ],
+    {
+      initialUrl: "/routeA",
+    },
+  );
 
-  await router.start()
+  await router.start();
 
-  const spy = vi.spyOn(router, 'push')
+  const spy = vi.spyOn(router, "push");
 
   const root = {
-    template: '<RouterView />',
-  }
+    template: "<RouterView />",
+  };
 
   const wrapper = mount(root, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  wrapper.find('a').trigger('click')
+  wrapper.find("a").trigger("click");
 
-  expect(spy).not.toHaveBeenCalled()
-})
+  expect(spy).not.toHaveBeenCalled();
+});
 
-test('to prop as Url renders and routes correctly', async () => {
+test("to prop as Url renders and routes correctly", async () => {
   const route = createRoute({
-    name: 'route',
-    path: '/route',
+    name: "route",
+    path: "/route",
     component,
-  })
-  const href = new URL('/route', window.location.origin)
+  });
+  const href = new URL("/route", window.location.origin);
 
   const router = createRouter([route], {
-    initialUrl: '/route',
-  })
+    initialUrl: "/route",
+  });
 
   const wrapper = mount(RouterLink, {
     props: {
-      to: '/route',
+      to: "/route",
     },
     slots: {
-      default: 'route',
+      default: "route",
     },
     global: {
       plugins: [router],
     },
-  })
-
-  const anchor = wrapper.find('a')
-  const element = anchor.element as HTMLAnchorElement
-  expect(element).toBeInstanceOf(HTMLAnchorElement)
-  expect(element.href).toBe(href.toString())
-  expect(element.innerHTML).toBe('route')
-
-  wrapper.find('a').trigger('click')
-
-  await flushPromises()
-
-  expect(router.route.name).toBe('route')
-})
-
-test.each<{ to: UrlString, match: boolean, exactMatch: boolean }>([
-  { to: '/parent-route', match: true, exactMatch: false },
-  { to: '/parent-route/child-route', match: true, exactMatch: true },
-  { to: '/other', match: false, exactMatch: false },
-])('isMatch and isExactMatch classes and slot props works as expected', async ({ to, match, exactMatch }) => {
-  const parentRoute = createRoute({
-    name: 'parent-route',
-    path: '/parent-route',
-  })
-
-  const childRoute = createRoute({
-    parent: parentRoute,
-    name: 'child-route',
-    path: '/child-route',
-    component,
-  })
+  });
+
+  const anchor = wrapper.find("a");
+  const element = anchor.element as HTMLAnchorElement;
+  expect(element).toBeInstanceOf(HTMLAnchorElement);
+  expect(element.href).toBe(href.toString());
+  expect(element.innerHTML).toBe("route");
+
+  wrapper.find("a").trigger("click");
+
+  await flushPromises();
+
+  expect(router.route.name).toBe("route");
+});
+
+test.each<{ to: UrlString; match: boolean; exactMatch: boolean }>([
+  { to: "/parent-route", match: true, exactMatch: false },
+  { to: "/parent-route/child-route", match: true, exactMatch: true },
+  { to: "/other", match: false, exactMatch: false },
+])(
+  "isMatch and isExactMatch classes and slot props works as expected",
+  async ({ to, match, exactMatch }) => {
+    const parentRoute = createRoute({
+      name: "parent-route",
+      path: "/parent-route",
+    });
+
+    const childRoute = createRoute({
+      parent: parentRoute,
+      name: "child-route",
+      path: "/child-route",
+      component,
+    });
 
-  const otherRoute = createRoute({
-    name: 'other',
-    path: '/other',
-    component,
-  })
+    const otherRoute = createRoute({
+      name: "other",
+      path: "/other",
+      component,
+    });
 
-  const router = createRouter([parentRoute, childRoute, otherRoute], {
-    initialUrl: '/parent-route/child-route',
-  })
+    const router = createRouter([parentRoute, childRoute, otherRoute], {
+      initialUrl: "/parent-route/child-route",
+    });
 
-  const wrapper = mount(RouterLink, {
-    props: {
-      to,
-    },
-    slots: {
-      default: '{{ params.isMatch }} {{ params.isExactMatch }}',
-    },
-    global: {
-      plugins: [router],
-    },
-  })
+    const wrapper = mount(RouterLink, {
+      props: {
+        to,
+      },
+      slots: {
+        default: "{{ params.isMatch }} {{ params.isExactMatch }}",
+      },
+      global: {
+        plugins: [router],
+      },
+    });
 
-  await router.start()
+    await router.start();
 
-  const anchor = wrapper.find('a')
+    const anchor = wrapper.find("a");
 
-  expect(anchor.text()).toBe(`${match} ${exactMatch}`)
+    expect(anchor.text()).toBe(`${match} ${exactMatch}`);
 
-  if (match) {
-    expect(anchor.classes()).toContain('router-link--match')
-  } else {
-    expect(anchor.classes()).not.toContain('router-link--match')
-  }
+    if (match) {
+      expect(anchor.classes()).toContain("router-link--match");
+    } else {
+      expect(anchor.classes()).not.toContain("router-link--match");
+    }
 
-  if (exactMatch) {
-    expect(anchor.classes()).toContain('router-link--exact-match')
-  } else {
-    expect(anchor.classes()).not.toContain('router-link--exact-match')
-  }
-})
+    if (exactMatch) {
+      expect(anchor.classes()).toContain("router-link--exact-match");
+    } else {
+      expect(anchor.classes()).not.toContain("router-link--exact-match");
+    }
+  },
+);
 
-test('isMatch correctly matches parent when sibling has the same url', async () => {
+test("isMatch correctly matches parent when sibling has the same url", async () => {
   const parentRoute = createRoute({
-    name: 'parent',
-    path: '/parent',
-  })
+    name: "parent",
+    path: "/parent",
+  });
 
   const siblingRoute = createRoute({
     parent: parentRoute,
-    name: 'sibling',
+    name: "sibling",
     component,
-  })
+  });
 
   const childRoute = createRoute({
     parent: parentRoute,
-    name: 'child',
-    path: '/child',
-    component: () => h(RouterLink, { to: (resolve) => resolve('parent') }, () => 'parent'),
-  })
+    name: "child",
+    path: "/child",
+    component: () => h(RouterLink, { to: (resolve) => resolve("parent") }, () => "parent"),
+  });
 
   const router = createRouter([parentRoute, siblingRoute, childRoute], {
-    initialUrl: '/parent/child',
-  })
+    initialUrl: "/parent/child",
+  });
 
   const root = {
-    template: '<RouterView />',
-  }
+    template: "<RouterView />",
+  };
 
   const wrapper = mount(root, {
     global: {
       plugins: [router],
     },
-  })
-
-  await router.start()
-
-  const link = wrapper.find('a')
-
-  expect(link.classes()).toContain('router-link--match')
-  expect(link.classes()).not.toContain('router-link--exact-match')
-})
-
-test.each<{ to: UrlString, active: boolean, exactActive: boolean }>([
-  { to: '/parent-route', active: true, exactActive: false },
-  { to: '/parent-route/child-route/pass', active: true, exactActive: true },
-  { to: '/parent-route/child-route/fail', active: false, exactActive: false },
-  { to: '/other', active: false, exactActive: false },
-])('isActive and isExactActive classes and slot props work as expected', async ({ to, active, exactActive }) => {
-  const parentRoute = createRoute({
-    name: 'parent-route',
-    path: '/parent-route',
-  })
-
-  const childRoute = createRoute({
-    parent: parentRoute,
-    name: 'child-route',
-    path: '/child-route/[param]',
-    component,
-  })
+  });
+
+  await router.start();
+
+  const link = wrapper.find("a");
+
+  expect(link.classes()).toContain("router-link--match");
+  expect(link.classes()).not.toContain("router-link--exact-match");
+});
+
+test.each<{ to: UrlString; active: boolean; exactActive: boolean }>([
+  { to: "/parent-route", active: true, exactActive: false },
+  { to: "/parent-route/child-route/pass", active: true, exactActive: true },
+  { to: "/parent-route/child-route/fail", active: false, exactActive: false },
+  { to: "/other", active: false, exactActive: false },
+])(
+  "isActive and isExactActive classes and slot props work as expected",
+  async ({ to, active, exactActive }) => {
+    const parentRoute = createRoute({
+      name: "parent-route",
+      path: "/parent-route",
+    });
+
+    const childRoute = createRoute({
+      parent: parentRoute,
+      name: "child-route",
+      path: "/child-route/[param]",
+      component,
+    });
 
-  const otherRoute = createRoute({
-    name: 'other',
-    path: '/other',
-    component,
-  })
+    const otherRoute = createRoute({
+      name: "other",
+      path: "/other",
+      component,
+    });
 
-  const router = createRouter([parentRoute, childRoute, otherRoute], {
-    initialUrl: '/parent-route/child-route/pass',
-  })
+    const router = createRouter([parentRoute, childRoute, otherRoute], {
+      initialUrl: "/parent-route/child-route/pass",
+    });
 
-  const wrapper = mount(RouterLink, {
-    props: {
-      to,
-    },
-    slots: {
-      default: '{{ params.isActive }} {{ params.isExactActive }}',
-    },
-    global: {
-      plugins: [router],
-    },
-  })
+    const wrapper = mount(RouterLink, {
+      props: {
+        to,
+      },
+      slots: {
+        default: "{{ params.isActive }} {{ params.isExactActive }}",
+      },
+      global: {
+        plugins: [router],
+      },
+    });
 
-  await router.start()
+    await router.start();
 
-  const anchor = wrapper.find('a')
+    const anchor = wrapper.find("a");
 
-  expect(anchor.text()).toBe(`${active} ${exactActive}`)
+    expect(anchor.text()).toBe(`${active} ${exactActive}`);
 
-  if (active) {
-    expect(anchor.classes()).toContain('router-link--active')
-  } else {
-    expect(anchor.classes()).not.toContain('router-link--active')
-  }
+    if (active) {
+      expect(anchor.classes()).toContain("router-link--active");
+    } else {
+      expect(anchor.classes()).not.toContain("router-link--active");
+    }
 
-  if (exactActive) {
-    expect(anchor.classes()).toContain('router-link--exact-active')
-  } else {
-    expect(anchor.classes()).not.toContain('router-link--exact-active')
-  }
-})
+    if (exactActive) {
+      expect(anchor.classes()).toContain("router-link--exact-active");
+    } else {
+      expect(anchor.classes()).not.toContain("router-link--exact-active");
+    }
+  },
+);
 
-test.each([
-  [true],
-  [false],
-])('isExternal slot prop works as expected', async (isExternal) => {
+test.each([[true], [false]])("isExternal slot prop works as expected", async (isExternal) => {
   const parentRoute = createRoute({
-    name: 'parent-route',
-    path: '/parent-route',
-  })
+    name: "parent-route",
+    path: "/parent-route",
+  });
 
   const childRoute = createRoute({
     parent: parentRoute,
-    name: 'child-route',
-    path: '/child-route',
+    name: "child-route",
+    path: "/child-route",
     component,
-  })
+  });
 
   const router = createRouter([parentRoute, childRoute], {
-    initialUrl: '/parent-route',
-  })
+    initialUrl: "/parent-route",
+  });
 
   const wrapper = mount(RouterLink, {
     props: {
-      to: isExternal ? 'https://vuejs.org/' : '/parent-route',
+      to: isExternal ? "https://vuejs.org/" : "/parent-route",
     },
     slots: {
-      default: '{{ params.isExternal }}',
+      default: "{{ params.isExternal }}",
     },
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  await router.start()
+  await router.start();
 
-  const anchor = wrapper.find('a')
+  const anchor = wrapper.find("a");
 
-  expect(anchor.text()).toBe(isExternal.toString())
-})
+  expect(anchor.text()).toBe(isExternal.toString());
+});
 
-describe('prefetch components', () => {
+describe("prefetch components", () => {
   test.each<PrefetchConfig | undefined>([
     undefined,
     true,
     false,
-    'eager',
-    'lazy',
+    "eager",
+    "lazy",
     { components: true },
     { components: false },
-    { components: 'eager' },
-    { components: 'lazy' },
-  ])('prefetch components respects router config when prefetch is %s', async (prefetch) => {
-    let loaded = undefined
+    { components: "eager" },
+    { components: "lazy" },
+  ])("prefetch components respects router config when prefetch is %s", async (prefetch) => {
+    let loaded = undefined;
 
     const route = createRoute({
-      name: 'route',
-      path: '/route',
+      name: "route",
+      path: "/route",
       component: defineAsyncComponent(() => {
         return new Promise((resolve) => {
-          loaded = true
-          resolve({ default: { template: 'foo' } })
-        })
+          loaded = true;
+          resolve({ default: { template: "foo" } });
+        });
       }),
-    })
+    });
 
     const router = createRouter([route], {
-      initialUrl: '/',
+      initialUrl: "/",
       prefetch,
-    })
+    });
 
     mount(RouterLink, {
       props: {
-        to: '/route',
+        to: "/route",
       },
       global: {
         plugins: [router],
       },
-    })
+    });
 
-    await flushPromises()
+    await flushPromises();
 
-    const value = getPrefetchConfigValue(prefetch, 'components')
+    const value = getPrefetchConfigValue(prefetch, "components");
 
-    if (value === 'eager') {
-      expect(loaded).toBe(true)
+    if (value === "eager") {
+      expect(loaded).toBe(true);
     } else {
-      expect(loaded).toBeUndefined()
+      expect(loaded).toBeUndefined();
     }
-  })
+  });
 
   test.each<PrefetchConfig | undefined>([
     undefined,
     true,
     false,
-    'eager',
-    'lazy',
+    "eager",
+    "lazy",
     { components: true },
     { components: false },
-    { components: 'eager' },
-    { components: 'lazy' },
-  ])('prefetch components respects route config when prefetch is %s', async (prefetch) => {
-    let loaded = undefined
+    { components: "eager" },
+    { components: "lazy" },
+  ])("prefetch components respects route config when prefetch is %s", async (prefetch) => {
+    let loaded = undefined;
 
     const route = createRoute({
-      name: 'route',
-      path: '/route',
+      name: "route",
+      path: "/route",
       prefetch,
       component: defineAsyncComponent(() => {
         return new Promise((resolve) => {
-          loaded = true
-          resolve({ default: { template: 'foo' } })
-        })
+          loaded = true;
+          resolve({ default: { template: "foo" } });
+        });
       }),
-    })
+    });
 
     const router = createRouter([route], {
-      initialUrl: '/',
-    })
+      initialUrl: "/",
+    });
 
     mount(RouterLink, {
       props: {
-        to: '/route',
+        to: "/route",
       },
       global: {
         plugins: [router],
       },
-    })
+    });
 
-    await flushPromises()
+    await flushPromises();
 
-    const value = getPrefetchConfigValue(prefetch, 'components')
+    const value = getPrefetchConfigValue(prefetch, "components");
 
-    if (value === 'eager') {
-      expect(loaded).toBe(true)
+    if (value === "eager") {
+      expect(loaded).toBe(true);
     } else {
-      expect(loaded).toBeUndefined()
+      expect(loaded).toBeUndefined();
     }
-  })
+  });
 
   test.each<PrefetchConfig | undefined>([
     undefined,
     true,
     false,
-    'eager',
-    'lazy',
+    "eager",
+    "lazy",
     { components: true },
     { components: false },
-    { components: 'eager' },
-    { components: 'lazy' },
-  ])('prefetch components respects link config when prefetch is %s', async (prefetch) => {
-    let loaded = undefined
+    { components: "eager" },
+    { components: "lazy" },
+  ])("prefetch components respects link config when prefetch is %s", async (prefetch) => {
+    let loaded = undefined;
 
     const route = createRoute({
-      name: 'route',
-      path: '/route',
+      name: "route",
+      path: "/route",
       component: defineAsyncComponent(() => {
         return new Promise((resolve) => {
-          loaded = true
-          resolve({ default: { template: 'foo' } })
-        })
+          loaded = true;
+          resolve({ default: { template: "foo" } });
+        });
       }),
-    })
+    });
 
     const router = createRouter([route], {
-      initialUrl: '/',
-    })
+      initialUrl: "/",
+    });
 
     mount(RouterLink, {
       props: {
-        to: '/route',
+        to: "/route",
         prefetch,
       },
       global: {
         plugins: [router],
       },
-    })
+    });
 
-    await flushPromises()
+    await flushPromises();
 
-    const value = getPrefetchConfigValue(prefetch, 'components')
+    const value = getPrefetchConfigValue(prefetch, "components");
 
-    if (value === 'eager') {
-      expect(loaded).toBe(true)
+    if (value === "eager") {
+      expect(loaded).toBe(true);
     } else {
-      expect(loaded).toBeUndefined()
+      expect(loaded).toBeUndefined();
     }
-  })
-})
+  });
+});
 
-describe('prefetch props', () => {
+describe("prefetch props", () => {
   test.each<PrefetchConfig | undefined>([
     undefined,
     true,
     false,
-    'eager',
-    'lazy',
+    "eager",
+    "lazy",
     { props: true },
     { props: false },
-    { props: 'eager' },
-    { props: 'lazy' },
-  ])('prefetch props respects router config when prefetch is %s', (prefetch) => {
-    const callback = vi.fn()
-
-    const route = createRoute({
-      name: 'route',
-      path: '/route',
-      component: echo,
-    }, callback)
+    { props: "eager" },
+    { props: "lazy" },
+  ])("prefetch props respects router config when prefetch is %s", (prefetch) => {
+    const callback = vi.fn();
+
+    const route = createRoute(
+      {
+        name: "route",
+        path: "/route",
+        component: echo,
+      },
+      callback,
+    );
 
     const router = createRouter([route], {
-      initialUrl: '/',
+      initialUrl: "/",
       prefetch,
-    })
+    });
 
     mount(RouterLink, {
       props: {
-        to: '/route',
+        to: "/route",
       },
       global: {
         plugins: [router],
       },
-    })
+    });
 
-    const value = getPrefetchConfigValue(prefetch, 'props')
+    const value = getPrefetchConfigValue(prefetch, "props");
 
-    if (value === 'eager') {
-      expect(callback).toHaveBeenCalledOnce()
+    if (value === "eager") {
+      expect(callback).toHaveBeenCalledOnce();
     } else {
-      expect(callback).not.toHaveBeenCalled()
+      expect(callback).not.toHaveBeenCalled();
     }
-  })
+  });
 
   test.each<PrefetchConfig | undefined>([
     undefined,
     true,
     false,
-    'eager',
-    'lazy',
+    "eager",
+    "lazy",
     { props: true },
     { props: false },
-    { props: 'eager' },
-    { props: 'lazy' },
-  ])('prefetch props respects route config when prefetch is %s', (prefetch) => {
-    const callback = vi.fn()
-
-    const route = createRoute({
-      name: 'route',
-      path: '/route',
-      component: echo,
-      prefetch,
-    }, callback)
+    { props: "eager" },
+    { props: "lazy" },
+  ])("prefetch props respects route config when prefetch is %s", (prefetch) => {
+    const callback = vi.fn();
+
+    const route = createRoute(
+      {
+        name: "route",
+        path: "/route",
+        component: echo,
+        prefetch,
+      },
+      callback,
+    );
 
     const router = createRouter([route], {
-      initialUrl: '/',
-    })
+      initialUrl: "/",
+    });
 
     mount(RouterLink, {
       props: {
-        to: '/route',
+        to: "/route",
       },
       global: {
         plugins: [router],
       },
-    })
+    });
 
-    const value = getPrefetchConfigValue(prefetch, 'props')
+    const value = getPrefetchConfigValue(prefetch, "props");
 
-    if (value === 'eager') {
-      expect(callback).toHaveBeenCalledOnce()
+    if (value === "eager") {
+      expect(callback).toHaveBeenCalledOnce();
     } else {
-      expect(callback).not.toHaveBeenCalled()
+      expect(callback).not.toHaveBeenCalled();
     }
-  })
+  });
 
   test.each<PrefetchConfig | undefined>([
     undefined,
     true,
     false,
-    'eager',
-    'lazy',
+    "eager",
+    "lazy",
     { props: true },
     { props: false },
-    { props: 'eager' },
-    { props: 'lazy' },
-  ])('prefetch props respects link config when prefetch is %s', (prefetch) => {
-    const callback = vi.fn()
-
-    const route = createRoute({
-      name: 'route',
-      path: '/route',
-      component: echo,
-    }, callback)
+    { props: "eager" },
+    { props: "lazy" },
+  ])("prefetch props respects link config when prefetch is %s", (prefetch) => {
+    const callback = vi.fn();
+
+    const route = createRoute(
+      {
+        name: "route",
+        path: "/route",
+        component: echo,
+      },
+      callback,
+    );
 
     const router = createRouter([route], {
-      initialUrl: '/',
-    })
+      initialUrl: "/",
+    });
 
     mount(RouterLink, {
       props: {
-        to: '/route',
+        to: "/route",
         prefetch,
       },
       global: {
         plugins: [router],
       },
-    })
+    });
 
-    const value = getPrefetchConfigValue(prefetch, 'props')
+    const value = getPrefetchConfigValue(prefetch, "props");
 
-    if (value === 'eager') {
-      expect(callback).toHaveBeenCalledOnce()
+    if (value === "eager") {
+      expect(callback).toHaveBeenCalledOnce();
     } else {
-      expect(callback).not.toHaveBeenCalled()
+      expect(callback).not.toHaveBeenCalled();
     }
-  })
+  });
 
-  test('prefetch props are passed to route component', async () => {
-    const value = 'hello world'
+  test("prefetch props are passed to route component", async () => {
+    const value = "hello world";
 
-    const props = vi.fn(() => Promise.resolve({
-      value,
-    }))
+    const props = vi.fn(() =>
+      Promise.resolve({
+        value,
+      }),
+    );
 
     const home = createRoute({
-      name: 'home',
-      path: '/',
-      component: () => h(RouterLink, { to: (resolve) => resolve('echo') }),
-    })
-
-    const route = createRoute({
-      name: 'echo',
-      path: '/echo',
-      component: echo,
-      prefetch: { props: 'eager' },
-    }, props)
+      name: "home",
+      path: "/",
+      component: () => h(RouterLink, { to: (resolve) => resolve("echo") }),
+    });
+
+    const route = createRoute(
+      {
+        name: "echo",
+        path: "/echo",
+        component: echo,
+        prefetch: { props: "eager" },
+      },
+      props,
+    );
 
     const router = createRouter([home, route], {
-      initialUrl: '/',
-    })
+      initialUrl: "/",
+    });
 
-    await router.start()
+    await router.start();
 
     const root = {
-      template: '<RouterView />',
-    }
+      template: "<RouterView />",
+    };
 
     const wrapper = mount(root, {
       global: {
         plugins: [router],
       },
-    })
+    });
 
-    expect(props).toHaveBeenCalledOnce()
+    expect(props).toHaveBeenCalledOnce();
 
-    wrapper.find('a').trigger('click')
+    wrapper.find("a").trigger("click");
 
-    await flushPromises()
+    await flushPromises();
 
-    expect(router.route.name).toBe('echo')
-    expect(props).toHaveBeenCalledOnce()
-    expect(wrapper.text()).toBe(value)
-  })
+    expect(router.route.name).toBe("echo");
+    expect(props).toHaveBeenCalledOnce();
+    expect(wrapper.text()).toBe(value);
+  });
 
-  test('parent routes that should not prefetch props are not prefetched', async () => {
-    const parentProps = vi.fn()
-    const childProps = vi.fn()
+  test("parent routes that should not prefetch props are not prefetched", async () => {
+    const parentProps = vi.fn();
+    const childProps = vi.fn();
 
     const home = createRoute({
-      name: 'home',
-      path: '/',
-      component: () => h(RouterLink, { to: (resolve) => resolve('child') }),
-    })
-
-    const parent = createRoute({
-      name: 'parent',
-      path: '/parent',
-      component: echo,
-      prefetch: { props: false },
-    }, parentProps)
-
-    const child = createRoute({
-      parent,
-      name: 'child',
-      path: '/child',
-      component: echo,
-      prefetch: { props: 'eager' },
-    }, childProps)
+      name: "home",
+      path: "/",
+      component: () => h(RouterLink, { to: (resolve) => resolve("child") }),
+    });
+
+    const parent = createRoute(
+      {
+        name: "parent",
+        path: "/parent",
+        component: echo,
+        prefetch: { props: false },
+      },
+      parentProps,
+    );
+
+    const child = createRoute(
+      {
+        parent,
+        name: "child",
+        path: "/child",
+        component: echo,
+        prefetch: { props: "eager" },
+      },
+      childProps,
+    );
 
     const router = createRouter([home, child], {
-      initialUrl: '/',
-    })
+      initialUrl: "/",
+    });
 
-    await router.start()
+    await router.start();
 
     const root = {
-      template: '<RouterView />',
-    }
+      template: "<RouterView />",
+    };
 
     mount(root, {
       global: {
         plugins: [router],
       },
-    })
+    });
 
-    expect(childProps).toHaveBeenCalledOnce()
-    expect(parentProps).not.toHaveBeenCalledOnce()
-  })
+    expect(childProps).toHaveBeenCalledOnce();
+    expect(parentProps).not.toHaveBeenCalledOnce();
+  });
 
-  test('props are not prefetched until link is visible when prefetch is lazy', async () => {
-    const callback = vi.fn()
+  test("props are not prefetched until link is visible when prefetch is lazy", async () => {
+    const callback = vi.fn();
 
     const routeA = createRoute({
-      name: 'routeA',
-      path: '/routeA',
-      component: () => h(RouterLink, { to: (resolve) => resolve('routeB') }),
-    })
-
-    const routeB = createRoute({
-      name: 'routeB',
-      path: '/routeB',
-      component: echo,
-      prefetch: { props: 'lazy' },
-    }, callback)
+      name: "routeA",
+      path: "/routeA",
+      component: () => h(RouterLink, { to: (resolve) => resolve("routeB") }),
+    });
+
+    const routeB = createRoute(
+      {
+        name: "routeB",
+        path: "/routeB",
+        component: echo,
+        prefetch: { props: "lazy" },
+      },
+      callback,
+    );
 
     const router = createRouter([routeA, routeB], {
-      initialUrl: '/routeA',
-    })
+      initialUrl: "/routeA",
+    });
 
-    await router.start()
+    await router.start();
 
-    const visible = ref(false)
+    const visible = ref(false);
 
     const root = {
-      template: '<RouterView />',
+      template: "<RouterView />",
       provide: {
         [visibilityObserverKey]: {
           observe: vi.fn(),
@@ -965,54 +1021,54 @@ describe('prefetch props', () => {
           isElementVisible: () => visible.value,
         } satisfies VisibilityObserver,
       },
-    }
+    };
 
     mount(root, {
       global: {
         plugins: [router],
       },
-    })
+    });
 
-    expect(callback).not.toHaveBeenCalled()
+    expect(callback).not.toHaveBeenCalled();
 
-    visible.value = true
+    visible.value = true;
 
-    await nextTick()
+    await nextTick();
 
-    expect(callback).toHaveBeenCalled()
-  })
+    expect(callback).toHaveBeenCalled();
+  });
 
-  test('components are not prefetched until link is visible when prefetch is lazy', async () => {
-    let loaded = false
+  test("components are not prefetched until link is visible when prefetch is lazy", async () => {
+    let loaded = false;
 
     const routeA = createRoute({
-      name: 'routeA',
-      path: '/routeA',
-      component: () => h(RouterLink, { to: (resolve) => resolve('routeB') }),
-    })
+      name: "routeA",
+      path: "/routeA",
+      component: () => h(RouterLink, { to: (resolve) => resolve("routeB") }),
+    });
 
     const routeB = createRoute({
-      name: 'routeB',
-      path: '/routeB',
-      prefetch: { components: 'lazy' },
+      name: "routeB",
+      path: "/routeB",
+      prefetch: { components: "lazy" },
       component: defineAsyncComponent(() => {
         return new Promise((resolve) => {
-          loaded = true
-          resolve({ default: { template: 'foo' } })
-        })
+          loaded = true;
+          resolve({ default: { template: "foo" } });
+        });
       }),
-    })
+    });
 
     const router = createRouter([routeA, routeB], {
-      initialUrl: '/routeA',
-    })
+      initialUrl: "/routeA",
+    });
 
-    await router.start()
+    await router.start();
 
-    const visible = ref(false)
+    const visible = ref(false);
 
     const root = {
-      template: '<RouterView />',
+      template: "<RouterView />",
       provide: {
         [visibilityObserverKey]: {
           observe: vi.fn(),
@@ -1021,113 +1077,116 @@ describe('prefetch props', () => {
           isElementVisible: () => visible.value,
         } satisfies VisibilityObserver,
       },
-    }
+    };
 
     mount(root, {
       global: {
         plugins: [router],
       },
-    })
+    });
 
-    expect(loaded).toBe(false)
+    expect(loaded).toBe(false);
 
-    visible.value = true
+    visible.value = true;
 
-    await nextTick()
+    await nextTick();
 
-    expect(loaded).toBe(true)
-  })
+    expect(loaded).toBe(true);
+  });
 
-  test('props are not prefetched until link is focused when prefetch is intent', async () => {
-    const callback = vi.fn()
+  test("props are not prefetched until link is focused when prefetch is intent", async () => {
+    const callback = vi.fn();
 
     const routeA = createRoute({
-      name: 'routeA',
-      path: '/routeA',
-      component: () => h(RouterLink, { to: (resolve) => resolve('routeB') }),
-    })
-
-    const routeB = createRoute({
-      name: 'routeB',
-      path: '/routeB',
-      component: echo,
-      prefetch: { props: 'intent' },
-    }, callback)
+      name: "routeA",
+      path: "/routeA",
+      component: () => h(RouterLink, { to: (resolve) => resolve("routeB") }),
+    });
+
+    const routeB = createRoute(
+      {
+        name: "routeB",
+        path: "/routeB",
+        component: echo,
+        prefetch: { props: "intent" },
+      },
+      callback,
+    );
 
     const router = createRouter([routeA, routeB], {
-      initialUrl: '/routeA',
-    })
+      initialUrl: "/routeA",
+    });
 
-    await router.start()
+    await router.start();
 
     const root = {
-      template: '<RouterView />',
-    }
+      template: "<RouterView />",
+    };
 
     const wrapper = mount(root, {
       global: {
         plugins: [router],
       },
-    })
+    });
 
-    await nextTick()
+    await nextTick();
 
-    expect(callback).not.toHaveBeenCalled()
+    expect(callback).not.toHaveBeenCalled();
 
-    const link = wrapper.find('a')
+    const link = wrapper.find("a");
 
-    link.trigger('focusin')
+    link.trigger("focusin");
 
-    await nextTick()
+    await nextTick();
 
-    expect(callback).toHaveBeenCalled()
-  })
+    expect(callback).toHaveBeenCalled();
+  });
 
-  test('components are not prefetched until link is focused when prefetch is intent', async () => {
-    let loaded = false
+  test("components are not prefetched until link is focused when prefetch is intent", async () => {
+    let loaded = false;
 
     const routeA = createRoute({
-      name: 'routeA',
-      path: '/routeA',
-      component: () => h(RouterLink, { to: (resolve) => resolve('routeB') }, () => 'routeB'),
-    })
+      name: "routeA",
+      path: "/routeA",
+      component: () => h(RouterLink, { to: (resolve) => resolve("routeB") }, () => "routeB"),
+    });
 
     const routeB = createRoute({
-      name: 'routeB',
-      path: '/routeB',
-      prefetch: { components: 'intent' },
+      name: "routeB",
+      path: "/routeB",
+      prefetch: { components: "intent" },
       component: defineAsyncComponent(() => {
         return new Promise((resolve) => {
-          loaded = true
-          resolve({ template: 'bar' })
-        })
+          loaded = true;
+          resolve({ template: "bar" });
+        });
       }),
-    })
+    });
 
     const router = createRouter([routeA, routeB], {
-      initialUrl: '/routeA',
-    })
+      initialUrl: "/routeA",
+    });
 
-    await router.start()
+    await router.start();
 
     const root = {
-      template: '<RouterView />',
-    }
+      template: "<RouterView />",
+    };
 
     const wrapper = mount(root, {
       global: {
         plugins: [router],
       },
-    })
+    });
 
-    await nextTick()
+    await nextTick();
 
-    expect(loaded).toBe(false)
+    expect(loaded).toBe(false);
 
-    wrapper.find('a').trigger('focusin')
+    wrapper.find("a").trigger("focusin");
 
-    await nextTick()
+    await nextTick();
 
-    expect(loaded).toBe(true)
-  })
-})
+    expect(loaded).toBe(true);
+  });
+});
diff --git a/src/components/routerLink.ts b/src/components/routerLink.ts
index b2a05701..963a2338 100644
--- a/src/components/routerLink.ts
+++ b/src/components/routerLink.ts
@@ -1,120 +1,147 @@
-import { isUrlString, UrlString } from '@/types/urlString'
-import { ResolvedRoute } from '@/types/resolved'
-import { computed, defineComponent, EmitsOptions, h, InjectionKey, SetupContext, SlotsType, VNode } from 'vue'
-import { createUseRouter } from '@/compositions/useRouter'
-import { Router } from '@/types/router'
-import { createUseLink } from '@/compositions/useLink'
-import { RouterLinkProps, ToCallback } from '@/types/routerLink'
+import { isUrlString, UrlString } from "@/types/urlString";
+import { ResolvedRoute } from "@/types/resolved";
+import {
+  computed,
+  defineComponent,
+  EmitsOptions,
+  h,
+  InjectionKey,
+  SetupContext,
+  SlotsType,
+  VNode,
+} from "vue";
+import { createUseRouter } from "@/compositions/useRouter";
+import { Router } from "@/types/router";
+import { createUseLink } from "@/compositions/useLink";
+import { RouterLinkProps, ToCallback } from "@/types/routerLink";
 
 type RouterLinkSlots = {
   default?: (props: {
-    route: ResolvedRoute | undefined,
-    isMatch: boolean,
-    isExactMatch: boolean,
-    isActive: boolean,
-    isExactActive: boolean,
-    isExternal: boolean,
-  }) => VNode[],
-}
+    route: ResolvedRoute | undefined;
+    isMatch: boolean;
+    isExactMatch: boolean;
+    isActive: boolean;
+    isExactActive: boolean;
+    isExternal: boolean;
+  }) => VNode[];
+};
 
 // Inferring the return type of the component is more accurate than defining it manually
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+// oxlint-disable-next-line @typescript-eslint/explicit-function-return-type
 export function createRouterLink<TRouter extends Router>(routerKey: InjectionKey<TRouter>) {
-  const useRouter = createUseRouter(routerKey)
-  const useLink = createUseLink(routerKey)
-
-  return defineComponent((props: RouterLinkProps<TRouter>, context: SetupContext<EmitsOptions, SlotsType<RouterLinkSlots>>) => {
-    const router = useRouter()
-
-    const route = computed<ResolvedRoute | undefined>(() => getResolvedRoute(props.to))
-    const href = computed<UrlString | undefined>(() => getHref(props.to))
-    const targetSelf = computed<boolean>(() => !props.target || props.target === '_self')
-
-    const options = computed(() => {
-      const { to, ...options } = props
-
-      return options
-    })
-
-    const { element, isMatch, isExactMatch, isActive, isExactActive, isExternal, push } = useLink(() => {
-      if (typeof props.to === 'function') {
-        return props.to(router.resolve)
+  const useRouter = createUseRouter(routerKey);
+  const useLink = createUseLink(routerKey);
+
+  return defineComponent(
+    (
+      props: RouterLinkProps<TRouter>,
+      context: SetupContext<EmitsOptions, SlotsType<RouterLinkSlots>>,
+    ) => {
+      const router = useRouter();
+
+      const route = computed<ResolvedRoute | undefined>(() => getResolvedRoute(props.to));
+      const href = computed<UrlString | undefined>(() => getHref(props.to));
+      const targetSelf = computed<boolean>(() => !props.target || props.target === "_self");
+
+      const options = computed(() => {
+        const { to, ...options } = props;
+
+        return options;
+      });
+
+      const { element, isMatch, isExactMatch, isActive, isExactActive, isExternal, push } = useLink(
+        () => {
+          if (typeof props.to === "function") {
+            return props.to(router.resolve);
+          }
+
+          return props.to;
+        },
+        options,
+      );
+
+      const classes = computed(() => ({
+        "router-link--match": isMatch.value,
+        "router-link--exact-match": isExactMatch.value,
+        "router-link--active": isActive.value,
+        "router-link--exact-active": isExactActive.value,
+      }));
+
+      function getResolvedRoute(
+        to: UrlString | ResolvedRoute | ToCallback<TRouter> | undefined,
+      ): ResolvedRoute | undefined {
+        if (typeof to === "function") {
+          const callbackValue = to(router.resolve);
+
+          return getResolvedRoute(callbackValue);
+        }
+
+        return isUrlString(to) ? router.find(to) : to;
       }
 
-      return props.to
-    }, options)
+      function getHref(
+        to: UrlString | ResolvedRoute | ToCallback<TRouter> | undefined,
+      ): UrlString | undefined {
+        if (typeof to === "function") {
+          const callbackValue = to(router.resolve);
 
-    const classes = computed(() => ({
-      'router-link--match': isMatch.value,
-      'router-link--exact-match': isExactMatch.value,
-      'router-link--active': isActive.value,
-      'router-link--exact-active': isExactActive.value,
-    }))
+          return getHref(callbackValue);
+        }
 
-    function getResolvedRoute(to: UrlString | ResolvedRoute | ToCallback<TRouter> | undefined): ResolvedRoute | undefined {
-      if (typeof to === 'function') {
-        const callbackValue = to(router.resolve)
+        if (isUrlString(to)) {
+          return to;
+        }
 
-        return getResolvedRoute(callbackValue)
+        return to?.href;
       }
 
-      return isUrlString(to) ? router.find(to) : to
-    }
-
-    function getHref(to: UrlString | ResolvedRoute | ToCallback<TRouter> | undefined): UrlString | undefined {
-      if (typeof to === 'function') {
-        const callbackValue = to(router.resolve)
-
-        return getHref(callbackValue)
+      function shouldAllowDefault(event: MouseEvent): boolean {
+        return (
+          event.defaultPrevented ||
+          event.button !== 0 ||
+          event.metaKey ||
+          event.ctrlKey ||
+          event.shiftKey ||
+          event.altKey ||
+          !targetSelf.value
+        );
       }
 
-      if (isUrlString(to)) {
-        return to
-      }
+      function onClick(event: MouseEvent): void {
+        if (shouldAllowDefault(event)) {
+          return;
+        }
 
-      return to?.href
-    }
-
-    function shouldAllowDefault(event: MouseEvent): boolean {
-      return event.defaultPrevented 
-        || event.button !== 0 
-        || event.metaKey 
-        || event.ctrlKey 
-        || event.shiftKey 
-        || event.altKey 
-        || !targetSelf.value
-    }
-
-    function onClick(event: MouseEvent): void {
-      if (shouldAllowDefault(event)) {
-        return
+        event.preventDefault();
+        push();
       }
 
-      event.preventDefault()
-      push()
-    }
-
-    return () => {
-      return h('a', {
-        href: href.value,
-        target: props.target,
-        class: ['router-link', classes.value],
-        ref: element,
-        onClick,
-      }, context.slots.default?.({
-        route: route.value,
-        isMatch: isMatch.value,
-        isExactMatch: isExactMatch.value,
-        isActive: isActive.value,
-        isExactActive: isExactActive.value,
-        isExternal: isExternal.value,
-      }),
-      )
-    }
-  }, {
-    name: 'RouterLink',
-    // The prop types are defined above. Vue requires manually defining the prop names themselves here to distinguish from attrs
-    // eslint-disable-next-line vue/require-prop-types
-    props: ['to', 'prefetch', 'query', 'hash', 'replace', 'state', 'target'],
-  })
+      return () => {
+        return h(
+          "a",
+          {
+            href: href.value,
+            target: props.target,
+            class: ["router-link", classes.value],
+            ref: element,
+            onClick,
+          },
+          context.slots.default?.({
+            route: route.value,
+            isMatch: isMatch.value,
+            isExactMatch: isExactMatch.value,
+            isActive: isActive.value,
+            isExactActive: isExactActive.value,
+            isExternal: isExternal.value,
+          }),
+        );
+      };
+    },
+    {
+      name: "RouterLink",
+      // The prop types are defined above. Vue requires manually defining the prop names themselves here to distinguish from attrs
+      // eslint-disable-next-line vue/require-prop-types
+      props: ["to", "prefetch", "query", "hash", "replace", "state", "target"],
+    },
+  );
 }
diff --git a/src/components/routerView.browser.spec.ts b/src/components/routerView.browser.spec.ts
index 7796e6e0..4942a149 100644
--- a/src/components/routerView.browser.spec.ts
+++ b/src/components/routerView.browser.spec.ts
@@ -1,308 +1,308 @@
-import { mount, flushPromises } from '@vue/test-utils'
-import { expect, test } from 'vitest'
-import { defineAsyncComponent, h } from 'vue'
-import echo from '@/components/echo'
-import helloWorld from '@/components/helloWorld'
-import { createRoute } from '@/services/createRoute'
-import { createRouter } from '@/services/createRouter'
-import { isWithComponent } from '@/types/createRouteOptions'
-import { component, routes } from '@/utilities/testHelpers'
-import { RouterLink } from '@/main'
-import { createRejection } from '@/services/createRejection'
-
-test('renders component for initial route', async () => {
+import { mount, flushPromises } from "@vue/test-utils";
+import { expect, test } from "vite-plus/test";
+import { defineAsyncComponent, h } from "vue";
+import echo from "@/components/echo";
+import helloWorld from "@/components/helloWorld";
+import { createRoute } from "@/services/createRoute";
+import { createRouter } from "@/services/createRouter";
+import { isWithComponent } from "@/types/createRouteOptions";
+import { component, routes } from "@/utilities/testHelpers";
+import { RouterLink } from "@/main";
+import { createRejection } from "@/services/createRejection";
+
+test("renders component for initial route", async () => {
   const route = createRoute({
-    name: 'foo',
-    path: '/',
-    component: { template: 'hello world' },
-  })
+    name: "foo",
+    path: "/",
+    component: { template: "hello world" },
+  });
 
   const router = createRouter([route], {
-    initialUrl: '/',
-  })
+    initialUrl: "/",
+  });
 
-  await router.start()
+  await router.start();
 
   const root = {
-    template: '<RouterView/>',
-  }
+    template: "<RouterView/>",
+  };
 
   const wrapper = mount(root, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  expect(wrapper.html()).toBe('hello world')
-})
+  expect(wrapper.html()).toBe("hello world");
+});
 
-test('renders components for initial route', async () => {
+test("renders components for initial route", async () => {
   const parentRoute = createRoute({
-    name: 'parent',
-    path: '/parent',
-  })
+    name: "parent",
+    path: "/parent",
+  });
 
   const childRoute = createRoute({
     parent: parentRoute,
-    name: 'child',
-    path: '/child',
-    component: { template: 'Child' },
-  })
+    name: "child",
+    path: "/child",
+    component: { template: "Child" },
+  });
 
   const router = createRouter([parentRoute, childRoute], {
-    initialUrl: '/parent/child',
-  })
+    initialUrl: "/parent/child",
+  });
 
-  await router.start()
+  await router.start();
 
   const root = {
-    template: '<RouterView />',
-  }
+    template: "<RouterView />",
+  };
 
   const wrapper = mount(root, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  expect(wrapper.html()).toBe('Child')
-})
+  expect(wrapper.html()).toBe("Child");
+});
 
-test('does not render component when router is not started', async () => {
+test("does not render component when router is not started", async () => {
   const route = createRoute({
-    name: 'foo',
-    path: '/',
-    component: { template: 'hello world' },
-  })
+    name: "foo",
+    path: "/",
+    component: { template: "hello world" },
+  });
 
   const router = createRouter([route], {
-    initialUrl: '/',
-  })
+    initialUrl: "/",
+  });
 
   const root = {
-    template: '<RouterView/>',
-  }
+    template: "<RouterView/>",
+  };
 
   const wrapper = mount(root, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  expect(wrapper.text()).toBe('')
+  expect(wrapper.text()).toBe("");
 
-  await router.start()
+  await router.start();
 
-  expect(wrapper.text()).toBe('hello world')
-})
+  expect(wrapper.text()).toBe("hello world");
+});
 
-test('updates components when route changes', async () => {
+test("updates components when route changes", async () => {
   const routes = [
     createRoute({
-      name: 'foo',
-      path: '/foo',
-      component: { template: 'Foo' },
+      name: "foo",
+      path: "/foo",
+      component: { template: "Foo" },
     }),
     createRoute({
-      name: 'bar',
-      path: '/bar',
-      component: { template: 'Bar' },
+      name: "bar",
+      path: "/bar",
+      component: { template: "Bar" },
     }),
     createRoute({
-      name: 'zoo',
-      path: '/zoo',
-      component: { template: 'Zoo' },
+      name: "zoo",
+      path: "/zoo",
+      component: { template: "Zoo" },
     }),
-  ] as const
+  ] as const;
 
   const router = createRouter(routes, {
-    initialUrl: '/foo',
-  })
+    initialUrl: "/foo",
+  });
 
   const root = {
-    template: '<RouterView />',
-  }
+    template: "<RouterView />",
+  };
 
   const wrapper = mount(root, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  await router.start()
+  await router.start();
 
-  expect(wrapper.html()).toBe('Foo')
+  expect(wrapper.html()).toBe("Foo");
 
-  await router.push('/bar')
+  await router.push("/bar");
 
-  expect(wrapper.html()).toBe('Bar')
+  expect(wrapper.html()).toBe("Bar");
 
-  await router.push('/zoo')
+  await router.push("/zoo");
 
-  expect(wrapper.html()).toBe('Zoo')
+  expect(wrapper.html()).toBe("Zoo");
 
-  await router.push('/foo')
+  await router.push("/foo");
 
-  expect(wrapper.html()).toBe('Foo')
-})
+  expect(wrapper.html()).toBe("Foo");
+});
 
-test('resolves async components', async () => {
+test("resolves async components", async () => {
   const route = createRoute({
-    name: 'async',
-    path: '/',
-    component: defineAsyncComponent(() => import('./helloWorld')),
-  })
+    name: "async",
+    path: "/",
+    component: defineAsyncComponent(() => import("./helloWorld")),
+  });
 
   const router = createRouter([route], {
-    initialUrl: '/',
-  })
+    initialUrl: "/",
+  });
 
   const root = {
-    template: '<RouterView/>',
-  }
+    template: "<RouterView/>",
+  };
 
   const wrapper = mount(root, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  await router.start()
-  await flushPromises()
-  await flushPromises()
-  await flushPromises()
+  await router.start();
+  await flushPromises();
+  await flushPromises();
+  await flushPromises();
 
-  expect(wrapper.html()).toBe(helloWorld.template)
-})
+  expect(wrapper.html()).toBe(helloWorld.template);
+});
 
-test('Renders the genericRejection component when the initialUrl does not match', async () => {
+test("Renders the genericRejection component when the initialUrl does not match", async () => {
   const router = createRouter([], {
-    initialUrl: '/does-not-exist',
-  })
+    initialUrl: "/does-not-exist",
+  });
 
-  await router.start()
+  await router.start();
 
   const root = {
-    template: '<RouterView/>',
-  }
+    template: "<RouterView/>",
+  };
 
   const wrapper = mount(root, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  expect(wrapper.text()).toBe('NotFound')
-})
+  expect(wrapper.text()).toBe("NotFound");
+});
 
-test('Renders custom genericRejection component when the initialUrl does not match', async () => {
-  const NotFound = { template: 'Custom Not Found' }
+test("Renders custom genericRejection component when the initialUrl does not match", async () => {
+  const NotFound = { template: "Custom Not Found" };
   const notFoundRejection = createRejection({
-    type: 'NotFound',
+    type: "NotFound",
     component: NotFound,
-  })
+  });
 
   const router = createRouter(routes, {
-    initialUrl: '/does-not-exist',
+    initialUrl: "/does-not-exist",
     rejections: [notFoundRejection],
-  })
+  });
 
-  await router.start()
+  await router.start();
 
   const root = {
-    template: '<RouterView/>',
-  }
+    template: "<RouterView/>",
+  };
 
   const wrapper = mount(root, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
   if (!isWithComponent(router.route.matched)) {
-    throw new Error('Matched route does not have a single component')
+    throw new Error("Matched route does not have a single component");
   }
 
-  const route = mount(router.route.matched.component)
+  const route = mount(router.route.matched.component);
 
-  expect(wrapper.text()).toBe(NotFound.template)
-  expect(route.text()).toBe(NotFound.template)
-})
+  expect(wrapper.text()).toBe(NotFound.template);
+  expect(route.text()).toBe(NotFound.template);
+});
 
-test('Renders the NotFound component when the router.push does not match', async () => {
+test("Renders the NotFound component when the router.push does not match", async () => {
   const route = createRoute({
-    name: 'foo',
-    path: '/',
-    component: { template: 'hello world' },
-  })
+    name: "foo",
+    path: "/",
+    component: { template: "hello world" },
+  });
 
   const router = createRouter([route], {
-    initialUrl: '/',
-  })
+    initialUrl: "/",
+  });
 
-  await router.start()
+  await router.start();
 
   const root = {
-    template: '<RouterView/>',
-  }
+    template: "<RouterView/>",
+  };
 
   const wrapper = mount(root, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  await router.push('/does-not-exist')
+  await router.push("/does-not-exist");
 
-  expect(wrapper.text()).toBe('NotFound')
-})
+  expect(wrapper.text()).toBe("NotFound");
+});
 
-test('Renders the route component when the router.push does match after a rejection', async () => {
+test("Renders the route component when the router.push does match after a rejection", async () => {
   const route = createRoute({
-    name: 'foo',
-    path: '/',
-    component: { template: 'hello world' },
-  })
+    name: "foo",
+    path: "/",
+    component: { template: "hello world" },
+  });
 
   const router = createRouter([route], {
-    initialUrl: '/does-not-exist',
-  })
+    initialUrl: "/does-not-exist",
+  });
 
-  await router.start()
+  await router.start();
 
   const root = {
-    template: '<RouterView/>',
-  }
+    template: "<RouterView/>",
+  };
 
   const wrapper = mount(root, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  expect(wrapper.text()).toBe('NotFound')
+  expect(wrapper.text()).toBe("NotFound");
 
-  await router.push('/')
+  await router.push("/");
 
-  expect(wrapper.text()).toBe('hello world')
-})
+  expect(wrapper.text()).toBe("hello world");
+});
 
-test('Renders the multiple components when using named route views', async () => {
+test("Renders the multiple components when using named route views", async () => {
   const route = createRoute({
-    name: 'foo',
-    path: '/',
+    name: "foo",
+    path: "/",
     components: {
-      default: { template: '_default_' },
-      one: { template: '_one_' },
-      two: { template: '_two_' },
+      default: { template: "_default_" },
+      one: { template: "_one_" },
+      two: { template: "_two_" },
     },
-  })
+  });
 
   const router = createRouter([route], {
-    initialUrl: '/',
-  })
+    initialUrl: "/",
+  });
 
-  await router.start()
+  await router.start();
 
   const root = {
     template: `
@@ -310,308 +310,346 @@ test('Renders the multiple components when using named route views', async () =>
       <RouterView />
       <RouterView name="two" />
     `,
-  }
+  };
 
   const wrapper = mount(root, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  expect(wrapper.text()).toBe('_one__default__two_')
-})
+  expect(wrapper.text()).toBe("_one__default__two_");
+});
 
-test('Binds props and attrs from route', async () => {
-  const routeA = createRoute({
-    name: 'routeA',
-    path: '/routeA/[param]',
-    component: echo,
-  }, (route) => ({ value: route.params.param }))
-
-  const routeB = createRoute({
-    name: 'routeB',
-    path: '/routeB/[param]',
-    component: echo,
-  }, (route) => ({ value: route.params.param }))
+test("Binds props and attrs from route", async () => {
+  const routeA = createRoute(
+    {
+      name: "routeA",
+      path: "/routeA/[param]",
+      component: echo,
+    },
+    (route) => ({ value: route.params.param }),
+  );
+
+  const routeB = createRoute(
+    {
+      name: "routeB",
+      path: "/routeB/[param]",
+      component: echo,
+    },
+    (route) => ({ value: route.params.param }),
+  );
 
   const router = createRouter([routeA, routeB], {
-    initialUrl: '/',
-  })
+    initialUrl: "/",
+  });
 
-  await router.start()
+  await router.start();
 
   const root = {
-    template: '<RouterView/>',
-  }
+    template: "<RouterView/>",
+  };
 
   const wrapper = mount(root, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  await router.push('/routeA/hello')
+  await router.push("/routeA/hello");
 
-  expect(wrapper.html()).toBe('hello')
+  expect(wrapper.html()).toBe("hello");
 
-  await router.push('/routeB/world')
+  await router.push("/routeB/world");
 
-  expect(wrapper.html()).toBe('world')
-})
+  expect(wrapper.html()).toBe("world");
+});
 
-test('Updates props and attrs when route params change', async () => {
-  const syncProps = createRoute({
-    name: 'sync',
-    path: '/sync/[param]',
-    component: echo,
-  }, (route) => ({ value: route.params.param }))
-
-  const asyncProps = createRoute({
-    name: 'async',
-    path: '/async/[param]',
-    component: echo,
-  }, async (route) => ({ value: route.params.param }))
+test("Updates props and attrs when route params change", async () => {
+  const syncProps = createRoute(
+    {
+      name: "sync",
+      path: "/sync/[param]",
+      component: echo,
+    },
+    (route) => ({ value: route.params.param }),
+  );
+
+  const asyncProps = createRoute(
+    {
+      name: "async",
+      path: "/async/[param]",
+      component: echo,
+    },
+    async (route) => ({ value: route.params.param }),
+  );
 
   const router = createRouter([syncProps, asyncProps], {
-    initialUrl: '/',
-  })
+    initialUrl: "/",
+  });
 
-  await router.start()
+  await router.start();
 
   const root = {
-    template: '<RouterView/>',
-  }
+    template: "<RouterView/>",
+  };
 
   const wrapper = mount(root, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  await router.push('sync', { param: 'foo' })
+  await router.push("sync", { param: "foo" });
 
-  expect(wrapper.html()).toBe('foo')
+  expect(wrapper.html()).toBe("foo");
 
-  await router.push('sync', { param: 'bar' })
+  await router.push("sync", { param: "bar" });
 
-  expect(wrapper.html()).toBe('bar')
+  expect(wrapper.html()).toBe("bar");
 
-  await router.push('async', { param: 'async-foo' })
+  await router.push("async", { param: "async-foo" });
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(wrapper.html()).toBe('async-foo')
+  expect(wrapper.html()).toBe("async-foo");
 
-  await router.push('async', { param: 'async-bar' })
+  await router.push("async", { param: "async-bar" });
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(wrapper.html()).toBe('async-bar')
-})
+  expect(wrapper.html()).toBe("async-bar");
+});
 
-test('Props from route can trigger push', async () => {
-  const routeA = createRoute({
-    name: 'routeA',
-    path: '/routeA',
-    component: echo,
-  }, (__, context) => {
-    throw context.push('/routeB')
-  })
-
-  const routeB = createRoute({
-    name: 'routeB',
-    path: '/routeB',
-    component: echo,
-  }, () => ({
-    value: 'routeB',
-  }))
+test("Props from route can trigger push", async () => {
+  const routeA = createRoute(
+    {
+      name: "routeA",
+      path: "/routeA",
+      component: echo,
+    },
+    (__, context) => {
+      throw context.push("/routeB");
+    },
+  );
+
+  const routeB = createRoute(
+    {
+      name: "routeB",
+      path: "/routeB",
+      component: echo,
+    },
+    () => ({
+      value: "routeB",
+    }),
+  );
 
   const router = createRouter([routeA, routeB], {
-    initialUrl: '/',
-  })
+    initialUrl: "/",
+  });
 
-  await router.start()
+  await router.start();
 
   const root = {
-    template: '<RouterView/>',
-  }
+    template: "<RouterView/>",
+  };
 
   const wrapper = mount(root, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  await router.push('/routeA')
+  await router.push("/routeA");
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(wrapper.html()).toBe('routeB')
-})
+  expect(wrapper.html()).toBe("routeB");
+});
 
-test('Props from route can trigger reject', async () => {
-  const routeA = createRoute({
-    name: 'routeA',
-    path: '/routeA',
-    component: echo,
-  }, (__, context) => {
-    throw context.reject('NotFound')
-  })
+test("Props from route can trigger reject", async () => {
+  const routeA = createRoute(
+    {
+      name: "routeA",
+      path: "/routeA",
+      component: echo,
+    },
+    (__, context) => {
+      throw context.reject("NotFound");
+    },
+  );
 
   const router = createRouter([routeA], {
-    initialUrl: '/',
-  })
+    initialUrl: "/",
+  });
 
-  await router.start()
+  await router.start();
 
   const root = {
-    template: '<RouterView/>',
-  }
+    template: "<RouterView/>",
+  };
 
   const wrapper = mount(root, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  await router.push('/routeA')
+  await router.push("/routeA");
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(wrapper.html()).toBe('<h1>NotFound</h1>')
-})
+  expect(wrapper.html()).toBe("<h1>NotFound</h1>");
+});
 
-test('prefetched props trigger push when navigation is initiated', async () => {
+test("prefetched props trigger push when navigation is initiated", async () => {
   const routeA = createRoute({
-    name: 'routeA',
-    path: '/routeA',
-    component: { render: () => h(RouterLink, { to: (resolve) => resolve('routeB') }, () => 'routeB') },
-  })
-
-  const routeB = createRoute({
-    name: 'routeB',
-    path: '/routeB',
-    component: echo,
-    prefetch: { props: true },
-  }, (__, { push }) => {
-    throw push('/routeC')
-  })
-
-  const routeC = createRoute({
-    name: 'routeC',
-    path: '/routeC',
-    component: echo,
-  }, () => ({
-    value: 'routeC',
-  }))
+    name: "routeA",
+    path: "/routeA",
+    component: {
+      render: () => h(RouterLink, { to: (resolve) => resolve("routeB") }, () => "routeB"),
+    },
+  });
+
+  const routeB = createRoute(
+    {
+      name: "routeB",
+      path: "/routeB",
+      component: echo,
+      prefetch: { props: true },
+    },
+    (__, { push }) => {
+      throw push("/routeC");
+    },
+  );
+
+  const routeC = createRoute(
+    {
+      name: "routeC",
+      path: "/routeC",
+      component: echo,
+    },
+    () => ({
+      value: "routeC",
+    }),
+  );
 
   const router = createRouter([routeA, routeB, routeC], {
-    initialUrl: '/routeA',
-  })
+    initialUrl: "/routeA",
+  });
 
-  await router.start()
+  await router.start();
 
   const root = {
-    template: '<RouterView/>',
-  }
+    template: "<RouterView/>",
+  };
 
   const wrapper = mount(root, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  expect(wrapper.text()).toBe('routeB')
+  expect(wrapper.text()).toBe("routeB");
 
-  wrapper.find('a').trigger('click')
+  wrapper.find("a").trigger("click");
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(wrapper.text()).toBe('routeC')
-})
+  expect(wrapper.text()).toBe("routeC");
+});
 
-test('prefetched async props trigger push when navigation is initiated', async () => {
+test("prefetched async props trigger push when navigation is initiated", async () => {
   const routeA = createRoute({
-    name: 'routeA',
-    path: '/routeA',
-    component: { render: () => h(RouterLink, { to: (resolve) => resolve('routeB') }, () => 'routeB') },
-  })
-
-  const routeB = createRoute({
-    name: 'routeB',
-    path: '/routeB',
-    component,
-    prefetch: { props: true },
-  }, (__, { push }) => {
-    throw push('/routeC')
-  })
-
-  const routeC = createRoute({
-    name: 'routeC',
-    path: '/routeC',
-    component: echo,
-  }, () => ({
-    value: 'routeC',
-  }))
+    name: "routeA",
+    path: "/routeA",
+    component: {
+      render: () => h(RouterLink, { to: (resolve) => resolve("routeB") }, () => "routeB"),
+    },
+  });
+
+  const routeB = createRoute(
+    {
+      name: "routeB",
+      path: "/routeB",
+      component,
+      prefetch: { props: true },
+    },
+    (__, { push }) => {
+      throw push("/routeC");
+    },
+  );
+
+  const routeC = createRoute(
+    {
+      name: "routeC",
+      path: "/routeC",
+      component: echo,
+    },
+    () => ({
+      value: "routeC",
+    }),
+  );
 
   const router = createRouter([routeA, routeB, routeC], {
-    initialUrl: '/routeA',
-  })
+    initialUrl: "/routeA",
+  });
 
-  await router.start()
+  await router.start();
 
   const root = {
-    template: '<RouterView/>',
-  }
+    template: "<RouterView/>",
+  };
 
   const wrapper = mount(root, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  expect(wrapper.text()).toBe('routeB')
+  expect(wrapper.text()).toBe("routeB");
 
-  wrapper.find('a').trigger('click')
+  wrapper.find("a").trigger("click");
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(wrapper.text()).toBe('routeC')
-})
+  expect(wrapper.text()).toBe("routeC");
+});
 
-test('Renders correct component when using default slot', async () => {
+test("Renders correct component when using default slot", async () => {
   const myRejection = createRejection({
-    type: 'myRejection',
+    type: "myRejection",
     component: {
-      template: 'My Rejection',
+      template: "My Rejection",
     },
-  })
+  });
 
   const foo = createRoute({
-    name: 'foo',
-    path: '/foo',
+    name: "foo",
+    path: "/foo",
     component: {
-      template: 'Foo',
+      template: "Foo",
     },
-  })
+  });
 
   const bar = createRoute({
-    name: 'bar',
-    path: '/bar',
+    name: "bar",
+    path: "/bar",
     component: {
-      template: 'Bar',
+      template: "Bar",
     },
-  })
+  });
 
   const router = createRouter([foo, bar], {
-    initialUrl: '/foo',
+    initialUrl: "/foo",
     rejections: [myRejection],
-  })
+  });
 
-  await router.start()
+  await router.start();
 
-  const wrapper = mount({
-    template: `
+  const wrapper = mount(
+    {
+      template: `
       <router-view>
         <template #default="{ component }">
           <transition name="fade">
@@ -620,62 +658,64 @@ test('Renders correct component when using default slot', async () => {
         </template>
       </router-view>
       `,
-  }, {
-    global: {
-      plugins: [router],
     },
-  })
+    {
+      global: {
+        plugins: [router],
+      },
+    },
+  );
 
-  expect(wrapper.text()).toBe('Foo')
+  expect(wrapper.text()).toBe("Foo");
 
-  await router.push('bar')
+  await router.push("bar");
 
-  expect(wrapper.text()).toBe('Bar')
+  expect(wrapper.text()).toBe("Bar");
 
-  router.reject('myRejection')
+  router.reject("myRejection");
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(wrapper.text()).toBe('My Rejection')
-})
+  expect(wrapper.text()).toBe("My Rejection");
+});
 
-test('Renders the rejection component when the rejection is not registered on the router', async () => {
-  const rejectionText = 'Rejection content to render'
+test("Renders the rejection component when the rejection is not registered on the router", async () => {
+  const rejectionText = "Rejection content to render";
   const myRejection = createRejection({
-    type: 'myRejection',
+    type: "myRejection",
     component: {
       template: rejectionText,
     },
-  })
+  });
 
   const route = createRoute({
-    name: 'foo',
-    path: '/',
+    name: "foo",
+    path: "/",
     context: [myRejection],
-    component: { template: 'Should not be rendered' },
-  })
+    component: { template: "Should not be rendered" },
+  });
 
   route.onBeforeRouteEnter((_to, { reject }) => {
-    throw reject('myRejection')
-  })
+    throw reject("myRejection");
+  });
 
   const router = createRouter([route], {
-    initialUrl: '/',
-  })
+    initialUrl: "/",
+  });
 
-  await router.start()
+  await router.start();
 
   const root = {
-    template: '<RouterView/>',
-  }
+    template: "<RouterView/>",
+  };
 
   const wrapper = mount(root, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(wrapper.text()).toBe(rejectionText)
-})
+  expect(wrapper.text()).toBe(rejectionText);
+});
diff --git a/src/components/routerView.spec.ts b/src/components/routerView.spec.ts
index 9a7ee9c5..cc118114 100644
--- a/src/components/routerView.spec.ts
+++ b/src/components/routerView.spec.ts
@@ -1,29 +1,29 @@
-import { createSSRApp } from 'vue'
-import { describe, it, expect } from 'vitest'
-import { createRoute } from '@/services/createRoute'
-import { createRouter } from '@/services/createRouter'
-import { renderToString } from 'vue/server-renderer'
+import { createSSRApp } from "vue";
+import { describe, it, expect } from "vite-plus/test";
+import { createRoute } from "@/services/createRoute";
+import { createRouter } from "@/services/createRouter";
+import { renderToString } from "vue/server-renderer";
 
-describe('SSR', () => {
-  it('should render the route', async () => {
+describe("SSR", () => {
+  it("should render the route", async () => {
     const route = createRoute({
-      name: 'foo',
-      path: '/',
-      component: { template: 'hello world' },
-    })
+      name: "foo",
+      path: "/",
+      component: { template: "hello world" },
+    });
 
     const router = createRouter([route], {
-      initialUrl: '/',
-    })
+      initialUrl: "/",
+    });
 
     const app = createSSRApp({
-      template: '<RouterView/>',
-    })
+      template: "<RouterView/>",
+    });
 
-    app.use(router)
+    app.use(router);
 
-    const html = await renderToString(app)
+    const html = await renderToString(app);
 
-    expect(html).toMatchInlineSnapshot('"hello world"')
-  })
-})
+    expect(html).toMatchInlineSnapshot('"hello world"');
+  });
+});
diff --git a/src/components/routerView.ts b/src/components/routerView.ts
index 8ead9957..ce8e0219 100644
--- a/src/components/routerView.ts
+++ b/src/components/routerView.ts
@@ -1,89 +1,104 @@
-import { createUseComponentsStore } from '@/compositions/useComponentsStore'
-import { createUseRejection } from '@/compositions/useRejection'
-import { createUseRoute } from '@/compositions/useRoute'
-import { createUseRouter } from '@/compositions/useRouter'
-import { createUseRouterDepth } from '@/compositions/useRouterDepth'
-import { isRejection, RouterRejection } from '@/types/rejection'
-import { RouterRoute } from '@/types/routerRoute'
-import { Router } from '@/types/router'
-import { Component, computed, defineComponent, EmitsOptions, h, InjectionKey, onServerPrefetch, SetupContext, SlotsType, UnwrapRef, VNode } from 'vue'
+import { createUseComponentsStore } from "@/compositions/useComponentsStore";
+import { createUseRejection } from "@/compositions/useRejection";
+import { createUseRoute } from "@/compositions/useRoute";
+import { createUseRouter } from "@/compositions/useRouter";
+import { createUseRouterDepth } from "@/compositions/useRouterDepth";
+import { isRejection, RouterRejection } from "@/types/rejection";
+import { RouterRoute } from "@/types/routerRoute";
+import { Router } from "@/types/router";
+import {
+  Component,
+  computed,
+  defineComponent,
+  EmitsOptions,
+  h,
+  InjectionKey,
+  onServerPrefetch,
+  SetupContext,
+  SlotsType,
+  UnwrapRef,
+  VNode,
+} from "vue";
 
 export type RouterViewProps = {
-  name?: string,
-}
+  name?: string;
+};
 
 type RouterViewSlots = {
   default?: (props: {
-    route: RouterRoute,
-    component: Component | null,
-    rejection: UnwrapRef<RouterRejection>,
-  }) => VNode,
-}
+    route: RouterRoute;
+    component: Component | null;
+    rejection: UnwrapRef<RouterRejection>;
+  }) => VNode;
+};
 
 // Inferring the return type of the component is more accurate than defining it manually
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+// oxlint-disable-next-line @typescript-eslint/explicit-function-return-type
 export function createRouterView<TRouter extends Router>(routerKey: InjectionKey<TRouter>) {
-  const useRoute = createUseRoute(routerKey)
-  const useRouter = createUseRouter(routerKey)
-  const useRejection = createUseRejection(routerKey)
-  const useRouterDepth = createUseRouterDepth(routerKey)
-  const useComponentsStore = createUseComponentsStore(routerKey)
+  const useRoute = createUseRoute(routerKey);
+  const useRouter = createUseRouter(routerKey);
+  const useRejection = createUseRejection(routerKey);
+  const useRouterDepth = createUseRouterDepth(routerKey);
+  const useComponentsStore = createUseComponentsStore(routerKey);
 
-  return defineComponent((props: RouterViewProps, context: SetupContext<EmitsOptions, SlotsType<RouterViewSlots>>) => {
-    const route = useRoute()
-    const router = useRouter()
-    const rejection = useRejection()
-    const depth = useRouterDepth({ increment: true })
+  return defineComponent(
+    (props: RouterViewProps, context: SetupContext<EmitsOptions, SlotsType<RouterViewSlots>>) => {
+      const route = useRoute();
+      const router = useRouter();
+      const rejection = useRejection();
+      const depth = useRouterDepth({ increment: true });
 
-    onServerPrefetch(async () => {
-      await router.start()
-    })
+      onServerPrefetch(async () => {
+        await router.start();
+      });
 
-    const { getRouteComponents } = useComponentsStore()
+      const { getRouteComponents } = useComponentsStore();
 
-    const component = computed(() => {
-      if (!router.started.value) {
-        return null
-      }
+      const component = computed(() => {
+        if (!router.started.value) {
+          return null;
+        }
 
-      if (isRejection(rejection.value) && !!rejection.value.route.matched.component) {
-        return rejection.value.route.matched.component
-      }
+        if (isRejection(rejection.value) && !!rejection.value.route.matched.component) {
+          return rejection.value.route.matched.component;
+        }
 
-      const match = route.matches.at(depth)
+        const match = route.matches.at(depth);
 
-      if (!match) {
-        return null
-      }
+        if (!match) {
+          return null;
+        }
 
-      const components = getRouteComponents(match)
-      const name = props.name ?? 'default'
+        const components = getRouteComponents(match);
+        const name = props.name ?? "default";
 
-      return components[name]
-    })
+        return components[name];
+      });
 
-    return () => {
-      if (context.slots.default) {
-        return context.slots.default({
-          route,
-          component: component.value,
-          rejection: rejection.value,
-        })
-      }
+      return () => {
+        if (context.slots.default) {
+          return context.slots.default({
+            route,
+            component: component.value,
+            rejection: rejection.value,
+          });
+        }
 
-      if (!component.value) {
-        return null
-      }
+        if (!component.value) {
+          return null;
+        }
 
-      // Don't use a key - let Vue handle component reuse/remounting naturally
-      // Components will remount when navigating to different routes,
-      // but will be reused when only params change on the same route
-      return h(component.value)
-    }
-  }, {
-    name: 'RouterView',
-    // The prop types are defined above. Vue requires manually defining the prop names themselves here to distinguish from attrs
-    // eslint-disable-next-line vue/require-prop-types
-    props: ['name'],
-  })
+        // Don't use a key - let Vue handle component reuse/remounting naturally
+        // Components will remount when navigating to different routes,
+        // but will be reused when only params change on the same route
+        return h(component.value);
+      };
+    },
+    {
+      name: "RouterView",
+      // The prop types are defined above. Vue requires manually defining the prop names themselves here to distinguish from attrs
+      // eslint-disable-next-line vue/require-prop-types
+      props: ["name"],
+    },
+  );
 }
diff --git a/src/compositions/useQueryValue.browser.spec.ts b/src/compositions/useQueryValue.browser.spec.ts
index 03a889ae..47dbc481 100644
--- a/src/compositions/useQueryValue.browser.spec.ts
+++ b/src/compositions/useQueryValue.browser.spec.ts
@@ -1,288 +1,288 @@
-import { createRouter } from '@/services/createRouter'
-import { createRoute } from '@/services/createRoute'
-import { expect, test } from 'vitest'
-import { flushPromises, mount } from '@vue/test-utils'
-import { useQueryValue, withDefault } from '@/main'
+import { createRouter } from "@/services/createRouter";
+import { createRoute } from "@/services/createRoute";
+import { expect, test } from "vite-plus/test";
+import { flushPromises, mount } from "@vue/test-utils";
+import { useQueryValue, withDefault } from "@/main";
 
-test('returns correct value and values when key does not exist', async () => {
+test("returns correct value and values when key does not exist", async () => {
   const root = createRoute({
-    name: 'root',
-    path: '/',
-  })
+    name: "root",
+    path: "/",
+  });
 
   const router = createRouter([root], {
-    initialUrl: '/',
-  })
+    initialUrl: "/",
+  });
 
-  await router.start()
+  await router.start();
 
   const component = {
-    template: 'empty',
+    template: "empty",
     setup() {
-      return useQueryValue('foo')
+      return useQueryValue("foo");
     },
-  }
+  };
 
   const wrapper = mount(component, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  expect(wrapper.vm.value).toBe(null)
-  expect(wrapper.vm.values).toEqual([])
-})
+  expect(wrapper.vm.value).toBe(null);
+  expect(wrapper.vm.values).toEqual([]);
+});
 
-test('returns correct value and values when key does exist', async () => {
+test("returns correct value and values when key does exist", async () => {
   const root = createRoute({
-    name: 'root',
-    path: '/',
-  })
+    name: "root",
+    path: "/",
+  });
 
   const router = createRouter([root], {
-    initialUrl: '/?foo=1&foo=2',
-  })
+    initialUrl: "/?foo=1&foo=2",
+  });
 
-  await router.start()
+  await router.start();
 
   const component = {
-    template: 'empty',
+    template: "empty",
     setup() {
-      return useQueryValue('foo')
+      return useQueryValue("foo");
     },
-  }
+  };
 
   const wrapper = mount(component, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  expect(wrapper.vm.value).toBe('1')
-  expect(wrapper.vm.values).toEqual(['1', '2'])
-})
+  expect(wrapper.vm.value).toBe("1");
+  expect(wrapper.vm.values).toEqual(["1", "2"]);
+});
 
-test('returns correct value and values when a param is used', async () => {
+test("returns correct value and values when a param is used", async () => {
   const root = createRoute({
-    name: 'root',
-    path: '/',
-  })
+    name: "root",
+    path: "/",
+  });
 
   const router = createRouter([root], {
-    initialUrl: '/?foo=1&foo=2',
-  })
+    initialUrl: "/?foo=1&foo=2",
+  });
 
-  await router.start()
+  await router.start();
 
   const component = {
-    template: 'empty',
+    template: "empty",
     setup() {
-      return useQueryValue('foo', Number)
+      return useQueryValue("foo", Number);
     },
-  }
+  };
 
   const wrapper = mount(component, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  expect(wrapper.vm.value).toBe(1)
-  expect(wrapper.vm.values).toEqual([1, 2])
-})
+  expect(wrapper.vm.value).toBe(1);
+  expect(wrapper.vm.values).toEqual([1, 2]);
+});
 
-test('returns correct value and values when a param is used that has a default value', async () => {
+test("returns correct value and values when a param is used that has a default value", async () => {
   const root = createRoute({
-    name: 'root',
-    path: '/',
-  })
+    name: "root",
+    path: "/",
+  });
 
   const router = createRouter([root], {
-    initialUrl: '/',
-  })
+    initialUrl: "/",
+  });
 
-  await router.start()
+  await router.start();
 
   const component = {
-    template: 'empty',
+    template: "empty",
     setup() {
-      return useQueryValue('foo', withDefault(Number, 3))
+      return useQueryValue("foo", withDefault(Number, 3));
     },
-  }
+  };
 
   const wrapper = mount(component, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  expect(wrapper.vm.value).toBe(3)
-  expect(wrapper.vm.values).toEqual([3])
-})
+  expect(wrapper.vm.value).toBe(3);
+  expect(wrapper.vm.values).toEqual([3]);
+});
 
-test('updates value and values when the query string changes', async () => {
+test("updates value and values when the query string changes", async () => {
   const root = createRoute({
-    name: 'root',
-    path: '/',
-  })
+    name: "root",
+    path: "/",
+  });
 
   const router = createRouter([root], {
-    initialUrl: '/?foo=1&foo=2',
-  })
+    initialUrl: "/?foo=1&foo=2",
+  });
 
-  await router.start()
+  await router.start();
 
   const component = {
-    template: 'empty',
+    template: "empty",
     setup() {
-      return useQueryValue('foo', Number)
+      return useQueryValue("foo", Number);
     },
-  }
+  };
 
   const wrapper = mount(component, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  expect(wrapper.vm.value).toBe(1)
-  expect(wrapper.vm.values).toEqual([1, 2])
+  expect(wrapper.vm.value).toBe(1);
+  expect(wrapper.vm.values).toEqual([1, 2]);
 
-  await router.push('/?foo=3')
+  await router.push("/?foo=3");
 
-  expect(wrapper.vm.value).toBe(3)
-  expect(wrapper.vm.values).toEqual([3])
-})
+  expect(wrapper.vm.value).toBe(3);
+  expect(wrapper.vm.values).toEqual([3]);
+});
 
-test('updates value and values when a param is used that has a default value', async () => {
+test("updates value and values when a param is used that has a default value", async () => {
   const root = createRoute({
-    name: 'root',
-    path: '/',
-  })
+    name: "root",
+    path: "/",
+  });
 
   const router = createRouter([root], {
-    initialUrl: '/',
-  })
+    initialUrl: "/",
+  });
 
-  await router.start()
+  await router.start();
 
   const component = {
-    template: 'empty',
+    template: "empty",
     setup() {
-      return useQueryValue('foo', withDefault(Number, 3))
+      return useQueryValue("foo", withDefault(Number, 3));
     },
-  }
+  };
 
   const wrapper = mount(component, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  expect(wrapper.vm.value).toBe(3)
-  expect(wrapper.vm.values).toEqual([3])
+  expect(wrapper.vm.value).toBe(3);
+  expect(wrapper.vm.values).toEqual([3]);
 
-  await router.push('/?foo=4')
+  await router.push("/?foo=4");
 
-  expect(wrapper.vm.value).toBe(4)
-  expect(wrapper.vm.values).toEqual([4])
-})
+  expect(wrapper.vm.value).toBe(4);
+  expect(wrapper.vm.values).toEqual([4]);
+});
 
-test('updates the query string when the value is set', async () => {
+test("updates the query string when the value is set", async () => {
   const root = createRoute({
-    name: 'root',
-    path: '/',
+    name: "root",
+    path: "/",
     query: {
-      '?tab': withDefault(Number, 1),
+      "?tab": withDefault(Number, 1),
     },
-  })
+  });
 
   const router = createRouter([root], {
-    initialUrl: '/?foo=1&foo=2',
-  })
+    initialUrl: "/?foo=1&foo=2",
+  });
 
-  await router.start()
+  await router.start();
 
   const component = {
-    template: 'empty',
+    template: "empty",
     setup() {
-      const { value } = useQueryValue('foo', Number)
+      const { value } = useQueryValue("foo", Number);
 
-      value.value = 3
+      value.value = 3;
     },
-  }
+  };
 
   mount(component, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(location.search).toBe('?tab=1&foo=3')
-})
+  expect(location.search).toBe("?tab=1&foo=3");
+});
 
-test('updates the query string when the values is set', async () => {
+test("updates the query string when the values is set", async () => {
   const root = createRoute({
-    name: 'root',
-    path: '/',
-  })
+    name: "root",
+    path: "/",
+  });
 
   const router = createRouter([root], {
-    initialUrl: '/?foo=1&foo=2',
-  })
+    initialUrl: "/?foo=1&foo=2",
+  });
 
-  await router.start()
+  await router.start();
 
   const component = {
-    template: 'empty',
+    template: "empty",
     setup() {
-      const { values } = useQueryValue('foo', Number)
+      const { values } = useQueryValue("foo", Number);
 
-      values.value = [3, 4]
+      values.value = [3, 4];
     },
-  }
+  };
 
   mount(component, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(router.route.query.toString()).toBe('foo=3&foo=4')
-})
+  expect(router.route.query.toString()).toBe("foo=3&foo=4");
+});
 
-test('removes the query string when the remove method is called', async () => {
+test("removes the query string when the remove method is called", async () => {
   const root = createRoute({
-    name: 'root',
-    path: '/',
-  })
+    name: "root",
+    path: "/",
+  });
 
   const router = createRouter([root], {
-    initialUrl: '/?foo=1&foo=2',
-  })
+    initialUrl: "/?foo=1&foo=2",
+  });
 
-  await router.start()
+  await router.start();
 
   const component = {
-    template: 'empty',
+    template: "empty",
     setup() {
-      const { remove } = useQueryValue('foo')
+      const { remove } = useQueryValue("foo");
 
-      remove()
+      remove();
     },
-  }
+  };
 
   mount(component, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(router.route.query.toString()).toBe('')
-})
+  expect(router.route.query.toString()).toBe("");
+});
diff --git a/src/compositions/useQueryValue.spec-d.ts b/src/compositions/useQueryValue.spec-d.ts
index c83d018e..beb23594 100644
--- a/src/compositions/useQueryValue.spec-d.ts
+++ b/src/compositions/useQueryValue.spec-d.ts
@@ -1,38 +1,38 @@
-import { Ref } from 'vue'
-import { expectTypeOf, test } from 'vitest'
-import { useQueryValue, withDefault } from '@/main'
+import { Ref } from "vue";
+import { expectTypeOf, test } from "vite-plus/test";
+import { useQueryValue, withDefault } from "@/main";
 
-test('value is Ref<string | null> when no param is provided', () => {
-  const { value } = useQueryValue('foo')
-  expectTypeOf(value).toEqualTypeOf<Ref<string | null>>()
-})
+test("value is Ref<string | null> when no param is provided", () => {
+  const { value } = useQueryValue("foo");
+  expectTypeOf(value).toEqualTypeOf<Ref<string | null>>();
+});
 
-test('value is Ref<T | null> when param has no default', () => {
-  const { value } = useQueryValue('foo', Number)
-  expectTypeOf(value).toEqualTypeOf<Ref<number | null>>()
-})
+test("value is Ref<T | null> when param has no default", () => {
+  const { value } = useQueryValue("foo", Number);
+  expectTypeOf(value).toEqualTypeOf<Ref<number | null>>();
+});
 
-test('value is Ref<T> (no null) when param has default', () => {
-  const { value } = useQueryValue('foo', withDefault(Number, 3))
-  expectTypeOf(value).toEqualTypeOf<Ref<number>>()
-})
+test("value is Ref<T> (no null) when param has default", () => {
+  const { value } = useQueryValue("foo", withDefault(Number, 3));
+  expectTypeOf(value).toEqualTypeOf<Ref<number>>();
+});
 
-test('values is Ref<string[]> when no param is provided', () => {
-  const { values } = useQueryValue('foo')
-  expectTypeOf(values).toEqualTypeOf<Ref<string[]>>()
-})
+test("values is Ref<string[]> when no param is provided", () => {
+  const { values } = useQueryValue("foo");
+  expectTypeOf(values).toEqualTypeOf<Ref<string[]>>();
+});
 
-test('values is Ref<T[]> when param has no default', () => {
-  const { values } = useQueryValue('foo', Number)
-  expectTypeOf(values).toEqualTypeOf<Ref<number[]>>()
-})
+test("values is Ref<T[]> when param has no default", () => {
+  const { values } = useQueryValue("foo", Number);
+  expectTypeOf(values).toEqualTypeOf<Ref<number[]>>();
+});
 
-test('values is Ref<T[]> (no null) when param has default', () => {
-  const { values } = useQueryValue('foo', withDefault(Number, 3))
-  expectTypeOf(values).toEqualTypeOf<Ref<number[]>>()
-})
+test("values is Ref<T[]> (no null) when param has default", () => {
+  const { values } = useQueryValue("foo", withDefault(Number, 3));
+  expectTypeOf(values).toEqualTypeOf<Ref<number[]>>();
+});
 
-test('remove is () => void', () => {
-  const { remove } = useQueryValue('foo')
-  expectTypeOf(remove).toEqualTypeOf<() => void>()
-})
+test("remove is () => void", () => {
+  const { remove } = useQueryValue("foo");
+  expectTypeOf(remove).toEqualTypeOf<() => void>();
+});
diff --git a/src/compositions/useRoute.browser.spec.ts b/src/compositions/useRoute.browser.spec.ts
index 704fe36c..8da23073 100644
--- a/src/compositions/useRoute.browser.spec.ts
+++ b/src/compositions/useRoute.browser.spec.ts
@@ -1,135 +1,135 @@
-import { mount } from '@vue/test-utils'
-import { expect, test } from 'vitest'
-import { useRoute } from '@/main'
-import { UseRouteInvalidError } from '@/errors/useRouteInvalidError'
-import { createRouter } from '@/services/createRouter'
-import { getError, routes } from '@/utilities/testHelpers'
-
-test('when given no routeKey returns the router route', async () => {
+import { mount } from "@vue/test-utils";
+import { expect, test } from "vite-plus/test";
+import { useRoute } from "@/main";
+import { UseRouteInvalidError } from "@/errors/useRouteInvalidError";
+import { createRouter } from "@/services/createRouter";
+import { getError, routes } from "@/utilities/testHelpers";
+
+test("when given no routeKey returns the router route", async () => {
   const router = createRouter(routes, {
-    initialUrl: '/routeA',
-  })
+    initialUrl: "/routeA",
+  });
 
-  await router.start()
+  await router.start();
 
   const component = {
-    template: 'foo',
+    template: "foo",
     setup() {
-      const route = useRoute()
+      const route = useRoute();
 
-      return { route }
+      return { route };
     },
-  }
+  };
 
   const wrapper = mount(component, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  expect(wrapper.vm.route).toBe(router.route)
-})
+  expect(wrapper.vm.route).toBe(router.route);
+});
 
-test('when given a routeKey that matches the current route returns the router route', async () => {
+test("when given a routeKey that matches the current route returns the router route", async () => {
   const router = createRouter(routes, {
-    initialUrl: '/parentB',
-  })
+    initialUrl: "/parentB",
+  });
 
-  await router.start()
+  await router.start();
 
   const component = {
-    template: 'foo',
+    template: "foo",
     setup() {
-      const route = useRoute('parentB')
+      const route = useRoute("parentB");
 
-      return { route }
+      return { route };
     },
-  }
+  };
 
   const wrapper = mount(component, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  expect(wrapper.vm.route).toBe(router.route)
-})
+  expect(wrapper.vm.route).toBe(router.route);
+});
 
-test('when given a routeKey that matches exactly the current route returns the router route', async () => {
+test("when given a routeKey that matches exactly the current route returns the router route", async () => {
   const router = createRouter(routes, {
-    initialUrl: '/parentA/parentAParam/childA/childAParam',
-  })
+    initialUrl: "/parentA/parentAParam/childA/childAParam",
+  });
 
-  await router.start()
+  await router.start();
 
   const component = {
-    template: 'foo',
+    template: "foo",
     setup() {
-      const route = useRoute('parentA.childA')
+      const route = useRoute("parentA.childA");
 
-      return { route }
+      return { route };
     },
-  }
+  };
 
   const wrapper = mount(component, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  expect(wrapper.vm.route).toBe(router.route)
-})
+  expect(wrapper.vm.route).toBe(router.route);
+});
 
-test('when given a routeKey that does not match the current route, throws UseRouteInvalidError', async () => {
+test("when given a routeKey that does not match the current route, throws UseRouteInvalidError", async () => {
   const router = createRouter(routes, {
-    initialUrl: '/parentB',
-  })
+    initialUrl: "/parentB",
+  });
 
-  await router.start()
+  await router.start();
 
   const component = {
-    template: 'foo',
+    template: "foo",
     setup() {
-      const route = useRoute('parentC')
+      const route = useRoute("parentC");
 
-      return { route }
+      return { route };
     },
-  }
+  };
 
   const error = getError(() => {
     mount(component, {
       global: {
         plugins: [router],
       },
-    })
-  })
+    });
+  });
 
-  expect(error).toBeInstanceOf(UseRouteInvalidError)
-})
+  expect(error).toBeInstanceOf(UseRouteInvalidError);
+});
 
-test('when given a routeKey that does not match exactly the current route, throws UseRouteInvalidError', async () => {
+test("when given a routeKey that does not match exactly the current route, throws UseRouteInvalidError", async () => {
   const router = createRouter(routes, {
-    initialUrl: '/parentA/parentAParam/childA/childAParam',
-  })
+    initialUrl: "/parentA/parentAParam/childA/childAParam",
+  });
 
-  await router.start()
+  await router.start();
 
   const component = {
-    template: 'foo',
+    template: "foo",
     setup() {
-      const route = useRoute('parentA', { exact: true })
+      const route = useRoute("parentA", { exact: true });
 
-      return { route }
+      return { route };
     },
-  }
+  };
 
   const error = getError(() => {
     mount(component, {
       global: {
         plugins: [router],
       },
-    })
-  })
+    });
+  });
 
-  expect(error).toBeInstanceOf(UseRouteInvalidError)
-})
+  expect(error).toBeInstanceOf(UseRouteInvalidError);
+});
diff --git a/src/compositions/useRoute.spec-d.ts b/src/compositions/useRoute.spec-d.ts
index 3cf8a6b7..c1504be8 100644
--- a/src/compositions/useRoute.spec-d.ts
+++ b/src/compositions/useRoute.spec-d.ts
@@ -1,137 +1,135 @@
-import { describe, expectTypeOf, test } from 'vitest'
-import { createUseRoute } from '@/compositions/useRoute'
-import { createRoute } from '@/services/createRoute'
-import { createRouter } from '@/services/createRouter'
-import { component } from '@/utilities/testHelpers'
-import { withParams } from '@/services/withParams'
+import { describe, expectTypeOf, test } from "vite-plus/test";
+import { createUseRoute } from "@/compositions/useRoute";
+import { createRoute } from "@/services/createRoute";
+import { createRouter } from "@/services/createRouter";
+import { component } from "@/utilities/testHelpers";
+import { withParams } from "@/services/withParams";
 
 const parentA = createRoute({
-  name: 'parentA',
-  path: '/parentA',
-})
+  name: "parentA",
+  path: "/parentA",
+});
 
 const childA = createRoute({
   parent: parentA,
-  name: 'childA',
-  path: '[?foo]',
-  query: withParams('bar=[?bar]', { bar: Boolean }),
+  name: "childA",
+  path: "[?foo]",
+  query: withParams("bar=[?bar]", { bar: Boolean }),
   component,
-})
+});
 
 const parentB = createRoute({
-  name: 'parentB',
-  path: '/parentB',
+  name: "parentB",
+  path: "/parentB",
   component,
-})
+});
 
-const routes = [parentA, childA, parentB] as const
+const routes = [parentA, childA, parentB] as const;
 
-const { key } = createRouter(routes)
-const useRoute = createUseRoute(key)
+const { key } = createRouter(routes);
+const useRoute = createUseRoute(key);
 
-test('without arguments returns full route union', () => {
-  const route = useRoute()
+test("without arguments returns full route union", () => {
+  const route = useRoute();
 
-  expectTypeOf<typeof route.name>().toEqualTypeOf<'parentA' | 'childA' | 'parentB'>()
-})
+  expectTypeOf<typeof route.name>().toEqualTypeOf<"parentA" | "childA" | "parentB">();
+});
 
-describe('with exact', () => {
-  test('narrows to exact route name', () => {
-    const route = useRoute('parentA', { exact: true })
+describe("with exact", () => {
+  test("narrows to exact route name", () => {
+    const route = useRoute("parentA", { exact: true });
 
-    expectTypeOf<typeof route.name>().toEqualTypeOf<'parentA'>()
-  })
+    expectTypeOf<typeof route.name>().toEqualTypeOf<"parentA">();
+  });
 
-  test('narrows params', () => {
-    const routeA = useRoute('parentA', { exact: true })
+  test("narrows params", () => {
+    const routeA = useRoute("parentA", { exact: true });
 
-    expectTypeOf<typeof routeA.params>().toEqualTypeOf<{}>()
+    expectTypeOf<typeof routeA.params>().toEqualTypeOf<{}>();
 
-    const routeChild = useRoute('childA', { exact: true })
+    const routeChild = useRoute("childA", { exact: true });
 
     expectTypeOf<typeof routeChild.params>().toEqualTypeOf<{
-      foo?: string | undefined,
-      bar?: boolean | undefined,
-    }>()
-  })
-})
+      foo?: string | undefined;
+      bar?: boolean | undefined;
+    }>();
+  });
+});
 
-describe('without exact', () => {
-  test('narrows to route and descendants', () => {
-    const route = useRoute('parentA')
+describe("without exact", () => {
+  test("narrows to route and descendants", () => {
+    const route = useRoute("parentA");
 
-    expectTypeOf<typeof route.name>().toEqualTypeOf<'parentA' | 'childA'>()
-  })
+    expectTypeOf<typeof route.name>().toEqualTypeOf<"parentA" | "childA">();
+  });
 
-  test('narrows params to include descendants', () => {
-    const route = useRoute('parentA')
+  test("narrows params to include descendants", () => {
+    const route = useRoute("parentA");
 
-    expectTypeOf<typeof route.params>().toEqualTypeOf<{} | {
-      foo?: string | undefined,
-      bar?: boolean | undefined,
-    }>()
-  })
+    expectTypeOf<typeof route.params>().toEqualTypeOf<
+      | {}
+      | {
+          foo?: string | undefined;
+          bar?: boolean | undefined;
+        }
+    >();
+  });
 
-  test('for leaf route narrows to just that route', () => {
-    const route = useRoute('parentB')
+  test("for leaf route narrows to just that route", () => {
+    const route = useRoute("parentB");
 
-    expectTypeOf<typeof route.name>().toEqualTypeOf<'parentB'>()
-  })
+    expectTypeOf<typeof route.name>().toEqualTypeOf<"parentB">();
+  });
 
-  test('with explicit exact false behaves same as without exact', () => {
-    const route = useRoute('parentA', { exact: false })
+  test("with explicit exact false behaves same as without exact", () => {
+    const route = useRoute("parentA", { exact: false });
 
-    expectTypeOf<typeof route.name>().toEqualTypeOf<'parentA' | 'childA'>()
-  })
-})
+    expectTypeOf<typeof route.name>().toEqualTypeOf<"parentA" | "childA">();
+  });
+});
 
-test('siblings are not matched when an unnamed parent is present', () => {
+test("siblings are not matched when an unnamed parent is present", () => {
   const parent = createRoute({
-    path: '/',
+    path: "/",
     component,
-  })
+  });
 
   const childA = createRoute({
     parent: parent,
-    name: 'childA',
+    name: "childA",
     component,
-  })
+  });
 
   const childB = createRoute({
     parent: parent,
-    name: 'childB',
+    name: "childB",
     component,
-  })
+  });
 
   const grandChild = createRoute({
     parent: childA,
-    name: 'grandChild',
+    name: "grandChild",
     component,
-  })
+  });
 
-  const routes = [
-    parent,
-    childA,
-    childB,
-    grandChild,
-  ] as const
+  const routes = [parent, childA, childB, grandChild] as const;
 
-  const { key } = createRouter(routes)
-  const useRoute = createUseRoute(key)
+  const { key } = createRouter(routes);
+  const useRoute = createUseRoute(key);
 
-  const anyRoute = useRoute()
+  const anyRoute = useRoute();
 
-  expectTypeOf<typeof anyRoute.name>().toEqualTypeOf<'childA' | 'childB' | 'grandChild'>()
+  expectTypeOf<typeof anyRoute.name>().toEqualTypeOf<"childA" | "childB" | "grandChild">();
 
-  const childARoute = useRoute('childA')
+  const childARoute = useRoute("childA");
 
-  expectTypeOf<typeof childARoute.name>().toEqualTypeOf<'childA' | 'grandChild'>()
+  expectTypeOf<typeof childARoute.name>().toEqualTypeOf<"childA" | "grandChild">();
 
-  const childBRoute = useRoute('childB')
+  const childBRoute = useRoute("childB");
 
-  expectTypeOf<typeof childBRoute.name>().toEqualTypeOf<'childB'>()
+  expectTypeOf<typeof childBRoute.name>().toEqualTypeOf<"childB">();
 
-  const grandChildRoute = useRoute('grandChild')
+  const grandChildRoute = useRoute("grandChild");
 
-  expectTypeOf<typeof grandChildRoute.name>().toEqualTypeOf<'grandChild'>()
-})
+  expectTypeOf<typeof grandChildRoute.name>().toEqualTypeOf<"grandChild">();
+});
diff --git a/src/guards/routes.spec-d.ts b/src/guards/routes.spec-d.ts
index 4c100d27..37a4e212 100644
--- a/src/guards/routes.spec-d.ts
+++ b/src/guards/routes.spec-d.ts
@@ -1,82 +1,88 @@
-import { expectTypeOf, test } from 'vitest'
-import { createIsRoute } from '@/guards/routes'
-import { createRoute } from '@/services/createRoute'
-import { createRouter } from '@/services/createRouter'
-import { component } from '@/utilities/testHelpers'
-import { withParams } from '@/services/withParams'
+import { expectTypeOf, test } from "vite-plus/test";
+import { createIsRoute } from "@/guards/routes";
+import { createRoute } from "@/services/createRoute";
+import { createRouter } from "@/services/createRouter";
+import { component } from "@/utilities/testHelpers";
+import { withParams } from "@/services/withParams";
 
-test('router route can be narrowed', () => {
+test("router route can be narrowed", () => {
   const parentA = createRoute({
-    name: 'parentA',
-    path: '/parentA',
-  })
+    name: "parentA",
+    path: "/parentA",
+  });
 
   const childA = createRoute({
     parent: parentA,
-    name: 'childA',
-    path: '[?foo]',
-    query: withParams('bar=[?bar]', { bar: Boolean }),
+    name: "childA",
+    path: "[?foo]",
+    query: withParams("bar=[?bar]", { bar: Boolean }),
     component,
-  })
+  });
 
   const routes = [
     parentA,
     childA,
     createRoute({
-      name: 'parentB',
-      path: '/parentB',
+      name: "parentB",
+      path: "/parentB",
       component,
     }),
-  ] as const
+  ] as const;
 
-  const { route, key } = createRouter(routes)
-  const isRoute = createIsRoute(key)
+  const { route, key } = createRouter(routes);
+  const isRoute = createIsRoute(key);
 
-  expectTypeOf<typeof route.name>().toEqualTypeOf<'parentA' | 'parentB' | 'childA'>()
+  expectTypeOf<typeof route.name>().toEqualTypeOf<"parentA" | "parentB" | "childA">();
 
-  if (route.name === 'parentA') {
-    expectTypeOf<typeof route.name>().toEqualTypeOf<'parentA'>()
+  if (route.name === "parentA") {
+    expectTypeOf<typeof route.name>().toEqualTypeOf<"parentA">();
   }
 
-  if (isRoute(route, 'parentA', { exact: true })) {
-    expectTypeOf<typeof route.name>().toEqualTypeOf<'parentA'>()
+  if (isRoute(route, "parentA", { exact: true })) {
+    expectTypeOf<typeof route.name>().toEqualTypeOf<"parentA">();
   }
 
-  if (isRoute(route, 'parentB', { exact: true })) {
-    expectTypeOf<typeof route.name>().toEqualTypeOf<'parentB'>()
+  if (isRoute(route, "parentB", { exact: true })) {
+    expectTypeOf<typeof route.name>().toEqualTypeOf<"parentB">();
   }
 
-  if (isRoute(route, 'parentA', { exact: false })) {
-    expectTypeOf<typeof route.name>().toEqualTypeOf<'parentA' | 'childA'>()
+  if (isRoute(route, "parentA", { exact: false })) {
+    expectTypeOf<typeof route.name>().toEqualTypeOf<"parentA" | "childA">();
   }
 
-  if (isRoute(route, 'parentB', { exact: false })) {
-    expectTypeOf<typeof route.name>().toEqualTypeOf<'parentB'>()
+  if (isRoute(route, "parentB", { exact: false })) {
+    expectTypeOf<typeof route.name>().toEqualTypeOf<"parentB">();
   }
 
-  if (isRoute(route, 'parentA')) {
-    expectTypeOf<typeof route.name>().toEqualTypeOf<'parentA' | 'childA'>()
+  if (isRoute(route, "parentA")) {
+    expectTypeOf<typeof route.name>().toEqualTypeOf<"parentA" | "childA">();
   }
 
-  if (route.name === 'parentA') {
-    expectTypeOf<typeof route.params>().toEqualTypeOf<{}>()
+  if (route.name === "parentA") {
+    expectTypeOf<typeof route.params>().toEqualTypeOf<{}>();
   }
 
-  if (isRoute(route, 'parentA', { exact: true })) {
-    expectTypeOf<typeof route.params>().toEqualTypeOf<{}>()
+  if (isRoute(route, "parentA", { exact: true })) {
+    expectTypeOf<typeof route.params>().toEqualTypeOf<{}>();
   }
 
-  if (isRoute(route, 'parentA', { exact: false })) {
-    expectTypeOf<typeof route.params>().toEqualTypeOf<{} | {
-      foo?: string | undefined,
-      bar?: boolean | undefined,
-    }>()
+  if (isRoute(route, "parentA", { exact: false })) {
+    expectTypeOf<typeof route.params>().toEqualTypeOf<
+      | {}
+      | {
+          foo?: string | undefined;
+          bar?: boolean | undefined;
+        }
+    >();
   }
 
-  if (isRoute(route, 'parentA')) {
-    expectTypeOf<typeof route.params>().toEqualTypeOf<{} | {
-      foo?: string | undefined,
-      bar?: boolean | undefined,
-    }>()
+  if (isRoute(route, "parentA")) {
+    expectTypeOf<typeof route.params>().toEqualTypeOf<
+      | {}
+      | {
+          foo?: string | undefined;
+          bar?: boolean | undefined;
+        }
+    >();
   }
-})
+});
diff --git a/src/services/arrayOf.spec.ts b/src/services/arrayOf.spec.ts
index 77cbe70c..f943efe9 100644
--- a/src/services/arrayOf.spec.ts
+++ b/src/services/arrayOf.spec.ts
@@ -1,40 +1,40 @@
-import { expect, test } from 'vitest'
-import { arrayOf } from '@/services/arrayOf'
-import { getParamValue, setParamValue } from '@/services/params'
-import { InvalidRouteParamValueError } from '@/errors/invalidRouteParamValueError'
+import { expect, test } from "vite-plus/test";
+import { arrayOf } from "@/services/arrayOf";
+import { getParamValue, setParamValue } from "@/services/params";
+import { InvalidRouteParamValueError } from "@/errors/invalidRouteParamValueError";
 
 test.each([
-  ['23', [23]],
-  ['true,23,foo', [true, 23, 'foo']],
-  ['1,2,3,4,5', [1, 2, 3, 4, 5]],
-])('given an array of params with valid values, returns an array of values', (input, expected) => {
-  const array = arrayOf([Number, Boolean, String])
+  ["23", [23]],
+  ["true,23,foo", [true, 23, "foo"]],
+  ["1,2,3,4,5", [1, 2, 3, 4, 5]],
+])("given an array of params with valid values, returns an array of values", (input, expected) => {
+  const array = arrayOf([Number, Boolean, String]);
 
-  const result = getParamValue(input, { param: array })
+  const result = getParamValue(input, { param: array });
 
-  expect(result).toEqual(expected)
-})
+  expect(result).toEqual(expected);
+});
 
-test('given an array of params with an invalid value, throws InvalidRouteParamValueError', () => {
-  const array = arrayOf([Number, Boolean])
+test("given an array of params with an invalid value, throws InvalidRouteParamValueError", () => {
+  const array = arrayOf([Number, Boolean]);
 
-  const action: () => void = () => getParamValue('true, 23, foo', { param: array })
+  const action: () => void = () => getParamValue("true, 23, foo", { param: array });
 
-  expect(action).toThrow(InvalidRouteParamValueError)
-})
+  expect(action).toThrow(InvalidRouteParamValueError);
+});
 
-test('given value is not an array, throws InvalidRouteParamValueError', () => {
-  const array = arrayOf([Number, Boolean])
+test("given value is not an array, throws InvalidRouteParamValueError", () => {
+  const array = arrayOf([Number, Boolean]);
 
-  const action: () => void = () => setParamValue({}, { param: array })
+  const action: () => void = () => setParamValue({}, { param: array });
 
-  expect(action).toThrow('Expected an array')
-})
+  expect(action).toThrow("Expected an array");
+});
 
-test('given a separator, uses it to split the value', () => {
-  const array = arrayOf([Number, Boolean, String], { separator: '|' })
+test("given a separator, uses it to split the value", () => {
+  const array = arrayOf([Number, Boolean, String], { separator: "|" });
 
-  const result = getParamValue('1|2|3', { param: array })
+  const result = getParamValue("1|2|3", { param: array });
 
-  expect(result).toEqual([1, 2, 3])
-})
+  expect(result).toEqual([1, 2, 3]);
+});
diff --git a/src/services/combineHash.spec.ts b/src/services/combineHash.spec.ts
index edc0eb0d..6a88bc1a 100644
--- a/src/services/combineHash.spec.ts
+++ b/src/services/combineHash.spec.ts
@@ -1,48 +1,48 @@
-import { expect, test } from 'vitest'
-import { DuplicateParamsError } from '@/errors/duplicateParamsError'
-import { combineHash } from '@/services/combineHash'
-import { withParams } from '@/services/withParams'
+import { expect, test } from "vite-plus/test";
+import { DuplicateParamsError } from "@/errors/duplicateParamsError";
+import { combineHash } from "@/services/combineHash";
+import { withParams } from "@/services/withParams";
 
-test('given 2 hash, returns new Hash joined together', () => {
-  const aHash = withParams('/foo', {})
-  const bHash = withParams('/bar', {})
+test("given 2 hash, returns new Hash joined together", () => {
+  const aHash = withParams("/foo", {});
+  const bHash = withParams("/bar", {});
 
-  const response = combineHash(aHash, bHash)
+  const response = combineHash(aHash, bHash);
 
-  expect(response.value).toBe('/foo/bar')
-})
+  expect(response.value).toBe("/foo/bar");
+});
 
-test('given 2 hash with params, returns new Hash joined together with params', () => {
-  const aHash = withParams('/[foz]', { foz: Boolean })
-  const bHash = withParams('/[baz]', { baz: Number })
+test("given 2 hash with params, returns new Hash joined together with params", () => {
+  const aHash = withParams("/[foz]", { foz: Boolean });
+  const bHash = withParams("/[baz]", { baz: Number });
 
-  const response = combineHash(aHash, bHash)
+  const response = combineHash(aHash, bHash);
 
-  expect(response.value).toBe('/[foz]/[baz]')
+  expect(response.value).toBe("/[foz]/[baz]");
   expect(response.params).toMatchObject({
     foz: { param: Boolean, isOptional: false, isGreedy: false },
     baz: { param: Number, isOptional: false, isGreedy: false },
-  })
-})
+  });
+});
 
-test('given 2 hash with optional params, returns new Hash joined together with params', () => {
-  const aHash = withParams('/[?foz]', { foz: Boolean })
-  const bHash = withParams('/[?baz]', { baz: Number })
+test("given 2 hash with optional params, returns new Hash joined together with params", () => {
+  const aHash = withParams("/[?foz]", { foz: Boolean });
+  const bHash = withParams("/[?baz]", { baz: Number });
 
-  const response = combineHash(aHash, bHash)
+  const response = combineHash(aHash, bHash);
 
-  expect(response.value).toBe('/[?foz]/[?baz]')
+  expect(response.value).toBe("/[?foz]/[?baz]");
   expect(response.params).toMatchObject({
     foz: { param: Boolean, isOptional: true, isGreedy: false },
     baz: { param: Number, isOptional: true, isGreedy: false },
-  })
-})
+  });
+});
 
-test('given 2 hash with params that include duplicates, throws DuplicateParamsError', () => {
-  const aHash = withParams('/[foz]', { foz: String })
-  const bHash = withParams('/[foz]', { foz: String })
+test("given 2 hash with params that include duplicates, throws DuplicateParamsError", () => {
+  const aHash = withParams("/[foz]", { foz: String });
+  const bHash = withParams("/[foz]", { foz: String });
 
-  const action: () => void = () => combineHash(aHash, bHash)
+  const action: () => void = () => combineHash(aHash, bHash);
 
-  expect(action).toThrow(DuplicateParamsError)
-})
+  expect(action).toThrow(DuplicateParamsError);
+});
diff --git a/src/services/combineMeta.spec.ts b/src/services/combineMeta.spec.ts
index 0b756d8c..b488866a 100644
--- a/src/services/combineMeta.spec.ts
+++ b/src/services/combineMeta.spec.ts
@@ -1,35 +1,35 @@
-import { expect, test } from 'vitest'
-import { MetaPropertyConflict } from '@/errors/metaPropertyConflict'
-import { combineMeta } from '@/services/combineMeta'
+import { expect, test } from "vite-plus/test";
+import { MetaPropertyConflict } from "@/errors/metaPropertyConflict";
+import { combineMeta } from "@/services/combineMeta";
 
-test('given 2 meta objects, returns new meta joined together', () => {
-  const aMeta = { foz: 123 }
-  const bMeta = { baz: 'baz' }
+test("given 2 meta objects, returns new meta joined together", () => {
+  const aMeta = { foz: 123 };
+  const bMeta = { baz: "baz" };
 
-  const response = combineMeta(aMeta, bMeta)
+  const response = combineMeta(aMeta, bMeta);
 
   expect(response).toMatchObject({
     foz: 123,
-    baz: 'baz',
-  })
-})
+    baz: "baz",
+  });
+});
 
-test('given 2 meta objects with duplicate properties but same type, overrides parent value with child', () => {
-  const aMeta = { foz: 123 }
-  const bMeta = { foz: 456 }
+test("given 2 meta objects with duplicate properties but same type, overrides parent value with child", () => {
+  const aMeta = { foz: 123 };
+  const bMeta = { foz: 456 };
 
-  const response = combineMeta(aMeta, bMeta)
+  const response = combineMeta(aMeta, bMeta);
 
   expect(response).toMatchObject({
     foz: 456,
-  })
-})
+  });
+});
 
-test('given 2 meta objects with duplicate properties with DIFFERENT types, throws MetaPropertyConflict error', () => {
-  const aMeta = { foz: 123 }
-  const bMeta = { foz: 'baz' }
+test("given 2 meta objects with duplicate properties with DIFFERENT types, throws MetaPropertyConflict error", () => {
+  const aMeta = { foz: 123 };
+  const bMeta = { foz: "baz" };
 
-  const action: () => void = () => combineMeta(aMeta, bMeta)
+  const action: () => void = () => combineMeta(aMeta, bMeta);
 
-  expect(action).toThrow(MetaPropertyConflict)
-})
+  expect(action).toThrow(MetaPropertyConflict);
+});
diff --git a/src/services/combinePath.spec-d.ts b/src/services/combinePath.spec-d.ts
index 145801e0..3a41c447 100644
--- a/src/services/combinePath.spec-d.ts
+++ b/src/services/combinePath.spec-d.ts
@@ -1,86 +1,86 @@
-import { expectTypeOf, test } from 'vitest'
-import { withParams, UrlPart } from '@/services/withParams'
-import { combinePath } from './combinePath'
+import { expectTypeOf, test } from "vite-plus/test";
+import { withParams, UrlPart } from "@/services/withParams";
+import { combinePath } from "./combinePath";
 
-test('given withParams without params, combines value, leaves params empty', () => {
-  const parent = withParams('/parent-without-params', {})
-  const child = withParams('/child-without-params', {})
+test("given withParams without params, combines value, leaves params empty", () => {
+  const parent = withParams("/parent-without-params", {});
+  const child = withParams("/child-without-params", {});
 
-  const response = combinePath(parent, child)
+  const response = combinePath(parent, child);
 
-  type Source = typeof response
-  type Expect = UrlPart<{}>
+  type Source = typeof response;
+  type Expect = UrlPart<{}>;
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-})
+  expectTypeOf<Source>().toEqualTypeOf<Expect>();
+});
 
-test('given withParams with unassigned params on parent, combines value, has single param from parent', () => {
-  const parent = withParams('/parent-with-[param]', {})
-  const child = withParams('/child-without-params', {})
+test("given withParams with unassigned params on parent, combines value, has single param from parent", () => {
+  const parent = withParams("/parent-with-[param]", {});
+  const child = withParams("/child-without-params", {});
 
-  const response = combinePath(parent, child)
+  const response = combinePath(parent, child);
 
-  type Source = typeof response
+  type Source = typeof response;
   type Expect = UrlPart<{
-    param: { param: StringConstructor, isOptional: false, isGreedy: false },
-  }>
+    param: { param: StringConstructor; isOptional: false; isGreedy: false };
+  }>;
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-})
+  expectTypeOf<Source>().toEqualTypeOf<Expect>();
+});
 
-test('given withParams with optional unassigned params on parent, combines value, has single param from parent', () => {
-  const parent = withParams('/parent-with-[?param]', {})
-  const child = withParams('/child-without-params', {})
+test("given withParams with optional unassigned params on parent, combines value, has single param from parent", () => {
+  const parent = withParams("/parent-with-[?param]", {});
+  const child = withParams("/child-without-params", {});
 
-  const response = combinePath(parent, child)
+  const response = combinePath(parent, child);
 
-  type Source = typeof response
+  type Source = typeof response;
   type Expect = UrlPart<{
-    param: { param: StringConstructor, isOptional: true, isGreedy: false },
-  }>
+    param: { param: StringConstructor; isOptional: true; isGreedy: false };
+  }>;
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-})
+  expectTypeOf<Source>().toEqualTypeOf<Expect>();
+});
 
-test('given withParams with params on parent, combines value, has single param from parent', () => {
-  const parent = withParams('/parent-with-[param]', { param: Boolean })
-  const child = withParams('/child-without-params', {})
+test("given withParams with params on parent, combines value, has single param from parent", () => {
+  const parent = withParams("/parent-with-[param]", { param: Boolean });
+  const child = withParams("/child-without-params", {});
 
-  const response = combinePath(parent, child)
+  const response = combinePath(parent, child);
 
-  type Source = typeof response
+  type Source = typeof response;
   type Expect = UrlPart<{
-    param: { param: BooleanConstructor, isOptional: false, isGreedy: false },
-  }>
+    param: { param: BooleanConstructor; isOptional: false; isGreedy: false };
+  }>;
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-})
+  expectTypeOf<Source>().toEqualTypeOf<Expect>();
+});
 
-test('given withParams with optional params on parent, combines value, has single param from parent', () => {
-  const parent = withParams('/parent-with-[?param]', { param: Boolean })
-  const child = withParams('/child-without-params', {})
+test("given withParams with optional params on parent, combines value, has single param from parent", () => {
+  const parent = withParams("/parent-with-[?param]", { param: Boolean });
+  const child = withParams("/child-without-params", {});
 
-  const response = combinePath(parent, child)
+  const response = combinePath(parent, child);
 
-  type Source = typeof response
+  type Source = typeof response;
   type Expect = UrlPart<{
-    param: { param: BooleanConstructor, isOptional: true, isGreedy: false },
-  }>
+    param: { param: BooleanConstructor; isOptional: true; isGreedy: false };
+  }>;
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-})
+  expectTypeOf<Source>().toEqualTypeOf<Expect>();
+});
 
-test('given withParams with params on both, combines value, has single param from parent', () => {
-  const parent = withParams('/parent-with-[param]', { param: Boolean })
-  const child = withParams('/child-with-[something]', { something: Number })
+test("given withParams with params on both, combines value, has single param from parent", () => {
+  const parent = withParams("/parent-with-[param]", { param: Boolean });
+  const child = withParams("/child-with-[something]", { something: Number });
 
-  const response = combinePath(parent, child)
+  const response = combinePath(parent, child);
 
-  type Source = typeof response
+  type Source = typeof response;
   type Expect = UrlPart<{
-    param: { param: BooleanConstructor, isOptional: false, isGreedy: false },
-    something: { param: NumberConstructor, isOptional: false, isGreedy: false },
-  }>
+    param: { param: BooleanConstructor; isOptional: false; isGreedy: false };
+    something: { param: NumberConstructor; isOptional: false; isGreedy: false };
+  }>;
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-})
+  expectTypeOf<Source>().toEqualTypeOf<Expect>();
+});
diff --git a/src/services/combinePath.spec.ts b/src/services/combinePath.spec.ts
index e838df8f..7b809e41 100644
--- a/src/services/combinePath.spec.ts
+++ b/src/services/combinePath.spec.ts
@@ -1,48 +1,48 @@
-import { expect, test } from 'vitest'
-import { DuplicateParamsError } from '@/errors/duplicateParamsError'
-import { combinePath } from '@/services/combinePath'
-import { withParams } from '@/services/withParams'
+import { expect, test } from "vite-plus/test";
+import { DuplicateParamsError } from "@/errors/duplicateParamsError";
+import { combinePath } from "@/services/combinePath";
+import { withParams } from "@/services/withParams";
 
-test('given 2 paths, returns new Path joined together', () => {
-  const aPath = withParams('/foo', {})
-  const bPath = withParams('/bar', {})
+test("given 2 paths, returns new Path joined together", () => {
+  const aPath = withParams("/foo", {});
+  const bPath = withParams("/bar", {});
 
-  const response = combinePath(aPath, bPath)
+  const response = combinePath(aPath, bPath);
 
-  expect(response.value).toBe('/foo/bar')
-})
+  expect(response.value).toBe("/foo/bar");
+});
 
-test('given 2 paths with params, returns new Path joined together with params', () => {
-  const aPath = withParams('/[foz]', { foz: Boolean })
-  const bPath = withParams('/[baz]', { baz: Number })
+test("given 2 paths with params, returns new Path joined together with params", () => {
+  const aPath = withParams("/[foz]", { foz: Boolean });
+  const bPath = withParams("/[baz]", { baz: Number });
 
-  const response = combinePath(aPath, bPath)
+  const response = combinePath(aPath, bPath);
 
-  expect(response.value).toBe('/[foz]/[baz]')
+  expect(response.value).toBe("/[foz]/[baz]");
   expect(response.params).toMatchObject({
     foz: { param: Boolean, isOptional: false, isGreedy: false },
     baz: { param: Number, isOptional: false, isGreedy: false },
-  })
-})
+  });
+});
 
-test('given 2 paths with optional params, returns new Path joined together with params', () => {
-  const aPath = withParams('/[?foz]', { foz: Boolean })
-  const bPath = withParams('/[?baz]', { baz: Number })
+test("given 2 paths with optional params, returns new Path joined together with params", () => {
+  const aPath = withParams("/[?foz]", { foz: Boolean });
+  const bPath = withParams("/[?baz]", { baz: Number });
 
-  const response = combinePath(aPath, bPath)
+  const response = combinePath(aPath, bPath);
 
-  expect(response.value).toBe('/[?foz]/[?baz]')
+  expect(response.value).toBe("/[?foz]/[?baz]");
   expect(response.params).toMatchObject({
     foz: { param: Boolean, isOptional: true, isGreedy: false },
     baz: { param: Number, isOptional: true, isGreedy: false },
-  })
-})
+  });
+});
 
-test('given 2 paths with params that include duplicates, throws DuplicateParamsError', () => {
-  const aPath = withParams('/[foz]', { foz: String })
-  const bPath = withParams('/[foz]', { foz: String })
+test("given 2 paths with params that include duplicates, throws DuplicateParamsError", () => {
+  const aPath = withParams("/[foz]", { foz: String });
+  const bPath = withParams("/[foz]", { foz: String });
 
-  const action: () => void = () => combinePath(aPath, bPath)
+  const action: () => void = () => combinePath(aPath, bPath);
 
-  expect(action).toThrow(DuplicateParamsError)
-})
+  expect(action).toThrow(DuplicateParamsError);
+});
diff --git a/src/services/combineQuery.spec.ts b/src/services/combineQuery.spec.ts
index 166b60ce..1c80ce8f 100644
--- a/src/services/combineQuery.spec.ts
+++ b/src/services/combineQuery.spec.ts
@@ -1,48 +1,48 @@
-import { expect, test } from 'vitest'
-import { DuplicateParamsError } from '@/errors/duplicateParamsError'
-import { combineQuery } from '@/services/combineQuery'
-import { withParams } from '@/services/withParams'
+import { expect, test } from "vite-plus/test";
+import { DuplicateParamsError } from "@/errors/duplicateParamsError";
+import { combineQuery } from "@/services/combineQuery";
+import { withParams } from "@/services/withParams";
 
-test('given 2 queries, returns new Query joined together', () => {
-  const aQuery = withParams('foo=ABC', {})
-  const bQuery = withParams('bar=123', {})
+test("given 2 queries, returns new Query joined together", () => {
+  const aQuery = withParams("foo=ABC", {});
+  const bQuery = withParams("bar=123", {});
 
-  const response = combineQuery(aQuery, bQuery)
+  const response = combineQuery(aQuery, bQuery);
 
-  expect(response.value).toBe('foo=ABC&bar=123')
-})
+  expect(response.value).toBe("foo=ABC&bar=123");
+});
 
-test('given 2 queries with params, returns new Query joined together with params', () => {
-  const aQuery = withParams('foo=[foz]', { foz: Boolean })
-  const bQuery = withParams('bar=[baz]', { baz: Number })
+test("given 2 queries with params, returns new Query joined together with params", () => {
+  const aQuery = withParams("foo=[foz]", { foz: Boolean });
+  const bQuery = withParams("bar=[baz]", { baz: Number });
 
-  const response = combineQuery(aQuery, bQuery)
+  const response = combineQuery(aQuery, bQuery);
 
-  expect(response.value).toBe('foo=[foz]&bar=[baz]')
+  expect(response.value).toBe("foo=[foz]&bar=[baz]");
   expect(response.params).toMatchObject({
     foz: { param: Boolean, isOptional: false, isGreedy: false },
     baz: { param: Number, isOptional: false, isGreedy: false },
-  })
-})
+  });
+});
 
-test('given 2 queries with optional params, returns new Query joined together with params', () => {
-  const aQuery = withParams('foo=[?foz]', { foz: Boolean })
-  const bQuery = withParams('bar=[?baz]', { baz: Number })
+test("given 2 queries with optional params, returns new Query joined together with params", () => {
+  const aQuery = withParams("foo=[?foz]", { foz: Boolean });
+  const bQuery = withParams("bar=[?baz]", { baz: Number });
 
-  const response = combineQuery(aQuery, bQuery)
+  const response = combineQuery(aQuery, bQuery);
 
-  expect(response.value).toBe('foo=[?foz]&bar=[?baz]')
+  expect(response.value).toBe("foo=[?foz]&bar=[?baz]");
   expect(response.params).toMatchObject({
     foz: { param: Boolean, isOptional: true, isGreedy: false },
     baz: { param: Number, isOptional: true, isGreedy: false },
-  })
-})
+  });
+});
 
-test('given 2 queries with params that include duplicates, throws DuplicateParamsError', () => {
-  const aQuery = withParams('foo=[foz]', { foz: String })
-  const bQuery = withParams('foo=[foz]', { foz: String })
+test("given 2 queries with params that include duplicates, throws DuplicateParamsError", () => {
+  const aQuery = withParams("foo=[foz]", { foz: String });
+  const bQuery = withParams("foo=[foz]", { foz: String });
 
-  const action: () => void = () => combineQuery(aQuery, bQuery)
+  const action: () => void = () => combineQuery(aQuery, bQuery);
 
-  expect(action).toThrow(DuplicateParamsError)
-})
+  expect(action).toThrow(DuplicateParamsError);
+});
diff --git a/src/services/combineState.spec.ts b/src/services/combineState.spec.ts
index 872d6425..3205c541 100644
--- a/src/services/combineState.spec.ts
+++ b/src/services/combineState.spec.ts
@@ -1,24 +1,24 @@
-import { expect, test } from 'vitest'
-import { DuplicateParamsError } from '@/errors/duplicateParamsError'
-import { combineState } from '@/services/combineState'
+import { expect, test } from "vite-plus/test";
+import { DuplicateParamsError } from "@/errors/duplicateParamsError";
+import { combineState } from "@/services/combineState";
 
-test('given 2 states, returns new State joined together', () => {
-  const aState = { foz: String }
-  const bState = { baz: Number }
+test("given 2 states, returns new State joined together", () => {
+  const aState = { foz: String };
+  const bState = { baz: Number };
 
-  const response = combineState(aState, bState)
+  const response = combineState(aState, bState);
 
   expect(response).toMatchObject({
     foz: String,
     baz: Number,
-  })
-})
+  });
+});
 
-test('given 2 states with params that include duplicates, throws DuplicateParamsError', () => {
-  const aState = { foz: String }
-  const bState = { foz: Number }
+test("given 2 states with params that include duplicates, throws DuplicateParamsError", () => {
+  const aState = { foz: String };
+  const bState = { foz: Number };
 
-  const action: () => void = () => combineState(aState, bState)
+  const action: () => void = () => combineState(aState, bState);
 
-  expect(action).toThrow(DuplicateParamsError)
-})
+  expect(action).toThrow(DuplicateParamsError);
+});
diff --git a/src/services/combineUrl.spec.ts b/src/services/combineUrl.spec.ts
index 74b26d52..535ea6d6 100644
--- a/src/services/combineUrl.spec.ts
+++ b/src/services/combineUrl.spec.ts
@@ -1,43 +1,43 @@
-import { expect, test } from 'vitest'
-import { combineUrl } from '@/services/combineUrl'
-import { createUrl } from '@/services/createUrl'
+import { expect, test } from "vite-plus/test";
+import { combineUrl } from "@/services/combineUrl";
+import { createUrl } from "@/services/createUrl";
 
 test.each([
-  [{ host: 'https://kitbag.dev' }, { host: 'https://kitbag.com' }],
-  [{ host: 'https://kitbag.dev' }, { host: '' }],
-  [{ host: 'https://kitbag.dev' }, { host: undefined }],
-])('given parent host (%s) and child host (%s), returns parent host', (parent, child) => {
-  const url = combineUrl(createUrl(parent), createUrl(child))
+  [{ host: "https://kitbag.dev" }, { host: "https://kitbag.com" }],
+  [{ host: "https://kitbag.dev" }, { host: "" }],
+  [{ host: "https://kitbag.dev" }, { host: undefined }],
+])("given parent host (%s) and child host (%s), returns parent host", (parent, child) => {
+  const url = combineUrl(createUrl(parent), createUrl(child));
 
-  expect(url.stringify()).toBe('https://kitbag.dev/')
-})
+  expect(url.stringify()).toBe("https://kitbag.dev/");
+});
 
 test.each([
-  [{ path: '/foo' }, { path: '/bar' }],
-  [{ path: '/foo/bar' }, { path: '' }],
-  [{ path: '/foo/bar' }, { path: undefined }],
-])('given parent path (%s) and child path (%s), returns paths combined', (parent, child) => {
-  const url = combineUrl(createUrl(parent), createUrl(child))
+  [{ path: "/foo" }, { path: "/bar" }],
+  [{ path: "/foo/bar" }, { path: "" }],
+  [{ path: "/foo/bar" }, { path: undefined }],
+])("given parent path (%s) and child path (%s), returns paths combined", (parent, child) => {
+  const url = combineUrl(createUrl(parent), createUrl(child));
 
-  expect(url.stringify()).toBe('/foo/bar')
-})
+  expect(url.stringify()).toBe("/foo/bar");
+});
 
 test.each([
-  [{ query: '?foo=456' }, { query: '?bar=123' }],
-  [{ query: '?foo=456&bar=123' }, { query: '' }],
-  [{ query: '?foo=456&bar=123' }, { query: undefined }],
-])('given parent query (%s) and child query (%s), returns child query', (parent, child) => {
-  const url = combineUrl(createUrl(parent), createUrl(child))
+  [{ query: "?foo=456" }, { query: "?bar=123" }],
+  [{ query: "?foo=456&bar=123" }, { query: "" }],
+  [{ query: "?foo=456&bar=123" }, { query: undefined }],
+])("given parent query (%s) and child query (%s), returns child query", (parent, child) => {
+  const url = combineUrl(createUrl(parent), createUrl(child));
 
-  expect(url.stringify()).toBe('/?foo=456&bar=123')
-})
+  expect(url.stringify()).toBe("/?foo=456&bar=123");
+});
 
 test.each([
-  [{ hash: '#foo' }, { hash: '#bar' }],
-  [{ hash: '#foobar' }, { hash: '' }],
-  [{ hash: '#foobar' }, { hash: undefined }],
-])('given parent hash (%s) and child hash (%s), returns child hash', (parent, child) => {
-  const url = combineUrl(createUrl(parent), createUrl(child))
-
-  expect(url.stringify()).toBe('/#foobar')
-})
+  [{ hash: "#foo" }, { hash: "#bar" }],
+  [{ hash: "#foobar" }, { hash: "" }],
+  [{ hash: "#foobar" }, { hash: undefined }],
+])("given parent hash (%s) and child hash (%s), returns child hash", (parent, child) => {
+  const url = combineUrl(createUrl(parent), createUrl(child));
+
+  expect(url.stringify()).toBe("/#foobar");
+});
diff --git a/src/services/component.browser.spec.ts b/src/services/component.browser.spec.ts
index 7a9ac320..02a53517 100644
--- a/src/services/component.browser.spec.ts
+++ b/src/services/component.browser.spec.ts
@@ -1,119 +1,128 @@
-import { flushPromises, mount } from '@vue/test-utils'
-import { expect, test } from 'vitest'
-import echo from '@/components/echo'
-import { createRoute } from '@/services/createRoute'
-import { createRouter } from '@/services/createRouter'
-import { h, defineComponent, getCurrentInstance } from 'vue'
-
-test('renders component with sync props', async () => {
-  const route = createRoute({
-    name: 'echo',
-    path: '/echo',
-    component: echo,
-  }, () => ({ value: 'echo' }))
+import { flushPromises, mount } from "@vue/test-utils";
+import { expect, test } from "vite-plus/test";
+import echo from "@/components/echo";
+import { createRoute } from "@/services/createRoute";
+import { createRouter } from "@/services/createRouter";
+import { h, defineComponent, getCurrentInstance } from "vue";
+
+test("renders component with sync props", async () => {
+  const route = createRoute(
+    {
+      name: "echo",
+      path: "/echo",
+      component: echo,
+    },
+    () => ({ value: "echo" }),
+  );
 
   const router = createRouter([route], {
-    initialUrl: '/',
-  })
+    initialUrl: "/",
+  });
 
-  await router.start()
+  await router.start();
 
   const root = {
-    template: '<RouterView/>',
-  }
+    template: "<RouterView/>",
+  };
 
   const wrapper = mount(root, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  await router.push('echo')
+  await router.push("echo");
 
-  expect(wrapper.html()).toBe('echo')
-})
+  expect(wrapper.html()).toBe("echo");
+});
 
-test('renders component with async props', async () => {
-  const route = createRoute({
-    name: 'echo',
-    path: '/echo',
-    component: echo,
-  }, async () => ({ value: 'echo' }))
+test("renders component with async props", async () => {
+  const route = createRoute(
+    {
+      name: "echo",
+      path: "/echo",
+      component: echo,
+    },
+    async () => ({ value: "echo" }),
+  );
 
   const router = createRouter([route], {
-    initialUrl: '/',
-  })
+    initialUrl: "/",
+  });
 
-  await router.start()
+  await router.start();
 
   const root = {
-    template: '<RouterView/>',
-  }
+    template: "<RouterView/>",
+  };
 
   const wrapper = mount(root, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  await router.push('echo')
+  await router.push("echo");
 
   // needed for async props
-  await flushPromises()
+  await flushPromises();
 
-  expect(wrapper.html()).toBe('echo')
-})
+  expect(wrapper.html()).toBe("echo");
+});
 
-test('component instance has suspense property when suspense is used', async () => {
+test("component instance has suspense property when suspense is used", async () => {
   const testComponent = defineComponent({
     setup() {
       // @ts-expect-error there isn't a way to check if suspense is used in the component without accessing a private property
-      const hasSuspense = Boolean(getCurrentInstance()?.suspense)
+      const hasSuspense = Boolean(getCurrentInstance()?.suspense);
 
-      return () => h('span', hasSuspense)
+      return () => h("span", hasSuspense);
     },
-  })
+  });
 
   const appWithSuspenseRoot = {
-    template: '<Suspense><test-component/></Suspense>',
+    template: "<Suspense><test-component/></Suspense>",
     components: {
       testComponent,
     },
-  }
+  };
 
-  const appWithSuspense = mount(appWithSuspenseRoot)
+  const appWithSuspense = mount(appWithSuspenseRoot);
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(appWithSuspense.text()).toBe('true')
+  expect(appWithSuspense.text()).toBe("true");
 
   const appWithoutSuspenseRoot = {
-    template: '<test-component/>',
+    template: "<test-component/>",
     components: {
       testComponent,
     },
-  }
+  };
 
-  const appWithoutSuspense = mount(appWithoutSuspenseRoot)
+  const appWithoutSuspense = mount(appWithoutSuspenseRoot);
 
-  expect(appWithoutSuspense.text()).toBe('false')
-})
+  expect(appWithoutSuspense.text()).toBe("false");
+});
 
-test('renders component with async props using suspense', async () => {
-  const { promise, resolve } = Promise.withResolvers<{ value: string }>()
-  const fallback = 'Loading...'
+test("renders component with async props using suspense", async () => {
+  const { promise, resolve } = Promise.withResolvers<{ value: string }>();
+  const fallback = "Loading...";
 
-  const route = createRoute({
-    name: 'home',
-    path: '/',
-    component: echo,
-  }, () => promise)
+  const route = createRoute(
+    {
+      name: "home",
+      path: "/",
+      component: echo,
+    },
+    () => promise,
+  );
 
   const router = createRouter([route], {
-    initialUrl: '/',
-  })
+    initialUrl: "/",
+  });
 
-  await router.start()
+  await router.start();
 
   const root = {
     template: `
@@ -124,21 +133,21 @@ test('renders component with async props using suspense', async () => {
         <RouterView/>
       </Suspense>
     `,
-  }
+  };
 
   const wrapper = mount(root, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  await router.push('home')
+  await router.push("home");
 
-  expect(wrapper.text()).toBe(fallback)
+  expect(wrapper.text()).toBe(fallback);
 
-  resolve({ value: 'hello world' })
+  resolve({ value: "hello world" });
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(wrapper.html()).toBe('hello world')
-})
+  expect(wrapper.html()).toBe("hello world");
+});
diff --git a/src/services/createExternalRoute.spec.ts b/src/services/createExternalRoute.spec.ts
index b3e8220e..ccaccb34 100644
--- a/src/services/createExternalRoute.spec.ts
+++ b/src/services/createExternalRoute.spec.ts
@@ -1,65 +1,69 @@
-import { expect, test } from 'vitest'
-import { createExternalRoute } from '@/services/createExternalRoute'
-import { DuplicateParamsError } from '@/errors/duplicateParamsError'
-import { withParams } from '@/services/withParams'
+import { expect, test } from "vite-plus/test";
+import { createExternalRoute } from "@/services/createExternalRoute";
+import { DuplicateParamsError } from "@/errors/duplicateParamsError";
+import { withParams } from "@/services/withParams";
 
-test('given parent, path is combined', () => {
+test("given parent, path is combined", () => {
   const parent = createExternalRoute({
-    host: 'https://kitbag.dev',
-    path: '/parent',
-  })
+    host: "https://kitbag.dev",
+    path: "/parent",
+  });
 
   const child = createExternalRoute({
     parent: parent,
-    path: withParams('/child/[id]', { id: Number }),
-  })
+    path: withParams("/child/[id]", { id: Number }),
+  });
 
-  expect(child.stringify({ id: 123 })).toBe('https://kitbag.dev/parent/child/123')
-})
+  expect(child.stringify({ id: 123 })).toBe("https://kitbag.dev/parent/child/123");
+});
 
-test('given parent, query is combined', () => {
+test("given parent, query is combined", () => {
   const parent = createExternalRoute({
-    host: 'https://kitbag.dev',
-    query: 'static=123',
-  })
+    host: "https://kitbag.dev",
+    query: "static=123",
+  });
 
   const child = createExternalRoute({
     parent: parent,
-    query: withParams('sort=[sort]', { sort: Boolean }),
-  })
+    query: withParams("sort=[sort]", { sort: Boolean }),
+  });
 
-  expect(child.stringify({ sort: true })).toBe('https://kitbag.dev/?static=123&sort=true')
-})
+  expect(child.stringify({ sort: true })).toBe("https://kitbag.dev/?static=123&sort=true");
+});
 
-test('given parent and child without meta, meta matches parent', () => {
+test("given parent and child without meta, meta matches parent", () => {
   const parent = createExternalRoute({
-    host: 'https://kitbag.dev',
+    host: "https://kitbag.dev",
     meta: {
       foo: 123,
     },
-  })
+  });
 
   const child = createExternalRoute({
     parent: parent,
-  })
+  });
 
   expect(child.meta).toMatchObject({
     foo: 123,
-  })
-})
+  });
+});
 
 test.each([
-  ['https://[foo].dev', '/[foo]', 'foo=[zoo]', '[bar]'],
-  ['https://[zoo].dev', '/[foo]', 'foo=[bar]', '[foo]'],
-  ['https://[zoo].dev', '/[bar]', 'foo=[foo]', '[foo]'],
-  ['https://[zoo].dev', '/[bar]', 'foo=[foo]', '[foo]'],
-])('given duplicate params across different parts of the route, throws DuplicateParamsError', (host, path, query, hash) => {
-  const action: () => void = () => createExternalRoute({
-    host,
-    path,
-    query,
-    hash,
-  })
+  ["https://[foo].dev", "/[foo]", "foo=[zoo]", "[bar]"],
+  ["https://[zoo].dev", "/[foo]", "foo=[bar]", "[foo]"],
+  ["https://[zoo].dev", "/[bar]", "foo=[foo]", "[foo]"],
+  ["https://[zoo].dev", "/[bar]", "foo=[foo]", "[foo]"],
+])(
+  "given duplicate params across different parts of the route, throws DuplicateParamsError",
+  (host, path, query, hash) => {
+    const action: () => void = () =>
+      createExternalRoute({
+        host,
+        path,
+        query,
+        hash,
+      });
 
-  expect(action).toThrow(DuplicateParamsError)
-})
+    expect(action).toThrow(DuplicateParamsError);
+  },
+);
diff --git a/src/services/createIsExternal.spec.ts b/src/services/createIsExternal.spec.ts
index ad4e7386..85d7c96e 100644
--- a/src/services/createIsExternal.spec.ts
+++ b/src/services/createIsExternal.spec.ts
@@ -1,32 +1,32 @@
-import { expect, test } from 'vitest'
-import { createIsExternal } from '@/services/createIsExternal'
+import { expect, test } from "vite-plus/test";
+import { createIsExternal } from "@/services/createIsExternal";
 
-test('given undefined host, returns true', () => {
-  const host: string | undefined = undefined
-  const url = 'https://router.kitbag.dev/introduction.html#introduction'
+test("given undefined host, returns true", () => {
+  const host: string | undefined = undefined;
+  const url = "https://router.kitbag.dev/introduction.html#introduction";
 
-  const isExternal = createIsExternal(host)
-  const response = isExternal(url)
+  const isExternal = createIsExternal(host);
+  const response = isExternal(url);
 
-  expect(response).toBe(true)
-})
+  expect(response).toBe(true);
+});
 
-test('given host with url that matches, returns false', () => {
-  const host = 'https://router.kitbag.dev'
-  const url = 'https://router.kitbag.dev/introduction.html#introduction'
+test("given host with url that matches, returns false", () => {
+  const host = "https://router.kitbag.dev";
+  const url = "https://router.kitbag.dev/introduction.html#introduction";
 
-  const isExternal = createIsExternal(host)
-  const response = isExternal(url)
+  const isExternal = createIsExternal(host);
+  const response = isExternal(url);
 
-  expect(response).toBe(false)
-})
+  expect(response).toBe(false);
+});
 
-test('given host with url that does NOT match, returns true', () => {
-  const host = 'https://github.com'
-  const url = 'https://router.kitbag.dev/introduction.html#introduction'
+test("given host with url that does NOT match, returns true", () => {
+  const host = "https://github.com";
+  const url = "https://router.kitbag.dev/introduction.html#introduction";
 
-  const isExternal = createIsExternal(host)
-  const response = isExternal(url)
+  const isExternal = createIsExternal(host);
+  const response = isExternal(url);
 
-  expect(response).toBe(true)
-})
+  expect(response).toBe(true);
+});
diff --git a/src/services/createResolvedRoute.spec.ts b/src/services/createResolvedRoute.spec.ts
index 3418c1f6..a57a8791 100644
--- a/src/services/createResolvedRoute.spec.ts
+++ b/src/services/createResolvedRoute.spec.ts
@@ -1,73 +1,73 @@
-import { describe, expect, test } from 'vitest'
-import { createRoute } from '@/services/createRoute'
-import { createResolvedRoute } from '@/services/createResolvedRoute'
-import { component } from '@/utilities/testHelpers'
+import { describe, expect, test } from "vite-plus/test";
+import { createRoute } from "@/services/createRoute";
+import { createResolvedRoute } from "@/services/createResolvedRoute";
+import { component } from "@/utilities/testHelpers";
 
-test('given a route with params returns all params', () => {
+test("given a route with params returns all params", () => {
   const route = createRoute({
-    name: 'route',
-    path: '/[paramA]',
-    query: 'paramB=[paramB]',
+    name: "route",
+    path: "/[paramA]",
+    query: "paramB=[paramB]",
     component,
-  })
-  const response = createResolvedRoute(route, { paramA: 'A', paramB: 'B' })
+  });
+  const response = createResolvedRoute(route, { paramA: "A", paramB: "B" });
 
   expect(response.params).toMatchObject({
-    paramA: 'A',
-    paramB: 'B',
-  })
-})
+    paramA: "A",
+    paramB: "B",
+  });
+});
 
-test('given state that matches state params, returns state', () => {
+test("given state that matches state params, returns state", () => {
   const parent = createRoute({
-    name: 'parent',
+    name: "parent",
     state: { foo: Boolean },
-  })
+  });
 
   const child = createRoute({
     parent,
-    name: 'foo',
-    path: '/foo',
+    name: "foo",
+    path: "/foo",
     component,
     state: { bar: String },
-  })
+  });
 
-  const response = createResolvedRoute(child, {}, { state: { foo: 'true', bar: 'abc' } })
+  const response = createResolvedRoute(child, {}, { state: { foo: "true", bar: "abc" } });
 
-  expect(response.state).toMatchObject({ foo: true, bar: 'abc' })
-})
+  expect(response.state).toMatchObject({ foo: true, bar: "abc" });
+});
 
-describe('resolve options', () => {
-  test('given options with query combines with query from route', () => {
+describe("resolve options", () => {
+  test("given options with query combines with query from route", () => {
     const route = createRoute({
-      name: 'route',
-      path: '/',
-      query: 'foo=foo1&foo=foo2',
+      name: "route",
+      path: "/",
+      query: "foo=foo1&foo=foo2",
       component,
-    })
+    });
 
-    const response = createResolvedRoute(route, {}, { query: 'bar=bar&baz' })
+    const response = createResolvedRoute(route, {}, { query: "bar=bar&baz" });
 
-    expect(response.query.get('foo')).toBe('foo1')
-    expect(response.query.getAll('foo')).toMatchObject(['foo1', 'foo2'])
-    expect(response.query.get('bar')).toBe('bar')
-    expect(response.query.getAll('bar')).toMatchObject(['bar'])
-    expect(response.query.get('baz')).toBe('')
-    expect(response.query.getAll('baz')).toMatchObject([''])
-    expect(response.query.get('does-not-exist')).toBe(null)
-    expect(response.query.getAll('does-not-exist')).toMatchObject([])
-  })
+    expect(response.query.get("foo")).toBe("foo1");
+    expect(response.query.getAll("foo")).toMatchObject(["foo1", "foo2"]);
+    expect(response.query.get("bar")).toBe("bar");
+    expect(response.query.getAll("bar")).toMatchObject(["bar"]);
+    expect(response.query.get("baz")).toBe("");
+    expect(response.query.getAll("baz")).toMatchObject([""]);
+    expect(response.query.get("does-not-exist")).toBe(null);
+    expect(response.query.getAll("does-not-exist")).toMatchObject([]);
+  });
 
-  test('given options with hash replaces hash from route', () => {
+  test("given options with hash replaces hash from route", () => {
     const route = createRoute({
-      name: 'route',
-      path: '/',
-      hash: 'bar',
+      name: "route",
+      path: "/",
+      hash: "bar",
       component,
-    })
+    });
 
-    const response = createResolvedRoute(route, {}, { hash: 'baz' })
+    const response = createResolvedRoute(route, {}, { hash: "baz" });
 
-    expect(response.hash).toBe('#baz')
-  })
-})
+    expect(response.hash).toBe("#baz");
+  });
+});
diff --git a/src/services/createRoute.spec-d.ts b/src/services/createRoute.spec-d.ts
index 5ddbfd77..b7baaabc 100644
--- a/src/services/createRoute.spec-d.ts
+++ b/src/services/createRoute.spec-d.ts
@@ -1,845 +1,917 @@
-import { describe, expectTypeOf, test } from 'vitest'
-import { createRoute } from './createRoute'
-import { Identity } from '@/types/utilities'
-import echo from '@/components/echo'
-import { component } from '@/utilities/testHelpers'
-import { withParams } from '@/services/withParams'
-import { InternalRouteHooks } from '@/types/hooks'
-import { BuiltInRejectionType } from '@/types/rejection'
-import { createRejection } from '@/services/createRejection'
-import { ResolvedRoute } from '@/types/resolved'
-import { RouteRedirects } from '@/types/redirects'
-import { Url } from '@/types/url'
-
-test('empty options returns an empty route', () => {
-  const route = createRoute({})
-
-  type Source = typeof route
-
-  expectTypeOf<Source>().toExtend<Url>()
-  expectTypeOf<Source>().toMatchObjectType<InternalRouteHooks<Source>>()
-  expectTypeOf<Source>().toMatchObjectType<RouteRedirects>()
-})
-
-test('options with name', () => {
-  const route = createRoute({ name: 'foo' })
-  type Source = typeof route['name']
-  type Expect = 'foo'
-
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-})
-
-test('options with name and parent', () => {
-  const parent = createRoute({ name: 'parent' })
+import { describe, expectTypeOf, test } from "vite-plus/test";
+import { createRoute } from "./createRoute";
+import { Identity } from "@/types/utilities";
+import echo from "@/components/echo";
+import { component } from "@/utilities/testHelpers";
+import { withParams } from "@/services/withParams";
+import { InternalRouteHooks } from "@/types/hooks";
+import { BuiltInRejectionType } from "@/types/rejection";
+import { createRejection } from "@/services/createRejection";
+import { ResolvedRoute } from "@/types/resolved";
+import { RouteRedirects } from "@/types/redirects";
+import { Url } from "@/types/url";
+
+test("empty options returns an empty route", () => {
+  const route = createRoute({});
+
+  type Source = typeof route;
+
+  expectTypeOf<Source>().toExtend<Url>();
+  expectTypeOf<Source>().toMatchObjectType<InternalRouteHooks<Source>>();
+  expectTypeOf<Source>().toMatchObjectType<RouteRedirects>();
+});
+
+test("options with name", () => {
+  const route = createRoute({ name: "foo" });
+  type Source = (typeof route)["name"];
+  type Expect = "foo";
+
+  expectTypeOf<Source>().toEqualTypeOf<Expect>();
+});
+
+test("options with name and parent", () => {
+  const parent = createRoute({ name: "parent" });
   const route = createRoute({
-    name: 'child',
+    name: "child",
     parent,
-  })
+  });
 
-  type Source = typeof route['name']
-  type Expect = 'child'
+  type Source = (typeof route)["name"];
+  type Expect = "child";
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-})
+  expectTypeOf<Source>().toEqualTypeOf<Expect>();
+});
 
-test('options with path with params', () => {
-  const route = createRoute({ path: '/foo/[bar]' })
-  type Source = typeof route['params']
-  type Expect = { bar: { param: StringConstructor, isOptional: false, isGreedy: false } }
+test("options with path with params", () => {
+  const route = createRoute({ path: "/foo/[bar]" });
+  type Source = (typeof route)["params"];
+  type Expect = { bar: { param: StringConstructor; isOptional: false; isGreedy: false } };
 
-  expectTypeOf<Source>().toMatchObjectType<Expect>()
-})
+  expectTypeOf<Source>().toMatchObjectType<Expect>();
+});
 
-test('options with path with params and parent', () => {
+test("options with path with params and parent", () => {
   const parent = createRoute({
-    path: '/parent/[parentParam]',
-  })
+    path: "/parent/[parentParam]",
+  });
 
   const route = createRoute({
-    path: '/child/[childParam]',
+    path: "/child/[childParam]",
     parent,
-  })
+  });
 
-  type Source = typeof route['params']
+  type Source = (typeof route)["params"];
   type Expect = {
-    parentParam: { param: StringConstructor, isOptional: false, isGreedy: false },
-    childParam: { param: StringConstructor, isOptional: false, isGreedy: false },
-  }
+    parentParam: { param: StringConstructor; isOptional: false; isGreedy: false };
+    childParam: { param: StringConstructor; isOptional: false; isGreedy: false };
+  };
 
-  expectTypeOf<Source>().toMatchObjectType<Expect>()
-})
+  expectTypeOf<Source>().toMatchObjectType<Expect>();
+});
 
-test('options with path with params with custom param types', () => {
+test("options with path with params with custom param types", () => {
   const route = createRoute({
-    path: withParams('/foo/[bar]', { bar: Number }),
-  })
+    path: withParams("/foo/[bar]", { bar: Number }),
+  });
 
-  type Source = typeof route['params']
+  type Source = (typeof route)["params"];
   type Expect = {
-    bar: { param: NumberConstructor, isOptional: false, isGreedy: false },
-  }
+    bar: { param: NumberConstructor; isOptional: false; isGreedy: false };
+  };
 
-  expectTypeOf<Source>().toMatchObjectType<Expect>()
-})
+  expectTypeOf<Source>().toMatchObjectType<Expect>();
+});
 
-test('options with path with params with custom param types and parent', () => {
+test("options with path with params with custom param types and parent", () => {
   const parent = createRoute({
-    path: withParams('/parent/[parentParam]', { parentParam: Number }),
-  })
+    path: withParams("/parent/[parentParam]", { parentParam: Number }),
+  });
 
   const route = createRoute({
-    path: withParams('/child/[childParam]', { childParam: Boolean }),
+    path: withParams("/child/[childParam]", { childParam: Boolean }),
     parent,
-  })
+  });
 
-  type Source = typeof route['params']
+  type Source = (typeof route)["params"];
   type Expect = {
-    parentParam: { param: NumberConstructor, isOptional: false, isGreedy: false },
-    childParam: { param: BooleanConstructor, isOptional: false, isGreedy: false },
-  }
+    parentParam: { param: NumberConstructor; isOptional: false; isGreedy: false };
+    childParam: { param: BooleanConstructor; isOptional: false; isGreedy: false };
+  };
 
-  expectTypeOf<Source>().toMatchObjectType<Expect>()
-})
+  expectTypeOf<Source>().toMatchObjectType<Expect>();
+});
 
-test('options with query', () => {
+test("options with query", () => {
   const route = createRoute({
-    query: 'foo=bar',
-  })
+    query: "foo=bar",
+  });
 
-  type Source = typeof route['params']
-  type Expect = {}
+  type Source = (typeof route)["params"];
+  type Expect = {};
 
-  expectTypeOf<Source>().toMatchObjectType<Expect>()
-})
+  expectTypeOf<Source>().toMatchObjectType<Expect>();
+});
 
-test('options with query and parent', () => {
+test("options with query and parent", () => {
   const parent = createRoute({
-    query: 'parent=parent',
-  })
+    query: "parent=parent",
+  });
 
   const route = createRoute({
-    query: 'child=child',
+    query: "child=child",
     parent,
-  })
+  });
 
-  type Source = typeof route['params']
-  type Expect = {}
+  type Source = (typeof route)["params"];
+  type Expect = {};
 
-  expectTypeOf<Source>().toMatchObjectType<Expect>()
-})
+  expectTypeOf<Source>().toMatchObjectType<Expect>();
+});
 
-test('options with query with params', () => {
-  const route = createRoute({ query: 'foo=[bar]' })
-  type Source = typeof route['params']
-  type Expect = { bar: { param: StringConstructor, isOptional: false, isGreedy: false } }
+test("options with query with params", () => {
+  const route = createRoute({ query: "foo=[bar]" });
+  type Source = (typeof route)["params"];
+  type Expect = { bar: { param: StringConstructor; isOptional: false; isGreedy: false } };
 
-  expectTypeOf<Source>().toMatchObjectType<Expect>()
-})
+  expectTypeOf<Source>().toMatchObjectType<Expect>();
+});
 
-test('options with query with params and parent', () => {
+test("options with query with params and parent", () => {
   const parent = createRoute({
-    query: 'parent=[parentParam]',
-  })
+    query: "parent=[parentParam]",
+  });
 
   const route = createRoute({
-    query: 'child=[childParam]',
+    query: "child=[childParam]",
     parent,
-  })
+  });
 
-  type Source = typeof route['params']
+  type Source = (typeof route)["params"];
   type Expect = {
-    parentParam: { param: StringConstructor, isOptional: false, isGreedy: false },
-    childParam: { param: StringConstructor, isOptional: false, isGreedy: false },
-  }
+    parentParam: { param: StringConstructor; isOptional: false; isGreedy: false };
+    childParam: { param: StringConstructor; isOptional: false; isGreedy: false };
+  };
 
-  expectTypeOf<Source>().toMatchObjectType<Expect>()
-})
+  expectTypeOf<Source>().toMatchObjectType<Expect>();
+});
 
-test('options with query with params with custom param types', () => {
-  const route = createRoute({ query: withParams('foo=[bar]', { bar: Number }) })
-  type Source = typeof route['params']
-  type Expect = { bar: { param: NumberConstructor, isOptional: false, isGreedy: false } }
+test("options with query with params with custom param types", () => {
+  const route = createRoute({ query: withParams("foo=[bar]", { bar: Number }) });
+  type Source = (typeof route)["params"];
+  type Expect = { bar: { param: NumberConstructor; isOptional: false; isGreedy: false } };
 
-  expectTypeOf<Source>().toMatchObjectType<Expect>()
-})
+  expectTypeOf<Source>().toMatchObjectType<Expect>();
+});
 
-test('options with query with params with custom param types and parent', () => {
+test("options with query with params with custom param types and parent", () => {
   const parent = createRoute({
-    query: withParams('parent=[parentParam]', { parentParam: Number }),
-  })
+    query: withParams("parent=[parentParam]", { parentParam: Number }),
+  });
 
   const route = createRoute({
-    query: withParams('child=[childParam]', { childParam: Boolean }),
+    query: withParams("child=[childParam]", { childParam: Boolean }),
     parent,
-  })
+  });
 
-  type Source = typeof route['params']
+  type Source = (typeof route)["params"];
   type Expect = {
-    parentParam: { param: NumberConstructor, isOptional: false, isGreedy: false },
-    childParam: { param: BooleanConstructor, isOptional: false, isGreedy: false },
-  }
+    parentParam: { param: NumberConstructor; isOptional: false; isGreedy: false };
+    childParam: { param: BooleanConstructor; isOptional: false; isGreedy: false };
+  };
 
-  expectTypeOf<Source>().toMatchObjectType<Expect>()
-})
+  expectTypeOf<Source>().toMatchObjectType<Expect>();
+});
 
-test('options with hash', () => {
-  const route = createRoute({ hash: 'foo' })
+test("options with hash", () => {
+  const route = createRoute({ hash: "foo" });
 
-  type Source = typeof route['params']
-  type Expect = {}
+  type Source = (typeof route)["params"];
+  type Expect = {};
 
-  expectTypeOf<Source>().toExtend<Expect>()
-})
+  expectTypeOf<Source>().toExtend<Expect>();
+});
 
-test('options with hash and parent', () => {
-  const parent = createRoute({ hash: 'parent' })
-  const route = createRoute({ hash: 'child', parent })
+test("options with hash and parent", () => {
+  const parent = createRoute({ hash: "parent" });
+  const route = createRoute({ hash: "child", parent });
 
-  type Source = typeof route['params']
-  type Expect = {}
+  type Source = (typeof route)["params"];
+  type Expect = {};
 
-  expectTypeOf<Source>().toExtend<Expect>()
-})
+  expectTypeOf<Source>().toExtend<Expect>();
+});
 
-test('options with meta', () => {
-  const route = createRoute({ meta: { foo: 'bar' } })
-  type Source = typeof route['meta']
-  type Expect = Readonly<{ foo: 'bar' }>
+test("options with meta", () => {
+  const route = createRoute({ meta: { foo: "bar" } });
+  type Source = (typeof route)["meta"];
+  type Expect = Readonly<{ foo: "bar" }>;
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-})
+  expectTypeOf<Source>().toEqualTypeOf<Expect>();
+});
 
-test('options with meta and parent', () => {
-  const parent = createRoute({ meta: { parent: 'parent' } })
-  const route = createRoute({ parent, meta: { child: 'child' } })
+test("options with meta and parent", () => {
+  const parent = createRoute({ meta: { parent: "parent" } });
+  const route = createRoute({ parent, meta: { child: "child" } });
 
-  type Source = Identity<typeof route['meta']>
-  type Expect = Readonly<{ parent: 'parent', child: 'child' }>
+  type Source = Identity<(typeof route)["meta"]>;
+  type Expect = Readonly<{ parent: "parent"; child: "child" }>;
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-})
+  expectTypeOf<Source>().toEqualTypeOf<Expect>();
+});
 
-test('options with state', () => {
-  const route = createRoute({ state: { foo: String } })
-  type Source = typeof route['state']
-  type Expect = Readonly<{ foo: StringConstructor }>
+test("options with state", () => {
+  const route = createRoute({ state: { foo: String } });
+  type Source = (typeof route)["state"];
+  type Expect = Readonly<{ foo: StringConstructor }>;
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-})
+  expectTypeOf<Source>().toEqualTypeOf<Expect>();
+});
 
-test('options with state and parent', () => {
-  const parent = createRoute({ state: { parent: String } })
-  const route = createRoute({ parent, state: { child: String } })
+test("options with state and parent", () => {
+  const parent = createRoute({ state: { parent: String } });
+  const route = createRoute({ parent, state: { child: String } });
 
-  type Source = Identity<typeof route['state']>
-  type Expect = Readonly<{ parent: StringConstructor, child: StringConstructor }>
+  type Source = Identity<(typeof route)["state"]>;
+  type Expect = Readonly<{ parent: StringConstructor; child: StringConstructor }>;
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-})
+  expectTypeOf<Source>().toEqualTypeOf<Expect>();
+});
 
-describe('props', () => {
-  test('options with component and optional props without second argument', () => {
+describe("props", () => {
+  test("options with component and optional props without second argument", () => {
     const route = createRoute({
       component,
-    })
+    });
 
-  type Source = typeof route['matched']['props']
-  type Expect = undefined
+    type Source = (typeof route)["matched"]["props"];
+    type Expect = undefined;
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
 
-  test('options with component and optional props with second argument', () => {
-    const route = createRoute({
-      component,
-    }, () => ({ foo: 'bar' }))
+  test("options with component and optional props with second argument", () => {
+    const route = createRoute(
+      {
+        component,
+      },
+      () => ({ foo: "bar" }),
+    );
 
-  type Source = typeof route['matched']['props']
-  type Expect = () => { foo: string }
+    type Source = (typeof route)["matched"]["props"];
+    type Expect = () => { foo: string };
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
 
-  test('options with component and required props missing second argument', () => {
-  // @ts-expect-error should require second argument
+  test("options with component and required props missing second argument", () => {
+    // @ts-expect-error should require second argument
     const route = createRoute({
       component: echo,
-    })
+    });
 
-  type Source = typeof route['matched']['props']
-  type Expect = undefined
+    type Source = (typeof route)["matched"]["props"];
+    type Expect = undefined;
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
 
-  test('options with component and required props with second argument ', () => {
-    const route = createRoute({
-      component: echo,
-    }, () => ({ value: 'bar', extra: true }))
+  test("options with component and required props with second argument ", () => {
+    const route = createRoute(
+      {
+        component: echo,
+      },
+      () => ({ value: "bar", extra: true }),
+    );
 
-  type Source = typeof route['matched']['props']
-  type Expect = () => { value: string, extra: boolean }
+    type Source = (typeof route)["matched"]["props"];
+    type Expect = () => { value: string; extra: boolean };
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
 
-  test('options with component and required props with second argument with incorrect type', () => {
-    const route = createRoute({
-      component: echo,
-      // @ts-expect-error should not accept incorrect type
-    }, () => ({ value: true, foo: 'bar' }))
+  test("options with component and required props with second argument with incorrect type", () => {
+    const route = createRoute(
+      {
+        component: echo,
+        // @ts-expect-error should not accept incorrect type
+      },
+      () => ({ value: true, foo: "bar" }),
+    );
 
-  type Source = typeof route['matched']['props']
-  type Expect = undefined
+    type Source = (typeof route)["matched"]["props"];
+    type Expect = undefined;
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
 
-  test('options with components and optional props without second argument', () => {
+  test("options with components and optional props without second argument", () => {
     const route = createRoute({
       components: {
         component,
       },
-    })
+    });
 
-  type Source = typeof route['matched']['props']
-  type Expect = undefined
+    type Source = (typeof route)["matched"]["props"];
+    type Expect = undefined;
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
 
-  test('options with components and optional props with second argument', () => {
-    const route = createRoute({
-      components: {
-        default: component,
+  test("options with components and optional props with second argument", () => {
+    const route = createRoute(
+      {
+        components: {
+          default: component,
+        },
       },
-    }, {
-      default: () => ({ foo: 'bar' }),
-    })
-
-  type Source = typeof route['matched']['props']
-  type Expect = { default: () => { foo: string } }
-
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
-
-  test('options with components and required props missing second argument', () => {
-  // @ts-expect-error should require second argument
-    const route = createRoute({
-      components: {
-        default: echo,
+      {
+        default: () => ({ foo: "bar" }),
       },
-    })
+    );
 
-  type Source = typeof route['matched']['props']
-  type Expect = undefined
+    type Source = (typeof route)["matched"]["props"];
+    type Expect = { default: () => { foo: string } };
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
 
-  test('options with components and required props with second argument ', () => {
+  test("options with components and required props missing second argument", () => {
+    // @ts-expect-error should require second argument
     const route = createRoute({
       components: {
         default: echo,
       },
-    }, {
-      default: () => ({ value: 'bar', extra: true }),
-    })
+    });
 
-  type Source = typeof route['matched']['props']
-  type Expect = { default: () => { value: string, extra: boolean } }
+    type Source = (typeof route)["matched"]["props"];
+    type Expect = undefined;
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
 
-  test('options with components and required props with second argument with incorrect type', () => {
-    const route = createRoute({
-      components: {
-        default: echo,
+  test("options with components and required props with second argument ", () => {
+    const route = createRoute(
+      {
+        components: {
+          default: echo,
+        },
       },
-    }, {
-    // @ts-expect-error should not accept incorrect type
-      default: () => ({ value: true, foo: 'bar' }),
-    })
-
-  type Source = typeof route['matched']['props']
-  type Expect = undefined
-
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
-
-  test('undefined is not a valid value for 2nd argument of createRoute', () => {
-    const route = createRoute({
-      component: echo,
-      // @ts-expect-error should not accept undefined
-    }, undefined)
+      {
+        default: () => ({ value: "bar", extra: true }),
+      },
+    );
 
-  type Source = typeof route['matched']['props']
-  type Expect = undefined
+    type Source = (typeof route)["matched"]["props"];
+    type Expect = { default: () => { value: string; extra: boolean } };
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
 
-  test('parent props are undefined when parent has no props', () => {
-    const parent = createRoute({
-      name: 'parent',
-    })
+  test("options with components and required props with second argument with incorrect type", () => {
+    const route = createRoute(
+      {
+        components: {
+          default: echo,
+        },
+      },
+      {
+        // @ts-expect-error should not accept incorrect type
+        default: () => ({ value: true, foo: "bar" }),
+      },
+    );
 
-    createRoute({
-      name: 'child',
-      parent: parent,
-    }, (__, { parent }) => {
-      expectTypeOf(parent.props).toEqualTypeOf<undefined>()
-      expectTypeOf(parent.name).toEqualTypeOf<'parent'>()
+    type Source = (typeof route)["matched"]["props"];
+    type Expect = undefined;
 
-      return {}
-    })
-  })
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
 
-  test('sync parent props are passed to child props', () => {
-    const parent = createRoute({
-      name: 'parent',
-    }, () => ({ foo: 123 }))
+  test("undefined is not a valid value for 2nd argument of createRoute", () => {
+    const route = createRoute(
+      {
+        component: echo,
+        // @ts-expect-error should not accept undefined
+      },
+      undefined,
+    );
 
-    createRoute({
-      name: 'child',
-      parent: parent,
-    }, (__, { parent }) => {
-      expectTypeOf(parent.props).toEqualTypeOf<{ foo: number }>()
-      expectTypeOf(parent.name).toEqualTypeOf<'parent'>()
+    type Source = (typeof route)["matched"]["props"];
+    type Expect = undefined;
 
-      return {}
-    })
-  })
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
 
-  test('async parent props are passed to child props', () => {
+  test("parent props are undefined when parent has no props", () => {
     const parent = createRoute({
-      name: 'parent',
-    }, async () => ({ foo: 123 }))
-
-    createRoute({
-      name: 'child',
-      parent: parent,
-    }, (__, { parent }) => {
-      expectTypeOf(parent.props).toEqualTypeOf<Promise<{ foo: number }>>()
-      expectTypeOf(parent.name).toEqualTypeOf<'parent'>()
+      name: "parent",
+    });
 
-      return {}
-    })
-  })
+    createRoute(
+      {
+        name: "child",
+        parent: parent,
+      },
+      (__, { parent }) => {
+        expectTypeOf(parent.props).toEqualTypeOf<undefined>();
+        expectTypeOf(parent.name).toEqualTypeOf<"parent">();
 
-  test('parent props are passed to child props when multiple parent components are used', () => {
-    const parent = createRoute({
-      name: 'parent',
-      components: {
-        one: component,
-        two: component,
+        return {};
       },
-    }, {
-      one: () => ({ foo: 123 }),
-      two: async () => ({ foo: 456 }),
-    })
+    );
+  });
 
-    createRoute({
-      name: 'child',
-      parent: parent,
-    }, (__, { parent }) => {
-      expectTypeOf(parent.props).toEqualTypeOf<{
-        one: { foo: number },
-        two: Promise<{ foo: number }>,
-      }>()
-      expectTypeOf(parent.name).toEqualTypeOf<'parent'>()
-
-      return {}
-    })
-  })
-
-  test('parent props are passed to child props when multiple child components are used', () => {
-    const parent = createRoute({
-      name: 'parent',
-    }, async () => ({ foo: 123 }))
+  test("sync parent props are passed to child props", () => {
+    const parent = createRoute(
+      {
+        name: "parent",
+      },
+      () => ({ foo: 123 }),
+    );
 
-    createRoute({
-      name: 'child',
-      parent: parent,
-      components: {
-        one: component,
-        two: component,
+    createRoute(
+      {
+        name: "child",
+        parent: parent,
       },
-    }, {
-      one: (__, { parent }) => {
-        expectTypeOf(parent.props).toEqualTypeOf<Promise<{ foo: number }>>()
-        expectTypeOf(parent.name).toEqualTypeOf<'parent'>()
+      (__, { parent }) => {
+        expectTypeOf(parent.props).toEqualTypeOf<{ foo: number }>();
+        expectTypeOf(parent.name).toEqualTypeOf<"parent">();
 
-        return {}
+        return {};
       },
-      two: (__, { parent }) => {
-        expectTypeOf(parent.props).toEqualTypeOf<Promise<{ foo: number }>>()
-        expectTypeOf(parent.name).toEqualTypeOf<'parent'>()
+    );
+  });
 
-        return {}
+  test("async parent props are passed to child props", () => {
+    const parent = createRoute(
+      {
+        name: "parent",
       },
-    })
-  })
+      async () => ({ foo: 123 }),
+    );
 
-  describe('reject', () => {
-    test('accepts built in rejections when no context is provided', () => {
-      createRoute({
-        name: 'route',
-        component: echo,
-      }, (__, context) => {
-        type Source = Parameters<typeof context.reject>[0]
-        type Expect = BuiltInRejectionType
+    createRoute(
+      {
+        name: "child",
+        parent: parent,
+      },
+      (__, { parent }) => {
+        expectTypeOf(parent.props).toEqualTypeOf<Promise<{ foo: number }>>();
+        expectTypeOf(parent.name).toEqualTypeOf<"parent">();
 
-        expectTypeOf<Source>().toEqualTypeOf<Expect>()
+        return {};
+      },
+    );
+  });
+
+  test("parent props are passed to child props when multiple parent components are used", () => {
+    const parent = createRoute(
+      {
+        name: "parent",
+        components: {
+          one: component,
+          two: component,
+        },
+      },
+      {
+        one: () => ({ foo: 123 }),
+        two: async () => ({ foo: 456 }),
+      },
+    );
 
-        return { value: 'foo' }
-      })
-    })
+    createRoute(
+      {
+        name: "child",
+        parent: parent,
+      },
+      (__, { parent }) => {
+        expectTypeOf(parent.props).toEqualTypeOf<{
+          one: { foo: number };
+          two: Promise<{ foo: number }>;
+        }>();
+        expectTypeOf(parent.name).toEqualTypeOf<"parent">();
+
+        return {};
+      },
+    );
+  });
 
-    test('accepts built in rejections and custom rejections when context is provided', () => {
+  test("parent props are passed to child props when multiple child components are used", () => {
+    const parent = createRoute(
+      {
+        name: "parent",
+      },
+      async () => ({ foo: 123 }),
+    );
+
+    createRoute(
+      {
+        name: "child",
+        parent: parent,
+        components: {
+          one: component,
+          two: component,
+        },
+      },
+      {
+        one: (__, { parent }) => {
+          expectTypeOf(parent.props).toEqualTypeOf<Promise<{ foo: number }>>();
+          expectTypeOf(parent.name).toEqualTypeOf<"parent">();
+
+          return {};
+        },
+        two: (__, { parent }) => {
+          expectTypeOf(parent.props).toEqualTypeOf<Promise<{ foo: number }>>();
+          expectTypeOf(parent.name).toEqualTypeOf<"parent">();
+
+          return {};
+        },
+      },
+    );
+  });
+
+  describe("reject", () => {
+    test("accepts built in rejections when no context is provided", () => {
+      createRoute(
+        {
+          name: "route",
+          component: echo,
+        },
+        (__, context) => {
+          type Source = Parameters<typeof context.reject>[0];
+          type Expect = BuiltInRejectionType;
+
+          expectTypeOf<Source>().toEqualTypeOf<Expect>();
+
+          return { value: "foo" };
+        },
+      );
+    });
+
+    test("accepts built in rejections and custom rejections when context is provided", () => {
       const rejection = createRejection({
-        type: 'NotAuthorized',
-      })
-
-      createRoute({
-        name: 'route',
-        component: echo,
-        context: [rejection],
-      }, (__, context) => {
-        type Source = Parameters<typeof context.reject>[0]
-        type Expect = 'NotAuthorized' | BuiltInRejectionType
-
-        expectTypeOf<Source>().toEqualTypeOf<Expect>()
-
-        return { value: 'foo' }
-      })
-    })
-  })
-
-  describe('push', () => {
-    test('accepts url when no context is provided', () => {
-      createRoute({
-        name: 'route',
-        component: echo,
-      }, (__, context) => {
-        // should accept a url
-        context.push('/')
-
-        // @ts-expect-error should not accept an invalid url
-        context.push('foo')
-
-        return { value: 'foo' }
-      })
-    })
-
-    test('accepts current route when no context is provided', () => {
-      createRoute({
-        name: 'route',
-        path: '/[paramName]',
-      }, (__, context) => {
-        context.push('route', { paramName: 'value' })
-
-        return {}
-      })
-    })
-
-    test('accepts url and routes when context is provided', () => {
+        type: "NotAuthorized",
+      });
+
+      createRoute(
+        {
+          name: "route",
+          component: echo,
+          context: [rejection],
+        },
+        (__, context) => {
+          type Source = Parameters<typeof context.reject>[0];
+          type Expect = "NotAuthorized" | BuiltInRejectionType;
+
+          expectTypeOf<Source>().toEqualTypeOf<Expect>();
+
+          return { value: "foo" };
+        },
+      );
+    });
+  });
+
+  describe("push", () => {
+    test("accepts url when no context is provided", () => {
+      createRoute(
+        {
+          name: "route",
+          component: echo,
+        },
+        (__, context) => {
+          // should accept a url
+          context.push("/");
+
+          // @ts-expect-error should not accept an invalid url
+          context.push("foo");
+
+          return { value: "foo" };
+        },
+      );
+    });
+
+    test("accepts current route when no context is provided", () => {
+      createRoute(
+        {
+          name: "route",
+          path: "/[paramName]",
+        },
+        (__, context) => {
+          context.push("route", { paramName: "value" });
+
+          return {};
+        },
+      );
+    });
+
+    test("accepts url and routes when context is provided", () => {
       const route = createRoute({
-        name: 'contextRoute',
-      })
-
-      createRoute({
-        name: 'route',
-        component: echo,
-        context: [route],
-      }, (__, context) => {
-        // valid
-        context.push('route')
-
-        // valid
-        context.push('contextRoute')
-
-        // @ts-expect-error should not accept an invalid route name
-        context.push('foo')
-
-        // should accept a url
-        context.push('/')
-
-        return { value: 'foo' }
-      })
-    })
-  })
-
-  describe('replace', () => {
-    test('accepts url when no context is provided', () => {
-      createRoute({
-        name: 'route',
-        component: echo,
-      }, (__, context) => {
-        // should accept a url
-        context.replace('/')
-
-        // @ts-expect-error should not accept an invalid url
-        context.replace('foo')
-
-        return { value: 'foo' }
-      })
-    })
-
-    test('accepts url and routes when context is provided', () => {
+        name: "contextRoute",
+      });
+
+      createRoute(
+        {
+          name: "route",
+          component: echo,
+          context: [route],
+        },
+        (__, context) => {
+          // valid
+          context.push("route");
+
+          // valid
+          context.push("contextRoute");
+
+          // @ts-expect-error should not accept an invalid route name
+          context.push("foo");
+
+          // should accept a url
+          context.push("/");
+
+          return { value: "foo" };
+        },
+      );
+    });
+  });
+
+  describe("replace", () => {
+    test("accepts url when no context is provided", () => {
+      createRoute(
+        {
+          name: "route",
+          component: echo,
+        },
+        (__, context) => {
+          // should accept a url
+          context.replace("/");
+
+          // @ts-expect-error should not accept an invalid url
+          context.replace("foo");
+
+          return { value: "foo" };
+        },
+      );
+    });
+
+    test("accepts url and routes when context is provided", () => {
       const route = createRoute({
-        name: 'route',
-      })
-
-      createRoute({
-        name: 'route',
-        component: echo,
-        context: [route],
-      }, (__, context) => {
-        // valid
-        context.replace('route')
-
-        // @ts-expect-error should not accept an invalid route name
-        context.replace('foo')
-
-        // should accept a url
-        context.replace('/')
-
-        return { value: 'foo' }
-      })
-    })
-  })
-
-  describe('update', () => {
-    test('accepts params based on the current route', () => {
-      createRoute({
-        name: 'route',
-        path: '/[paramName]',
-        component,
-      }, (__, context) => {
-        context.update('paramName', 'value')
-
-        // @ts-expect-error should not accept invalid param name
-        context.update('invalidParamName', 'value')
-
-        context.update({ paramName: 'value' })
-
-        // @ts-expect-error should not accept invalid params
-        context.update({ invalidParamName: 'value' })
-
-        context.update({ paramName: 'value' }, { replace: true })
-
-        // @ts-expect-error should not accept invalid options
-        context.update({ paramName: 'value' }, { invalid: true })
-
-        return {}
-      })
-    })
-  })
-})
-
-describe('meta', () => {
-  test('is always defined', () => {
+        name: "route",
+      });
+
+      createRoute(
+        {
+          name: "route",
+          component: echo,
+          context: [route],
+        },
+        (__, context) => {
+          // valid
+          context.replace("route");
+
+          // @ts-expect-error should not accept an invalid route name
+          context.replace("foo");
+
+          // should accept a url
+          context.replace("/");
+
+          return { value: "foo" };
+        },
+      );
+    });
+  });
+
+  describe("update", () => {
+    test("accepts params based on the current route", () => {
+      createRoute(
+        {
+          name: "route",
+          path: "/[paramName]",
+          component,
+        },
+        (__, context) => {
+          context.update("paramName", "value");
+
+          // @ts-expect-error should not accept invalid param name
+          context.update("invalidParamName", "value");
+
+          context.update({ paramName: "value" });
+
+          // @ts-expect-error should not accept invalid params
+          context.update({ invalidParamName: "value" });
+
+          context.update({ paramName: "value" }, { replace: true });
+
+          // @ts-expect-error should not accept invalid options
+          context.update({ paramName: "value" }, { invalid: true });
+
+          return {};
+        },
+      );
+    });
+  });
+});
+
+describe("meta", () => {
+  test("is always defined", () => {
     const route = createRoute({
-      name: 'route',
-    })
+      name: "route",
+    });
 
-    expectTypeOf(route.meta).toEqualTypeOf<Readonly<{}>>()
-  })
+    expectTypeOf(route.meta).toEqualTypeOf<Readonly<{}>>();
+  });
 
-  test('preserves provided values', () => {
+  test("preserves provided values", () => {
     const route = createRoute({
-      name: 'route',
+      name: "route",
       meta: {
-        foo: 'bar',
+        foo: "bar",
       },
-    })
+    });
 
-    expectTypeOf(route.meta).toEqualTypeOf<Readonly<{ foo: 'bar' }>>()
-  })
+    expectTypeOf(route.meta).toEqualTypeOf<Readonly<{ foo: "bar" }>>();
+  });
 
-  test('preserves provided values with parent', () => {
+  test("preserves provided values with parent", () => {
     const parent = createRoute({
-      name: 'parent',
+      name: "parent",
       meta: {
-        foo: 'bar',
+        foo: "bar",
       },
-    })
+    });
 
     const route = createRoute({
-      name: 'child',
+      name: "child",
       parent: parent,
       meta: {
-        bar: 'baz',
+        bar: "baz",
       },
-    })
+    });
 
-    expectTypeOf(parent.meta).toExtend<{}>()
-    expectTypeOf(route.meta.bar).toEqualTypeOf<'baz'>()
-    expectTypeOf(route.meta.foo).toEqualTypeOf<'bar'>()
-  })
-})
+    expectTypeOf(parent.meta).toExtend<{}>();
+    expectTypeOf(route.meta.bar).toEqualTypeOf<"baz">();
+    expectTypeOf(route.meta.foo).toEqualTypeOf<"bar">();
+  });
+});
 
-describe('matched.meta', () => {
-  test('is always defined', () => {
+describe("matched.meta", () => {
+  test("is always defined", () => {
     const route = createRoute({
-      name: 'route',
-    })
+      name: "route",
+    });
 
-    expectTypeOf(route.matched.meta).toEqualTypeOf<Readonly<{}>>()
-  })
+    expectTypeOf(route.matched.meta).toEqualTypeOf<Readonly<{}>>();
+  });
 
-  test('preserves provided values', () => {
+  test("preserves provided values", () => {
     const route = createRoute({
-      name: 'route',
+      name: "route",
       meta: {
-        foo: 'bar',
+        foo: "bar",
       },
-    })
+    });
 
-    expectTypeOf(route.matched.meta).toEqualTypeOf<Readonly<{ foo: 'bar' }>>()
-  })
-})
+    expectTypeOf(route.matched.meta).toEqualTypeOf<Readonly<{ foo: "bar" }>>();
+  });
+});
 
-describe('matches[number].meta', () => {
-  test('is always defined', () => {
+describe("matches[number].meta", () => {
+  test("is always defined", () => {
     const route = createRoute({
-      name: 'route',
-    })
+      name: "route",
+    });
 
-    expectTypeOf(route.matches[0].meta).toEqualTypeOf<Readonly<{}>>()
-  })
+    expectTypeOf(route.matches[0].meta).toEqualTypeOf<Readonly<{}>>();
+  });
 
-  test('preserves provided values', () => {
+  test("preserves provided values", () => {
     const route = createRoute({
-      name: 'route',
+      name: "route",
       meta: {
-        foo: 'bar',
+        foo: "bar",
       },
-    })
+    });
 
-    expectTypeOf(route.matches[0].meta).toEqualTypeOf<Readonly<{ foo: 'bar' }>>()
-  })
-})
+    expectTypeOf(route.matches[0].meta).toEqualTypeOf<Readonly<{ foo: "bar" }>>();
+  });
+});
 
-describe('hooks', () => {
-  test('to and from are typed correctly', () => {
+describe("hooks", () => {
+  test("to and from are typed correctly", () => {
     const route = createRoute({
-      name: 'route',
-      path: '/[paramName]',
+      name: "route",
+      path: "/[paramName]",
       component,
-    })
+    });
 
     route.onBeforeRouteEnter((to, { from }) => {
-      expectTypeOf(to).toEqualTypeOf<ResolvedRoute<typeof route>>()
-      expectTypeOf(from).toEqualTypeOf<ResolvedRoute | null>()
-    })
+      expectTypeOf(to).toEqualTypeOf<ResolvedRoute<typeof route>>();
+      expectTypeOf(from).toEqualTypeOf<ResolvedRoute | null>();
+    });
 
     route.onBeforeRouteUpdate((to, { from }) => {
-      expectTypeOf(to).toEqualTypeOf<ResolvedRoute<typeof route>>()
-      expectTypeOf(from).toEqualTypeOf<ResolvedRoute | null>()
-    })
+      expectTypeOf(to).toEqualTypeOf<ResolvedRoute<typeof route>>();
+      expectTypeOf(from).toEqualTypeOf<ResolvedRoute | null>();
+    });
 
     route.onBeforeRouteLeave((to, { from }) => {
-      expectTypeOf(to).toEqualTypeOf<ResolvedRoute>()
-      expectTypeOf(from).toEqualTypeOf<ResolvedRoute<typeof route>>()
-    })
+      expectTypeOf(to).toEqualTypeOf<ResolvedRoute>();
+      expectTypeOf(from).toEqualTypeOf<ResolvedRoute<typeof route>>();
+    });
 
     route.onAfterRouteEnter((to, { from }) => {
-      expectTypeOf(to).toEqualTypeOf<ResolvedRoute<typeof route>>()
-      expectTypeOf(from).toEqualTypeOf<ResolvedRoute | null>()
-    })
+      expectTypeOf(to).toEqualTypeOf<ResolvedRoute<typeof route>>();
+      expectTypeOf(from).toEqualTypeOf<ResolvedRoute | null>();
+    });
 
     route.onAfterRouteUpdate((to, { from }) => {
-      expectTypeOf(to).toEqualTypeOf<ResolvedRoute<typeof route>>()
-      expectTypeOf(from).toEqualTypeOf<ResolvedRoute | null>()
-    })
+      expectTypeOf(to).toEqualTypeOf<ResolvedRoute<typeof route>>();
+      expectTypeOf(from).toEqualTypeOf<ResolvedRoute | null>();
+    });
 
     route.onAfterRouteLeave((to, { from }) => {
-      expectTypeOf(to).toEqualTypeOf<ResolvedRoute>()
-      expectTypeOf(from).toEqualTypeOf<ResolvedRoute<typeof route>>()
-    })
-  })
+      expectTypeOf(to).toEqualTypeOf<ResolvedRoute>();
+      expectTypeOf(from).toEqualTypeOf<ResolvedRoute<typeof route>>();
+    });
+  });
 
-  test('context.push', () => {
+  test("context.push", () => {
     const contextRoute = createRoute({
-      name: 'contextRoute',
+      name: "contextRoute",
       component,
-    })
+    });
 
     const route = createRoute({
       context: [contextRoute],
-      name: 'route',
-      path: '/[paramName]',
+      name: "route",
+      path: "/[paramName]",
       component,
-    })
+    });
 
     route.onBeforeRouteEnter((_to, context) => {
       // valid - current route
-      context.push('route', { paramName: 'value' })
+      context.push("route", { paramName: "value" });
 
       // valid - context route
-      context.push('contextRoute')
+      context.push("contextRoute");
 
       // @ts-expect-error should not accept an invalid route name
-      context.push('foo')
+      context.push("foo");
 
       // @ts-expect-error should not accept an invalid param
-      context.push('route', { invalidParamName: 'value' })
-    })
-  })
-  test('context.update', () => {
+      context.push("route", { invalidParamName: "value" });
+    });
+  });
+  test("context.update", () => {
     const route = createRoute({
-      name: 'route',
-      path: '/[paramName]',
+      name: "route",
+      path: "/[paramName]",
       component,
-    })
+    });
 
     route.onBeforeRouteEnter((_to, context) => {
-      context.update('paramName', 'value')
+      context.update("paramName", "value");
 
       // @ts-expect-error should not accept invalid param name
-      context.update('invalidParamName', 'value')
+      context.update("invalidParamName", "value");
 
-      context.update({ paramName: 'value' })
+      context.update({ paramName: "value" });
 
       // @ts-expect-error should not accept invalid params
-      context.update({ invalidParamName: 'value' })
+      context.update({ invalidParamName: "value" });
 
-      context.update({ paramName: 'value' }, { replace: true })
+      context.update({ paramName: "value" }, { replace: true });
 
       // @ts-expect-error should not accept invalid options
-      context.update({ paramName: 'value' }, { invalid: true })
-    })
-  })
-})
+      context.update({ paramName: "value" }, { invalid: true });
+    });
+  });
+});
 
-test('given parent, context is combined', () => {
-  const parentRejection = createRejection({ type: 'aRejection' })
-  const childRelated = createRoute({ name: 'bRoute' })
+test("given parent, context is combined", () => {
+  const parentRejection = createRejection({ type: "aRejection" });
+  const childRelated = createRoute({ name: "bRoute" });
 
   const parent = createRoute({
     meta: {
       foo: 123,
     },
     context: [parentRejection],
-  })
+  });
 
   const child = createRoute({
     parent,
     context: [childRelated],
     meta: {
-      bar: 'zoo',
+      bar: "zoo",
     },
-  })
+  });
 
   child.onAfterRouteEnter((_to, { push, reject }) => {
-    expectTypeOf(reject).parameters.toEqualTypeOf<['NotFound' | 'aRejection']>()
+    expectTypeOf(reject).parameters.toEqualTypeOf<["NotFound" | "aRejection"]>();
 
     // ok
-    push('bRoute')
+    push("bRoute");
     // @ts-expect-error should not accept an invalid route name
-    push('fakeRoute')
-  })
-})
+    push("fakeRoute");
+  });
+});
diff --git a/src/services/createRoute.spec.ts b/src/services/createRoute.spec.ts
index 59b034d1..9ad6d10a 100644
--- a/src/services/createRoute.spec.ts
+++ b/src/services/createRoute.spec.ts
@@ -1,365 +1,396 @@
-import { describe, expect, test, vi } from 'vitest'
-import { createRoute } from '@/services/createRoute'
-import { component } from '@/utilities/testHelpers'
-import { createRouter } from '@/services/createRouter'
-import { DuplicateParamsError } from '@/errors/duplicateParamsError'
-import { withParams } from '@/services/withParams'
-import { createRejection } from './createRejection'
-
-describe('combine', () => {
-  test('given parent, path is combined', () => {
+import { describe, expect, test, vi } from "vite-plus/test";
+import { createRoute } from "@/services/createRoute";
+import { component } from "@/utilities/testHelpers";
+import { createRouter } from "@/services/createRouter";
+import { DuplicateParamsError } from "@/errors/duplicateParamsError";
+import { withParams } from "@/services/withParams";
+import { createRejection } from "./createRejection";
+
+describe("combine", () => {
+  test("given parent, path is combined", () => {
     const parent = createRoute({
-      path: '/parent',
-    })
+      path: "/parent",
+    });
 
     const child = createRoute({
       parent: parent,
-      path: withParams('/child/[id]', { id: Number }),
-    })
+      path: withParams("/child/[id]", { id: Number }),
+    });
 
-    expect(child.stringify({ id: 123 })).toBe('/parent/child/123')
-  })
+    expect(child.stringify({ id: 123 })).toBe("/parent/child/123");
+  });
 
-  test('given undefined path, path is combined', () => {
+  test("given undefined path, path is combined", () => {
     const parent = createRoute({
-      path: '/parent',
-    })
+      path: "/parent",
+    });
 
     const child = createRoute({
       parent: parent,
-    })
+    });
 
     const grandChild = createRoute({
       parent: child,
-      path: '/grand-child',
-    })
+      path: "/grand-child",
+    });
 
-    const kinless = createRoute({})
+    const kinless = createRoute({});
 
-    expect(kinless.stringify()).toBe('/')
-    expect(child.stringify()).toBe('/parent')
-    expect(grandChild.stringify()).toBe('/parent/grand-child')
-  })
+    expect(kinless.stringify()).toBe("/");
+    expect(child.stringify()).toBe("/parent");
+    expect(grandChild.stringify()).toBe("/parent/grand-child");
+  });
 
-  test('given parent, query is combined', () => {
+  test("given parent, query is combined", () => {
     const parent = createRoute({
-      query: 'static=123',
-    })
+      query: "static=123",
+    });
 
     const child = createRoute({
       parent: parent,
-      query: withParams('sort=[sort]', { sort: Boolean }),
-    })
+      query: withParams("sort=[sort]", { sort: Boolean }),
+    });
 
-    expect(child.stringify({ sort: true })).toBe('/?static=123&sort=true')
-  })
+    expect(child.stringify({ sort: true })).toBe("/?static=123&sort=true");
+  });
 
-  test('given parent, state is combined into state', () => {
+  test("given parent, state is combined into state", () => {
     const parent = createRoute({
       state: {
         foo: Number,
       },
-    })
+    });
 
     const child = createRoute({
       parent: parent,
       state: {
         bar: String,
       },
-    })
+    });
 
     expect(child.state).toMatchObject({
       foo: Number,
       bar: String,
-    })
-  })
+    });
+  });
 
-  test('given parent and child without state, state matches parent', () => {
+  test("given parent and child without state, state matches parent", () => {
     const parent = createRoute({
       state: {
         foo: Number,
       },
-    })
+    });
 
     const child = createRoute({
       parent: parent,
-    })
+    });
 
     expect(child.state).toMatchObject({
       foo: Number,
-    })
-  })
+    });
+  });
 
-  test('given parent, meta is combined', () => {
+  test("given parent, meta is combined", () => {
     const parent = createRoute({
       meta: {
         foo: 123,
       },
-    })
+    });
 
     const child = createRoute({
       parent: parent,
       meta: {
-        bar: 'zoo',
+        bar: "zoo",
       },
-    })
+    });
 
     expect(child.meta).toMatchObject({
       foo: 123,
-      bar: 'zoo',
-    })
-  })
+      bar: "zoo",
+    });
+  });
 
-  test('given parent, context is combined', () => {
-    const parentRejection = createRejection({ type: 'aRejection' })
-    const childRelated = createRoute({ name: 'bRoute' })
+  test("given parent, context is combined", () => {
+    const parentRejection = createRejection({ type: "aRejection" });
+    const childRelated = createRoute({ name: "bRoute" });
 
     const parent = createRoute({
       meta: {
         foo: 123,
       },
       context: [parentRejection],
-    })
+    });
 
     const child = createRoute({
       parent,
       context: [childRelated],
       meta: {
-        bar: 'zoo',
+        bar: "zoo",
       },
-    })
+    });
 
-    expect(child.context).toMatchObject([parentRejection, childRelated])
-  })
+    expect(child.context).toMatchObject([parentRejection, childRelated]);
+  });
 
-  test('given parent and child without meta, meta matches parent', () => {
+  test("given parent and child without meta, meta matches parent", () => {
     const parent = createRoute({
       meta: {
         foo: 123,
       },
-    })
+    });
 
     const child = createRoute({
       parent: parent,
-    })
+    });
 
     expect(child.meta).toMatchObject({
       foo: 123,
-    })
-  })
+    });
+  });
 
-  test('given child has hoist, everything is combined except url', () => {
+  test("given child has hoist, everything is combined except url", () => {
     const parent = createRoute({
-      path: '/parent/[?parent]',
-      query: 'parent=123',
-      hash: 'parent',
+      path: "/parent/[?parent]",
+      query: "parent=123",
+      hash: "parent",
       state: {
-        parent: 'parent',
+        parent: "parent",
       },
       meta: {
-        parent: 'parent',
+        parent: "parent",
       },
-    })
+    });
 
     const child = createRoute({
       parent,
       hoist: true,
-      path: '/child/[?child]',
-      query: 'child=456',
-      hash: 'child',
+      path: "/child/[?child]",
+      query: "child=456",
+      hash: "child",
       state: {
-        child: 'child',
+        child: "child",
       },
       meta: {
-        child: 'child',
+        child: "child",
       },
-    })
+    });
 
-    const params = child.parse('/child/42?child=456#child')
+    const params = child.parse("/child/42?child=456#child");
     expect(params).toMatchObject({
-      child: '42',
-    })
+      child: "42",
+    });
 
     // @ts-expect-error - parent is not a param
-    params.parent = true
+    params.parent = true;
 
-    expect(child.stringify({ child: '42' })).toBe('/child/42?child=456#child')
+    expect(child.stringify({ child: "42" })).toBe("/child/42?child=456#child");
     expect(child.state).toMatchObject({
-      parent: 'parent',
-      child: 'child',
-    })
+      parent: "parent",
+      child: "child",
+    });
     expect(child.meta).toMatchObject({
-      parent: 'parent',
-      child: 'child',
-    })
-  })
-})
-
-describe('props', () => {
-  test('parent context is passed to child props', async () => {
-    const spy = vi.fn()
+      parent: "parent",
+      child: "child",
+    });
+  });
+});
+
+describe("props", () => {
+  test("parent context is passed to child props", async () => {
+    const spy = vi.fn();
     const parent = createRoute({
-      name: 'parent',
-    })
-
-    const child = createRoute({
-      name: 'child',
-      parent: parent,
-      path: '/child',
-    }, (_, { parent }) => {
-      return spy(parent)
-    })
+      name: "parent",
+    });
+
+    const child = createRoute(
+      {
+        name: "child",
+        parent: parent,
+        path: "/child",
+      },
+      (_, { parent }) => {
+        return spy(parent);
+      },
+    );
 
     const router = createRouter([parent, child], {
-      initialUrl: '/child',
-    })
+      initialUrl: "/child",
+    });
 
-    await router.start()
+    await router.start();
 
-    expect(spy).toHaveBeenCalledWith({ name: 'parent', props: undefined })
-  })
+    expect(spy).toHaveBeenCalledWith({ name: "parent", props: undefined });
+  });
 
-  test('sync parent props are passed to child props', async () => {
-    const spy = vi.fn()
+  test("sync parent props are passed to child props", async () => {
+    const spy = vi.fn();
 
-    const parent = createRoute({
-      name: 'parent',
-    }, () => ({ foo: 123 }))
-
-    const child = createRoute({
-      name: 'child',
-      parent: parent,
-      path: '/child',
-    }, (__, { parent }) => {
-      return spy({ value: parent.props.foo })
-    })
+    const parent = createRoute(
+      {
+        name: "parent",
+      },
+      () => ({ foo: 123 }),
+    );
+
+    const child = createRoute(
+      {
+        name: "child",
+        parent: parent,
+        path: "/child",
+      },
+      (__, { parent }) => {
+        return spy({ value: parent.props.foo });
+      },
+    );
 
     const router = createRouter([parent, child], {
-      initialUrl: '/child',
-    })
-
-    await router.start()
+      initialUrl: "/child",
+    });
 
-    expect(spy).toHaveBeenCalledWith({ value: 123 })
-  })
+    await router.start();
 
-  test('async parent props are passed to child props', async () => {
-    const spy = vi.fn()
+    expect(spy).toHaveBeenCalledWith({ value: 123 });
+  });
 
-    const parent = createRoute({
-      name: 'parent',
-    }, async () => ({ foo: 123 }))
+  test("async parent props are passed to child props", async () => {
+    const spy = vi.fn();
 
-    const child = createRoute({
-      name: 'child',
-      parent: parent,
-      path: '/child',
-    }, async (__, { parent }) => {
-      expect(parent.props).toBeDefined()
-      expect(parent.props).toBeInstanceOf(Promise)
+    const parent = createRoute(
+      {
+        name: "parent",
+      },
+      async () => ({ foo: 123 }),
+    );
+
+    const child = createRoute(
+      {
+        name: "child",
+        parent: parent,
+        path: "/child",
+      },
+      async (__, { parent }) => {
+        expect(parent.props).toBeDefined();
+        expect(parent.props).toBeInstanceOf(Promise);
 
-      const { foo: value } = await parent.props
+        const { foo: value } = await parent.props;
 
-      return spy({ value })
-    })
+        return spy({ value });
+      },
+    );
 
     const router = createRouter([parent, child], {
-      initialUrl: '/child',
-    })
+      initialUrl: "/child",
+    });
 
-    await router.start()
+    await router.start();
 
-    expect(spy).toHaveBeenCalledWith({ value: 123 })
-  })
+    expect(spy).toHaveBeenCalledWith({ value: 123 });
+  });
 
-  test('sync parent props with multiple views are passed to child props', async () => {
-    const spy = vi.fn()
+  test("sync parent props with multiple views are passed to child props", async () => {
+    const spy = vi.fn();
 
-    const parent = createRoute({
-      name: 'parent',
-      components: {
-        one: component,
-        two: component,
-        three: component,
+    const parent = createRoute(
+      {
+        name: "parent",
+        components: {
+          one: component,
+          two: component,
+          three: component,
+        },
+      },
+      {
+        one: () => ({ foo: 123 }),
+        two: () => ({ bar: 456 }),
       },
-    }, {
-      one: () => ({ foo: 123 }),
-      two: () => ({ bar: 456 }),
-    })
+    );
 
-    const child = createRoute({
-      name: 'child',
-      parent: parent,
-      path: '/child',
-    }, (__, { parent }) => {
-      return spy({
-        value1: parent.props.one.foo,
-        value2: parent.props.two.bar,
-      })
-    })
+    const child = createRoute(
+      {
+        name: "child",
+        parent: parent,
+        path: "/child",
+      },
+      (__, { parent }) => {
+        return spy({
+          value1: parent.props.one.foo,
+          value2: parent.props.two.bar,
+        });
+      },
+    );
 
     const router = createRouter([parent, child], {
-      initialUrl: '/child',
-    })
+      initialUrl: "/child",
+    });
 
-    await router.start()
+    await router.start();
 
-    expect(spy).toHaveBeenCalledWith({ value1: 123, value2: 456 })
-  })
+    expect(spy).toHaveBeenCalledWith({ value1: 123, value2: 456 });
+  });
 
-  test('async parent props with multiple views are passed to child props', async () => {
-    const spy = vi.fn()
+  test("async parent props with multiple views are passed to child props", async () => {
+    const spy = vi.fn();
 
-    const parent = createRoute({
-      name: 'parent',
-      components: {
-        one: component,
-        two: component,
-        three: component,
+    const parent = createRoute(
+      {
+        name: "parent",
+        components: {
+          one: component,
+          two: component,
+          three: component,
+        },
       },
-    }, {
-      one: async () => ({ foo: 123 }),
-      two: async () => ({ bar: 456 }),
-    })
-
-    const child = createRoute({
-      name: 'child',
-      parent: parent,
-      path: '/child',
-    }, async (__, { parent }) => {
-      expect(parent.props).toBeDefined()
-      expect(parent.props.one).toBeInstanceOf(Promise)
-      expect(parent.props.two).toBeInstanceOf(Promise)
-
-      const { foo: value1 } = await parent.props.one
-      const { bar: value2 } = await parent.props.two
+      {
+        one: async () => ({ foo: 123 }),
+        two: async () => ({ bar: 456 }),
+      },
+    );
 
-      return spy({
-        value1,
-        value2,
-      })
-    })
+    const child = createRoute(
+      {
+        name: "child",
+        parent: parent,
+        path: "/child",
+      },
+      async (__, { parent }) => {
+        expect(parent.props).toBeDefined();
+        expect(parent.props.one).toBeInstanceOf(Promise);
+        expect(parent.props.two).toBeInstanceOf(Promise);
+
+        const { foo: value1 } = await parent.props.one;
+        const { bar: value2 } = await parent.props.two;
+
+        return spy({
+          value1,
+          value2,
+        });
+      },
+    );
 
     const router = createRouter([parent, child], {
-      initialUrl: '/child',
-    })
+      initialUrl: "/child",
+    });
 
-    await router.start()
+    await router.start();
 
-    expect(spy).toHaveBeenCalledWith({ value1: 123, value2: 456 })
-  })
-})
+    expect(spy).toHaveBeenCalledWith({ value1: 123, value2: 456 });
+  });
+});
 
 test.each([
-  ['/[foo]', 'foo=[foo]', '[bar]'],
-  ['/[foo]', 'foo=[bar]', '[foo]'],
-  ['/[bar]', 'foo=[foo]', '[foo]'],
-])('given duplicate params across different parts of the route, throws DuplicateParamsError', (path, query, hash) => {
-  const action: () => void = () => createRoute({
-    path,
-    query,
-    hash,
-  })
-
-  expect(action).toThrow(DuplicateParamsError)
-})
+  ["/[foo]", "foo=[foo]", "[bar]"],
+  ["/[foo]", "foo=[bar]", "[foo]"],
+  ["/[bar]", "foo=[foo]", "[foo]"],
+])(
+  "given duplicate params across different parts of the route, throws DuplicateParamsError",
+  (path, query, hash) => {
+    const action: () => void = () =>
+      createRoute({
+        path,
+        query,
+        hash,
+      });
+
+    expect(action).toThrow(DuplicateParamsError);
+  },
+);
diff --git a/src/services/createRouteRedirects.spec.ts b/src/services/createRouteRedirects.spec.ts
index f98ebd8f..8eb9710f 100644
--- a/src/services/createRouteRedirects.spec.ts
+++ b/src/services/createRouteRedirects.spec.ts
@@ -1,156 +1,156 @@
-import { MultipleRouteRedirectsError } from '@/errors/multipleRouteRedirectsError'
-import { createRoute, createRouter } from '@/main'
-import { expect, test } from 'vitest'
+import { MultipleRouteRedirectsError } from "@/errors/multipleRouteRedirectsError";
+import { createRoute, createRouter } from "@/main";
+import { expect, test } from "vite-plus/test";
 
-test('redirectTo correctly redirects to the to route', async () => {
+test("redirectTo correctly redirects to the to route", async () => {
   const to = createRoute({
-    name: 'to',
-    path: '/to',
-  })
+    name: "to",
+    path: "/to",
+  });
 
   const from = createRoute({
-    name: 'from',
-    path: '/from',
-  })
+    name: "from",
+    path: "/from",
+  });
 
-  from.redirectTo(to)
+  from.redirectTo(to);
 
-  const router = createRouter([to, from], { initialUrl: '/from' })
+  const router = createRouter([to, from], { initialUrl: "/from" });
 
-  await router.start()
+  await router.start();
 
-  expect(router.route.href).toBe('/to')
-})
+  expect(router.route.href).toBe("/to");
+});
 
-test('redirectFrom correctly redirects from the from route', async () => {
+test("redirectFrom correctly redirects from the from route", async () => {
   const to = createRoute({
-    name: 'to',
-    path: '/to',
-  })
+    name: "to",
+    path: "/to",
+  });
 
   const from = createRoute({
-    name: 'from',
-    path: '/from',
-  })
+    name: "from",
+    path: "/from",
+  });
 
-  to.redirectFrom(from)
+  to.redirectFrom(from);
 
-  const router = createRouter([to, from], { initialUrl: '/from' })
+  const router = createRouter([to, from], { initialUrl: "/from" });
 
-  await router.start()
+  await router.start();
 
-  expect(router.route.href).toBe('/to')
-})
+  expect(router.route.href).toBe("/to");
+});
 
-test('redirectTo correctly redirects to the to route with params', async () => {
-  const paramValue = 'paramValue'
+test("redirectTo correctly redirects to the to route with params", async () => {
+  const paramValue = "paramValue";
 
   const to = createRoute({
-    name: 'to',
-    path: '/to/[toParam]',
-  })
+    name: "to",
+    path: "/to/[toParam]",
+  });
 
   const from = createRoute({
-    name: 'from',
-    path: '/from/[fromParam]',
-  })
+    name: "from",
+    path: "/from/[fromParam]",
+  });
 
   to.redirectFrom(from, ({ fromParam }) => {
-    expect(fromParam).toEqual(paramValue)
+    expect(fromParam).toEqual(paramValue);
 
-    return { toParam: fromParam }
-  })
+    return { toParam: fromParam };
+  });
 
   const router = createRouter([to, from], {
     initialUrl: `/from/${paramValue}`,
-  })
+  });
 
-  await router.start()
+  await router.start();
 
-  expect(router.route.href).toBe(`/to/${paramValue}`)
-})
+  expect(router.route.href).toBe(`/to/${paramValue}`);
+});
 
-test('redirectFrom correctly redirects from the from route with params', async () => {
-  const paramValue = 'paramValue'
+test("redirectFrom correctly redirects from the from route with params", async () => {
+  const paramValue = "paramValue";
 
   const to = createRoute({
-    name: 'to',
-    path: '/to/[toParam]',
-  })
+    name: "to",
+    path: "/to/[toParam]",
+  });
 
   const from = createRoute({
-    name: 'from',
-    path: '/from/[fromParam]',
-  })
+    name: "from",
+    path: "/from/[fromParam]",
+  });
 
   from.redirectTo(to, ({ fromParam }) => {
-    expect(fromParam).toEqual(paramValue)
+    expect(fromParam).toEqual(paramValue);
 
-    return { toParam: fromParam }
-  })
+    return { toParam: fromParam };
+  });
 
   const router = createRouter([to, from], {
     initialUrl: `/from/${paramValue}`,
-  })
+  });
 
-  await router.start()
+  await router.start();
 
-  expect(router.route.href).toBe(`/to/${paramValue}`)
-})
+  expect(router.route.href).toBe(`/to/${paramValue}`);
+});
 
-test('throws MultipleRouteRedirectsError when a route has multiple redirects', () => {
+test("throws MultipleRouteRedirectsError when a route has multiple redirects", () => {
   const to = createRoute({
-    name: 'to',
-    path: '/to',
-  })
+    name: "to",
+    path: "/to",
+  });
 
   const from = createRoute({
-    name: 'from',
-    path: '/from',
-  })
+    name: "from",
+    path: "/from",
+  });
 
-  to.redirectFrom(from)
+  to.redirectFrom(from);
 
-  expect(() => to.redirectFrom(from)).toThrow(MultipleRouteRedirectsError)
-  expect(() => from.redirectTo(to)).toThrow(MultipleRouteRedirectsError)
-})
+  expect(() => to.redirectFrom(from)).toThrow(MultipleRouteRedirectsError);
+  expect(() => from.redirectTo(to)).toThrow(MultipleRouteRedirectsError);
+});
 
-test('from does not need to be passed into the route for redirect to work', async () => {
+test("from does not need to be passed into the route for redirect to work", async () => {
   const to = createRoute({
-    name: 'to',
-    path: '/to',
-  })
+    name: "to",
+    path: "/to",
+  });
 
   const from = createRoute({
-    name: 'from',
-    path: '/from',
-  })
+    name: "from",
+    path: "/from",
+  });
 
-  to.redirectFrom(from)
+  to.redirectFrom(from);
 
-  const router = createRouter([to], { initialUrl: '/from' })
+  const router = createRouter([to], { initialUrl: "/from" });
 
-  await router.start()
+  await router.start();
 
-  expect(router.route.href).toBe('/to')
-})
+  expect(router.route.href).toBe("/to");
+});
 
-test('to does not need to be passed into the route for redirect to work', async () => {
+test("to does not need to be passed into the route for redirect to work", async () => {
   const to = createRoute({
-    name: 'to',
-    path: '/to',
-  })
+    name: "to",
+    path: "/to",
+  });
 
   const from = createRoute({
-    name: 'from',
-    path: '/from',
-  })
+    name: "from",
+    path: "/from",
+  });
 
-  to.redirectTo(from)
+  to.redirectTo(from);
 
-  const router = createRouter([from], { initialUrl: '/to' })
+  const router = createRouter([from], { initialUrl: "/to" });
 
-  await router.start()
+  await router.start();
 
-  expect(router.route.href).toBe('/from')
-})
+  expect(router.route.href).toBe("/from");
+});
diff --git a/src/services/createRouter.browser.spec.ts b/src/services/createRouter.browser.spec.ts
index f2044035..6f02bb65 100644
--- a/src/services/createRouter.browser.spec.ts
+++ b/src/services/createRouter.browser.spec.ts
@@ -1,116 +1,118 @@
-import { flushPromises, mount } from '@vue/test-utils'
-import { describe, expect, test } from 'vitest'
-import { createRoute } from '@/services/createRoute'
-import { createRouter } from '@/services/createRouter'
-import { component } from '@/utilities/testHelpers'
-import { createRejection } from './createRejection'
-
-test('Router is automatically started when installed', async () => {
+import { flushPromises, mount } from "@vue/test-utils";
+import { describe, expect, test } from "vite-plus/test";
+import { createRoute } from "@/services/createRoute";
+import { createRouter } from "@/services/createRouter";
+import { component } from "@/utilities/testHelpers";
+import { createRejection } from "./createRejection";
+
+test("Router is automatically started when installed", async () => {
   const route = createRoute({
-    name: 'root',
-    path: '/',
+    name: "root",
+    path: "/",
     component,
-  })
+  });
 
   const router = createRouter([route], {
-    initialUrl: '/',
-  })
+    initialUrl: "/",
+  });
 
   const root = {
-    template: '<RouterView/>',
-  }
+    template: "<RouterView/>",
+  };
 
-  expect(router.route.name).toBe('NotFound')
+  expect(router.route.name).toBe("NotFound");
 
   mount(root, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  await router.start()
+  await router.start();
 
-  expect(router.route.name).toBe('root')
-})
+  expect(router.route.name).toBe("root");
+});
 
-describe('options.rejections', () => {
-  test('given a rejection, adds the rejection to the router', async () => {
+describe("options.rejections", () => {
+  test("given a rejection, adds the rejection to the router", async () => {
     const route = createRoute({
-      name: 'root',
-      path: '/',
+      name: "root",
+      path: "/",
       component,
-    })
+    });
 
     const customRejection = createRejection({
-      type: 'CustomRejection',
-      component: { template: '<div>This is a custom rejection</div>' },
-    })
+      type: "CustomRejection",
+      component: { template: "<div>This is a custom rejection</div>" },
+    });
 
     const router = createRouter([route], {
-      initialUrl: '/',
+      initialUrl: "/",
       rejections: [customRejection],
-    })
+    });
 
     const root = {
-      template: '<RouterView/>',
-    }
+      template: "<RouterView/>",
+    };
 
     const wrapper = mount(root, {
       global: {
         plugins: [router],
       },
-    })
+    });
 
-    await router.start()
+    await router.start();
 
-    expect(router.route.name).toBe('root')
+    expect(router.route.name).toBe("root");
 
-    router.reject('CustomRejection')
+    router.reject("CustomRejection");
 
-    await flushPromises()
+    await flushPromises();
 
-    expect(router.route.name).toBe('root')
-    expect(window.location.pathname).toBe('/')
+    expect(router.route.name).toBe("root");
+    expect(window.location.pathname).toBe("/");
 
-    expect(wrapper.html()).toBe('<div>This is a custom rejection</div>')
-  })
-})
+    expect(wrapper.html()).toBe("<div>This is a custom rejection</div>");
+  });
+});
 
-test('given child has hoist, keeps parent context and components without parent url', async () => {
+test("given child has hoist, keeps parent context and components without parent url", async () => {
   const parent = createRoute({
-    name: 'parent',
-    path: '/parent',
+    name: "parent",
+    path: "/parent",
     component: { template: '<div class="parent"><RouterView/></div>' },
-  })
+  });
 
   const child = createRoute({
-    name: 'child',
+    name: "child",
     parent,
     hoist: true,
-    path: '/child/[?child]',
+    path: "/child/[?child]",
     component: { template: '<i class="child" />' },
-  })
+  });
 
-  const router = createRouter([child], { initialUrl: '/' })
+  const router = createRouter([child], { initialUrl: "/" });
 
   const root = {
-    template: '<RouterView/>',
-  }
+    template: "<RouterView/>",
+  };
 
   const wrapper = mount(root, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  await router.start()
+  await router.start();
 
-  await router.push('child', { child: '42' })
+  await router.push("child", { child: "42" });
 
-  expect(router.route).toMatchObject(expect.objectContaining({
-    name: 'child',
-    href: '/child/42',
-  }))
+  expect(router.route).toMatchObject(
+    expect.objectContaining({
+      name: "child",
+      href: "/child/42",
+    }),
+  );
 
-  expect(wrapper.html()).toBe('<div class="parent"><i class="child"></i></div>')
-})
+  expect(wrapper.html()).toBe('<div class="parent"><i class="child"></i></div>');
+});
diff --git a/src/services/createRouter.spec-d.ts b/src/services/createRouter.spec-d.ts
index f83620c1..cea27a72 100644
--- a/src/services/createRouter.spec-d.ts
+++ b/src/services/createRouter.spec-d.ts
@@ -1,305 +1,321 @@
-import { createRoute } from '@/services/createRoute'
-import { createRouter } from '@/services/createRouter'
-import { component } from '@/utilities/testHelpers'
-import { describe, test, expectTypeOf } from 'vitest'
-import { createRouterPlugin } from './createRouterPlugin'
-import { BuiltInRejectionType } from '@/types/rejection'
-import { createRejection } from './createRejection'
-import { AddBeforeEnterHook, AddBeforeUpdateHook, AddBeforeLeaveHook, AddAfterEnterHook, AddAfterUpdateHook, AddAfterLeaveHook, AddErrorHook, AddRejectionHook } from '@/types/hooks'
-import { RouterAbort } from '@/types/routerAbort'
-import { RouteUpdate } from '@/types/routeUpdate'
-import { ResolvedRouteUnion } from '@/types/resolved'
-import { RouterRouteUnion } from '@/types/router'
-
-describe('hooks', () => {
+import { createRoute } from "@/services/createRoute";
+import { createRouter } from "@/services/createRouter";
+import { component } from "@/utilities/testHelpers";
+import { describe, test, expectTypeOf } from "vite-plus/test";
+import { createRouterPlugin } from "./createRouterPlugin";
+import { BuiltInRejectionType } from "@/types/rejection";
+import { createRejection } from "./createRejection";
+import {
+  AddBeforeEnterHook,
+  AddBeforeUpdateHook,
+  AddBeforeLeaveHook,
+  AddAfterEnterHook,
+  AddAfterUpdateHook,
+  AddAfterLeaveHook,
+  AddErrorHook,
+  AddRejectionHook,
+} from "@/types/hooks";
+import { RouterAbort } from "@/types/routerAbort";
+import { RouteUpdate } from "@/types/routeUpdate";
+import { ResolvedRouteUnion } from "@/types/resolved";
+import { RouterRouteUnion } from "@/types/router";
+
+describe("hooks", () => {
   const parent = createRoute({
-    name: 'parent',
-    path: '/parent/[parentParam]',
+    name: "parent",
+    path: "/parent/[parentParam]",
     component,
-  })
+  });
 
   const child = createRoute({
-    name: 'child',
-    path: '/child/[childParam]',
+    name: "child",
+    path: "/child/[childParam]",
     parent,
     component,
-  })
+  });
 
   const pluginRoute = createRoute({
-    name: 'plugin',
-    path: '/plugin/[pluginParam]',
+    name: "plugin",
+    path: "/plugin/[pluginParam]",
     component,
-  })
+  });
 
-  const routes = [parent, child] as const
+  const routes = [parent, child] as const;
 
-  const pluginRoutes = [pluginRoute] as const
+  const pluginRoutes = [pluginRoute] as const;
 
   const plugin = createRouterPlugin({
     routes: pluginRoutes,
-  })
-
-  const router = createRouter(routes, { initialUrl: '/' }, [plugin])
-
-  type Routes = typeof routes | typeof pluginRoutes
-
-  test('functions are correctly typed', () => {
-    expectTypeOf(router.onBeforeRouteEnter).toEqualTypeOf<AddBeforeEnterHook<Routes, never>>()
-    expectTypeOf(router.onBeforeRouteLeave).toEqualTypeOf<AddBeforeLeaveHook<Routes, never>>()
-    expectTypeOf(router.onBeforeRouteUpdate).toEqualTypeOf<AddBeforeUpdateHook<Routes, never>>()
-    expectTypeOf(router.onAfterRouteEnter).toEqualTypeOf<AddAfterEnterHook<Routes, never>>()
-    expectTypeOf(router.onAfterRouteLeave).toEqualTypeOf<AddAfterLeaveHook<Routes, never>>()
-    expectTypeOf(router.onAfterRouteUpdate).toEqualTypeOf<AddAfterUpdateHook<Routes, never>>()
-    expectTypeOf(router.onError).toEqualTypeOf<AddErrorHook<Routes[number], Routes, never>>()
-    expectTypeOf(router.onRejection).toEqualTypeOf<AddRejectionHook<BuiltInRejectionType, Routes>>()
-  })
-
-  test('to and from can be narrowed', () => {
+  });
+
+  const router = createRouter(routes, { initialUrl: "/" }, [plugin]);
+
+  type Routes = typeof routes | typeof pluginRoutes;
+
+  test("functions are correctly typed", () => {
+    expectTypeOf(router.onBeforeRouteEnter).toEqualTypeOf<AddBeforeEnterHook<Routes, never>>();
+    expectTypeOf(router.onBeforeRouteLeave).toEqualTypeOf<AddBeforeLeaveHook<Routes, never>>();
+    expectTypeOf(router.onBeforeRouteUpdate).toEqualTypeOf<AddBeforeUpdateHook<Routes, never>>();
+    expectTypeOf(router.onAfterRouteEnter).toEqualTypeOf<AddAfterEnterHook<Routes, never>>();
+    expectTypeOf(router.onAfterRouteLeave).toEqualTypeOf<AddAfterLeaveHook<Routes, never>>();
+    expectTypeOf(router.onAfterRouteUpdate).toEqualTypeOf<AddAfterUpdateHook<Routes, never>>();
+    expectTypeOf(router.onError).toEqualTypeOf<AddErrorHook<Routes[number], Routes, never>>();
+    expectTypeOf(router.onRejection).toEqualTypeOf<
+      AddRejectionHook<BuiltInRejectionType, Routes>
+    >();
+  });
+
+  test("to and from can be narrowed", () => {
     router.onBeforeRouteEnter((to, context) => {
-      if (to.name === 'parent') {
-        expectTypeOf(to.name).toEqualTypeOf<'parent'>()
-        expectTypeOf(to.params).toEqualTypeOf<{ parentParam: string }>()
+      if (to.name === "parent") {
+        expectTypeOf(to.name).toEqualTypeOf<"parent">();
+        expectTypeOf(to.params).toEqualTypeOf<{ parentParam: string }>();
       }
 
-      if (context.from?.name === 'parent') {
-        expectTypeOf(context.from.name).toEqualTypeOf<'parent'>()
-        expectTypeOf(context.from.params).toEqualTypeOf<{ parentParam: string }>()
+      if (context.from?.name === "parent") {
+        expectTypeOf(context.from.name).toEqualTypeOf<"parent">();
+        expectTypeOf(context.from.params).toEqualTypeOf<{ parentParam: string }>();
       }
 
-      if (to.name === 'child') {
-        expectTypeOf(to.name).toEqualTypeOf<'child'>()
-        expectTypeOf(to.params).toEqualTypeOf<{ parentParam: string, childParam: string }>()
+      if (to.name === "child") {
+        expectTypeOf(to.name).toEqualTypeOf<"child">();
+        expectTypeOf(to.params).toEqualTypeOf<{ parentParam: string; childParam: string }>();
       }
 
-      if (context.from?.name === 'child') {
-        expectTypeOf(context.from.name).toEqualTypeOf<'child'>()
-        expectTypeOf(context.from.params).toEqualTypeOf<{ parentParam: string, childParam: string }>()
+      if (context.from?.name === "child") {
+        expectTypeOf(context.from.name).toEqualTypeOf<"child">();
+        expectTypeOf(context.from.params).toEqualTypeOf<{
+          parentParam: string;
+          childParam: string;
+        }>();
       }
 
-      expectTypeOf(context.push).toEqualTypeOf(router.push)
-      expectTypeOf(context.replace).toEqualTypeOf(router.replace)
-    })
-  })
+      expectTypeOf(context.push).toEqualTypeOf(router.push);
+      expectTypeOf(context.replace).toEqualTypeOf(router.replace);
+    });
+  });
 
-  test('context.push', () => {
+  test("context.push", () => {
     router.onBeforeRouteEnter((_to, context) => {
-      expectTypeOf(context.push).toEqualTypeOf(router.push)
-    })
-  })
+      expectTypeOf(context.push).toEqualTypeOf(router.push);
+    });
+  });
 
-  test('context.replace', () => {
+  test("context.replace", () => {
     router.onBeforeRouteEnter((_to, context) => {
-      expectTypeOf(context.replace).toEqualTypeOf(router.replace)
-    })
-  })
+      expectTypeOf(context.replace).toEqualTypeOf(router.replace);
+    });
+  });
 
-  test('context.reject', () => {
+  test("context.reject", () => {
     router.onBeforeRouteEnter((_to, context) => {
-      expectTypeOf(context.reject).toEqualTypeOf(router.reject)
-    })
-  })
+      expectTypeOf(context.reject).toEqualTypeOf(router.reject);
+    });
+  });
 
-  test('context.update', () => {
+  test("context.update", () => {
     router.onBeforeRouteEnter((_to, context) => {
-      expectTypeOf(context.update).toEqualTypeOf<RouteUpdate<ResolvedRouteUnion<Routes[number]>>>()
-    })
-  })
+      expectTypeOf(context.update).toEqualTypeOf<RouteUpdate<ResolvedRouteUnion<Routes[number]>>>();
+    });
+  });
 
-  test('context.abort', () => {
+  test("context.abort", () => {
     router.onBeforeRouteEnter((_to, context) => {
-      expectTypeOf(context.abort).toEqualTypeOf<RouterAbort>()
-    })
-  })
-})
+      expectTypeOf(context.abort).toEqualTypeOf<RouterAbort>();
+    });
+  });
+});
 
-describe('rejections', () => {
-  test('built in rejections are valid', () => {
-    const _router = createRouter([])
-    type Source = Parameters<typeof _router.reject>[0]
-    type Expect = BuiltInRejectionType
+describe("rejections", () => {
+  test("built in rejections are valid", () => {
+    const _router = createRouter([]);
+    type Source = Parameters<typeof _router.reject>[0];
+    type Expect = BuiltInRejectionType;
 
-    expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
 
-  test('custom rejections are valid', () => {
+  test("custom rejections are valid", () => {
     const myCustomRejection = createRejection({
-      type: 'MyCustomRejection',
+      type: "MyCustomRejection",
       component,
-    })
+    });
 
     const _router = createRouter([], {
       rejections: [myCustomRejection],
-    })
+    });
 
-    type Source = Parameters<typeof _router.reject>[0]
-    type Expect = BuiltInRejectionType | 'MyCustomRejection'
+    type Source = Parameters<typeof _router.reject>[0];
+    type Expect = BuiltInRejectionType | "MyCustomRejection";
 
-    expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
 
-  test('custom rejections from plugins are valid', () => {
+  test("custom rejections from plugins are valid", () => {
     const myPluginRejection = createRejection({
-      type: 'MyPluginRejection',
+      type: "MyPluginRejection",
       component,
-    })
+    });
     const plugin = createRouterPlugin({
       rejections: [myPluginRejection],
-    })
+    });
 
-    const _router = createRouter([], {}, [plugin])
+    const _router = createRouter([], {}, [plugin]);
 
-    type Source = Parameters<typeof _router.reject>[0]
-    type Expect = BuiltInRejectionType | 'MyPluginRejection'
+    type Source = Parameters<typeof _router.reject>[0];
+    type Expect = BuiltInRejectionType | "MyPluginRejection";
 
-    expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
-})
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
+});
 
-describe('options.rejections in hooks', () => {
-  test('route hooks do not have access to router-level rejections', () => {
+describe("options.rejections in hooks", () => {
+  test("route hooks do not have access to router-level rejections", () => {
     const route = createRoute({
-      name: 'root',
-      path: '/',
+      name: "root",
+      path: "/",
       component,
-    })
+    });
 
     const customRejection = createRejection({
-      type: 'CustomRejection',
-      component: { template: '<div>This is a custom rejection</div>' },
-    })
+      type: "CustomRejection",
+      component: { template: "<div>This is a custom rejection</div>" },
+    });
 
     createRouter([route], {
-      initialUrl: '/',
+      initialUrl: "/",
       rejections: [customRejection],
-    })
+    });
 
     route.onBeforeRouteUpdate((_to, { reject, push }) => {
-      expectTypeOf(reject).parameters.toEqualTypeOf<[BuiltInRejectionType]>()
+      expectTypeOf(reject).parameters.toEqualTypeOf<[BuiltInRejectionType]>();
 
       // ok
-      push('root')
+      push("root");
       // @ts-expect-error does not know about routes outside of context
-      push('fakeRoute')
-    })
-  })
+      push("fakeRoute");
+    });
+  });
 
-  test('router hooks have access to router-level rejections', () => {
+  test("router hooks have access to router-level rejections", () => {
     const route = createRoute({
-      name: 'root',
-      path: '/',
+      name: "root",
+      path: "/",
       component,
-    })
+    });
 
     const customRejection = createRejection({
-      type: 'CustomRejection',
-      component: { template: '<div>This is a custom rejection</div>' },
-    })
+      type: "CustomRejection",
+      component: { template: "<div>This is a custom rejection</div>" },
+    });
 
     const router = createRouter([route], {
-      initialUrl: '/',
+      initialUrl: "/",
       rejections: [customRejection],
-    })
+    });
 
     router.onBeforeRouteUpdate((_to, { reject, push }) => {
-      expectTypeOf(reject).parameters.toEqualTypeOf<[BuiltInRejectionType | 'CustomRejection']>()
+      expectTypeOf(reject).parameters.toEqualTypeOf<[BuiltInRejectionType | "CustomRejection"]>();
 
       // ok
-      push('root')
+      push("root");
       // @ts-expect-error does not know about routes outside of router
-      push('fakeRoute')
-    })
-  })
-})
+      push("fakeRoute");
+    });
+  });
+});
 
-describe('route', () => {
-  test('route is never if there are no named routes', () => {
+describe("route", () => {
+  test("route is never if there are no named routes", () => {
     const route = createRoute({
       component,
-    })
+    });
 
-    expectTypeOf(route.name).toEqualTypeOf<''>()
+    expectTypeOf(route.name).toEqualTypeOf<"">();
 
-    const router = createRouter([route])
+    const router = createRouter([route]);
 
-    expectTypeOf(router.route).toEqualTypeOf<never>()
-  })
+    expectTypeOf(router.route).toEqualTypeOf<never>();
+  });
 
-  test('route union does not include routes without a name', () => {
+  test("route union does not include routes without a name", () => {
     // does not include routes without a name
     const routeA = createRoute({
       component,
-    })
+    });
 
     // does not include routes with an empty name
     const routeB = createRoute({
-      name: '',
+      name: "",
       component,
-    })
+    });
 
     const routeC = createRoute({
-      name: 'routeC',
+      name: "routeC",
       component,
-    })
+    });
 
     const routeD = createRoute({
-      name: 'routeD',
+      name: "routeD",
       component,
-    })
+    });
 
-    const router = createRouter([routeA, routeB, routeC, routeD])
+    const router = createRouter([routeA, routeB, routeC, routeD]);
 
-    expectTypeOf(router.route).toEqualTypeOf<RouterRouteUnion<[typeof routeC, typeof routeD]>>()
-  })
-})
+    expectTypeOf(router.route).toEqualTypeOf<RouterRouteUnion<[typeof routeC, typeof routeD]>>();
+  });
+});
 
-describe('route.matched.meta', () => {
-  test('is always defined', () => {
+describe("route.matched.meta", () => {
+  test("is always defined", () => {
     const routeA = createRoute({
-      name: 'routeA',
-    })
+      name: "routeA",
+    });
 
-    const router = createRouter([routeA])
+    const router = createRouter([routeA]);
 
-    expectTypeOf(router.route.matched.meta).toEqualTypeOf<Readonly<{}>>()
-  })
+    expectTypeOf(router.route.matched.meta).toEqualTypeOf<Readonly<{}>>();
+  });
 
-  test('union type is preserved', () => {
+  test("union type is preserved", () => {
     const routeA = createRoute({
-      name: 'routeA',
-    })
+      name: "routeA",
+    });
 
     const routeB = createRoute({
-      name: 'routeB',
+      name: "routeB",
       meta: { public: true },
-    })
+    });
 
-    const router = createRouter([routeA, routeB])
+    const router = createRouter([routeA, routeB]);
 
-    expectTypeOf(router.route.matched.meta).toEqualTypeOf<Readonly<{}> | Readonly<{ public: true }>>()
-  })
+    expectTypeOf(router.route.matched.meta).toEqualTypeOf<
+      Readonly<{}> | Readonly<{ public: true }>
+    >();
+  });
 
-  test('union type can be narrowed', () => {
+  test("union type can be narrowed", () => {
     const routeA = createRoute({
-      name: 'routeA',
-    })
+      name: "routeA",
+    });
 
     const routeB = createRoute({
-      name: 'routeB',
+      name: "routeB",
       meta: { public: true },
-    })
+    });
 
-    const router = createRouter([routeA, routeB])
+    const router = createRouter([routeA, routeB]);
 
-    if (router.route.matched.name === 'routeA') {
-      expectTypeOf(router.route.matched.meta).toEqualTypeOf<Readonly<{}>>()
+    if (router.route.matched.name === "routeA") {
+      expectTypeOf(router.route.matched.meta).toEqualTypeOf<Readonly<{}>>();
     }
 
-    if (router.route.matched.name === 'routeB') {
-      expectTypeOf(router.route.matched.meta).toEqualTypeOf<Readonly<{ public: true }>>()
+    if (router.route.matched.name === "routeB") {
+      expectTypeOf(router.route.matched.meta).toEqualTypeOf<Readonly<{ public: true }>>();
     }
 
-    if ('public' in router.route.matched.meta) {
-      expectTypeOf(router.route.matched.meta.public).toEqualTypeOf<true>()
+    if ("public" in router.route.matched.meta) {
+      expectTypeOf(router.route.matched.meta.public).toEqualTypeOf<true>();
     }
-  })
-})
+  });
+});
diff --git a/src/services/createRouter.spec.ts b/src/services/createRouter.spec.ts
index 8b4b8f58..af4c875a 100644
--- a/src/services/createRouter.spec.ts
+++ b/src/services/createRouter.spec.ts
@@ -1,1019 +1,1040 @@
-import { flushPromises } from '@vue/test-utils'
-import { Location } from '@/services/history'
-import { describe, expect, test, vi } from 'vitest'
-import { computed, toRefs } from 'vue'
-import { DuplicateNamesError } from '@/errors/duplicateNamesError'
-import { createRoute } from '@/services/createRoute'
-import { createRouter } from '@/services/createRouter'
-import * as createRouterHistoryUtilities from '@/services/createRouterHistory'
-import { component, routes } from '@/utilities/testHelpers'
-import { createExternalRoute } from '@/services/createExternalRoute'
-import { RouteNotFoundError } from '@/errors/routeNotFoundError'
-import { InvalidRouteParamValueError } from '@/errors/invalidRouteParamValueError'
-import { createRejection } from './createRejection'
-
-test('initial route is set', async () => {
+import { flushPromises } from "@vue/test-utils";
+import { Location } from "@/services/history";
+import { describe, expect, test, vi } from "vite-plus/test";
+import { computed, toRefs } from "vue";
+import { DuplicateNamesError } from "@/errors/duplicateNamesError";
+import { createRoute } from "@/services/createRoute";
+import { createRouter } from "@/services/createRouter";
+import * as createRouterHistoryUtilities from "@/services/createRouterHistory";
+import { component, routes } from "@/utilities/testHelpers";
+import { createExternalRoute } from "@/services/createExternalRoute";
+import { RouteNotFoundError } from "@/errors/routeNotFoundError";
+import { InvalidRouteParamValueError } from "@/errors/invalidRouteParamValueError";
+import { createRejection } from "./createRejection";
+
+test("initial route is set", async () => {
   const foo = createRoute({
-    name: 'root',
+    name: "root",
     component,
-    path: '/',
-  })
+    path: "/",
+  });
 
   const { route, start } = createRouter([foo], {
-    initialUrl: '/',
-  })
+    initialUrl: "/",
+  });
 
-  await start()
+  await start();
 
-  expect(route.matched.name).toBe('root')
-})
+  expect(route.matched.name).toBe("root");
+});
 
-test('initial state is set', async () => {
+test("initial state is set", async () => {
   const location: Location = {
-    key: 'foo',
-    pathname: '/',
-    search: '',
-    hash: '',
-    state: { zoo: '123' },
-  }
-
-  const actual = createRouterHistoryUtilities.createRouterHistory({ listener: () => {} })
-  vi.spyOn(createRouterHistoryUtilities, 'createRouterHistory').mockImplementation(() => ({
+    key: "foo",
+    pathname: "/",
+    search: "",
+    hash: "",
+    state: { zoo: "123" },
+  };
+
+  const actual = createRouterHistoryUtilities.createRouterHistory({ listener: () => {} });
+  vi.spyOn(createRouterHistoryUtilities, "createRouterHistory").mockImplementation(() => ({
     ...actual,
     location,
-  }))
+  }));
 
   const foo = createRoute({
-    name: 'root',
+    name: "root",
     component,
-    path: '/',
+    path: "/",
     state: { zoo: Number },
-  })
+  });
 
   const { route, start } = createRouter([foo], {
-    initialUrl: '/',
-  })
+    initialUrl: "/",
+  });
 
-  await start()
+  await start();
 
-  expect(route.state).toMatchObject({ zoo: 123 })
-})
+  expect(route.state).toMatchObject({ zoo: 123 });
+});
 
-test('updates the route when navigating', async () => {
+test("updates the route when navigating", async () => {
   const theRoute = createRoute({
-    name: 'first',
+    name: "first",
     component,
-    path: '/first',
-  })
+    path: "/first",
+  });
 
   const routes = [
     theRoute,
     createRoute({
-      name: 'second',
+      name: "second",
       component,
-      path: '/second',
+      path: "/second",
     }),
     createRoute({
-      name: 'third',
+      name: "third",
       component,
-      path: '/third/[id]',
+      path: "/third/[id]",
     }),
-  ]
+  ];
 
   const { push, route, start } = createRouter(routes, {
-    initialUrl: '/first',
-  })
+    initialUrl: "/first",
+  });
 
-  await start()
+  await start();
 
-  await push('first', {}, { state: { foo: 123 } })
+  await push("first", {}, { state: { foo: 123 } });
 
-  expect(route.matched.name).toBe('first')
+  expect(route.matched.name).toBe("first");
 
-  await push('/second')
+  await push("/second");
 
-  expect(route.matched.name).toBe('second')
-})
+  expect(route.matched.name).toBe("second");
+});
 
-test('route update updates the current route', async () => {
-  const route = createRoute(
-    {
-      name: 'root',
-      component,
-      path: '/[param]',
-    })
+test("route update updates the current route", async () => {
+  const route = createRoute({
+    name: "root",
+    component,
+    path: "/[param]",
+  });
 
   const router = createRouter([route], {
-    initialUrl: '/one',
-  })
+    initialUrl: "/one",
+  });
 
-  await router.start()
+  await router.start();
 
-  await router.route.update('param', 'two')
+  await router.route.update("param", "two");
 
-  expect(router.route.params.param).toBe('two')
+  expect(router.route.params.param).toBe("two");
 
   await router.route.update({
-    param: 'three',
-  })
+    param: "three",
+  });
 
-  expect(router.route.params.param).toBe('three')
-})
+  expect(router.route.params.param).toBe("three");
+});
 
-test.fails('route is readonly except for individual params', async () => {
+test.fails("route is readonly except for individual params", async () => {
   const routes = [
     createRoute({
-      name: 'root',
+      name: "root",
       component,
-      path: '/',
+      path: "/",
     }),
-  ]
+  ];
 
   const { route, start } = createRouter(routes, {
-    initialUrl: '/',
-  })
+    initialUrl: "/",
+  });
 
-  await start()
+  await start();
 
   // @ts-expect-error value is immutable
-  route.name = 'child'
-  expect(route.name).toBe('root')
+  route.name = "child";
+  expect(route.name).toBe("root");
 
   // @ts-expect-error value is immutable
-  route.matched = 'match'
-  expect(route.matched).toMatchObject(routes[0].matched)
+  route.matched = "match";
+  expect(route.matched).toMatchObject(routes[0].matched);
 
   // @ts-expect-error value is immutable
-  route.matches = 'matches'
-  expect(route.matches).toMatchObject(routes[0].matches)
+  route.matches = "matches";
+  expect(route.matches).toMatchObject(routes[0].matches);
 
-  route.params = { foo: 'bar' }
-  expect(route.params).toMatchObject({})
-})
+  route.params = { foo: "bar" };
+  expect(route.params).toMatchObject({});
+});
 
-test('individual params are writable', async () => {
+test("individual params are writable", async () => {
   const routes = [
     createRoute({
-      name: 'root',
+      name: "root",
       component,
-      path: '/[param]',
+      path: "/[param]",
     }),
-  ]
+  ];
 
   const { route, start } = createRouter(routes, {
-    initialUrl: '/one',
-  })
+    initialUrl: "/one",
+  });
 
-  await start()
+  await start();
 
-  route.params.param = 'goodbye'
+  route.params.param = "goodbye";
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(route.params.param).toBe('goodbye')
+  expect(route.params.param).toBe("goodbye");
 
-  const { param } = toRefs(route.params)
+  const { param } = toRefs(route.params);
 
-  param.value = 'again'
+  param.value = "again";
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(route.params.param).toBe('again')
+  expect(route.params.param).toBe("again");
 
   // @ts-expect-error value is immutable
-  route.params.nothing = 'nothing'
+  route.params.nothing = "nothing";
 
-  await flushPromises()
+  await flushPromises();
 
   // @ts-expect-error value is immutable
-  expect(route.params.nothing).toBeUndefined()
-})
+  expect(route.params.nothing).toBeUndefined();
+});
 
-test('individual params are writable when using toRefs', async () => {
+test("individual params are writable when using toRefs", async () => {
   const routes = [
     createRoute({
-      name: 'root',
+      name: "root",
       component,
-      path: '/[param]',
+      path: "/[param]",
     }),
-  ]
+  ];
 
   const { route, start } = createRouter(routes, {
-    initialUrl: '/one',
-  })
+    initialUrl: "/one",
+  });
 
-  await start()
+  await start();
 
-  const { param } = toRefs(route.params)
+  const { param } = toRefs(route.params);
 
-  param.value = 'two'
+  param.value = "two";
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(route.params.param).toBe('two')
-})
+  expect(route.params.param).toBe("two");
+});
 
-test('setting an unknown param does not add its value to the route', async () => {
+test("setting an unknown param does not add its value to the route", async () => {
   const routes = [
     createRoute({
-      name: 'root',
+      name: "root",
       component,
-      path: '/',
+      path: "/",
     }),
-  ]
+  ];
   const { route, start } = createRouter(routes, {
-    initialUrl: '/',
-  })
+    initialUrl: "/",
+  });
 
-  await start()
+  await start();
 
   // @ts-expect-error value is immutable
-  route.params.nothing = 'nothing'
+  route.params.nothing = "nothing";
 
-  await flushPromises()
+  await flushPromises();
 
   // @ts-expect-error value is immutable
-  expect(route.params.nothing).toBeUndefined()
-})
+  expect(route.params.nothing).toBeUndefined();
+});
 
-test('params are writable', async () => {
+test("params are writable", async () => {
   const routes = [
     createRoute({
-      name: 'root',
+      name: "root",
       component,
-      path: '/[paramA]/[paramB]/[?paramC]',
+      path: "/[paramA]/[paramB]/[?paramC]",
     }),
-  ]
+  ];
 
   const { route, start } = createRouter(routes, {
-    initialUrl: '/one/two/three',
-  })
+    initialUrl: "/one/two/three",
+  });
 
-  await start()
+  await start();
 
   expect(route.params).toMatchObject({
-    paramA: 'one',
-    paramB: 'two',
-    paramC: 'three',
-  })
+    paramA: "one",
+    paramB: "two",
+    paramC: "three",
+  });
 
   route.params = {
-    paramA: 'four',
-    paramB: 'five',
-  }
+    paramA: "four",
+    paramB: "five",
+  };
 
-  await flushPromises()
+  await flushPromises();
 
   expect(route.params).toMatchObject({
-    paramA: 'four',
-    paramB: 'five',
-  })
+    paramA: "four",
+    paramB: "five",
+  });
 
-  const { params } = toRefs(route)
+  const { params } = toRefs(route);
 
   params.value = {
-    paramA: 'six',
-    paramB: 'seven',
-  }
+    paramA: "six",
+    paramB: "seven",
+  };
 
-  await flushPromises()
+  await flushPromises();
 
   expect(route.params).toMatchObject({
-    paramA: 'six',
-    paramB: 'seven',
-  })
-})
+    paramA: "six",
+    paramB: "seven",
+  });
+});
 
-test('params can be destructured', async () => {
+test("params can be destructured", async () => {
   const root = createRoute({
-    name: 'root',
+    name: "root",
     component,
-    path: '/[paramA]/[paramB]',
-  })
+    path: "/[paramA]/[paramB]",
+  });
 
   const { route, start, push } = createRouter([root], {
-    initialUrl: '/one/two',
-  })
+    initialUrl: "/one/two",
+  });
 
-  await start()
+  await start();
 
-  const { paramA, paramB } = toRefs(route.params)
+  const { paramA, paramB } = toRefs(route.params);
 
-  expect(paramA.value).toBe('one')
-  expect(paramB.value).toBe('two')
+  expect(paramA.value).toBe("one");
+  expect(paramB.value).toBe("two");
 
-  await push('root', { paramA: 'three', paramB: 'four' })
+  await push("root", { paramA: "three", paramB: "four" });
 
-  expect(paramA.value).toBe('three')
-  expect(paramB.value).toBe('four')
+  expect(paramA.value).toBe("three");
+  expect(paramB.value).toBe("four");
 
-  paramA.value = 'five'
+  paramA.value = "five";
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(route.params.paramA).toBe('five')
-})
+  expect(route.params.paramA).toBe("five");
+});
 
-test('query is writable', async () => {
+test("query is writable", async () => {
   const root = createRoute({
-    name: 'root',
+    name: "root",
     component,
-    path: '/',
-  })
+    path: "/",
+  });
 
   const { route, start } = createRouter([root], {
-    initialUrl: '/?foo=bar&fiz=buz',
-  })
+    initialUrl: "/?foo=bar&fiz=buz",
+  });
 
-  await start()
+  await start();
 
-  route.query = 'foo=bar&foo=baz'
+  route.query = "foo=bar&foo=baz";
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(route.query.toString()).toBe('foo=bar&foo=baz')
+  expect(route.query.toString()).toBe("foo=bar&foo=baz");
 
-  const { query } = toRefs(route)
+  const { query } = toRefs(route);
 
   // @ts-expect-error vue's `reactive` utility loses the type information for computed setters but we do expect this to work
-  query.value = 'foo2=bar2&foo2=baz2'
+  query.value = "foo2=bar2&foo2=baz2";
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(route.query.toString()).toBe('foo2=bar2&foo2=baz2')
-})
+  expect(route.query.toString()).toBe("foo2=bar2&foo2=baz2");
+});
 
-test('query.set updates the route', async () => {
+test("query.set updates the route", async () => {
   const root = createRoute({
-    name: 'root',
+    name: "root",
     component,
-    path: '/',
-  })
+    path: "/",
+  });
 
   const { route, start } = createRouter([root], {
-    initialUrl: '/',
-  })
+    initialUrl: "/",
+  });
 
-  await start()
+  await start();
 
-  route.query.set('foo', 'bar')
+  route.query.set("foo", "bar");
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(route.query.toString()).toBe('foo=bar')
+  expect(route.query.toString()).toBe("foo=bar");
 
-  route.query.set('fuz', 'buz')
+  route.query.set("fuz", "buz");
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(route.query.toString()).toBe('foo=bar&fuz=buz')
-})
+  expect(route.query.toString()).toBe("foo=bar&fuz=buz");
+});
 
-test('query.set does not duplicate existing params when updating one param', async () => {
+test("query.set does not duplicate existing params when updating one param", async () => {
   const root = createRoute({
-    name: 'root',
+    name: "root",
     component,
-    path: '/',
-    query: 'param=[param]',
-  })
+    path: "/",
+    query: "param=[param]",
+  });
 
   const { route, start } = createRouter([root], {
-    initialUrl: '/?param=value&foo=1',
-  })
+    initialUrl: "/?param=value&foo=1",
+  });
 
-  await start()
+  await start();
 
-  expect(route.query.toString()).toBe('param=value&foo=1')
+  expect(route.query.toString()).toBe("param=value&foo=1");
 
-  route.query.set('foo', '2')
+  route.query.set("foo", "2");
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(route.query.toString()).toBe('param=value&foo=2')
-})
+  expect(route.query.toString()).toBe("param=value&foo=2");
+});
 
-test('query.set can change the value of a param that is already set', async () => {
+test("query.set can change the value of a param that is already set", async () => {
   const root = createRoute({
-    name: 'root',
+    name: "root",
     component,
-    query: 'param=[param]',
-    path: '/',
-  })
+    query: "param=[param]",
+    path: "/",
+  });
 
   const { route, start } = createRouter([root], {
-    initialUrl: '/?param=foo&notAParam=1',
-  })
+    initialUrl: "/?param=foo&notAParam=1",
+  });
 
-  await start()
+  await start();
 
-  route.query.set('param', 'bar')
+  route.query.set("param", "bar");
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(route.query.toString()).toBe('param=bar&notAParam=1')
-})
+  expect(route.query.toString()).toBe("param=bar&notAParam=1");
+});
 
-test('query.append updates the route', async () => {
+test("query.append updates the route", async () => {
   const root = createRoute({
-    name: 'root',
+    name: "root",
     component,
-    path: '/',
-  })
+    path: "/",
+  });
 
   const { route, start } = createRouter([root], {
-    initialUrl: '/',
-  })
+    initialUrl: "/",
+  });
 
-  await start()
+  await start();
 
-  route.query.append('foo', 'bar')
+  route.query.append("foo", "bar");
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(route.query.toString()).toBe('foo=bar')
+  expect(route.query.toString()).toBe("foo=bar");
 
-  route.query.append('fuz', 'buz')
+  route.query.append("fuz", "buz");
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(route.query.toString()).toBe('foo=bar&fuz=buz')
-})
+  expect(route.query.toString()).toBe("foo=bar&fuz=buz");
+});
 
-test('query.delete updates the route', async () => {
+test("query.delete updates the route", async () => {
   const root = createRoute({
-    name: 'root',
+    name: "root",
     component,
-    path: '/',
-  })
+    path: "/",
+  });
 
   const { route, start } = createRouter([root], {
-    initialUrl: '/?foo=bar&fiz=buz',
-  })
+    initialUrl: "/?foo=bar&fiz=buz",
+  });
 
-  await start()
+  await start();
 
-  route.query.delete('foo')
+  route.query.delete("foo");
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(route.query.toString()).toBe('fiz=buz')
-})
+  expect(route.query.toString()).toBe("fiz=buz");
+});
 
-test('query.values is reactive', async () => {
+test("query.values is reactive", async () => {
   const root = createRoute({
-    name: 'root',
+    name: "root",
     component,
-    path: '/',
-  })
+    path: "/",
+  });
 
   const { route, start } = createRouter([root], {
-    initialUrl: '/?foo=foo1&bar=bar1',
-  })
+    initialUrl: "/?foo=foo1&bar=bar1",
+  });
 
-  await start()
+  await start();
 
-  const values = computed(() => Array.from(route.query.values()))
+  const values = computed(() => Array.from(route.query.values()));
 
-  expect(values.value).toMatchObject(['foo1', 'bar1'])
+  expect(values.value).toMatchObject(["foo1", "bar1"]);
 
-  route.query.append('foo', 'foo2')
+  route.query.append("foo", "foo2");
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(values.value).toMatchObject(['foo1', 'bar1', 'foo2'])
-})
+  expect(values.value).toMatchObject(["foo1", "bar1", "foo2"]);
+});
 
-test('given an array of Routes with duplicate names, throws DuplicateNamesError', () => {
+test("given an array of Routes with duplicate names, throws DuplicateNamesError", () => {
   const aRoutes = [
-    createRoute({ name: 'foo', component }),
-    createRoute({ name: 'bar', component }),
-  ]
+    createRoute({ name: "foo", component }),
+    createRoute({ name: "bar", component }),
+  ];
   const bRoutes = [
-    createRoute({ name: 'zoo', component }),
-    createRoute({ name: 'bar', component }),
-  ]
-
-  const action: () => void = () => createRouter([aRoutes, bRoutes], {
-    initialUrl: '/',
-  })
-
-  expect(action).toThrow(DuplicateNamesError)
-})
-
-test('given an array of Routes with missing context, can still match missing routes', async () => {
-  const missingRoute = createRoute({ name: 'missing', path: '/missing', component })
-
-  const router = createRouter([
-    createRoute({ name: 'foo', path: '/foo', component, context: [missingRoute] }),
-    createRoute({ name: 'bar', path: '/bar', component }),
-  ], {
-    initialUrl: '/missing',
-  })
+    createRoute({ name: "zoo", component }),
+    createRoute({ name: "bar", component }),
+  ];
+
+  const action: () => void = () =>
+    createRouter([aRoutes, bRoutes], {
+      initialUrl: "/",
+    });
+
+  expect(action).toThrow(DuplicateNamesError);
+});
+
+test("given an array of Routes with missing context, can still match missing routes", async () => {
+  const missingRoute = createRoute({ name: "missing", path: "/missing", component });
+
+  const router = createRouter(
+    [
+      createRoute({ name: "foo", path: "/foo", component, context: [missingRoute] }),
+      createRoute({ name: "bar", path: "/bar", component }),
+    ],
+    {
+      initialUrl: "/missing",
+    },
+  );
 
-  await router.start()
+  await router.start();
 
-  expect(router.route.name).toBe('missing')
-})
+  expect(router.route.name).toBe("missing");
+});
 
-test('given an array of Routes with missing context with duplicate route names, throws DuplicateNamesError', async () => {
-  const missingRoute = createRoute({ name: 'foo', component })
+test("given an array of Routes with missing context with duplicate route names, throws DuplicateNamesError", async () => {
+  const missingRoute = createRoute({ name: "foo", component });
 
-  const action: () => void = () => createRouter([
-    createRoute({ name: 'foo', component, context: [missingRoute] }),
-  ], {
-    initialUrl: '/missing',
-  })
+  const action: () => void = () =>
+    createRouter([createRoute({ name: "foo", component, context: [missingRoute] })], {
+      initialUrl: "/missing",
+    });
 
-  expect(action).toThrow(DuplicateNamesError)
-})
+  expect(action).toThrow(DuplicateNamesError);
+});
 
-test('initial route is not set until the router is started', async () => {
+test("initial route is not set until the router is started", async () => {
   const route = createRoute({
-    name: 'root',
-    path: '/',
+    name: "root",
+    path: "/",
     component,
-  })
+  });
 
   const router = createRouter([route], {
-    initialUrl: '/',
-  })
+    initialUrl: "/",
+  });
 
-  expect(router.route.name).toBe('NotFound')
+  expect(router.route.name).toBe("NotFound");
 
-  await router.start()
+  await router.start();
 
-  expect(router.route.name).toBe('root')
-})
+  expect(router.route.name).toBe("root");
+});
 
-describe('router.resolve', () => {
-  test('when given a name that matches a route return that route', () => {
-    const router = createRouter(routes, { initialUrl: '/' })
+describe("router.resolve", () => {
+  test("when given a name that matches a route return that route", () => {
+    const router = createRouter(routes, { initialUrl: "/" });
 
-    const route = router.resolve('parentB')
+    const route = router.resolve("parentB");
 
-    expect(route).toBeDefined()
-    expect(route.name).toBe('parentB')
-  })
+    expect(route).toBeDefined();
+    expect(route.name).toBe("parentB");
+  });
 
-  test('when given a name that does not match a route throws RouteNotFoundError', () => {
-    const router = createRouter(routes, { initialUrl: '/' })
+  test("when given a name that does not match a route throws RouteNotFoundError", () => {
+    const router = createRouter(routes, { initialUrl: "/" });
 
-    const action: () => void = () => router.resolve('parentD' as any)
+    const action: () => void = () => router.resolve("parentD" as any);
 
-    expect(action).toThrow(RouteNotFoundError)
-  })
+    expect(action).toThrow(RouteNotFoundError);
+  });
 
-  test('given a route name with params, interpolates param values', () => {
-    const router = createRouter(routes, { initialUrl: '/' })
-    const route = router.resolve('parentA', { paramA: 'bar' })
+  test("given a route name with params, interpolates param values", () => {
+    const router = createRouter(routes, { initialUrl: "/" });
+    const route = router.resolve("parentA", { paramA: "bar" });
 
     expect(route).toMatchObject({
-      name: 'parentA',
+      name: "parentA",
       params: {
-        paramA: 'bar',
+        paramA: "bar",
       },
-      href: '/parentA/bar',
-    })
-  })
+      href: "/parentA/bar",
+    });
+  });
 
-  test('given a route name with query, interpolates param values', () => {
-    const router = createRouter(routes, { initialUrl: '/' })
-    const route = router.resolve('parentA', { paramA: 'bar' }, { query: { foo: 'foo' } })
+  test("given a route name with query, interpolates param values", () => {
+    const router = createRouter(routes, { initialUrl: "/" });
+    const route = router.resolve("parentA", { paramA: "bar" }, { query: { foo: "foo" } });
 
     expect(route).toMatchObject({
-      name: 'parentA',
+      name: "parentA",
       params: {
-        paramA: 'bar',
+        paramA: "bar",
       },
-      href: '/parentA/bar?foo=foo',
-    })
-  })
+      href: "/parentA/bar?foo=foo",
+    });
+  });
 
-  test('given a route name with params cannot be matched, throws InvalidRouteParamValueError', () => {
-    const router = createRouter(routes, { initialUrl: '/' })
+  test("given a route name with params cannot be matched, throws InvalidRouteParamValueError", () => {
+    const router = createRouter(routes, { initialUrl: "/" });
 
-    const action: () => void = () => router.resolve('parentA', { missing: 'foo' } as any)
+    const action: () => void = () => router.resolve("parentA", { missing: "foo" } as any);
 
-    expect(action).toThrow(InvalidRouteParamValueError)
-  })
+    expect(action).toThrow(InvalidRouteParamValueError);
+  });
 
-  test('given a param with a dash or underscore resolves the correct url', () => {
+  test("given a param with a dash or underscore resolves the correct url", () => {
     const routes = [
       createRoute({
-        name: 'kebab',
-        path: '/[test-param]',
+        name: "kebab",
+        path: "/[test-param]",
         component,
       }),
       createRoute({
-        name: 'snake',
-        path: '/[test_param]',
+        name: "snake",
+        path: "/[test_param]",
         component,
       }),
-    ]
+    ];
 
-    const router = createRouter(routes, { initialUrl: '/' })
+    const router = createRouter(routes, { initialUrl: "/" });
 
-    const kebab = router.resolve('kebab', { 'test-param': 'foo' })
+    const kebab = router.resolve("kebab", { "test-param": "foo" });
 
     expect(kebab).toMatchObject({
-      name: 'kebab',
+      name: "kebab",
       params: {
-        'test-param': 'foo',
+        "test-param": "foo",
       },
-      href: '/foo',
-    })
+      href: "/foo",
+    });
 
-    const snake = router.resolve('snake', { test_param: 'foo' })
+    const snake = router.resolve("snake", { test_param: "foo" });
 
     expect(snake).toMatchObject({
-      name: 'snake',
+      name: "snake",
       params: {
-        test_param: 'foo',
+        test_param: "foo",
       },
-      href: '/foo',
-    })
-  })
+      href: "/foo",
+    });
+  });
 
-  test('when given an external route returns a fully qualified url', () => {
-    const routes = [createExternalRoute({
-      host: 'https://kitbag.dev',
-      name: 'external',
-      path: '/',
-    })]
+  test("when given an external route returns a fully qualified url", () => {
+    const routes = [
+      createExternalRoute({
+        host: "https://kitbag.dev",
+        name: "external",
+        path: "/",
+      }),
+    ];
 
-    const router = createRouter(routes, { initialUrl: '/' })
+    const router = createRouter(routes, { initialUrl: "/" });
 
-    const route = router.resolve('external')
+    const route = router.resolve("external");
 
     expect(route).toMatchObject({
-      name: 'external',
-      href: 'https://kitbag.dev/',
-    })
-  })
+      name: "external",
+      href: "https://kitbag.dev/",
+    });
+  });
 
-  test('when given an external route with params in host, interpolates param values', () => {
-    const routes = [createExternalRoute({
-      host: 'https://[subdomain].kitbag.dev',
-      name: 'external',
-      path: '/',
-    })]
+  test("when given an external route with params in host, interpolates param values", () => {
+    const routes = [
+      createExternalRoute({
+        host: "https://[subdomain].kitbag.dev",
+        name: "external",
+        path: "/",
+      }),
+    ];
 
-    const router = createRouter(routes, { initialUrl: '/' })
+    const router = createRouter(routes, { initialUrl: "/" });
 
-    const route = router.resolve('external', { subdomain: 'router' })
+    const route = router.resolve("external", { subdomain: "router" });
 
     expect(route).toMatchObject({
-      name: 'external',
-      href: 'https://router.kitbag.dev/',
-    })
-  })
+      name: "external",
+      href: "https://router.kitbag.dev/",
+    });
+  });
 
-  test('given a route with hash, interpolates hash value', () => {
-    const router = createRouter(routes, { initialUrl: '/' })
+  test("given a route with hash, interpolates hash value", () => {
+    const router = createRouter(routes, { initialUrl: "/" });
 
-    const route = router.resolve('parentA', { paramA: 'bar' }, { hash: 'foo' })
+    const route = router.resolve("parentA", { paramA: "bar" }, { hash: "foo" });
 
     expect(route).toMatchObject({
-      name: 'parentA',
+      name: "parentA",
       params: {
-        paramA: 'bar',
+        paramA: "bar",
       },
-      hash: '#foo',
-      href: '/parentA/bar#foo',
-    })
-  })
-})
+      hash: "#foo",
+      href: "/parentA/bar#foo",
+    });
+  });
+});
 
-describe('router.push', () => {
-  test('given a resolved route, pushes the route', async () => {
-    const router = createRouter(routes, { initialUrl: '/' })
-    const route = router.resolve('parentA', { paramA: 'bar' })
+describe("router.push", () => {
+  test("given a resolved route, pushes the route", async () => {
+    const router = createRouter(routes, { initialUrl: "/" });
+    const route = router.resolve("parentA", { paramA: "bar" });
 
-    await router.push(route)
+    await router.push(route);
 
-    expect(router.route.href).toBe('/parentA/bar')
-  })
+    expect(router.route.href).toBe("/parentA/bar");
+  });
 
-  test('given a route name, pushes the route', async () => {
-    const router = createRouter(routes, { initialUrl: '/' })
+  test("given a route name, pushes the route", async () => {
+    const router = createRouter(routes, { initialUrl: "/" });
 
-    await router.push('parentA', { paramA: 'bar' })
+    await router.push("parentA", { paramA: "bar" });
 
-    expect(router.route.href).toBe('/parentA/bar')
-  })
+    expect(router.route.href).toBe("/parentA/bar");
+  });
 
-  test('given an internal Url, pushes the route', async () => {
-    const router = createRouter(routes, { initialUrl: '/' })
+  test("given an internal Url, pushes the route", async () => {
+    const router = createRouter(routes, { initialUrl: "/" });
 
-    await router.push('/parentA/bar')
+    await router.push("/parentA/bar");
 
     expect(router.route).toMatchObject({
-      name: 'parentA',
+      name: "parentA",
       params: {
-        paramA: 'bar',
+        paramA: "bar",
       },
-    })
-  })
+    });
+  });
 
-  test('given a resolved route with state inside, pushes state', async () => {
+  test("given a resolved route with state inside, pushes state", async () => {
     const routeWithState = createRoute({
-      name: 'route-with-state',
+      name: "route-with-state",
       component,
-      path: '/route-with-state',
+      path: "/route-with-state",
       state: { zoo: Number },
-    })
-    const router = createRouter([routeWithState], { initialUrl: '/' })
-    const route = router.resolve('route-with-state', { paramA: 'bar' }, { state: { zoo: 123 } })
+    });
+    const router = createRouter([routeWithState], { initialUrl: "/" });
+    const route = router.resolve("route-with-state", { paramA: "bar" }, { state: { zoo: 123 } });
 
-    await router.push(route)
+    await router.push(route);
 
-    expect(router.route.state).toMatchObject({ zoo: 123 })
-  })
+    expect(router.route.state).toMatchObject({ zoo: 123 });
+  });
 
-  test('given a resolved route with state in options, pushes state', async () => {
+  test("given a resolved route with state in options, pushes state", async () => {
     const routeWithState = createRoute({
-      name: 'route-with-state',
+      name: "route-with-state",
       component,
-      path: '/route-with-state',
+      path: "/route-with-state",
       state: { zoo: Number },
-    })
-    const router = createRouter([routeWithState], { initialUrl: '/' })
-    const route = router.resolve('route-with-state', { paramA: 'bar' })
+    });
+    const router = createRouter([routeWithState], { initialUrl: "/" });
+    const route = router.resolve("route-with-state", { paramA: "bar" });
 
-    await router.push(route, { state: { zoo: 123 } })
+    await router.push(route, { state: { zoo: 123 } });
 
-    expect(router.route.state).toMatchObject({ zoo: 123 })
-  })
+    expect(router.route.state).toMatchObject({ zoo: 123 });
+  });
 
-  test('given a route name with state in options, pushes state', async () => {
+  test("given a route name with state in options, pushes state", async () => {
     const routeWithState = createRoute({
-      name: 'route-with-state',
+      name: "route-with-state",
       component,
-      path: '/route-with-state',
+      path: "/route-with-state",
       state: { zoo: Number },
-    })
-    const router = createRouter([routeWithState], { initialUrl: '/' })
+    });
+    const router = createRouter([routeWithState], { initialUrl: "/" });
 
-    await router.push('route-with-state', { paramA: 'bar' }, { state: { zoo: 123 } })
+    await router.push("route-with-state", { paramA: "bar" }, { state: { zoo: 123 } });
 
-    expect(router.route.state).toMatchObject({ zoo: 123 })
-  })
+    expect(router.route.state).toMatchObject({ zoo: 123 });
+  });
 
-  test('given an internal Url with state in options, pushes state', async () => {
+  test("given an internal Url with state in options, pushes state", async () => {
     const routeWithState = createRoute({
-      name: 'route-with-state',
+      name: "route-with-state",
       component,
-      path: '/route-with-state',
+      path: "/route-with-state",
       state: { zoo: Number },
-    })
-    const router = createRouter([routeWithState], { initialUrl: '/' })
-
-    await router.push('/route-with-state', { state: { zoo: 123 } })
-
-    expect(router.route.state).toMatchObject({ zoo: 123 })
-  })
-})
-
-describe('router.onError', () => {
-  test.each([
-    { hook: 'onBeforeRouteEnter' },
-    { hook: 'onAfterRouteEnter' },
-  ] as const)('given an error thrown in $hook, calls the onError callback with the correct context', async ({ hook }) => {
-    const error = new Error('Test error')
-    const onError = vi.fn()
-
-    const route = createRoute({
-      name: 'route-with-error',
-      component,
-      path: '/',
-    })
-
-    const router = createRouter([route], { initialUrl: '/' })
-
-    router[hook](() => {
-      throw error
-    })
+    });
+    const router = createRouter([routeWithState], { initialUrl: "/" });
 
-    router.onError(onError)
+    await router.push("/route-with-state", { state: { zoo: 123 } });
 
-    await router.push('route-with-error')
+    expect(router.route.state).toMatchObject({ zoo: 123 });
+  });
+});
 
-    expect(onError).toHaveBeenCalledWith(error, expect.objectContaining({
-      source: 'hook',
-    }))
-  })
+describe("router.onError", () => {
+  test.each([{ hook: "onBeforeRouteEnter" }, { hook: "onAfterRouteEnter" }] as const)(
+    "given an error thrown in $hook, calls the onError callback with the correct context",
+    async ({ hook }) => {
+      const error = new Error("Test error");
+      const onError = vi.fn();
 
-  test.each([
-    { hook: 'onBeforeRouteUpdate' },
-    { hook: 'onAfterRouteUpdate' },
-  ] as const)('given an error thrown in $hook, calls the onError callback with the correct context', async ({ hook }) => {
-    const error = new Error('Test error')
-    const onError = vi.fn()
-
-    const route = createRoute({
-      name: 'route-with-error',
-      component,
-      path: '/[param]',
-    })
-
-    const router = createRouter([route], { initialUrl: '/' })
-    await router.start()
-
-    router[hook](() => {
-      throw error
-    })
-
-    router.onError(onError)
-
-    // Navigate to the route first
-    await router.push('route-with-error', { param: 'bar' })
-    // Then navigate to the same route again to trigger update
-    await router.push('route-with-error', { param: 'foo' })
+      const route = createRoute({
+        name: "route-with-error",
+        component,
+        path: "/",
+      });
 
-    expect(onError).toHaveBeenCalledWith(error, expect.objectContaining({
-      source: 'hook',
-    }))
-  })
+      const router = createRouter([route], { initialUrl: "/" });
 
-  test.each([
-    { hook: 'onBeforeRouteLeave' },
-    { hook: 'onAfterRouteLeave' },
-  ] as const)('given an error thrown in $hook, calls the onError callback with the correct context', async ({ hook }) => {
-    const error = new Error('Test error')
-    const onError = vi.fn()
+      router[hook](() => {
+        throw error;
+      });
 
-    const route1 = createRoute({
-      name: 'route-1',
-      component,
-      path: '/route-1',
-    })
-
-    const route2 = createRoute({
-      name: 'route-2',
-      component,
-      path: '/route-2',
-    })
+      router.onError(onError);
 
-    const router = createRouter([route1, route2], { initialUrl: '/' })
-    await router.start()
+      await router.push("route-with-error");
 
-    router[hook](() => {
-      throw error
-    })
+      expect(onError).toHaveBeenCalledWith(
+        error,
+        expect.objectContaining({
+          source: "hook",
+        }),
+      );
+    },
+  );
 
-    router.onError(onError)
+  test.each([{ hook: "onBeforeRouteUpdate" }, { hook: "onAfterRouteUpdate" }] as const)(
+    "given an error thrown in $hook, calls the onError callback with the correct context",
+    async ({ hook }) => {
+      const error = new Error("Test error");
+      const onError = vi.fn();
 
-    // Navigate to route-1 first
-    await router.push('route-1')
-    // Then navigate to route-2 to trigger leave
-    await router.push('route-2')
-
-    expect(onError).toHaveBeenCalledWith(error, expect.objectContaining({
-      source: 'hook',
-    }))
-  })
+      const route = createRoute({
+        name: "route-with-error",
+        component,
+        path: "/[param]",
+      });
+
+      const router = createRouter([route], { initialUrl: "/" });
+      await router.start();
+
+      router[hook](() => {
+        throw error;
+      });
+
+      router.onError(onError);
+
+      // Navigate to the route first
+      await router.push("route-with-error", { param: "bar" });
+      // Then navigate to the same route again to trigger update
+      await router.push("route-with-error", { param: "foo" });
+
+      expect(onError).toHaveBeenCalledWith(
+        error,
+        expect.objectContaining({
+          source: "hook",
+        }),
+      );
+    },
+  );
+
+  test.each([{ hook: "onBeforeRouteLeave" }, { hook: "onAfterRouteLeave" }] as const)(
+    "given an error thrown in $hook, calls the onError callback with the correct context",
+    async ({ hook }) => {
+      const error = new Error("Test error");
+      const onError = vi.fn();
+
+      const route1 = createRoute({
+        name: "route-1",
+        component,
+        path: "/route-1",
+      });
 
-  test('given an error thrown in a props callback, calls the onError callback with the correct context', async () => {
-    const error = new Error('Test error')
-    const onError = vi.fn()
+      const route2 = createRoute({
+        name: "route-2",
+        component,
+        path: "/route-2",
+      });
+
+      const router = createRouter([route1, route2], { initialUrl: "/" });
+      await router.start();
+
+      router[hook](() => {
+        throw error;
+      });
+
+      router.onError(onError);
+
+      // Navigate to route-1 first
+      await router.push("route-1");
+      // Then navigate to route-2 to trigger leave
+      await router.push("route-2");
+
+      expect(onError).toHaveBeenCalledWith(
+        error,
+        expect.objectContaining({
+          source: "hook",
+        }),
+      );
+    },
+  );
+
+  test("given an error thrown in a props callback, calls the onError callback with the correct context", async () => {
+    const error = new Error("Test error");
+    const onError = vi.fn();
+
+    const routeWithError = createRoute(
+      {
+        name: "route-with-error",
+        component,
+        path: "/route-with-error",
+      },
+      () => {
+        throw error;
+      },
+    );
 
-    const routeWithError = createRoute({
-      name: 'route-with-error',
-      component,
-      path: '/route-with-error',
-    }, () => {
-      throw error
-    })
+    const router = createRouter([routeWithError], { initialUrl: "/" });
+    await router.start();
 
-    const router = createRouter([routeWithError], { initialUrl: '/' })
-    await router.start()
+    router.onError(onError);
 
-    router.onError(onError)
+    await router.push("route-with-error");
+    await flushPromises();
 
-    await router.push('route-with-error')
-    await flushPromises()
+    expect(onError).toHaveBeenCalledWith(
+      error,
+      expect.objectContaining({
+        source: "props",
+      }),
+    );
+  });
+});
 
-    expect(onError).toHaveBeenCalledWith(error, expect.objectContaining({
-      source: 'props',
-    }))
-  })
-})
-  
-describe('router.onRejection', () => {
-  test('given router itself triggers a rejection, calls the onRejection callback with the correct context', async () => {
-    const onRejection = vi.fn()
+describe("router.onRejection", () => {
+  test("given router itself triggers a rejection, calls the onRejection callback with the correct context", async () => {
+    const onRejection = vi.fn();
 
     const rejection = createRejection({
-      type: 'CustomRejection',
-      component: { template: '<div>This is a custom rejection</div>' },
-    })
+      type: "CustomRejection",
+      component: { template: "<div>This is a custom rejection</div>" },
+    });
 
     const route = createRoute({
-      name: 'route',
+      name: "route",
       component,
-      path: '/',
-    })
+      path: "/",
+    });
+
+    const router = createRouter([route], { initialUrl: "/", rejections: [rejection] });
 
-    const router = createRouter([route], { initialUrl: '/', rejections: [rejection] })
+    router.onRejection(onRejection);
 
-    router.onRejection(onRejection)
-     
-    await router.start()
+    await router.start();
 
-    router.reject('CustomRejection')
+    router.reject("CustomRejection");
 
-    expect(onRejection).toHaveBeenCalledWith('CustomRejection', {
+    expect(onRejection).toHaveBeenCalledWith("CustomRejection", {
       to: null,
       from: null,
-    })
-  })
+    });
+  });
 
-  test('given route hooks that trigger a rejection, calls the onRejection callback with the correct context', async () => {
-    const onRejection = vi.fn()
+  test("given route hooks that trigger a rejection, calls the onRejection callback with the correct context", async () => {
+    const onRejection = vi.fn();
 
     const route = createRoute({
-      name: 'route-with-rejection',
+      name: "route-with-rejection",
       component,
-      path: '/',
-    })
+      path: "/",
+    });
 
     route.onBeforeRouteEnter((_to, { reject }) => {
-      reject('NotFound')
-    })
+      reject("NotFound");
+    });
 
-    const router = createRouter([route], { initialUrl: '/' })
+    const router = createRouter([route], { initialUrl: "/" });
 
-    router.onRejection(onRejection)
+    router.onRejection(onRejection);
 
-    await router.start()
+    await router.start();
 
-    expect(onRejection).toHaveBeenCalledWith('NotFound', {
+    expect(onRejection).toHaveBeenCalledWith("NotFound", {
       to: expect.objectContaining({
-        name: 'route-with-rejection',
+        name: "route-with-rejection",
       }),
       from: null,
-    })
-  })
-})
+    });
+  });
+});
 
-describe('options.removeTrailingSlashes', () => {
+describe("options.removeTrailingSlashes", () => {
   const foo = createRoute({
-    name: 'foo',
+    name: "foo",
     component,
-    path: '/foo',
-  })
+    path: "/foo",
+  });
 
   const fooWithTrailingSlash = createRoute({
-    name: 'fooWithTrailingSlash',
+    name: "fooWithTrailingSlash",
     component,
-    path: '/foo/',
-  })
+    path: "/foo/",
+  });
 
   const bar = createRoute({
-    name: 'bar',
+    name: "bar",
     component,
-    path: '/bar',
-  })
+    path: "/bar",
+  });
 
-  test('when true, removes trailing slashes from the path', async () => {
+  test("when true, removes trailing slashes from the path", async () => {
     const router = createRouter([foo, fooWithTrailingSlash, bar], {
-      initialUrl: '/foo/',
+      initialUrl: "/foo/",
       removeTrailingSlashes: true,
-    })
+    });
 
-    await router.start()
+    await router.start();
 
     // trims the trailing slash from the initial url
-    expect(router.route.href).toBe('/foo')
+    expect(router.route.href).toBe("/foo");
 
-    await router.push('/bar/')
+    await router.push("/bar/");
 
     // trims the trailing slash from the path
-    expect(router.route.href).toBe('/bar')
+    expect(router.route.href).toBe("/bar");
 
-    await router.push('fooWithTrailingSlash')
+    await router.push("fooWithTrailingSlash");
 
     // trims the trailing slash from the path
-    expect(router.route.href).toBe('/foo')
-  })
+    expect(router.route.href).toBe("/foo");
+  });
 
-  test('when false, does not remove trailing slashes from the path', async () => {
+  test("when false, does not remove trailing slashes from the path", async () => {
     const router = createRouter([foo, fooWithTrailingSlash, bar], {
-      initialUrl: '/foo/',
+      initialUrl: "/foo/",
       removeTrailingSlashes: false,
-    })
+    });
 
-    await router.start()
+    await router.start();
 
-    expect(router.route.href).toBe('/foo/')
+    expect(router.route.href).toBe("/foo/");
 
-    await router.push('fooWithTrailingSlash')
+    await router.push("fooWithTrailingSlash");
 
-    expect(router.route.href).toBe('/foo/')
+    expect(router.route.href).toBe("/foo/");
 
-    await router.push('/bar/')
+    await router.push("/bar/");
 
     // rejects so has an empty path
-    expect(router.route.href).toBe('/')
-  })
-})
+    expect(router.route.href).toBe("/");
+  });
+});
diff --git a/src/services/createRouter.ts b/src/services/createRouter.ts
index 03d672cb..d96e782b 100644
--- a/src/services/createRouter.ts
+++ b/src/services/createRouter.ts
@@ -1,50 +1,50 @@
-import { createPath } from '@/services/history'
-import { App, ref } from 'vue'
-import { createCurrentRoute } from '@/services/createCurrentRoute'
-import { createIsExternal } from '@/services/createIsExternal'
-import { parseUrl, updateUrl } from '@/services/urlParser'
-import { createPropStore } from '@/services/createPropStore'
-import { createRouterHistory } from '@/services/createRouterHistory'
-import { createRouterHooks, getRouterHooksKey } from '@/services/createRouterHooks'
-import { getInitialUrl } from '@/services/getInitialUrl'
-import { setStateValues } from '@/services/state'
-import { Routes } from '@/types/route'
-import { Router, RouterOptions } from '@/types/router'
-import { RouterPush, RouterPushOptions } from '@/types/routerPush'
-import { RouterReplace, RouterReplaceOptions } from '@/types/routerReplace'
-import { RoutesName } from '@/types/routesMap'
-import { UrlString, isUrlString } from '@/types/urlString'
-import { createUniqueIdSequence, isFirstUniqueSequenceId } from '@/services/createUniqueIdSequence'
-import { createVisibilityObserver } from './createVisibilityObserver'
-import { visibilityObserverKey } from '@/compositions/useVisibilityObserver'
-import { RouterResolve, RouterResolveOptions } from '@/types/routerResolve'
-import { RouteNotFoundError } from '@/errors/routeNotFoundError'
-import { createResolvedRoute } from '@/services/createResolvedRoute'
-import { ResolvedRoute } from '@/types/resolved'
-import { RouterReject } from '@/types/routerReject'
-import { EmptyRouterPlugin, RouterPlugin } from '@/types/routerPlugin'
-import { getRoutesForRouter } from './getRoutesForRouter'
-import { getGlobalHooksForRouter } from './getGlobalHooksForRouter'
-import { createComponentsStore } from './createComponentsStore'
-import { initZod, zodParamsDetected } from './zod'
-import { getComponentsStoreKey } from '@/compositions/useComponentsStore'
-import { getPropStoreInjectionKey } from '@/compositions/usePropStore'
-import { getRouterRejectionInjectionKey } from '@/compositions/useRejection'
-import { routerInjectionKey } from '@/keys'
-import { createRouterView } from '@/components/routerView'
-import { createRouterLink } from '@/components/routerLink'
-import { ContextPushError } from '@/errors/contextPushError'
-import { ContextRejectionError } from '@/errors/contextRejectionError'
-import { setupRouterDevtools } from '@/devtools/createRouterDevtools'
-import { getMatchForUrl } from './getMatchesForUrl'
-import { pathHasTrailingSlash, removeTrailingSlashesFromPath } from '@/utilities/trailingSlashes'
-import { setDocumentTitle } from '@/utilities/setDocumentTitle'
-import { createCurrentRejection } from '@/services/createCurrentRejection'
+import { createPath } from "@/services/history";
+import { App, ref } from "vue";
+import { createCurrentRoute } from "@/services/createCurrentRoute";
+import { createIsExternal } from "@/services/createIsExternal";
+import { parseUrl, updateUrl } from "@/services/urlParser";
+import { createPropStore } from "@/services/createPropStore";
+import { createRouterHistory } from "@/services/createRouterHistory";
+import { createRouterHooks, getRouterHooksKey } from "@/services/createRouterHooks";
+import { getInitialUrl } from "@/services/getInitialUrl";
+import { setStateValues } from "@/services/state";
+import { Routes } from "@/types/route";
+import { Router, RouterOptions } from "@/types/router";
+import { RouterPush, RouterPushOptions } from "@/types/routerPush";
+import { RouterReplace, RouterReplaceOptions } from "@/types/routerReplace";
+import { RoutesName } from "@/types/routesMap";
+import { UrlString, isUrlString } from "@/types/urlString";
+import { createUniqueIdSequence, isFirstUniqueSequenceId } from "@/services/createUniqueIdSequence";
+import { createVisibilityObserver } from "./createVisibilityObserver";
+import { visibilityObserverKey } from "@/compositions/useVisibilityObserver";
+import { RouterResolve, RouterResolveOptions } from "@/types/routerResolve";
+import { RouteNotFoundError } from "@/errors/routeNotFoundError";
+import { createResolvedRoute } from "@/services/createResolvedRoute";
+import { ResolvedRoute } from "@/types/resolved";
+import { RouterReject } from "@/types/routerReject";
+import { EmptyRouterPlugin, RouterPlugin } from "@/types/routerPlugin";
+import { getRoutesForRouter } from "./getRoutesForRouter";
+import { getGlobalHooksForRouter } from "./getGlobalHooksForRouter";
+import { createComponentsStore } from "./createComponentsStore";
+import { initZod, zodParamsDetected } from "./zod";
+import { getComponentsStoreKey } from "@/compositions/useComponentsStore";
+import { getPropStoreInjectionKey } from "@/compositions/usePropStore";
+import { getRouterRejectionInjectionKey } from "@/compositions/useRejection";
+import { routerInjectionKey } from "@/keys";
+import { createRouterView } from "@/components/routerView";
+import { createRouterLink } from "@/components/routerLink";
+import { ContextPushError } from "@/errors/contextPushError";
+import { ContextRejectionError } from "@/errors/contextRejectionError";
+import { setupRouterDevtools } from "@/devtools/createRouterDevtools";
+import { getMatchForUrl } from "./getMatchesForUrl";
+import { pathHasTrailingSlash, removeTrailingSlashesFromPath } from "@/utilities/trailingSlashes";
+import { setDocumentTitle } from "@/utilities/setDocumentTitle";
+import { createCurrentRejection } from "@/services/createCurrentRejection";
 
 type RouterUpdateOptions = {
-  replace?: boolean,
-  state?: any,
-}
+  replace?: boolean;
+  state?: any;
+};
 
 /**
  * Creates a router instance for a Vue application, equipped with methods for route handling, lifecycle hooks, and state management.
@@ -72,327 +72,359 @@ type RouterUpdateOptions = {
 export function createRouter<
   const TRoutes extends Routes,
   const TOptions extends RouterOptions = {},
-  const TPlugin extends RouterPlugin = EmptyRouterPlugin
->(routes: TRoutes, options?: TOptions, plugins?: TPlugin[]): Router<TRoutes, TOptions, TPlugin>
+  const TPlugin extends RouterPlugin = EmptyRouterPlugin,
+>(routes: TRoutes, options?: TOptions, plugins?: TPlugin[]): Router<TRoutes, TOptions, TPlugin>;
 
 export function createRouter<
   const TRoutes extends Routes,
   const TOptions extends RouterOptions = {},
-  const TPlugin extends RouterPlugin = EmptyRouterPlugin
->(routes: TRoutes[], options?: TOptions, plugins?: TPlugin[]): Router<TRoutes, TOptions, TPlugin>
+  const TPlugin extends RouterPlugin = EmptyRouterPlugin,
+>(routes: TRoutes[], options?: TOptions, plugins?: TPlugin[]): Router<TRoutes, TOptions, TPlugin>;
 
 export function createRouter<
   const TRoutes extends Routes,
   const TOptions extends RouterOptions = {},
-  const TPlugin extends RouterPlugin = EmptyRouterPlugin
->(routesOrArrayOfRoutes: TRoutes | TRoutes[], options?: TOptions, plugins: TPlugin[] = []): Router<TRoutes, TOptions, TPlugin> {
-  const isGlobalRouter = options?.isGlobalRouter ?? true
-  const routerKey = isGlobalRouter ? routerInjectionKey : Symbol()
-  const shouldRemoveTrailingSlashes = options?.removeTrailingSlashes ?? true
-  const { routes, getRouteByName, getRejectionByType } = getRoutesForRouter(routesOrArrayOfRoutes, plugins, options)
-  const notFoundRejection = getRejectionByType('NotFound')
-  const notFoundRoute = createResolvedRoute(notFoundRejection.route)
-
-  const hooks = createRouterHooks()
-
-  hooks.addGlobalRouteHooks(getGlobalHooksForRouter(plugins))
-
-  const getNavigationId = createUniqueIdSequence()
-  const propStore = createPropStore()
-  const componentsStore = createComponentsStore(routerKey)
-  const visibilityObserver = createVisibilityObserver()
+  const TPlugin extends RouterPlugin = EmptyRouterPlugin,
+>(
+  routesOrArrayOfRoutes: TRoutes | TRoutes[],
+  options?: TOptions,
+  plugins: TPlugin[] = [],
+): Router<TRoutes, TOptions, TPlugin> {
+  const isGlobalRouter = options?.isGlobalRouter ?? true;
+  const routerKey = isGlobalRouter ? routerInjectionKey : Symbol();
+  const shouldRemoveTrailingSlashes = options?.removeTrailingSlashes ?? true;
+  const { routes, getRouteByName, getRejectionByType } = getRoutesForRouter(
+    routesOrArrayOfRoutes,
+    plugins,
+    options,
+  );
+  const notFoundRejection = getRejectionByType("NotFound");
+  const notFoundRoute = createResolvedRoute(notFoundRejection.route);
+
+  const hooks = createRouterHooks();
+
+  hooks.addGlobalRouteHooks(getGlobalHooksForRouter(plugins));
+
+  const getNavigationId = createUniqueIdSequence();
+  const propStore = createPropStore();
+  const componentsStore = createComponentsStore(routerKey);
+  const visibilityObserver = createVisibilityObserver();
   const history = createRouterHistory({
     mode: options?.historyMode,
     listener: ({ location }) => {
-      const url = createPath(location)
+      const url = createPath(location);
 
-      set(url, { state: location.state, replace: true })
+      set(url, { state: location.state, replace: true });
     },
-  })
+  });
 
   function find(url: string, resolveOptions: RouterResolveOptions = {}): ResolvedRoute | undefined {
-    const urlIsRelative = !isExternal(url)
-    const filteredRoutes = routes.filter((route) => route.isRelative === urlIsRelative)
-    const parseOptions = { removeTrailingSlashes: shouldRemoveTrailingSlashes }
+    const urlIsRelative = !isExternal(url);
+    const filteredRoutes = routes.filter((route) => route.isRelative === urlIsRelative);
+    const parseOptions = { removeTrailingSlashes: shouldRemoveTrailingSlashes };
 
-    return getMatchForUrl(filteredRoutes, url, { ...resolveOptions, ...parseOptions })
+    return getMatchForUrl(filteredRoutes, url, { ...resolveOptions, ...parseOptions });
   }
 
   async function set(url: string, options: RouterUpdateOptions = {}): Promise<void> {
     if (pathHasTrailingSlash(url) && shouldRemoveTrailingSlashes) {
-      const cleanedUrl = removeTrailingSlashesFromPath(url)
+      const cleanedUrl = removeTrailingSlashesFromPath(url);
 
       if (isUrlString(cleanedUrl)) {
-        return replace(cleanedUrl, options)
+        return replace(cleanedUrl, options);
       }
     }
 
-    const navigationId = getNavigationId()
+    const navigationId = getNavigationId();
 
-    history.stopListening()
+    history.stopListening();
 
-    const to = find(url, options) ?? notFoundRoute
+    const to = find(url, options) ?? notFoundRoute;
 
-    const from = getFromRouteForHooks(navigationId)
+    const from = getFromRouteForHooks(navigationId);
 
-    const beforeResponse = await hooks.runBeforeRouteHooks({ to, from })
+    const beforeResponse = await hooks.runBeforeRouteHooks({ to, from });
 
     switch (beforeResponse.status) {
       // On abort do nothing
-      case 'ABORT':
-        return
+      case "ABORT":
+        return;
 
       // On push update the history, and push new route, and return
-      case 'PUSH':
-        history.update(url, options)
-        await push(...beforeResponse.to)
-        return
+      case "PUSH":
+        history.update(url, options);
+        await push(...beforeResponse.to);
+        return;
 
       // On reject update the history, the route, and set the rejection type
-      case 'REJECT':
-        history.update(url, options)
-        setRejection(beforeResponse.type, to, from)
-        break
+      case "REJECT":
+        history.update(url, options);
+        setRejection(beforeResponse.type, to, from);
+        break;
 
       // On success update history, set the route, and clear the rejection
-      case 'SUCCESS':
-        history.update(url, options)
-        clearRejection()
-        break
+      case "SUCCESS":
+        history.update(url, options);
+        clearRejection();
+        break;
 
       default:
-        throw new Error(`Switch is not exhaustive for before hook response status: ${JSON.stringify(beforeResponse satisfies never)}`)
+        throw new Error(
+          `Switch is not exhaustive for before hook response status: ${JSON.stringify(beforeResponse satisfies never)}`,
+        );
     }
 
     if (!isExternal(url)) {
-      setPropsAndUpdateRoute(navigationId, to, from)
+      setPropsAndUpdateRoute(navigationId, to, from);
     }
 
-    const afterResponse = await hooks.runAfterRouteHooks({ to, from })
+    const afterResponse = await hooks.runAfterRouteHooks({ to, from });
 
     switch (afterResponse.status) {
-      case 'PUSH':
-        await push(...afterResponse.to)
-        break
+      case "PUSH":
+        await push(...afterResponse.to);
+        break;
 
-      case 'REJECT':
-        setRejection(afterResponse.type, to, from)
-        break
+      case "REJECT":
+        setRejection(afterResponse.type, to, from);
+        break;
 
-      case 'SUCCESS':
-        break
+      case "SUCCESS":
+        break;
 
       default:
-        const exhaustive: never = afterResponse
-        throw new Error(`Switch is not exhaustive for after hook response status: ${JSON.stringify(exhaustive)}`)
+        const exhaustive: never = afterResponse;
+        throw new Error(
+          `Switch is not exhaustive for after hook response status: ${JSON.stringify(exhaustive)}`,
+        );
     }
 
-    setDocumentTitle(currentRejectionRoute.value ?? to)
+    setDocumentTitle(currentRejectionRoute.value ?? to);
 
-    history.startListening()
+    history.startListening();
   }
 
-  function setPropsAndUpdateRoute(navigationId: string, to: ResolvedRoute, from: ResolvedRoute | null): void {
-    const currentNavigationId = navigationId
+  function setPropsAndUpdateRoute(
+    navigationId: string,
+    to: ResolvedRoute,
+    from: ResolvedRoute | null,
+  ): void {
+    const currentNavigationId = navigationId;
 
-    propStore.setProps(to)
+    propStore
+      .setProps(to)
       .then((response) => {
         if (currentNavigationId !== navigationId) {
-          return
+          return;
         }
 
         switch (response.status) {
-          case 'SUCCESS':
-            break
+          case "SUCCESS":
+            break;
 
-          case 'PUSH':
-            push(...response.to)
-            break
+          case "PUSH":
+            push(...response.to);
+            break;
 
-          case 'REJECT':
-            setRejection(response.type, to, from)
-            break
+          case "REJECT":
+            setRejection(response.type, to, from);
+            break;
 
           default:
-            const exhaustive: never = response
-            throw new Error(`Switch is not exhaustive for prop store response status: ${JSON.stringify(exhaustive)}`)
+            const exhaustive: never = response;
+            throw new Error(
+              `Switch is not exhaustive for prop store response status: ${JSON.stringify(exhaustive)}`,
+            );
         }
       })
       .catch((error: unknown) => {
         try {
-          hooks.runErrorHooks(error, { to, from, source: 'props' })
+          hooks.runErrorHooks(error, { to, from, source: "props" });
         } catch (error) {
           if (error instanceof ContextPushError) {
-            push(...error.response.to)
-            return
+            push(...error.response.to);
+            return;
           }
 
           if (error instanceof ContextRejectionError) {
-            setRejection(error.response.type, to, from)
-            return
+            setRejection(error.response.type, to, from);
+            return;
           }
 
-          throw error
+          throw error;
         }
-      })
+      });
 
-    updateRoute(to)
+    updateRoute(to);
   }
 
-  const resolve: RouterResolve<TRoutes | TPlugin['routes']> = (
-    source: RoutesName<TRoutes | TPlugin['routes']>,
+  const resolve: RouterResolve<TRoutes | TPlugin["routes"]> = (
+    source: RoutesName<TRoutes | TPlugin["routes"]>,
     params: Record<string, unknown> = {},
     options: RouterResolveOptions = {},
   ) => {
-    const match = getRouteByName(source)
+    const match = getRouteByName(source);
 
     if (!match) {
-      throw new RouteNotFoundError(source)
+      throw new RouteNotFoundError(source);
     }
 
-    return createResolvedRoute(match, params, options)
-  }
+    return createResolvedRoute(match, params, options);
+  };
 
-  const push: RouterPush<TRoutes | TPlugin['routes']> = (
-    source: UrlString | RoutesName<TRoutes | TPlugin['routes']> | ResolvedRoute,
+  const push: RouterPush<TRoutes | TPlugin["routes"]> = (
+    source: UrlString | RoutesName<TRoutes | TPlugin["routes"]> | ResolvedRoute,
     paramsOrOptions?: Record<string, unknown> | RouterPushOptions,
     maybeOptions?: RouterPushOptions,
   ) => {
     if (isUrlString(source)) {
-      const options: RouterPushOptions = { ...paramsOrOptions }
+      const options: RouterPushOptions = { ...paramsOrOptions };
       const url = updateUrl(source, {
         query: options.query,
         hash: options.hash,
-      })
+      });
 
-      return set(url, options)
+      return set(url, options);
     }
 
-    if (typeof source === 'string') {
-      const { replace, ...options }: RouterPushOptions = { ...maybeOptions }
-      const params: any = { ...paramsOrOptions }
-      const resolved = resolve(source, params, options)
-      const state = setStateValues({ ...resolved.matched.state }, { ...resolved.state, ...options.state })
+    if (typeof source === "string") {
+      const { replace, ...options }: RouterPushOptions = { ...maybeOptions };
+      const params: any = { ...paramsOrOptions };
+      const resolved = resolve(source, params, options);
+      const state = setStateValues(
+        { ...resolved.matched.state },
+        { ...resolved.state, ...options.state },
+      );
 
-      return set(resolved.href, { replace, state })
+      return set(resolved.href, { replace, state });
     }
 
-    const { replace, ...options }: RouterPushOptions = { ...paramsOrOptions }
-    const state = setStateValues({ ...source.matched.state }, { ...source.state, ...options.state })
+    const { replace, ...options }: RouterPushOptions = { ...paramsOrOptions };
+    const state = setStateValues(
+      { ...source.matched.state },
+      { ...source.state, ...options.state },
+    );
 
     const url = updateUrl(source.href, {
       query: options.query,
       hash: options.hash,
-    })
+    });
 
-    return set(url, { replace, state })
-  }
+    return set(url, { replace, state });
+  };
 
-  const replace: RouterReplace<TRoutes | TPlugin['routes']> = (
-    source: UrlString | RoutesName<TRoutes | TPlugin['routes']> | ResolvedRoute,
+  const replace: RouterReplace<TRoutes | TPlugin["routes"]> = (
+    source: UrlString | RoutesName<TRoutes | TPlugin["routes"]> | ResolvedRoute,
     paramsOrOptions?: Record<string, unknown> | RouterReplaceOptions,
     maybeOptions?: RouterReplaceOptions,
   ) => {
     if (isUrlString(source)) {
-      const options: RouterPushOptions = { ...paramsOrOptions, replace: true }
+      const options: RouterPushOptions = { ...paramsOrOptions, replace: true };
 
-      return push(source, options)
+      return push(source, options);
     }
 
-    if (typeof source === 'string') {
-      const options: RouterPushOptions = { ...maybeOptions, replace: true }
-      const params: any = { ...paramsOrOptions }
+    if (typeof source === "string") {
+      const options: RouterPushOptions = { ...maybeOptions, replace: true };
+      const params: any = { ...paramsOrOptions };
 
-      return push(source, params, options)
+      return push(source, params, options);
     }
 
-    const options: RouterPushOptions = { ...paramsOrOptions, replace: true }
+    const options: RouterPushOptions = { ...paramsOrOptions, replace: true };
 
-    return push(source, options)
-  }
+    return push(source, options);
+  };
 
-  function setRejection(type: string, to: ResolvedRoute | null = null, from: ResolvedRoute | null = null): void {
-    const rejection = getRejectionByType(type)
+  function setRejection(
+    type: string,
+    to: ResolvedRoute | null = null,
+    from: ResolvedRoute | null = null,
+  ): void {
+    const rejection = getRejectionByType(type);
 
     if (!rejection) {
-      return
+      return;
     }
 
-    hooks.runRejectionHooks(rejection, { to, from })
+    hooks.runRejectionHooks(rejection, { to, from });
 
-    updateRejection(rejection)
+    updateRejection(rejection);
   }
 
-  const reject: RouterReject<TOptions['rejections'] | TPlugin['rejections']> = (type) => {
-    setRejection(type)
-    setDocumentTitle(currentRejectionRoute.value)
-  }
+  const reject: RouterReject<TOptions["rejections"] | TPlugin["rejections"]> = (type) => {
+    setRejection(type);
+    setDocumentTitle(currentRejectionRoute.value);
+  };
 
-  const { currentRejection, currentRejectionRoute, updateRejection, clearRejection } = createCurrentRejection()
-  const { currentRoute, routerRoute, updateRoute } = createCurrentRoute<TRoutes | TPlugin['routes']>(routerKey, notFoundRoute, push)
+  const { currentRejection, currentRejectionRoute, updateRejection, clearRejection } =
+    createCurrentRejection();
+  const { currentRoute, routerRoute, updateRoute } = createCurrentRoute<
+    TRoutes | TPlugin["routes"]
+  >(routerKey, notFoundRoute, push);
 
-  const initialUrl = getInitialUrl(options?.initialUrl)
-  const initialState = history.location.state
-  const { host } = parseUrl(initialUrl)
-  const isExternal = createIsExternal(host)
+  const initialUrl = getInitialUrl(options?.initialUrl);
+  const initialState = history.location.state;
+  const { host } = parseUrl(initialUrl);
+  const isExternal = createIsExternal(host);
 
-  let starting = false
-  const started = ref(false)
+  let starting = false;
+  const started = ref(false);
 
   // eslint is just incorrect here
-  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-  const { promise: initialize, resolve: initialized } = Promise.withResolvers<void>()
+  // oxlint-disable-next-line @typescript-eslint/no-invalid-void-type
+  const { promise: initialize, resolve: initialized } = Promise.withResolvers<void>();
 
   async function start(): Promise<void> {
     if (starting) {
-      return initialize
+      return initialize;
     }
 
-    starting = true
+    starting = true;
 
-    const shouldInitZod = zodParamsDetected(routes)
+    const shouldInitZod = zodParamsDetected(routes);
 
     if (shouldInitZod) {
-      await initZod()
+      await initZod();
     }
 
-    await set(initialUrl, { replace: true, state: initialState })
+    await set(initialUrl, { replace: true, state: initialState });
 
-    history.startListening()
+    history.startListening();
 
-    initialized()
-    started.value = true
+    initialized();
+    started.value = true;
   }
 
   function stop(): void {
-    history.stopListening()
+    history.stopListening();
   }
 
   function getFromRouteForHooks(navigationId: string): ResolvedRoute | null {
-    return isFirstUniqueSequenceId(navigationId) ? null : { ...currentRoute }
+    return isFirstUniqueSequenceId(navigationId) ? null : { ...currentRoute };
   }
 
   function install(app: App): void {
-    hooks.setVueApp(app)
-    propStore.setVueApp(app)
+    hooks.setVueApp(app);
+    propStore.setVueApp(app);
 
-    const routerView = createRouterView(routerKey)
-    const routerLink = createRouterLink(routerKey)
+    const routerView = createRouterView(routerKey);
+    const routerLink = createRouterLink(routerKey);
 
-    app.component('RouterView', routerView)
-    app.component('RouterLink', routerLink)
-    app.provide(getRouterRejectionInjectionKey(routerKey), currentRejection)
-    app.provide(getRouterHooksKey(routerKey), hooks)
-    app.provide(getPropStoreInjectionKey(routerKey), propStore)
-    app.provide(getComponentsStoreKey(routerKey), componentsStore)
-    app.provide(visibilityObserverKey, visibilityObserver)
+    app.component("RouterView", routerView);
+    app.component("RouterLink", routerLink);
+    app.provide(getRouterRejectionInjectionKey(routerKey), currentRejection);
+    app.provide(getRouterHooksKey(routerKey), hooks);
+    app.provide(getPropStoreInjectionKey(routerKey), propStore);
+    app.provide(getComponentsStoreKey(routerKey), componentsStore);
+    app.provide(visibilityObserverKey, visibilityObserver);
 
-    app.provide(routerKey, router)
+    app.provide(routerKey, router);
 
     // Setup DevTools integration
-    setupRouterDevtools({ router, app, routes })
+    setupRouterDevtools({ router, app, routes });
 
-    start()
+    start();
   }
 
   const router: Router<TRoutes, TOptions, TPlugin> = {
@@ -422,7 +454,7 @@ export function createRouter<
     stop,
     key: routerKey,
     hasDevtools: false,
-  }
+  };
 
-  return router
+  return router;
 }
diff --git a/src/services/createRouterHistory.browser.spec.ts b/src/services/createRouterHistory.browser.spec.ts
index 11d7c940..0e183549 100644
--- a/src/services/createRouterHistory.browser.spec.ts
+++ b/src/services/createRouterHistory.browser.spec.ts
@@ -1,38 +1,38 @@
-import { beforeEach, expect, test, vi } from 'vitest'
-import { createRouterHistory } from '@/services/createRouterHistory'
-import { random } from '@/utilities/testHelpers'
+import { beforeEach, expect, test, vi } from "vite-plus/test";
+import { createRouterHistory } from "@/services/createRouterHistory";
+import { random } from "@/utilities/testHelpers";
 
 function noop(): void {}
 
-beforeEach(() => vi.resetAllMocks())
+beforeEach(() => vi.resetAllMocks());
 
-test('when go is called, forwards call to window history', () => {
-  vi.spyOn(window.history, 'go')
+test("when go is called, forwards call to window history", () => {
+  vi.spyOn(window.history, "go");
 
-  const delta = random.number({ min: 0, max: 100 })
-  const history = createRouterHistory({ listener: noop })
+  const delta = random.number({ min: 0, max: 100 });
+  const history = createRouterHistory({ listener: noop });
 
-  history.go(delta)
+  history.go(delta);
 
-  expect(window.history.go).toHaveBeenCalledWith(delta)
-})
+  expect(window.history.go).toHaveBeenCalledWith(delta);
+});
 
-test('when back is called, forwards call to window history', () => {
-  vi.spyOn(window.history, 'go')
+test("when back is called, forwards call to window history", () => {
+  vi.spyOn(window.history, "go");
 
-  const history = createRouterHistory({ listener: noop })
+  const history = createRouterHistory({ listener: noop });
 
-  history.back()
+  history.back();
 
-  expect(window.history.go).toHaveBeenCalledOnce()
-})
+  expect(window.history.go).toHaveBeenCalledOnce();
+});
 
-test('when forward is called, forwards call to window history', () => {
-  vi.spyOn(window.history, 'go')
+test("when forward is called, forwards call to window history", () => {
+  vi.spyOn(window.history, "go");
 
-  const history = createRouterHistory({ listener: noop })
+  const history = createRouterHistory({ listener: noop });
 
-  history.forward()
+  history.forward();
 
-  expect(window.history.go).toHaveBeenCalledOnce()
-})
+  expect(window.history.go).toHaveBeenCalledOnce();
+});
diff --git a/src/services/createRouterPlugin.browser.spec.ts b/src/services/createRouterPlugin.browser.spec.ts
index 6dedeab0..00e82d04 100644
--- a/src/services/createRouterPlugin.browser.spec.ts
+++ b/src/services/createRouterPlugin.browser.spec.ts
@@ -1,119 +1,119 @@
-import { test, expect, vi } from 'vitest'
-import { createRoute } from './createRoute'
-import { createRouter } from './createRouter'
-import { createRouterPlugin } from './createRouterPlugin'
-import { component, routes } from '@/utilities/testHelpers'
-import { mount, flushPromises } from '@vue/test-utils'
-import { createRejection } from './createRejection'
-
-test('given a plugin, adds the routes to the router', async () => {
+import { test, expect, vi } from "vite-plus/test";
+import { createRoute } from "./createRoute";
+import { createRouter } from "./createRouter";
+import { createRouterPlugin } from "./createRouterPlugin";
+import { component, routes } from "@/utilities/testHelpers";
+import { mount, flushPromises } from "@vue/test-utils";
+import { createRejection } from "./createRejection";
+
+test("given a plugin, adds the routes to the router", async () => {
   const pluginRejection = createRejection({
-    type: 'plugin',
+    type: "plugin",
     component,
-  })
+  });
 
   const plugin = createRouterPlugin({
-    routes: [createRoute({ name: 'plugin', path: '/plugin', component })],
+    routes: [createRoute({ name: "plugin", path: "/plugin", component })],
     rejections: [pluginRejection],
-  })
+  });
 
-  const router = createRouter([], { initialUrl: '/plugin' }, [plugin])
+  const router = createRouter([], { initialUrl: "/plugin" }, [plugin]);
 
-  await router.start()
+  await router.start();
 
-  expect(router.route.name).toBe('plugin')
-})
+  expect(router.route.name).toBe("plugin");
+});
 
-test('given a plugin, adds the rejections to the router', async () => {
+test("given a plugin, adds the rejections to the router", async () => {
   const pluginRejection = createRejection({
-    type: 'from-plugin',
-    component: { template: '<div>This is a plugin rejection</div>' },
-  })
+    type: "from-plugin",
+    component: { template: "<div>This is a plugin rejection</div>" },
+  });
 
   const plugin = createRouterPlugin({
     rejections: [pluginRejection],
-  })
+  });
 
-  const router = createRouter([], { initialUrl: '/' }, [plugin])
+  const router = createRouter([], { initialUrl: "/" }, [plugin]);
 
-  await router.start()
+  await router.start();
 
   const root = {
-    template: '<RouterView/>',
-  }
+    template: "<RouterView/>",
+  };
 
   const wrapper = mount(root, {
     global: {
       plugins: [router],
     },
-  })
-
-  router.reject('from-plugin')
-
-  await flushPromises()
-
-  expect(wrapper.html()).toBe('<div>This is a plugin rejection</div>')
-})
-
-test('given a plugin, adds the hooks to the router', async () => {
-  const onBeforeRouteEnterMock = vi.fn()
-  const onBeforeRouteUpdateMock = vi.fn()
-  const onBeforeRouteLeaveMock = vi.fn()
-  const onAfterRouteEnterMock = vi.fn()
-  const onAfterRouteUpdateMock = vi.fn()
-  const onAfterRouteLeaveMock = vi.fn()
-
-  const plugin = createRouterPlugin({})
-
-  plugin.onBeforeRouteEnter(onBeforeRouteEnterMock)
-  plugin.onBeforeRouteUpdate(onBeforeRouteUpdateMock)
-  plugin.onBeforeRouteLeave(onBeforeRouteLeaveMock)
-  plugin.onAfterRouteEnter(onAfterRouteEnterMock)
-  plugin.onAfterRouteUpdate(onAfterRouteUpdateMock)
-  plugin.onAfterRouteLeave(onAfterRouteLeaveMock)
-
-  const router = createRouter(routes, { initialUrl: '/parentA/valueA' }, [plugin])
-
-  expect(onBeforeRouteEnterMock).toHaveBeenCalledTimes(0)
-  expect(onBeforeRouteUpdateMock).toHaveBeenCalledTimes(0)
-  expect(onBeforeRouteLeaveMock).toHaveBeenCalledTimes(0)
-  expect(onAfterRouteLeaveMock).toHaveBeenCalledTimes(0)
-  expect(onAfterRouteUpdateMock).toHaveBeenCalledTimes(0)
-  expect(onAfterRouteEnterMock).toHaveBeenCalledTimes(0)
-
-  await router.start()
-
-  expect(onBeforeRouteEnterMock).toHaveBeenCalledTimes(1)
-  expect(onBeforeRouteUpdateMock).toHaveBeenCalledTimes(0)
-  expect(onBeforeRouteLeaveMock).toHaveBeenCalledTimes(0)
-  expect(onAfterRouteLeaveMock).toHaveBeenCalledTimes(0)
-  expect(onAfterRouteUpdateMock).toHaveBeenCalledTimes(0)
-  expect(onAfterRouteEnterMock).toHaveBeenCalledTimes(1)
-
-  await router.push('parentA.childA', { paramA: 'valueA', paramB: 'valueB' })
-
-  expect(onBeforeRouteEnterMock).toHaveBeenCalledTimes(2)
-  expect(onBeforeRouteUpdateMock).toHaveBeenCalledTimes(1)
-  expect(onBeforeRouteLeaveMock).toHaveBeenCalledTimes(0)
-  expect(onAfterRouteLeaveMock).toHaveBeenCalledTimes(0)
-  expect(onAfterRouteUpdateMock).toHaveBeenCalledTimes(1)
-  expect(onAfterRouteEnterMock).toHaveBeenCalledTimes(2)
-
-  await router.push('parentA.childB', { paramA: 'valueB', paramD: 'valueD' })
-
-  expect(onBeforeRouteEnterMock).toHaveBeenCalledTimes(3)
-  expect(onBeforeRouteUpdateMock).toHaveBeenCalledTimes(2)
-  expect(onBeforeRouteLeaveMock).toHaveBeenCalledTimes(1)
-  expect(onAfterRouteLeaveMock).toHaveBeenCalledTimes(1)
-  expect(onAfterRouteUpdateMock).toHaveBeenCalledTimes(2)
-  expect(onAfterRouteEnterMock).toHaveBeenCalledTimes(3)
-
-  await router.push('parentB')
-
-  expect(onBeforeRouteEnterMock).toHaveBeenCalledTimes(4)
-  expect(onBeforeRouteUpdateMock).toHaveBeenCalledTimes(2)
-  expect(onBeforeRouteLeaveMock).toHaveBeenCalledTimes(2)
-  expect(onAfterRouteLeaveMock).toHaveBeenCalledTimes(2)
-  expect(onAfterRouteUpdateMock).toHaveBeenCalledTimes(2)
-  expect(onAfterRouteEnterMock).toHaveBeenCalledTimes(4)
-})
+  });
+
+  router.reject("from-plugin");
+
+  await flushPromises();
+
+  expect(wrapper.html()).toBe("<div>This is a plugin rejection</div>");
+});
+
+test("given a plugin, adds the hooks to the router", async () => {
+  const onBeforeRouteEnterMock = vi.fn();
+  const onBeforeRouteUpdateMock = vi.fn();
+  const onBeforeRouteLeaveMock = vi.fn();
+  const onAfterRouteEnterMock = vi.fn();
+  const onAfterRouteUpdateMock = vi.fn();
+  const onAfterRouteLeaveMock = vi.fn();
+
+  const plugin = createRouterPlugin({});
+
+  plugin.onBeforeRouteEnter(onBeforeRouteEnterMock);
+  plugin.onBeforeRouteUpdate(onBeforeRouteUpdateMock);
+  plugin.onBeforeRouteLeave(onBeforeRouteLeaveMock);
+  plugin.onAfterRouteEnter(onAfterRouteEnterMock);
+  plugin.onAfterRouteUpdate(onAfterRouteUpdateMock);
+  plugin.onAfterRouteLeave(onAfterRouteLeaveMock);
+
+  const router = createRouter(routes, { initialUrl: "/parentA/valueA" }, [plugin]);
+
+  expect(onBeforeRouteEnterMock).toHaveBeenCalledTimes(0);
+  expect(onBeforeRouteUpdateMock).toHaveBeenCalledTimes(0);
+  expect(onBeforeRouteLeaveMock).toHaveBeenCalledTimes(0);
+  expect(onAfterRouteLeaveMock).toHaveBeenCalledTimes(0);
+  expect(onAfterRouteUpdateMock).toHaveBeenCalledTimes(0);
+  expect(onAfterRouteEnterMock).toHaveBeenCalledTimes(0);
+
+  await router.start();
+
+  expect(onBeforeRouteEnterMock).toHaveBeenCalledTimes(1);
+  expect(onBeforeRouteUpdateMock).toHaveBeenCalledTimes(0);
+  expect(onBeforeRouteLeaveMock).toHaveBeenCalledTimes(0);
+  expect(onAfterRouteLeaveMock).toHaveBeenCalledTimes(0);
+  expect(onAfterRouteUpdateMock).toHaveBeenCalledTimes(0);
+  expect(onAfterRouteEnterMock).toHaveBeenCalledTimes(1);
+
+  await router.push("parentA.childA", { paramA: "valueA", paramB: "valueB" });
+
+  expect(onBeforeRouteEnterMock).toHaveBeenCalledTimes(2);
+  expect(onBeforeRouteUpdateMock).toHaveBeenCalledTimes(1);
+  expect(onBeforeRouteLeaveMock).toHaveBeenCalledTimes(0);
+  expect(onAfterRouteLeaveMock).toHaveBeenCalledTimes(0);
+  expect(onAfterRouteUpdateMock).toHaveBeenCalledTimes(1);
+  expect(onAfterRouteEnterMock).toHaveBeenCalledTimes(2);
+
+  await router.push("parentA.childB", { paramA: "valueB", paramD: "valueD" });
+
+  expect(onBeforeRouteEnterMock).toHaveBeenCalledTimes(3);
+  expect(onBeforeRouteUpdateMock).toHaveBeenCalledTimes(2);
+  expect(onBeforeRouteLeaveMock).toHaveBeenCalledTimes(1);
+  expect(onAfterRouteLeaveMock).toHaveBeenCalledTimes(1);
+  expect(onAfterRouteUpdateMock).toHaveBeenCalledTimes(2);
+  expect(onAfterRouteEnterMock).toHaveBeenCalledTimes(3);
+
+  await router.push("parentB");
+
+  expect(onBeforeRouteEnterMock).toHaveBeenCalledTimes(4);
+  expect(onBeforeRouteUpdateMock).toHaveBeenCalledTimes(2);
+  expect(onBeforeRouteLeaveMock).toHaveBeenCalledTimes(2);
+  expect(onAfterRouteLeaveMock).toHaveBeenCalledTimes(2);
+  expect(onAfterRouteUpdateMock).toHaveBeenCalledTimes(2);
+  expect(onAfterRouteEnterMock).toHaveBeenCalledTimes(4);
+});
diff --git a/src/services/createRouterPlugin.spec-d.ts b/src/services/createRouterPlugin.spec-d.ts
index a4daf3ff..1b8ffdc2 100644
--- a/src/services/createRouterPlugin.spec-d.ts
+++ b/src/services/createRouterPlugin.spec-d.ts
@@ -1,44 +1,44 @@
-import { describe, expectTypeOf, test } from 'vitest'
-import { routes } from '@/utilities/testHelpers'
-import { createRouterPlugin } from './createRouterPlugin'
-import { createRejection } from './createRejection'
-import { ResolvedRoute } from '@/types/resolved'
-import { RouterReject } from '@/types/routerReject'
-import { RouterPush } from '@/types/routerPush'
-import { RouterReplace } from '@/types/routerReplace'
+import { describe, expectTypeOf, test } from "vite-plus/test";
+import { routes } from "@/utilities/testHelpers";
+import { createRouterPlugin } from "./createRouterPlugin";
+import { createRejection } from "./createRejection";
+import { ResolvedRoute } from "@/types/resolved";
+import { RouterReject } from "@/types/routerReject";
+import { RouterPush } from "@/types/routerPush";
+import { RouterReplace } from "@/types/routerReplace";
 
-describe('hooks', () => {
+describe("hooks", () => {
   const NotAuthorized = createRejection({
-    type: 'NotAuthorized',
-  })
+    type: "NotAuthorized",
+  });
 
   const plugin = createRouterPlugin({
     routes,
     rejections: [NotAuthorized],
-  })
+  });
 
-  test('to and from should not be specifically typed', () => {
+  test("to and from should not be specifically typed", () => {
     plugin.onBeforeRouteEnter((to, { from }) => {
-      expectTypeOf(to).toEqualTypeOf<ResolvedRoute>()
-      expectTypeOf(from).toEqualTypeOf<ResolvedRoute | null>()
-    })
-  })
+      expectTypeOf(to).toEqualTypeOf<ResolvedRoute>();
+      expectTypeOf(from).toEqualTypeOf<ResolvedRoute | null>();
+    });
+  });
 
-  test('reject should be correctly typed', () => {
+  test("reject should be correctly typed", () => {
     plugin.onBeforeRouteEnter((_to, { reject }) => {
-      expectTypeOf(reject).toEqualTypeOf<RouterReject<[typeof NotAuthorized]>>()
-    })
-  })
+      expectTypeOf(reject).toEqualTypeOf<RouterReject<[typeof NotAuthorized]>>();
+    });
+  });
 
-  test('push should be correctly typed', () => {
+  test("push should be correctly typed", () => {
     plugin.onBeforeRouteEnter((_to, { push }) => {
-      expectTypeOf(push).toEqualTypeOf<RouterPush<typeof routes>>()
-    })
-  })
+      expectTypeOf(push).toEqualTypeOf<RouterPush<typeof routes>>();
+    });
+  });
 
-  test('replace should be correctly typed', () => {
+  test("replace should be correctly typed", () => {
     plugin.onBeforeRouteEnter((_to, { replace }) => {
-      expectTypeOf(replace).toEqualTypeOf<RouterReplace<typeof routes>>()
-    })
-  })
-})
+      expectTypeOf(replace).toEqualTypeOf<RouterReplace<typeof routes>>();
+    });
+  });
+});
diff --git a/src/services/createRouterRoute.spec.ts b/src/services/createRouterRoute.spec.ts
index 0a79c16c..d1ba8f4e 100644
--- a/src/services/createRouterRoute.spec.ts
+++ b/src/services/createRouterRoute.spec.ts
@@ -1,42 +1,34 @@
-import { expect, test, vi } from 'vitest'
-import { reactive } from 'vue'
-import { createRouterRoute, isRouterRoute } from '@/services/createRouterRoute'
-import { createRoute } from './createRoute'
-import { createResolvedRoute } from './createResolvedRoute'
-
-test('isRouterRoute returns correct response', () => {
-  const route = createRoute({ name: 'isRouterRoute' })
-  const resolved = createResolvedRoute(route, {})
-  const push = vi.fn()
-  const routerKey = Symbol()
-
-  const routerRoute = createRouterRoute(routerKey, reactive(resolved), push)
-
-  expect(isRouterRoute(routerKey, routerRoute)).toBe(true)
-  expect(isRouterRoute(routerKey, {})).toBe(false)
-})
-
-test('sending state, includes state in push options', () => {
-  const route = createRoute({ name: 'state' })
-  const resolved = createResolvedRoute(route, {})
-  const push = vi.fn()
-  const routerKey = Symbol()
-
-  const routerRoute = createRouterRoute(routerKey, reactive(resolved), push)
-
-  routerRoute.update({}, { state: { foo: 'foo' } })
-
-  expect(push).toBeCalledWith(
-    'state',
-    {},
-    { state: { foo: 'foo' } },
-  )
-
-  routerRoute.update('param', 123, { state: { bar: 'bar' } })
-
-  expect(push).toBeCalledWith(
-    'state',
-    { param: 123 },
-    { state: { bar: 'bar' } },
-  )
-})
+import { expect, test, vi } from "vite-plus/test";
+import { reactive } from "vue";
+import { createRouterRoute, isRouterRoute } from "@/services/createRouterRoute";
+import { createRoute } from "./createRoute";
+import { createResolvedRoute } from "./createResolvedRoute";
+
+test("isRouterRoute returns correct response", () => {
+  const route = createRoute({ name: "isRouterRoute" });
+  const resolved = createResolvedRoute(route, {});
+  const push = vi.fn();
+  const routerKey = Symbol();
+
+  const routerRoute = createRouterRoute(routerKey, reactive(resolved), push);
+
+  expect(isRouterRoute(routerKey, routerRoute)).toBe(true);
+  expect(isRouterRoute(routerKey, {})).toBe(false);
+});
+
+test("sending state, includes state in push options", () => {
+  const route = createRoute({ name: "state" });
+  const resolved = createResolvedRoute(route, {});
+  const push = vi.fn();
+  const routerKey = Symbol();
+
+  const routerRoute = createRouterRoute(routerKey, reactive(resolved), push);
+
+  routerRoute.update({}, { state: { foo: "foo" } });
+
+  expect(push).toBeCalledWith("state", {}, { state: { foo: "foo" } });
+
+  routerRoute.update("param", 123, { state: { bar: "bar" } });
+
+  expect(push).toBeCalledWith("state", { param: 123 }, { state: { bar: "bar" } });
+});
diff --git a/src/services/createUrl.spec.ts b/src/services/createUrl.spec.ts
index a46cadc6..a59c4a53 100644
--- a/src/services/createUrl.spec.ts
+++ b/src/services/createUrl.spec.ts
@@ -1,676 +1,703 @@
-import { describe, expect, test, vi } from 'vitest'
-import { createUrl } from '@/services/createUrl'
-import { withParams } from './withParams'
-import { withDefault } from './withDefault'
-import { InvalidRouteParamValueError } from '@/errors/invalidRouteParamValueError'
-import { createParam } from './createParam'
+import { describe, expect, test, vi } from "vite-plus/test";
+import { createUrl } from "@/services/createUrl";
+import { withParams } from "./withParams";
+import { withDefault } from "./withDefault";
+import { InvalidRouteParamValueError } from "@/errors/invalidRouteParamValueError";
+import { createParam } from "./createParam";
 
 test('given a query that starts with "?", strips the leading "?"', () => {
-  const url = createUrl({ query: '?foo=123' })
+  const url = createUrl({ query: "?foo=123" });
 
-  expect(url.stringify()).toBe('/?foo=123')
-})
+  expect(url.stringify()).toBe("/?foo=123");
+});
 
 test('given a hash that starts with "#", strips the leading "#"', () => {
-  const url = createUrl({ hash: '#foo' })
-  expect(url.stringify()).toBe('/#foo')
-})
+  const url = createUrl({ hash: "#foo" });
+  expect(url.stringify()).toBe("/#foo");
+});
 
-describe('stringify', () => {
-  test('given parts without host, protocol, or path, returns forward slash to satisfy Url', () => {
-    const url = createUrl({})
+describe("stringify", () => {
+  test("given parts without host, protocol, or path, returns forward slash to satisfy Url", () => {
+    const url = createUrl({});
 
-    expect(url.stringify()).toBe('/')
-  })
+    expect(url.stringify()).toBe("/");
+  });
 
-  test.each(['foo', '/foo'])('given parts with path, returns value with path', (path) => {
+  test.each(["foo", "/foo"])("given parts with path, returns value with path", (path) => {
     const parts = {
-      host: 'https://kitbag.dev',
+      host: "https://kitbag.dev",
       path,
-    }
+    };
 
-    const url = createUrl(parts)
+    const url = createUrl(parts);
 
-    expect(url.stringify()).toBe('https://kitbag.dev/foo')
-  })
+    expect(url.stringify()).toBe("https://kitbag.dev/foo");
+  });
 
-  test.each(['?bar=123', 'bar=123'])('given parts with query, returns value with query', (query) => {
-    const parts = {
-      host: 'https://kitbag.dev',
-      query,
-    }
+  test.each(["?bar=123", "bar=123"])(
+    "given parts with query, returns value with query",
+    (query) => {
+      const parts = {
+        host: "https://kitbag.dev",
+        query,
+      };
 
-    const url = createUrl(parts)
+      const url = createUrl(parts);
 
-    expect(url.stringify()).toBe('https://kitbag.dev/?bar=123')
-  })
+      expect(url.stringify()).toBe("https://kitbag.dev/?bar=123");
+    },
+  );
 
-  test.each(['bar', '#bar'])('given parts with hash, returns value with hash', (hash) => {
+  test.each(["bar", "#bar"])("given parts with hash, returns value with hash", (hash) => {
     const parts = {
-      host: 'https://kitbag.dev',
+      host: "https://kitbag.dev",
       hash,
-    }
+    };
 
-    const url = createUrl(parts)
+    const url = createUrl(parts);
 
-    expect(url.stringify()).toBe('https://kitbag.dev/#bar')
-  })
+    expect(url.stringify()).toBe("https://kitbag.dev/#bar");
+  });
 
-  test('given parts without host, returns url starting with forward slash', () => {
+  test("given parts without host, returns url starting with forward slash", () => {
     const parts = {
-      path: '/foo',
-      query: '?bar=123',
-    }
+      path: "/foo",
+      query: "?bar=123",
+    };
 
-    const url = createUrl(parts)
+    const url = createUrl(parts);
 
-    expect(url.stringify()).toBe('/foo?bar=123')
-  })
+    expect(url.stringify()).toBe("/foo?bar=123");
+  });
 
-  test.each([
-    { host: 'https://router.kitbag.dev' },
-    { host: 'https://github.io' },
-  ])('given parts with host, returns value that satisfies Url', (parts) => {
-    const url = createUrl(parts)
+  test.each([{ host: "https://router.kitbag.dev" }, { host: "https://github.io" }])(
+    "given parts with host, returns value that satisfies Url",
+    (parts) => {
+      const url = createUrl(parts);
 
-    expect(url.stringify()).toBe(`${parts.host}/`)
-  })
-})
+      expect(url.stringify()).toBe(`${parts.host}/`);
+    },
+  );
+});
 
-describe('parse', () => {
+describe("parse", () => {
   test.each([
-    ['/[foo]', '/', 'Param is not optional, received ""'],
-    [withParams('/[foo]', { foo: Number }), '/abc', 'Expected number value, received "abc"'],
-    [withParams('/[foo]', { foo: Boolean }), '/abc', 'Expected boolean value, received "abc"'],
-    [withParams('/[foo]', { foo: Date }), '/abc', 'Expected date value, received "abc"'],
-    [withParams('/[foo]', { foo: JSON }), '/abc', 'Expected JSON value, received "abc"'],
-    [withParams('/[foo]', { foo: /[\d{3}]/ }), '/abc', 'Expected value to match regex /[\\d{3}]/, received "abc"'],
-    [withParams('/[foo]', { foo: 'def' }), '/abc', 'Expected value to be def, received "abc"'],
-  ])('given invalid url $1, throws InvalidRouteParamValueError with useful error message $2', (path, input, output) => {
-    const url = createUrl({
-      path,
-    })
+    ["/[foo]", "/", 'Param is not optional, received ""'],
+    [withParams("/[foo]", { foo: Number }), "/abc", 'Expected number value, received "abc"'],
+    [withParams("/[foo]", { foo: Boolean }), "/abc", 'Expected boolean value, received "abc"'],
+    [withParams("/[foo]", { foo: Date }), "/abc", 'Expected date value, received "abc"'],
+    [withParams("/[foo]", { foo: JSON }), "/abc", 'Expected JSON value, received "abc"'],
+    [
+      withParams("/[foo]", { foo: /[\d{3}]/ }),
+      "/abc",
+      'Expected value to match regex /[\\d{3}]/, received "abc"',
+    ],
+    [withParams("/[foo]", { foo: "def" }), "/abc", 'Expected value to be def, received "abc"'],
+  ])(
+    "given invalid url $1, throws InvalidRouteParamValueError with useful error message $2",
+    (path, input, output) => {
+      const url = createUrl({
+        path,
+      });
 
-    expect(() => url.parse(input)).toThrowError(output)
-  })
+      expect(() => url.parse(input)).toThrowError(output);
+    },
+  );
 
-  test('given params in each part of the URL, extracts them', () => {
-    const input = 'foo'
+  test("given params in each part of the URL, extracts them", () => {
+    const input = "foo";
 
     const url = createUrl({
-      host: 'https://[inHost].dev',
-      path: '/[inPath]',
-      query: 'inQuery=[inQuery]',
-      hash: '[inHash]',
-    })
-    const response = url.parse(`https://${input}.dev/${input}?inQuery=${input}#${input}`)
-
-    expect(response.inHost).toBe(input)
-    expect(response.inPath).toBe(input)
-    expect(response.inQuery).toBe(input)
-    expect(response.inHash).toBe(`#${input}`)
-  })
-
-  test('given value with encoded URL characters, decodes those characters', () => {
+      host: "https://[inHost].dev",
+      path: "/[inPath]",
+      query: "inQuery=[inQuery]",
+      hash: "[inHash]",
+    });
+    const response = url.parse(`https://${input}.dev/${input}?inQuery=${input}#${input}`);
+
+    expect(response.inHost).toBe(input);
+    expect(response.inPath).toBe(input);
+    expect(response.inQuery).toBe(input);
+    expect(response.inHash).toBe(`#${input}`);
+  });
+
+  test("given value with encoded URL characters, decodes those characters", () => {
     const escapeCodes = [
-      { decoded: ' ', encoded: '%20' },
-      { decoded: '<', encoded: '%3C' },
-      { decoded: '>', encoded: '%3E' },
-      { decoded: '#', encoded: '%23' },
-      { decoded: '%', encoded: '%25' },
-      { decoded: '{', encoded: '%7B' },
-      { decoded: '}', encoded: '%7D' },
-      { decoded: '|', encoded: '%7C' },
-      { decoded: '\\', encoded: '%5C' },
-      { decoded: '^', encoded: '%5E' },
-      { decoded: '~', encoded: '%7E' },
-      { decoded: '[', encoded: '%5B' },
-      { decoded: ']', encoded: '%5D' },
-      { decoded: '`', encoded: '%60' },
-      { decoded: ';', encoded: '%3B' },
-      { decoded: '?', encoded: '%3F' },
-      { decoded: ':', encoded: '%3A' },
-      { decoded: '@', encoded: '%40' },
-      { decoded: '=', encoded: '%3D' },
-      { decoded: '&', encoded: '%26' },
-      { decoded: '$', encoded: '%24' },
-    ]
-
-    const input = escapeCodes.map((code) => code.encoded).join('')
-    const output = escapeCodes.map((code) => code.decoded).join('')
+      { decoded: " ", encoded: "%20" },
+      { decoded: "<", encoded: "%3C" },
+      { decoded: ">", encoded: "%3E" },
+      { decoded: "#", encoded: "%23" },
+      { decoded: "%", encoded: "%25" },
+      { decoded: "{", encoded: "%7B" },
+      { decoded: "}", encoded: "%7D" },
+      { decoded: "|", encoded: "%7C" },
+      { decoded: "\\", encoded: "%5C" },
+      { decoded: "^", encoded: "%5E" },
+      { decoded: "~", encoded: "%7E" },
+      { decoded: "[", encoded: "%5B" },
+      { decoded: "]", encoded: "%5D" },
+      { decoded: "`", encoded: "%60" },
+      { decoded: ";", encoded: "%3B" },
+      { decoded: "?", encoded: "%3F" },
+      { decoded: ":", encoded: "%3A" },
+      { decoded: "@", encoded: "%40" },
+      { decoded: "=", encoded: "%3D" },
+      { decoded: "&", encoded: "%26" },
+      { decoded: "$", encoded: "%24" },
+    ];
+
+    const input = escapeCodes.map((code) => code.encoded).join("");
+    const output = escapeCodes.map((code) => code.decoded).join("");
 
     const url = createUrl({
-      path: '/[inPath]',
-      query: 'inQuery=[inQuery]',
-      hash: '[inHash]',
-    })
-    const response = url.parse(`/${input}?inQuery=${input}#${input}`)
-
-    expect(response.inPath).toBe(output)
-    expect(response.inQuery).toBe(output)
-    expect(response.inHash).toBe(`#${output}`)
-  })
-
-  test('given url with query param that has a different param name than query key, still works as expected', () => {
+      path: "/[inPath]",
+      query: "inQuery=[inQuery]",
+      hash: "[inHash]",
+    });
+    const response = url.parse(`/${input}?inQuery=${input}#${input}`);
+
+    expect(response.inPath).toBe(output);
+    expect(response.inQuery).toBe(output);
+    expect(response.inHash).toBe(`#${output}`);
+  });
+
+  test("given url with query param that has a different param name than query key, still works as expected", () => {
     const url = createUrl({
-      path: '/',
-      query: 's=[?search]',
-    })
-
-    const response = url.parse('/?s=foo')
-
-    expect(response.search).toBe('foo')
-  })
-})
-
-describe('url assembly', () => {
-  describe('path params', () => {
-    test.each([
-      ['/simple'],
-      [withParams('/simple', {})],
-    ])('given simple route with string path and without params, returns route path', (path) => {
-      const url = createUrl({
-        name: 'simple',
-        path,
-      })
+      path: "/",
+      query: "s=[?search]",
+    });
 
-      const response = url.stringify()
+    const response = url.parse("/?s=foo");
 
-      expect(response).toBe('/simple')
-    })
+    expect(response.search).toBe("foo");
+  });
+});
 
-    test.each([
-      ['/simple/[?simple]'],
-      [withParams('/simple/[?simple]', { simple: String })],
-      [withParams('/simple/[simple]', { simple: withDefault(String, 'abc') })],
-    ])('given route with optional string param NOT provided, returns route Path with string without values interpolated', (path) => {
-      const url = createUrl({
-        name: 'simple',
-        path,
-      })
+describe("url assembly", () => {
+  describe("path params", () => {
+    test.each([["/simple"], [withParams("/simple", {})]])(
+      "given simple route with string path and without params, returns route path",
+      (path) => {
+        const url = createUrl({
+          name: "simple",
+          path,
+        });
 
-      const response = url.stringify()
+        const response = url.stringify();
 
-      expect(response).toBe('/simple/')
-    })
+        expect(response).toBe("/simple");
+      },
+    );
 
     test.each([
-      ['/simple/[?simple]'],
-      [withParams('/simple/[?simple]', { simple: String })],
-    ])('given route with optional string param provided, returns route Path with string with values interpolated', (path) => {
-      const url = createUrl({
-        name: 'simple',
-        path,
-      })
+      ["/simple/[?simple]"],
+      [withParams("/simple/[?simple]", { simple: String })],
+      [withParams("/simple/[simple]", { simple: withDefault(String, "abc") })],
+    ])(
+      "given route with optional string param NOT provided, returns route Path with string without values interpolated",
+      (path) => {
+        const url = createUrl({
+          name: "simple",
+          path,
+        });
+
+        const response = url.stringify();
+
+        expect(response).toBe("/simple/");
+      },
+    );
+
+    test.each([["/simple/[?simple]"], [withParams("/simple/[?simple]", { simple: String })]])(
+      "given route with optional string param provided, returns route Path with string with values interpolated",
+      (path) => {
+        const url = createUrl({
+          name: "simple",
+          path,
+        });
+
+        const response = url.stringify({
+          simple: "ABC",
+        });
+
+        expect(response).toBe("/simple/ABC");
+      },
+    );
+
+    test("given route with default string param provided, returns route Path with string with values interpolated", () => {
+      const url = createUrl({
+        name: "simple",
+        path: withParams("/simple/[simple]", { simple: withDefault(String, "abc") }),
+      });
 
       const response = url.stringify({
-        simple: 'ABC',
-      })
-
-      expect(response).toBe('/simple/ABC')
-    })
-
-    test('given route with default string param provided, returns route Path with string with values interpolated', () => {
-      const url = createUrl({
-        name: 'simple',
-        path: withParams('/simple/[simple]', { simple: withDefault(String, 'abc') }),
-      })
-
-      const response = url.stringify({
-        simple: 'DEF',
-      })
-
-      expect(response).toBe('/simple/DEF')
-    })
+        simple: "DEF",
+      });
+
+      expect(response).toBe("/simple/DEF");
+    });
+
+    test.each([["/simple/[simple]"], [withParams("/simple/[simple]", { simple: String })]])(
+      "given route with required string param NOT provided, throws InvalidRouteParamValueError",
+      (path) => {
+        const url = createUrl({
+          name: "simple",
+          path,
+        });
+
+        expect(() => url.stringify()).toThrowError(InvalidRouteParamValueError);
+      },
+    );
+
+    test.each([["/simple/[simple]"], [withParams("/simple/[simple]", { simple: String })]])(
+      "given route with required string param provided, returns route Path with string with values interpolated",
+      (path) => {
+        const url = createUrl({
+          name: "simple",
+          path,
+        });
+
+        const response = url.stringify({
+          simple: "ABC",
+        });
+
+        expect(response).toBe("/simple/ABC");
+      },
+    );
+  });
+
+  describe("query params", () => {
+    test.each([["simple=abc"], [withParams("simple=abc", {})]])(
+      "given simple route with string query and without params, returns route query",
+      (query) => {
+        const url = createUrl({
+          name: "simple",
+          path: "/",
+          query,
+        });
+
+        const response = url.stringify();
+
+        expect(response).toBe("/?simple=abc");
+      },
+    );
 
     test.each([
-      ['/simple/[simple]'],
-      [withParams('/simple/[simple]', { simple: String })],
-    ])('given route with required string param NOT provided, throws InvalidRouteParamValueError', (path) => {
+      ["simple=[?simple]"],
+      [withParams("simple=[?simple]", { simple: String })],
+      [withParams("simple=[simple]", { simple: withDefault(String, "abc") })],
+    ])("given route with optional param NOT provided, leaves entire key off", (query) => {
       const url = createUrl({
-        name: 'simple',
-        path,
-      })
-
-      expect(() => url.stringify()).toThrowError(InvalidRouteParamValueError)
-    })
-
-    test.each([
-      ['/simple/[simple]'],
-      [withParams('/simple/[simple]', { simple: String })],
-    ])('given route with required string param provided, returns route Path with string with values interpolated', (path) => {
-      const url = createUrl({
-        name: 'simple',
-        path,
-      })
-
-      const response = url.stringify({
-        simple: 'ABC',
-      })
-
-      expect(response).toBe('/simple/ABC')
-    })
-  })
-
-  describe('query params', () => {
-    test.each([
-      ['simple=abc'],
-      [withParams('simple=abc', {})],
-    ])('given simple route with string query and without params, returns route query', (query) => {
-      const url = createUrl({
-        name: 'simple',
-        path: '/',
+        name: "simple",
+        path: "/",
         query,
-      })
+      });
 
-      const response = url.stringify()
+      const response = url.stringify();
 
-      expect(response).toBe('/?simple=abc')
-    })
+      expect(response).toBe("/");
+    });
 
-    test.each([
-      ['simple=[?simple]'],
-      [withParams('simple=[?simple]', { simple: String })],
-      [withParams('simple=[simple]', { simple: withDefault(String, 'abc') })],
-    ])('given route with optional param NOT provided, leaves entire key off', (query) => {
-      const url = createUrl({
-        name: 'simple',
-        path: '/',
-        query,
-      })
+    test.each([["simple=[?simple]"], [withParams("simple=[?simple]", { simple: String })]])(
+      "given route with optional string param provided but empty, returns route Query with string without values interpolated",
+      (query) => {
+        const url = createUrl({
+          name: "simple",
+          path: "/",
+          query,
+        });
 
-      const response = url.stringify()
+        const response = url.stringify({ simple: "" });
 
-      expect(response).toBe('/')
-    })
+        expect(response).toBe("/?simple=");
+      },
+    );
 
-    test.each([
-      ['simple=[?simple]'],
-      [withParams('simple=[?simple]', { simple: String })],
-    ])('given route with optional string param provided but empty, returns route Query with string without values interpolated', (query) => {
-      const url = createUrl({
-        name: 'simple',
-        path: '/',
-        query,
-      })
-
-      const response = url.stringify({ simple: '' })
-
-      expect(response).toBe('/?simple=')
-    })
-
-    test('given route with default string param provided but empty, returns route Query with string without values interpolated', () => {
+    test("given route with default string param provided but empty, returns route Query with string without values interpolated", () => {
       const url = createUrl({
-        name: 'simple',
-        path: '/',
-        query: withParams('simple=[simple]', { simple: withDefault(String, 'abc') }),
-      })
+        name: "simple",
+        path: "/",
+        query: withParams("simple=[simple]", { simple: withDefault(String, "abc") }),
+      });
 
-      const response = url.stringify({ simple: '' })
+      const response = url.stringify({ simple: "" });
 
-      expect(response).toBe('/?simple=')
-    })
+      expect(response).toBe("/?simple=");
+    });
 
-    test.each([
-      ['simple=[?simple]'],
-      [withParams('simple=[?simple]', { simple: String })],
-    ])('given route with optional string param provided, returns route Query with string with values interpolated', (query) => {
-      const url = createUrl({
-        name: 'simple',
-        path: '/',
-        query,
-      })
+    test.each([["simple=[?simple]"], [withParams("simple=[?simple]", { simple: String })]])(
+      "given route with optional string param provided, returns route Query with string with values interpolated",
+      (query) => {
+        const url = createUrl({
+          name: "simple",
+          path: "/",
+          query,
+        });
 
-      const response = url.stringify({
-        simple: 'ABC',
-      })
+        const response = url.stringify({
+          simple: "ABC",
+        });
 
-      expect(response).toBe('/?simple=ABC')
-    })
+        expect(response).toBe("/?simple=ABC");
+      },
+    );
 
-    test('given route with default string param provided, returns route Query with string with values interpolated', () => {
+    test("given route with default string param provided, returns route Query with string with values interpolated", () => {
       const url = createUrl({
-        name: 'simple',
-        path: '/',
-        query: withParams('simple=[simple]', { simple: withDefault(String, 'abc') }),
-      })
+        name: "simple",
+        path: "/",
+        query: withParams("simple=[simple]", { simple: withDefault(String, "abc") }),
+      });
 
       const response = url.stringify({
-        simple: 'DEF',
-      })
+        simple: "DEF",
+      });
 
-      expect(response).toBe('/?simple=DEF')
-    })
+      expect(response).toBe("/?simple=DEF");
+    });
 
-    test.each([
-      ['simple=[simple]'],
-      [withParams('simple=[simple]', { simple: String })],
-    ])('given route with required string param NOT provided, throws InvalidRouteParamValueError', (query) => {
-      const url = createUrl({
-        name: 'simple',
-        path: '/',
-        query,
-      })
+    test.each([["simple=[simple]"], [withParams("simple=[simple]", { simple: String })]])(
+      "given route with required string param NOT provided, throws InvalidRouteParamValueError",
+      (query) => {
+        const url = createUrl({
+          name: "simple",
+          path: "/",
+          query,
+        });
 
-      expect(() => url.stringify()).toThrowError(InvalidRouteParamValueError)
-    })
+        expect(() => url.stringify()).toThrowError(InvalidRouteParamValueError);
+      },
+    );
 
-    test.each([
-      ['simple=[simple]'],
-      [withParams('simple=[simple]', { simple: String })],
-    ])('given route with required string param provided, returns route Query with string with values interpolated', (query) => {
-      const url = createUrl({
-        name: 'simple',
-        path: '/',
-        query,
-      })
+    test.each([["simple=[simple]"], [withParams("simple=[simple]", { simple: String })]])(
+      "given route with required string param provided, returns route Query with string with values interpolated",
+      (query) => {
+        const url = createUrl({
+          name: "simple",
+          path: "/",
+          query,
+        });
 
-      const response = url.stringify({
-        simple: 'ABC',
-      })
+        const response = url.stringify({
+          simple: "ABC",
+        });
 
-      expect(response).toBe('/?simple=ABC')
-    })
+        expect(response).toBe("/?simple=ABC");
+      },
+    );
 
-    test('given route with optional custom param, finds and uses param to set value', () => {
-      const randomValue = Math.floor(Math.random() * 1000)
-      const get = vi.fn()
-      const set = vi.fn().mockReturnValue(randomValue.toString())
-      const myParam = createParam({ get, set })
+    test("given route with optional custom param, finds and uses param to set value", () => {
+      const randomValue = Math.floor(Math.random() * 1000);
+      const get = vi.fn();
+      const set = vi.fn().mockReturnValue(randomValue.toString());
+      const myParam = createParam({ get, set });
 
       const url = createUrl({
-        name: 'simple',
-        path: '/',
-        query: withParams('sort=[?sort]', { sort: myParam }),
-      })
+        name: "simple",
+        path: "/",
+        query: withParams("sort=[?sort]", { sort: myParam }),
+      });
 
-      const response = url.stringify({ sort: 'irrelevant' })
+      const response = url.stringify({ sort: "irrelevant" });
 
-      expect(response).toBe(`/?sort=${randomValue}`)
-    })
+      expect(response).toBe(`/?sort=${randomValue}`);
+    });
 
-    test('given route with query params with different param names than query keys, still works as expected', () => {
+    test("given route with query params with different param names than query keys, still works as expected", () => {
       const url = createUrl({
-        name: 'query-keys',
-        path: '/',
-        query: 's=[?search]',
-      })
+        name: "query-keys",
+        path: "/",
+        query: "s=[?search]",
+      });
 
-      const response = url.stringify({ search: 'foo' })
+      const response = url.stringify({ search: "foo" });
 
-      expect(response).toBe('/?s=foo')
-    })
+      expect(response).toBe("/?s=foo");
+    });
 
-    test('given route with query params defined in a record, returns route Query with string with values interpolated', () => {
+    test("given route with query params defined in a record, returns route Query with string with values interpolated", () => {
       const url = createUrl({
-        name: 'simple',
-        path: '/',
-        query: { s: 'ABC' },
-      })
+        name: "simple",
+        path: "/",
+        query: { s: "ABC" },
+      });
 
-      const response = url.stringify()
+      const response = url.stringify();
 
-      expect(response).toBe('/?s=ABC')
-    })
+      expect(response).toBe("/?s=ABC");
+    });
 
     // todo withDefault doesn't work type-wise
-    test('given route with query params defined in a record, returns route Query with string with values interpolated', () => {
+    test("given route with query params defined in a record, returns route Query with string with values interpolated", () => {
       const url = createUrl({
-        name: 'simple',
-        path: '/',
+        name: "simple",
+        path: "/",
         query: { s: Boolean },
-      })
+      });
 
-      const response = url.stringify({ s: true })
+      const response = url.stringify({ s: true });
 
-      expect(response).toBe('/?s=true')
-    })
+      expect(response).toBe("/?s=true");
+    });
 
-    test('given route with query params defined in a array, returns route Query with string with values interpolated', () => {
+    test("given route with query params defined in a array, returns route Query with string with values interpolated", () => {
       const url = createUrl({
-        name: 'simple',
-        path: '/',
-        query: [['s', 'ABC']],
-      })
+        name: "simple",
+        path: "/",
+        query: [["s", "ABC"]],
+      });
 
-      const response = url.stringify()
+      const response = url.stringify();
 
-      expect(response).toBe('/?s=ABC')
-    })
+      expect(response).toBe("/?s=ABC");
+    });
 
-    test('given route with query params defined in a array, returns route Query with string with values interpolated', () => {
+    test("given route with query params defined in a array, returns route Query with string with values interpolated", () => {
       const url = createUrl({
-        name: 'simple',
-        path: '/',
-        query: [['s', Boolean]],
-      })
+        name: "simple",
+        path: "/",
+        query: [["s", Boolean]],
+      });
 
-      const response = url.stringify({ s: true })
+      const response = url.stringify({ s: true });
 
-      expect(response).toBe('/?s=true')
-    })
-  })
+      expect(response).toBe("/?s=true");
+    });
+  });
 
-  describe('host params', () => {
-    test.each([
-      ['https://kitbag.dev'],
-      [withParams('https://kitbag.dev', {})],
-    ])('given simple route with string host and without params, returns route host', (host) => {
-      const url = createUrl({
-        name: 'simple',
-        path: '/',
-        host,
-      })
+  describe("host params", () => {
+    test.each([["https://kitbag.dev"], [withParams("https://kitbag.dev", {})]])(
+      "given simple route with string host and without params, returns route host",
+      (host) => {
+        const url = createUrl({
+          name: "simple",
+          path: "/",
+          host,
+        });
 
-      const response = url.stringify()
+        const response = url.stringify();
 
-      expect(response).toBe('https://kitbag.dev/')
-    })
+        expect(response).toBe("https://kitbag.dev/");
+      },
+    );
 
     test.each([
-      ['https://[?subdomain]kitbag.dev'],
-      [withParams('https://[?subdomain]kitbag.dev', { subdomain: String })],
-      [withParams('https://[?subdomain]kitbag.dev', { subdomain: withDefault(String, 'abc') })],
-    ])('given route with optional param NOT provided, leaves entire key off', (host) => {
+      ["https://[?subdomain]kitbag.dev"],
+      [withParams("https://[?subdomain]kitbag.dev", { subdomain: String })],
+      [withParams("https://[?subdomain]kitbag.dev", { subdomain: withDefault(String, "abc") })],
+    ])("given route with optional param NOT provided, leaves entire key off", (host) => {
       const url = createUrl({
-        name: 'simple',
-        path: '/',
+        name: "simple",
+        path: "/",
         host,
-      })
+      });
 
-      const response = url.stringify()
+      const response = url.stringify();
 
-      expect(response).toBe('https://kitbag.dev/')
-    })
+      expect(response).toBe("https://kitbag.dev/");
+    });
 
     test.each([
-      ['https://[?subdomain]kitbag.dev'],
-      [withParams('https://[?subdomain]kitbag.dev', { subdomain: String })],
-    ])('given route with optional string param provided, returns route Host with string with values interpolated', (host) => {
-      const url = createUrl({
-        name: 'simple',
-        path: '/',
-        host,
-      })
-
-      const response = url.stringify({
-        subdomain: 'ABC.',
-      })
-
-      expect(response).toBe('https://abc.kitbag.dev/')
-    })
-
-    test('given route with default string param provided, returns route Host with string with values interpolated', () => {
-      const url = createUrl({
-        name: 'simple',
-        path: '/',
-        host: withParams('https://[?subdomain]kitbag.dev', { subdomain: withDefault(String, 'abc.') }),
-      })
+      ["https://[?subdomain]kitbag.dev"],
+      [withParams("https://[?subdomain]kitbag.dev", { subdomain: String })],
+    ])(
+      "given route with optional string param provided, returns route Host with string with values interpolated",
+      (host) => {
+        const url = createUrl({
+          name: "simple",
+          path: "/",
+          host,
+        });
+
+        const response = url.stringify({
+          subdomain: "ABC.",
+        });
+
+        expect(response).toBe("https://abc.kitbag.dev/");
+      },
+    );
+
+    test("given route with default string param provided, returns route Host with string with values interpolated", () => {
+      const url = createUrl({
+        name: "simple",
+        path: "/",
+        host: withParams("https://[?subdomain]kitbag.dev", {
+          subdomain: withDefault(String, "abc."),
+        }),
+      });
 
       const response = url.stringify({
-        subdomain: 'DEF.',
-      })
+        subdomain: "DEF.",
+      });
 
-      expect(response).toBe('https://def.kitbag.dev/')
-    })
+      expect(response).toBe("https://def.kitbag.dev/");
+    });
 
     test.each([
-      ['https://[subdomain]kitbag.dev'],
-      [withParams('https://[subdomain]kitbag.dev', { subdomain: String })],
-    ])('given route with required string param NOT provided, throws InvalidRouteParamValueError', (host) => {
-      const url = createUrl({
-        name: 'simple',
-        path: '/',
-        host,
-      })
-
-      expect(() => url.stringify()).toThrowError(InvalidRouteParamValueError)
-    })
+      ["https://[subdomain]kitbag.dev"],
+      [withParams("https://[subdomain]kitbag.dev", { subdomain: String })],
+    ])(
+      "given route with required string param NOT provided, throws InvalidRouteParamValueError",
+      (host) => {
+        const url = createUrl({
+          name: "simple",
+          path: "/",
+          host,
+        });
+
+        expect(() => url.stringify()).toThrowError(InvalidRouteParamValueError);
+      },
+    );
 
     test.each([
-      ['https://[subdomain]kitbag.dev'],
-      [withParams('https://[subdomain]kitbag.dev', { subdomain: String })],
-    ])('given route with required string param provided, returns route Host with string with values interpolated', (host) => {
-      const url = createUrl({
-        name: 'simple',
-        path: '/',
-        host,
-      })
+      ["https://[subdomain]kitbag.dev"],
+      [withParams("https://[subdomain]kitbag.dev", { subdomain: String })],
+    ])(
+      "given route with required string param provided, returns route Host with string with values interpolated",
+      (host) => {
+        const url = createUrl({
+          name: "simple",
+          path: "/",
+          host,
+        });
+
+        const response = url.stringify({
+          subdomain: "ABC.",
+        });
+
+        expect(response).toBe("https://abc.kitbag.dev/");
+      },
+    );
+  });
+
+  describe("hash params", () => {
+    test.each([["foo"], [withParams("foo", {})]])(
+      "given simple route with string hash and without params, returns route hash",
+      (hash) => {
+        const url = createUrl({
+          name: "simple",
+          path: "/",
+          hash,
+        });
+
+        const response = url.stringify();
+
+        expect(response).toBe("/#foo");
+      },
+    );
 
-      const response = url.stringify({
-        subdomain: 'ABC.',
-      })
-
-      expect(response).toBe('https://abc.kitbag.dev/')
-    })
-  })
-
-  describe('hash params', () => {
     test.each([
-      ['foo'],
-      [withParams('foo', {})],
-    ])('given simple route with string hash and without params, returns route hash', (hash) => {
-      const url = createUrl({
-        name: 'simple',
-        path: '/',
-        hash,
-      })
-
-      const response = url.stringify()
-
-      expect(response).toBe('/#foo')
-    })
-
-    test.each([
-      ['foo[?bar]'],
-      [withParams('foo[?bar]', { bar: String })],
-      [withParams('foo[bar]', { bar: withDefault(String, 'abc') })],
-    ])('given route with optional param NOT provided, returns route hash with string without values interpolated', (hash) => {
-      const url = createUrl({
-        name: 'simple',
-        path: '/',
-        hash,
-      })
-
-      const response = url.stringify()
-
-      expect(response).toBe('/#foo')
-    })
-
-    test.each([
-      ['foo[?bar]'],
-      [withParams('foo[?bar]', { bar: String })],
-    ])('given route with optional string param provided, returns route Hash with string with values interpolated', (hash) => {
-      const url = createUrl({
-        name: 'simple',
-        path: '/',
-        hash,
-      })
-
-      const response = url.stringify({
-        bar: 'ABC.',
-      })
-
-      expect(response).toBe('/#fooABC.')
-    })
-
-    test('given route with default string param provided, returns route Hash with string with values interpolated', () => {
-      const url = createUrl({
-        name: 'simple',
-        path: '/',
-        hash: withParams('foo[bar]', { bar: withDefault(String, 'abc.') }),
-      })
+      ["foo[?bar]"],
+      [withParams("foo[?bar]", { bar: String })],
+      [withParams("foo[bar]", { bar: withDefault(String, "abc") })],
+    ])(
+      "given route with optional param NOT provided, returns route hash with string without values interpolated",
+      (hash) => {
+        const url = createUrl({
+          name: "simple",
+          path: "/",
+          hash,
+        });
+
+        const response = url.stringify();
+
+        expect(response).toBe("/#foo");
+      },
+    );
+
+    test.each([["foo[?bar]"], [withParams("foo[?bar]", { bar: String })]])(
+      "given route with optional string param provided, returns route Hash with string with values interpolated",
+      (hash) => {
+        const url = createUrl({
+          name: "simple",
+          path: "/",
+          hash,
+        });
+
+        const response = url.stringify({
+          bar: "ABC.",
+        });
+
+        expect(response).toBe("/#fooABC.");
+      },
+    );
+
+    test("given route with default string param provided, returns route Hash with string with values interpolated", () => {
+      const url = createUrl({
+        name: "simple",
+        path: "/",
+        hash: withParams("foo[bar]", { bar: withDefault(String, "abc.") }),
+      });
 
       const response = url.stringify({
-        bar: 'DEF.',
-      })
-
-      expect(response).toBe('/#fooDEF.')
-    })
-
-    test.each([
-      ['foo[bar]'],
-      [withParams('foo[bar]', { bar: String })],
-    ])('given route with required string param NOT provided, throws InvalidRouteParamValueError', (hash) => {
-      const url = createUrl({
-        name: 'simple',
-        path: '/',
-        hash,
-      })
-
-      expect(() => url.stringify()).toThrowError(InvalidRouteParamValueError)
-    })
-
-    test.each([
-      ['foo[bar]'],
-      [withParams('foo[bar]', { bar: String })],
-    ])('given route with required string param provided, returns route Hash with string with values interpolated', (hash) => {
-      const url = createUrl({
-        name: 'simple',
-        path: '/',
-        hash,
-      })
-
-      const response = url.stringify({
-        bar: 'ABC',
-      })
-
-      expect(response).toBe('/#fooABC')
-    })
-  })
-
-  test('given route without host that does not start with a forward slash, returns url with forward slash', () => {
+        bar: "DEF.",
+      });
+
+      expect(response).toBe("/#fooDEF.");
+    });
+
+    test.each([["foo[bar]"], [withParams("foo[bar]", { bar: String })]])(
+      "given route with required string param NOT provided, throws InvalidRouteParamValueError",
+      (hash) => {
+        const url = createUrl({
+          name: "simple",
+          path: "/",
+          hash,
+        });
+
+        expect(() => url.stringify()).toThrowError(InvalidRouteParamValueError);
+      },
+    );
+
+    test.each([["foo[bar]"], [withParams("foo[bar]", { bar: String })]])(
+      "given route with required string param provided, returns route Hash with string with values interpolated",
+      (hash) => {
+        const url = createUrl({
+          name: "simple",
+          path: "/",
+          hash,
+        });
+
+        const response = url.stringify({
+          bar: "ABC",
+        });
+
+        expect(response).toBe("/#fooABC");
+      },
+    );
+  });
+
+  test("given route without host that does not start with a forward slash, returns url with forward slash", () => {
     const url = createUrl({
-      name: 'invalid-relative-path',
-      path: 'foo',
-    })
+      name: "invalid-relative-path",
+      path: "foo",
+    });
 
-    const response = url.stringify()
+    const response = url.stringify();
 
-    expect(response).toBe('/foo')
-  })
+    expect(response).toBe("/foo");
+  });
 
-  test('given route with host and path without forward slash, returns forward slash after host', () => {
+  test("given route with host and path without forward slash, returns forward slash after host", () => {
     const url = createUrl({
-      name: 'missing-delimiter-after-host',
-      path: 'foo',
-      host: 'https://kitbag.dev',
-    })
+      name: "missing-delimiter-after-host",
+      path: "foo",
+      host: "https://kitbag.dev",
+    });
 
-    const response = url.stringify()
+    const response = url.stringify();
 
-    expect(response).toBe('https://kitbag.dev/foo')
-  })
+    expect(response).toBe("https://kitbag.dev/foo");
+  });
 
-  test('given route with host and path with excess forward slashes, returns forward slash after host', () => {
+  test("given route with host and path with excess forward slashes, returns forward slash after host", () => {
     const url = createUrl({
-      name: 'extra-delimiter-after-host',
-      path: '/foo',
-      host: 'https://kitbag.dev/',
-    })
+      name: "extra-delimiter-after-host",
+      path: "/foo",
+      host: "https://kitbag.dev/",
+    });
 
-    const response = url.stringify()
+    const response = url.stringify();
 
-    expect(response).toBe('https://kitbag.dev/foo')
-  })
-})
+    expect(response).toBe("https://kitbag.dev/foo");
+  });
+});
diff --git a/src/services/getInitialUrl.browser.spec.ts b/src/services/getInitialUrl.browser.spec.ts
index b552cc4b..f276ede2 100644
--- a/src/services/getInitialUrl.browser.spec.ts
+++ b/src/services/getInitialUrl.browser.spec.ts
@@ -1,20 +1,20 @@
-import { expect, test, vi } from 'vitest'
-import { getInitialUrl } from '@/services/getInitialUrl'
-import { random } from '@/utilities/testHelpers'
+import { expect, test, vi } from "vite-plus/test";
+import { getInitialUrl } from "@/services/getInitialUrl";
+import { random } from "@/utilities/testHelpers";
 
-test('given value for initial route, returns value', () => {
-  const initialRoute = random.number().toString()
+test("given value for initial route, returns value", () => {
+  const initialRoute = random.number().toString();
 
-  const response = getInitialUrl(initialRoute)
+  const response = getInitialUrl(initialRoute);
 
-  expect(response).toBe(initialRoute)
-})
+  expect(response).toBe(initialRoute);
+});
 
-test('defaults to window.location without protocol or host', () => {
-  const initialRoute = 'https://localhost:5173/home?with=search#foo'
-  vi.stubGlobal('location', initialRoute)
+test("defaults to window.location without protocol or host", () => {
+  const initialRoute = "https://localhost:5173/home?with=search#foo";
+  vi.stubGlobal("location", initialRoute);
 
-  const response = getInitialUrl()
+  const response = getInitialUrl();
 
-  expect(response).toBe(initialRoute)
-})
+  expect(response).toBe(initialRoute);
+});
diff --git a/src/services/getInitialUrl.spec.ts b/src/services/getInitialUrl.spec.ts
index af03a023..7ffea4b5 100644
--- a/src/services/getInitialUrl.spec.ts
+++ b/src/services/getInitialUrl.spec.ts
@@ -1,6 +1,8 @@
-import { expect, test } from 'vitest'
-import { getInitialUrl } from '@/services/getInitialUrl'
+import { expect, test } from "vite-plus/test";
+import { getInitialUrl } from "@/services/getInitialUrl";
 
-test('throws error if initial route is not set', () => {
-  expect(() => getInitialUrl()).toThrowError('initialUrl must be set if window.location is unavailable')
-})
+test("throws error if initial route is not set", () => {
+  expect(() => getInitialUrl()).toThrowError(
+    "initialUrl must be set if window.location is unavailable",
+  );
+});
diff --git a/src/services/getMatchesForUrl.spec.ts b/src/services/getMatchesForUrl.spec.ts
index 5fa2a415..13927d4a 100644
--- a/src/services/getMatchesForUrl.spec.ts
+++ b/src/services/getMatchesForUrl.spec.ts
@@ -1,167 +1,163 @@
-import { describe, expect, test } from 'vitest'
-import { createRoute } from '@/services/createRoute'
-import { getMatchForUrl } from '@/services/getMatchesForUrl'
-import { component } from '@/utilities/testHelpers'
+import { describe, expect, test } from "vite-plus/test";
+import { createRoute } from "@/services/createRoute";
+import { getMatchForUrl } from "@/services/getMatchesForUrl";
+import { component } from "@/utilities/testHelpers";
 
-test('given path WITHOUT params, returns match', () => {
+test("given path WITHOUT params, returns match", () => {
   const parent = createRoute({
-    name: 'parent',
-    path: '/parent',
-  })
+    name: "parent",
+    path: "/parent",
+  });
 
   const child = createRoute({
     parent: parent,
-    name: 'parent.child',
-    path: '/child',
-  })
+    name: "parent.child",
+    path: "/child",
+  });
 
   const grandchild = createRoute({
     parent: child,
-    name: 'parent.child.grandchild',
-    path: '/grandchild',
+    name: "parent.child.grandchild",
+    path: "/grandchild",
     component,
-  })
+  });
 
-  const routes = [parent, child, grandchild]
+  const routes = [parent, child, grandchild];
 
-  const match = getMatchForUrl(routes, '/parent/child/grandchild')
+  const match = getMatchForUrl(routes, "/parent/child/grandchild");
 
-  expect(match).toBeDefined()
-  expect(match?.name).toBe('parent.child.grandchild')
-  expect(match?.matched.name).toBe('parent.child.grandchild')
-})
+  expect(match).toBeDefined();
+  expect(match?.name).toBe("parent.child.grandchild");
+  expect(match?.matched.name).toBe("parent.child.grandchild");
+});
 
-test('given path to unnamed parent, without option to get to leaf, returns no matches', () => {
+test("given path to unnamed parent, without option to get to leaf, returns no matches", () => {
   const unnamedParent = createRoute({
-    path: '/unnamed',
-  })
+    path: "/unnamed",
+  });
 
   const unnamedChild = createRoute({
     parent: unnamedParent,
-    path: '/unnamed-child/[child-id]',
-  })
+    path: "/unnamed-child/[child-id]",
+  });
 
   const namedGrandchild = createRoute({
     parent: unnamedChild,
-    path: '/named-grandchild',
+    path: "/named-grandchild",
     component,
-  })
+  });
 
-  const routes = [unnamedParent, unnamedChild, namedGrandchild]
+  const routes = [unnamedParent, unnamedChild, namedGrandchild];
 
-  const match = getMatchForUrl(routes, '/unnamed')
+  const match = getMatchForUrl(routes, "/unnamed");
 
-  expect(match).toBeUndefined()
-})
+  expect(match).toBeUndefined();
+});
 
-test('given path to unnamed  parent, with option to get to leaf, returns available leaf', () => {
+test("given path to unnamed  parent, with option to get to leaf, returns available leaf", () => {
   const unnamedParent = createRoute({
-    path: '/unnamed',
-  })
+    path: "/unnamed",
+  });
 
   const unnamedChildRoot = createRoute({
     parent: unnamedParent,
-    name: 'child-root',
+    name: "child-root",
     component,
-  })
+  });
 
-  const routes = [unnamedChildRoot, unnamedParent]
-  const match = getMatchForUrl(routes, '/unnamed')
+  const routes = [unnamedChildRoot, unnamedParent];
+  const match = getMatchForUrl(routes, "/unnamed");
 
-  expect(match).toBeDefined()
-  expect(match?.name).toBe('child-root')
-})
+  expect(match).toBeDefined();
+  expect(match?.name).toBe("child-root");
+});
 
-test('given route with simple string param WITHOUT value present, returns no matches', () => {
+test("given route with simple string param WITHOUT value present, returns no matches", () => {
   const route = createRoute({
-    name: 'simple-params',
-    path: '/simple/[simple]',
+    name: "simple-params",
+    path: "/simple/[simple]",
     component,
-  })
-  const response = getMatchForUrl([route], '/simple/')
+  });
+  const response = getMatchForUrl([route], "/simple/");
 
-  expect(response).toBeUndefined()
-})
+  expect(response).toBeUndefined();
+});
 
-test('given route with simple string query param WITHOUT value present, returns no matches', () => {
+test("given route with simple string query param WITHOUT value present, returns no matches", () => {
   const route = createRoute({
-    name: 'simple-params',
-    path: '/missing',
-    query: 'simple=[simple]',
+    name: "simple-params",
+    path: "/missing",
+    query: "simple=[simple]",
     component,
-  })
+  });
 
-  const response = getMatchForUrl([route], '/missing?without=params')
+  const response = getMatchForUrl([route], "/missing?without=params");
 
-  expect(response).toBeUndefined()
-})
+  expect(response).toBeUndefined();
+});
 
-test('given route with equal matches, returns first match', () => {
+test("given route with equal matches, returns first match", () => {
   const firstRoute = createRoute({
-    name: 'first-route',
-    path: '/',
+    name: "first-route",
+    path: "/",
     component,
-  })
+  });
 
   const secondRoute = createRoute({
     parent: firstRoute,
-    name: 'second-route',
+    name: "second-route",
     component,
-  })
+  });
 
   const thirdRoute = createRoute({
-    name: 'third-route',
-    path: '/',
+    name: "third-route",
+    path: "/",
     component,
-  })
+  });
 
-  const match = getMatchForUrl([
-    firstRoute,
-    secondRoute,
-    thirdRoute,
-  ], '/')
+  const match = getMatchForUrl([firstRoute, secondRoute, thirdRoute], "/");
 
-  expect(match).toBeDefined()
-  expect(match?.name).toBe('first-route')
-})
+  expect(match).toBeDefined();
+  expect(match?.name).toBe("first-route");
+});
 
-test('given url with query params that include params and extra values, retains extra query params', () => {
+test("given url with query params that include params and extra values, retains extra query params", () => {
   const route = createRoute({
-    name: 'query-params',
-    path: '/',
-    query: 'foo=[param]',
+    name: "query-params",
+    path: "/",
+    query: "foo=[param]",
     component,
-  })
+  });
 
-  const match = getMatchForUrl([route], '/?extra=42&foo=1')
+  const match = getMatchForUrl([route], "/?extra=42&foo=1");
 
-  expect(match).toBeDefined()
-  expect(match?.query.toString()).toBe('foo=1&extra=42')
-})
+  expect(match).toBeDefined();
+  expect(match?.query.toString()).toBe("foo=1&extra=42");
+});
 
-describe('trailing slashes', () => {
-  test('given route without trailing slash, does not match url with trailing slash', () => {
+describe("trailing slashes", () => {
+  test("given route without trailing slash, does not match url with trailing slash", () => {
     const route = createRoute({
-      name: 'no-trailing-slash',
-      path: '/parent/child',
+      name: "no-trailing-slash",
+      path: "/parent/child",
       component,
-    })
+    });
 
-    const match = getMatchForUrl([route], '/parent/child/')
+    const match = getMatchForUrl([route], "/parent/child/");
 
-    expect(match).toBeUndefined()
-  })
+    expect(match).toBeUndefined();
+  });
 
-  test('given route with trailing slash, matches url without trailing slash', () => {
+  test("given route with trailing slash, matches url without trailing slash", () => {
     const route = createRoute({
-      name: 'with-trailing-slash',
-      path: '/parent/child/',
+      name: "with-trailing-slash",
+      path: "/parent/child/",
       component,
-    })
+    });
 
-    const match = getMatchForUrl([route], '/parent/child')
+    const match = getMatchForUrl([route], "/parent/child");
 
-    expect(match).toBeDefined()
-    expect(match?.name).toBe('with-trailing-slash')
-  })
-})
+    expect(match).toBeDefined();
+    expect(match?.name).toBe("with-trailing-slash");
+  });
+});
diff --git a/src/services/getRouteHooks.spec.ts b/src/services/getRouteHooks.spec.ts
index 9cf10ecc..03d572af 100644
--- a/src/services/getRouteHooks.spec.ts
+++ b/src/services/getRouteHooks.spec.ts
@@ -1,58 +1,66 @@
-import { expect, test, vi } from 'vitest'
-import { getBeforeHooksFromRoutes } from '@/services/getRouteHooks'
-import { createRoute } from './createRoute'
-import { createResolvedRoute } from './createResolvedRoute'
-import { getHooks } from '@/types/hooks'
+import { expect, test, vi } from "vite-plus/test";
+import { getBeforeHooksFromRoutes } from "@/services/getRouteHooks";
+import { createRoute } from "./createRoute";
+import { createResolvedRoute } from "./createResolvedRoute";
+import { getHooks } from "@/types/hooks";
 
-test('given two ResolvedRoutes returns before timing hooks in correct order', () => {
+test("given two ResolvedRoutes returns before timing hooks in correct order", () => {
   const parent = createRoute({
-    name: 'parentA',
-  })
+    name: "parentA",
+  });
 
-  parent.onBeforeRouteUpdate(vi.fn())
+  parent.onBeforeRouteUpdate(vi.fn());
 
   const childA = createRoute({
-    name: 'childA',
+    name: "childA",
     parent: parent,
-  })
+  });
 
-  childA.onBeforeRouteEnter(vi.fn())
-  childA.onBeforeRouteUpdate(vi.fn())
-  childA.onBeforeRouteLeave(vi.fn())
+  childA.onBeforeRouteEnter(vi.fn());
+  childA.onBeforeRouteUpdate(vi.fn());
+  childA.onBeforeRouteLeave(vi.fn());
 
   const grandchildA = createRoute({
-    name: 'grandchildA',
+    name: "grandchildA",
     parent: childA,
-  })
+  });
 
-  grandchildA.onBeforeRouteEnter(vi.fn())
-  grandchildA.onBeforeRouteUpdate(vi.fn())
-  grandchildA.onBeforeRouteLeave(vi.fn())
+  grandchildA.onBeforeRouteEnter(vi.fn());
+  grandchildA.onBeforeRouteUpdate(vi.fn());
+  grandchildA.onBeforeRouteLeave(vi.fn());
 
   const childB = createRoute({
-    name: 'childB',
+    name: "childB",
     parent: parent,
-  })
+  });
 
-  childB.onBeforeRouteEnter(vi.fn())
-  childB.onBeforeRouteUpdate(vi.fn())
-  childB.onBeforeRouteLeave(vi.fn())
+  childB.onBeforeRouteEnter(vi.fn());
+  childB.onBeforeRouteUpdate(vi.fn());
+  childB.onBeforeRouteLeave(vi.fn());
 
   const grandchildB = createRoute({
-    name: 'grandchildB',
+    name: "grandchildB",
     parent: childB,
-  })
+  });
 
-  grandchildB.onBeforeRouteEnter(vi.fn())
-  grandchildB.onBeforeRouteUpdate(vi.fn())
-  grandchildB.onBeforeRouteLeave(vi.fn())
+  grandchildB.onBeforeRouteEnter(vi.fn());
+  grandchildB.onBeforeRouteUpdate(vi.fn());
+  grandchildB.onBeforeRouteLeave(vi.fn());
 
-  const to = createResolvedRoute(grandchildA, {})
-  const from = createResolvedRoute(grandchildB, {})
+  const to = createResolvedRoute(grandchildA, {});
+  const from = createResolvedRoute(grandchildB, {});
 
-  const hooks = getBeforeHooksFromRoutes(to, from)
+  const hooks = getBeforeHooksFromRoutes(to, from);
 
-  expect(Array.from(hooks.onBeforeRouteEnter)).toMatchObject([...Array.from(getHooks(childA).at(-1)?.onBeforeRouteEnter ?? []), ...Array.from(getHooks(grandchildA).at(-1)?.onBeforeRouteEnter ?? [])])
-  expect(Array.from(hooks.onBeforeRouteUpdate)).toMatchObject([...Array.from(getHooks(parent).at(-1)?.onBeforeRouteUpdate ?? [])])
-  expect(Array.from(hooks.onBeforeRouteLeave)).toMatchObject([...Array.from(getHooks(childB).at(-1)?.onBeforeRouteLeave ?? []), ...Array.from(getHooks(grandchildB).at(-1)?.onBeforeRouteLeave ?? [])])
-})
+  expect(Array.from(hooks.onBeforeRouteEnter)).toMatchObject([
+    ...Array.from(getHooks(childA).at(-1)?.onBeforeRouteEnter ?? []),
+    ...Array.from(getHooks(grandchildA).at(-1)?.onBeforeRouteEnter ?? []),
+  ]);
+  expect(Array.from(hooks.onBeforeRouteUpdate)).toMatchObject(
+    Array.from(getHooks(parent).at(-1)?.onBeforeRouteUpdate ?? []),
+  );
+  expect(Array.from(hooks.onBeforeRouteLeave)).toMatchObject([
+    ...Array.from(getHooks(childB).at(-1)?.onBeforeRouteLeave ?? []),
+    ...Array.from(getHooks(grandchildB).at(-1)?.onBeforeRouteLeave ?? []),
+  ]);
+});
diff --git a/src/services/getRoutesForRouter.spec.ts b/src/services/getRoutesForRouter.spec.ts
index bb532d8a..08921871 100644
--- a/src/services/getRoutesForRouter.spec.ts
+++ b/src/services/getRoutesForRouter.spec.ts
@@ -1,125 +1,101 @@
-import { describe, expect, test } from 'vitest'
-import { createRoute } from '@/services/createRoute'
-import { getRoutesForRouter } from '@/services/getRoutesForRouter'
-import { component } from '@/utilities'
-import { createRouterPlugin } from '@/services/createRouterPlugin'
+import { describe, expect, test } from "vite-plus/test";
+import { createRoute } from "@/services/createRoute";
+import { getRoutesForRouter } from "@/services/getRoutesForRouter";
+import { component } from "@/utilities";
+import { createRouterPlugin } from "@/services/createRouterPlugin";
 
-test('given routes without names, removes routes from response', () => {
-  const foo = createRoute({ name: 'foo' })
+test("given routes without names, removes routes from response", () => {
+  const foo = createRoute({ name: "foo" });
 
   const { routes } = getRoutesForRouter([
     foo,
-    createRoute({ component, name: '' }),
+    createRoute({ component, name: "" }),
     createRoute({ component, name: undefined }),
     createRoute({ component }),
-  ])
+  ]);
 
-  expect(routes).toMatchObject([foo])
-})
+  expect(routes).toMatchObject([foo]);
+});
 
-test('given named routes inside plugins, includes them in the response', () => {
-  const pluginFoo = createRoute({ name: 'plugin-foo' })
+test("given named routes inside plugins, includes them in the response", () => {
+  const pluginFoo = createRoute({ name: "plugin-foo" });
   const plugins = [
     createRouterPlugin({
       routes: [
         pluginFoo,
-        createRoute({ name: '' }),
+        createRoute({ name: "" }),
         createRoute({ name: undefined }),
         createRoute({ component }),
       ],
     }),
-  ]
+  ];
 
-  const { routes } = getRoutesForRouter([], plugins)
+  const { routes } = getRoutesForRouter([], plugins);
 
-  expect(routes).toMatchObject([pluginFoo])
-})
+  expect(routes).toMatchObject([pluginFoo]);
+});
 
-test('given named routes inside route context, includes them in the response', () => {
-  const relatedRoute = createRoute({ name: 'related' })
-  const fooRoute = createRoute({ name: 'foo', context: [relatedRoute] })
-  const barRoute = createRoute({ name: 'bar', context: [relatedRoute] })
-  const zooRoute = createRoute({ name: 'zoo', context: [relatedRoute] })
+test("given named routes inside route context, includes them in the response", () => {
+  const relatedRoute = createRoute({ name: "related" });
+  const fooRoute = createRoute({ name: "foo", context: [relatedRoute] });
+  const barRoute = createRoute({ name: "bar", context: [relatedRoute] });
+  const zooRoute = createRoute({ name: "zoo", context: [relatedRoute] });
   const plugins = [
     createRouterPlugin({
-      routes: [
-        fooRoute,
-        barRoute,
-        zooRoute,
-      ],
+      routes: [fooRoute, barRoute, zooRoute],
     }),
-  ]
+  ];
 
-  const { routes } = getRoutesForRouter([], plugins)
+  const { routes } = getRoutesForRouter([], plugins);
 
-  expect(routes).toMatchObject([
-    fooRoute,
-    relatedRoute,
-    barRoute,
-    zooRoute,
-  ])
-})
+  expect(routes).toMatchObject([fooRoute, relatedRoute, barRoute, zooRoute]);
+});
 
-test('given named routes inside route context of plugin routes, includes them in the response', () => {
-  const relatedRoute = createRoute({ name: 'related' })
-  const fooRoute = createRoute({ name: 'foo', context: [relatedRoute] })
-  const barRoute = createRoute({ name: 'bar', context: [relatedRoute] })
-  const zooRoute = createRoute({ name: 'zoo', context: [relatedRoute] })
+test("given named routes inside route context of plugin routes, includes them in the response", () => {
+  const relatedRoute = createRoute({ name: "related" });
+  const fooRoute = createRoute({ name: "foo", context: [relatedRoute] });
+  const barRoute = createRoute({ name: "bar", context: [relatedRoute] });
+  const zooRoute = createRoute({ name: "zoo", context: [relatedRoute] });
 
-  const { routes } = getRoutesForRouter([
-    fooRoute,
-    barRoute,
-    zooRoute,
-  ])
-
-  expect(routes).toMatchObject([
-    fooRoute,
-    relatedRoute,
-    barRoute,
-    zooRoute,
-  ])
-})
-
-test('return routes sorted by depth', () => {
-  const routeA = createRoute({ name: 'a' })
-  const routeB = createRoute({ name: 'b', parent: routeA })
-  const routeC = createRoute({ name: 'c', parent: routeB })
-  const routeD = createRoute({ name: 'd', parent: routeA })
-  const routeE = createRoute({ name: 'e' })
-
-  const { routes } = getRoutesForRouter([routeA, routeB, routeC, routeD, routeE])
-
-  expect(routes.map((route) => route.name)).toMatchObject([
-    'c',
-    'b',
-    'd',
-    'a',
-    'e',
-  ])
-})
-
-describe('getRouteByName', () => {
-  test('circular context is ignored', () => {
-    const routeA = createRoute({ name: 'a' })
-    const routeB = createRoute({ name: 'b', context: [routeA] })
+  const { routes } = getRoutesForRouter([fooRoute, barRoute, zooRoute]);
+
+  expect(routes).toMatchObject([fooRoute, relatedRoute, barRoute, zooRoute]);
+});
+
+test("return routes sorted by depth", () => {
+  const routeA = createRoute({ name: "a" });
+  const routeB = createRoute({ name: "b", parent: routeA });
+  const routeC = createRoute({ name: "c", parent: routeB });
+  const routeD = createRoute({ name: "d", parent: routeA });
+  const routeE = createRoute({ name: "e" });
+
+  const { routes } = getRoutesForRouter([routeA, routeB, routeC, routeD, routeE]);
+
+  expect(routes.map((route) => route.name)).toMatchObject(["c", "b", "d", "a", "e"]);
+});
+
+describe("getRouteByName", () => {
+  test("circular context is ignored", () => {
+    const routeA = createRoute({ name: "a" });
+    const routeB = createRoute({ name: "b", context: [routeA] });
 
     // @ts-expect-error - you cannot actually do this
-    routeA.context.push(routeB)
-    routeB.context.push(routeA)
+    routeA.context.push(routeB);
+    routeB.context.push(routeA);
 
-    expect(() => getRoutesForRouter([routeA, routeB])).not.toThrow()
-  })
+    expect(() => getRoutesForRouter([routeA, routeB])).not.toThrow();
+  });
 
-  test('returns the route by name', () => {
-    const route = createRoute({ name: 'foo' })
-    const { getRouteByName } = getRoutesForRouter([route])
+  test("returns the route by name", () => {
+    const route = createRoute({ name: "foo" });
+    const { getRouteByName } = getRoutesForRouter([route]);
 
-    expect(getRouteByName('foo')).toBe(route)
-  })
+    expect(getRouteByName("foo")).toBe(route);
+  });
 
-  test('getRouteByName returns undefined if the route is not found', () => {
-    const { getRouteByName } = getRoutesForRouter([])
+  test("getRouteByName returns undefined if the route is not found", () => {
+    const { getRouteByName } = getRoutesForRouter([]);
 
-    expect(getRouteByName('foo')).toBeUndefined()
-  })
-})
+    expect(getRouteByName("foo")).toBeUndefined();
+  });
+});
diff --git a/src/services/getRoutesForRouter.ts b/src/services/getRoutesForRouter.ts
index b5f71f9c..bb97c3ee 100644
--- a/src/services/getRoutesForRouter.ts
+++ b/src/services/getRoutesForRouter.ts
@@ -1,11 +1,18 @@
-import { isRoute, Route, RouteInternal, Routes } from '@/types/route'
-import { RouterPlugin } from '@/types/routerPlugin'
-import { DuplicateNamesError } from '@/errors/duplicateNamesError'
-import { isNamedRoute } from '@/utilities/isNamedRoute'
-import { insertBaseRoute } from '@/services/insertBaseRoute'
-import { BUILT_IN_REJECTION_TYPES, BuiltInRejectionType, isRejection, Rejection, RejectionInternal, Rejections } from '@/types/rejection'
-import { RouterOptions } from '@/types/router'
-import { createRejection } from '@/services/createRejection'
+import { isRoute, Route, RouteInternal, Routes } from "@/types/route";
+import { RouterPlugin } from "@/types/routerPlugin";
+import { DuplicateNamesError } from "@/errors/duplicateNamesError";
+import { isNamedRoute } from "@/utilities/isNamedRoute";
+import { insertBaseRoute } from "@/services/insertBaseRoute";
+import {
+  BUILT_IN_REJECTION_TYPES,
+  BuiltInRejectionType,
+  isRejection,
+  Rejection,
+  RejectionInternal,
+  Rejections,
+} from "@/types/rejection";
+import { RouterOptions } from "@/types/router";
+import { createRejection } from "@/services/createRejection";
 
 /**
  * Takes in routes and plugins and returns a list of routes with the base route inserted if provided.
@@ -13,96 +20,97 @@ import { createRejection } from '@/services/createRejection'
  *
  * @throws {DuplicateNamesError} If there are duplicate names in the routes.
  */
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-export function getRoutesForRouter(routes: Routes | Routes[], plugins: RouterPlugin[] = [], options: RouterOptions = {}) {
-  const routerRoutes = new Map<string, Route & RouteInternal>()
-  const routerRejections = new Map<string, (Rejection & RejectionInternal)>()
+// oxlint-disable-next-line @typescript-eslint/explicit-function-return-type
+export function getRoutesForRouter(
+  routes: Routes | Routes[],
+  plugins: RouterPlugin[] = [],
+  options: RouterOptions = {},
+) {
+  const routerRoutes = new Map<string, Route & RouteInternal>();
+  const routerRejections = new Map<string, Rejection & RejectionInternal>();
 
-  const allRoutes = [
-    ...routes,
-    ...plugins.map((plugin) => plugin.routes),
-  ]
+  const allRoutes = [...routes, ...plugins.map((plugin) => plugin.routes)];
 
   const allRejections = [
     ...BUILT_IN_REJECTION_TYPES.map((type) => createRejection({ type })),
-    ...options.rejections ?? [],
+    ...(options.rejections ?? []),
     ...plugins.map((plugin) => plugin.rejections),
-  ]
+  ];
 
   function addRoute(route: Route): void {
     if (!isRoute(route) || !isNamedRoute(route)) {
-      return
+      return;
     }
 
-    const existingRouteByName = routerRoutes.get(route.name)
+    const existingRouteByName = routerRoutes.get(route.name);
 
     if (existingRouteByName && existingRouteByName.id !== route.id) {
-      throw new DuplicateNamesError(route.name)
+      throw new DuplicateNamesError(route.name);
     }
 
     if (existingRouteByName && existingRouteByName.id === route.id) {
-      return
+      return;
     }
 
-    routerRoutes.set(route.name, insertBaseRoute(route, options.base))
+    routerRoutes.set(route.name, insertBaseRoute(route, options.base));
 
     for (const context of route.context) {
       if (isRoute(context)) {
-        addRoute(context)
+        addRoute(context);
       }
 
       if (isRejection(context)) {
-        addRejection(context)
+        addRejection(context);
       }
     }
   }
 
   function addRejection(rejection: Rejection): void {
     if (!isRejection(rejection)) {
-      return
+      return;
     }
 
-    routerRejections.set(rejection.type, rejection)
+    routerRejections.set(rejection.type, rejection);
   }
 
   function addRoutes(routes: Routes): void {
     for (const route of routes) {
-      addRoute(route)
+      addRoute(route);
     }
   }
 
   function addRejections(rejections: Rejections): void {
     for (const rejection of rejections) {
-      addRejection(rejection)
+      addRejection(rejection);
     }
   }
 
   for (const route of allRoutes) {
     if (isRoutes(route)) {
-      addRoutes(route)
-      continue
+      addRoutes(route);
+      continue;
     }
 
-    addRoute(route)
+    addRoute(route);
   }
 
   for (const rejection of allRejections) {
     if (isRejections(rejection)) {
-      addRejections(rejection)
-      continue
+      addRejections(rejection);
+      continue;
     }
 
-    addRejection(rejection)
+    addRejection(rejection);
   }
 
   function getRouteByName(type: string): Route | undefined {
-    return routerRoutes.get(type)
+    return routerRoutes.get(type);
   }
 
-  function getRejectionByType(type: BuiltInRejectionType): (Rejection & RejectionInternal)
-  function getRejectionByType(type: string): (Rejection & RejectionInternal) | undefined
+  function getRejectionByType(type: BuiltInRejectionType): Rejection & RejectionInternal;
+  function getRejectionByType(type: string): (Rejection & RejectionInternal) | undefined;
   function getRejectionByType(type: string): (Rejection & RejectionInternal) | undefined {
-    return routerRejections.get(type)
+    return routerRejections.get(type);
   }
 
   return {
@@ -110,17 +118,20 @@ export function getRoutesForRouter(routes: Routes | Routes[], plugins: RouterPlu
     rejections: Array.from(routerRejections.values()),
     getRouteByName,
     getRejectionByType,
-  }
+  };
 }
 
 function isRoutes(routes: Routes | Route): routes is Routes {
-  return Array.isArray(routes)
+  return Array.isArray(routes);
 }
 
 function isRejections(rejections: Rejections | Rejection): rejections is Rejections {
-  return Array.isArray(rejections)
+  return Array.isArray(rejections);
 }
 
-function sortByDepthDescending(aRoute: Route & RouteInternal, bRoute: Route & RouteInternal): number {
-  return bRoute.depth - aRoute.depth
+function sortByDepthDescending(
+  aRoute: Route & RouteInternal,
+  bRoute: Route & RouteInternal,
+): number {
+  return bRoute.depth - aRoute.depth;
 }
diff --git a/src/services/history.browser.spec.ts b/src/services/history.browser.spec.ts
index 973530ac..9473ce7a 100644
--- a/src/services/history.browser.spec.ts
+++ b/src/services/history.browser.spec.ts
@@ -1,144 +1,152 @@
-import { BrowserHistory, createBrowserHistory, createHashHistory, createMemoryHistory, HashHistory, MemoryHistory } from '@/services/history'
-import { afterEach, beforeEach, describe, expect, test } from 'vitest'
-
-describe('a browser history', () => {
-  let history: BrowserHistory
+import {
+  BrowserHistory,
+  createBrowserHistory,
+  createHashHistory,
+  createMemoryHistory,
+  HashHistory,
+  MemoryHistory,
+} from "@/services/history";
+import { afterEach, beforeEach, describe, expect, test } from "vite-plus/test";
+
+describe("a browser history", () => {
+  let history: BrowserHistory;
   beforeEach(() => {
     // @ts-expect-error - copied test from history
-    window.history.replaceState(null, null, '/')
-    history = createBrowserHistory()
-  })
+    window.history.replaceState(null, null, "/");
+    history = createBrowserHistory();
+  });
 
-  test('knows how to create hrefs from location objects', () => {
+  test("knows how to create hrefs from location objects", () => {
     const href = history.createHref({
-      pathname: '/the/path',
-      search: '?the=query',
-      hash: '#the-hash',
-    })
+      pathname: "/the/path",
+      search: "?the=query",
+      hash: "#the-hash",
+    });
 
-    expect(href).toEqual('/the/path?the=query#the-hash')
-  })
+    expect(href).toEqual("/the/path?the=query#the-hash");
+  });
 
-  test('knows how to create hrefs from strings', () => {
-    const href = history.createHref('/the/path?the=query#the-hash')
-    expect(href).toEqual('/the/path?the=query#the-hash')
-  })
+  test("knows how to create hrefs from strings", () => {
+    const href = history.createHref("/the/path?the=query#the-hash");
+    expect(href).toEqual("/the/path?the=query#the-hash");
+  });
 
-  test('does not encode the generated path', () => {
+  test("does not encode the generated path", () => {
     const encodedHref = history.createHref({
-      pathname: '/%23abc',
-    })
-    expect(encodedHref).toEqual('/%23abc')
+      pathname: "/%23abc",
+    });
+    expect(encodedHref).toEqual("/%23abc");
 
     const unencodedHref = history.createHref({
-      pathname: '/#abc',
-    })
-    expect(unencodedHref).toEqual('/#abc')
-  })
-})
-
-describe('a hash history on a page with a <base> tag', () => {
-  let history: HashHistory, base: HTMLBaseElement
+      pathname: "/#abc",
+    });
+    expect(unencodedHref).toEqual("/#abc");
+  });
+});
+
+describe("a hash history on a page with a <base> tag", () => {
+  let history: HashHistory, base: HTMLBaseElement;
   beforeEach(() => {
-    if (window.location.hash !== '#/') {
-      window.location.hash = '/'
+    if (window.location.hash !== "#/") {
+      window.location.hash = "/";
     }
 
-    base = document.createElement('base')
-    base.setAttribute('href', '/prefix')
+    base = document.createElement("base");
+    base.setAttribute("href", "/prefix");
 
-    document.head.appendChild(base)
+    document.head.appendChild(base);
 
-    history = createHashHistory()
-  })
+    history = createHashHistory();
+  });
 
   afterEach(() => {
-    document.head.removeChild(base)
-  })
+    document.head.removeChild(base);
+  });
 
-  test('knows how to create hrefs', () => {
-    const hashIndex = window.location.href.indexOf('#')
-    const upToHash = hashIndex === -1 ? window.location.href : window.location.href.slice(0, hashIndex)
+  test("knows how to create hrefs", () => {
+    const hashIndex = window.location.href.indexOf("#");
+    const upToHash =
+      hashIndex === -1 ? window.location.href : window.location.href.slice(0, hashIndex);
 
     const href = history.createHref({
-      pathname: '/the/path',
-      search: '?the=query',
-      hash: '#the-hash',
-    })
+      pathname: "/the/path",
+      search: "?the=query",
+      hash: "#the-hash",
+    });
 
-    expect(href).toEqual(upToHash + '#/the/path?the=query#the-hash')
-  })
-})
+    expect(href).toEqual(upToHash + "#/the/path?the=query#the-hash");
+  });
+});
 
-describe('a hash history', () => {
-  let history: HashHistory
+describe("a hash history", () => {
+  let history: HashHistory;
   beforeEach(() => {
-    window.history.replaceState(null, null as any as string, '#/') // FIXME: type
-    history = createHashHistory()
-  })
+    window.history.replaceState(null, null as any as string, "#/"); // FIXME: type
+    history = createHashHistory();
+  });
 
-  test('knows how to create hrefs from location objects', () => {
+  test("knows how to create hrefs from location objects", () => {
     const href = history.createHref({
-      pathname: '/the/path',
-      search: '?the=query',
-      hash: '#the-hash',
-    })
+      pathname: "/the/path",
+      search: "?the=query",
+      hash: "#the-hash",
+    });
 
-    expect(href).toEqual('#/the/path?the=query#the-hash')
-  })
+    expect(href).toEqual("#/the/path?the=query#the-hash");
+  });
 
-  test('knows how to create hrefs from strings', () => {
-    const href = history.createHref('/the/path?the=query#the-hash')
-    expect(href).toEqual('#/the/path?the=query#the-hash')
-  })
+  test("knows how to create hrefs from strings", () => {
+    const href = history.createHref("/the/path?the=query#the-hash");
+    expect(href).toEqual("#/the/path?the=query#the-hash");
+  });
 
-  test('does not encode the generated path', () => {
+  test("does not encode the generated path", () => {
     const encodedHref = history.createHref({
-      pathname: '/%23abc',
-    })
-    expect(encodedHref).toEqual('#/%23abc')
+      pathname: "/%23abc",
+    });
+    expect(encodedHref).toEqual("#/%23abc");
 
     const unencodedHref = history.createHref({
-      pathname: '/#abc',
-    })
-    expect(unencodedHref).toEqual('#/#abc')
-  })
-})
-
-describe('a memory history', () => {
-  let history: MemoryHistory
+      pathname: "/#abc",
+    });
+    expect(unencodedHref).toEqual("#/#abc");
+  });
+});
+
+describe("a memory history", () => {
+  let history: MemoryHistory;
   beforeEach(() => {
-    history = createMemoryHistory()
-  })
+    history = createMemoryHistory();
+  });
 
-  test('has an index property', () => {
-    expect(typeof history.index).toBe('number')
-  })
+  test("has an index property", () => {
+    expect(typeof history.index).toBe("number");
+  });
 
-  test('knows how to create hrefs', () => {
+  test("knows how to create hrefs", () => {
     const href = history.createHref({
-      pathname: '/the/path',
-      search: '?the=query',
-      hash: '#the-hash',
-    })
+      pathname: "/the/path",
+      search: "?the=query",
+      hash: "#the-hash",
+    });
 
-    expect(href).toEqual('/the/path?the=query#the-hash')
-  })
+    expect(href).toEqual("/the/path?the=query#the-hash");
+  });
 
-  test('knows how to create hrefs from strings', () => {
-    const href = history.createHref('/the/path?the=query#the-hash')
-    expect(href).toEqual('/the/path?the=query#the-hash')
-  })
+  test("knows how to create hrefs from strings", () => {
+    const href = history.createHref("/the/path?the=query#the-hash");
+    expect(href).toEqual("/the/path?the=query#the-hash");
+  });
 
-  test('does not encode the generated path', () => {
+  test("does not encode the generated path", () => {
     const encodedHref = history.createHref({
-      pathname: '/%23abc',
-    })
-    expect(encodedHref).toEqual('/%23abc')
+      pathname: "/%23abc",
+    });
+    expect(encodedHref).toEqual("/%23abc");
 
     const unencodedHref = history.createHref({
-      pathname: '/#abc',
-    })
-    expect(unencodedHref).toEqual('/#abc')
-  })
-})
+      pathname: "/#abc",
+    });
+    expect(unencodedHref).toEqual("/#abc");
+  });
+});
diff --git a/src/services/history.ts b/src/services/history.ts
index 0d22d379..bf0f455e 100644
--- a/src/services/history.ts
+++ b/src/services/history.ts
@@ -1,46 +1,46 @@
-export type Action = 'POP' | 'PUSH' | 'REPLACE'
-export type Pathname = string
-export type Search = string
-export type Hash = string
-export type Key = string
+export type Action = "POP" | "PUSH" | "REPLACE";
+export type Pathname = string;
+export type Search = string;
+export type Hash = string;
+export type Key = string;
 
 export interface Path {
-  pathname: Pathname,
-  search: Search,
-  hash: Hash,
+  pathname: Pathname;
+  search: Search;
+  hash: Hash;
 }
 
 export interface Location extends Path {
-  state: unknown,
-  key: Key,
+  state: unknown;
+  key: Key;
 }
 
 export interface Update {
-  action: Action,
-  location: Location,
+  action: Action;
+  location: Location;
 }
 
-export type Listener = (update: Update) => void
+export type Listener = (update: Update) => void;
 
 export interface Transition extends Update {
-  retry: () => void,
+  retry: () => void;
 }
 
-export type Blocker = (tx: Transition) => void
+export type Blocker = (tx: Transition) => void;
 
-export type To = string | Partial<Path>
+export type To = string | Partial<Path>;
 
 export interface History {
-  readonly action: Action,
-  readonly location: Location,
-  createHref: (to: To) => string,
-  push: (to: To, state?: unknown) => void,
-  replace: (to: To, state?: unknown) => void,
-  go: (delta: number) => void,
-  back: () => void,
-  forward: () => void,
-  listen: (listener: Listener) => () => void,
-  block: (blocker: Blocker) => () => void,
+  readonly action: Action;
+  readonly location: Location;
+  createHref: (to: To) => string;
+  push: (to: To, state?: unknown) => void;
+  replace: (to: To, state?: unknown) => void;
+  go: (delta: number) => void;
+  back: () => void;
+  forward: () => void;
+  listen: (listener: Listener) => () => void;
+  block: (blocker: Blocker) => () => void;
 }
 
 export interface BrowserHistory extends History {}
@@ -48,116 +48,114 @@ export interface BrowserHistory extends History {}
 export interface HashHistory extends History {}
 
 export interface MemoryHistory extends History {
-  readonly index: number,
+  readonly index: number;
 }
 
 export type BrowserHistoryOptions = {
-  window?: Window,
-}
+  window?: Window;
+};
 
 export type HashHistoryOptions = {
-  window?: Window,
-}
+  window?: Window;
+};
 
-export type InitialEntry = string | Partial<Location>
+export type InitialEntry = string | Partial<Location>;
 
 export type MemoryHistoryOptions = {
-  initialEntries?: InitialEntry[],
-  initialIndex?: number,
-}
+  initialEntries?: InitialEntry[];
+  initialIndex?: number;
+};
 
 // UTILS
 
 function createEvents<T>(): {
-  readonly length: number,
-  push: (fn: (arg: T) => void) => () => void,
-  call: (arg: T) => void,
+  readonly length: number;
+  push: (fn: (arg: T) => void) => () => void;
+  call: (arg: T) => void;
 } {
-  let handlers: ((arg: T) => void)[] = []
+  let handlers: ((arg: T) => void)[] = [];
   return {
     get length() {
-      return handlers.length
+      return handlers.length;
     },
     push(fn: (arg: T) => void): () => void {
-      handlers.push(fn)
+      handlers.push(fn);
       return () => {
-        handlers = handlers.filter((handler) => handler !== fn)
-      }
+        handlers = handlers.filter((handler) => handler !== fn);
+      };
     },
     call(arg: T): void {
-      handlers.forEach((fn) => fn(arg))
+      handlers.forEach((fn) => fn(arg));
     },
-  }
+  };
 }
 
 function createKey(): string {
-  return Math.random()
-    .toString(36)
-    .slice(2, 10)
+  return Math.random().toString(36).slice(2, 10);
 }
 
 function clamp(n: number, lowerBound: number, upperBound: number): number {
-  return Math.min(Math.max(n, lowerBound), upperBound)
+  return Math.min(Math.max(n, lowerBound), upperBound);
 }
 
 function promptBeforeUnload(event: BeforeUnloadEvent): void {
-  event.preventDefault()
+  event.preventDefault();
   // Chrome (and legacy IE) requires returnValue to be set
-  // eslint-disable-next-line @typescript-eslint/no-deprecated
-  event.returnValue = ''
+  // oxlint-disable-next-line @typescript-eslint/no-deprecated
+  event.returnValue = "";
 }
 
-export function createPath({ pathname = '/', search = '', hash = '' }: Partial<Path>): string {
-  let result = pathname
-  if (search && search !== '?') result += search.startsWith('?') ? search : '?' + search
-  if (hash && hash !== '#') result += hash.startsWith('#') ? hash : '#' + hash
-  return result
+export function createPath({ pathname = "/", search = "", hash = "" }: Partial<Path>): string {
+  let result = pathname;
+  if (search && search !== "?") result += search.startsWith("?") ? search : "?" + search;
+  if (hash && hash !== "#") result += hash.startsWith("#") ? hash : "#" + hash;
+  return result;
 }
 
 export function parsePath(path: string): Partial<Path> {
-  const parsedPath: Partial<Path> = {}
+  const parsedPath: Partial<Path> = {};
 
   if (path) {
-    const hashIndex = path.indexOf('#')
+    const hashIndex = path.indexOf("#");
 
     if (hashIndex >= 0) {
-      parsedPath.hash = path.slice(hashIndex)
-      path = path.slice(0, hashIndex)
+      parsedPath.hash = path.slice(hashIndex);
+      path = path.slice(0, hashIndex);
     }
 
-    const searchIndex = path.indexOf('?')
+    const searchIndex = path.indexOf("?");
 
     if (searchIndex >= 0) {
-      parsedPath.search = path.slice(searchIndex)
-      path = path.slice(0, searchIndex)
+      parsedPath.search = path.slice(searchIndex);
+      path = path.slice(0, searchIndex);
     }
 
     if (path) {
-      parsedPath.pathname = path
+      parsedPath.pathname = path;
     }
   }
 
-  return parsedPath
+  return parsedPath;
 }
 
 function readOnly<T extends object>(obj: T): Readonly<T> {
-  return Object.freeze(obj)
+  return Object.freeze(obj);
 }
 
 // BROWSER HISTORY
 
-const BeforeUnloadEventType = 'beforeunload'
-const PopStateEventType = 'popstate'
-const HashChangeEventType = 'hashchange'
+const BeforeUnloadEventType = "beforeunload";
+const PopStateEventType = "popstate";
+const HashChangeEventType = "hashchange";
 
 export function createBrowserHistory(options: BrowserHistoryOptions = {}): BrowserHistory {
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-  const { window: win = document.defaultView! } = options
-  const globalHistory = win.history
+  // oxlint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const { window: win = document.defaultView! } = options;
+  const globalHistory = win.history;
 
   function getIndexAndLocation(): [number | null, Location] {
-    const { pathname, search, hash } = win.location
-    const state = globalHistory.state ?? {}
+    const { pathname, search, hash } = win.location;
+    const state = globalHistory.state ?? {};
     return [
       state.idx,
       readOnly({
@@ -165,179 +163,179 @@ export function createBrowserHistory(options: BrowserHistoryOptions = {}): Brows
         search,
         hash,
         state: state.usr ?? null,
-        key: state.key ?? 'default',
+        key: state.key ?? "default",
       }),
-    ]
+    ];
   }
 
-  let blockedPopTx: Transition | null = null
+  let blockedPopTx: Transition | null = null;
 
   function handlePop(): void {
     if (blockedPopTx) {
-      blockers.call(blockedPopTx)
-      blockedPopTx = null
+      blockers.call(blockedPopTx);
+      blockedPopTx = null;
     } else {
-      const nextAction = 'POP'
-      const [nextIndex, nextLocation] = getIndexAndLocation()
+      const nextAction = "POP";
+      const [nextIndex, nextLocation] = getIndexAndLocation();
 
       if (blockers.length) {
         if (nextIndex != null) {
-          const delta = index ?? 0 - nextIndex
+          const delta = index ?? 0 - nextIndex;
 
           if (delta) {
             blockedPopTx = {
               action: nextAction,
               location: nextLocation,
               retry() {
-                go(delta * -1)
+                go(delta * -1);
               },
-            }
-            go(delta)
+            };
+            go(delta);
           }
         }
       } else {
-        applyTx(nextAction)
+        applyTx(nextAction);
       }
     }
   }
 
-  win.addEventListener(PopStateEventType, handlePop)
+  win.addEventListener(PopStateEventType, handlePop);
 
-  let action: Action = 'POP'
-  let [index, location] = getIndexAndLocation()
-  const listeners = createEvents<Update>()
-  const blockers = createEvents<Transition>()
+  let action: Action = "POP";
+  let [index, location] = getIndexAndLocation();
+  const listeners = createEvents<Update>();
+  const blockers = createEvents<Transition>();
 
   if (index == null) {
-    index = 0
-    globalHistory.replaceState({ ...globalHistory.state, idx: index }, '', createHref(location))
+    index = 0;
+    globalHistory.replaceState({ ...globalHistory.state, idx: index }, "", createHref(location));
   }
 
   function createHref(to: To): string {
-    return typeof to === 'string' ? to : createPath(to)
+    return typeof to === "string" ? to : createPath(to);
   }
 
   function getNextLocation(to: To, state: unknown = null): Location {
     return readOnly({
       pathname: location.pathname,
-      hash: '',
-      search: '',
-      ...typeof to === 'string' ? parsePath(to) : to,
+      hash: "",
+      search: "",
+      ...(typeof to === "string" ? parsePath(to) : to),
       state,
       key: createKey(),
-    })
+    });
   }
 
-  function getHistoryStateAndUrl(nextLocation: Location, idx: number): [Record<string, unknown>, string] {
-    return [
-      { usr: nextLocation.state, key: nextLocation.key, idx },
-      createHref(nextLocation),
-    ]
+  function getHistoryStateAndUrl(
+    nextLocation: Location,
+    idx: number,
+  ): [Record<string, unknown>, string] {
+    return [{ usr: nextLocation.state, key: nextLocation.key, idx }, createHref(nextLocation)];
   }
 
   function allowTx(txAction: Action, txLocation: Location, retry: () => void): boolean {
     if (blockers.length) {
-      blockers.call({ action: txAction, location: txLocation, retry })
-      return false
+      blockers.call({ action: txAction, location: txLocation, retry });
+      return false;
     }
-    return true
+    return true;
   }
 
   function applyTx(nextAction: Action): void {
-    action = nextAction
-    ;[index, location] = getIndexAndLocation()
-    listeners.call({ action, location })
+    action = nextAction;
+    [index, location] = getIndexAndLocation();
+    listeners.call({ action, location });
   }
 
   function push(to: To, state?: unknown): void {
-    const nextAction: Action = 'PUSH'
-    const nextLocation = getNextLocation(to, state)
+    const nextAction: Action = "PUSH";
+    const nextLocation = getNextLocation(to, state);
 
     function retry(): void {
-      push(to, state)
+      push(to, state);
     }
 
     if (allowTx(nextAction, nextLocation, retry)) {
-      const [historyState, url] = getHistoryStateAndUrl(nextLocation, (index ?? 0) + 1)
+      const [historyState, url] = getHistoryStateAndUrl(nextLocation, (index ?? 0) + 1);
 
       try {
-        globalHistory.pushState(historyState, '', url)
+        globalHistory.pushState(historyState, "", url);
       } catch {
-        win.location.assign(url)
+        win.location.assign(url);
       }
 
-      applyTx(nextAction)
+      applyTx(nextAction);
     }
   }
 
   function replace(to: To, state?: unknown): void {
-    const nextAction: Action = 'REPLACE'
-    const nextLocation = getNextLocation(to, state)
+    const nextAction: Action = "REPLACE";
+    const nextLocation = getNextLocation(to, state);
 
     function retry(): void {
-      replace(to, state)
+      replace(to, state);
     }
 
     if (allowTx(nextAction, nextLocation, retry)) {
-      const [historyState, url] = getHistoryStateAndUrl(nextLocation, index ?? 0)
-      globalHistory.replaceState(historyState, '', url)
-      applyTx(nextAction)
+      const [historyState, url] = getHistoryStateAndUrl(nextLocation, index ?? 0);
+      globalHistory.replaceState(historyState, "", url);
+      applyTx(nextAction);
     }
   }
 
   function go(delta: number): void {
-    globalHistory.go(delta)
+    globalHistory.go(delta);
   }
 
   const history: BrowserHistory = {
     get action() {
-      return action
+      return action;
     },
     get location() {
-      return location
+      return location;
     },
     createHref,
     push,
     replace,
     go,
     back() {
-      go(-1)
+      go(-1);
     },
     forward() {
-      go(1)
+      go(1);
     },
     listen(listener: Listener) {
-      return listeners.push(listener)
+      return listeners.push(listener);
     },
     block(blocker: Blocker) {
-      const unblock = blockers.push(blocker)
+      const unblock = blockers.push(blocker);
 
       if (blockers.length === 1) {
-        win.addEventListener(BeforeUnloadEventType, promptBeforeUnload)
+        win.addEventListener(BeforeUnloadEventType, promptBeforeUnload);
       }
 
       return () => {
-        unblock()
+        unblock();
         if (!blockers.length) {
-          win.removeEventListener(BeforeUnloadEventType, promptBeforeUnload)
+          win.removeEventListener(BeforeUnloadEventType, promptBeforeUnload);
         }
-      }
+      };
     },
-  }
+  };
 
-  return history
+  return history;
 }
 
 // HASH HISTORY
 
 export function createHashHistory(options: HashHistoryOptions = {}): HashHistory {
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-  const { window: win = document.defaultView! } = options
-  const globalHistory = win.history
+  // oxlint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const { window: win = document.defaultView! } = options;
+  const globalHistory = win.history;
 
   function getIndexAndLocation(): [number | null, Location] {
-    const { pathname = '/', search = '', hash = '' } = parsePath(win.location.hash.slice(1))
-    const state = globalHistory.state ?? {}
+    const { pathname = "/", search = "", hash = "" } = parsePath(win.location.hash.slice(1));
+    const state = globalHistory.state ?? {};
     return [
       state.idx,
       readOnly({
@@ -345,309 +343,310 @@ export function createHashHistory(options: HashHistoryOptions = {}): HashHistory
         search,
         hash,
         state: state.usr ?? null,
-        key: state.key ?? 'default',
+        key: state.key ?? "default",
       }),
-    ]
+    ];
   }
 
-  let blockedPopTx: Transition | null = null
+  let blockedPopTx: Transition | null = null;
 
   function handlePop(): void {
     if (blockedPopTx) {
-      blockers.call(blockedPopTx)
-      blockedPopTx = null
+      blockers.call(blockedPopTx);
+      blockedPopTx = null;
     } else {
-      const nextAction: Action = 'POP'
-      const [nextIndex, nextLocation] = getIndexAndLocation()
+      const nextAction: Action = "POP";
+      const [nextIndex, nextLocation] = getIndexAndLocation();
 
       if (blockers.length) {
         if (nextIndex != null) {
-          const delta = (index ?? 0) - nextIndex
+          const delta = (index ?? 0) - nextIndex;
 
           if (delta) {
             blockedPopTx = {
               action: nextAction,
               location: nextLocation,
               retry() {
-                go(delta * -1)
+                go(delta * -1);
               },
-            }
-            go(delta)
+            };
+            go(delta);
           }
         }
       } else {
-        applyTx(nextAction)
+        applyTx(nextAction);
       }
     }
   }
 
-  win.addEventListener(PopStateEventType, handlePop)
+  win.addEventListener(PopStateEventType, handlePop);
   win.addEventListener(HashChangeEventType, () => {
-    const [, nextLocation] = getIndexAndLocation()
+    const [, nextLocation] = getIndexAndLocation();
     if (createPath(nextLocation) !== createPath(location)) {
-      handlePop()
+      handlePop();
     }
-  })
+  });
 
-  let action: Action = 'POP'
-  let [index, location] = getIndexAndLocation()
-  const listeners = createEvents<Update>()
-  const blockers = createEvents<Transition>()
+  let action: Action = "POP";
+  let [index, location] = getIndexAndLocation();
+  const listeners = createEvents<Update>();
+  const blockers = createEvents<Transition>();
 
   if (index == null) {
-    index = 0
-    globalHistory.replaceState({ ...globalHistory.state, idx: index }, '')
+    index = 0;
+    globalHistory.replaceState({ ...globalHistory.state, idx: index }, "");
   }
 
   function getBaseHref(): string {
-    const base = document.querySelector('base')
-    let href = ''
+    const base = document.querySelector("base");
+    let href = "";
 
-    if (base?.getAttribute('href')) {
-      const url = win.location.href
-      const hashIndex = url.indexOf('#')
-      href = hashIndex === -1 ? url : url.slice(0, hashIndex)
+    if (base?.getAttribute("href")) {
+      const url = win.location.href;
+      const hashIndex = url.indexOf("#");
+      href = hashIndex === -1 ? url : url.slice(0, hashIndex);
     }
 
-    return href
+    return href;
   }
 
   function createHref(to: To): string {
-    return getBaseHref() + '#' + (typeof to === 'string' ? to : createPath(to))
+    return getBaseHref() + "#" + (typeof to === "string" ? to : createPath(to));
   }
 
   function getNextLocation(to: To, state: unknown = null): Location {
     return readOnly({
       pathname: location.pathname,
-      hash: '',
-      search: '',
-      ...typeof to === 'string' ? parsePath(to) : to,
+      hash: "",
+      search: "",
+      ...(typeof to === "string" ? parsePath(to) : to),
       state,
       key: createKey(),
-    })
+    });
   }
 
-  function getHistoryStateAndUrl(nextLocation: Location, idx: number): [Record<string, unknown>, string] {
-    return [
-      { usr: nextLocation.state, key: nextLocation.key, idx },
-      createHref(nextLocation),
-    ]
+  function getHistoryStateAndUrl(
+    nextLocation: Location,
+    idx: number,
+  ): [Record<string, unknown>, string] {
+    return [{ usr: nextLocation.state, key: nextLocation.key, idx }, createHref(nextLocation)];
   }
 
   function allowTx(txAction: Action, txLocation: Location, retry: () => void): boolean {
     if (blockers.length) {
-      blockers.call({ action: txAction, location: txLocation, retry })
-      return false
+      blockers.call({ action: txAction, location: txLocation, retry });
+      return false;
     }
-    return true
+    return true;
   }
 
   function applyTx(nextAction: Action): void {
-    action = nextAction
-    ;[index, location] = getIndexAndLocation()
-    listeners.call({ action, location })
+    action = nextAction;
+    [index, location] = getIndexAndLocation();
+    listeners.call({ action, location });
   }
 
   function push(to: To, state?: unknown): void {
-    const nextAction: Action = 'PUSH'
-    const nextLocation = getNextLocation(to, state)
+    const nextAction: Action = "PUSH";
+    const nextLocation = getNextLocation(to, state);
 
     function retry(): void {
-      push(to, state)
+      push(to, state);
     }
 
     if (allowTx(nextAction, nextLocation, retry)) {
-      const [historyState, url] = getHistoryStateAndUrl(nextLocation, (index ?? 0) + 1)
+      const [historyState, url] = getHistoryStateAndUrl(nextLocation, (index ?? 0) + 1);
 
       try {
-        globalHistory.pushState(historyState, '', url)
+        globalHistory.pushState(historyState, "", url);
       } catch {
-        win.location.assign(url)
+        win.location.assign(url);
       }
 
-      applyTx(nextAction)
+      applyTx(nextAction);
     }
   }
 
   function replace(to: To, state?: unknown): void {
-    const nextAction: Action = 'REPLACE'
-    const nextLocation = getNextLocation(to, state)
+    const nextAction: Action = "REPLACE";
+    const nextLocation = getNextLocation(to, state);
 
     function retry(): void {
-      replace(to, state)
+      replace(to, state);
     }
 
     if (allowTx(nextAction, nextLocation, retry)) {
-      const [historyState, url] = getHistoryStateAndUrl(nextLocation, index ?? 0)
-      globalHistory.replaceState(historyState, '', url)
-      applyTx(nextAction)
+      const [historyState, url] = getHistoryStateAndUrl(nextLocation, index ?? 0);
+      globalHistory.replaceState(historyState, "", url);
+      applyTx(nextAction);
     }
   }
 
   function go(delta: number): void {
-    globalHistory.go(delta)
+    globalHistory.go(delta);
   }
 
   const history: HashHistory = {
     get action() {
-      return action
+      return action;
     },
     get location() {
-      return location
+      return location;
     },
     createHref,
     push,
     replace,
     go,
     back() {
-      go(-1)
+      go(-1);
     },
     forward() {
-      go(1)
+      go(1);
     },
     listen(listener: Listener) {
-      return listeners.push(listener)
+      return listeners.push(listener);
     },
     block(blocker: Blocker) {
-      const unblock = blockers.push(blocker)
+      const unblock = blockers.push(blocker);
 
       if (blockers.length === 1) {
-        win.addEventListener(BeforeUnloadEventType, promptBeforeUnload)
+        win.addEventListener(BeforeUnloadEventType, promptBeforeUnload);
       }
 
       return () => {
-        unblock()
+        unblock();
         if (!blockers.length) {
-          win.removeEventListener(BeforeUnloadEventType, promptBeforeUnload)
+          win.removeEventListener(BeforeUnloadEventType, promptBeforeUnload);
         }
-      }
+      };
     },
-  }
+  };
 
-  return history
+  return history;
 }
 
 // MEMORY HISTORY
 
 export function createMemoryHistory(options: MemoryHistoryOptions = {}): MemoryHistory {
-  const { initialEntries = ['/'], initialIndex } = options
-
-  const entries: Location[] = initialEntries.map((entry) => readOnly({
-    pathname: '/',
-    search: '',
-    hash: '',
-    state: null,
-    key: createKey(),
-    ...typeof entry === 'string' ? parsePath(entry) : entry,
-  }),
-  )
-
-  let index = clamp(initialIndex ?? entries.length - 1, 0, entries.length - 1)
-  let action: Action = 'POP'
-  let location = entries[index]
-  const listeners = createEvents<Update>()
-  const blockers = createEvents<Transition>()
+  const { initialEntries = ["/"], initialIndex } = options;
+
+  const entries: Location[] = initialEntries.map((entry) =>
+    readOnly({
+      pathname: "/",
+      search: "",
+      hash: "",
+      state: null,
+      key: createKey(),
+      ...(typeof entry === "string" ? parsePath(entry) : entry),
+    }),
+  );
+
+  let index = clamp(initialIndex ?? entries.length - 1, 0, entries.length - 1);
+  let action: Action = "POP";
+  let location = entries[index];
+  const listeners = createEvents<Update>();
+  const blockers = createEvents<Transition>();
 
   function createHref(to: To): string {
-    return typeof to === 'string' ? to : createPath(to)
+    return typeof to === "string" ? to : createPath(to);
   }
 
   function getNextLocation(to: To, state: unknown = null): Location {
     return readOnly({
       pathname: location.pathname,
-      search: '',
-      hash: '',
-      ...typeof to === 'string' ? parsePath(to) : to,
+      search: "",
+      hash: "",
+      ...(typeof to === "string" ? parsePath(to) : to),
       state,
       key: createKey(),
-    })
+    });
   }
 
   function allowTx(txAction: Action, txLocation: Location, retry: () => void): boolean {
     if (blockers.length) {
-      blockers.call({ action: txAction, location: txLocation, retry })
-      return false
+      blockers.call({ action: txAction, location: txLocation, retry });
+      return false;
     }
-    return true
+    return true;
   }
 
   function applyTx(nextAction: Action, nextLocation: Location): void {
-    action = nextAction
-    location = nextLocation
-    listeners.call({ action, location })
+    action = nextAction;
+    location = nextLocation;
+    listeners.call({ action, location });
   }
 
   function push(to: To, state?: unknown): void {
-    const nextAction: Action = 'PUSH'
-    const nextLocation = getNextLocation(to, state)
+    const nextAction: Action = "PUSH";
+    const nextLocation = getNextLocation(to, state);
 
     function retry(): void {
-      push(to, state)
+      push(to, state);
     }
 
     if (allowTx(nextAction, nextLocation, retry)) {
-      index += 1
-      entries.splice(index, entries.length, nextLocation)
-      applyTx(nextAction, nextLocation)
+      index += 1;
+      entries.splice(index, entries.length, nextLocation);
+      applyTx(nextAction, nextLocation);
     }
   }
 
   function replace(to: To, state?: unknown): void {
-    const nextAction: Action = 'REPLACE'
-    const nextLocation = getNextLocation(to, state)
+    const nextAction: Action = "REPLACE";
+    const nextLocation = getNextLocation(to, state);
 
     function retry(): void {
-      replace(to, state)
+      replace(to, state);
     }
 
     if (allowTx(nextAction, nextLocation, retry)) {
-      entries[index] = nextLocation
-      applyTx(nextAction, nextLocation)
+      entries[index] = nextLocation;
+      applyTx(nextAction, nextLocation);
     }
   }
 
   function go(delta: number): void {
-    const nextIndex = clamp(index + delta, 0, entries.length - 1)
-    const nextAction: Action = 'POP'
-    const nextLocation = entries[nextIndex]
+    const nextIndex = clamp(index + delta, 0, entries.length - 1);
+    const nextAction: Action = "POP";
+    const nextLocation = entries[nextIndex];
 
     function retry(): void {
-      go(delta)
+      go(delta);
     }
 
     if (allowTx(nextAction, nextLocation, retry)) {
-      index = nextIndex
-      applyTx(nextAction, nextLocation)
+      index = nextIndex;
+      applyTx(nextAction, nextLocation);
     }
   }
 
   const history: MemoryHistory = {
     get index() {
-      return index
+      return index;
     },
     get action() {
-      return action
+      return action;
     },
     get location() {
-      return location
+      return location;
     },
     createHref,
     push,
     replace,
     go,
     back() {
-      go(-1)
+      go(-1);
     },
     forward() {
-      go(1)
+      go(1);
     },
     listen(listener: Listener) {
-      return listeners.push(listener)
+      return listeners.push(listener);
     },
     block(blocker: Blocker) {
-      return blockers.push(blocker)
+      return blockers.push(blocker);
     },
-  }
+  };
 
-  return history
+  return history;
 }
diff --git a/src/services/hooks.browser.spec.ts b/src/services/hooks.browser.spec.ts
index 0892ef34..44e80435 100644
--- a/src/services/hooks.browser.spec.ts
+++ b/src/services/hooks.browser.spec.ts
@@ -1,91 +1,97 @@
-import { expect, test, vi } from 'vitest'
-import { createRoute } from './createRoute'
-import { createRouter } from './createRouter'
-import { h } from 'vue'
-import { mount } from '@vue/test-utils'
-import { routes } from '@/utilities/testHelpers'
-import { createExternalRoute } from './createExternalRoute'
-import { createRejection } from './createRejection'
-import { onAfterRouteLeave, onAfterRouteUpdate, onBeforeRouteLeave, onBeforeRouteUpdate, RouterView } from '@/main'
-
-test('global hooks are called correctly', async () => {
-  const router = createRouter(routes, { initialUrl: '/parentA/valueA' })
-
-  const onBeforeRouteEnter = vi.fn()
-  const onBeforeRouteUpdate = vi.fn()
-  const onBeforeRouteLeave = vi.fn()
-  const onAfterRouteEnter = vi.fn()
-  const onAfterRouteUpdate = vi.fn()
-  const onAfterRouteLeave = vi.fn()
-  const onError = vi.fn()
-  const onRejection = vi.fn()
-
-  router.onBeforeRouteEnter(onBeforeRouteEnter)
-  router.onAfterRouteEnter(onAfterRouteEnter)
-  router.onBeforeRouteUpdate(onBeforeRouteUpdate)
-  router.onAfterRouteUpdate(onAfterRouteUpdate)
-  router.onBeforeRouteLeave(onBeforeRouteLeave)
-  router.onAfterRouteLeave(onAfterRouteLeave)
-  router.onError(onError)
-  router.onRejection(onRejection)
-
-  await router.start()
-
-  expect(onBeforeRouteEnter).toHaveBeenCalledTimes(1)
-  expect(onBeforeRouteUpdate).toHaveBeenCalledTimes(0)
-  expect(onBeforeRouteLeave).toHaveBeenCalledTimes(0)
-  expect(onAfterRouteLeave).toHaveBeenCalledTimes(0)
-  expect(onAfterRouteUpdate).toHaveBeenCalledTimes(0)
-  expect(onAfterRouteEnter).toHaveBeenCalledTimes(1)
-  expect(onError).toHaveBeenCalledTimes(0)
-  expect(onRejection).toHaveBeenCalledTimes(0)
-
-  await router.push('parentA.childA', { paramA: 'valueA', paramB: 'valueB' })
-
-  expect(onBeforeRouteEnter).toHaveBeenCalledTimes(2)
-  expect(onBeforeRouteUpdate).toHaveBeenCalledTimes(1)
-  expect(onBeforeRouteLeave).toHaveBeenCalledTimes(0)
-  expect(onAfterRouteLeave).toHaveBeenCalledTimes(0)
-  expect(onAfterRouteUpdate).toHaveBeenCalledTimes(1)
-  expect(onAfterRouteEnter).toHaveBeenCalledTimes(2)
-  expect(onError).toHaveBeenCalledTimes(0)
-  expect(onRejection).toHaveBeenCalledTimes(0)
-
-  await router.push('parentA.childB', { paramA: 'valueB', paramD: 'valueD' })
-
-  expect(onBeforeRouteEnter).toHaveBeenCalledTimes(3)
-  expect(onBeforeRouteUpdate).toHaveBeenCalledTimes(2)
-  expect(onBeforeRouteLeave).toHaveBeenCalledTimes(1)
-  expect(onAfterRouteLeave).toHaveBeenCalledTimes(1)
-  expect(onAfterRouteUpdate).toHaveBeenCalledTimes(2)
-  expect(onAfterRouteEnter).toHaveBeenCalledTimes(3)  
-  expect(onError).toHaveBeenCalledTimes(0)
-  expect(onRejection).toHaveBeenCalledTimes(0)
-
-  await router.push('parentB')
-
-  expect(onBeforeRouteEnter).toHaveBeenCalledTimes(4)
-  expect(onBeforeRouteUpdate).toHaveBeenCalledTimes(2)
-  expect(onBeforeRouteLeave).toHaveBeenCalledTimes(2)
-  expect(onAfterRouteLeave).toHaveBeenCalledTimes(2)
-  expect(onAfterRouteUpdate).toHaveBeenCalledTimes(2)
-  expect(onAfterRouteEnter).toHaveBeenCalledTimes(4)  
-  expect(onError).toHaveBeenCalledTimes(0)
-  expect(onRejection).toHaveBeenCalledTimes(0)
-
-  router.reject('NotFound')
-
-  expect(onBeforeRouteEnter).toHaveBeenCalledTimes(4)
-  expect(onBeforeRouteUpdate).toHaveBeenCalledTimes(2)
-  expect(onBeforeRouteLeave).toHaveBeenCalledTimes(2)
-  expect(onAfterRouteLeave).toHaveBeenCalledTimes(2)
-  expect(onAfterRouteUpdate).toHaveBeenCalledTimes(2)
-  expect(onAfterRouteEnter).toHaveBeenCalledTimes(4)  
-  expect(onError).toHaveBeenCalledTimes(0)
-  expect(onRejection).toHaveBeenCalledTimes(1)
-})
-
-test('route hooks are called correctly', async () => {
+import { expect, test, vi } from "vite-plus/test";
+import { createRoute } from "./createRoute";
+import { createRouter } from "./createRouter";
+import { h } from "vue";
+import { mount } from "@vue/test-utils";
+import { routes } from "@/utilities/testHelpers";
+import { createExternalRoute } from "./createExternalRoute";
+import { createRejection } from "./createRejection";
+import {
+  onAfterRouteLeave,
+  onAfterRouteUpdate,
+  onBeforeRouteLeave,
+  onBeforeRouteUpdate,
+  RouterView,
+} from "@/main";
+
+test("global hooks are called correctly", async () => {
+  const router = createRouter(routes, { initialUrl: "/parentA/valueA" });
+
+  const onBeforeRouteEnter = vi.fn();
+  const onBeforeRouteUpdate = vi.fn();
+  const onBeforeRouteLeave = vi.fn();
+  const onAfterRouteEnter = vi.fn();
+  const onAfterRouteUpdate = vi.fn();
+  const onAfterRouteLeave = vi.fn();
+  const onError = vi.fn();
+  const onRejection = vi.fn();
+
+  router.onBeforeRouteEnter(onBeforeRouteEnter);
+  router.onAfterRouteEnter(onAfterRouteEnter);
+  router.onBeforeRouteUpdate(onBeforeRouteUpdate);
+  router.onAfterRouteUpdate(onAfterRouteUpdate);
+  router.onBeforeRouteLeave(onBeforeRouteLeave);
+  router.onAfterRouteLeave(onAfterRouteLeave);
+  router.onError(onError);
+  router.onRejection(onRejection);
+
+  await router.start();
+
+  expect(onBeforeRouteEnter).toHaveBeenCalledTimes(1);
+  expect(onBeforeRouteUpdate).toHaveBeenCalledTimes(0);
+  expect(onBeforeRouteLeave).toHaveBeenCalledTimes(0);
+  expect(onAfterRouteLeave).toHaveBeenCalledTimes(0);
+  expect(onAfterRouteUpdate).toHaveBeenCalledTimes(0);
+  expect(onAfterRouteEnter).toHaveBeenCalledTimes(1);
+  expect(onError).toHaveBeenCalledTimes(0);
+  expect(onRejection).toHaveBeenCalledTimes(0);
+
+  await router.push("parentA.childA", { paramA: "valueA", paramB: "valueB" });
+
+  expect(onBeforeRouteEnter).toHaveBeenCalledTimes(2);
+  expect(onBeforeRouteUpdate).toHaveBeenCalledTimes(1);
+  expect(onBeforeRouteLeave).toHaveBeenCalledTimes(0);
+  expect(onAfterRouteLeave).toHaveBeenCalledTimes(0);
+  expect(onAfterRouteUpdate).toHaveBeenCalledTimes(1);
+  expect(onAfterRouteEnter).toHaveBeenCalledTimes(2);
+  expect(onError).toHaveBeenCalledTimes(0);
+  expect(onRejection).toHaveBeenCalledTimes(0);
+
+  await router.push("parentA.childB", { paramA: "valueB", paramD: "valueD" });
+
+  expect(onBeforeRouteEnter).toHaveBeenCalledTimes(3);
+  expect(onBeforeRouteUpdate).toHaveBeenCalledTimes(2);
+  expect(onBeforeRouteLeave).toHaveBeenCalledTimes(1);
+  expect(onAfterRouteLeave).toHaveBeenCalledTimes(1);
+  expect(onAfterRouteUpdate).toHaveBeenCalledTimes(2);
+  expect(onAfterRouteEnter).toHaveBeenCalledTimes(3);
+  expect(onError).toHaveBeenCalledTimes(0);
+  expect(onRejection).toHaveBeenCalledTimes(0);
+
+  await router.push("parentB");
+
+  expect(onBeforeRouteEnter).toHaveBeenCalledTimes(4);
+  expect(onBeforeRouteUpdate).toHaveBeenCalledTimes(2);
+  expect(onBeforeRouteLeave).toHaveBeenCalledTimes(2);
+  expect(onAfterRouteLeave).toHaveBeenCalledTimes(2);
+  expect(onAfterRouteUpdate).toHaveBeenCalledTimes(2);
+  expect(onAfterRouteEnter).toHaveBeenCalledTimes(4);
+  expect(onError).toHaveBeenCalledTimes(0);
+  expect(onRejection).toHaveBeenCalledTimes(0);
+
+  router.reject("NotFound");
+
+  expect(onBeforeRouteEnter).toHaveBeenCalledTimes(4);
+  expect(onBeforeRouteUpdate).toHaveBeenCalledTimes(2);
+  expect(onBeforeRouteLeave).toHaveBeenCalledTimes(2);
+  expect(onAfterRouteLeave).toHaveBeenCalledTimes(2);
+  expect(onAfterRouteUpdate).toHaveBeenCalledTimes(2);
+  expect(onAfterRouteEnter).toHaveBeenCalledTimes(4);
+  expect(onError).toHaveBeenCalledTimes(0);
+  expect(onRejection).toHaveBeenCalledTimes(1);
+});
+
+test("route hooks are called correctly", async () => {
   const parentHooks = {
     beforeEnter: vi.fn(),
     beforeLeave: vi.fn(),
@@ -93,83 +99,83 @@ test('route hooks are called correctly', async () => {
     afterEnter: vi.fn(),
     afterLeave: vi.fn(),
     afterUpdate: vi.fn(),
-  }
+  };
 
   const parentA = createRoute({
-    name: 'parentA',
-    path: '/parentA',
-  })
+    name: "parentA",
+    path: "/parentA",
+  });
 
-  parentA.onBeforeRouteEnter(() => parentHooks.beforeEnter())
-  parentA.onBeforeRouteLeave(() => parentHooks.beforeLeave())
-  parentA.onBeforeRouteUpdate(() => parentHooks.beforeUpdate())
-  parentA.onAfterRouteEnter(() => parentHooks.afterEnter())
-  parentA.onAfterRouteLeave(() => parentHooks.afterLeave())
-  parentA.onAfterRouteUpdate(() => parentHooks.afterUpdate())
+  parentA.onBeforeRouteEnter(() => parentHooks.beforeEnter());
+  parentA.onBeforeRouteLeave(() => parentHooks.beforeLeave());
+  parentA.onBeforeRouteUpdate(() => parentHooks.beforeUpdate());
+  parentA.onAfterRouteEnter(() => parentHooks.afterEnter());
+  parentA.onAfterRouteLeave(() => parentHooks.afterLeave());
+  parentA.onAfterRouteUpdate(() => parentHooks.afterUpdate());
 
   const parentB = createRoute({
-    name: 'parentB',
-    path: '/parentB',
-  })
+    name: "parentB",
+    path: "/parentB",
+  });
 
   const child = createRoute({
-    name: 'child',
-    path: '/child/[param]',
+    name: "child",
+    path: "/child/[param]",
     parent: parentA,
-  })
+  });
 
   const router = createRouter([parentA, parentB, child], {
-    initialUrl: '/parentA',
-  })
+    initialUrl: "/parentA",
+  });
 
   const root = {
-    template: '<RouterView />',
-  }
+    template: "<RouterView />",
+  };
 
   mount(root, {
     global: {
       plugins: [router],
     },
-  })
-
-  await router.start()
-
-  expect(parentHooks.beforeEnter).toHaveBeenCalledTimes(1)
-  expect(parentHooks.beforeUpdate).toHaveBeenCalledTimes(0)
-  expect(parentHooks.beforeLeave).toHaveBeenCalledTimes(0)
-  expect(parentHooks.afterLeave).toHaveBeenCalledTimes(0)
-  expect(parentHooks.afterUpdate).toHaveBeenCalledTimes(0)
-  expect(parentHooks.afterEnter).toHaveBeenCalledTimes(1)
-
-  await router.push('child', { param: 'param2' })
-
-  expect(parentHooks.beforeEnter).toHaveBeenCalledTimes(1)
-  expect(parentHooks.beforeUpdate).toHaveBeenCalledTimes(1)
-  expect(parentHooks.beforeLeave).toHaveBeenCalledTimes(0)
-  expect(parentHooks.afterLeave).toHaveBeenCalledTimes(0)
-  expect(parentHooks.afterUpdate).toHaveBeenCalledTimes(1)
-  expect(parentHooks.afterEnter).toHaveBeenCalledTimes(1) 
-
-  await router.push('parentA')
-
-  expect(parentHooks.beforeEnter).toHaveBeenCalledTimes(1)
-  expect(parentHooks.beforeUpdate).toHaveBeenCalledTimes(2)
-  expect(parentHooks.beforeLeave).toHaveBeenCalledTimes(0)
-  expect(parentHooks.afterLeave).toHaveBeenCalledTimes(0)
-  expect(parentHooks.afterUpdate).toHaveBeenCalledTimes(2)
-  expect(parentHooks.afterEnter).toHaveBeenCalledTimes(1)
-
-  await router.push('parentB')
-
-  expect(parentHooks.beforeEnter).toHaveBeenCalledTimes(1)
-  expect(parentHooks.beforeUpdate).toHaveBeenCalledTimes(2)
-  expect(parentHooks.beforeLeave).toHaveBeenCalledTimes(1)
-  expect(parentHooks.afterLeave).toHaveBeenCalledTimes(1)
-  expect(parentHooks.afterUpdate).toHaveBeenCalledTimes(2)
-  expect(parentHooks.afterEnter).toHaveBeenCalledTimes(1)
-})
-
-test('external route hooks are called correctly', async () => {
+  });
+
+  await router.start();
+
+  expect(parentHooks.beforeEnter).toHaveBeenCalledTimes(1);
+  expect(parentHooks.beforeUpdate).toHaveBeenCalledTimes(0);
+  expect(parentHooks.beforeLeave).toHaveBeenCalledTimes(0);
+  expect(parentHooks.afterLeave).toHaveBeenCalledTimes(0);
+  expect(parentHooks.afterUpdate).toHaveBeenCalledTimes(0);
+  expect(parentHooks.afterEnter).toHaveBeenCalledTimes(1);
+
+  await router.push("child", { param: "param2" });
+
+  expect(parentHooks.beforeEnter).toHaveBeenCalledTimes(1);
+  expect(parentHooks.beforeUpdate).toHaveBeenCalledTimes(1);
+  expect(parentHooks.beforeLeave).toHaveBeenCalledTimes(0);
+  expect(parentHooks.afterLeave).toHaveBeenCalledTimes(0);
+  expect(parentHooks.afterUpdate).toHaveBeenCalledTimes(1);
+  expect(parentHooks.afterEnter).toHaveBeenCalledTimes(1);
+
+  await router.push("parentA");
+
+  expect(parentHooks.beforeEnter).toHaveBeenCalledTimes(1);
+  expect(parentHooks.beforeUpdate).toHaveBeenCalledTimes(2);
+  expect(parentHooks.beforeLeave).toHaveBeenCalledTimes(0);
+  expect(parentHooks.afterLeave).toHaveBeenCalledTimes(0);
+  expect(parentHooks.afterUpdate).toHaveBeenCalledTimes(2);
+  expect(parentHooks.afterEnter).toHaveBeenCalledTimes(1);
+
+  await router.push("parentB");
+
+  expect(parentHooks.beforeEnter).toHaveBeenCalledTimes(1);
+  expect(parentHooks.beforeUpdate).toHaveBeenCalledTimes(2);
+  expect(parentHooks.beforeLeave).toHaveBeenCalledTimes(1);
+  expect(parentHooks.afterLeave).toHaveBeenCalledTimes(1);
+  expect(parentHooks.afterUpdate).toHaveBeenCalledTimes(2);
+  expect(parentHooks.afterEnter).toHaveBeenCalledTimes(1);
+});
+
+test("external route hooks are called correctly", async () => {
   const internalHooks = {
     beforeEnter: vi.fn(),
     beforeLeave: vi.fn(),
@@ -178,165 +184,168 @@ test('external route hooks are called correctly', async () => {
     afterLeave: vi.fn(),
     afterUpdate: vi.fn(),
     onRejection: vi.fn(),
-  }
+  };
 
   const internal = createRoute({
-    name: 'internal',
-    path: '/',
-  })
+    name: "internal",
+    path: "/",
+  });
 
-  internal.onBeforeRouteEnter(() => internalHooks.beforeEnter())
-  internal.onBeforeRouteLeave(() => internalHooks.beforeLeave())
-  internal.onBeforeRouteUpdate(() => internalHooks.beforeUpdate())
-  internal.onAfterRouteEnter(() => internalHooks.afterEnter())
-  internal.onAfterRouteLeave(() => internalHooks.afterLeave())
-  internal.onAfterRouteUpdate(() => internalHooks.afterUpdate())
+  internal.onBeforeRouteEnter(() => internalHooks.beforeEnter());
+  internal.onBeforeRouteLeave(() => internalHooks.beforeLeave());
+  internal.onBeforeRouteUpdate(() => internalHooks.beforeUpdate());
+  internal.onAfterRouteEnter(() => internalHooks.afterEnter());
+  internal.onAfterRouteLeave(() => internalHooks.afterLeave());
+  internal.onAfterRouteUpdate(() => internalHooks.afterUpdate());
 
   const externalHooks = {
     beforeEnter: vi.fn(),
-  }
+  };
 
   const external = createExternalRoute({
-    name: 'external',
-    host: 'https://kitbag.dev',
-    path: '/',
-  })
+    name: "external",
+    host: "https://kitbag.dev",
+    path: "/",
+  });
 
-  external.onBeforeRouteEnter(() => externalHooks.beforeEnter())
+  external.onBeforeRouteEnter(() => externalHooks.beforeEnter());
 
   const router = createRouter([internal, external], {
-    initialUrl: '/',
-  })
+    initialUrl: "/",
+  });
 
   const root = {
-    template: '<RouterView />',
-  }
+    template: "<RouterView />",
+  };
 
   mount(root, {
     global: {
       plugins: [router],
     },
-  })
-
-  await router.start()
-
-  expect(internalHooks.beforeEnter).toHaveBeenCalledTimes(1)
-  expect(internalHooks.beforeUpdate).toHaveBeenCalledTimes(0)
-  expect(internalHooks.beforeLeave).toHaveBeenCalledTimes(0)
-  expect(internalHooks.afterLeave).toHaveBeenCalledTimes(0)
-  expect(internalHooks.afterUpdate).toHaveBeenCalledTimes(0)
-  expect(internalHooks.afterEnter).toHaveBeenCalledTimes(1)
-  expect(externalHooks.beforeEnter).toHaveBeenCalledTimes(0)
-  expect(internalHooks.onRejection).toHaveBeenCalledTimes(0)
-
-  await router.push('external')
-
-  expect(internalHooks.beforeEnter).toHaveBeenCalledTimes(1)
-  expect(internalHooks.beforeUpdate).toHaveBeenCalledTimes(0)
-  expect(internalHooks.beforeLeave).toHaveBeenCalledTimes(1)
-  expect(internalHooks.afterLeave).toHaveBeenCalledTimes(1)
-  expect(internalHooks.afterUpdate).toHaveBeenCalledTimes(0)
-  expect(internalHooks.afterEnter).toHaveBeenCalledTimes(1)
-  expect(externalHooks.beforeEnter).toHaveBeenCalledTimes(1)
-  expect(internalHooks.onRejection).toHaveBeenCalledTimes(0)
-})
-
-test('rejection hooks are called correctly', async () => {
-  const onRejection = vi.fn()
+  });
+
+  await router.start();
+
+  expect(internalHooks.beforeEnter).toHaveBeenCalledTimes(1);
+  expect(internalHooks.beforeUpdate).toHaveBeenCalledTimes(0);
+  expect(internalHooks.beforeLeave).toHaveBeenCalledTimes(0);
+  expect(internalHooks.afterLeave).toHaveBeenCalledTimes(0);
+  expect(internalHooks.afterUpdate).toHaveBeenCalledTimes(0);
+  expect(internalHooks.afterEnter).toHaveBeenCalledTimes(1);
+  expect(externalHooks.beforeEnter).toHaveBeenCalledTimes(0);
+  expect(internalHooks.onRejection).toHaveBeenCalledTimes(0);
+
+  await router.push("external");
+
+  expect(internalHooks.beforeEnter).toHaveBeenCalledTimes(1);
+  expect(internalHooks.beforeUpdate).toHaveBeenCalledTimes(0);
+  expect(internalHooks.beforeLeave).toHaveBeenCalledTimes(1);
+  expect(internalHooks.afterLeave).toHaveBeenCalledTimes(1);
+  expect(internalHooks.afterUpdate).toHaveBeenCalledTimes(0);
+  expect(internalHooks.afterEnter).toHaveBeenCalledTimes(1);
+  expect(externalHooks.beforeEnter).toHaveBeenCalledTimes(1);
+  expect(internalHooks.onRejection).toHaveBeenCalledTimes(0);
+});
+
+test("rejection hooks are called correctly", async () => {
+  const onRejection = vi.fn();
 
   const rejection = createRejection({
-    type: 'CustomRejection',
-  })
+    type: "CustomRejection",
+  });
 
-  rejection.onRejection((type, { to, from }) => onRejection(type, { to, from }))
+  rejection.onRejection((type, { to, from }) => onRejection(type, { to, from }));
 
-  const router = createRouter(routes, { initialUrl: '/', rejections: [rejection] })
-  
-  await router.start()
+  const router = createRouter(routes, { initialUrl: "/", rejections: [rejection] });
 
-  expect(onRejection).toHaveBeenCalledTimes(0)
+  await router.start();
 
-  router.reject('CustomRejection')
+  expect(onRejection).toHaveBeenCalledTimes(0);
 
-  expect(onRejection).toHaveBeenCalledTimes(1)
-  expect(onRejection).toHaveBeenCalledWith('CustomRejection', expect.objectContaining({
-    to: null,
-    from: null,
-  }))
-})
+  router.reject("CustomRejection");
 
-test('component hooks are called correctly', async () => {
+  expect(onRejection).toHaveBeenCalledTimes(1);
+  expect(onRejection).toHaveBeenCalledWith(
+    "CustomRejection",
+    expect.objectContaining({
+      to: null,
+      from: null,
+    }),
+  );
+});
+
+test("component hooks are called correctly", async () => {
   const parentHooks = {
     beforeUpdate: vi.fn(),
     beforeLeave: vi.fn(),
     afterLeave: vi.fn(),
     afterUpdate: vi.fn(),
-  }
+  };
 
   const parentA = createRoute({
-    name: 'parentA',
-    path: '/parentA',
+    name: "parentA",
+    path: "/parentA",
     component: {
       setup: () => {
-        onBeforeRouteUpdate(() => parentHooks.beforeUpdate())
-        onBeforeRouteLeave(() => parentHooks.beforeLeave())
-        onAfterRouteLeave(() => parentHooks.afterLeave())
-        onAfterRouteUpdate(() => parentHooks.afterUpdate())
+        onBeforeRouteUpdate(() => parentHooks.beforeUpdate());
+        onBeforeRouteLeave(() => parentHooks.beforeLeave());
+        onAfterRouteLeave(() => parentHooks.afterLeave());
+        onAfterRouteUpdate(() => parentHooks.afterUpdate());
       },
       render: () => h(RouterView),
     },
-  })
+  });
 
   const parentB = createRoute({
-    name: 'parentB',
-    path: '/parentB',
-  })
+    name: "parentB",
+    path: "/parentB",
+  });
 
   const child = createRoute({
-    name: 'child',
-    path: '/child/[param]',
+    name: "child",
+    path: "/child/[param]",
     parent: parentA,
-  })
+  });
 
   const router = createRouter([parentA, parentB, child], {
-    initialUrl: '/parentA',
-  })
+    initialUrl: "/parentA",
+  });
 
   const root = {
-    template: '<RouterView />',
-  }
+    template: "<RouterView />",
+  };
 
   mount(root, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  await router.start()
+  await router.start();
 
-  expect(parentHooks.beforeUpdate).toHaveBeenCalledTimes(0)
-  expect(parentHooks.beforeLeave).toHaveBeenCalledTimes(0)
-  expect(parentHooks.afterLeave).toHaveBeenCalledTimes(0)
-  expect(parentHooks.afterUpdate).toHaveBeenCalledTimes(0)
+  expect(parentHooks.beforeUpdate).toHaveBeenCalledTimes(0);
+  expect(parentHooks.beforeLeave).toHaveBeenCalledTimes(0);
+  expect(parentHooks.afterLeave).toHaveBeenCalledTimes(0);
+  expect(parentHooks.afterUpdate).toHaveBeenCalledTimes(0);
 
-  await router.push('child', { param: 'param2' })
+  await router.push("child", { param: "param2" });
 
-  expect(parentHooks.beforeUpdate).toHaveBeenCalledTimes(1)
-  expect(parentHooks.beforeLeave).toHaveBeenCalledTimes(0)
-  expect(parentHooks.afterLeave).toHaveBeenCalledTimes(0)
-  expect(parentHooks.afterUpdate).toHaveBeenCalledTimes(1)
+  expect(parentHooks.beforeUpdate).toHaveBeenCalledTimes(1);
+  expect(parentHooks.beforeLeave).toHaveBeenCalledTimes(0);
+  expect(parentHooks.afterLeave).toHaveBeenCalledTimes(0);
+  expect(parentHooks.afterUpdate).toHaveBeenCalledTimes(1);
 
-  await router.push('parentA', {})
+  await router.push("parentA", {});
 
-  expect(parentHooks.beforeUpdate).toHaveBeenCalledTimes(2)
-  expect(parentHooks.beforeLeave).toHaveBeenCalledTimes(0)
-  expect(parentHooks.afterLeave).toHaveBeenCalledTimes(0)
-  expect(parentHooks.afterUpdate).toHaveBeenCalledTimes(2)
+  expect(parentHooks.beforeUpdate).toHaveBeenCalledTimes(2);
+  expect(parentHooks.beforeLeave).toHaveBeenCalledTimes(0);
+  expect(parentHooks.afterLeave).toHaveBeenCalledTimes(0);
+  expect(parentHooks.afterUpdate).toHaveBeenCalledTimes(2);
 
-  await router.push('parentB')
+  await router.push("parentB");
 
-  expect(parentHooks.beforeUpdate).toHaveBeenCalledTimes(2)
-  expect(parentHooks.beforeLeave).toHaveBeenCalledTimes(1)
-  expect(parentHooks.afterLeave).toHaveBeenCalledTimes(1)
-  expect(parentHooks.afterUpdate).toHaveBeenCalledTimes(2)
-})
+  expect(parentHooks.beforeUpdate).toHaveBeenCalledTimes(2);
+  expect(parentHooks.beforeLeave).toHaveBeenCalledTimes(1);
+  expect(parentHooks.afterLeave).toHaveBeenCalledTimes(1);
+  expect(parentHooks.afterUpdate).toHaveBeenCalledTimes(2);
+});
diff --git a/src/services/hooks.spec.ts b/src/services/hooks.spec.ts
index 0f147b1f..abf52c30 100644
--- a/src/services/hooks.spec.ts
+++ b/src/services/hooks.spec.ts
@@ -1,247 +1,247 @@
-import { expect, test, vi } from 'vitest'
-import { createRouterHooks } from '@/services/createRouterHooks'
-import { BeforeEnterHook } from '@/types/hooks'
-import { ResolvedRoute } from '@/types/resolved'
-import { component } from '@/utilities/testHelpers'
-import { createRoute } from './createRoute'
-import { createResolvedRoute } from './createResolvedRoute'
-
-test('calls hook with correct routes', () => {
-  const hook = vi.fn()
-  const { runBeforeRouteHooks } = createRouterHooks()
+import { expect, test, vi } from "vite-plus/test";
+import { createRouterHooks } from "@/services/createRouterHooks";
+import { BeforeEnterHook } from "@/types/hooks";
+import { ResolvedRoute } from "@/types/resolved";
+import { component } from "@/utilities/testHelpers";
+import { createRoute } from "./createRoute";
+import { createResolvedRoute } from "./createResolvedRoute";
+
+test("calls hook with correct routes", () => {
+  const hook = vi.fn();
+  const { runBeforeRouteHooks } = createRouterHooks();
 
   const toRoute = createRoute({
     id: Math.random().toString(),
-    name: 'routeA',
+    name: "routeA",
     component,
-  })
+  });
 
-  toRoute.onBeforeRouteEnter(hook)
+  toRoute.onBeforeRouteEnter(hook);
 
   const fromRoute = createRoute({
     id: Math.random().toString(),
-    name: 'routeB',
+    name: "routeB",
     component,
-  })
+  });
 
-  const to = createResolvedRoute(toRoute, {})
-  const from = createResolvedRoute(fromRoute, {})
+  const to = createResolvedRoute(toRoute, {});
+  const from = createResolvedRoute(fromRoute, {});
 
-  runBeforeRouteHooks({ to, from })
+  runBeforeRouteHooks({ to, from });
 
-  expect(hook).toHaveBeenCalledOnce()
-})
+  expect(hook).toHaveBeenCalledOnce();
+});
 
-test.each<{ type: string, status: string, hook: BeforeEnterHook }>([
+test.each<{ type: string; status: string; hook: BeforeEnterHook }>([
   {
-    type: 'reject',
-    status: 'REJECT',
+    type: "reject",
+    status: "REJECT",
     hook: (_to, { reject }) => {
-      reject('NotFound')
+      reject("NotFound");
     },
   },
-  { type: 'push', status: 'PUSH', hook: (_to, { push }) => push('/') },
-  { type: 'replace', status: 'PUSH', hook: (_to, { replace }) => replace('/') },
-  { type: 'update', status: 'PUSH', hook: (_to, { update }) => update('paramName', 'value') },
+  { type: "push", status: "PUSH", hook: (_to, { push }) => push("/") },
+  { type: "replace", status: "PUSH", hook: (_to, { replace }) => replace("/") },
+  { type: "update", status: "PUSH", hook: (_to, { update }) => update("paramName", "value") },
   {
-    type: 'abort',
-    status: 'ABORT',
+    type: "abort",
+    status: "ABORT",
     hook: (_to, { abort }) => {
-      abort()
+      abort();
     },
   },
-])('Returns correct status when hook is called', async ({ status, hook }) => {
-  const { runBeforeRouteHooks } = createRouterHooks()
+])("Returns correct status when hook is called", async ({ status, hook }) => {
+  const { runBeforeRouteHooks } = createRouterHooks();
 
   const toRoute = createRoute({
     id: Math.random().toString(),
-    name: 'routeA',
+    name: "routeA",
     component,
-  })
+  });
 
-  toRoute.onBeforeRouteEnter(hook)
+  toRoute.onBeforeRouteEnter(hook);
 
   const fromRoute = createRoute({
     id: Math.random().toString(),
-    name: 'routeB',
+    name: "routeB",
     component,
-  })
+  });
 
-  fromRoute.onBeforeRouteEnter(hook)
+  fromRoute.onBeforeRouteEnter(hook);
 
-  const to = createResolvedRoute(toRoute, {})
-  const from = createResolvedRoute(fromRoute, {})
+  const to = createResolvedRoute(toRoute, {});
+  const from = createResolvedRoute(fromRoute, {});
 
-  const response = await runBeforeRouteHooks({ to, from })
+  const response = await runBeforeRouteHooks({ to, from });
 
-  expect(response.status).toBe(status)
-})
+  expect(response.status).toBe(status);
+});
 
-test('hook is called in order', async () => {
-  const hookA = vi.fn()
-  const hookB = vi.fn()
-  const hookC = vi.fn()
-  const { runBeforeRouteHooks } = createRouterHooks()
+test("hook is called in order", async () => {
+  const hookA = vi.fn();
+  const hookB = vi.fn();
+  const hookC = vi.fn();
+  const { runBeforeRouteHooks } = createRouterHooks();
 
   const toRoute = createRoute({
     id: Math.random().toString(),
-    name: 'routeA',
+    name: "routeA",
     component,
-  })
+  });
 
-  toRoute.onBeforeRouteEnter(hookA)
-  toRoute.onBeforeRouteEnter(hookB)
-  toRoute.onBeforeRouteEnter(hookC)
+  toRoute.onBeforeRouteEnter(hookA);
+  toRoute.onBeforeRouteEnter(hookB);
+  toRoute.onBeforeRouteEnter(hookC);
 
   const fromRoute = createRoute({
     id: Math.random().toString(),
-    name: 'routeB',
+    name: "routeB",
     component,
-  })
+  });
 
-  const to = createResolvedRoute(toRoute, {})
-  const from = createResolvedRoute(fromRoute, {})
+  const to = createResolvedRoute(toRoute, {});
+  const from = createResolvedRoute(fromRoute, {});
 
-  await runBeforeRouteHooks({ to, from })
+  await runBeforeRouteHooks({ to, from });
 
-  const [orderA] = hookA.mock.invocationCallOrder
-  const [orderB] = hookB.mock.invocationCallOrder
-  const [orderC] = hookC.mock.invocationCallOrder
+  const [orderA] = hookA.mock.invocationCallOrder;
+  const [orderB] = hookB.mock.invocationCallOrder;
+  const [orderC] = hookC.mock.invocationCallOrder;
 
-  expect(orderA).toBeLessThan(orderB)
-  expect(orderB).toBeLessThan(orderC)
-})
+  expect(orderA).toBeLessThan(orderB);
+  expect(orderB).toBeLessThan(orderC);
+});
 
-test('multiple onError callbacks run in order', () => {
+test("multiple onError callbacks run in order", () => {
   const errorHook1 = vi.fn((error) => {
-    throw error
-  })
-  const errorHook2 = vi.fn()
-  const errorHook3 = vi.fn()
+    throw error;
+  });
+  const errorHook2 = vi.fn();
+  const errorHook3 = vi.fn();
 
-  const { runErrorHooks, onError } = createRouterHooks()
+  const { runErrorHooks, onError } = createRouterHooks();
 
-  onError(errorHook1)
-  onError(errorHook2)
-  onError(errorHook3)
+  onError(errorHook1);
+  onError(errorHook2);
+  onError(errorHook3);
 
-  const testError = new Error('Test error')
+  const testError = new Error("Test error");
   const toRoute = createRoute({
-    name: 'routeA',
+    name: "routeA",
     component,
-    href: '/',
-    hash: '',
-  })
+    href: "/",
+    hash: "",
+  });
 
-  const to = createResolvedRoute(toRoute, {})
-  const from: ResolvedRoute | null = null
+  const to = createResolvedRoute(toRoute, {});
+  const from: ResolvedRoute | null = null;
 
-  runErrorHooks(testError, { to, from, source: 'hook' })
+  runErrorHooks(testError, { to, from, source: "hook" });
 
-  expect(errorHook1).toHaveBeenCalledOnce()
-  expect(errorHook2).toHaveBeenCalledOnce()
-  expect(errorHook3).not.toHaveBeenCalled()
+  expect(errorHook1).toHaveBeenCalledOnce();
+  expect(errorHook2).toHaveBeenCalledOnce();
+  expect(errorHook3).not.toHaveBeenCalled();
 
-  const [order1] = errorHook1.mock.invocationCallOrder
-  const [order2] = errorHook2.mock.invocationCallOrder
+  const [order1] = errorHook1.mock.invocationCallOrder;
+  const [order2] = errorHook2.mock.invocationCallOrder;
 
-  expect(order1).toBeLessThan(order2)
-})
+  expect(order1).toBeLessThan(order2);
+});
 
-test('when onError callback calls reject, other onError callbacks do not run', () => {
+test("when onError callback calls reject, other onError callbacks do not run", () => {
   const errorHook1 = vi.fn((_error, { reject }) => {
-    reject('NotFound')
-    return true
-  })
-  const errorHook2 = vi.fn(() => false)
-  const errorHook3 = vi.fn(() => false)
-  const { runErrorHooks, onError } = createRouterHooks()
-
-  onError(errorHook1)
-  onError(errorHook2)
-  onError(errorHook3)
-
-  const testError = new Error('Test error')
+    reject("NotFound");
+    return true;
+  });
+  const errorHook2 = vi.fn(() => false);
+  const errorHook3 = vi.fn(() => false);
+  const { runErrorHooks, onError } = createRouterHooks();
+
+  onError(errorHook1);
+  onError(errorHook2);
+  onError(errorHook3);
+
+  const testError = new Error("Test error");
   const toRoute = createRoute({
-    name: 'routeA',
+    name: "routeA",
     component,
-    href: '/',
-    hash: '',
-  })
+    href: "/",
+    hash: "",
+  });
 
-  const to = createResolvedRoute(toRoute, {})
-  const from: ResolvedRoute | null = null
+  const to = createResolvedRoute(toRoute, {});
+  const from: ResolvedRoute | null = null;
 
   expect(() => {
-    runErrorHooks(testError, { to, from, source: 'hook' })
-  }).toThrow()
+    runErrorHooks(testError, { to, from, source: "hook" });
+  }).toThrow();
 
-  expect(errorHook1).toHaveBeenCalledOnce()
-  expect(errorHook2).not.toHaveBeenCalled()
-  expect(errorHook3).not.toHaveBeenCalled()
-})
+  expect(errorHook1).toHaveBeenCalledOnce();
+  expect(errorHook2).not.toHaveBeenCalled();
+  expect(errorHook3).not.toHaveBeenCalled();
+});
 
-test('when onError callback calls push, other onError callbacks do not run', () => {
+test("when onError callback calls push, other onError callbacks do not run", () => {
   const errorHook1 = vi.fn((_error, { push }) => {
-    push('/other')
-  })
-  const errorHook2 = vi.fn()
-  const errorHook3 = vi.fn()
-  const { runErrorHooks, onError } = createRouterHooks()
+    push("/other");
+  });
+  const errorHook2 = vi.fn();
+  const errorHook3 = vi.fn();
+  const { runErrorHooks, onError } = createRouterHooks();
 
-  onError(errorHook1)
-  onError(errorHook2)
-  onError(errorHook3)
+  onError(errorHook1);
+  onError(errorHook2);
+  onError(errorHook3);
 
-  const testError = new Error('Test error')
+  const testError = new Error("Test error");
   const toRoute = createRoute({
     id: Math.random().toString(),
-    name: 'routeA',
+    name: "routeA",
     component,
-    href: '/',
-    hash: '',
-  })
+    href: "/",
+    hash: "",
+  });
 
-  const to = createResolvedRoute(toRoute, {})
-  const from: ResolvedRoute | null = null
+  const to = createResolvedRoute(toRoute, {});
+  const from: ResolvedRoute | null = null;
 
   expect(() => {
-    runErrorHooks(testError, { to, from, source: 'hook' })
-  }).toThrow()
+    runErrorHooks(testError, { to, from, source: "hook" });
+  }).toThrow();
 
-  expect(errorHook1).toHaveBeenCalledOnce()
-  expect(errorHook2).not.toHaveBeenCalled()
-  expect(errorHook3).not.toHaveBeenCalled()
-})
+  expect(errorHook1).toHaveBeenCalledOnce();
+  expect(errorHook2).not.toHaveBeenCalled();
+  expect(errorHook3).not.toHaveBeenCalled();
+});
 
-test('when onError callback calls replace, other onError callbacks do not run', () => {
+test("when onError callback calls replace, other onError callbacks do not run", () => {
   const errorHook1 = vi.fn((_error, { replace }) => {
-    replace('/other')
-  })
-  const errorHook2 = vi.fn()
-  const errorHook3 = vi.fn()
-  const { runErrorHooks, onError } = createRouterHooks()
+    replace("/other");
+  });
+  const errorHook2 = vi.fn();
+  const errorHook3 = vi.fn();
+  const { runErrorHooks, onError } = createRouterHooks();
 
-  onError(errorHook1)
-  onError(errorHook2)
-  onError(errorHook3)
+  onError(errorHook1);
+  onError(errorHook2);
+  onError(errorHook3);
 
-  const testError = new Error('Test error')
+  const testError = new Error("Test error");
   const toRoute = createRoute({
-    name: 'routeA',
+    name: "routeA",
     component,
-    href: '/',
-    hash: '',
-  })
+    href: "/",
+    hash: "",
+  });
 
-  const to = createResolvedRoute(toRoute, {})
-  const from: ResolvedRoute | null = null
+  const to = createResolvedRoute(toRoute, {});
+  const from: ResolvedRoute | null = null;
 
   expect(() => {
-    runErrorHooks(testError, { to, from, source: 'hook' })
-  }).toThrow()
+    runErrorHooks(testError, { to, from, source: "hook" });
+  }).toThrow();
 
-  expect(errorHook1).toHaveBeenCalledOnce()
-  expect(errorHook2).not.toHaveBeenCalled()
-  expect(errorHook3).not.toHaveBeenCalled()
-})
+  expect(errorHook1).toHaveBeenCalledOnce();
+  expect(errorHook2).not.toHaveBeenCalled();
+  expect(errorHook3).not.toHaveBeenCalled();
+});
diff --git a/src/services/insertBaseRoute.spec.ts b/src/services/insertBaseRoute.spec.ts
index 2955afa5..6441236b 100644
--- a/src/services/insertBaseRoute.spec.ts
+++ b/src/services/insertBaseRoute.spec.ts
@@ -1,24 +1,24 @@
-import { expect, test } from 'vitest'
-import { createRoute } from '@/services/createRoute'
-import { insertBaseRoute } from '@/services/insertBaseRoute'
+import { expect, test } from "vite-plus/test";
+import { createRoute } from "@/services/createRoute";
+import { insertBaseRoute } from "@/services/insertBaseRoute";
 
-test.each([
-  [undefined],
-  [''],
-])('given empty or undefined base, returns route unmodified', (base) => {
-  const route = createRoute({ name: 'foo', path: '/foo' })
+test.each([[undefined], [""]])(
+  "given empty or undefined base, returns route unmodified",
+  (base) => {
+    const route = createRoute({ name: "foo", path: "/foo" });
 
-  const response = insertBaseRoute(route, base)
+    const response = insertBaseRoute(route, base);
 
-  expect(response).toMatchObject(route)
-})
+    expect(response).toMatchObject(route);
+  },
+);
 
-test('given value for base, returns route with base prefixed', () => {
-  const base = '/kitbag'
+test("given value for base, returns route with base prefixed", () => {
+  const base = "/kitbag";
 
-  const route = createRoute({ name: 'foo', path: '/foo' })
+  const route = createRoute({ name: "foo", path: "/foo" });
 
-  const response = insertBaseRoute(route, base)
+  const response = insertBaseRoute(route, base);
 
-  expect(response.stringify()).toBe('/kitbag/foo')
-})
+  expect(response.stringify()).toBe("/kitbag/foo");
+});
diff --git a/src/services/params.spec.ts b/src/services/params.spec.ts
index b40a306f..dd75bed0 100644
--- a/src/services/params.spec.ts
+++ b/src/services/params.spec.ts
@@ -1,194 +1,202 @@
-import { describe, expect, test } from 'vitest'
-import { InvalidRouteParamValueError } from '@/errors/invalidRouteParamValueError'
-import { getParamValue, setParamValue } from '@/services/params'
-import { withDefault } from '@/services/withDefault'
-import { ParamGetSet, ParamGetter } from '@/types/paramTypes'
-
-describe('getParamValue', () => {
-  test('given Boolean constructor Param, returns for correct value for Boolean', () => {
-    expect(getParamValue('true', { param: Boolean })).toBe(true)
-    expect(getParamValue('false', { param: Boolean })).toBe(false)
-    expect(() => getParamValue('foo', { param: Boolean })).toThrow(InvalidRouteParamValueError)
-  })
-
-  test('given Number constructor Param, returns for correct value for Number', () => {
-    expect(getParamValue('1', { param: Number })).toBe(1)
-    expect(getParamValue('1.5', { param: Number })).toBe(1.5)
-    expect(() => getParamValue('foo', { param: Number })).toThrow(InvalidRouteParamValueError)
-  })
-
-  test('Given a JSON Param, returns correct value for JSON', () => {
-    expect(getParamValue('1', { param: JSON })).toBe(1)
-    expect(getParamValue('"foo"', { param: JSON })).toBe('foo')
-    expect(() => getParamValue('foo', { param: JSON })).toThrow(InvalidRouteParamValueError)
-  })
-
-  test('given Date constructor Param, returns for correct value for Date', () => {
-    expect(getParamValue('2024-05-16T21:13:56.842Z', { param: Date })).toMatchObject(new Date('2024-05-16T21:13:56.842Z'))
-    expect(() => getParamValue('foo', { param: Date })).toThrow(InvalidRouteParamValueError)
-  })
-
-  test('Given Regex Param, returns for correct value for RegExp', () => {
-    const param = /yes/
-
-    expect(getParamValue('yes', { param })).toBe('yes')
-    expect(() => getParamValue('no', { param })).toThrow(InvalidRouteParamValueError)
-    expect(() => getParamValue('foo', { param })).toThrow(InvalidRouteParamValueError)
-  })
-
-  test('given Literal Param, with matching value, returns value', () => {
-    expect(getParamValue('foo', { param: 'foo' })).toBe('foo')
-    expect(getParamValue('1', { param: 1 })).toBe(1)
-    expect(getParamValue('true', { param: true })).toBe(true)
-  })
-
-  test('given Literal Param, with non-matching value, throws InvalidRouteParamValueError', () => {
-    expect(() => getParamValue('foo', { param: 'bar' })).toThrow(InvalidRouteParamValueError)
-    expect(() => getParamValue('1', { param: 2 })).toThrow(InvalidRouteParamValueError)
-    expect(() => getParamValue('true', { param: false })).toThrow(InvalidRouteParamValueError)
-  })
-
-  test.each([
-    [undefined],
-    [''],
-  ])('Given Optional Param and string without value, returns undefined', (stringWithoutValue) => {
-    const paramTypes = [String, Number, Boolean, Date, JSON, /regexp/g, () => 'getter']
-
-    for (const param of paramTypes) {
-      expect(getParamValue(stringWithoutValue, { param, isOptional: true })).toBe(undefined)
-    }
-  })
-
-  test.each([
-    [undefined],
-    [''],
-  ])('Given Optional Param with default and string without value, returns default value', (stringWithoutValue) => {
-    const paramTypes = [String, Number, Boolean, Date, JSON, /regexp/g, () => 'getter']
-
-    for (const param of paramTypes) {
-      expect(getParamValue(stringWithoutValue, { param: withDefault(param, 'abc'), isOptional: true })).toBe('abc')
-    }
-  })
+import { describe, expect, test } from "vite-plus/test";
+import { InvalidRouteParamValueError } from "@/errors/invalidRouteParamValueError";
+import { getParamValue, setParamValue } from "@/services/params";
+import { withDefault } from "@/services/withDefault";
+import { ParamGetSet, ParamGetter } from "@/types/paramTypes";
+
+describe("getParamValue", () => {
+  test("given Boolean constructor Param, returns for correct value for Boolean", () => {
+    expect(getParamValue("true", { param: Boolean })).toBe(true);
+    expect(getParamValue("false", { param: Boolean })).toBe(false);
+    expect(() => getParamValue("foo", { param: Boolean })).toThrow(InvalidRouteParamValueError);
+  });
+
+  test("given Number constructor Param, returns for correct value for Number", () => {
+    expect(getParamValue("1", { param: Number })).toBe(1);
+    expect(getParamValue("1.5", { param: Number })).toBe(1.5);
+    expect(() => getParamValue("foo", { param: Number })).toThrow(InvalidRouteParamValueError);
+  });
+
+  test("Given a JSON Param, returns correct value for JSON", () => {
+    expect(getParamValue("1", { param: JSON })).toBe(1);
+    expect(getParamValue('"foo"', { param: JSON })).toBe("foo");
+    expect(() => getParamValue("foo", { param: JSON })).toThrow(InvalidRouteParamValueError);
+  });
+
+  test("given Date constructor Param, returns for correct value for Date", () => {
+    expect(getParamValue("2024-05-16T21:13:56.842Z", { param: Date })).toMatchObject(
+      new Date("2024-05-16T21:13:56.842Z"),
+    );
+    expect(() => getParamValue("foo", { param: Date })).toThrow(InvalidRouteParamValueError);
+  });
+
+  test("Given Regex Param, returns for correct value for RegExp", () => {
+    const param = /yes/;
+
+    expect(getParamValue("yes", { param })).toBe("yes");
+    expect(() => getParamValue("no", { param })).toThrow(InvalidRouteParamValueError);
+    expect(() => getParamValue("foo", { param })).toThrow(InvalidRouteParamValueError);
+  });
+
+  test("given Literal Param, with matching value, returns value", () => {
+    expect(getParamValue("foo", { param: "foo" })).toBe("foo");
+    expect(getParamValue("1", { param: 1 })).toBe(1);
+    expect(getParamValue("true", { param: true })).toBe(true);
+  });
+
+  test("given Literal Param, with non-matching value, throws InvalidRouteParamValueError", () => {
+    expect(() => getParamValue("foo", { param: "bar" })).toThrow(InvalidRouteParamValueError);
+    expect(() => getParamValue("1", { param: 2 })).toThrow(InvalidRouteParamValueError);
+    expect(() => getParamValue("true", { param: false })).toThrow(InvalidRouteParamValueError);
+  });
+
+  test.each([[undefined], [""]])(
+    "Given Optional Param and string without value, returns undefined",
+    (stringWithoutValue) => {
+      const paramTypes = [String, Number, Boolean, Date, JSON, /regexp/g, () => "getter"];
+
+      for (const param of paramTypes) {
+        expect(getParamValue(stringWithoutValue, { param, isOptional: true })).toBe(undefined);
+      }
+    },
+  );
+
+  test.each([[undefined], [""]])(
+    "Given Optional Param with default and string without value, returns default value",
+    (stringWithoutValue) => {
+      const paramTypes = [String, Number, Boolean, Date, JSON, /regexp/g, () => "getter"];
+
+      for (const param of paramTypes) {
+        expect(
+          getParamValue(stringWithoutValue, { param: withDefault(param, "abc"), isOptional: true }),
+        ).toBe("abc");
+      }
+    },
+  );
 
-  test('Given Custom Getter Param, returns for correct value for ParamGetter', () => {
-    const param: ParamGetter<'yes'> = (value, { invalid }) => {
-      if (value !== 'yes') {
-        invalid()
+  test("Given Custom Getter Param, returns for correct value for ParamGetter", () => {
+    const param: ParamGetter<"yes"> = (value, { invalid }) => {
+      if (value !== "yes") {
+        invalid();
       }
 
-      return 'yes'
-    }
+      return "yes";
+    };
 
-    expect(getParamValue('yes', { param })).toBe('yes')
-    expect(() => getParamValue('no', { param })).toThrowError()
-    expect(() => getParamValue('foo', { param })).toThrowError()
-  })
+    expect(getParamValue("yes", { param })).toBe("yes");
+    expect(() => getParamValue("no", { param })).toThrowError();
+    expect(() => getParamValue("foo", { param })).toThrowError();
+  });
 
-  test('Given Custom GetSet, returns correct value for ParamGetSet', () => {
-    const getter: ParamGetSet<'yes'> = {
+  test("Given Custom GetSet, returns correct value for ParamGetSet", () => {
+    const getter: ParamGetSet<"yes"> = {
       get: (value, { invalid }) => {
-        if (value !== 'yes') {
-          invalid()
+        if (value !== "yes") {
+          invalid();
         }
 
-        return 'yes'
+        return "yes";
       },
       set: (value) => value,
-    }
-
-    expect(getParamValue('yes', { param: getter })).toBe('yes')
-    expect(() => getParamValue('no', { param: getter })).toThrowError()
-    expect(() => getParamValue('foo', { param: getter })).toThrowError()
-  })
-})
-
-describe('setParamValue', () => {
-  test('Given Boolean Param, returns for correct value for Boolean', () => {
-    expect(setParamValue(true, { param: Boolean })).toBe('true')
-    expect(setParamValue(false, { param: Boolean })).toBe('false')
-    expect(() => setParamValue('foo', { param: Boolean })).toThrow(InvalidRouteParamValueError)
-  })
-
-  test('Given Number Param, returns for correct value for Number', () => {
-    expect(setParamValue(1, { param: Number })).toBe('1')
-    expect(setParamValue(1.5, { param: Number })).toBe('1.5')
-    expect(() => setParamValue('foo', { param: Number })).toThrow(InvalidRouteParamValueError)
-  })
-
-  test('given  Date constructor Param, returns for correct value for Date', () => {
-    expect(setParamValue(new Date('2024-05-16T21:13:56.842Z'), { param: Date })).toBe('2024-05-16T21:13:56.842Z')
-    expect(() => setParamValue('foo', { param: Date })).toThrow(InvalidRouteParamValueError)
-  })
-
-  test('Given a JSON Param, returns correct value for JSON', () => {
-    expect(setParamValue(['foo'], { param: JSON })).toBe('["foo"]')
-    expect(setParamValue(1.5, { param: JSON })).toBe('1.5')
-
-    const circular: Record<string, any> = { foo: 'bar' }
-    circular.foo = circular
-
-    expect(() => setParamValue(circular, { param: JSON })).toThrow(InvalidRouteParamValueError)
-  })
-
-  test('Given Regex Param, returns value as String', () => {
-    const param = /yes/
-
-    expect(setParamValue('yes', { param })).toBe('yes')
-  })
-
-  test('Given Literal Param, with matching value, returns value', () => {
-    expect(setParamValue('foo', { param: 'foo' })).toBe('foo')
-    expect(setParamValue(1, { param: 1 })).toBe('1')
-    expect(setParamValue(true, { param: true })).toBe('true')
-  })
-
-  test('Given Literal Param, with non-matching value, throws InvalidRouteParamValueError', () => {
-    expect(() => setParamValue('foo', { param: 'bar' })).toThrow(InvalidRouteParamValueError)
-    expect(() => setParamValue(1, { param: 2 })).toThrow(InvalidRouteParamValueError)
-    expect(() => setParamValue(true, { param: false })).toThrow(InvalidRouteParamValueError)
-  })
-
-  test('Given Optional Param and value undefined, assigns empty string', () => {
-    const paramTypes = [String, Number, Boolean, Date, JSON, /regexp/g, () => 'getter']
+    };
+
+    expect(getParamValue("yes", { param: getter })).toBe("yes");
+    expect(() => getParamValue("no", { param: getter })).toThrowError();
+    expect(() => getParamValue("foo", { param: getter })).toThrowError();
+  });
+});
+
+describe("setParamValue", () => {
+  test("Given Boolean Param, returns for correct value for Boolean", () => {
+    expect(setParamValue(true, { param: Boolean })).toBe("true");
+    expect(setParamValue(false, { param: Boolean })).toBe("false");
+    expect(() => setParamValue("foo", { param: Boolean })).toThrow(InvalidRouteParamValueError);
+  });
+
+  test("Given Number Param, returns for correct value for Number", () => {
+    expect(setParamValue(1, { param: Number })).toBe("1");
+    expect(setParamValue(1.5, { param: Number })).toBe("1.5");
+    expect(() => setParamValue("foo", { param: Number })).toThrow(InvalidRouteParamValueError);
+  });
+
+  test("given  Date constructor Param, returns for correct value for Date", () => {
+    expect(setParamValue(new Date("2024-05-16T21:13:56.842Z"), { param: Date })).toBe(
+      "2024-05-16T21:13:56.842Z",
+    );
+    expect(() => setParamValue("foo", { param: Date })).toThrow(InvalidRouteParamValueError);
+  });
+
+  test("Given a JSON Param, returns correct value for JSON", () => {
+    expect(setParamValue(["foo"], { param: JSON })).toBe('["foo"]');
+    expect(setParamValue(1.5, { param: JSON })).toBe("1.5");
+
+    const circular: Record<string, any> = { foo: "bar" };
+    circular.foo = circular;
+
+    expect(() => setParamValue(circular, { param: JSON })).toThrow(InvalidRouteParamValueError);
+  });
+
+  test("Given Regex Param, returns value as String", () => {
+    const param = /yes/;
+
+    expect(setParamValue("yes", { param })).toBe("yes");
+  });
+
+  test("Given Literal Param, with matching value, returns value", () => {
+    expect(setParamValue("foo", { param: "foo" })).toBe("foo");
+    expect(setParamValue(1, { param: 1 })).toBe("1");
+    expect(setParamValue(true, { param: true })).toBe("true");
+  });
+
+  test("Given Literal Param, with non-matching value, throws InvalidRouteParamValueError", () => {
+    expect(() => setParamValue("foo", { param: "bar" })).toThrow(InvalidRouteParamValueError);
+    expect(() => setParamValue(1, { param: 2 })).toThrow(InvalidRouteParamValueError);
+    expect(() => setParamValue(true, { param: false })).toThrow(InvalidRouteParamValueError);
+  });
+
+  test("Given Optional Param and value undefined, assigns empty string", () => {
+    const paramTypes = [String, Number, Boolean, Date, JSON, /regexp/g, () => "getter"];
 
     for (const param of paramTypes) {
-      expect(setParamValue(undefined, { param, isOptional: true })).toBe('')
-      expect(setParamValue(undefined, { param: withDefault(param, 'abc'), isOptional: true })).toBe('')
+      expect(setParamValue(undefined, { param, isOptional: true })).toBe("");
+      expect(setParamValue(undefined, { param: withDefault(param, "abc"), isOptional: true })).toBe(
+        "",
+      );
     }
-  })
+  });
 
-  test('Given Getter Custom Param, returns value as String', () => {
+  test("Given Getter Custom Param, returns value as String", () => {
     const param: ParamGetter = (value, { invalid }) => {
-      if (value !== 'yes') {
-        invalid()
+      if (value !== "yes") {
+        invalid();
       }
 
-      return 'yes'
-    }
+      return "yes";
+    };
 
-    expect(setParamValue('yes', { param })).toBe('yes')
-  })
+    expect(setParamValue("yes", { param })).toBe("yes");
+  });
 
-  test('Given Custom GetSet Param, returns correct value for ParamGetSet', () => {
+  test("Given Custom GetSet Param, returns correct value for ParamGetSet", () => {
     const param: ParamGetSet = {
       get: (value, { invalid }) => {
-        if (value !== 'yes') {
-          invalid()
+        if (value !== "yes") {
+          invalid();
         }
 
-        return 'yes'
+        return "yes";
       },
       set: (value, { invalid }) => {
-        if (value !== 'yes') {
-          invalid()
+        if (value !== "yes") {
+          invalid();
         }
 
-        return 'yes'
+        return "yes";
       },
-    }
+    };
 
-    expect(setParamValue('yes', { param })).toBe('yes')
-    expect(() => setParamValue('no', { param })).toThrowError()
-    expect(() => setParamValue('foo', { param })).toThrowError()
-  })
-})
+    expect(setParamValue("yes", { param })).toBe("yes");
+    expect(() => setParamValue("no", { param })).toThrowError();
+    expect(() => setParamValue("foo", { param })).toThrowError();
+  });
+});
diff --git a/src/services/paramsFinder.spec.ts b/src/services/paramsFinder.spec.ts
index 9b72711f..190ed40f 100644
--- a/src/services/paramsFinder.spec.ts
+++ b/src/services/paramsFinder.spec.ts
@@ -1,85 +1,86 @@
-import { describe, expect, test } from 'vitest'
-import { InvalidRouteParamValueError } from '@/errors/invalidRouteParamValueError'
-import { getParamValueFromUrl, setParamValueOnUrl } from '@/services/paramsFinder'
-import { withParams } from '@/services/withParams'
+import { describe, expect, test } from "vite-plus/test";
+import { InvalidRouteParamValueError } from "@/errors/invalidRouteParamValueError";
+import { getParamValueFromUrl, setParamValueOnUrl } from "@/services/paramsFinder";
+import { withParams } from "@/services/withParams";
 
-describe('getParamValueFromUrl', () => {
-  test('given path WITHOUT params, always returns undefined', () => {
-    const path = withParams('/no-params', {})
-    const response = getParamValueFromUrl('/no-params', path, 'key')
+describe("getParamValueFromUrl", () => {
+  test("given path WITHOUT params, always returns undefined", () => {
+    const path = withParams("/no-params", {});
+    const response = getParamValueFromUrl("/no-params", path, "key");
 
-    expect(response).toBe(undefined)
-  })
+    expect(response).toBe(undefined);
+  });
 
-  test('given paramName that does NOT match param on route, always returns undefined', () => {
-    const path = withParams('/key/[key]/not-in/[route]', {})
-    const response = getParamValueFromUrl('/key/ABC/not-in/123', path, 'fail')
+  test("given paramName that does NOT match param on route, always returns undefined", () => {
+    const path = withParams("/key/[key]/not-in/[route]", {});
+    const response = getParamValueFromUrl("/key/ABC/not-in/123", path, "fail");
 
-    expect(response).toBe(undefined)
-  })
+    expect(response).toBe(undefined);
+  });
 
-  test('given paramName that matches param on route but value is not present, always returns undefined', () => {
-    const path = withParams('/simple/[simple]', {})
-    const response = getParamValueFromUrl('/simple', path, 'simple')
+  test("given paramName that matches param on route but value is not present, always returns undefined", () => {
+    const path = withParams("/simple/[simple]", {});
+    const response = getParamValueFromUrl("/simple", path, "simple");
 
-    expect(response).toBe(undefined)
-  })
+    expect(response).toBe(undefined);
+  });
 
-  test('given paramName that matches param on route, returns value', () => {
-    const path = withParams('/simple/[simple]', {})
-    const response = getParamValueFromUrl('/simple/ABC', path, 'simple')
+  test("given paramName that matches param on route, returns value", () => {
+    const path = withParams("/simple/[simple]", {});
+    const response = getParamValueFromUrl("/simple/ABC", path, "simple");
 
-    expect(response).toBe('ABC')
-  })
+    expect(response).toBe("ABC");
+  });
 
-  test('given multiple params, uses wildcards for non-selected param name', () => {
-    const path = withParams('/[str]/[num]/[bool]', {})
-    const response = getParamValueFromUrl('/ABC/123/true', path, 'num')
+  test("given multiple params, uses wildcards for non-selected param name", () => {
+    const path = withParams("/[str]/[num]/[bool]", {});
+    const response = getParamValueFromUrl("/ABC/123/true", path, "num");
 
-    expect(response).toBe('123')
-  })
+    expect(response).toBe("123");
+  });
 
-  test('given multiple params, where optional params are omitted from path, still finds the required param', () => {
-    const path = withParams('/[required]/[?optional]', {})
-    const response = getParamValueFromUrl('/ABC/', path, 'required')
+  test("given multiple params, where optional params are omitted from path, still finds the required param", () => {
+    const path = withParams("/[required]/[?optional]", {});
+    const response = getParamValueFromUrl("/ABC/", path, "required");
 
-    expect(response).toBe('ABC')
-  })
+    expect(response).toBe("ABC");
+  });
 
-  test('given path with greedy param, extracts multi-segment value for greedy param', () => {
-    const path = withParams('/[id]/[rest*]/suffix', {})
+  test("given path with greedy param, extracts multi-segment value for greedy param", () => {
+    const path = withParams("/[id]/[rest*]/suffix", {});
 
-    expect(getParamValueFromUrl('/1/a/b/c/suffix', path, 'rest')).toBe('a/b/c')
-    expect(getParamValueFromUrl('/1/a/b/c/suffix', path, 'id')).toBe('1')
-  })
-})
+    expect(getParamValueFromUrl("/1/a/b/c/suffix", path, "rest")).toBe("a/b/c");
+    expect(getParamValueFromUrl("/1/a/b/c/suffix", path, "id")).toBe("1");
+  });
+});
 
-describe('setParamValueOnUrl', () => {
-  test('given path WITHOUT params, always returns url as it was passed', () => {
-    const path = withParams('/no-params', {})
-    const response = setParamValueOnUrl('/no-params', path, 'key', 'ABC')
+describe("setParamValueOnUrl", () => {
+  test("given path WITHOUT params, always returns url as it was passed", () => {
+    const path = withParams("/no-params", {});
+    const response = setParamValueOnUrl("/no-params", path, "key", "ABC");
 
-    expect(response).toBe('/no-params')
-  })
+    expect(response).toBe("/no-params");
+  });
 
-  test('given paramName that does NOT match param on route, returns url unmodified', () => {
-    const path = withParams('/key/[key]/not-in/[route]', {})
-    const response = setParamValueOnUrl('/key/[key]/not-in/[route]', path, 'fail', 'ABC')
+  test("given paramName that does NOT match param on route, returns url unmodified", () => {
+    const path = withParams("/key/[key]/not-in/[route]", {});
+    const response = setParamValueOnUrl("/key/[key]/not-in/[route]", path, "fail", "ABC");
 
-    expect(response).toBe('/key/[key]/not-in/[route]')
-  })
+    expect(response).toBe("/key/[key]/not-in/[route]");
+  });
 
-  test('given paramName that matches param on route, returns url with param replaced', () => {
-    const path = withParams('/simple/[simple]', {})
-    const response = setParamValueOnUrl('/simple/[simple]', path, 'simple', 'ABC')
+  test("given paramName that matches param on route, returns url with param replaced", () => {
+    const path = withParams("/simple/[simple]", {});
+    const response = setParamValueOnUrl("/simple/[simple]", path, "simple", "ABC");
 
-    expect(response).toBe('/simple/ABC')
-  })
+    expect(response).toBe("/simple/ABC");
+  });
 
-  test('given paramName that matches param on route and value is not present, throws InvalidRouteParamValueError', () => {
-    const path = withParams('/simple/[simple]', {})
-    const action: () => void = () => setParamValueOnUrl('/simple/[simple]', path, 'simple', undefined)
+  test("given paramName that matches param on route and value is not present, throws InvalidRouteParamValueError", () => {
+    const path = withParams("/simple/[simple]", {});
+    const action: () => void = () =>
+      setParamValueOnUrl("/simple/[simple]", path, "simple", undefined);
 
-    expect(action).toThrowError(InvalidRouteParamValueError)
-  })
-})
+    expect(action).toThrowError(InvalidRouteParamValueError);
+  });
+});
diff --git a/src/services/queryParamFilter.spec.ts b/src/services/queryParamFilter.spec.ts
index 22560324..ead84d3b 100644
--- a/src/services/queryParamFilter.spec.ts
+++ b/src/services/queryParamFilter.spec.ts
@@ -1,38 +1,38 @@
-import { expect, test } from 'vitest'
-import { filterQueryParams } from './queryParamFilter'
+import { expect, test } from "vite-plus/test";
+import { filterQueryParams } from "./queryParamFilter";
 
-test('given no overlap, returns source unmodified', () => {
-  const source = new URLSearchParams('foo=123')
-  const exclude = new URLSearchParams('bar=456')
+test("given no overlap, returns source unmodified", () => {
+  const source = new URLSearchParams("foo=123");
+  const exclude = new URLSearchParams("bar=456");
 
-  const response = filterQueryParams(source, exclude)
+  const response = filterQueryParams(source, exclude);
 
-  expect(response.toString()).toBe('foo=123')
-})
+  expect(response.toString()).toBe("foo=123");
+});
 
-test('given exclude with same key but different value, returns source unmodified', () => {
-  const source = new URLSearchParams('foo=123')
-  const exclude = new URLSearchParams('foo=456')
+test("given exclude with same key but different value, returns source unmodified", () => {
+  const source = new URLSearchParams("foo=123");
+  const exclude = new URLSearchParams("foo=456");
 
-  const response = filterQueryParams(source, exclude)
+  const response = filterQueryParams(source, exclude);
 
-  expect(response.toString()).toBe('foo=123')
-})
+  expect(response.toString()).toBe("foo=123");
+});
 
-test('given exclude with same key and value, returns source without duplicates', () => {
-  const source = new URLSearchParams('foo=123&bar=456')
-  const exclude = new URLSearchParams('foo=123')
+test("given exclude with same key and value, returns source without duplicates", () => {
+  const source = new URLSearchParams("foo=123&bar=456");
+  const exclude = new URLSearchParams("foo=123");
 
-  const response = filterQueryParams(source, exclude)
+  const response = filterQueryParams(source, exclude);
 
-  expect(response.toString()).toBe('bar=456')
-})
+  expect(response.toString()).toBe("bar=456");
+});
 
-test('given source with multiple values for same key, only removes matching value', () => {
-  const source = new URLSearchParams('foo=123&foo=456')
-  const exclude = new URLSearchParams('foo=123')
+test("given source with multiple values for same key, only removes matching value", () => {
+  const source = new URLSearchParams("foo=123&foo=456");
+  const exclude = new URLSearchParams("foo=123");
 
-  const response = filterQueryParams(source, exclude)
+  const response = filterQueryParams(source, exclude);
 
-  expect(response.toString()).toBe('foo=456')
-})
+  expect(response.toString()).toBe("foo=456");
+});
diff --git a/src/services/routeRegex.spec.ts b/src/services/routeRegex.spec.ts
index b49496f7..2be15695 100644
--- a/src/services/routeRegex.spec.ts
+++ b/src/services/routeRegex.spec.ts
@@ -1,220 +1,249 @@
-import { describe, expect, test } from 'vitest'
-import { generateRouteHostRegexPattern, generateRoutePathRegexPattern, generateRouteQueryRegexPatterns, getParamName, regexCaptureAll, regexCatchAll, regexGreedyCatchAll, regexGreedyCaptureAll, replaceIndividualParamWithCaptureGroup, splitByMatches } from '@/services/routeRegex'
-import { withParams } from './withParams'
+import { describe, expect, test } from "vite-plus/test";
+import {
+  generateRouteHostRegexPattern,
+  generateRoutePathRegexPattern,
+  generateRouteQueryRegexPatterns,
+  getParamName,
+  regexCaptureAll,
+  regexCatchAll,
+  regexGreedyCatchAll,
+  regexGreedyCaptureAll,
+  replaceIndividualParamWithCaptureGroup,
+  splitByMatches,
+} from "@/services/routeRegex";
+import { withParams } from "./withParams";
 
-describe('generateRouteHostRegexPattern', () => {
-  test('given host without params, returns unmodified value with start and end markers', () => {
-    const host = 'https://www.kitbag.io'
+describe("generateRouteHostRegexPattern", () => {
+  test("given host without params, returns unmodified value with start and end markers", () => {
+    const host = "https://www.kitbag.io";
 
-    const result = generateRouteHostRegexPattern(host)
+    const result = generateRouteHostRegexPattern(host);
 
-    const expected = new RegExp('^https://www\\.kitbag\\.io$', 'i')
-    expect(result.toString()).toBe(expected.toString())
-  })
+    const expected = new RegExp("^https://www\\.kitbag\\.io$", "i");
+    expect(result.toString()).toBe(expected.toString());
+  });
 
-  test('given host with params, returns value with params replaced with catchall', () => {
-    const host = 'https://[subdomain].kitbag.io'
+  test("given host with params, returns value with params replaced with catchall", () => {
+    const host = "https://[subdomain].kitbag.io";
 
-    const result = generateRouteHostRegexPattern(host)
+    const result = generateRouteHostRegexPattern(host);
 
-    const expected = new RegExp(`^https://${regexCatchAll}\\.kitbag\\.io$`, 'i')
-    expect(result.toString()).toBe(expected.toString())
-  })
+    const expected = new RegExp(`^https://${regexCatchAll}\\.kitbag\\.io$`, "i");
+    expect(result.toString()).toBe(expected.toString());
+  });
 
-  test('given host with optional params, returns value with params replaced with catchall', () => {
-    const host = 'https://[?subdomain].kitbag.io'
+  test("given host with optional params, returns value with params replaced with catchall", () => {
+    const host = "https://[?subdomain].kitbag.io";
 
-    const result = generateRouteHostRegexPattern(host)
+    const result = generateRouteHostRegexPattern(host);
 
-    const expected = new RegExp(`^https://${regexCatchAll}\\.kitbag\\.io$`, 'i')
-    expect(result.toString()).toBe(expected.toString())
-  })
+    const expected = new RegExp(`^https://${regexCatchAll}\\.kitbag\\.io$`, "i");
+    expect(result.toString()).toBe(expected.toString());
+  });
 
-  test('given host with regex characters outside of params, escapes regex characters', () => {
-    const host = 'https://www.with$]regex[params*'
+  test("given host with regex characters outside of params, escapes regex characters", () => {
+    const host = "https://www.with$]regex[params*";
 
-    const result = generateRouteHostRegexPattern(host)
+    const result = generateRouteHostRegexPattern(host);
 
-    const expected = new RegExp('^https://www\\.with\\$\\]regex\\[params\\*$', 'i')
-    expect(result.toString()).toBe(expected.toString())
-  })
-})
+    const expected = new RegExp("^https://www\\.with\\$\\]regex\\[params\\*$", "i");
+    expect(result.toString()).toBe(expected.toString());
+  });
+});
 
-describe('generateRoutePathRegexPattern', () => {
-  test('given path without params, returns unmodified value with start and end markers', () => {
-    const path = 'parent/child/grandchild'
+describe("generateRoutePathRegexPattern", () => {
+  test("given path without params, returns unmodified value with start and end markers", () => {
+    const path = "parent/child/grandchild";
 
-    const result = generateRoutePathRegexPattern(path)
+    const result = generateRoutePathRegexPattern(path);
 
-    const expected = new RegExp('^parent/child/grandchild$', 'i')
-    expect(result.toString()).toBe(expected.toString())
-  })
+    const expected = new RegExp("^parent/child/grandchild$", "i");
+    expect(result.toString()).toBe(expected.toString());
+  });
 
-  test('given path with params, returns value with params replaced with catchall', () => {
-    const path = 'parent/child/[childParam]/grand-child/[grandChild123]'
+  test("given path with params, returns value with params replaced with catchall", () => {
+    const path = "parent/child/[childParam]/grand-child/[grandChild123]";
 
-    const result = generateRoutePathRegexPattern(path)
+    const result = generateRoutePathRegexPattern(path);
 
-    const expected = new RegExp(`^parent/child/${regexCatchAll}/grand-child/${regexCatchAll}$`, 'i')
-    expect(result.toString()).toBe(expected.toString())
-  })
+    const expected = new RegExp(
+      `^parent/child/${regexCatchAll}/grand-child/${regexCatchAll}$`,
+      "i",
+    );
+    expect(result.toString()).toBe(expected.toString());
+  });
 
-  test('given path with optional params, returns value with params replaced with catchall', () => {
-    const path = 'parent/child/[?childParam]/grand-child/[?grandChild123]'
+  test("given path with optional params, returns value with params replaced with catchall", () => {
+    const path = "parent/child/[?childParam]/grand-child/[?grandChild123]";
 
-    const result = generateRoutePathRegexPattern(path)
+    const result = generateRoutePathRegexPattern(path);
 
-    const expected = new RegExp(`^parent/child/${regexCatchAll}/grand-child/${regexCatchAll}$`, 'i')
-    expect(result.toString()).toBe(expected.toString())
-  })
+    const expected = new RegExp(
+      `^parent/child/${regexCatchAll}/grand-child/${regexCatchAll}$`,
+      "i",
+    );
+    expect(result.toString()).toBe(expected.toString());
+  });
 
-  test('given path with regex characters outside of params, escapes regex characters', () => {
-    const path = 'path.with$]regex[params*'
+  test("given path with regex characters outside of params, escapes regex characters", () => {
+    const path = "path.with$]regex[params*";
 
-    const result = generateRoutePathRegexPattern(path)
+    const result = generateRoutePathRegexPattern(path);
 
-    const expected = new RegExp('^path\\.with\\$\\]regex\\[params\\*$', 'i')
-    expect(result.toString()).toBe(expected.toString())
-  })
+    const expected = new RegExp("^path\\.with\\$\\]regex\\[params\\*$", "i");
+    expect(result.toString()).toBe(expected.toString());
+  });
 
-  test('given path with greedy param, uses greedy catch-all for that segment', () => {
-    const path = 'parent/[a]/[b*]/[c]'
+  test("given path with greedy param, uses greedy catch-all for that segment", () => {
+    const path = "parent/[a]/[b*]/[c]";
 
-    const result = generateRoutePathRegexPattern(path)
+    const result = generateRoutePathRegexPattern(path);
 
-    const expected = new RegExp(`^parent/${regexCatchAll}/${regexGreedyCatchAll}/${regexCatchAll}$`, 'i')
-    expect(result.toString()).toBe(expected.toString())
-  })
-})
+    const expected = new RegExp(
+      `^parent/${regexCatchAll}/${regexGreedyCatchAll}/${regexCatchAll}$`,
+      "i",
+    );
+    expect(result.toString()).toBe(expected.toString());
+  });
+});
 
-describe('generateRouteQueryRegexPatterns', () => {
-  test('given query without params, returns unmodified value with start and end markers', () => {
-    const result = generateRouteQueryRegexPatterns('')
+describe("generateRouteQueryRegexPatterns", () => {
+  test("given query without params, returns unmodified value with start and end markers", () => {
+    const result = generateRouteQueryRegexPatterns("");
 
-    expect(result).toMatchObject([])
-  })
+    expect(result).toMatchObject([]);
+  });
 
-  test('given query with required params, returns value with params replaced with catchall', () => {
-    const query = 'dynamic=[first]&static=params&another=[second]'
+  test("given query with required params, returns value with params replaced with catchall", () => {
+    const query = "dynamic=[first]&static=params&another=[second]";
 
-    const result = generateRouteQueryRegexPatterns(query)
+    const result = generateRouteQueryRegexPatterns(query);
 
-    expect(result).toMatchObject([new RegExp(`dynamic=${regexCaptureAll}`), new RegExp('static=params'), new RegExp(`another=${regexCaptureAll}`)])
-  })
+    expect(result).toMatchObject([
+      new RegExp(`dynamic=${regexCaptureAll}`),
+      new RegExp("static=params"),
+      new RegExp(`another=${regexCaptureAll}`),
+    ]);
+  });
 
-  test('given query with optional params, returns value without params', () => {
-    const query = 'dynamic=[?first]&static=params&another=[?second]'
+  test("given query with optional params, returns value without params", () => {
+    const query = "dynamic=[?first]&static=params&another=[?second]";
 
-    const result = generateRouteQueryRegexPatterns(query)
+    const result = generateRouteQueryRegexPatterns(query);
 
-    expect(result).toMatchObject([new RegExp('static=params')])
-  })
+    expect(result).toMatchObject([new RegExp("static=params")]);
+  });
 
-  test('given query with regex characters outside of params, escapes regex characters', () => {
-    const query = 'query=$with&normal=[param]&regex*chars=)throughout[&'
+  test("given query with regex characters outside of params, escapes regex characters", () => {
+    const query = "query=$with&normal=[param]&regex*chars=)throughout[&";
 
-    const result = generateRouteQueryRegexPatterns(query)
+    const result = generateRouteQueryRegexPatterns(query);
 
     expect(result.map((pattern) => pattern.toString())).toMatchObject([
-      '/query=\\$with(&|$)/i',
+      "/query=\\$with(&|$)/i",
       `/normal=${regexCatchAll}(&|$)/i`,
-      '/regex\\*chars=\\)throughout\\[(&|$)/i',
-    ])
-  })
-})
+      "/regex\\*chars=\\)throughout\\[(&|$)/i",
+    ]);
+  });
+});
 
-describe('getParamName', () => {
-  test('given string with optional param name syntax, returns param name', () => {
-    const paramName = 'foo'
+describe("getParamName", () => {
+  test("given string with optional param name syntax, returns param name", () => {
+    const paramName = "foo";
 
-    const response = getParamName(`[?${paramName}]`)
+    const response = getParamName(`[?${paramName}]`);
 
-    expect(response).toBe(paramName)
-  })
+    expect(response).toBe(paramName);
+  });
 
-  test('given string with param name syntax, returns param name', () => {
-    const paramName = 'foo'
+  test("given string with param name syntax, returns param name", () => {
+    const paramName = "foo";
 
-    const response = getParamName(`[${paramName}]`)
+    const response = getParamName(`[${paramName}]`);
 
-    expect(response).toBe(paramName)
-  })
+    expect(response).toBe(paramName);
+  });
 
-  test('given string with greedy param name syntax, returns base param name', () => {
-    const response = getParamName('[foo*]')
+  test("given string with greedy param name syntax, returns base param name", () => {
+    const response = getParamName("[foo*]");
 
-    expect(response).toBe('foo')
-  })
+    expect(response).toBe("foo");
+  });
 
-  test('given string with optional greedy param name syntax, returns base param name', () => {
-    const response = getParamName('[?foo*]')
+  test("given string with optional greedy param name syntax, returns base param name", () => {
+    const response = getParamName("[?foo*]");
 
-    expect(response).toBe('foo')
-  })
+    expect(response).toBe("foo");
+  });
 
-  test.each([
-    ['foo'],
-    ['?foo'],
-    ['?:*foo'],
-  ])('given string that is not param syntax, returns undefined', (paramName) => {
-    const response = getParamName(paramName)
+  test.each([["foo"], ["?foo"], ["?:*foo"]])(
+    "given string that is not param syntax, returns undefined",
+    (paramName) => {
+      const response = getParamName(paramName);
 
-    expect(response).toBe(undefined)
-  })
-})
+      expect(response).toBe(undefined);
+    },
+  );
+});
 
-describe('replaceIndividualParamWithCaptureGroup', () => {
-  test('given normal param, replaces with segment capture pattern', () => {
-    const path = withParams('/[id]/suffix', { id: String })
+describe("replaceIndividualParamWithCaptureGroup", () => {
+  test("given normal param, replaces with segment capture pattern", () => {
+    const path = withParams("/[id]/suffix", { id: String });
 
-    const result = replaceIndividualParamWithCaptureGroup(path, 'id')
+    const result = replaceIndividualParamWithCaptureGroup(path, "id");
 
-    expect(result).toBe(`/${regexCaptureAll}/suffix`)
-  })
+    expect(result).toBe(`/${regexCaptureAll}/suffix`);
+  });
 
-  test('given greedy param, replaces with greedy capture pattern', () => {
-    const path = withParams('/[rest*]/suffix', { rest: String })
+  test("given greedy param, replaces with greedy capture pattern", () => {
+    const path = withParams("/[rest*]/suffix", { rest: String });
 
-    const result = replaceIndividualParamWithCaptureGroup(path, 'rest')
+    const result = replaceIndividualParamWithCaptureGroup(path, "rest");
 
-    expect(result).toBe(`/${regexGreedyCaptureAll}/suffix`)
-  })
-})
+    expect(result).toBe(`/${regexGreedyCaptureAll}/suffix`);
+  });
+});
 
-describe('splitByMatches', () => {
-  test('given string without matches, returns full string', () => {
-    const value = 'string without matches'
-    const pattern = /will-not-find/g
+describe("splitByMatches", () => {
+  test("given string without matches, returns full string", () => {
+    const value = "string without matches";
+    const pattern = /will-not-find/g;
 
-    const response = splitByMatches(value, pattern)
+    const response = splitByMatches(value, pattern);
 
-    expect(response).toMatchObject([value])
-  })
+    expect(response).toMatchObject([value]);
+  });
 
-  test('given string with match at the beginning, returns match the rest', () => {
-    const value = 'at-beginning, string with match'
-    const pattern = /at-beginning/g
+  test("given string with match at the beginning, returns match the rest", () => {
+    const value = "at-beginning, string with match";
+    const pattern = /at-beginning/g;
 
-    const response = splitByMatches(value, pattern)
+    const response = splitByMatches(value, pattern);
 
-    expect(response).toMatchObject(['at-beginning', ', string with match'])
-  })
+    expect(response).toMatchObject(["at-beginning", ", string with match"]);
+  });
 
-  test('given string with match at the end, returns the rest then match', () => {
-    const value = 'string with match at-end'
-    const pattern = /at-end/g
+  test("given string with match at the end, returns the rest then match", () => {
+    const value = "string with match at-end";
+    const pattern = /at-end/g;
 
-    const response = splitByMatches(value, pattern)
+    const response = splitByMatches(value, pattern);
 
-    expect(response).toMatchObject(['string with match ', 'at-end'])
-  })
+    expect(response).toMatchObject(["string with match ", "at-end"]);
+  });
 
-  test('given string with matches in the middle, returns array of matches and everything in between', () => {
-    const value = 'found-throughout string found-throughout with match found-throughout'
-    const pattern = /found-throughout/g
+  test("given string with matches in the middle, returns array of matches and everything in between", () => {
+    const value = "found-throughout string found-throughout with match found-throughout";
+    const pattern = /found-throughout/g;
 
-    const response = splitByMatches(value, pattern)
+    const response = splitByMatches(value, pattern);
 
-    expect(response).toMatchObject(['found-throughout', ' string ', 'found-throughout', ' with match ', 'found-throughout'])
-  })
-})
+    expect(response).toMatchObject([
+      "found-throughout",
+      " string ",
+      "found-throughout",
+      " with match ",
+      "found-throughout",
+    ]);
+  });
+});
diff --git a/src/services/state.spec.ts b/src/services/state.spec.ts
index 0bedf058..db6b1e7a 100644
--- a/src/services/state.spec.ts
+++ b/src/services/state.spec.ts
@@ -1,112 +1,108 @@
-import { describe, expect, test } from 'vitest'
-import { getStateValues, setStateValues } from '@/services/state'
-import { withDefault } from '@/services/withDefault'
-
-describe('setStateValues', () => {
-  test.each([
-    [null],
-    [undefined],
-    ['{}'],
-    [[]],
-  ])('given state that is not expected format, returns empty object', (state) => {
-    const params = {
-      foo: Number,
-    }
+import { describe, expect, test } from "vite-plus/test";
+import { getStateValues, setStateValues } from "@/services/state";
+import { withDefault } from "@/services/withDefault";
 
-    const response = setStateValues(params, state)
+describe("setStateValues", () => {
+  test.each([[null], [undefined], ["{}"], [[]]])(
+    "given state that is not expected format, returns empty object",
+    (state) => {
+      const params = {
+        foo: Number,
+      };
 
-    expect(response).toMatchObject({})
-  })
+      const response = setStateValues(params, state);
 
-  test('given state missing the expected key, returns empty string', () => {
+      expect(response).toMatchObject({});
+    },
+  );
+
+  test("given state missing the expected key, returns empty string", () => {
     const params = {
       foo: Number,
-    }
+    };
     const state = {
-      bar: 'abc',
-    }
+      bar: "abc",
+    };
 
-    const response = setStateValues(params, state)
+    const response = setStateValues(params, state);
 
     expect(response).toMatchObject({
-      foo: '',
-    })
-  })
+      foo: "",
+    });
+  });
 
-  test('given state with the expected key, returns parsed value', () => {
+  test("given state with the expected key, returns parsed value", () => {
     const params = {
       foo: Number,
-    }
+    };
     const state = {
       foo: 456,
-    }
+    };
 
-    const response = setStateValues(params, state)
+    const response = setStateValues(params, state);
 
     expect(response).toMatchObject({
-      foo: '456',
-    })
-  })
-})
-
-describe('getStateValues', () => {
-  test.each([
-    [null],
-    [undefined],
-    ['{}'],
-    [[]],
-  ])('given state that is not expected format, returns empty object', (state) => {
-    const params = {
-      foo: Number,
-    }
-
-    const response = getStateValues(params, state)
-
-    expect(response).toMatchObject({})
-  })
-
-  test('given state missing the expected key without default, returns undefined', () => {
+      foo: "456",
+    });
+  });
+});
+
+describe("getStateValues", () => {
+  test.each([[null], [undefined], ["{}"], [[]]])(
+    "given state that is not expected format, returns empty object",
+    (state) => {
+      const params = {
+        foo: Number,
+      };
+
+      const response = getStateValues(params, state);
+
+      expect(response).toMatchObject({});
+    },
+  );
+
+  test("given state missing the expected key without default, returns undefined", () => {
     const params = {
       foo: Number,
-    }
+    };
     const state = {
-      bar: 'abc',
-    }
+      bar: "abc",
+    };
 
-    const response = getStateValues(params, state)
+    const response = getStateValues(params, state);
 
     expect(response).toMatchObject({
       foo: undefined,
-    })
-  })
+    });
+  });
 
-  test('given state missing the expected key with default, returns default value', () => {
+  test("given state missing the expected key with default, returns default value", () => {
     const params = {
       foo: withDefault(Number, 123),
-    }
+    };
     const state = {
-      bar: 'abc',
-    }
+      bar: "abc",
+    };
 
-    const response = getStateValues(params, state)
+    const response = getStateValues(params, state);
 
     expect(response).toMatchObject({
       foo: 123,
-    })
-  })
+    });
+  });
 
-  test('given state with the expected key, returns parsed value', () => {
+  test("given state with the expected key, returns parsed value", () => {
     const params = {
       foo: Number,
-    }
+    };
     const state = {
-      foo: '456',
-    }
+      foo: "456",
+    };
 
-    const response = getStateValues(params, state)
+    const response = getStateValues(params, state);
 
     expect(response).toMatchObject({
       foo: 456,
-    })
-  })
-})
+    });
+  });
+});
diff --git a/src/services/tupleOf.spec.ts b/src/services/tupleOf.spec.ts
index acb194bc..f91acb73 100644
--- a/src/services/tupleOf.spec.ts
+++ b/src/services/tupleOf.spec.ts
@@ -1,52 +1,53 @@
-import { expect, test } from 'vitest'
-import { tupleOf } from '@/services/tupleOf'
-import { getParamValue, setParamValue } from '@/services/params'
-import { InvalidRouteParamValueError } from '@/errors/invalidRouteParamValueError'
+import { expect, test } from "vite-plus/test";
+import { tupleOf } from "@/services/tupleOf";
+import { getParamValue, setParamValue } from "@/services/params";
+import { InvalidRouteParamValueError } from "@/errors/invalidRouteParamValueError";
 
 test.each([
-  ['23,true,foo', [23, true, 'foo']],
-  ['-2,false,bar', [-2, false, 'bar']],
-])('given an array of params with valid values, returns an array of values', (input, expected) => {
-  const array = tupleOf([Number, Boolean, String])
+  ["23,true,foo", [23, true, "foo"]],
+  ["-2,false,bar", [-2, false, "bar"]],
+])("given an array of params with valid values, returns an array of values", (input, expected) => {
+  const array = tupleOf([Number, Boolean, String]);
 
-  const result = getParamValue(input, { param: array })
+  const result = getParamValue(input, { param: array });
 
-  expect(result).toEqual(expected)
-})
+  expect(result).toEqual(expected);
+});
 
-test.each([
-  {}, true, '', Infinity,
-])('given value is %s not an array, throws InvalidRouteParamValueError', (value) => {
-  const array = tupleOf([Number, Boolean])
+test.each([{}, true, "", Infinity])(
+  "given value is %s not an array, throws InvalidRouteParamValueError",
+  (value) => {
+    const array = tupleOf([Number, Boolean]);
 
-  const action: () => void = () => setParamValue(value, { param: array })
+    const action: () => void = () => setParamValue(value, { param: array });
 
-  expect(action).toThrow('Expected a tuple')
-})
+    expect(action).toThrow("Expected a tuple");
+  },
+);
 
-test('given value with too few values, throws InvalidRouteParamValueError', () => {
-  const array = tupleOf([Number, Number])
+test("given value with too few values, throws InvalidRouteParamValueError", () => {
+  const array = tupleOf([Number, Number]);
 
-  const action: () => void = () => setParamValue([1], { param: array })
+  const action: () => void = () => setParamValue([1], { param: array });
 
-  expect(action).toThrow('Expected tuple with 2 values')
-})
+  expect(action).toThrow("Expected tuple with 2 values");
+});
 
-test('given value with too many values, throws InvalidRouteParamValueError', () => {
-  const array = tupleOf([Number, Number])
+test("given value with too many values, throws InvalidRouteParamValueError", () => {
+  const array = tupleOf([Number, Number]);
 
-  const action: () => void = () => setParamValue([1, 2, 3], { param: array })
+  const action: () => void = () => setParamValue([1, 2, 3], { param: array });
 
-  expect(action).toThrow('Expected tuple with 2 values')
-})
+  expect(action).toThrow("Expected tuple with 2 values");
+});
 
-test.each([
-  ['23'],
-  ['true,23'],
-])('given an array of params with invalid value %s, throws InvalidRouteParamValueError', (value) => {
-  const array = tupleOf([Number, Boolean])
+test.each([["23"], ["true,23"]])(
+  "given an array of params with invalid value %s, throws InvalidRouteParamValueError",
+  (value) => {
+    const array = tupleOf([Number, Boolean]);
 
-  const action: () => void = () => getParamValue(value, { param: array })
+    const action: () => void = () => getParamValue(value, { param: array });
 
-  expect(action).toThrow(InvalidRouteParamValueError)
-})
+    expect(action).toThrow(InvalidRouteParamValueError);
+  },
+);
diff --git a/src/services/unionOf.spec.ts b/src/services/unionOf.spec.ts
index fbe5bc83..1ba3c84e 100644
--- a/src/services/unionOf.spec.ts
+++ b/src/services/unionOf.spec.ts
@@ -1,86 +1,90 @@
-import { expect, test, vi } from 'vitest'
-import { InvalidRouteParamValueError } from '@/errors/invalidRouteParamValueError'
-import { unionOf } from '@/services/unionOf'
-import { getParamValue } from './params'
+import { expect, test, vi } from "vite-plus/test";
+import { InvalidRouteParamValueError } from "@/errors/invalidRouteParamValueError";
+import { unionOf } from "@/services/unionOf";
+import { getParamValue } from "./params";
 
 function throwsInvalidRouteParamValueError(): () => never {
   return () => {
-    throw new InvalidRouteParamValueError()
-  }
+    throw new InvalidRouteParamValueError();
+  };
 }
 
-test('given several params, calls each until one returns a value', () => {
-  const aParam = vi.fn().mockImplementationOnce(throwsInvalidRouteParamValueError())
-  const bParam = vi.fn().mockImplementationOnce(throwsInvalidRouteParamValueError())
-  const cParam = vi.fn().mockImplementationOnce(() => 'works!')
-  const dParam = vi.fn().mockImplementationOnce(() => 'also works!')
+test("given several params, calls each until one returns a value", () => {
+  const aParam = vi.fn().mockImplementationOnce(throwsInvalidRouteParamValueError());
+  const bParam = vi.fn().mockImplementationOnce(throwsInvalidRouteParamValueError());
+  const cParam = vi.fn().mockImplementationOnce(() => "works!");
+  const dParam = vi.fn().mockImplementationOnce(() => "also works!");
 
-  const union = unionOf([aParam, bParam, cParam, dParam])
+  const union = unionOf([aParam, bParam, cParam, dParam]);
 
-  const result = getParamValue('foo', { param: union, isOptional: false, isGreedy: false })
+  const result = getParamValue("foo", { param: union, isOptional: false, isGreedy: false });
 
-  expect(aParam).toHaveBeenCalledTimes(1)
-  expect(bParam).toHaveBeenCalledTimes(1)
-  expect(cParam).toHaveBeenCalledTimes(1)
-  expect(dParam).not.toHaveBeenCalled()
+  expect(aParam).toHaveBeenCalledTimes(1);
+  expect(bParam).toHaveBeenCalledTimes(1);
+  expect(cParam).toHaveBeenCalledTimes(1);
+  expect(dParam).not.toHaveBeenCalled();
 
-  expect(result).toBe('works!')
-})
+  expect(result).toBe("works!");
+});
 
-test('given no param returns value, throws InvalidRouteParamValueError', () => {
-  const aParam = vi.fn().mockImplementationOnce(throwsInvalidRouteParamValueError())
-  const bParam = vi.fn().mockImplementationOnce(throwsInvalidRouteParamValueError())
-  const cParam = vi.fn().mockImplementationOnce(throwsInvalidRouteParamValueError())
-  const dParam = vi.fn().mockImplementationOnce(throwsInvalidRouteParamValueError())
+test("given no param returns value, throws InvalidRouteParamValueError", () => {
+  const aParam = vi.fn().mockImplementationOnce(throwsInvalidRouteParamValueError());
+  const bParam = vi.fn().mockImplementationOnce(throwsInvalidRouteParamValueError());
+  const cParam = vi.fn().mockImplementationOnce(throwsInvalidRouteParamValueError());
+  const dParam = vi.fn().mockImplementationOnce(throwsInvalidRouteParamValueError());
 
-  const union = unionOf([aParam, bParam, cParam, dParam])
+  const union = unionOf([aParam, bParam, cParam, dParam]);
 
-  const action: () => void = () => getParamValue('foo', { param: union, isOptional: false, isGreedy: false })
+  const action: () => void = () =>
+    getParamValue("foo", { param: union, isOptional: false, isGreedy: false });
 
-  expect(action).toThrow('Value "foo" does not satisfy any of the possible values')
-  expect(aParam).toHaveBeenCalledTimes(1)
-  expect(bParam).toHaveBeenCalledTimes(1)
-  expect(cParam).toHaveBeenCalledTimes(1)
-  expect(dParam).toHaveBeenCalledTimes(1)
-})
+  expect(action).toThrow('Value "foo" does not satisfy any of the possible values');
+  expect(aParam).toHaveBeenCalledTimes(1);
+  expect(bParam).toHaveBeenCalledTimes(1);
+  expect(cParam).toHaveBeenCalledTimes(1);
+  expect(dParam).toHaveBeenCalledTimes(1);
+});
 
-test('given a param that throws something other than InvalidRouteParamValueError, throws the error', () => {
+test("given a param that throws something other than InvalidRouteParamValueError, throws the error", () => {
   const param = vi.fn().mockImplementationOnce(() => {
-    throw new Error('Something went wrong')
-  })
+    throw new Error("Something went wrong");
+  });
 
-  const union = unionOf([param])
+  const union = unionOf([param]);
 
-  const action: () => void = () => getParamValue('foo', { param: union, isOptional: false, isGreedy: false })
+  const action: () => void = () =>
+    getParamValue("foo", { param: union, isOptional: false, isGreedy: false });
 
-  expect(action).toThrow('Something went wrong')
-})
+  expect(action).toThrow("Something went wrong");
+});
 
 test.each([
-  [Number, '1', 1],
-  [Boolean, 'true', true],
-  [JSON, '{"foo": "bar"}', { foo: 'bar' }],
-  [Date, '2021-01-01T00:00:00.000Z', new Date('2021-01-01T00:00:00.000Z')],
-  [/foo/, 'foo', 'foo'],
-  [String, 'foo', 'foo'],
-])('works with param of built-in type %s', (param, input, output) => {
-  const union = unionOf([param])
-
-  const result = getParamValue(input, { param: union, isOptional: false, isGreedy: false })
-
-  if (typeof output === 'object') {
-    expect(result).toEqual(output)
+  [Number, "1", 1],
+  [Boolean, "true", true],
+  [JSON, '{"foo": "bar"}', { foo: "bar" }],
+  [Date, "2021-01-01T00:00:00.000Z", new Date("2021-01-01T00:00:00.000Z")],
+  [/foo/, "foo", "foo"],
+  [String, "foo", "foo"],
+])("works with param of built-in type %s", (param, input, output) => {
+  const union = unionOf([param]);
+
+  const result = getParamValue(input, { param: union, isOptional: false, isGreedy: false });
+
+  if (typeof output === "object") {
+    expect(result).toEqual(output);
   } else {
-    expect(result).toBe(output)
+    expect(result).toBe(output);
   }
-})
+});
 
-test.each([
-  23, 'foo', true,
-])('works with literal param of type %s', (value) => {
-  const union = unionOf([value])
+test.each([23, "foo", true])("works with literal param of type %s", (value) => {
+  const union = unionOf([value]);
 
-  const result = getParamValue(value.toString(), { param: union, isOptional: false, isGreedy: false })
+  const result = getParamValue(value.toString(), {
+    param: union,
+    isOptional: false,
+    isGreedy: false,
+  });
 
-  expect(result).toBe(value)
-})
+  expect(result).toBe(value);
+});
diff --git a/src/services/urlParser.spec.ts b/src/services/urlParser.spec.ts
index 4a0ee2d1..00fedcd3 100644
--- a/src/services/urlParser.spec.ts
+++ b/src/services/urlParser.spec.ts
@@ -1,155 +1,170 @@
-import { describe, expect, test } from 'vitest'
-import { parseUrl, stringifyUrl, updateUrl } from '@/services/urlParser'
+import { describe, expect, test } from "vite-plus/test";
+import { parseUrl, stringifyUrl, updateUrl } from "@/services/urlParser";
 
-describe('parseUrl', () => {
-  test('given relative url, returns host and protocol undefined', () => {
-    const url = '/foo?bar=123'
+describe("parseUrl", () => {
+  test("given relative url, returns host and protocol undefined", () => {
+    const url = "/foo?bar=123";
 
-    const parts = parseUrl(url)
+    const parts = parseUrl(url);
 
-    expect(parts.host).toBe(undefined)
-  })
+    expect(parts.host).toBe(undefined);
+  });
 
-  test('given absolute url with path, returns everything up to path', () => {
-    const url = 'https://kitbag.dev/foo'
+  test("given absolute url with path, returns everything up to path", () => {
+    const url = "https://kitbag.dev/foo";
 
-    const parts = parseUrl(url)
+    const parts = parseUrl(url);
 
-    expect(parts.host).toBe('https://kitbag.dev')
-    expect(parts.path).toBe('/foo')
-    expect(parts.query.toString()).toBe('')
-    expect(parts.hash).toBe('')
-  })
+    expect(parts.host).toBe("https://kitbag.dev");
+    expect(parts.path).toBe("/foo");
+    expect(parts.query.toString()).toBe("");
+    expect(parts.hash).toBe("");
+  });
 
-  test('given absolute url with path and query, returns everything up to search', () => {
-    const url = 'https://kitbag.dev/foo?bar=123'
+  test("given absolute url with path and query, returns everything up to search", () => {
+    const url = "https://kitbag.dev/foo?bar=123";
 
-    const parts = parseUrl(url)
+    const parts = parseUrl(url);
 
-    expect(parts.host).toBe('https://kitbag.dev')
-    expect(parts.path).toBe('/foo')
-    expect(parts.query.toString()).toBe('bar=123')
-    expect(parts.hash).toBe('')
-  })
+    expect(parts.host).toBe("https://kitbag.dev");
+    expect(parts.path).toBe("/foo");
+    expect(parts.query.toString()).toBe("bar=123");
+    expect(parts.hash).toBe("");
+  });
 
-  test('given absolute url with path, query, and hash, returns everything', () => {
-    const url = 'https://kitbag.dev/foo?bar=123#zoo'
+  test("given absolute url with path, query, and hash, returns everything", () => {
+    const url = "https://kitbag.dev/foo?bar=123#zoo";
 
-    const parts = parseUrl(url)
+    const parts = parseUrl(url);
 
-    expect(parts.host).toBe('https://kitbag.dev')
-    expect(parts.path).toBe('/foo')
-    expect(parts.query.toString()).toBe('bar=123')
-    expect(parts.hash).toBe('#zoo')
-  })
-})
+    expect(parts.host).toBe("https://kitbag.dev");
+    expect(parts.path).toBe("/foo");
+    expect(parts.query.toString()).toBe("bar=123");
+    expect(parts.hash).toBe("#zoo");
+  });
+});
 
-describe('stringifyUrl', () => {
-  test('given parts, returns stringified url', () => {
+describe("stringifyUrl", () => {
+  test("given parts, returns stringified url", () => {
     const parts = {
-      host: 'https://kitbag.dev',
-      path: '/foo',
-      query: '?bar=123',
-      hash: '#zoo',
-    }
+      host: "https://kitbag.dev",
+      path: "/foo",
+      query: "?bar=123",
+      hash: "#zoo",
+    };
 
-    const url = stringifyUrl(parts)
+    const url = stringifyUrl(parts);
 
-    expect(url).toBe('https://kitbag.dev/foo?bar=123#zoo')
-  })
-})
+    expect(url).toBe("https://kitbag.dev/foo?bar=123#zoo");
+  });
+});
 
-describe('updateUrl', () => {
+describe("updateUrl", () => {
   test.each([
-    [{ host: 'https://kitbag.com' }, { host: 'https://kitbag.dev' }],
-    [{ host: 'https://kitbag.dev' }, { host: '' }],
-    [{ host: 'https://kitbag.dev' }, { host: undefined }],
-  ])('given previous host (%s) and updated host (%s), returns updated host', (previous, updated) => {
-    const url = updateUrl(previous, updated)
-
-    expect(url.host).toBe('https://kitbag.dev')
-  })
+    [{ host: "https://kitbag.com" }, { host: "https://kitbag.dev" }],
+    [{ host: "https://kitbag.dev" }, { host: "" }],
+    [{ host: "https://kitbag.dev" }, { host: undefined }],
+  ])(
+    "given previous host (%s) and updated host (%s), returns updated host",
+    (previous, updated) => {
+      const url = updateUrl(previous, updated);
+
+      expect(url.host).toBe("https://kitbag.dev");
+    },
+  );
 
   test.each([
-    [{ path: '/bar' }, { path: '/foo' }],
-    [{ path: '/foo' }, { path: '' }],
-    [{ path: '/foo' }, { path: undefined }],
-  ])('given previous path (%s) and updated path (%s), returns updated path', (previous, updated) => {
-    const url = updateUrl(previous, updated)
-
-    expect(url.path).toBe('/foo')
-  })
+    [{ path: "/bar" }, { path: "/foo" }],
+    [{ path: "/foo" }, { path: "" }],
+    [{ path: "/foo" }, { path: undefined }],
+  ])(
+    "given previous path (%s) and updated path (%s), returns updated path",
+    (previous, updated) => {
+      const url = updateUrl(previous, updated);
+
+      expect(url.path).toBe("/foo");
+    },
+  );
 
   test.each([
-    [{ query: new URLSearchParams('?foo=456') }, { query: new URLSearchParams('?bar=123') }],
-    [{ query: new URLSearchParams('?foo=456') }, { query: '?bar=123' }],
-    [{ query: new URLSearchParams('?foo=456&bar=123') }, { query: '' }],
-    [{ query: new URLSearchParams('?foo=456&bar=123') }, { query: undefined }],
-  ])('given previous query (%s) and updated query (%s), returns updated query', (previous, updated) => {
-    const url = updateUrl(previous, updated)
-
-    expect(url.query.toString()).toBe('foo=456&bar=123')
-  })
+    [{ query: new URLSearchParams("?foo=456") }, { query: new URLSearchParams("?bar=123") }],
+    [{ query: new URLSearchParams("?foo=456") }, { query: "?bar=123" }],
+    [{ query: new URLSearchParams("?foo=456&bar=123") }, { query: "" }],
+    [{ query: new URLSearchParams("?foo=456&bar=123") }, { query: undefined }],
+  ])(
+    "given previous query (%s) and updated query (%s), returns updated query",
+    (previous, updated) => {
+      const url = updateUrl(previous, updated);
+
+      expect(url.query.toString()).toBe("foo=456&bar=123");
+    },
+  );
 
   test.each([
-    [{ hash: 'bar' }, { hash: 'foo' }],
-    [{ hash: 'foo' }, { hash: '' }],
-    [{ hash: 'foo' }, { hash: undefined }],
-  ])('given previous hash (%s) and updated hash (%s), returns updated hash', (previous, updated) => {
-    const url = updateUrl(previous, updated)
-
-    expect(url.hash).toBe('foo')
-  })
-})
-
-describe('stringifyUrl', () => {
-  test('given parts without host, or path, returns forward slash to satisfy Url', () => {
-    const url = stringifyUrl({})
-
-    expect(url).toBe('/')
-  })
-
-  test.each(['foo', '/foo'])('given parts with path, returns value with path', (path) => {
+    [{ hash: "bar" }, { hash: "foo" }],
+    [{ hash: "foo" }, { hash: "" }],
+    [{ hash: "foo" }, { hash: undefined }],
+  ])(
+    "given previous hash (%s) and updated hash (%s), returns updated hash",
+    (previous, updated) => {
+      const url = updateUrl(previous, updated);
+
+      expect(url.hash).toBe("foo");
+    },
+  );
+});
+
+describe("stringifyUrl", () => {
+  test("given parts without host, or path, returns forward slash to satisfy Url", () => {
+    const url = stringifyUrl({});
+
+    expect(url).toBe("/");
+  });
+
+  test.each(["foo", "/foo"])("given parts with path, returns value with path", (path) => {
     const parts = {
-      host: 'https://kitbag.dev',
+      host: "https://kitbag.dev",
       path,
-    }
+    };
 
-    const url = stringifyUrl(parts)
+    const url = stringifyUrl(parts);
 
-    expect(url).toBe('https://kitbag.dev/foo')
-  })
+    expect(url).toBe("https://kitbag.dev/foo");
+  });
 
-  test.each(['?bar=123', 'bar=123'])('given parts with query, returns value with query', (query) => {
-    const parts = {
-      host: 'https://kitbag.dev',
-      query,
-    }
+  test.each(["?bar=123", "bar=123"])(
+    "given parts with query, returns value with query",
+    (query) => {
+      const parts = {
+        host: "https://kitbag.dev",
+        query,
+      };
 
-    const url = stringifyUrl(parts)
+      const url = stringifyUrl(parts);
 
-    expect(url).toBe('https://kitbag.dev/?bar=123')
-  })
+      expect(url).toBe("https://kitbag.dev/?bar=123");
+    },
+  );
 
-  test.each(['bar', '#bar'])('given parts with hash, returns value with hash', (hash) => {
+  test.each(["bar", "#bar"])("given parts with hash, returns value with hash", (hash) => {
     const parts = {
-      host: 'https://kitbag.dev',
+      host: "https://kitbag.dev",
       hash,
-    }
+    };
 
-    const url = stringifyUrl(parts)
+    const url = stringifyUrl(parts);
 
-    expect(url).toBe('https://kitbag.dev/#bar')
-  })
+    expect(url).toBe("https://kitbag.dev/#bar");
+  });
 
-  test('given parts without host, returns url starting with forward slash', () => {
+  test("given parts without host, returns url starting with forward slash", () => {
     const parts = {
-      path: '/foo',
-      query: '?bar=123',
-    }
+      path: "/foo",
+      query: "?bar=123",
+    };
 
-    const url = stringifyUrl(parts)
+    const url = stringifyUrl(parts);
 
-    expect(url).toBe('/foo?bar=123')
-  })
-})
+    expect(url).toBe("/foo?bar=123");
+  });
+});
diff --git a/src/services/valibot.spec-d.ts b/src/services/valibot.spec-d.ts
index 29cd241d..507fb8b2 100644
--- a/src/services/valibot.spec-d.ts
+++ b/src/services/valibot.spec-d.ts
@@ -1,18 +1,22 @@
-import { expectTypeOf, test } from 'vitest'
-import { withParams } from './withParams'
-import { string, boolean } from 'valibot'
-import { ExtractParamType } from '@/types/params'
+import { expectTypeOf, test } from "vite-plus/test";
+import { withParams } from "./withParams";
+import { string, boolean } from "valibot";
+import { ExtractParamType } from "@/types/params";
 
-test('withParams accepts valibot schemas', () => {
-  const schema = string()
-  const { params } = withParams('/[foo]', { foo: schema })
+test("withParams accepts valibot schemas", () => {
+  const schema = string();
+  const { params } = withParams("/[foo]", { foo: schema });
 
-  expectTypeOf(params.foo).toEqualTypeOf<{ param: typeof schema, isOptional: false, isGreedy: false }>()
-})
+  expectTypeOf(params.foo).toEqualTypeOf<{
+    param: typeof schema;
+    isOptional: false;
+    isGreedy: false;
+  }>();
+});
 
-test('ExtractParamType returns the correct type for valibot params', () => {
-  const param = boolean()
-  type Input = ExtractParamType<typeof param>
+test("ExtractParamType returns the correct type for valibot params", () => {
+  const param = boolean();
+  type Input = ExtractParamType<typeof param>;
 
-  expectTypeOf<Input>().toEqualTypeOf<boolean>()
-})
+  expectTypeOf<Input>().toEqualTypeOf<boolean>();
+});
diff --git a/src/services/valibot.spec.ts b/src/services/valibot.spec.ts
index aae0ea52..667226a1 100644
--- a/src/services/valibot.spec.ts
+++ b/src/services/valibot.spec.ts
@@ -1,45 +1,69 @@
-import { safeGetParamValue, safeSetParamValue } from './params'
-import { test, expect } from 'vitest'
-import * as v from 'valibot'
+import { safeGetParamValue, safeSetParamValue } from "./params";
+import { test, expect } from "vite-plus/test";
+import * as v from "valibot";
 
 enum Fruits {
   Apple = 0,
-  Banana = 1
+  Banana = 1,
 }
 
-const discriminatedUnion = v.variant('type', [
-  v.object({ type: v.literal('one'), value: v.string() }),
-  v.object({ type: v.literal('two'), value: v.number() }),
-])
+const discriminatedUnion = v.variant("type", [
+  v.object({ type: v.literal("one"), value: v.string() }),
+  v.object({ type: v.literal("two"), value: v.number() }),
+]);
 
 test.each([
-  { schema: v.literal('foo'), string: 'foo', parsed: 'foo' },
-  { schema: v.literal(1), string: '1', parsed: 1 },
-  { schema: v.literal(true), string: 'true', parsed: true },
-  { schema: v.string(), string: 'foo', parsed: 'foo' },
-  { schema: v.number(), string: '1', parsed: 1 },
-  { schema: v.boolean(), string: 'true', parsed: true },
-  { schema: v.date(), string: '2022-01-12T00:00:00.000Z', parsed: new Date('2022-01-12T00:00:00.000Z') },
-  { schema: v.object({ foo: v.string() }), string: '{"foo":"bar"}', parsed: { foo: 'bar' } },
-  { schema: v.object({ foo: v.nullable(v.string()) }), string: '{"foo":null}', parsed: { foo: null } },
-  { schema: v.object({ foo: v.optional(v.string()) }), string: '{}', parsed: {} },
-  { schema: v.enum(Fruits), string: '0', parsed: Fruits.Apple },
-  { schema: v.array(v.string()), string: '["foo","bar"]', parsed: ['foo', 'bar'] },
-  { schema: v.tuple([v.string(), v.number()]), string: '["foo",1]', parsed: ['foo', 1] },
-  { schema: v.union([v.string(), v.number()]), string: 'foo', parsed: 'foo' },
-  { schema: v.union([v.string(), v.number()]), string: '1', parsed: 1 },
-  { schema: v.union([v.string(), v.object({ foo: v.string() })]), string: '{"foo":"bar"}', parsed: { foo: 'bar' } },
-  { schema: discriminatedUnion, string: '{"type":"one","value":"foo"}', parsed: { type: 'one', value: 'foo' } },
-  { schema: discriminatedUnion, string: '{"type":"two","value":1}', parsed: { type: 'two', value: 1 } },
-  { schema: v.record(v.string(), v.object({ foo: v.string() })), string: '{"one":{"foo":"bar"}}', parsed: { one: { foo: 'bar' } } },
-  { schema: v.map(v.string(), v.number()), string: '[["one",1]]', parsed: new Map([['one', 1]]) },
-  { schema: v.set(v.number()), string: '[1,2,3]', parsed: new Set([1, 2, 3]) },
-])('given $schema.type, returns $parsed for $string', async ({ schema, string, parsed }) => {
-  if (typeof parsed === 'string' || typeof parsed === 'number' || typeof parsed === 'boolean') {
-    expect(safeGetParamValue(string, { param: schema })).toBe(parsed)
-    expect(safeSetParamValue(parsed, { param: schema })).toBe(string)
+  { schema: v.literal("foo"), string: "foo", parsed: "foo" },
+  { schema: v.literal(1), string: "1", parsed: 1 },
+  { schema: v.literal(true), string: "true", parsed: true },
+  { schema: v.string(), string: "foo", parsed: "foo" },
+  { schema: v.number(), string: "1", parsed: 1 },
+  { schema: v.boolean(), string: "true", parsed: true },
+  {
+    schema: v.date(),
+    string: "2022-01-12T00:00:00.000Z",
+    parsed: new Date("2022-01-12T00:00:00.000Z"),
+  },
+  { schema: v.object({ foo: v.string() }), string: '{"foo":"bar"}', parsed: { foo: "bar" } },
+  {
+    schema: v.object({ foo: v.nullable(v.string()) }),
+    string: '{"foo":null}',
+    parsed: { foo: null },
+  },
+  { schema: v.object({ foo: v.optional(v.string()) }), string: "{}", parsed: {} },
+  { schema: v.enum(Fruits), string: "0", parsed: Fruits.Apple },
+  { schema: v.array(v.string()), string: '["foo","bar"]', parsed: ["foo", "bar"] },
+  { schema: v.tuple([v.string(), v.number()]), string: '["foo",1]', parsed: ["foo", 1] },
+  { schema: v.union([v.string(), v.number()]), string: "foo", parsed: "foo" },
+  { schema: v.union([v.string(), v.number()]), string: "1", parsed: 1 },
+  {
+    schema: v.union([v.string(), v.object({ foo: v.string() })]),
+    string: '{"foo":"bar"}',
+    parsed: { foo: "bar" },
+  },
+  {
+    schema: discriminatedUnion,
+    string: '{"type":"one","value":"foo"}',
+    parsed: { type: "one", value: "foo" },
+  },
+  {
+    schema: discriminatedUnion,
+    string: '{"type":"two","value":1}',
+    parsed: { type: "two", value: 1 },
+  },
+  {
+    schema: v.record(v.string(), v.object({ foo: v.string() })),
+    string: '{"one":{"foo":"bar"}}',
+    parsed: { one: { foo: "bar" } },
+  },
+  { schema: v.map(v.string(), v.number()), string: '[["one",1]]', parsed: new Map([["one", 1]]) },
+  { schema: v.set(v.number()), string: "[1,2,3]", parsed: new Set([1, 2, 3]) },
+])("given $schema.type, returns $parsed for $string", async ({ schema, string, parsed }) => {
+  if (typeof parsed === "string" || typeof parsed === "number" || typeof parsed === "boolean") {
+    expect(safeGetParamValue(string, { param: schema })).toBe(parsed);
+    expect(safeSetParamValue(parsed, { param: schema })).toBe(string);
   } else {
-    expect(safeGetParamValue(string, { param: schema })).toMatchObject(parsed)
-    expect(safeSetParamValue(parsed, { param: schema })).toBe(string)
+    expect(safeGetParamValue(string, { param: schema })).toMatchObject(parsed);
+    expect(safeSetParamValue(parsed, { param: schema })).toBe(string);
   }
-})
+});
diff --git a/src/services/valibot.ts b/src/services/valibot.ts
index d6bfe9ec..9af5ba65 100644
--- a/src/services/valibot.ts
+++ b/src/services/valibot.ts
@@ -1,262 +1,264 @@
-import { Param, ParamGetSet } from '@/types/paramTypes'
-import { isRecord } from '@/utilities/guards'
-import { isPromise } from '@/utilities/promises'
-import { StandardSchemaV1 } from '@standard-schema/spec'
+import { Param, ParamGetSet } from "@/types/paramTypes";
+import { isRecord } from "@/utilities/guards";
+import { isPromise } from "@/utilities/promises";
+import { StandardSchemaV1 } from "@standard-schema/spec";
 
 export interface ValibotSchemaLike extends StandardSchemaV1<any> {
-  type: string,
+  type: string;
 }
 
 // inferring the return type is preferred for this function
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+// oxlint-disable-next-line @typescript-eslint/explicit-function-return-type
 function parse(schema: ValibotSchemaLike, value: unknown) {
-  const result = schema['~standard'].validate(value)
+  const result = schema["~standard"].validate(value);
 
   if (isPromise(result)) {
-    throw new Error('Promise schemas are not supported')
+    throw new Error("Promise schemas are not supported");
   }
 
   if (result.issues) {
-    throw new Error('Validation failed')
+    throw new Error("Validation failed");
   }
 
-  return result.value
+  return result.value;
 }
 
 function isValibotSchemaLike(param: Param): param is ValibotSchemaLike {
-  return isRecord(param)
-    && 'type' in param
-    && typeof param.type === 'string'
-    && '~standard' in param
-    && isRecord(param['~standard'])
-    && 'vendor' in param['~standard']
-    && param['~standard'].vendor === 'valibot'
+  return (
+    isRecord(param) &&
+    "type" in param &&
+    typeof param.type === "string" &&
+    "~standard" in param &&
+    isRecord(param["~standard"]) &&
+    "vendor" in param["~standard"] &&
+    param["~standard"].vendor === "valibot"
+  );
 }
 
 export function isValibotParam(value: Param): value is ValibotSchemaLike {
-  return isValibotSchemaLike(value)
+  return isValibotSchemaLike(value);
 }
 
 export function createValibotParam<T>(schema: ValibotSchemaLike): ParamGetSet<T> {
   return {
     get: (value, { invalid }) => {
       try {
-        return parseValibotValue(value, schema) as T
+        return parseValibotValue(value, schema) as T;
       } catch {
-        throw invalid()
+        throw invalid();
       }
     },
     set: (value, { invalid }) => {
       try {
-        return stringifyValibotValue(value, schema)
+        return stringifyValibotValue(value, schema);
       } catch {
-        throw invalid()
+        throw invalid();
       }
     },
-  }
+  };
 }
 
-const isoDateRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/
+const isoDateRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
 
 function reviver(_key: string, value: any): any {
-  if (typeof value === 'string' && isoDateRegex.test(value)) {
-    const date = new Date(value)
+  if (typeof value === "string" && isoDateRegex.test(value)) {
+    const date = new Date(value);
 
     if (isNaN(date.getTime())) {
-      return value
+      return value;
     }
 
-    return date
+    return date;
   }
 
-  return value
+  return value;
 }
 
 function tryAll<T>(fns: (() => T)[]): T {
   for (const fn of fns) {
     try {
-      return fn()
+      return fn();
     } catch {
-      continue
+      continue;
     }
   }
 
-  throw new Error('All functions failed')
+  throw new Error("All functions failed");
 }
 
 // Sorts string schemas last
 function sortValibotSchemas(schemaA: ValibotSchemaLike, schemaB: ValibotSchemaLike): number {
-  return schemaA.type === 'string' ? 1 : schemaB.type === 'string' ? -1 : 0
+  return schemaA.type === "string" ? 1 : schemaB.type === "string" ? -1 : 0;
 }
 
 function parseValibotValue(value: string, schema: ValibotSchemaLike): unknown {
-  if (schema.type === 'boolean') {
-    return parse(schema, Boolean(value))
+  if (schema.type === "boolean") {
+    return parse(schema, Boolean(value));
   }
 
-  if (schema.type === 'date') {
-    return parse(schema, new Date(value))
+  if (schema.type === "date") {
+    return parse(schema, new Date(value));
   }
 
-  if (schema.type === 'number') {
-    return parse(schema, Number(value))
+  if (schema.type === "number") {
+    return parse(schema, Number(value));
   }
 
-  if (schema.type === 'literal') {
+  if (schema.type === "literal") {
     return tryAll([
       () => parse(schema, Number(value)),
       () => parse(schema, Boolean(value)),
       () => parse(schema, value),
-    ])
+    ]);
   }
 
-  if (schema.type === 'object') {
-    return parse(schema, JSON.parse(value, reviver))
+  if (schema.type === "object") {
+    return parse(schema, JSON.parse(value, reviver));
   }
 
-  if (schema.type === 'enum') {
+  if (schema.type === "enum") {
     return tryAll([
       () => parse(schema, Number(value)),
       () => parse(schema, Boolean(value)),
       () => parse(schema, value),
-    ])
+    ]);
   }
 
-  if (schema.type === 'array') {
-    return parse(schema, JSON.parse(value, reviver))
+  if (schema.type === "array") {
+    return parse(schema, JSON.parse(value, reviver));
   }
 
-  if (schema.type === 'tuple') {
-    return parse(schema, JSON.parse(value, reviver))
+  if (schema.type === "tuple") {
+    return parse(schema, JSON.parse(value, reviver));
   }
 
-  if (schema.type === 'union' && 'options' in schema) {
+  if (schema.type === "union" && "options" in schema) {
     const schemas = (schema.options as ValibotSchemaLike[])
       .sort(sortValibotSchemas)
-      .map((schema) => () => parseValibotValue(value, schema))
+      .map((schema) => () => parseValibotValue(value, schema));
 
-    return tryAll(schemas)
+    return tryAll(schemas);
   }
 
-  if (schema.type === 'variant' && 'options' in schema) {
+  if (schema.type === "variant" && "options" in schema) {
     const schemas = (schema.options as ValibotSchemaLike[])
       .sort(sortValibotSchemas)
-      .map((schema) => () => parseValibotValue(value, schema))
+      .map((schema) => () => parseValibotValue(value, schema));
 
-    return tryAll(schemas)
+    return tryAll(schemas);
   }
 
-  if (schema.type === 'record') {
-    return parse(schema, JSON.parse(value, reviver))
+  if (schema.type === "record") {
+    return parse(schema, JSON.parse(value, reviver));
   }
 
-  if (schema.type === 'map') {
-    return parse(schema, new Map(JSON.parse(value, reviver)))
+  if (schema.type === "map") {
+    return parse(schema, new Map(JSON.parse(value, reviver)));
   }
 
-  if (schema.type === 'set') {
-    return parse(schema, new Set(JSON.parse(value, reviver)))
+  if (schema.type === "set") {
+    return parse(schema, new Set(JSON.parse(value, reviver)));
   }
 
-  if (schema.type === 'intersection') {
-    throw new Error('Intersection schemas are not supported')
+  if (schema.type === "intersection") {
+    throw new Error("Intersection schemas are not supported");
   }
 
-  if (schema.type === 'promise') {
-    throw new Error('Promise schemas are not supported')
+  if (schema.type === "promise") {
+    throw new Error("Promise schemas are not supported");
   }
 
-  if (schema.type === 'function') {
-    throw new Error('Function schemas are not supported')
+  if (schema.type === "function") {
+    throw new Error("Function schemas are not supported");
   }
 
-  return parse(schema, value)
+  return parse(schema, value);
 }
 
 function stringifyValibotValue(value: unknown, schema: ValibotSchemaLike): string {
-  if (schema.type === 'string') {
-    return parse(schema, value).toString()
+  if (schema.type === "string") {
+    return parse(schema, value).toString();
   }
 
-  if (schema.type === 'boolean') {
-    return parse(schema, value).toString()
+  if (schema.type === "boolean") {
+    return parse(schema, value).toString();
   }
 
-  if (schema.type === 'date') {
-    return parse(schema, value).toISOString()
+  if (schema.type === "date") {
+    return parse(schema, value).toISOString();
   }
 
-  if (schema.type === 'number') {
-    return parse(schema, Number(value)).toString()
+  if (schema.type === "number") {
+    return parse(schema, Number(value)).toString();
   }
 
-  if (schema.type === 'literal') {
-    return parse(schema, value).toString()
+  if (schema.type === "literal") {
+    return parse(schema, value).toString();
   }
 
-  if (schema.type === 'object') {
-    return JSON.stringify(parse(schema, value))
+  if (schema.type === "object") {
+    return JSON.stringify(parse(schema, value));
   }
 
-  if (schema.type === 'enum') {
-    return parse(schema, value).toString()
+  if (schema.type === "enum") {
+    return parse(schema, value).toString();
   }
 
-  if (schema.type === 'nativeEnum') {
-    return parse(schema, value).toString()
+  if (schema.type === "nativeEnum") {
+    return parse(schema, value).toString();
   }
 
-  if (schema.type === 'array') {
-    return JSON.stringify(parse(schema, value))
+  if (schema.type === "array") {
+    return JSON.stringify(parse(schema, value));
   }
 
-  if (schema.type === 'tuple') {
-    return JSON.stringify(parse(schema, value))
+  if (schema.type === "tuple") {
+    return JSON.stringify(parse(schema, value));
   }
 
-  if (schema.type === 'union' && 'options' in schema) {
+  if (schema.type === "union" && "options" in schema) {
     const schemas = (schema.options as ValibotSchemaLike[])
       .sort(sortValibotSchemas)
-      .map((schema) => () => stringifyValibotValue(value, schema))
+      .map((schema) => () => stringifyValibotValue(value, schema));
 
-    return tryAll(schemas)
+    return tryAll(schemas);
   }
 
-  if (schema.type === 'variant' && 'options' in schema) {
+  if (schema.type === "variant" && "options" in schema) {
     const schemas = (schema.options as ValibotSchemaLike[])
       .sort(sortValibotSchemas)
-      .map((schema) => () => stringifyValibotValue(value, schema))
+      .map((schema) => () => stringifyValibotValue(value, schema));
 
-    return tryAll(schemas)
+    return tryAll(schemas);
   }
 
-  if (schema.type === 'record') {
-    return JSON.stringify(parse(schema, value))
+  if (schema.type === "record") {
+    return JSON.stringify(parse(schema, value));
   }
 
-  if (schema.type === 'map') {
-    const parsed = parse(schema, value)
+  if (schema.type === "map") {
+    const parsed = parse(schema, value);
 
-    return JSON.stringify(Array.from(parsed.entries()))
+    return JSON.stringify(Array.from(parsed.entries()));
   }
 
-  if (schema.type === 'set') {
-    const parsed = parse(schema, value)
+  if (schema.type === "set") {
+    const parsed = parse(schema, value);
 
-    return JSON.stringify(Array.from(parsed.values()))
+    return JSON.stringify(Array.from(parsed.values()));
   }
 
-  if (schema.type === 'intersection') {
-    throw new Error('Intersection schemas are not supported')
+  if (schema.type === "intersection") {
+    throw new Error("Intersection schemas are not supported");
   }
 
-  if (schema.type === 'promise') {
-    throw new Error('Promise schemas are not supported')
+  if (schema.type === "promise") {
+    throw new Error("Promise schemas are not supported");
   }
 
-  if (schema.type === 'function') {
-    throw new Error('Function schemas are not supported')
+  if (schema.type === "function") {
+    throw new Error("Function schemas are not supported");
   }
 
-  return JSON.stringify(parse(schema, value))
+  return JSON.stringify(parse(schema, value));
 }
diff --git a/src/services/withParams.spec-d.ts b/src/services/withParams.spec-d.ts
index d8cf37cb..369c4ab9 100644
--- a/src/services/withParams.spec-d.ts
+++ b/src/services/withParams.spec-d.ts
@@ -1,151 +1,174 @@
-import { expectTypeOf, test, describe } from 'vitest'
-import { ToUrlQueryPart, ToUrlPart, UrlPart, withParams } from '@/services/withParams'
-import { ParamWithDefault } from './withDefault'
+import { expectTypeOf, test, describe } from "vite-plus/test";
+import { ToUrlQueryPart, ToUrlPart, UrlPart, withParams } from "@/services/withParams";
+import { ParamWithDefault } from "./withDefault";
 
-test('given a string without params, expects no params', () => {
-  const source = withParams('/something-without-params', {})
+test("given a string without params, expects no params", () => {
+  const source = withParams("/something-without-params", {});
 
-  type Source = typeof source
-  type Expect = UrlPart<{}>
+  type Source = typeof source;
+  type Expect = UrlPart<{}>;
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-})
+  expectTypeOf<Source>().toEqualTypeOf<Expect>();
+});
 
-test('given a string with required params NOT assigned, uses string constructor', () => {
-  const source = withParams('/something-with-[param]', {})
+test("given a string with required params NOT assigned, uses string constructor", () => {
+  const source = withParams("/something-with-[param]", {});
 
-  type Source = typeof source
-  type Expect = UrlPart<{ param: { param: StringConstructor, isOptional: false, isGreedy: false } }>
+  type Source = typeof source;
+  type Expect = UrlPart<{
+    param: { param: StringConstructor; isOptional: false; isGreedy: false };
+  }>;
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-})
+  expectTypeOf<Source>().toEqualTypeOf<Expect>();
+});
 
-test('given a string with required params assigned, uses passed in Type', () => {
-  const source = withParams('/something-with-[param]', { param: Boolean })
+test("given a string with required params assigned, uses passed in Type", () => {
+  const source = withParams("/something-with-[param]", { param: Boolean });
 
-  type Source = typeof source
-  type Expect = UrlPart<{ param: { param: BooleanConstructor, isOptional: false, isGreedy: false } }>
+  type Source = typeof source;
+  type Expect = UrlPart<{
+    param: { param: BooleanConstructor; isOptional: false; isGreedy: false };
+  }>;
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-})
+  expectTypeOf<Source>().toEqualTypeOf<Expect>();
+});
 
-describe('ToUrlPart', () => {
-  test('given a string, returns ToUrlPart with that string and empty params', () => {
-    type Source = ToUrlPart<'test'>
-    type Expect = UrlPart<{}>
+describe("ToUrlPart", () => {
+  test("given a string, returns ToUrlPart with that string and empty params", () => {
+    type Source = ToUrlPart<"test">;
+    type Expect = UrlPart<{}>;
 
-    expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
 
-  test('given undefined, returns ToUrlPart with empty string', () => {
-    type Source = ToUrlPart<undefined>
-    type Expect = UrlPart<{}>
+  test("given undefined, returns ToUrlPart with empty string", () => {
+    type Source = ToUrlPart<undefined>;
+    type Expect = UrlPart<{}>;
 
-    expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
 
-  test('given a ToUrlPart type, returns the same type', () => {
-    type Source = ToUrlPart<UrlPart<{ foo: { param: NumberConstructor, isOptional: false, isGreedy: false } }>>
-    type Expect = UrlPart<{ foo: { param: NumberConstructor, isOptional: false, isGreedy: false } }>
+  test("given a ToUrlPart type, returns the same type", () => {
+    type Source = ToUrlPart<
+      UrlPart<{ foo: { param: NumberConstructor; isOptional: false; isGreedy: false } }>
+    >;
+    type Expect = UrlPart<{
+      foo: { param: NumberConstructor; isOptional: false; isGreedy: false };
+    }>;
 
-    expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
-})
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
+});
 
-describe('ToUrlQueryPart', () => {
-  test('given a string, returns UrlPart with that string', () => {
-    type Source = ToUrlQueryPart<'foo=bar'>
-    type Expect = UrlPart<{}>
+describe("ToUrlQueryPart", () => {
+  test("given a string, returns UrlPart with that string", () => {
+    type Source = ToUrlQueryPart<"foo=bar">;
+    type Expect = UrlPart<{}>;
 
-    expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
 
-  test('given undefined, returns UrlPart with empty string', () => {
-    type Source = ToUrlQueryPart<undefined>
-    type Expect = UrlPart<{}>
+  test("given undefined, returns UrlPart with empty string", () => {
+    type Source = ToUrlQueryPart<undefined>;
+    type Expect = UrlPart<{}>;
 
-    expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
 
-  test('given a UrlPart type, returns the same type', () => {
-    const query = withParams('foo=[foo]', { foo: Number })
-    type Source = ToUrlQueryPart<typeof query>
-    type Expect = UrlPart<{ foo: { param: NumberConstructor, isOptional: false, isGreedy: false } }>
+  test("given a UrlPart type, returns the same type", () => {
+    const query = withParams("foo=[foo]", { foo: Number });
+    type Source = ToUrlQueryPart<typeof query>;
+    type Expect = UrlPart<{
+      foo: { param: NumberConstructor; isOptional: false; isGreedy: false };
+    }>;
 
-    expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
 
-  test('given a record with string values, returns record of UrlPart', () => {
-    type Source = ToUrlQueryPart<{ foo: 'bar', baz: 'qux' }>
-    type Expect = UrlPart<{}>
+  test("given a record with string values, returns record of UrlPart", () => {
+    type Source = ToUrlQueryPart<{ foo: "bar"; baz: "qux" }>;
+    type Expect = UrlPart<{}>;
 
-    expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
 
-  test('given a record with Param values, returns record of parameterized UrlPart', () => {
-    type Source = ToUrlQueryPart<{ foo: NumberConstructor, baz: BooleanConstructor, zoo: '14' }>
+  test("given a record with Param values, returns record of parameterized UrlPart", () => {
+    type Source = ToUrlQueryPart<{ foo: NumberConstructor; baz: BooleanConstructor; zoo: "14" }>;
     type Expect = UrlPart<{
-      foo: { param: NumberConstructor, isOptional: false, isGreedy: false },
-      baz: { param: BooleanConstructor, isOptional: false, isGreedy: false },
-    }>
-
-    expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
-
-  test('given a record with Param values and optional key, returns record of parameterized UrlPart', () => {
-    type Source = ToUrlQueryPart<{ 'foo': NumberConstructor, '?baz': BooleanConstructor, '?zoo': '14' }>
+      foo: { param: NumberConstructor; isOptional: false; isGreedy: false };
+      baz: { param: BooleanConstructor; isOptional: false; isGreedy: false };
+    }>;
+
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
+
+  test("given a record with Param values and optional key, returns record of parameterized UrlPart", () => {
+    type Source = ToUrlQueryPart<{
+      foo: NumberConstructor;
+      "?baz": BooleanConstructor;
+      "?zoo": "14";
+    }>;
     type Expect = UrlPart<{
-      foo: { param: NumberConstructor, isOptional: false, isGreedy: false },
-      baz: { param: BooleanConstructor, isOptional: true, isGreedy: false },
-    }>
-
-    expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
-
-  test('given a record with Param values with a param that has a default value, returns record of parameterized UrlPart', () => {
-    type Source = ToUrlQueryPart<{ foo: NumberConstructor, baz: ParamWithDefault<BooleanConstructor> }>
+      foo: { param: NumberConstructor; isOptional: false; isGreedy: false };
+      baz: { param: BooleanConstructor; isOptional: true; isGreedy: false };
+    }>;
+
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
+
+  test("given a record with Param values with a param that has a default value, returns record of parameterized UrlPart", () => {
+    type Source = ToUrlQueryPart<{
+      foo: NumberConstructor;
+      baz: ParamWithDefault<BooleanConstructor>;
+    }>;
     type Expect = {
-      foo: { isOptional: false, isGreedy: false },
-      baz: { isOptional: true, isGreedy: false },
-    }
+      foo: { isOptional: false; isGreedy: false };
+      baz: { isOptional: true; isGreedy: false };
+    };
 
-    expectTypeOf<Source['params']>().toMatchObjectType<Expect>()
-  })
+    expectTypeOf<Source["params"]>().toMatchObjectType<Expect>();
+  });
 
-  test('given an array with string tuples, each element maps to UrlPart', () => {
-    type Source = ToUrlQueryPart<[['foo', 'bar'], ['baz', 'qux']]>
-    type Expect = UrlPart<{}>
+  test("given an array with string tuples, each element maps to UrlPart", () => {
+    type Source = ToUrlQueryPart<[["foo", "bar"], ["baz", "qux"]]>;
+    type Expect = UrlPart<{}>;
 
-    expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
 
-  test('given an array with Param tuples, each element maps to parameterized UrlPart', () => {
-    type Source = ToUrlQueryPart<[['foo', NumberConstructor], ['baz', BooleanConstructor], ['zoo', '14']]>
+  test("given an array with Param tuples, each element maps to parameterized UrlPart", () => {
+    type Source = ToUrlQueryPart<
+      [["foo", NumberConstructor], ["baz", BooleanConstructor], ["zoo", "14"]]
+    >;
     type Expect = UrlPart<{
-      foo: { param: NumberConstructor, isOptional: false, isGreedy: false },
-      baz: { param: BooleanConstructor, isOptional: false, isGreedy: false },
-    }>
+      foo: { param: NumberConstructor; isOptional: false; isGreedy: false };
+      baz: { param: BooleanConstructor; isOptional: false; isGreedy: false };
+    }>;
 
-    expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
 
-  test('given an array with Param tuples and optional key, each element maps to parameterized UrlPart', () => {
-    type Source = ToUrlQueryPart<[['foo', NumberConstructor], ['?baz', BooleanConstructor], ['?zoo', '14']]>
+  test("given an array with Param tuples and optional key, each element maps to parameterized UrlPart", () => {
+    type Source = ToUrlQueryPart<
+      [["foo", NumberConstructor], ["?baz", BooleanConstructor], ["?zoo", "14"]]
+    >;
     type Expect = UrlPart<{
-      foo: { param: NumberConstructor, isOptional: false, isGreedy: false },
-      baz: { param: BooleanConstructor, isOptional: true, isGreedy: false },
-    }>
+      foo: { param: NumberConstructor; isOptional: false; isGreedy: false };
+      baz: { param: BooleanConstructor; isOptional: true; isGreedy: false };
+    }>;
 
-    expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
 
-  test('given an array with Param tuples and Param with default value, each element maps to parameterized UrlPart', () => {
-    type Source = ToUrlQueryPart<[['foo', NumberConstructor], ['baz', ParamWithDefault<BooleanConstructor>]]>
+  test("given an array with Param tuples and Param with default value, each element maps to parameterized UrlPart", () => {
+    type Source = ToUrlQueryPart<
+      [["foo", NumberConstructor], ["baz", ParamWithDefault<BooleanConstructor>]]
+    >;
     type Expect = {
-      foo: { isOptional: false, isGreedy: false },
-      baz: { isOptional: true, isGreedy: false },
-    }
+      foo: { isOptional: false; isGreedy: false };
+      baz: { isOptional: true; isGreedy: false };
+    };
 
-    expectTypeOf<Source['params']>().toMatchObjectType<Expect>()
-  })
-})
+    expectTypeOf<Source["params"]>().toMatchObjectType<Expect>();
+  });
+});
diff --git a/src/services/withParams.spec.ts b/src/services/withParams.spec.ts
index f1195fe8..31bd7d50 100644
--- a/src/services/withParams.spec.ts
+++ b/src/services/withParams.spec.ts
@@ -1,161 +1,177 @@
-import { expect, test, describe } from 'vitest'
-import { DuplicateParamsError } from '@/errors/duplicateParamsError'
-import { withDefault } from '@/services/withDefault'
-import { toUrlQueryPart, toUrlPart, withParams } from '@/services/withParams'
+import { expect, test, describe } from "vite-plus/test";
+import { DuplicateParamsError } from "@/errors/duplicateParamsError";
+import { withDefault } from "@/services/withDefault";
+import { toUrlQueryPart, toUrlPart, withParams } from "@/services/withParams";
 
-test('given value without params, returns empty object', () => {
-  const response = withParams('example-without-params', {})
+test("given value without params, returns empty object", () => {
+  const response = withParams("example-without-params", {});
 
-  expect(response.params).toMatchObject({})
-})
+  expect(response.params).toMatchObject({});
+});
 
-test('given value with simple params, returns each param name as type String', () => {
-  const response = withParams('[parentId]-[childId]', {})
+test("given value with simple params, returns each param name as type String", () => {
+  const response = withParams("[parentId]-[childId]", {});
 
   expect(response.params).toMatchObject({
     parentId: { param: String, isOptional: false, isGreedy: false },
     childId: { param: String, isOptional: false, isGreedy: false },
-  })
-})
-
-test('given value with optional params, returns each param name as type String', () => {
-  const response = withParams('[?parentId]-[?childId]', {})
-
-  expect(JSON.stringify(response.params)).toMatch(JSON.stringify({
-    parentId: { param: String, isOptional: true, isGreedy: false },
-    childId: { param: String, isOptional: true, isGreedy: false },
-  }))
-})
-
-test('given value with param types, returns each param with corresponding param', () => {
-  const response = withParams('[parentId]-[childId]', {
+  });
+});
+
+test("given value with optional params, returns each param name as type String", () => {
+  const response = withParams("[?parentId]-[?childId]", {});
+
+  expect(JSON.stringify(response.params)).toMatch(
+    JSON.stringify({
+      parentId: { param: String, isOptional: true, isGreedy: false },
+      childId: { param: String, isOptional: true, isGreedy: false },
+    }),
+  );
+});
+
+test("given value with param types, returns each param with corresponding param", () => {
+  const response = withParams("[parentId]-[childId]", {
     parentId: Boolean,
-  })
+  });
 
   expect(response.params).toMatchObject({
     parentId: { param: Boolean, isOptional: false, isGreedy: false },
     childId: { param: String, isOptional: false, isGreedy: false },
-  })
-})
+  });
+});
 
-test('given value with the same param name, throws DuplicateParamsError', () => {
-  const action: () => void = () => withParams('[foo]-[?foo]', { })
+test("given value with the same param name, throws DuplicateParamsError", () => {
+  const action: () => void = () => withParams("[foo]-[?foo]", {});
 
-  expect(action).toThrowError(DuplicateParamsError)
-})
+  expect(action).toThrowError(DuplicateParamsError);
+});
 
-describe('toUrlPart', () => {
-  test('given a string, returns UrlPart with that value', () => {
-    const response = toUrlPart('foo=bar')
+describe("toUrlPart", () => {
+  test("given a string, returns UrlPart with that value", () => {
+    const response = toUrlPart("foo=bar");
 
-    expect(response.value).toBe('foo=bar')
-  })
+    expect(response.value).toBe("foo=bar");
+  });
 
-  test('given undefined, returns UrlPart with empty value', () => {
-    const response = toUrlPart(undefined)
+  test("given undefined, returns UrlPart with empty value", () => {
+    const response = toUrlPart(undefined);
 
-    expect(response.value).toBe('')
-  })
+    expect(response.value).toBe("");
+  });
 
-  test('given a UrlPart object, returns same object', () => {
-    const original = withParams('test', {})
-    const response = toUrlPart(original)
+  test("given a UrlPart object, returns same object", () => {
+    const original = withParams("test", {});
+    const response = toUrlPart(original);
 
-    expect(response).toBe(original)
-  })
-})
+    expect(response).toBe(original);
+  });
+});
 
-describe('toUrlQueryPart', () => {
-  test('given a string, returns UrlPartWithParams with that value', () => {
-    const response = toUrlQueryPart('foo=bar')
+describe("toUrlQueryPart", () => {
+  test("given a string, returns UrlPartWithParams with that value", () => {
+    const response = toUrlQueryPart("foo=bar");
 
-    expect(response.value).toBe('foo=bar')
-  })
+    expect(response.value).toBe("foo=bar");
+  });
 
-  test('given undefined, returns UrlPartWithParams with empty value', () => {
-    const response = toUrlQueryPart(undefined)
+  test("given undefined, returns UrlPartWithParams with empty value", () => {
+    const response = toUrlQueryPart(undefined);
 
-    expect(response.value).toBe('')
-  })
+    expect(response.value).toBe("");
+  });
 
-  test('given a UrlPartWithParams object, returns same object', () => {
-    const original = withParams('test', {})
-    const response = toUrlQueryPart(original)
+  test("given a UrlPartWithParams object, returns same object", () => {
+    const original = withParams("test", {});
+    const response = toUrlQueryPart(original);
 
-    expect(response).toBe(original)
-  })
+    expect(response).toBe(original);
+  });
 
-  test('given a record with string values, converts to query string', () => {
-    const response = toUrlQueryPart({ foo: 'bar', baz: 'qux' })
+  test("given a record with string values, converts to query string", () => {
+    const response = toUrlQueryPart({ foo: "bar", baz: "qux" });
 
-    expect(response.value).toBe('foo=bar&baz=qux')
-    expect(response.params).toMatchObject({})
-  })
+    expect(response.value).toBe("foo=bar&baz=qux");
+    expect(response.params).toMatchObject({});
+  });
 
-  test('given a record with Param values, converts to parameterized query string', () => {
-    const response = toUrlQueryPart({ foo: Number, baz: Boolean })
+  test("given a record with Param values, converts to parameterized query string", () => {
+    const response = toUrlQueryPart({ foo: Number, baz: Boolean });
 
-    expect(response.value).toBe('foo=[foo]&baz=[baz]')
+    expect(response.value).toBe("foo=[foo]&baz=[baz]");
     expect(response.params).toMatchObject({
       foo: { param: Number, isOptional: false, isGreedy: false },
       baz: { param: Boolean, isOptional: false, isGreedy: false },
-    })
-  })
+    });
+  });
 
-  test('given a record with Param values and optional key, converts to parameterized query string', () => {
-    const response = toUrlQueryPart({ 'foo': Number, '?baz': Boolean, '?zoo': 'zoo' })
+  test("given a record with Param values and optional key, converts to parameterized query string", () => {
+    const response = toUrlQueryPart({ foo: Number, "?baz": Boolean, "?zoo": "zoo" });
 
-    expect(response.value).toBe('foo=[foo]&baz=[?baz]&?zoo=zoo')
+    expect(response.value).toBe("foo=[foo]&baz=[?baz]&?zoo=zoo");
     expect(response.params).toMatchObject({
       foo: { param: Number, isOptional: false, isGreedy: false },
       baz: { param: Boolean, isOptional: true, isGreedy: false },
-    })
-  })
+    });
+  });
 
-  test('given a record with Param values and Param with default value, converts to parameterized query string', () => {
-    const response = toUrlQueryPart({ foo: Number, baz: withDefault(Boolean, true) })
+  test("given a record with Param values and Param with default value, converts to parameterized query string", () => {
+    const response = toUrlQueryPart({ foo: Number, baz: withDefault(Boolean, true) });
 
-    expect(response.value).toBe('foo=[foo]&baz=[baz]')
+    expect(response.value).toBe("foo=[foo]&baz=[baz]");
     expect(response.params).toMatchObject({
       foo: { isOptional: false, isGreedy: false },
       baz: { isOptional: true, isGreedy: false },
-    })
-  })
-
-  test('given an array with string values, converts to query string', () => {
-    const response = toUrlQueryPart([['foo', 'bar'], ['baz', 'qux']])
-
-    expect(response.value).toBe('foo=bar&baz=qux')
-    expect(response.params).toMatchObject({})
-  })
-
-  test('given an array with Param values, converts to parameterized query string', () => {
-    const response = toUrlQueryPart([['foo', Number], ['baz', Boolean], ['zoo', 'zoo']])
-
-    expect(response.value).toBe('foo=[foo]&baz=[baz]&zoo=zoo')
+    });
+  });
+
+  test("given an array with string values, converts to query string", () => {
+    const response = toUrlQueryPart([
+      ["foo", "bar"],
+      ["baz", "qux"],
+    ]);
+
+    expect(response.value).toBe("foo=bar&baz=qux");
+    expect(response.params).toMatchObject({});
+  });
+
+  test("given an array with Param values, converts to parameterized query string", () => {
+    const response = toUrlQueryPart([
+      ["foo", Number],
+      ["baz", Boolean],
+      ["zoo", "zoo"],
+    ]);
+
+    expect(response.value).toBe("foo=[foo]&baz=[baz]&zoo=zoo");
     expect(response.params).toMatchObject({
       foo: { param: Number, isOptional: false, isGreedy: false },
       baz: { param: Boolean, isOptional: false, isGreedy: false },
-    })
-  })
+    });
+  });
 
-  test('given an array with Param values and optional key, converts to parameterized query string', () => {
-    const response = toUrlQueryPart([['foo', Number], ['?baz', Boolean], ['?zoo', 'zoo']])
+  test("given an array with Param values and optional key, converts to parameterized query string", () => {
+    const response = toUrlQueryPart([
+      ["foo", Number],
+      ["?baz", Boolean],
+      ["?zoo", "zoo"],
+    ]);
 
-    expect(response.value).toBe('foo=[foo]&baz=[?baz]&?zoo=zoo')
+    expect(response.value).toBe("foo=[foo]&baz=[?baz]&?zoo=zoo");
     expect(response.params).toMatchObject({
       foo: { param: Number, isOptional: false, isGreedy: false },
       baz: { param: Boolean, isOptional: true, isGreedy: false },
-    })
-  })
+    });
+  });
 
-  test('given an array with Param values and Param with default value, converts to parameterized query string', () => {
-    const response = toUrlQueryPart([['foo', Number], ['baz', withDefault(Boolean, true)]])
+  test("given an array with Param values and Param with default value, converts to parameterized query string", () => {
+    const response = toUrlQueryPart([
+      ["foo", Number],
+      ["baz", withDefault(Boolean, true)],
+    ]);
 
-    expect(response.value).toBe('foo=[foo]&baz=[baz]')
+    expect(response.value).toBe("foo=[foo]&baz=[baz]");
     expect(response.params).toMatchObject({
       foo: { isOptional: false, isGreedy: false },
       baz: { isOptional: true, isGreedy: false },
-    })
-  })
-})
+    });
+  });
+});
diff --git a/src/services/zod.spec-d.ts b/src/services/zod.spec-d.ts
index c2288f73..9c97cc63 100644
--- a/src/services/zod.spec-d.ts
+++ b/src/services/zod.spec-d.ts
@@ -1,18 +1,22 @@
-import { expectTypeOf, test } from 'vitest'
-import { withParams } from './withParams'
-import { z } from 'zod'
-import { ExtractParamType } from '@/types/params'
+import { expectTypeOf, test } from "vite-plus/test";
+import { withParams } from "./withParams";
+import { z } from "zod";
+import { ExtractParamType } from "@/types/params";
 
-test('withParams accepts zod schemas', () => {
-  const schema = z.string()
-  const { params } = withParams('/[foo]', { foo: schema })
+test("withParams accepts zod schemas", () => {
+  const schema = z.string();
+  const { params } = withParams("/[foo]", { foo: schema });
 
-  expectTypeOf(params.foo).toEqualTypeOf<{ param: typeof schema, isOptional: false, isGreedy: false }>()
-})
+  expectTypeOf(params.foo).toEqualTypeOf<{
+    param: typeof schema;
+    isOptional: false;
+    isGreedy: false;
+  }>();
+});
 
-test('ExtractParamType returns the correct type for zod params', () => {
-  const param = z.boolean()
-  type Input = ExtractParamType<typeof param>
+test("ExtractParamType returns the correct type for zod params", () => {
+  const param = z.boolean();
+  type Input = ExtractParamType<typeof param>;
 
-  expectTypeOf<Input>().toEqualTypeOf<boolean>()
-})
+  expectTypeOf<Input>().toEqualTypeOf<boolean>();
+});
diff --git a/src/services/zod.spec.ts b/src/services/zod.spec.ts
index 5efab203..f798c520 100644
--- a/src/services/zod.spec.ts
+++ b/src/services/zod.spec.ts
@@ -1,76 +1,122 @@
-import { safeGetParamValue, safeSetParamValue } from './params'
-import { z } from 'zod'
-import { test, expect } from 'vitest'
-import { initZod } from './zod'
+import { safeGetParamValue, safeSetParamValue } from "./params";
+import { z } from "zod";
+import { test, expect } from "vite-plus/test";
+import { initZod } from "./zod";
 
-const discriminatedUnion = z.discriminatedUnion('type', [
-  z.object({ type: z.literal('one'), value: z.string() }),
-  z.object({ type: z.literal('two'), value: z.number() }),
-])
+const discriminatedUnion = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("one"), value: z.string() }),
+  z.object({ type: z.literal("two"), value: z.number() }),
+]);
 
 enum Fruits {
-  Apple = '0',
-  Banana = '1'
+  Apple = "0",
+  Banana = "1",
 }
 
 test.each([
-  { schema: z.literal('foo'), string: 'foo', parsed: 'foo' },
-  { schema: z.literal(1), string: '1', parsed: 1 },
-  { schema: z.literal(true), string: 'true', parsed: true },
-  { schema: z.string(), string: 'foo', parsed: 'foo' },
-  { schema: z.number(), string: '1', parsed: 1 },
-  { schema: z.boolean(), string: 'true', parsed: true },
-  { schema: z.iso.datetime(), string: '2022-01-12T00:00:00.000Z', parsed: '2022-01-12T00:00:00.000Z' },
-  { schema: z.iso.date(), string: '2022-01-12', parsed: '2022-01-12' },
-  { schema: z.iso.time(), string: '09:52:31', parsed: '09:52:31' },
-  { schema: z.date(), string: '2022-01-12T00:00:00.000Z', parsed: new Date('2022-01-12T00:00:00.000Z') },
-  { schema: z.object({ foo: z.string() }), string: '{"foo":"bar"}', parsed: { foo: 'bar' } },
-  { schema: z.object({ foo: z.string().nullable() }), string: '{"foo":null}', parsed: { foo: null } },
-  { schema: z.object({ foo: z.string().optional() }), string: '{}', parsed: {} },
-  { schema: z.enum(['foo', 'bar']), string: 'foo', parsed: 'foo' },
-  { schema: z.enum(Fruits), string: '0', parsed: Fruits.Apple },
-  { schema: z.string().array(), string: '["foo","bar"]', parsed: ['foo', 'bar'] },
-  { schema: z.ipv4(), string: '192.168.1.1', parsed: '192.168.1.1' },
-  { schema: z.ipv6(), string: '2001:db8::1', parsed: '2001:db8::1' },
-  { schema: z.cidrv4(), string: '192.168.0.0/24', parsed: '192.168.0.0/24' },
-  { schema: z.cidrv6(), string: '2001:db8::/64', parsed: '2001:db8::/64' },
-  { schema: z.url(), string: 'https://example.com', parsed: 'https://example.com' },
-  { schema: z.email(), string: 'test@example.com', parsed: 'test@example.com' },
-  { schema: z.uuid(), string: '123e4567-e89b-12d3-a456-426614174000', parsed: '123e4567-e89b-12d3-a456-426614174000' },
-  { schema: z.base64(), string: 'SGVsbG8gV29ybGQ=', parsed: 'SGVsbG8gV29ybGQ=' },
-  { schema: z.cuid(), string: 'ckopqwooh000001la8h2e3xb6', parsed: 'ckopqwooh000001la8h2e3xb6' },
-  { schema: z.cuid2(), string: 'tz4a98xxat96iws9zmbrgj3a', parsed: 'tz4a98xxat96iws9zmbrgj3a' },
-  { schema: z.ulid(), string: '01ARZ3NDEKTSV4RRFFQ69G5FAV', parsed: '01ARZ3NDEKTSV4RRFFQ69G5FAV' },
-  { schema: z.jwt(), string: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.dozjgNryP4J3jVmNHl0w5N_XgL0n3I9PlFUP0THsR8U', parsed: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.dozjgNryP4J3jVmNHl0w5N_XgL0n3I9PlFUP0THsR8U' },
-  { schema: z.bigint(), string: '123', parsed: 123n },
-  { schema: z.nan(), string: 'NaN', parsed: NaN },
-  { schema: z.tuple([z.string(), z.number()]), string: '["foo",1]', parsed: ['foo', 1] },
-  { schema: z.union([z.string(), z.number()]), string: 'foo', parsed: 'foo' },
-  { schema: z.union([z.string(), z.number()]), string: '1', parsed: 1 },
-  { schema: z.union([z.string(), z.object({ foo: z.string() })]), string: '{"foo":"bar"}', parsed: { foo: 'bar' } },
-  { schema: discriminatedUnion, string: '{"type":"one","value":"foo"}', parsed: { type: 'one', value: 'foo' } },
-  { schema: discriminatedUnion, string: '{"type":"two","value":1}', parsed: { type: 'two', value: 1 } },
-  { schema: z.record(z.string(), z.object({ foo: z.string() })), string: '{"one":{"foo":"bar"}}', parsed: { one: { foo: 'bar' } } },
-  { schema: z.map(z.string(), z.number()), string: '[["one",1]]', parsed: new Map([['one', 1]]) },
-  { schema: z.set(z.number()), string: '[1,2,3]', parsed: new Set([1, 2, 3]) },
-])('given $schema, returns $parsed for $string', async ({ schema, string, parsed }) => {
-  await initZod()
+  { schema: z.literal("foo"), string: "foo", parsed: "foo" },
+  { schema: z.literal(1), string: "1", parsed: 1 },
+  { schema: z.literal(true), string: "true", parsed: true },
+  { schema: z.string(), string: "foo", parsed: "foo" },
+  { schema: z.number(), string: "1", parsed: 1 },
+  { schema: z.boolean(), string: "true", parsed: true },
+  {
+    schema: z.iso.datetime(),
+    string: "2022-01-12T00:00:00.000Z",
+    parsed: "2022-01-12T00:00:00.000Z",
+  },
+  { schema: z.iso.date(), string: "2022-01-12", parsed: "2022-01-12" },
+  { schema: z.iso.time(), string: "09:52:31", parsed: "09:52:31" },
+  {
+    schema: z.date(),
+    string: "2022-01-12T00:00:00.000Z",
+    parsed: new Date("2022-01-12T00:00:00.000Z"),
+  },
+  { schema: z.object({ foo: z.string() }), string: '{"foo":"bar"}', parsed: { foo: "bar" } },
+  {
+    schema: z.object({ foo: z.string().nullable() }),
+    string: '{"foo":null}',
+    parsed: { foo: null },
+  },
+  { schema: z.object({ foo: z.string().optional() }), string: "{}", parsed: {} },
+  { schema: z.enum(["foo", "bar"]), string: "foo", parsed: "foo" },
+  { schema: z.enum(Fruits), string: "0", parsed: Fruits.Apple },
+  { schema: z.string().array(), string: '["foo","bar"]', parsed: ["foo", "bar"] },
+  { schema: z.ipv4(), string: "192.168.1.1", parsed: "192.168.1.1" },
+  { schema: z.ipv6(), string: "2001:db8::1", parsed: "2001:db8::1" },
+  { schema: z.cidrv4(), string: "192.168.0.0/24", parsed: "192.168.0.0/24" },
+  { schema: z.cidrv6(), string: "2001:db8::/64", parsed: "2001:db8::/64" },
+  { schema: z.url(), string: "https://example.com", parsed: "https://example.com" },
+  { schema: z.email(), string: "test@example.com", parsed: "test@example.com" },
+  {
+    schema: z.uuid(),
+    string: "123e4567-e89b-12d3-a456-426614174000",
+    parsed: "123e4567-e89b-12d3-a456-426614174000",
+  },
+  { schema: z.base64(), string: "SGVsbG8gV29ybGQ=", parsed: "SGVsbG8gV29ybGQ=" },
+  { schema: z.cuid(), string: "ckopqwooh000001la8h2e3xb6", parsed: "ckopqwooh000001la8h2e3xb6" },
+  { schema: z.cuid2(), string: "tz4a98xxat96iws9zmbrgj3a", parsed: "tz4a98xxat96iws9zmbrgj3a" },
+  { schema: z.ulid(), string: "01ARZ3NDEKTSV4RRFFQ69G5FAV", parsed: "01ARZ3NDEKTSV4RRFFQ69G5FAV" },
+  {
+    schema: z.jwt(),
+    string:
+      "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.dozjgNryP4J3jVmNHl0w5N_XgL0n3I9PlFUP0THsR8U",
+    parsed:
+      "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.dozjgNryP4J3jVmNHl0w5N_XgL0n3I9PlFUP0THsR8U",
+  },
+  { schema: z.bigint(), string: "123", parsed: 123n },
+  { schema: z.nan(), string: "NaN", parsed: NaN },
+  { schema: z.tuple([z.string(), z.number()]), string: '["foo",1]', parsed: ["foo", 1] },
+  { schema: z.union([z.string(), z.number()]), string: "foo", parsed: "foo" },
+  { schema: z.union([z.string(), z.number()]), string: "1", parsed: 1 },
+  {
+    schema: z.union([z.string(), z.object({ foo: z.string() })]),
+    string: '{"foo":"bar"}',
+    parsed: { foo: "bar" },
+  },
+  {
+    schema: discriminatedUnion,
+    string: '{"type":"one","value":"foo"}',
+    parsed: { type: "one", value: "foo" },
+  },
+  {
+    schema: discriminatedUnion,
+    string: '{"type":"two","value":1}',
+    parsed: { type: "two", value: 1 },
+  },
+  {
+    schema: z.record(z.string(), z.object({ foo: z.string() })),
+    string: '{"one":{"foo":"bar"}}',
+    parsed: { one: { foo: "bar" } },
+  },
+  { schema: z.map(z.string(), z.number()), string: '[["one",1]]', parsed: new Map([["one", 1]]) },
+  { schema: z.set(z.number()), string: "[1,2,3]", parsed: new Set([1, 2, 3]) },
+])("given $schema, returns $parsed for $string", async ({ schema, string, parsed }) => {
+  await initZod();
 
-  if (typeof parsed === 'string' || typeof parsed === 'number' || typeof parsed === 'boolean' || typeof parsed === 'bigint') {
-    expect(safeGetParamValue(string, { param: schema })).toBe(parsed)
-    expect(safeSetParamValue(parsed, { param: schema })).toBe(string)
+  if (
+    typeof parsed === "string" ||
+    typeof parsed === "number" ||
+    typeof parsed === "boolean" ||
+    typeof parsed === "bigint"
+  ) {
+    expect(safeGetParamValue(string, { param: schema })).toBe(parsed);
+    expect(safeSetParamValue(parsed, { param: schema })).toBe(string);
   } else {
-    expect(safeGetParamValue(string, { param: schema })).toMatchObject(parsed)
-    expect(safeSetParamValue(parsed, { param: schema })).toBe(string)
+    expect(safeGetParamValue(string, { param: schema })).toMatchObject(parsed);
+    expect(safeSetParamValue(parsed, { param: schema })).toBe(string);
   }
-})
+});
 
 test.each([
-  { schema: z.intersection(z.object({ foo: z.string() }), z.object({ bar: z.number() })), type: 'Intersection' },
-  { schema: z.promise(z.string()), type: 'Promise' },
-])('$type schemas are not supported', async ({ schema }) => {
-  await initZod()
+  {
+    schema: z.intersection(z.object({ foo: z.string() }), z.object({ bar: z.number() })),
+    type: "Intersection",
+  },
+  { schema: z.promise(z.string()), type: "Promise" },
+])("$type schemas are not supported", async ({ schema }) => {
+  await initZod();
 
-  expect(safeGetParamValue('test', { param: schema })).toBeUndefined()
-  expect(safeSetParamValue('test', { param: schema })).toBeUndefined()
-})
+  expect(safeGetParamValue("test", { param: schema })).toBeUndefined();
+  expect(safeSetParamValue("test", { param: schema })).toBeUndefined();
+});
diff --git a/src/services/zod.ts b/src/services/zod.ts
index f15b19f1..15ae4e66 100644
--- a/src/services/zod.ts
+++ b/src/services/zod.ts
@@ -1,18 +1,18 @@
-import { Param, ParamGetSet } from '@/types/paramTypes'
-import { Routes } from '@/types/route'
-import { isUrl } from '@/types/url'
-import { isRecord } from '@/utilities/guards'
-import { StandardSchemaV1 } from '@standard-schema/spec'
-import { type ZodType } from 'zod'
+import { Param, ParamGetSet } from "@/types/paramTypes";
+import { Routes } from "@/types/route";
+import { isUrl } from "@/types/url";
+import { isRecord } from "@/utilities/guards";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import { type ZodType } from "zod";
 
 export interface ZodSchemaLike extends StandardSchemaV1<any> {
-  parse: (input: any) => any,
+  parse: (input: any) => any;
 }
 
-let zod: ZodSchemas | null = null
+let zod: ZodSchemas | null = null;
 
 // inferring the return type is preferred for this function
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+// oxlint-disable-next-line @typescript-eslint/explicit-function-return-type
 async function getZodInstances() {
   const {
     ZodType,
@@ -49,7 +49,7 @@ async function getZodInstances() {
     ZodSet,
     ZodIntersection,
     ZodPromise,
-  } = await import('zod')
+  } = await import("zod");
 
   return {
     ZodType,
@@ -86,128 +86,136 @@ async function getZodInstances() {
     ZodSet,
     ZodIntersection,
     ZodPromise,
-  }
+  };
 }
 
-type ZodSchemas = Awaited<ReturnType<typeof getZodInstances>>
+type ZodSchemas = Awaited<ReturnType<typeof getZodInstances>>;
 
 export function zodParamsDetected(routes: Routes): boolean {
   return Object.values(routes).some((route) => {
     if (!isUrl(route)) {
-      return false
+      return false;
     }
 
-    return Object.values(route.schema.host.params).some(({ param }) => isZodSchemaLike(param))
-      || Object.values(route.schema.path.params).some(({ param }) => isZodSchemaLike(param))
-      || Object.values(route.schema.query.params).some(({ param }) => isZodSchemaLike(param))
-  })
+    return (
+      Object.values(route.schema.host.params).some(({ param }) => isZodSchemaLike(param)) ||
+      Object.values(route.schema.path.params).some(({ param }) => isZodSchemaLike(param)) ||
+      Object.values(route.schema.query.params).some(({ param }) => isZodSchemaLike(param))
+    );
+  });
 }
 
 function isZodSchemaLike(param: Param): param is ZodSchemaLike {
-  return isRecord(param)
-    && 'parse' in param
-    && typeof param.parse === 'function'
-    && '~standard' in param
-    && isRecord(param['~standard'])
-    && 'vendor' in param['~standard']
-    && param['~standard'].vendor === 'zod'
+  return (
+    isRecord(param) &&
+    "parse" in param &&
+    typeof param.parse === "function" &&
+    "~standard" in param &&
+    isRecord(param["~standard"]) &&
+    "vendor" in param["~standard"] &&
+    param["~standard"].vendor === "zod"
+  );
 }
 
 export async function initZod(): Promise<void> {
   try {
-    zod = await getZodInstances()
+    zod = await getZodInstances();
   } catch {
-    throw new Error('Failed to initialize Zod')
+    throw new Error("Failed to initialize Zod");
   }
 }
 
 export function isZodParam(value: unknown): value is ZodType {
   if (!zod) {
-    return false
+    return false;
   }
 
-  return value instanceof zod.ZodType
+  return value instanceof zod.ZodType;
 }
 
 export function createZodParam<T>(schema: ZodType<T>): ParamGetSet<T> {
   return {
     get: (value, { invalid }) => {
       try {
-        return parseZodValue(value, schema) as T
+        return parseZodValue(value, schema) as T;
       } catch {
-        throw invalid()
+        throw invalid();
       }
     },
     set: (value, { invalid }) => {
       try {
-        return stringifyZodValue(value, schema)
+        return stringifyZodValue(value, schema);
       } catch {
-        throw invalid()
+        throw invalid();
       }
     },
-  }
+  };
 }
 
-const isoDateRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/
+const isoDateRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
 
 function reviver(_key: string, value: any): any {
-  if (typeof value === 'string' && isoDateRegex.test(value)) {
-    const date = new Date(value)
+  if (typeof value === "string" && isoDateRegex.test(value)) {
+    const date = new Date(value);
 
     if (isNaN(date.getTime())) {
-      return value
+      return value;
     }
 
-    return date
+    return date;
   }
 
-  return value
+  return value;
 }
 
 function tryAll<T>(fns: (() => T)[]): T {
   for (const fn of fns) {
     try {
-      return fn()
+      return fn();
     } catch {
-      continue
+      continue;
     }
   }
 
-  throw new Error('All functions failed')
+  throw new Error("All functions failed");
 }
 
 // Sorts string schemas last
 function sortZodSchemas(schemaA: ZodType, schemaB: ZodType): number {
-  return zod?.ZodString && schemaA instanceof zod.ZodString ? 1 : zod?.ZodString && schemaB instanceof zod.ZodString ? -1 : 0
+  return zod?.ZodString && schemaA instanceof zod.ZodString
+    ? 1
+    : zod?.ZodString && schemaB instanceof zod.ZodString
+      ? -1
+      : 0;
 }
 
 function parseZodValue(value: string, schema: ZodType): unknown {
   if (!zod) {
-    throw new Error('Zod is not initialized')
+    throw new Error("Zod is not initialized");
   }
 
   if (schema instanceof zod.ZodString) {
-    return schema.parse(value)
+    return schema.parse(value);
   }
 
   if (schema instanceof zod.ZodBoolean) {
-    return schema.parse(Boolean(value))
+    return schema.parse(Boolean(value));
   }
 
   if (schema instanceof zod.ZodDate) {
-    return schema.parse(new Date(value))
+    return schema.parse(new Date(value));
   }
 
   if (schema instanceof zod.ZodNumber) {
-    return schema.parse(Number(value))
+    return schema.parse(Number(value));
   }
 
   if (schema instanceof zod.ZodBigInt) {
-    return schema.parse(BigInt(value))
+    return schema.parse(BigInt(value));
   }
 
   if (schema instanceof zod.ZodNaN) {
-    return schema.parse(Number(value))
+    return schema.parse(Number(value));
   }
 
   if (schema instanceof zod.ZodLiteral) {
@@ -215,218 +223,214 @@ function parseZodValue(value: string, schema: ZodType): unknown {
       () => schema.parse(Number(value)),
       () => schema.parse(Boolean(value)),
       () => schema.parse(value),
-    ])
+    ]);
   }
 
   if (schema instanceof zod.ZodObject) {
-    return schema.parse(JSON.parse(value, reviver))
+    return schema.parse(JSON.parse(value, reviver));
   }
 
   if (schema instanceof zod.ZodEnum) {
-    return schema.parse(value)
+    return schema.parse(value);
   }
 
   if (schema instanceof zod.ZodArray) {
-    return schema.parse(JSON.parse(value, reviver))
+    return schema.parse(JSON.parse(value, reviver));
   }
 
   if (schema instanceof zod.ZodTuple) {
-    return schema.parse(JSON.parse(value, reviver))
+    return schema.parse(JSON.parse(value, reviver));
   }
 
   if (schema instanceof zod.ZodUnion) {
-    const schemas = Array
-      .from(schema.def.options as ZodType[])
+    const schemas = Array.from(schema.def.options as ZodType[])
       .sort(sortZodSchemas)
-      .map((schema: ZodType) => () => parseZodValue(value, schema))
+      .map((schema: ZodType) => () => parseZodValue(value, schema));
 
-    return tryAll(schemas)
+    return tryAll(schemas);
   }
 
   if (schema instanceof zod.ZodDiscriminatedUnion) {
-    const schemas = Array
-      .from(schema.options as ZodType[])
+    const schemas = Array.from(schema.options as ZodType[])
       .sort(sortZodSchemas)
-      .map((schema: ZodType) => () => parseZodValue(value, schema))
+      .map((schema: ZodType) => () => parseZodValue(value, schema));
 
-    return tryAll(schemas)
+    return tryAll(schemas);
   }
 
   if (schema instanceof zod.ZodRecord) {
-    return schema.parse(JSON.parse(value, reviver))
+    return schema.parse(JSON.parse(value, reviver));
   }
 
   if (schema instanceof zod.ZodMap) {
-    return schema.parse(new Map(JSON.parse(value, reviver)))
+    return schema.parse(new Map(JSON.parse(value, reviver)));
   }
 
   if (schema instanceof zod.ZodSet) {
-    return schema.parse(new Set(JSON.parse(value, reviver)))
+    return schema.parse(new Set(JSON.parse(value, reviver)));
   }
 
   if (schema instanceof zod.ZodIntersection) {
-    throw new Error('Intersection schemas are not supported')
+    throw new Error("Intersection schemas are not supported");
   }
 
   if (schema instanceof zod.ZodPromise) {
-    throw new Error('Promise schemas are not supported')
+    throw new Error("Promise schemas are not supported");
   }
 
-  return schema.parse(value)
+  return schema.parse(value);
 }
 
 function stringifyZodValue(value: unknown, schema: ZodType): string {
   if (!zod) {
-    throw new Error('Zod is not initialized')
+    throw new Error("Zod is not initialized");
   }
 
   if (schema instanceof zod.ZodString) {
-    return schema.parse(value)
+    return schema.parse(value);
   }
 
   if (schema instanceof zod.ZodISODateTime) {
-    return schema.parse(value)
+    return schema.parse(value);
   }
 
   if (schema instanceof zod.ZodISODate) {
-    return schema.parse(value)
+    return schema.parse(value);
   }
 
   if (schema instanceof zod.ZodISOTime) {
-    return schema.parse(value)
+    return schema.parse(value);
   }
 
   if (schema instanceof zod.ZodIPv4) {
-    return schema.parse(value)
+    return schema.parse(value);
   }
 
   if (schema instanceof zod.ZodIPv6) {
-    return schema.parse(value)
+    return schema.parse(value);
   }
 
   if (schema instanceof zod.ZodCIDRv4) {
-    return schema.parse(value)
+    return schema.parse(value);
   }
 
   if (schema instanceof zod.ZodCIDRv6) {
-    return schema.parse(value)
+    return schema.parse(value);
   }
 
   if (schema instanceof zod.ZodURL) {
-    return schema.parse(value)
+    return schema.parse(value);
   }
 
   if (schema instanceof zod.ZodEmail) {
-    return schema.parse(value)
+    return schema.parse(value);
   }
 
   if (schema instanceof zod.ZodUUID) {
-    return schema.parse(value)
+    return schema.parse(value);
   }
 
   if (schema instanceof zod.ZodBase64) {
-    return schema.parse(value)
+    return schema.parse(value);
   }
 
   if (schema instanceof zod.ZodCUID) {
-    return schema.parse(value)
+    return schema.parse(value);
   }
 
   if (schema instanceof zod.ZodCUID2) {
-    return schema.parse(value)
+    return schema.parse(value);
   }
 
   if (schema instanceof zod.ZodULID) {
-    return schema.parse(value)
+    return schema.parse(value);
   }
 
   if (schema instanceof zod.ZodJWT) {
-    return schema.parse(value)
+    return schema.parse(value);
   }
 
   if (schema instanceof zod.ZodBoolean) {
-    return schema.parse(value).toString()
+    return schema.parse(value).toString();
   }
 
   if (schema instanceof zod.ZodDate) {
-    return schema.parse(value).toISOString()
+    return schema.parse(value).toISOString();
   }
 
   if (schema instanceof zod.ZodNumber) {
-    return schema.parse(Number(value)).toString()
+    return schema.parse(Number(value)).toString();
   }
 
   if (schema instanceof zod.ZodBigInt) {
-    return schema.parse(BigInt(String(value))).toString()
+    return schema.parse(BigInt(String(value))).toString();
   }
 
   if (schema instanceof zod.ZodNaN) {
-    return schema.parse(value).toString()
+    return schema.parse(value).toString();
   }
 
   if (schema instanceof zod.ZodLiteral) {
-    const parsed = schema.parse(value)
-    return parsed != null ? parsed.toString() : String(parsed)
+    const parsed = schema.parse(value);
+    return parsed != null ? parsed.toString() : String(parsed);
   }
 
   if (schema instanceof zod.ZodObject) {
-    return JSON.stringify(schema.parse(value))
+    return JSON.stringify(schema.parse(value));
   }
 
   if (schema instanceof zod.ZodEnum) {
-    const parsed = schema.parse(value)
-    return typeof parsed === 'string' ? parsed : String(parsed)
+    const parsed = schema.parse(value);
+    return typeof parsed === "string" ? parsed : String(parsed);
   }
 
   if (schema instanceof zod.ZodArray) {
-    return JSON.stringify(schema.parse(value))
+    return JSON.stringify(schema.parse(value));
   }
 
   if (schema instanceof zod.ZodTuple) {
-    return JSON.stringify(schema.parse(value))
+    return JSON.stringify(schema.parse(value));
   }
 
   if (schema instanceof zod.ZodUnion) {
-    const schemas = Array
-      .from(schema.def.options as ZodType[])
+    const schemas = Array.from(schema.def.options as ZodType[])
       .sort(sortZodSchemas)
-      .map((schema: ZodType) => () => stringifyZodValue(value, schema))
+      .map((schema: ZodType) => () => stringifyZodValue(value, schema));
 
-    return tryAll(schemas)
+    return tryAll(schemas);
   }
 
   if (schema instanceof zod.ZodDiscriminatedUnion) {
-    const schemas = Array
-      .from(schema.options as ZodType[])
+    const schemas = Array.from(schema.options as ZodType[])
       .sort(sortZodSchemas)
-      .map((schema: ZodType) => () => stringifyZodValue(value, schema))
+      .map((schema: ZodType) => () => stringifyZodValue(value, schema));
 
-    return tryAll(schemas)
+    return tryAll(schemas);
   }
 
   if (schema instanceof zod.ZodRecord) {
-    return JSON.stringify(schema.parse(value))
+    return JSON.stringify(schema.parse(value));
   }
 
   if (schema instanceof zod.ZodMap) {
-    const parsed = schema.parse(value)
+    const parsed = schema.parse(value);
 
-    return JSON.stringify(Array.from(parsed.entries()))
+    return JSON.stringify(Array.from(parsed.entries()));
   }
 
   if (schema instanceof zod.ZodSet) {
-    const parsed = schema.parse(value)
+    const parsed = schema.parse(value);
 
-    return JSON.stringify(Array.from(parsed.values()))
+    return JSON.stringify(Array.from(parsed.values()));
   }
 
   if (schema instanceof zod.ZodIntersection) {
-    throw new Error('Intersection schemas are not supported')
+    throw new Error("Intersection schemas are not supported");
   }
 
   if (schema instanceof zod.ZodPromise) {
-    throw new Error('Promise schemas are not supported')
+    throw new Error("Promise schemas are not supported");
   }
 
-  return JSON.stringify(schema.parse(value))
+  return JSON.stringify(schema.parse(value));
 }
diff --git a/src/tests/hooks.spec.ts b/src/tests/hooks.spec.ts
index 8ca1c132..d4866cd7 100644
--- a/src/tests/hooks.spec.ts
+++ b/src/tests/hooks.spec.ts
@@ -1,59 +1,62 @@
-import echo from '@/components/echo'
-import { createRoute } from '@/services/createRoute'
-import { createRouter } from '@/services/createRouter'
-import { component } from '@/utilities'
-import { expect, test, vi } from 'vitest'
-import { createApp, inject } from 'vue'
-
-test('hooks are run with the correct context', async () => {
-  const beforeRouteHook = vi.fn()
-  const afterRouteHook = vi.fn()
-  const beforeGlobalHook = vi.fn()
-  const afterGlobalHook = vi.fn()
-
-  const route = createRoute({
-    path: '/',
-    name: 'route',
-    component: echo,
-  }, () => ({ value: 'hello' }))
+import echo from "@/components/echo";
+import { createRoute } from "@/services/createRoute";
+import { createRouter } from "@/services/createRouter";
+import { component } from "@/utilities";
+import { expect, test, vi } from "vite-plus/test";
+import { createApp, inject } from "vue";
+
+test("hooks are run with the correct context", async () => {
+  const beforeRouteHook = vi.fn();
+  const afterRouteHook = vi.fn();
+  const beforeGlobalHook = vi.fn();
+  const afterGlobalHook = vi.fn();
+
+  const route = createRoute(
+    {
+      path: "/",
+      name: "route",
+      component: echo,
+    },
+    () => ({ value: "hello" }),
+  );
 
   route.onBeforeRouteEnter(() => {
-    const value = inject('global')
+    const value = inject("global");
 
-    beforeRouteHook(value)
-  })
+    beforeRouteHook(value);
+  });
 
   route.onAfterRouteEnter(() => {
-    const value = inject('global')
+    const value = inject("global");
 
-    afterRouteHook(value)
-  })
+    afterRouteHook(value);
+  });
 
   const router = createRouter([route], {
-    initialUrl: '/',
-  })
+    initialUrl: "/",
+  });
 
   router.onBeforeRouteEnter(() => {
-    const value = inject('global')
+    const value = inject("global");
 
-    beforeGlobalHook(value)
-  })
+    beforeGlobalHook(value);
+  });
 
   router.onAfterRouteEnter(() => {
-    const value = inject('global')
+    const value = inject("global");
 
-    afterGlobalHook(value)
-  })
+    afterGlobalHook(value);
+  });
 
-  const app = createApp(component)
+  const app = createApp(component);
 
-  app.provide('global', 'hello world')
-  app.use(router)
+  app.provide("global", "hello world");
+  app.use(router);
 
-  await router.start()
+  await router.start();
 
-  expect(beforeRouteHook).toHaveBeenCalledWith('hello world')
-  expect(afterRouteHook).toHaveBeenCalledWith('hello world')
-  expect(beforeGlobalHook).toHaveBeenCalledWith('hello world')
-  expect(afterGlobalHook).toHaveBeenCalledWith('hello world')
-})
+  expect(beforeRouteHook).toHaveBeenCalledWith("hello world");
+  expect(afterRouteHook).toHaveBeenCalledWith("hello world");
+  expect(beforeGlobalHook).toHaveBeenCalledWith("hello world");
+  expect(afterGlobalHook).toHaveBeenCalledWith("hello world");
+});
diff --git a/src/tests/routeProps.browser.spec.ts b/src/tests/routeProps.browser.spec.ts
index 99a88db9..52590256 100644
--- a/src/tests/routeProps.browser.spec.ts
+++ b/src/tests/routeProps.browser.spec.ts
@@ -1,112 +1,118 @@
 /* eslint-disable vue/one-component-per-file */
-import { vi, test, expect } from 'vitest'
-import { createRoute } from '@/services/createRoute'
-import { createRouter } from '@/services/createRouter'
-import { defineComponent, h } from 'vue'
-import { mount } from '@vue/test-utils'
-import { component } from '@/utilities/testHelpers'
-import { RouterView } from '@/main'
-import echo from '@/components/echo'
-
-test('components are not remounted when props change', async () => {
-  const setupParent = vi.fn()
-  const setupChild = vi.fn()
-
-  const routeA = createRoute({
-    name: 'routeA',
-    path: '/routeA/[parentParam]',
-    component: defineComponent({
-      props: {
-        value: {
-          type: String,
-          required: true,
+import { vi, test, expect } from "vite-plus/test";
+import { createRoute } from "@/services/createRoute";
+import { createRouter } from "@/services/createRouter";
+import { defineComponent, h } from "vue";
+import { mount } from "@vue/test-utils";
+import { component } from "@/utilities/testHelpers";
+import { RouterView } from "@/main";
+import echo from "@/components/echo";
+
+test("components are not remounted when props change", async () => {
+  const setupParent = vi.fn();
+  const setupChild = vi.fn();
+
+  const routeA = createRoute(
+    {
+      name: "routeA",
+      path: "/routeA/[parentParam]",
+      component: defineComponent({
+        props: {
+          value: {
+            type: String,
+            required: true,
+          },
         },
-      },
-      setup: setupParent,
-      render(props: { value: string }) {
-        return h('div', {}, [h(echo, { value: props.value }), h(RouterView)])
-      },
-    }),
-  }, (route) => {
-    return {
-      value: route.params.parentParam,
-    }
-  })
-
-  const routeAChild = createRoute({
-    parent: routeA,
-    name: 'routeA.child',
-    path: '/childA/[childParam]',
-    component: defineComponent({
-      setup: setupChild,
-      render(props: { value: string }) {
-        return h(echo, { value: props.value })
-      },
-    }),
-  }, (route) => {
-    return {
-      value: route.params.childParam,
-    }
-  })
+        setup: setupParent,
+        render(props: { value: string }) {
+          return h("div", {}, [h(echo, { value: props.value }), h(RouterView)]);
+        },
+      }),
+    },
+    (route) => {
+      return {
+        value: route.params.parentParam,
+      };
+    },
+  );
+
+  const routeAChild = createRoute(
+    {
+      parent: routeA,
+      name: "routeA.child",
+      path: "/childA/[childParam]",
+      component: defineComponent({
+        setup: setupChild,
+        render(props: { value: string }) {
+          return h(echo, { value: props.value });
+        },
+      }),
+    },
+    (route) => {
+      return {
+        value: route.params.childParam,
+      };
+    },
+  );
 
   const routeB = createRoute({
-    name: 'routeB',
-    path: '/routeB',
+    name: "routeB",
+    path: "/routeB",
     component,
-  })
+  });
 
   const router = createRouter([routeA, routeAChild, routeB], {
-    initialUrl: '/routeA/bar',
-  })
+    initialUrl: "/routeA/bar",
+  });
 
   const root = {
-    template: '<RouterView />',
-  }
+    template: "<RouterView />",
+  };
 
   const wrapper = mount(root, {
     global: {
       plugins: [router],
     },
-  })
+  });
 
-  await router.start()
+  await router.start();
 
   // the initial render should call the parent setup function
-  expect(setupParent).toHaveBeenCalledTimes(1)
+  expect(setupParent).toHaveBeenCalledTimes(1);
 
   // validate that the initial route was rendered
-  expect(wrapper.text()).toBe('bar')
+  expect(wrapper.text()).toBe("bar");
 
   // updating the current route should not remount
-  await router.route.update({ parentParam: 'foo' })
+  await router.route.update({ parentParam: "foo" });
 
-  expect(setupParent).toHaveBeenCalledTimes(1)
+  expect(setupParent).toHaveBeenCalledTimes(1);
 
-  await router.route.update({ parentParam: 'bar' })
+  await router.route.update({ parentParam: "bar" });
 
   // navigating away and back should remount
-  await router.push('routeB')
-  await router.push('routeA', { parentParam: 'foo' })
+  await router.push("routeB");
+  await router.push("routeA", { parentParam: "foo" });
 
-  expect(setupParent).toHaveBeenCalledTimes(2)
+  expect(setupParent).toHaveBeenCalledTimes(2);
 
   // navigating to the same route with different props should not remount
-  await router.push('routeA', { parentParam: 'bar' })
+  await router.push("routeA", { parentParam: "bar" });
 
-  expect(setupParent).toHaveBeenCalledTimes(2)
+  expect(setupParent).toHaveBeenCalledTimes(2);
 
   // navigating to a child route should not remount
-  await router.push('routeA.child', { parentParam: 'foo', childParam: 'foo' })
+  await router.push("routeA.child", { parentParam: "foo", childParam: "foo" });
 
-  expect(setupParent).toHaveBeenCalledTimes(2)
-  expect(setupChild).toHaveBeenCalledTimes(1)
+  expect(setupParent).toHaveBeenCalledTimes(2);
+  expect(setupChild).toHaveBeenCalledTimes(1);
 
   // updating parent param should not remount parent or child
-  await router.route.update({ parentParam: 'bar' })
+  await router.route.update({ parentParam: "bar" });
 
-  expect(setupParent).toHaveBeenCalledTimes(2)
-  expect(setupChild).toHaveBeenCalledTimes(1)
+  expect(setupParent).toHaveBeenCalledTimes(2);
+  expect(setupChild).toHaveBeenCalledTimes(1);
 
   // validate that the components were rendered
-  expect(wrapper.text()).toBe('barfoo')
-})
+  expect(wrapper.text()).toBe("barfoo");
+});
diff --git a/src/tests/routeProps.spec.ts b/src/tests/routeProps.spec.ts
index d19c91b9..4d8ae104 100644
--- a/src/tests/routeProps.spec.ts
+++ b/src/tests/routeProps.spec.ts
@@ -1,60 +1,66 @@
-import { expect, test, vi } from 'vitest'
-import { createRoute } from '@/services/createRoute'
-import { createRouter } from '@/services/createRouter'
-import { createApp, inject } from 'vue'
-import { component } from '@/utilities/testHelpers'
-
-test('props are called each time the route is matched', async () => {
-  const props = vi.fn()
-
-  const route = createRoute({
-    name: 'test',
-    path: '/[param]',
-  }, props)
+import { expect, test, vi } from "vite-plus/test";
+import { createRoute } from "@/services/createRoute";
+import { createRouter } from "@/services/createRouter";
+import { createApp, inject } from "vue";
+import { component } from "@/utilities/testHelpers";
+
+test("props are called each time the route is matched", async () => {
+  const props = vi.fn();
+
+  const route = createRoute(
+    {
+      name: "test",
+      path: "/[param]",
+    },
+    props,
+  );
 
   const router = createRouter([route], {
-    initialUrl: '/',
-  })
+    initialUrl: "/",
+  });
 
-  await router.start()
+  await router.start();
 
-  await router.push('test', { param: 'foo' })
+  await router.push("test", { param: "foo" });
 
-  expect(props).toHaveBeenCalledTimes(1)
+  expect(props).toHaveBeenCalledTimes(1);
 
-  await router.push('test', { param: 'bar' })
+  await router.push("test", { param: "bar" });
 
-  expect(props).toHaveBeenCalledTimes(2)
+  expect(props).toHaveBeenCalledTimes(2);
 
-  await router.push('test', { param: 'foo' })
+  await router.push("test", { param: "foo" });
 
-  expect(props).toHaveBeenCalledTimes(3)
-})
+  expect(props).toHaveBeenCalledTimes(3);
+});
 
-test('props are called with the correct context', async () => {
-  const props = vi.fn()
+test("props are called with the correct context", async () => {
+  const props = vi.fn();
 
-  const route = createRoute({
-    name: 'route',
-    path: '/',
-  }, () => {
-    const value = inject('global')
+  const route = createRoute(
+    {
+      name: "route",
+      path: "/",
+    },
+    () => {
+      const value = inject("global");
 
-    props(value)
+      props(value);
 
-    return {}
-  })
+      return {};
+    },
+  );
 
   const router = createRouter([route], {
-    initialUrl: '/',
-  })
+    initialUrl: "/",
+  });
 
-  const app = createApp(component)
+  const app = createApp(component);
 
-  app.provide('global', 'hello world')
-  app.use(router)
+  app.provide("global", "hello world");
+  app.use(router);
 
-  await router.start()
+  await router.start();
 
-  expect(props).toHaveBeenCalledWith('hello world')
-})
+  expect(props).toHaveBeenCalledWith("hello world");
+});
diff --git a/src/types/redirects.spec-d.ts b/src/types/redirects.spec-d.ts
index 617d03d6..24e80d03 100644
--- a/src/types/redirects.spec-d.ts
+++ b/src/types/redirects.spec-d.ts
@@ -1,80 +1,80 @@
-import { createRoute } from '@/services/createRoute'
-import { describe, expectTypeOf, test } from 'vitest'
+import { createRoute } from "@/services/createRoute";
+import { describe, expectTypeOf, test } from "vite-plus/test";
 
 const toWithoutParams = createRoute({
-  name: 'to',
-  path: '/to',
-})
+  name: "to",
+  path: "/to",
+});
 
 const fromWithoutParams = createRoute({
-  name: 'from',
-  path: '/from',
-})
+  name: "from",
+  path: "/from",
+});
 
 const toWithParams = createRoute({
-  name: 'to',
-  path: '/to/[toPathParam]',
-  query: 'to=[toQueryParam]',
-})
+  name: "to",
+  path: "/to/[toPathParam]",
+  query: "to=[toQueryParam]",
+});
 
 const fromWithParams = createRoute({
-  name: 'from',
-  path: '/from/[fromPathParam]',
-  query: 'from=[fromQueryParam]',
-})
+  name: "from",
+  path: "/from/[fromPathParam]",
+  query: "from=[fromQueryParam]",
+});
 
-describe('redirectTo', () => {
-  test('no params are correctly typed', () => {
-    fromWithoutParams.redirectTo(toWithoutParams)
-  })
+describe("redirectTo", () => {
+  test("no params are correctly typed", () => {
+    fromWithoutParams.redirectTo(toWithoutParams);
+  });
 
-  test('callback params are correctly typed', () => {
+  test("callback params are correctly typed", () => {
     fromWithParams.redirectTo(toWithParams, (params) => {
-      expectTypeOf(params).toEqualTypeOf<{ fromPathParam: string, fromQueryParam: string }>()
+      expectTypeOf(params).toEqualTypeOf<{ fromPathParam: string; fromQueryParam: string }>();
 
-      return { toPathParam: 'string', toQueryParam: 'string' }
-    })
-  })
+      return { toPathParam: "string", toQueryParam: "string" };
+    });
+  });
 
-  test('does not accept missing params', () => {
+  test("does not accept missing params", () => {
     // @ts-expect-error - missing params
     fromWithParams.redirectTo(toWithParams, () => {
-      return { toQueryParam: 'string' }
-    })
-  })
+      return { toQueryParam: "string" };
+    });
+  });
 
-  test('does not accept invalid to params', () => {
+  test("does not accept invalid to params", () => {
     // @ts-expect-error - invalid params
     fromWithParams.redirectTo(toWithParams, () => {
-      return { toPathParam: true, toQueryParam: 'string' }
-    })
-  })
-})
+      return { toPathParam: true, toQueryParam: "string" };
+    });
+  });
+});
 
-describe('redirectFrom', () => {
-  test('no params are correctly typed', () => {
-    toWithoutParams.redirectFrom(fromWithoutParams)
-  })
+describe("redirectFrom", () => {
+  test("no params are correctly typed", () => {
+    toWithoutParams.redirectFrom(fromWithoutParams);
+  });
 
-  test('callback params are correctly typed', () => {
+  test("callback params are correctly typed", () => {
     toWithParams.redirectFrom(fromWithParams, (params) => {
-      expectTypeOf(params).toEqualTypeOf<{ fromPathParam: string, fromQueryParam: string }>()
+      expectTypeOf(params).toEqualTypeOf<{ fromPathParam: string; fromQueryParam: string }>();
 
-      return { toPathParam: 'string', toQueryParam: 'string' }
-    })
-  })
+      return { toPathParam: "string", toQueryParam: "string" };
+    });
+  });
 
-  test('does not accept missing params', () => {
+  test("does not accept missing params", () => {
     // @ts-expect-error - missing params
     toWithParams.redirectFrom(fromWithParams, () => {
-      return { toQueryParam: 'string' }
-    })
-  })
+      return { toQueryParam: "string" };
+    });
+  });
 
-  test('does not accept invalid to params', () => {
+  test("does not accept invalid to params", () => {
     // @ts-expect-error - invalid params
     toWithParams.redirectFrom(fromWithParams, () => {
-      return { toPathParam: true, toQueryParam: 'string' }
-    })
-  })
-})
+      return { toPathParam: true, toQueryParam: "string" };
+    });
+  });
+});
diff --git a/src/types/register.spec.ts b/src/types/register.spec.ts
index 384e3396..6a479bbc 100644
--- a/src/types/register.spec.ts
+++ b/src/types/register.spec.ts
@@ -1,8 +1,8 @@
-import { expectTypeOf, test } from 'vitest'
-import { RouteMeta } from './register'
+import { expectTypeOf, test } from "vite-plus/test";
+import { RouteMeta } from "./register";
 
-test('given route meta in router options, RouteMeta is correct', () => {
-  type Meta = RouteMeta<{ routeMeta: { zoo: number } }>
+test("given route meta in router options, RouteMeta is correct", () => {
+  type Meta = RouteMeta<{ routeMeta: { zoo: number } }>;
 
-  expectTypeOf<Meta>().toEqualTypeOf<{ zoo: number }>()
-})
+  expectTypeOf<Meta>().toEqualTypeOf<{ zoo: number }>();
+});
diff --git a/src/types/resolved.spec-d.ts b/src/types/resolved.spec-d.ts
index 0ecb6439..35c8a0b8 100644
--- a/src/types/resolved.spec-d.ts
+++ b/src/types/resolved.spec-d.ts
@@ -1,27 +1,27 @@
-import { expectTypeOf, test } from 'vitest'
-import { RouterRoute } from '@/types/routerRoute'
-import { ResolvedRoute } from '@/types/resolved'
-import { withParams } from '@/services/withParams'
-import { createRoute } from '@/services/createRoute'
+import { expectTypeOf, test } from "vite-plus/test";
+import { RouterRoute } from "@/types/routerRoute";
+import { ResolvedRoute } from "@/types/resolved";
+import { withParams } from "@/services/withParams";
+import { createRoute } from "@/services/createRoute";
 
-test('given a specific Route, params are narrow', () => {
+test("given a specific Route, params are narrow", () => {
   const testRoute = createRoute({
-    name: 'parentA',
-    path: '/parentA/[paramA]',
-    query: withParams('foo=[paramB]&bar=[?paramC]', { paramB: Boolean }),
-  })
+    name: "parentA",
+    path: "/parentA/[paramA]",
+    query: withParams("foo=[paramB]&bar=[?paramC]", { paramB: Boolean }),
+  });
 
-    type TestRoute = typeof testRoute
+  type TestRoute = typeof testRoute;
 
-    type Source = RouterRoute<ResolvedRoute<TestRoute>>['params']
-    type Expect = { paramA: string, paramB: boolean, paramC?: string | undefined }
+  type Source = RouterRoute<ResolvedRoute<TestRoute>>["params"];
+  type Expect = { paramA: string; paramB: boolean; paramC?: string | undefined };
 
-    expectTypeOf<Expect>().toEqualTypeOf<Source>()
-})
+  expectTypeOf<Expect>().toEqualTypeOf<Source>();
+});
 
-test('without a specific Route, params are Record<string, unknown>', () => {
-  type Source = RouterRoute['params']
-  type Expect = Record<string, unknown>
+test("without a specific Route, params are Record<string, unknown>", () => {
+  type Source = RouterRoute["params"];
+  type Expect = Record<string, unknown>;
 
-  expectTypeOf<Expect>().toEqualTypeOf<Source>()
-})
+  expectTypeOf<Expect>().toEqualTypeOf<Source>();
+});
diff --git a/src/types/route.spec-d.ts b/src/types/route.spec-d.ts
index c040dc19..7773c372 100644
--- a/src/types/route.spec-d.ts
+++ b/src/types/route.spec-d.ts
@@ -1,48 +1,57 @@
-import { describe, expectTypeOf, test } from 'vitest'
-import { withParams } from '@/services/withParams'
-import { withDefault } from '@/services/withDefault'
-import { createRoute } from '@/services/createRoute'
-import { createExternalRoute } from '@/services/createExternalRoute'
-import { UrlParamsReading, UrlParamsWriting } from '@/types/url'
+import { describe, expectTypeOf, test } from "vite-plus/test";
+import { withParams } from "@/services/withParams";
+import { withDefault } from "@/services/withDefault";
+import { createRoute } from "@/services/createRoute";
+import { createExternalRoute } from "@/services/createExternalRoute";
+import { UrlParamsReading, UrlParamsWriting } from "@/types/url";
 
-describe('ExtractRouteParamTypes', () => {
-  test('when reading/writing params, given routes with different params, some optional, no defaults, combines into expected args', () => {
+describe("ExtractRouteParamTypes", () => {
+  test("when reading/writing params, given routes with different params, some optional, no defaults, combines into expected args", () => {
     const testRoute = createExternalRoute({
-      name: 'parentA',
-      host: 'https://[inHost].dev',
-      path: '/[inPath]',
-      query: withParams('foo=[inQuery]&bar=[?paramC]', {
+      name: "parentA",
+      host: "https://[inHost].dev",
+      path: "/[inPath]",
+      query: withParams("foo=[inQuery]&bar=[?paramC]", {
         inQuery: Boolean,
       }),
-      hash: '[inHash]',
-    })
+      hash: "[inHash]",
+    });
 
-    type TestRoute = typeof testRoute
+    type TestRoute = typeof testRoute;
 
-    type SourceWriting = UrlParamsWriting<TestRoute>
-    type SourceReading = UrlParamsReading<TestRoute>
-    type Expect = { inHost: string, inPath: string, paramC?: string, inQuery: boolean, inHash: string }
+    type SourceWriting = UrlParamsWriting<TestRoute>;
+    type SourceReading = UrlParamsReading<TestRoute>;
+    type Expect = {
+      inHost: string;
+      inPath: string;
+      paramC?: string;
+      inQuery: boolean;
+      inHash: string;
+    };
 
-    expectTypeOf<SourceWriting>().toEqualTypeOf<Expect>()
-    expectTypeOf<SourceReading>().toEqualTypeOf<Expect>()
-  })
+    expectTypeOf<SourceWriting>().toEqualTypeOf<Expect>();
+    expectTypeOf<SourceReading>().toEqualTypeOf<Expect>();
+  });
 
-  test('when optional params have defaults, Reading and Writing change', () => {
+  test("when optional params have defaults, Reading and Writing change", () => {
     const testRoute = createRoute({
-      name: 'parentA',
-      host: 'https://kitbag.dev',
-      path: '/',
-      query: withParams('foo=[required]&bar=[?optional]', {
+      name: "parentA",
+      host: "https://kitbag.dev",
+      path: "/",
+      query: withParams("foo=[required]&bar=[?optional]", {
         required: Boolean,
-        optional: withDefault(String, 'ABC'),
+        optional: withDefault(String, "ABC"),
       }),
-    })
-    type TestRoute = typeof testRoute
+    });
+    type TestRoute = typeof testRoute;
 
-    type SourceWriting = UrlParamsWriting<TestRoute>
-    type SourceReading = UrlParamsReading<TestRoute>
+    type SourceWriting = UrlParamsWriting<TestRoute>;
+    type SourceReading = UrlParamsReading<TestRoute>;
 
-    expectTypeOf<SourceWriting>().toEqualTypeOf<{ required: boolean, optional?: string | undefined }>()
-    expectTypeOf<SourceReading>().toEqualTypeOf<{ required: boolean, optional: string }>()
-  })
-})
+    expectTypeOf<SourceWriting>().toEqualTypeOf<{
+      required: boolean;
+      optional?: string | undefined;
+    }>();
+    expectTypeOf<SourceReading>().toEqualTypeOf<{ required: boolean; optional: string }>();
+  });
+});
diff --git a/src/types/routeTitle.browser.spec.ts b/src/types/routeTitle.browser.spec.ts
index 9213a430..397b6768 100644
--- a/src/types/routeTitle.browser.spec.ts
+++ b/src/types/routeTitle.browser.spec.ts
@@ -1,169 +1,169 @@
-import { expect, test, vi } from 'vitest'
-import { createRoute } from '@/services/createRoute'
-import { component } from '@/utilities/testHelpers'
-import { createRouter } from '@/services/createRouter'
-import { flushPromises } from '@vue/test-utils'
+import { expect, test, vi } from "vite-plus/test";
+import { createRoute } from "@/services/createRoute";
+import { component } from "@/utilities/testHelpers";
+import { createRouter } from "@/services/createRouter";
+import { flushPromises } from "@vue/test-utils";
 
-test('route with title updates document title', async () => {
+test("route with title updates document title", async () => {
   const route = createRoute({
-    name: 'root',
-    path: '/',
+    name: "root",
+    path: "/",
     component,
-  })
+  });
 
-  const title = 'foo'
-  const callback = vi.fn(() => title)
+  const title = "foo";
+  const callback = vi.fn(() => title);
 
-  route.setTitle(callback)
+  route.setTitle(callback);
 
   const router = createRouter([route], {
-    initialUrl: '/',
-  })
+    initialUrl: "/",
+  });
 
-  await router.start()
+  await router.start();
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(callback).toHaveBeenCalledTimes(1)
-  expect(document.title).toBe(title)
-})
+  expect(callback).toHaveBeenCalledTimes(1);
+  expect(document.title).toBe(title);
+});
 
-test('route with title and parent with title does not call parent getTitle', async () => {
+test("route with title and parent with title does not call parent getTitle", async () => {
   const parent = createRoute({
-    name: 'parent',
-    path: '/parent',
+    name: "parent",
+    path: "/parent",
     component,
-  })
-  const parentGetTitle = vi.fn(() => 'parent')
-  parent.setTitle(parentGetTitle)
+  });
+  const parentGetTitle = vi.fn(() => "parent");
+  parent.setTitle(parentGetTitle);
 
   const child = createRoute({
-    name: 'child',
-    path: '/child',
+    name: "child",
+    path: "/child",
     component,
     parent,
-  })
+  });
 
-  const childGetTitle = vi.fn(() => 'child')
-  child.setTitle(childGetTitle)
+  const childGetTitle = vi.fn(() => "child");
+  child.setTitle(childGetTitle);
 
   const router = createRouter([parent, child], {
-    initialUrl: '/parent/child',
-  })
+    initialUrl: "/parent/child",
+  });
 
-  await router.start()
+  await router.start();
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(parentGetTitle).not.toHaveBeenCalled()
-  expect(childGetTitle).toHaveBeenCalledTimes(1)
-  expect(document.title).toBe('child')
-})
+  expect(parentGetTitle).not.toHaveBeenCalled();
+  expect(childGetTitle).toHaveBeenCalledTimes(1);
+  expect(document.title).toBe("child");
+});
 
-test('route with title and parent with title does call parent getTitle when called directly', async () => {
+test("route with title and parent with title does call parent getTitle when called directly", async () => {
   const parent = createRoute({
-    name: 'parent',
-    path: '/parent',
+    name: "parent",
+    path: "/parent",
     component,
-  })
+  });
 
-  const parentGetTitle = vi.fn(() => 'parent')
-  parent.setTitle(parentGetTitle)
+  const parentGetTitle = vi.fn(() => "parent");
+  parent.setTitle(parentGetTitle);
 
   const child = createRoute({
-    name: 'child',
-    path: '/child',
+    name: "child",
+    path: "/child",
     component,
     parent,
-  })
+  });
 
   const childGetTitle = vi.fn(async (_to, { getParentTitle }) => {
-    const parentTitle = await getParentTitle()
-    return `${parentTitle} - child`
-  })
+    const parentTitle = await getParentTitle();
+    return `${parentTitle} - child`;
+  });
 
-  child.setTitle(childGetTitle)
+  child.setTitle(childGetTitle);
 
   const router = createRouter([parent, child], {
-    initialUrl: '/parent/child',
-  })
+    initialUrl: "/parent/child",
+  });
 
-  await router.start()
+  await router.start();
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(parentGetTitle).toHaveBeenCalledTimes(1)
-  expect(childGetTitle).toHaveBeenCalledTimes(1)
-  expect(document.title).toBe('parent - child')
-})
+  expect(parentGetTitle).toHaveBeenCalledTimes(1);
+  expect(childGetTitle).toHaveBeenCalledTimes(1);
+  expect(document.title).toBe("parent - child");
+});
 
-test('route with title and parent with title does call parent getTitle when called directly', async () => {
+test("route with title and parent with title does call parent getTitle when called directly", async () => {
   const parent = createRoute({
-    name: 'parent',
-    path: '/parent',
+    name: "parent",
+    path: "/parent",
     component,
-  })
+  });
 
-  const parentGetTitle = vi.fn(() => 'parent')
-  parent.setTitle(parentGetTitle)
+  const parentGetTitle = vi.fn(() => "parent");
+  parent.setTitle(parentGetTitle);
 
   const child = createRoute({
-    name: 'child',
-    path: '/child',
+    name: "child",
+    path: "/child",
     component,
     parent,
-  })
+  });
 
   const grandchild = createRoute({
-    name: 'grandchild',
-    path: '/grandchild',
+    name: "grandchild",
+    path: "/grandchild",
     component,
     parent: child,
-  })
+  });
 
   const grandchildGetTitle = vi.fn(async (_to, { getParentTitle }) => {
-    const parentTitle = await getParentTitle()
-    return `${parentTitle} - grandchild`
-  })
+    const parentTitle = await getParentTitle();
+    return `${parentTitle} - grandchild`;
+  });
 
-  grandchild.setTitle(grandchildGetTitle)
+  grandchild.setTitle(grandchildGetTitle);
 
   const router = createRouter([parent, child, grandchild], {
-    initialUrl: '/parent/child/grandchild',
-  })
+    initialUrl: "/parent/child/grandchild",
+  });
 
-  await router.start()
+  await router.start();
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(parentGetTitle).toHaveBeenCalledTimes(1)
-  expect(grandchildGetTitle).toHaveBeenCalledTimes(1)
-  expect(document.title).toBe('parent - grandchild')
-})
+  expect(parentGetTitle).toHaveBeenCalledTimes(1);
+  expect(grandchildGetTitle).toHaveBeenCalledTimes(1);
+  expect(document.title).toBe("parent - grandchild");
+});
 
-test('route without title and parent with title updates document title', async () => {
+test("route without title and parent with title updates document title", async () => {
   const parent = createRoute({
-    name: 'parent',
-    path: '/parent',
+    name: "parent",
+    path: "/parent",
     component,
-  })
+  });
 
-  parent.setTitle(() => 'parent')
+  parent.setTitle(() => "parent");
 
   const child = createRoute({
-    name: 'child',
-    path: '/child',
+    name: "child",
+    path: "/child",
     component,
     parent,
-  })
+  });
 
   const router = createRouter([parent, child], {
-    initialUrl: '/parent/child',
-  })
+    initialUrl: "/parent/child",
+  });
 
-  await router.start()
+  await router.start();
 
-  await flushPromises()
+  await flushPromises();
 
-  expect(document.title).toBe('parent')
-})
+  expect(document.title).toBe("parent");
+});
diff --git a/src/types/routeWithParams.spec-d.ts b/src/types/routeWithParams.spec-d.ts
index d6f3a989..d6e474d1 100644
--- a/src/types/routeWithParams.spec-d.ts
+++ b/src/types/routeWithParams.spec-d.ts
@@ -1,22 +1,22 @@
-import { expectTypeOf, test } from 'vitest'
-import { RouteGetByKey } from '@/types/routeWithParams'
-import { createRoute } from '@/services/createRoute'
+import { expectTypeOf, test } from "vite-plus/test";
+import { RouteGetByKey } from "@/types/routeWithParams";
+import { createRoute } from "@/services/createRoute";
 
-test('RouteGetByName works as expected', () => {
+test("RouteGetByName works as expected", () => {
   const parentA = createRoute({
-    name: 'parentA',
-    path: '/parentA/[paramA]',
-  })
+    name: "parentA",
+    path: "/parentA/[paramA]",
+  });
 
   const childA = createRoute({
     parent: parentA,
-    name: 'parentA.childA',
-    path: '/childA/[?paramB]',
-  })
+    name: "parentA.childA",
+    path: "/childA/[?paramB]",
+  });
 
-  type Routes = [typeof parentA, typeof childA]
-  type Source = RouteGetByKey<Routes, 'parentA.childA'>
-  type Expect = typeof childA
+  type Routes = [typeof parentA, typeof childA];
+  type Source = RouteGetByKey<Routes, "parentA.childA">;
+  type Expect = typeof childA;
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-})
+  expectTypeOf<Source>().toEqualTypeOf<Expect>();
+});
diff --git a/src/types/routesMap.spec-ts.ts b/src/types/routesMap.spec-ts.ts
index 84ec6637..c1fe6a69 100644
--- a/src/types/routesMap.spec-ts.ts
+++ b/src/types/routesMap.spec-ts.ts
@@ -1,53 +1,47 @@
-import { expectTypeOf, test } from 'vitest'
-import { createRoute } from '@/services/createRoute'
-import { Route } from '@/types/route'
-import { RoutesMap } from '@/types/routesMap'
-import { component } from '@/utilities/testHelpers'
+import { expectTypeOf, test } from "vite-plus/test";
+import { createRoute } from "@/services/createRoute";
+import { Route } from "@/types/route";
+import { RoutesMap } from "@/types/routesMap";
+import { component } from "@/utilities/testHelpers";
 
-test('RoutesMap given generic routes, returns generic string', () => {
-  type Map = RoutesMap<Route[]>
+test("RoutesMap given generic routes, returns generic string", () => {
+  type Map = RoutesMap<Route[]>;
 
-  type Source = Map[keyof Map]['name']
-  type Expect = string
+  type Source = Map[keyof Map]["name"];
+  type Expect = string;
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-})
+  expectTypeOf<Source>().toEqualTypeOf<Expect>();
+});
 
-test('RoutesMap given unnamed parents, removes them from return value and children names', () => {
+test("RoutesMap given unnamed parents, removes them from return value and children names", () => {
   const root = createRoute({
-    path: '/',
-  })
+    path: "/",
+  });
 
   const foo = createRoute({
     parent: root,
-    name: 'foo',
-    path: '/foo',
+    name: "foo",
+    path: "/foo",
     component,
-  })
+  });
 
-  const zooFoo = createRoute({ name: 'zoofoo', path: '/zoofoo', component, parent: foo })
+  const zooFoo = createRoute({ name: "zoofoo", path: "/zoofoo", component, parent: foo });
 
   const bar = createRoute({
     parent: root,
-    path: '/bar',
+    path: "/bar",
     component,
-  })
+  });
 
-  const zooBar = createRoute({ name: 'zoo', path: '/zoo', component, parent: bar })
+  const zooBar = createRoute({ name: "zoo", path: "/zoo", component, parent: bar });
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  const routes = [
-    root,
-    foo,
-    zooFoo,
-    bar,
-    zooBar,
-  ]
+  // oxlint-disable-next-line @typescript-eslint/no-unused-vars
+  const routes = [root, foo, zooFoo, bar, zooBar];
 
-  type Map = RoutesMap<typeof routes>
+  type Map = RoutesMap<typeof routes>;
 
-  type Source = keyof Map
-  type Expect = 'foo' | 'zoofoo' | 'zoo'
+  type Source = keyof Map;
+  type Expect = "foo" | "zoofoo" | "zoo";
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-})
+  expectTypeOf<Source>().toEqualTypeOf<Expect>();
+});
diff --git a/src/utilities/checkDuplicateNames.spec.ts b/src/utilities/checkDuplicateNames.spec.ts
index b6c79e3a..6a6a0874 100644
--- a/src/utilities/checkDuplicateNames.spec.ts
+++ b/src/utilities/checkDuplicateNames.spec.ts
@@ -1,51 +1,51 @@
-import { expect, test } from 'vitest'
-import { DuplicateNamesError } from '@/errors/duplicateNamesError'
-import { checkDuplicateNames } from '@/utilities/checkDuplicateNames'
-import { createRoute } from '@/services/createRoute'
+import { expect, test } from "vite-plus/test";
+import { DuplicateNamesError } from "@/errors/duplicateNamesError";
+import { checkDuplicateNames } from "@/utilities/checkDuplicateNames";
+import { createRoute } from "@/services/createRoute";
 
-test('given routes with all unique names, does nothing', () => {
+test("given routes with all unique names, does nothing", () => {
   const routes = [
-    createRoute({ name: 'foo' }),
-    createRoute({ name: 'bar' }),
-    createRoute({ name: 'zoo' }),
-  ]
+    createRoute({ name: "foo" }),
+    createRoute({ name: "bar" }),
+    createRoute({ name: "zoo" }),
+  ];
 
   const action: () => void = () => {
-    checkDuplicateNames(routes)
-  }
+    checkDuplicateNames(routes);
+  };
 
-  expect(action).not.toThrow()
-})
+  expect(action).not.toThrow();
+});
 
-test('given routes with duplicate names but same id, does nothing', () => {
-  const duplicate = createRoute({ name: 'duplicate' })
+test("given routes with duplicate names but same id, does nothing", () => {
+  const duplicate = createRoute({ name: "duplicate" });
 
   const routes = [
-    createRoute({ name: 'foo' }),
+    createRoute({ name: "foo" }),
     duplicate,
-    createRoute({ name: 'bar' }),
+    createRoute({ name: "bar" }),
     duplicate,
-    createRoute({ name: 'zoo' }),
-  ]
+    createRoute({ name: "zoo" }),
+  ];
 
   const action: () => void = () => {
-    checkDuplicateNames(routes)
-  }
+    checkDuplicateNames(routes);
+  };
 
-  expect(action).not.toThrow()
-})
+  expect(action).not.toThrow();
+});
 
-test('given routes with duplicate , throws DuplicateNamesError', () => {
+test("given routes with duplicate , throws DuplicateNamesError", () => {
   const routes = [
-    createRoute({ name: 'foo' }),
-    createRoute({ name: 'bar' }),
-    createRoute({ name: 'zoo' }),
-    createRoute({ name: 'bar' }),
-    createRoute({ name: 'foo' }),
-  ]
+    createRoute({ name: "foo" }),
+    createRoute({ name: "bar" }),
+    createRoute({ name: "zoo" }),
+    createRoute({ name: "bar" }),
+    createRoute({ name: "foo" }),
+  ];
   const action: () => void = () => {
-    checkDuplicateNames(routes)
-  }
+    checkDuplicateNames(routes);
+  };
 
-  expect(action).toThrow(DuplicateNamesError)
-})
+  expect(action).toThrow(DuplicateNamesError);
+});
diff --git a/src/utilities/checkDuplicateParams.spec.ts b/src/utilities/checkDuplicateParams.spec.ts
index 5b83b383..63be1101 100644
--- a/src/utilities/checkDuplicateParams.spec.ts
+++ b/src/utilities/checkDuplicateParams.spec.ts
@@ -1,65 +1,71 @@
-import { expect, test } from 'vitest'
-import { DuplicateParamsError } from '@/errors/duplicateParamsError'
-import { checkDuplicateParams } from '@/utilities/checkDuplicateParams'
+import { expect, test } from "vite-plus/test";
+import { DuplicateParamsError } from "@/errors/duplicateParamsError";
+import { checkDuplicateParams } from "@/utilities/checkDuplicateParams";
 
-test('given a single array without duplicates, does nothing', () => {
-  const input = ['foo', 'bar', 'zoo']
+test("given a single array without duplicates, does nothing", () => {
+  const input = ["foo", "bar", "zoo"];
 
   const action: () => void = () => {
-    checkDuplicateParams(input)
-  }
+    checkDuplicateParams(input);
+  };
 
-  expect(action).not.toThrow()
-})
+  expect(action).not.toThrow();
+});
 
 test.each([
-  [['foo', 'bar', 'zoo', 'bar']],
-  [['foo', 'bar', 'zoo'], ['jar', 'zoo']],
-  [['foo', 'bar', 'zoo'], ['jar'], ['zoo']],
-])('given a multiple arrays with duplicates, throws DuplicateParamsError', (...arrays) => {
+  [["foo", "bar", "zoo", "bar"]],
+  [
+    ["foo", "bar", "zoo"],
+    ["jar", "zoo"],
+  ],
+  [["foo", "bar", "zoo"], ["jar"], ["zoo"]],
+])("given a multiple arrays with duplicates, throws DuplicateParamsError", (...arrays) => {
   const action: () => void = () => {
-    checkDuplicateParams(...arrays)
-  }
+    checkDuplicateParams(...arrays);
+  };
 
-  expect(action).toThrow(DuplicateParamsError)
-})
+  expect(action).toThrow(DuplicateParamsError);
+});
 
 test.each([
-  [['foo', 'bar', 'zoo']],
-  [['foo', 'bar', 'zoo'], ['jar']],
-  [['foo', 'bar'], ['jar'], ['zoo']],
-])('given a multiple arrays without duplicates, does nothing', () => {
-  const aArray = ['foo', 'bar', 'zoo']
-  const bArray = ['jar']
+  [["foo", "bar", "zoo"]],
+  [["foo", "bar", "zoo"], ["jar"]],
+  [["foo", "bar"], ["jar"], ["zoo"]],
+])("given a multiple arrays without duplicates, does nothing", () => {
+  const aArray = ["foo", "bar", "zoo"];
+  const bArray = ["jar"];
 
   const action: () => void = () => {
-    checkDuplicateParams(aArray, bArray)
-  }
+    checkDuplicateParams(aArray, bArray);
+  };
 
-  expect(action).not.toThrow()
-})
+  expect(action).not.toThrow();
+});
 
 test.each([
-  [{ foo: 'foo', var: 'bar', zoo: 'zoo' }, { jar: 'jar', zoo: 'zoo' }],
-  [{ foo: 'foo', var: 'bar', zoo: 'zoo' }, { jar: 'jar' }, { zoo: 'zoo' }],
-])('given multiple records with duplicates keys, throws DuplicateParamsError', (...records) => {
+  [
+    { foo: "foo", var: "bar", zoo: "zoo" },
+    { jar: "jar", zoo: "zoo" },
+  ],
+  [{ foo: "foo", var: "bar", zoo: "zoo" }, { jar: "jar" }, { zoo: "zoo" }],
+])("given multiple records with duplicates keys, throws DuplicateParamsError", (...records) => {
   const action: () => void = () => {
-    checkDuplicateParams(...records)
-  }
+    checkDuplicateParams(...records);
+  };
 
-  expect(action).toThrow(DuplicateParamsError)
-})
+  expect(action).toThrow(DuplicateParamsError);
+});
 
 test.each([
-  [{ foo: 'foo', var: 'bar', zoo: 'zoo' }, { jar: 'jar' }],
-  [{ foo: 'foo', var: 'bar' }, { jar: 'jar' }, { zoo: 'zoo' }],
-])('given multiple records without duplicates keys, does nothing', () => {
-  const aRecord = { foo: 'foo', var: 'bar' }
-  const bRecord = { jar: 'jar', zoo: 'zoo' }
+  [{ foo: "foo", var: "bar", zoo: "zoo" }, { jar: "jar" }],
+  [{ foo: "foo", var: "bar" }, { jar: "jar" }, { zoo: "zoo" }],
+])("given multiple records without duplicates keys, does nothing", () => {
+  const aRecord = { foo: "foo", var: "bar" };
+  const bRecord = { jar: "jar", zoo: "zoo" };
 
   const action: () => void = () => {
-    checkDuplicateParams(aRecord, bRecord)
-  }
+    checkDuplicateParams(aRecord, bRecord);
+  };
 
-  expect(action).not.toThrow()
-})
+  expect(action).not.toThrow();
+});
diff --git a/src/utilities/components.spec.ts b/src/utilities/components.spec.ts
index 18c08eb2..45f41db3 100644
--- a/src/utilities/components.spec.ts
+++ b/src/utilities/components.spec.ts
@@ -1,11 +1,11 @@
-import { expect, test } from 'vitest'
-import { defineAsyncComponent } from 'vue'
-import helloWorld from '@/components/helloWorld'
-import { isAsyncComponent } from '@/utilities/components'
+import { expect, test } from "vite-plus/test";
+import { defineAsyncComponent } from "vue";
+import helloWorld from "@/components/helloWorld";
+import { isAsyncComponent } from "@/utilities/components";
 
 test.each([
   [helloWorld, false],
-  [defineAsyncComponent(() => import('@/components/helloWorld')), true],
-])('isAsyncComponent returns correct value', (component, isAsync) => {
-  expect(isAsyncComponent(component)).toBe(isAsync)
-})
+  [defineAsyncComponent(() => import("@/components/helloWorld")), true],
+])("isAsyncComponent returns correct value", (component, isAsync) => {
+  expect(isAsyncComponent(component)).toBe(isAsync);
+});
diff --git a/src/utilities/guards.spec.ts b/src/utilities/guards.spec.ts
index c137a029..46811940 100644
--- a/src/utilities/guards.spec.ts
+++ b/src/utilities/guards.spec.ts
@@ -1,65 +1,65 @@
-import { describe, expect, expectTypeOf, test } from 'vitest'
-import { hasProperty, StringHasValue } from '@/utilities/guards'
+import { describe, expect, expectTypeOf, test } from "vite-plus/test";
+import { hasProperty, StringHasValue } from "@/utilities/guards";
 
-describe('hasProperty', () => {
-  test('returns true when property exists', () => {
-    const source = hasProperty({ foo: true }, 'foo')
+describe("hasProperty", () => {
+  test("returns true when property exists", () => {
+    const source = hasProperty({ foo: true }, "foo");
 
-    expect(source).toBe(true)
-  })
+    expect(source).toBe(true);
+  });
 
-  test('returns false when property does not exists', () => {
-    const source = hasProperty({}, 'foo')
+  test("returns false when property does not exists", () => {
+    const source = hasProperty({}, "foo");
 
-    expect(source).toBe(false)
-  })
+    expect(source).toBe(false);
+  });
 
-  test('returns true when property exists and is correct type', () => {
-    const source = hasProperty({ foo: true }, 'foo', Boolean)
+  test("returns true when property exists and is correct type", () => {
+    const source = hasProperty({ foo: true }, "foo", Boolean);
 
-    expect(source).toBe(true)
-  })
+    expect(source).toBe(true);
+  });
 
-  test('returns false when property exists and is not correct type', () => {
-    const source = hasProperty({ foo: true }, 'foo', String)
+  test("returns false when property exists and is not correct type", () => {
+    const source = hasProperty({ foo: true }, "foo", String);
 
-    expect(source).toBe(false)
-  })
-})
+    expect(source).toBe(false);
+  });
+});
 
-describe('stringHasValue', () => {
-  test('given empty string, returns false', () => {
-  type Source = StringHasValue<''>
-  type Expect = false
+describe("stringHasValue", () => {
+  test("given empty string, returns false", () => {
+    type Source = StringHasValue<"">;
+    type Expect = false;
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
 
-  test('given generic string, returns true', () => {
-  type Source = StringHasValue<string>
-  type Expect = true
+  test("given generic string, returns true", () => {
+    type Source = StringHasValue<string>;
+    type Expect = true;
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
 
-  test('given type any, returns true', () => {
-  type Source = StringHasValue<any>
-  type Expect = true
+  test("given type any, returns true", () => {
+    type Source = StringHasValue<any>;
+    type Expect = true;
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
 
-  test('given type other than string or any, returns false', () => {
-  type Source = StringHasValue<undefined>
-  type Expect = false
+  test("given type other than string or any, returns false", () => {
+    type Source = StringHasValue<undefined>;
+    type Expect = false;
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
 
-  test('given string not empty, returns true', () => {
-  type Source = StringHasValue<'foo'>
-  type Expect = true
+  test("given string not empty, returns true", () => {
+    type Source = StringHasValue<"foo">;
+    type Expect = true;
 
-  expectTypeOf<Source>().toEqualTypeOf<Expect>()
-  })
-})
+    expectTypeOf<Source>().toEqualTypeOf<Expect>();
+  });
+});
diff --git a/src/utilities/isBrowser.browser.spec.ts b/src/utilities/isBrowser.browser.spec.ts
index 3cc58d12..70e7aa5b 100644
--- a/src/utilities/isBrowser.browser.spec.ts
+++ b/src/utilities/isBrowser.browser.spec.ts
@@ -1,6 +1,6 @@
-import { expect, test } from 'vitest'
-import { isBrowser } from '@/utilities/isBrowser'
+import { expect, test } from "vite-plus/test";
+import { isBrowser } from "@/utilities/isBrowser";
 
-test('isBrowser returns true when environment is browser', () => {
-  expect(isBrowser()).toBe(true)
-})
+test("isBrowser returns true when environment is browser", () => {
+  expect(isBrowser()).toBe(true);
+});
diff --git a/src/utilities/isBrowser.spec.ts b/src/utilities/isBrowser.spec.ts
index 0d32ec97..afec1e45 100644
--- a/src/utilities/isBrowser.spec.ts
+++ b/src/utilities/isBrowser.spec.ts
@@ -1,6 +1,6 @@
-import { expect, test } from 'vitest'
-import { isBrowser } from '@/utilities/isBrowser'
+import { expect, test } from "vite-plus/test";
+import { isBrowser } from "@/utilities/isBrowser";
 
-test('isBrowser returns false when environment is node', () => {
-  expect(isBrowser()).toBe(false)
-})
+test("isBrowser returns false when environment is node", () => {
+  expect(isBrowser()).toBe(false);
+});
diff --git a/src/utilities/prefetch.spec.ts b/src/utilities/prefetch.spec.ts
index 08cbccb2..b16f355c 100644
--- a/src/utilities/prefetch.spec.ts
+++ b/src/utilities/prefetch.spec.ts
@@ -1,42 +1,48 @@
-import { describe, expect, test } from 'vitest'
-import { DEFAULT_PREFETCH_STRATEGY, getPrefetchConfigValue, getPrefetchOption } from './prefetch'
+import { describe, expect, test } from "vite-plus/test";
+import { DEFAULT_PREFETCH_STRATEGY, getPrefetchConfigValue, getPrefetchOption } from "./prefetch";
 
-describe('getPrefetchOptions', () => {
+describe("getPrefetchOptions", () => {
   test.each([
-    [undefined, 'lazy', false, 'lazy'],
+    [undefined, "lazy", false, "lazy"],
     [true, false, false, DEFAULT_PREFETCH_STRATEGY],
     [{ components: true }, false, false, DEFAULT_PREFETCH_STRATEGY],
-    [{ components: true }, 'eager', false, 'eager'],
-    [false, 'eager', true, false],
-    [{ components: false }, 'lazy', true, false],
-    [{ components: true }, 'intent', true, 'intent'],
-    [{ components: 'intent' }, 'lazy', true, 'intent'],
-    [false, 'intent', true, false],
-    [undefined, 'intent', true, 'intent'],
-  ] as const)('when given [`%s`, `%s`, `%s`] returns `%s`', (linkPrefetch, routePrefetch, routerPrefetch, expected) => {
-    const value = getPrefetchOption({
-      linkPrefetch,
-      routePrefetch,
-      routerPrefetch,
-    }, 'components')
+    [{ components: true }, "eager", false, "eager"],
+    [false, "eager", true, false],
+    [{ components: false }, "lazy", true, false],
+    [{ components: true }, "intent", true, "intent"],
+    [{ components: "intent" }, "lazy", true, "intent"],
+    [false, "intent", true, false],
+    [undefined, "intent", true, "intent"],
+  ] as const)(
+    "when given [`%s`, `%s`, `%s`] returns `%s`",
+    (linkPrefetch, routePrefetch, routerPrefetch, expected) => {
+      const value = getPrefetchOption(
+        {
+          linkPrefetch,
+          routePrefetch,
+          routerPrefetch,
+        },
+        "components",
+      );
 
-    expect(value).toBe(expected)
-  })
-})
+      expect(value).toBe(expected);
+    },
+  );
+});
 
-describe('getPrefetchConfigValue', () => {
+describe("getPrefetchConfigValue", () => {
   test.each([
     [false, false],
     [true, true],
     [undefined, undefined],
-    ['lazy', 'lazy'],
+    ["lazy", "lazy"],
     [{ components: false }, false],
     [{ components: true }, true],
     [{ components: undefined }, undefined],
-    [{ components: 'lazy' }, 'lazy'],
-  ] as const)('when given `%s` returns `%s`', (input, expected) => {
-    const value = getPrefetchConfigValue(input, 'components')
+    [{ components: "lazy" }, "lazy"],
+  ] as const)("when given `%s` returns `%s`", (input, expected) => {
+    const value = getPrefetchConfigValue(input, "components");
 
-    expect(value).toBe(expected)
-  })
-})
+    expect(value).toBe(expected);
+  });
+});
diff --git a/src/utilities/trailingSlashes.spec.ts b/src/utilities/trailingSlashes.spec.ts
index 61439ea0..e8eb972e 100644
--- a/src/utilities/trailingSlashes.spec.ts
+++ b/src/utilities/trailingSlashes.spec.ts
@@ -1,110 +1,110 @@
-import { describe, expect, test } from 'vitest'
-import { pathHasTrailingSlash, removeTrailingSlashesFromPath } from './trailingSlashes'
+import { describe, expect, test } from "vite-plus/test";
+import { pathHasTrailingSlash, removeTrailingSlashesFromPath } from "./trailingSlashes";
 
-describe('removeTrailingSlashesFromPath', () => {
-  test('removes single trailing slash', () => {
-    const url = '/foo/bar/'
+describe("removeTrailingSlashesFromPath", () => {
+  test("removes single trailing slash", () => {
+    const url = "/foo/bar/";
 
-    const response = removeTrailingSlashesFromPath(url)
+    const response = removeTrailingSlashesFromPath(url);
 
-    expect(response).toBe('/foo/bar')
-  })
+    expect(response).toBe("/foo/bar");
+  });
 
-  test('removes multiple trailing slashes', () => {
-    const url = '/foo/bar///'
+  test("removes multiple trailing slashes", () => {
+    const url = "/foo/bar///";
 
-    const response = removeTrailingSlashesFromPath(url)
+    const response = removeTrailingSlashesFromPath(url);
 
-    expect(response).toBe('/foo/bar')
-  })
+    expect(response).toBe("/foo/bar");
+  });
 
-  test('does nothing if there are no trailing slashes', () => {
-    const url = '/foo/bar'
+  test("does nothing if there are no trailing slashes", () => {
+    const url = "/foo/bar";
 
-    const response = removeTrailingSlashesFromPath(url)
+    const response = removeTrailingSlashesFromPath(url);
 
-    expect(response).toBe('/foo/bar')
-  })
+    expect(response).toBe("/foo/bar");
+  });
 
-  test('does not remove duplicate slashes in the middle of the string', () => {
-    const url = '/foo//bar/'
+  test("does not remove duplicate slashes in the middle of the string", () => {
+    const url = "/foo//bar/";
 
-    const response = removeTrailingSlashesFromPath(url)
+    const response = removeTrailingSlashesFromPath(url);
 
-    expect(response).toBe('/foo//bar')
-  })
+    expect(response).toBe("/foo//bar");
+  });
 
-  test('does not remove trailing slash that is the only character in the string', () => {
-    const url = '/'
+  test("does not remove trailing slash that is the only character in the string", () => {
+    const url = "/";
 
-    const response = removeTrailingSlashesFromPath(url)
+    const response = removeTrailingSlashesFromPath(url);
 
-    expect(response).toBe('/')
-  })
+    expect(response).toBe("/");
+  });
 
-  test('removes trailing slash from path of full URL', () => {
-    const url = 'https://kitbag.dev/foo/'
+  test("removes trailing slash from path of full URL", () => {
+    const url = "https://kitbag.dev/foo/";
 
-    const response = removeTrailingSlashesFromPath(url)
+    const response = removeTrailingSlashesFromPath(url);
 
-    expect(response).toBe('https://kitbag.dev/foo')
-  })
+    expect(response).toBe("https://kitbag.dev/foo");
+  });
 
-  test('preserves root path for full URL (no trim)', () => {
-    const url = 'https://kitbag.dev/'
+  test("preserves root path for full URL (no trim)", () => {
+    const url = "https://kitbag.dev/";
 
-    const response = removeTrailingSlashesFromPath(url)
+    const response = removeTrailingSlashesFromPath(url);
 
-    expect(response).toBe('https://kitbag.dev/')
-  })
+    expect(response).toBe("https://kitbag.dev/");
+  });
 
-  test('preserves query and hash when removing trailing slash from full URL', () => {
-    const url = 'https://kitbag.dev/foo/?a=1#section'
+  test("preserves query and hash when removing trailing slash from full URL", () => {
+    const url = "https://kitbag.dev/foo/?a=1#section";
 
-    const response = removeTrailingSlashesFromPath(url)
+    const response = removeTrailingSlashesFromPath(url);
 
-    expect(response).toBe('https://kitbag.dev/foo?a=1#section')
-  })
-})
+    expect(response).toBe("https://kitbag.dev/foo?a=1#section");
+  });
+});
 
-describe('hasTrailingSlashes', () => {
-  test('returns true if the string has a trailing slash', () => {
-    const url = '/foo/bar/'
+describe("hasTrailingSlashes", () => {
+  test("returns true if the string has a trailing slash", () => {
+    const url = "/foo/bar/";
 
-    const response = pathHasTrailingSlash(url)
+    const response = pathHasTrailingSlash(url);
 
-    expect(response).toBe(true)
-  })
+    expect(response).toBe(true);
+  });
 
-  test('returns false if the string does not have a trailing slash', () => {
-    const url = '/foo/bar'
+  test("returns false if the string does not have a trailing slash", () => {
+    const url = "/foo/bar";
 
-    const response = pathHasTrailingSlash(url)
+    const response = pathHasTrailingSlash(url);
 
-    expect(response).toBe(false)
-  })
+    expect(response).toBe(false);
+  });
 
-  test('returns false when the only character is a leading slash', () => {
-    const url = '/'
+  test("returns false when the only character is a leading slash", () => {
+    const url = "/";
 
-    const response = pathHasTrailingSlash(url)
+    const response = pathHasTrailingSlash(url);
 
-    expect(response).toBe(false)
-  })
+    expect(response).toBe(false);
+  });
 
-  test('returns true when full URL path has trailing slash', () => {
-    const url = 'https://kitbag.dev/foo/'
+  test("returns true when full URL path has trailing slash", () => {
+    const url = "https://kitbag.dev/foo/";
 
-    const response = pathHasTrailingSlash(url)
+    const response = pathHasTrailingSlash(url);
 
-    expect(response).toBe(true)
-  })
+    expect(response).toBe(true);
+  });
 
-  test('returns false when full URL path is root', () => {
-    const url = 'https://kitbag.dev/'
+  test("returns false when full URL path is root", () => {
+    const url = "https://kitbag.dev/";
 
-    const response = pathHasTrailingSlash(url)
+    const response = pathHasTrailingSlash(url);
 
-    expect(response).toBe(false)
-  })
-})
+    expect(response).toBe(false);
+  });
+});
diff --git a/src/utilities/urlSearchParams.spec.ts b/src/utilities/urlSearchParams.spec.ts
index 4c823ebb..e1a418c5 100644
--- a/src/utilities/urlSearchParams.spec.ts
+++ b/src/utilities/urlSearchParams.spec.ts
@@ -1,26 +1,23 @@
-import { expect, test } from 'vitest'
-import { combineUrlSearchParams } from './urlSearchParams'
+import { expect, test } from "vite-plus/test";
+import { combineUrlSearchParams } from "./urlSearchParams";
 
-test.each([
-  'foo=bar',
-  { foo: 'bar' },
-  [['foo', 'bar']],
-])('given different constructor types, normalizes into URLSearchParams', (params) => {
-  const response = combineUrlSearchParams(params, undefined)
+test.each(["foo=bar", { foo: "bar" }, [["foo", "bar"]]])(
+  "given different constructor types, normalizes into URLSearchParams",
+  (params) => {
+    const response = combineUrlSearchParams(params, undefined);
 
-  expect(Array.from(response.entries())).toMatchObject([
-    ['foo', 'bar'],
-  ])
-})
+    expect(Array.from(response.entries())).toMatchObject([["foo", "bar"]]);
+  },
+);
 
-test('given duplicate keys, appends new entry', () => {
-  const aParams = new URLSearchParams({ foo: 'foo' })
-  const bParams = new URLSearchParams({ foo: 'bar' })
+test("given duplicate keys, appends new entry", () => {
+  const aParams = new URLSearchParams({ foo: "foo" });
+  const bParams = new URLSearchParams({ foo: "bar" });
 
-  const response = combineUrlSearchParams(aParams, bParams)
+  const response = combineUrlSearchParams(aParams, bParams);
 
   expect(Array.from(response.entries())).toMatchObject([
-    ['foo', 'foo'],
-    ['foo', 'bar'],
-  ])
-})
+    ["foo", "foo"],
+    ["foo", "bar"],
+  ]);
+});
diff --git a/vite.config.js b/vite.config.js
index fa0f6229..6dffce9a 100644
--- a/vite.config.js
+++ b/vite.config.js
@@ -1,14 +1,21 @@
-import { resolve } from 'path'
-import { defineConfig } from 'vitest/config'
-import vue from '@vitejs/plugin-vue'
-import dts from 'vite-plugin-dts'
+import { resolve } from "path";
+import { defineConfig } from "vite-plus";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import vue from "@vitejs/plugin-vue";
+import dts from "vite-plugin-dts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
 
 export default defineConfig({
+  staged: {
+    "*": "vp check --fix",
+  },
   resolve: {
     alias: [
       {
-        find: '@',
-        replacement: resolve(__dirname, 'src'),
+        find: "@",
+        replacement: resolve(__dirname, "src"),
       },
     ],
   },
@@ -17,24 +24,24 @@ export default defineConfig({
       {
         extends: true,
         test: {
-          name: 'browser',
-          environment: 'happy-dom',
-          include: ['src/**/*.browser.spec.ts'],
+          name: "browser",
+          environment: "happy-dom",
+          include: ["src/**/*.browser.spec.ts"],
         },
       },
       {
         extends: true,
         test: {
-          name: 'node',
-          environment: 'node',
-          include: ['src/**/*.spec.ts'],
-          exclude: ['src/**/*.browser.spec.ts'],
+          name: "node",
+          environment: "node",
+          include: ["src/**/*.spec.ts"],
+          exclude: ["src/**/*.browser.spec.ts"],
           typecheck: {
             enabled: true,
-            checker: 'vue-tsc',
+            checker: "vue-tsc",
             ignoreSourceErrors: true,
-            tsconfig: './tsconfig.json',
-            include: ['src/**/*.spec-d.ts'],
+            tsconfig: "./tsconfig.json",
+            include: ["src/**/*.spec-d.ts"],
           },
         },
       },
@@ -42,15 +49,15 @@ export default defineConfig({
   },
   build: {
     lib: {
-      entry: resolve(__dirname, 'src/main.ts'),
-      name: '@kitbag/router',
-      fileName: 'kitbag-router',
+      entry: resolve(__dirname, "src/main.ts"),
+      name: "@kitbag/router",
+      fileName: "kitbag-router",
     },
     rollupOptions: {
-      external: ['vue', 'zod', /^node:/],
+      external: ["vue", "zod", /^node:/],
       output: {
         globals: {
-          vue: 'Vue',
+          vue: "Vue",
         },
       },
     },
@@ -61,4 +68,4 @@ export default defineConfig({
       insertTypesEntry: true,
     }),
   ],
-})
+});