@virou/core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Tankosin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,175 @@
+'use strict';
+
+const vue = require('vue');
+const core = require('@vueuse/core');
+const rou3 = require('rou3');
+const ufo = require('ufo');
+
+function addRoutes(router, routes, parentPath = "") {
+  const { context, routeTree, views, keys } = router;
+  routes.forEach(({ key, path, component, meta, children }) => {
+    const fullPath = ufo.joinURL(parentPath, path);
+    views[fullPath] ||= [];
+    views[fullPath].push(vue.defineAsyncComponent(component));
+    keys[fullPath] ||= [];
+    keys[fullPath].push(key ?? null);
+    rou3.addRoute(context, "GET", fullPath, { key, fullPath, meta });
+    const node = [fullPath];
+    if (children) {
+      const childRouteTree = [];
+      addRoutes({ ...router, routeTree: childRouteTree }, children, fullPath);
+      node[1] = childRouteTree;
+    }
+    routeTree.push(node);
+  });
+}
+function resolveRouteTree(routeTree, targetPath, accumulatedPaths = []) {
+  for (const [path, children] of routeTree) {
+    const paths = [...accumulatedPaths, path];
+    if (path === targetPath) {
+      return paths;
+    }
+    if (children) {
+      const result = resolveRouteTree(children, targetPath, paths);
+      if (result.length) {
+        return result;
+      }
+    }
+  }
+  return [];
+}
+function createRenderList(routes, targetPath, views, keys) {
+  const renderList = [];
+  const currentSegments = targetPath.split("/").filter(Boolean);
+  routes.forEach((path) => {
+    const treeViews = views[path];
+    const treeKeys = keys[path];
+    if (treeViews === undefined || treeKeys === undefined || treeViews.length !== treeKeys.length) {
+      throw new Error(`[virou] Mismatch or missing data for path: ${path}`);
+    }
+    const resolvedPath = ufo.joinURL("/", ...currentSegments.slice(0, path.split("/").filter(Boolean).length));
+    for (let i = 0; i < treeViews.length; i++) {
+      const view = treeViews[i];
+      const key = treeKeys[i];
+      if (view !== undefined && key !== undefined && (targetPath === resolvedPath || i === 0)) {
+        renderList.push([key ?? resolvedPath, view]);
+      }
+    }
+  });
+  return renderList;
+}
+
+const virouSymbol = Symbol("virou");
+const useVirouState = core.createGlobalState(() => {
+  const routers = vue.shallowRef({});
+  const activeRoutePaths = vue.ref({});
+  return { routers, activeRoutePaths };
+});
+function createVRouter(key, routes, options) {
+  const { routers, activeRoutePaths } = useVirouState();
+  if (key in routers.value) {
+    throw new Error(`[virou] [createVRouter] key already exists: ${key}`);
+  }
+  routers.value[key] = {
+    context: rou3.createRouter(),
+    routeTree: [],
+    views: {},
+    keys: {}
+  };
+  addRoutes(routers.value[key], routes);
+  const { initialPath } = options ||= {
+    initialPath: "/"
+  };
+  activeRoutePaths.value[key] = initialPath;
+}
+function useVRouter(...args) {
+  if (typeof args[0] !== "string") {
+    args.unshift(vue.inject(virouSymbol, vue.useId()));
+  }
+  const [key, routes] = args;
+  if (!key || typeof key !== "string") {
+    throw new TypeError(`[virou] [useVRouter] key must be a string: ${key}`);
+  }
+  vue.provide(virouSymbol, key);
+  const options = args[2];
+  const { routers, activeRoutePaths } = useVirouState();
+  if (routers.value[key] === undefined) {
+    if (routes === undefined) {
+      throw new Error(`[virou] [useVRouter] routes is required for key: ${key}`);
+    }
+    createVRouter(key, routes, options);
+  }
+  const route = vue.computed(() => {
+    const { context, routeTree, views, keys } = routers.value[key];
+    const activeRoutePath = activeRoutePaths.value[key];
+    const matchedRoute = rou3.findRoute(
+      context,
+      "GET",
+      activeRoutePath
+    );
+    const activeRouteTree = matchedRoute && resolveRouteTree(routeTree, matchedRoute.data.fullPath);
+    const { search, pathname, hash } = ufo.parseURL(activeRoutePath);
+    const renderList = activeRouteTree && createRenderList(activeRouteTree, pathname, views, keys);
+    return {
+      fullPath: activeRoutePath,
+      ...matchedRoute,
+      search,
+      path: pathname,
+      hash,
+      activeRouteTree,
+      renderList
+    };
+  });
+  return {
+    route,
+    router: {
+      addRoute: (route2) => {
+        addRoutes(routers.value[key], [route2]);
+      },
+      replace: (path) => {
+        activeRoutePaths.value[key] = path;
+      },
+      _key: key,
+      _depthKey: Symbol.for(key)
+    }
+  };
+}
+
+const VRouterView = vue.defineComponent({
+  name: "VRouterView",
+  props: {
+    routerKey: {
+      type: String,
+      default: undefined
+    },
+    viewKey: {
+      type: String,
+      default: undefined
+    },
+    keepalive: {
+      type: Boolean,
+      default: false
+    }
+  },
+  setup(props) {
+    const routerKey = props.routerKey ?? vue.inject(virouSymbol);
+    if (routerKey === undefined) {
+      throw new Error(`[virou] [VRouterView] routerKey is required`);
+    }
+    const { router, route } = useVRouter(routerKey);
+    const depth = vue.inject(router._depthKey, 0);
+    const render = vue.computed(() => route.value.renderList?.[depth]);
+    vue.provide(router._depthKey, depth + 1);
+    return () => {
+      const [key, component] = render.value ?? [];
+      const _key = key ?? props.viewKey ?? route.value.path;
+      const ViewComponent = component !== null && component !== undefined ? vue.h(component, { _key }) : null;
+      return props.keepalive ? vue.h(vue.KeepAlive, null, [ViewComponent]) : ViewComponent;
+    };
+  }
+});
+
+exports.VRouterView = VRouterView;
+exports.createVRouter = createVRouter;
+exports.useVRouter = useVRouter;
+exports.virouSymbol = virouSymbol;

package/dist/index.d.cts

@@ -0,0 +1,99 @@
+import * as vue from 'vue';
+import { Component, AsyncComponentLoader, ComputedRef } from 'vue';
+import { RouterContext } from 'rou3';
+
+declare const VRouterView: vue.DefineComponent<vue.ExtractPropTypes<{
+    routerKey: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    viewKey: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    keepalive: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    routerKey: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    viewKey: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    keepalive: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    routerKey: string;
+    viewKey: string;
+    keepalive: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+type VRouteTreeNode = [key: string, children?: VRouteTreeNode[]];
+type VRouteViews = Record<string, Component[]>;
+type VRouteKeys = Record<string, Array<string | null>>;
+type VRouteRenderView = [key: string, component: Component];
+interface VRouteRecordRaw {
+    key?: string;
+    path: string;
+    component: AsyncComponentLoader<Component>;
+    meta?: Record<string, any>;
+    children?: VRouteRecordRaw[];
+}
+interface VRouteMatchedData {
+    key?: string;
+    fullPath: string;
+    meta?: Record<string, any>;
+}
+interface VRouterInstance {
+    context: RouterContext<VRouteMatchedData>;
+    routeTree: VRouteTreeNode[];
+    views: VRouteViews;
+    keys: VRouteKeys;
+}
+interface VRouterOptions {
+    initialPath: string;
+}
+interface VRouter {
+    route: ComputedRef<{
+        fullPath: string;
+        data?: VRouteMatchedData;
+        params?: Record<string, string>;
+        path: string;
+        search: string;
+        hash: string;
+        activeRouteTree?: string[];
+        renderList?: VRouteRenderView[];
+    }>;
+    router: {
+        addRoute: (route: VRouteRecordRaw) => void;
+        replace: (path: string) => void;
+        _key: string;
+        _depthKey: symbol;
+    };
+}
+
+declare const virouSymbol: unique symbol;
+declare function createVRouter(key: string, routes: VRouteRecordRaw[], options?: VRouterOptions): void;
+/**
+ * Creates or retrieves a virtual router
+ *
+ * @param key - a unique identifier for the router
+ * @param routes - a list of routes to add to the router
+ * @param options - configuration options for the router
+ *
+ * @returns an object containing:
+ *   - `route`: reactive data for the current route (e.g., path, fullPath, query, etc.)
+ *   - `router`: utilities to manage the router (e.g., `addRoute`, `replace`)
+ */
+declare function useVRouter(key?: string, routes?: VRouteRecordRaw[], options?: VRouterOptions): VRouter;
+declare function useVRouter(routes?: VRouteRecordRaw[], options?: VRouterOptions): VRouter;
+
+export { type VRouteKeys, type VRouteMatchedData, type VRouteRecordRaw, type VRouteRenderView, type VRouteTreeNode, type VRouteViews, type VRouter, type VRouterInstance, type VRouterOptions, VRouterView, createVRouter, useVRouter, virouSymbol };

package/dist/index.d.mts

@@ -0,0 +1,99 @@
+import * as vue from 'vue';
+import { Component, AsyncComponentLoader, ComputedRef } from 'vue';
+import { RouterContext } from 'rou3';
+
+declare const VRouterView: vue.DefineComponent<vue.ExtractPropTypes<{
+    routerKey: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    viewKey: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    keepalive: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    routerKey: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    viewKey: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    keepalive: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    routerKey: string;
+    viewKey: string;
+    keepalive: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+type VRouteTreeNode = [key: string, children?: VRouteTreeNode[]];
+type VRouteViews = Record<string, Component[]>;
+type VRouteKeys = Record<string, Array<string | null>>;
+type VRouteRenderView = [key: string, component: Component];
+interface VRouteRecordRaw {
+    key?: string;
+    path: string;
+    component: AsyncComponentLoader<Component>;
+    meta?: Record<string, any>;
+    children?: VRouteRecordRaw[];
+}
+interface VRouteMatchedData {
+    key?: string;
+    fullPath: string;
+    meta?: Record<string, any>;
+}
+interface VRouterInstance {
+    context: RouterContext<VRouteMatchedData>;
+    routeTree: VRouteTreeNode[];
+    views: VRouteViews;
+    keys: VRouteKeys;
+}
+interface VRouterOptions {
+    initialPath: string;
+}
+interface VRouter {
+    route: ComputedRef<{
+        fullPath: string;
+        data?: VRouteMatchedData;
+        params?: Record<string, string>;
+        path: string;
+        search: string;
+        hash: string;
+        activeRouteTree?: string[];
+        renderList?: VRouteRenderView[];
+    }>;
+    router: {
+        addRoute: (route: VRouteRecordRaw) => void;
+        replace: (path: string) => void;
+        _key: string;
+        _depthKey: symbol;
+    };
+}
+
+declare const virouSymbol: unique symbol;
+declare function createVRouter(key: string, routes: VRouteRecordRaw[], options?: VRouterOptions): void;
+/**
+ * Creates or retrieves a virtual router
+ *
+ * @param key - a unique identifier for the router
+ * @param routes - a list of routes to add to the router
+ * @param options - configuration options for the router
+ *
+ * @returns an object containing:
+ *   - `route`: reactive data for the current route (e.g., path, fullPath, query, etc.)
+ *   - `router`: utilities to manage the router (e.g., `addRoute`, `replace`)
+ */
+declare function useVRouter(key?: string, routes?: VRouteRecordRaw[], options?: VRouterOptions): VRouter;
+declare function useVRouter(routes?: VRouteRecordRaw[], options?: VRouterOptions): VRouter;
+
+export { type VRouteKeys, type VRouteMatchedData, type VRouteRecordRaw, type VRouteRenderView, type VRouteTreeNode, type VRouteViews, type VRouter, type VRouterInstance, type VRouterOptions, VRouterView, createVRouter, useVRouter, virouSymbol };

package/dist/index.d.ts

@@ -0,0 +1,99 @@
+import * as vue from 'vue';
+import { Component, AsyncComponentLoader, ComputedRef } from 'vue';
+import { RouterContext } from 'rou3';
+
+declare const VRouterView: vue.DefineComponent<vue.ExtractPropTypes<{
+    routerKey: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    viewKey: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    keepalive: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    routerKey: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    viewKey: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    keepalive: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    routerKey: string;
+    viewKey: string;
+    keepalive: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+type VRouteTreeNode = [key: string, children?: VRouteTreeNode[]];
+type VRouteViews = Record<string, Component[]>;
+type VRouteKeys = Record<string, Array<string | null>>;
+type VRouteRenderView = [key: string, component: Component];
+interface VRouteRecordRaw {
+    key?: string;
+    path: string;
+    component: AsyncComponentLoader<Component>;
+    meta?: Record<string, any>;
+    children?: VRouteRecordRaw[];
+}
+interface VRouteMatchedData {
+    key?: string;
+    fullPath: string;
+    meta?: Record<string, any>;
+}
+interface VRouterInstance {
+    context: RouterContext<VRouteMatchedData>;
+    routeTree: VRouteTreeNode[];
+    views: VRouteViews;
+    keys: VRouteKeys;
+}
+interface VRouterOptions {
+    initialPath: string;
+}
+interface VRouter {
+    route: ComputedRef<{
+        fullPath: string;
+        data?: VRouteMatchedData;
+        params?: Record<string, string>;
+        path: string;
+        search: string;
+        hash: string;
+        activeRouteTree?: string[];
+        renderList?: VRouteRenderView[];
+    }>;
+    router: {
+        addRoute: (route: VRouteRecordRaw) => void;
+        replace: (path: string) => void;
+        _key: string;
+        _depthKey: symbol;
+    };
+}
+
+declare const virouSymbol: unique symbol;
+declare function createVRouter(key: string, routes: VRouteRecordRaw[], options?: VRouterOptions): void;
+/**
+ * Creates or retrieves a virtual router
+ *
+ * @param key - a unique identifier for the router
+ * @param routes - a list of routes to add to the router
+ * @param options - configuration options for the router
+ *
+ * @returns an object containing:
+ *   - `route`: reactive data for the current route (e.g., path, fullPath, query, etc.)
+ *   - `router`: utilities to manage the router (e.g., `addRoute`, `replace`)
+ */
+declare function useVRouter(key?: string, routes?: VRouteRecordRaw[], options?: VRouterOptions): VRouter;
+declare function useVRouter(routes?: VRouteRecordRaw[], options?: VRouterOptions): VRouter;
+
+export { type VRouteKeys, type VRouteMatchedData, type VRouteRecordRaw, type VRouteRenderView, type VRouteTreeNode, type VRouteViews, type VRouter, type VRouterInstance, type VRouterOptions, VRouterView, createVRouter, useVRouter, virouSymbol };

package/dist/index.mjs

@@ -0,0 +1,170 @@
+import { defineAsyncComponent, shallowRef, ref, inject, useId, provide, computed, defineComponent, h, KeepAlive } from 'vue';
+import { createGlobalState } from '@vueuse/core';
+import { addRoute, createRouter, findRoute } from 'rou3';
+import { joinURL, parseURL } from 'ufo';
+
+function addRoutes(router, routes, parentPath = "") {
+  const { context, routeTree, views, keys } = router;
+  routes.forEach(({ key, path, component, meta, children }) => {
+    const fullPath = joinURL(parentPath, path);
+    views[fullPath] ||= [];
+    views[fullPath].push(defineAsyncComponent(component));
+    keys[fullPath] ||= [];
+    keys[fullPath].push(key ?? null);
+    addRoute(context, "GET", fullPath, { key, fullPath, meta });
+    const node = [fullPath];
+    if (children) {
+      const childRouteTree = [];
+      addRoutes({ ...router, routeTree: childRouteTree }, children, fullPath);
+      node[1] = childRouteTree;
+    }
+    routeTree.push(node);
+  });
+}
+function resolveRouteTree(routeTree, targetPath, accumulatedPaths = []) {
+  for (const [path, children] of routeTree) {
+    const paths = [...accumulatedPaths, path];
+    if (path === targetPath) {
+      return paths;
+    }
+    if (children) {
+      const result = resolveRouteTree(children, targetPath, paths);
+      if (result.length) {
+        return result;
+      }
+    }
+  }
+  return [];
+}
+function createRenderList(routes, targetPath, views, keys) {
+  const renderList = [];
+  const currentSegments = targetPath.split("/").filter(Boolean);
+  routes.forEach((path) => {
+    const treeViews = views[path];
+    const treeKeys = keys[path];
+    if (treeViews === undefined || treeKeys === undefined || treeViews.length !== treeKeys.length) {
+      throw new Error(`[virou] Mismatch or missing data for path: ${path}`);
+    }
+    const resolvedPath = joinURL("/", ...currentSegments.slice(0, path.split("/").filter(Boolean).length));
+    for (let i = 0; i < treeViews.length; i++) {
+      const view = treeViews[i];
+      const key = treeKeys[i];
+      if (view !== undefined && key !== undefined && (targetPath === resolvedPath || i === 0)) {
+        renderList.push([key ?? resolvedPath, view]);
+      }
+    }
+  });
+  return renderList;
+}
+
+const virouSymbol = Symbol("virou");
+const useVirouState = createGlobalState(() => {
+  const routers = shallowRef({});
+  const activeRoutePaths = ref({});
+  return { routers, activeRoutePaths };
+});
+function createVRouter(key, routes, options) {
+  const { routers, activeRoutePaths } = useVirouState();
+  if (key in routers.value) {
+    throw new Error(`[virou] [createVRouter] key already exists: ${key}`);
+  }
+  routers.value[key] = {
+    context: createRouter(),
+    routeTree: [],
+    views: {},
+    keys: {}
+  };
+  addRoutes(routers.value[key], routes);
+  const { initialPath } = options ||= {
+    initialPath: "/"
+  };
+  activeRoutePaths.value[key] = initialPath;
+}
+function useVRouter(...args) {
+  if (typeof args[0] !== "string") {
+    args.unshift(inject(virouSymbol, useId()));
+  }
+  const [key, routes] = args;
+  if (!key || typeof key !== "string") {
+    throw new TypeError(`[virou] [useVRouter] key must be a string: ${key}`);
+  }
+  provide(virouSymbol, key);
+  const options = args[2];
+  const { routers, activeRoutePaths } = useVirouState();
+  if (routers.value[key] === undefined) {
+    if (routes === undefined) {
+      throw new Error(`[virou] [useVRouter] routes is required for key: ${key}`);
+    }
+    createVRouter(key, routes, options);
+  }
+  const route = computed(() => {
+    const { context, routeTree, views, keys } = routers.value[key];
+    const activeRoutePath = activeRoutePaths.value[key];
+    const matchedRoute = findRoute(
+      context,
+      "GET",
+      activeRoutePath
+    );
+    const activeRouteTree = matchedRoute && resolveRouteTree(routeTree, matchedRoute.data.fullPath);
+    const { search, pathname, hash } = parseURL(activeRoutePath);
+    const renderList = activeRouteTree && createRenderList(activeRouteTree, pathname, views, keys);
+    return {
+      fullPath: activeRoutePath,
+      ...matchedRoute,
+      search,
+      path: pathname,
+      hash,
+      activeRouteTree,
+      renderList
+    };
+  });
+  return {
+    route,
+    router: {
+      addRoute: (route2) => {
+        addRoutes(routers.value[key], [route2]);
+      },
+      replace: (path) => {
+        activeRoutePaths.value[key] = path;
+      },
+      _key: key,
+      _depthKey: Symbol.for(key)
+    }
+  };
+}
+
+const VRouterView = defineComponent({
+  name: "VRouterView",
+  props: {
+    routerKey: {
+      type: String,
+      default: undefined
+    },
+    viewKey: {
+      type: String,
+      default: undefined
+    },
+    keepalive: {
+      type: Boolean,
+      default: false
+    }
+  },
+  setup(props) {
+    const routerKey = props.routerKey ?? inject(virouSymbol);
+    if (routerKey === undefined) {
+      throw new Error(`[virou] [VRouterView] routerKey is required`);
+    }
+    const { router, route } = useVRouter(routerKey);
+    const depth = inject(router._depthKey, 0);
+    const render = computed(() => route.value.renderList?.[depth]);
+    provide(router._depthKey, depth + 1);
+    return () => {
+      const [key, component] = render.value ?? [];
+      const _key = key ?? props.viewKey ?? route.value.path;
+      const ViewComponent = component !== null && component !== undefined ? h(component, { _key }) : null;
+      return props.keepalive ? h(KeepAlive, null, [ViewComponent]) : ViewComponent;
+    };
+  }
+});
+
+export { VRouterView, createVRouter, useVRouter, virouSymbol };

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@virou/core",
+  "type": "module",
+  "version": "0.1.0",
+  "description": "Virtual router with multiple instance support for Vue",
+  "author": "Tankosin<https://github.com/tankosinn>",
+  "license": "MIT",
+  "homepage": "https://github.com/tankosinn/virou#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tankosinn/virou.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/tankosinn/virou/issues"
+  },
+  "keywords": [
+    "vue",
+    "vue-router",
+    "virtual-router",
+    "router"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@vueuse/core": "^12.4.0",
+    "rou3": "^0.5.1",
+    "ufo": "^1.5.4",
+    "vue": "^3.5.13"
+  },
+  "devDependencies": {
+    "unbuild": "3.3.1"
+  },
+  "scripts": {
+    "build": "unbuild"
+  }
+}