@lytjs/router 6.4.0 → 6.6.0

package/dist/index.cjs

@@ -0,0 +1,1062 @@
+'use strict';
+
+var reactivity = require('@lytjs/reactivity');
+
+// src/types.ts
+function locationQueryToSearchParams(query) {
+  const searchParams = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value === null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const v of value) {
+        if (v !== null) {
+          searchParams.append(key, v);
+        }
+      }
+    } else {
+      searchParams.append(key, value);
+    }
+  }
+  return searchParams;
+}
+var NavigationFailureType = /* @__PURE__ */ ((NavigationFailureType2) => {
+  NavigationFailureType2[NavigationFailureType2["aborted"] = 1] = "aborted";
+  NavigationFailureType2[NavigationFailureType2["cancelled"] = 2] = "cancelled";
+  NavigationFailureType2[NavigationFailureType2["duplicated"] = 4] = "duplicated";
+  return NavigationFailureType2;
+})(NavigationFailureType || {});
+
+// src/matcher.ts
+var PARAM_RE = /^:(\w+)(\??)?(\.\.\.)?$/;
+var WILDCARD_RE = /^\*$/;
+function tokenizePath(path) {
+  const segments = path.split("/");
+  const tokens = [];
+  for (const segment of segments) {
+    if (!segment) continue;
+    const paramMatch = segment.match(PARAM_RE);
+    if (paramMatch) {
+      const [, name, optional, repeatable] = paramMatch;
+      if (name) {
+        tokens.push({
+          type: "param",
+          name,
+          repeatable: repeatable === "...",
+          optional: optional === "?"
+        });
+      }
+      continue;
+    }
+    if (WILDCARD_RE.test(segment)) {
+      tokens.push({ type: "wildcard", value: "*" });
+      continue;
+    }
+    tokens.push({ type: "static", value: segment });
+  }
+  return tokens;
+}
+function scoreRoute(tokens) {
+  let score = 0;
+  for (const token of tokens) {
+    switch (token.type) {
+      case "static":
+        score += 3;
+        break;
+      case "param":
+        score += token.optional ? 1 : 2;
+        break;
+      case "wildcard":
+        score += 0;
+        break;
+    }
+  }
+  return score;
+}
+function matchPath(pathname, tokens, strict = false) {
+  const pathSegments = pathname.split("/").filter(Boolean);
+  const params = {};
+  let matched = true;
+  let i = 0;
+  for (const token of tokens) {
+    if (i >= pathSegments.length) {
+      if (token.type === "param" && token.optional) continue;
+      if (token.type === "wildcard") continue;
+      matched = false;
+      break;
+    }
+    const segment = pathSegments[i];
+    switch (token.type) {
+      case "static":
+        if (segment !== token.value) {
+          matched = false;
+        }
+        i++;
+        break;
+      case "param":
+        if (token.repeatable) {
+          params[token.name] = pathSegments.slice(i);
+          i = pathSegments.length;
+        } else if (segment !== void 0) {
+          params[token.name] = segment;
+          i++;
+        }
+        break;
+      case "wildcard":
+        params[token.value] = pathSegments.slice(i).join("/");
+        i = pathSegments.length;
+        break;
+    }
+    if (!matched) break;
+  }
+  if (matched && i < pathSegments.length) {
+    matched = false;
+  }
+  if (!strict && matched && pathSegments.length === 0 && tokens.length === 0) {
+    matched = true;
+  }
+  return {
+    matched,
+    params,
+    path: "/" + pathSegments.slice(0, i).join("/"),
+    score: scoreRoute(tokens)
+  };
+}
+function normalizeRouteRecord(record, parent) {
+  const tokens = tokenizePath(record.path);
+  const fullPath = parent ? parent.record.path + (record.path.startsWith("/") ? record.path : "/" + record.path) : record.path;
+  const normalized = {
+    path: fullPath,
+    name: record.name ?? null,
+    meta: record.meta ?? {},
+    children: [],
+    beforeEnter: record.beforeEnter,
+    props: record.props ?? false,
+    component: record.component,
+    components: "components" in record ? record.components : void 0
+  };
+  const matcher = {
+    record: normalized,
+    tokens,
+    score: scoreRoute(tokens),
+    children: [],
+    parent
+  };
+  if (record.children) {
+    for (const child of record.children) {
+      const childMatcher = normalizeRouteRecord(child, matcher);
+      matcher.children.push(childMatcher);
+      normalized.children.push(childMatcher.record);
+    }
+  }
+  return matcher;
+}
+function flattenMatchers(matchers) {
+  const result = [];
+  function walk(matcher, parentTokens = []) {
+    const combinedTokens = [...parentTokens, ...matcher.tokens];
+    const matcherWithCombinedTokens = {
+      ...matcher,
+      tokens: combinedTokens
+    };
+    result.push(matcherWithCombinedTokens);
+    for (const child of matcher.children) {
+      walk(child, combinedTokens);
+    }
+  }
+  for (const matcher of matchers) {
+    walk(matcher);
+  }
+  return result;
+}
+function parseQuery(queryString) {
+  const query = {};
+  if (!queryString) return query;
+  const search = queryString.startsWith("?") ? queryString.slice(1) : queryString;
+  const pairs = search.split("&");
+  for (const pair of pairs) {
+    if (!pair) continue;
+    const [key, value] = pair.split("=");
+    const decodedKey = decodeURIComponent(key);
+    const decodedValue = value !== void 0 ? decodeURIComponent(value) : void 0;
+    if (decodedKey in query) {
+      const existing = query[decodedKey];
+      if (Array.isArray(existing)) {
+        if (decodedValue !== void 0) {
+          existing.push(decodedValue);
+        }
+      } else if (decodedValue !== void 0) {
+        if (existing === null) {
+          query[decodedKey] = [decodedValue];
+        } else {
+          query[decodedKey] = [existing, decodedValue];
+        }
+      }
+    } else if (decodedValue !== void 0) {
+      query[decodedKey] = decodedValue;
+    } else {
+      query[decodedKey] = null;
+    }
+  }
+  return query;
+}
+function stringifyQuery(query) {
+  const pairs = [];
+  for (const [key, value] of Object.entries(query)) {
+    if (value === null || value === void 0) {
+      pairs.push(encodeURIComponent(key));
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const v of value) {
+        pairs.push(`${encodeURIComponent(key)}=${v === null ? "" : encodeURIComponent(v)}`);
+      }
+    } else {
+      pairs.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+    }
+  }
+  return pairs.length ? `?${pairs.join("&")}` : "";
+}
+function resolveFullPath(path, query = {}, hash = "") {
+  const queryString = stringifyQuery(query);
+  const hashString = hash.startsWith("#") ? hash : hash ? `#${hash}` : "";
+  return `${path}${queryString}${hashString}`;
+}
+function parseFullPath(fullPath) {
+  const hashIndex = fullPath.indexOf("#");
+  const queryIndex = fullPath.indexOf("?");
+  let path;
+  let queryString = "";
+  let hash = "";
+  if (hashIndex > -1) {
+    hash = fullPath.slice(hashIndex);
+    path = fullPath.slice(0, hashIndex);
+  } else {
+    path = fullPath;
+  }
+  if (queryIndex > -1) {
+    queryString = path.slice(queryIndex);
+    path = path.slice(0, queryIndex);
+  }
+  return {
+    path: path || "/",
+    query: parseQuery(queryString),
+    hash: hash.replace(/^#/, "")
+  };
+}
+
+// src/location.ts
+function resolveLocation(raw, currentLocation, router) {
+  if (typeof raw === "string") {
+    const { path: path2, query: query2, hash: hash2 } = parseFullPath(raw);
+    return { path: path2, query: query2, hash: hash2 };
+  }
+  const { name, path, query = {}, hash = "", params } = raw;
+  if (name !== void 0 && name !== null && router) {
+    const resolved = router.resolveName(name, params);
+    if (resolved) {
+      return {
+        path: resolved.path,
+        query,
+        hash,
+        params
+      };
+    }
+  }
+  if (path !== void 0) {
+    const { path: parsedPath, query: parsedQuery, hash: parsedHash } = parseFullPath(path);
+    return {
+      path: parsedPath,
+      query: { ...parsedQuery, ...query },
+      hash: hash || parsedHash,
+      params
+    };
+  }
+  return {
+    path: currentLocation?.path || "/",
+    query,
+    hash,
+    params
+  };
+}
+function isSameRouteLocation(a, b) {
+  if (!a || !b) return false;
+  return a.path === b.path && a.hash === b.hash && JSON.stringify(a.query) === JSON.stringify(b.query);
+}
+function createRouteLocation(path, query = {}, hash = "", params = {}) {
+  return {
+    name: null,
+    path,
+    fullPath: resolveFullPath(path, query, hash),
+    query,
+    hash,
+    params,
+    matched: [],
+    meta: {}
+  };
+}
+
+// src/composables/useRouter.ts
+var currentRouter = null;
+function setCurrentRouter(router) {
+  currentRouter = router;
+}
+function useRouter() {
+  if (!currentRouter) {
+    throw new Error(
+      "[@lytjs/router] No active router instance. Make sure to call app.use(router) before using useRouter()."
+    );
+  }
+  return currentRouter;
+}
+
+// src/router.ts
+function createRouter(options) {
+  const matchers = options.routes.map((route) => normalizeRouteRecord(route));
+  const flatMatchers = flattenMatchers(matchers);
+  const currentRoute = reactivity.signal({
+    name: null,
+    path: "/",
+    fullPath: "/",
+    query: {},
+    hash: "",
+    params: {},
+    matched: [],
+    meta: {}
+  });
+  const beforeEachGuards = [];
+  const beforeResolveGuards = [];
+  const afterEachHooks = [];
+  let readyResolve = null;
+  const readyPromise = new Promise((resolve) => {
+    readyResolve = resolve;
+  });
+  let pendingNavigation = null;
+  function resolveRoute(path) {
+    let bestMatch = null;
+    let bestScore = -1;
+    let bestParams = {};
+    for (const matcher of flatMatchers) {
+      const result = matchPath(path, matcher.tokens, options.strict);
+      if (result.matched && result.score > bestScore) {
+        bestScore = result.score;
+        bestMatch = matcher;
+        bestParams = result.params;
+      }
+    }
+    if (!bestMatch) {
+      return { matched: [], params: {}, meta: {} };
+    }
+    const matched = [];
+    let current = bestMatch;
+    while (current) {
+      matched.unshift(current);
+      current = current.parent;
+    }
+    const meta = {};
+    for (const m of matched) {
+      Object.assign(meta, m.record.meta);
+    }
+    return { matched, params: bestParams, meta };
+  }
+  function resolveName(name, params) {
+    for (const matcher of flatMatchers) {
+      if (matcher.record.name === name) {
+        let path = matcher.record.path;
+        if (params) {
+          for (const [key, value] of Object.entries(params)) {
+            const paramValue = Array.isArray(value) ? value.join("/") : value;
+            path = path.replace(`:${key}`, paramValue);
+          }
+        }
+        return { path };
+      }
+    }
+    return null;
+  }
+  async function navigate(to, replace = false) {
+    const resolved = resolveLocation(to, currentRoute(), { resolveName });
+    const targetPath = resolved.path;
+    if (typeof to !== "string" && to.name !== null && to.name !== void 0 && !resolveName(to.name, to.params)) {
+      return {
+        type: 1 /* aborted */,
+        from: currentRoute(),
+        to: currentRoute()
+      };
+    }
+    const { matched, params, meta } = resolveRoute(targetPath);
+    if (matched.length === 0) {
+      return {
+        type: 1 /* aborted */,
+        from: currentRoute(),
+        to: currentRoute()
+      };
+    }
+    const lastMatched = matched[matched.length - 1];
+    const targetLocation = {
+      name: lastMatched?.record?.name ?? null,
+      path: targetPath,
+      fullPath: resolved.path + (Object.keys(resolved.query).length ? "?" + locationQueryToSearchParams(resolved.query).toString() : "") + (resolved.hash ? `#${resolved.hash}` : ""),
+      query: resolved.query,
+      hash: resolved.hash,
+      params,
+      matched: matched.map((m) => m.record),
+      meta
+    };
+    if (isSameRouteLocation(currentRoute(), targetLocation)) {
+      return {
+        type: 4 /* duplicated */,
+        from: currentRoute(),
+        to: targetLocation
+      };
+    }
+    const from = currentRoute();
+    const fromMatched = currentRoute().matched.map((record) => {
+      return flatMatchers.find((m) => m.record === record);
+    }).filter((m) => m !== void 0);
+    const failure = await runGuardSequence(targetLocation, from, matched, fromMatched);
+    if (failure) {
+      return failure;
+    }
+    if (replace) {
+      await options.history.replace(targetLocation);
+    } else {
+      await options.history.push(targetLocation);
+    }
+    currentRoute.set(targetLocation);
+    if (options.scrollBehavior) {
+      const savedPosition = replace ? null : null;
+      const scrollPosition = options.scrollBehavior(targetLocation, from, savedPosition);
+      if (scrollPosition) {
+        if (typeof window !== "undefined") {
+          window.scrollTo(scrollPosition);
+        }
+      }
+    }
+    for (const hook of afterEachHooks) {
+      hook(targetLocation, from);
+    }
+    return;
+  }
+  async function runGuardSequence(to, from, matched, fromMatched) {
+    for (const matcher of fromMatched) {
+      const component = matcher.record.component;
+      if (component && component.beforeRouteLeave) {
+        const result = await component.beforeRouteLeave(to, from, noop);
+        if (result === false || result instanceof Error) {
+          return { type: 1 /* aborted */, from, to };
+        }
+        if (typeof result === "string" || typeof result === "object" && result !== null) {
+          return navigate(result, true);
+        }
+      }
+    }
+    for (const guard of beforeEachGuards) {
+      const result = await guard(to, from, noop);
+      if (result === false || result instanceof Error) {
+        return {
+          type: 1 /* aborted */,
+          from,
+          to
+        };
+      }
+      if (typeof result === "string" || typeof result === "object" && result !== null) {
+        return navigate(result, true);
+      }
+    }
+    for (const matcher of matched) {
+      if (matcher.record.beforeEnter) {
+        const result = await matcher.record.beforeEnter(to, from, noop);
+        if (result === false || result instanceof Error) {
+          return {
+            type: 1 /* aborted */,
+            from,
+            to
+          };
+        }
+        if (typeof result === "string" || typeof result === "object" && result !== null) {
+          return navigate(result, true);
+        }
+      }
+    }
+    for (const guard of beforeResolveGuards) {
+      const result = await guard(to, from, noop);
+      if (result === false || result instanceof Error) {
+        return {
+          type: 1 /* aborted */,
+          from,
+          to
+        };
+      }
+      if (typeof result === "string" || typeof result === "object" && result !== null) {
+        return navigate(result, true);
+      }
+    }
+    return;
+  }
+  function noop() {
+  }
+  options.history.listen((to, _from, info) => {
+    if (info.type === "pop") {
+      const { matched, params, meta } = resolveRoute(to.path);
+      const newLocation = {
+        ...to,
+        params,
+        matched: matched.map((m) => m.record),
+        meta: { ...meta, ...to.meta }
+      };
+      currentRoute.set(newLocation);
+    }
+  });
+  const router = {
+    currentRoute,
+    options,
+    resolveName,
+    async push(to) {
+      if (pendingNavigation) return pendingNavigation;
+      try {
+        pendingNavigation = navigate(to, false);
+        return await pendingNavigation;
+      } finally {
+        pendingNavigation = null;
+      }
+    },
+    async replace(to) {
+      if (pendingNavigation) return pendingNavigation;
+      try {
+        pendingNavigation = navigate(to, true);
+        return await pendingNavigation;
+      } finally {
+        pendingNavigation = null;
+      }
+    },
+    go(delta) {
+      options.history.go(delta);
+    },
+    back() {
+      this.go(-1);
+    },
+    forward() {
+      this.go(1);
+    },
+    beforeEach(guard) {
+      beforeEachGuards.push(guard);
+      return () => {
+        const index = beforeEachGuards.indexOf(guard);
+        if (index > -1) beforeEachGuards.splice(index, 1);
+      };
+    },
+    afterEach(hook) {
+      afterEachHooks.push(hook);
+      return () => {
+        const index = afterEachHooks.indexOf(hook);
+        if (index > -1) afterEachHooks.splice(index, 1);
+      };
+    },
+    beforeResolve(guard) {
+      beforeResolveGuards.push(guard);
+      return () => {
+        const index = beforeResolveGuards.indexOf(guard);
+        if (index > -1) beforeResolveGuards.splice(index, 1);
+      };
+    },
+    install(app) {
+      setCurrentRouter(router);
+      if (app.config?.globalProperties) {
+        app.config.globalProperties.$router = router;
+      }
+      if (app.provide) {
+        app.provide("__lytjs_router__", router);
+      }
+      const initialLocation = options.history.location;
+      const { matched, params, meta } = resolveRoute(initialLocation.path);
+      currentRoute.set({
+        ...initialLocation,
+        params,
+        matched: matched.map((m) => m.record),
+        meta: { ...meta, ...initialLocation.meta }
+      });
+      readyResolve?.();
+    },
+    async isReady() {
+      return readyPromise;
+    }
+  };
+  return router;
+}
+
+// src/history.ts
+function createBaseHistory(base) {
+  const listeners = [];
+  const currentLocation = createRouteLocation(base);
+  return {
+    listeners,
+    currentLocation,
+    pushState(location, _data) {
+      currentLocation.path = location.path;
+      currentLocation.fullPath = location.fullPath;
+      currentLocation.query = location.query;
+      currentLocation.hash = location.hash;
+      currentLocation.params = location.params;
+      currentLocation.matched = location.matched;
+      currentLocation.meta = location.meta;
+      currentLocation.name = location.name;
+    },
+    replaceState(location, _data) {
+      currentLocation.path = location.path;
+      currentLocation.fullPath = location.fullPath;
+      currentLocation.query = location.query;
+      currentLocation.hash = location.hash;
+      currentLocation.params = location.params;
+      currentLocation.matched = location.matched;
+      currentLocation.meta = location.meta;
+      currentLocation.name = location.name;
+    },
+    triggerListeners(to, from, info) {
+      for (const listener of listeners) {
+        listener(to, from, info);
+      }
+    }
+  };
+}
+function createWebHistory(base = "") {
+  const normalizedBase = base.startsWith("/") ? base : `/${base}`;
+  const { listeners, currentLocation, pushState, replaceState, triggerListeners } = createBaseHistory(normalizedBase);
+  function getCurrentUrl() {
+    const { pathname, search, hash: hash2 } = window.location;
+    const path2 = pathname.startsWith(normalizedBase) ? pathname.slice(normalizedBase.length) || "/" : pathname;
+    return `${path2}${search}${hash2}`;
+  }
+  const initialUrl = getCurrentUrl();
+  const { path, query, hash } = parseFullPath(initialUrl);
+  currentLocation.path = path;
+  currentLocation.fullPath = initialUrl;
+  currentLocation.query = query;
+  currentLocation.hash = hash;
+  let popStateHandler = null;
+  function setupListeners() {
+    popStateHandler = (e) => {
+      const url = getCurrentUrl();
+      const { path: path2, query: query2, hash: hash2 } = parseFullPath(url);
+      const to = createRouteLocation(path2, query2, hash2);
+      const from = { ...currentLocation };
+      pushState(to, e.state);
+      triggerListeners(to, from, { type: "pop", direction: "unknown", delta: 0 });
+    };
+    window.addEventListener("popstate", popStateHandler);
+  }
+  function destroy() {
+    if (popStateHandler) {
+      window.removeEventListener("popstate", popStateHandler);
+      popStateHandler = null;
+    }
+    listeners.length = 0;
+  }
+  function push(to) {
+    const routeLocation = typeof to === "string" ? parseFullPath(to) : to;
+    const path2 = routeLocation.path || "/";
+    const query2 = routeLocation.query || {};
+    const hash2 = routeLocation.hash || "";
+    const fullPath = resolveFullPath(path2, query2, hash2);
+    const from = { ...currentLocation };
+    const location = createRouteLocation(path2, query2, hash2);
+    pushState(location);
+    window.history.pushState(
+      { ...window.history.state, current: fullPath },
+      "",
+      `${normalizedBase}${fullPath}`
+    );
+    triggerListeners(location, from, { type: "push", direction: "forward", delta: 1 });
+    return Promise.resolve();
+  }
+  function replace(to) {
+    const routeLocation = typeof to === "string" ? parseFullPath(to) : to;
+    const path2 = routeLocation.path || "/";
+    const query2 = routeLocation.query || {};
+    const hash2 = routeLocation.hash || "";
+    const fullPath = resolveFullPath(path2, query2, hash2);
+    const from = { ...currentLocation };
+    const location = createRouteLocation(path2, query2, hash2);
+    replaceState(location);
+    window.history.replaceState(
+      { ...window.history.state, current: fullPath },
+      "",
+      `${normalizedBase}${fullPath}`
+    );
+    triggerListeners(location, from, { type: "replace", direction: "unknown", delta: 0 });
+    return Promise.resolve();
+  }
+  function go(delta) {
+    window.history.go(delta);
+  }
+  function listen(callback) {
+    listeners.push(callback);
+    return () => {
+      const index = listeners.indexOf(callback);
+      if (index > -1) listeners.splice(index, 1);
+    };
+  }
+  setupListeners();
+  return {
+    get location() {
+      return currentLocation;
+    },
+    get state() {
+      return window.history.state;
+    },
+    base: normalizedBase,
+    push,
+    replace,
+    go,
+    listen,
+    destroy
+  };
+}
+function createWebHashHistory(base = "") {
+  const normalizedBase = base.startsWith("/") ? base : `/${base}`;
+  const { listeners, currentLocation, pushState, replaceState, triggerListeners } = createBaseHistory(normalizedBase);
+  function getHash() {
+    const href = window.location.href;
+    const hashIndex = href.indexOf("#");
+    return hashIndex === -1 ? "" : href.slice(hashIndex + 1);
+  }
+  function getCurrentUrl() {
+    const hash2 = getHash();
+    if (normalizedBase !== "/" && hash2.startsWith(normalizedBase)) {
+      return hash2.slice(normalizedBase.length) || "/";
+    }
+    return hash2 || "/";
+  }
+  const initialUrl = getCurrentUrl();
+  const { path, query, hash } = parseFullPath(initialUrl);
+  currentLocation.path = path;
+  currentLocation.fullPath = initialUrl;
+  currentLocation.query = query;
+  currentLocation.hash = hash;
+  let hashChangeHandler = null;
+  function setupListeners() {
+    hashChangeHandler = () => {
+      const url = getCurrentUrl();
+      const { path: path2, query: query2, hash: hash2 } = parseFullPath(url);
+      const to = createRouteLocation(path2, query2, hash2);
+      const from = { ...currentLocation };
+      pushState(to);
+      triggerListeners(to, from, { type: "pop", direction: "unknown", delta: 0 });
+    };
+    window.addEventListener("hashchange", hashChangeHandler);
+  }
+  function destroy() {
+    if (hashChangeHandler) {
+      window.removeEventListener("hashchange", hashChangeHandler);
+      hashChangeHandler = null;
+    }
+    listeners.length = 0;
+  }
+  function push(to) {
+    const routeLocation = typeof to === "string" ? parseFullPath(to) : to;
+    const path2 = routeLocation.path || "/";
+    const query2 = routeLocation.query || {};
+    const hash2 = routeLocation.hash || "";
+    const fullPath = resolveFullPath(path2, query2, hash2);
+    const from = { ...currentLocation };
+    const location = createRouteLocation(path2, query2, hash2);
+    pushState(location);
+    window.location.hash = `${normalizedBase}${fullPath}`;
+    triggerListeners(location, from, { type: "push", direction: "forward", delta: 1 });
+    return Promise.resolve();
+  }
+  function replace(to) {
+    const routeLocation = typeof to === "string" ? parseFullPath(to) : to;
+    const path2 = routeLocation.path || "/";
+    const query2 = routeLocation.query || {};
+    const hash2 = routeLocation.hash || "";
+    const fullPath = resolveFullPath(path2, query2, hash2);
+    const from = { ...currentLocation };
+    const location = createRouteLocation(path2, query2, hash2);
+    replaceState(location);
+    const url = window.location.href;
+    const hashIndex = url.indexOf("#");
+    const base2 = hashIndex === -1 ? url : url.slice(0, hashIndex);
+    window.location.replace(`${base2}#${normalizedBase}${fullPath}`);
+    triggerListeners(location, from, { type: "replace", direction: "unknown", delta: 0 });
+    return Promise.resolve();
+  }
+  function go(delta) {
+    window.history.go(delta);
+  }
+  function listen(callback) {
+    listeners.push(callback);
+    return () => {
+      const index = listeners.indexOf(callback);
+      if (index > -1) listeners.splice(index, 1);
+    };
+  }
+  setupListeners();
+  return {
+    get location() {
+      return currentLocation;
+    },
+    get state() {
+      return null;
+    },
+    base: normalizedBase,
+    push,
+    replace,
+    go,
+    listen,
+    destroy
+  };
+}
+function createMemoryHistory(initial = "/") {
+  const { listeners, currentLocation, pushState, replaceState, triggerListeners } = createBaseHistory("/");
+  const entries = [initial];
+  let currentIndex = 0;
+  const { path, query, hash } = parseFullPath(initial);
+  currentLocation.path = path;
+  currentLocation.fullPath = initial;
+  currentLocation.query = query;
+  currentLocation.hash = hash;
+  function push(to) {
+    const { path: path2, query: query2, hash: hash2 } = typeof to === "string" ? parseFullPath(to) : { path: to.path || "/", query: to.query || {}, hash: to.hash || "" };
+    const fullPath = resolveFullPath(path2, query2, hash2);
+    const from = { ...currentLocation };
+    const location = createRouteLocation(path2, query2, hash2);
+    pushState(location);
+    entries.splice(currentIndex + 1);
+    entries.push(fullPath);
+    currentIndex = entries.length - 1;
+    triggerListeners(location, from, { type: "push", direction: "forward", delta: 1 });
+    return Promise.resolve();
+  }
+  function replace(to) {
+    const { path: path2, query: query2, hash: hash2 } = typeof to === "string" ? parseFullPath(to) : { path: to.path || "/", query: to.query || {}, hash: to.hash || "" };
+    const fullPath = resolveFullPath(path2, query2, hash2);
+    const from = { ...currentLocation };
+    const location = createRouteLocation(path2, query2, hash2);
+    replaceState(location);
+    entries[currentIndex] = fullPath;
+    triggerListeners(location, from, { type: "replace", direction: "unknown", delta: 0 });
+    return Promise.resolve();
+  }
+  function go(delta) {
+    const nextIndex = currentIndex + delta;
+    if (nextIndex >= 0 && nextIndex < entries.length) {
+      const from = { ...currentLocation };
+      currentIndex = nextIndex;
+      const { path: path2, query: query2, hash: hash2 } = parseFullPath(entries[currentIndex]);
+      const to = createRouteLocation(path2, query2, hash2);
+      pushState(to);
+      triggerListeners(to, from, {
+        type: "pop",
+        direction: delta < 0 ? "back" : "forward",
+        delta
+      });
+    }
+  }
+  function listen(callback) {
+    listeners.push(callback);
+    return () => {
+      const index = listeners.indexOf(callback);
+      if (index > -1) listeners.splice(index, 1);
+    };
+  }
+  function destroy() {
+    listeners.length = 0;
+  }
+  return {
+    get location() {
+      return currentLocation;
+    },
+    get state() {
+      return null;
+    },
+    base: "",
+    push,
+    replace,
+    go,
+    listen,
+    destroy
+  };
+}
+
+// src/composables/useRoute.ts
+function useRoute() {
+  const router = useRouter();
+  return router.currentRoute;
+}
+function useLink(options) {
+  const router = useRouter();
+  const route = useRoute();
+  const targetLocation = reactivity.computedSignal(() => {
+    return resolveLocation(options.to, route());
+  });
+  const isActive = reactivity.computedSignal(() => {
+    const target = targetLocation();
+    return route().path.startsWith(target.path);
+  });
+  const isExactActive = reactivity.computedSignal(() => {
+    return isSameRouteLocation(route(), targetLocation());
+  });
+  const href = reactivity.computedSignal(() => {
+    const loc = targetLocation();
+    const path = loc.path;
+    const query = Object.keys(loc.query).length ? "?" + locationQueryToSearchParams(loc.query).toString() : "";
+    const hash = loc.hash ? `#${loc.hash}` : "";
+    return path + query + hash;
+  });
+  function navigate(e) {
+    if (e) {
+      if (e.ctrlKey || e.metaKey || e.altKey || e.shiftKey) return;
+      if (e.defaultPrevented) return;
+      e.preventDefault();
+    }
+    if (options.replace) {
+      router.replace(options.to);
+    } else {
+      router.push(options.to);
+    }
+  }
+  return {
+    route: targetLocation,
+    href,
+    isActive,
+    isExactActive,
+    navigate
+  };
+}
+var RouterView = {
+  name: "RouterView",
+  props: {
+    name: {
+      type: String,
+      default: "default"
+    }
+  },
+  setup(props) {
+    const route = useRoute();
+    const matchedComponent = reactivity.computedSignal(() => {
+      const currentRoute = route();
+      const matched = currentRoute.matched;
+      for (const record of matched) {
+        if (record.components && record.components[props.name]) {
+          return { component: record.components[props.name], record };
+        }
+        if (record.component && props.name === "default") {
+          return { component: record.component, record };
+        }
+      }
+      return null;
+    });
+    return () => {
+      const matched = matchedComponent();
+      if (!matched) return null;
+      const { component, record } = matched;
+      const resolvedComponent = typeof component === "function" ? component() : component;
+      let routeProps = {};
+      const currentRoute = route();
+      if (record.props) {
+        if (typeof record.props === "function") {
+          routeProps = record.props(currentRoute);
+        } else if (typeof record.props === "object") {
+          routeProps = record.props;
+        } else if (record.props === true) {
+          routeProps = currentRoute.params;
+        }
+      }
+      if (resolvedComponent && typeof resolvedComponent === "object" && "setup" in resolvedComponent) {
+        return { ...resolvedComponent, props: { ...routeProps, ...resolvedComponent.props } };
+      }
+      return resolvedComponent;
+    };
+  }
+};
+var RouterLink = {
+  name: "RouterLink",
+  props: {
+    to: {
+      type: String,
+      required: true
+    },
+    replace: {
+      type: Boolean,
+      default: false
+    },
+    activeClass: {
+      type: String,
+      default: "router-link-active"
+    },
+    exactActiveClass: {
+      type: String,
+      default: "router-link-exact-active"
+    },
+    ariaCurrentValue: {
+      type: String,
+      default: "page"
+    }
+  },
+  setup(props, {
+    slots
+  }) {
+    const router = useRouter();
+    const route = useRoute();
+    const targetLocation = reactivity.computedSignal(() => {
+      return resolveLocation(props.to, route());
+    });
+    const isActive = reactivity.computedSignal(() => {
+      const target = targetLocation();
+      return route().path.startsWith(target.path);
+    });
+    const isExactActive = reactivity.computedSignal(() => {
+      return isSameRouteLocation(route(), targetLocation());
+    });
+    const href = reactivity.computedSignal(() => {
+      const loc = targetLocation();
+      const path = loc.path;
+      const query = Object.keys(loc.query).length ? "?" + locationQueryToSearchParams(loc.query).toString() : "";
+      const hash = loc.hash ? `#${loc.hash}` : "";
+      return path + query + hash;
+    });
+    function handleClick(event) {
+      if (event.ctrlKey || event.metaKey || event.altKey || event.shiftKey) return;
+      if (event.defaultPrevented) return;
+      if (event.button !== void 0 && event.button !== 0) return;
+      event.preventDefault();
+      if (props.replace) {
+        router.replace(props.to);
+      } else {
+        router.push(props.to);
+      }
+    }
+    return () => {
+      const classes = [];
+      if (isActive()) classes.push(props.activeClass);
+      if (isExactActive()) classes.push(props.exactActiveClass);
+      const linkData = {
+        tag: "a",
+        props: {
+          href: href(),
+          class: classes.join(" "),
+          "aria-current": isExactActive() ? props.ariaCurrentValue : void 0,
+          onClick: handleClick
+        },
+        children: slots?.default ? slots.default({ isActive: isActive(), isExactActive: isExactActive() }) : null
+      };
+      return linkData;
+    };
+  }
+};
+
+exports.NavigationFailureType = NavigationFailureType;
+exports.RouterLink = RouterLink;
+exports.RouterView = RouterView;
+exports.createMemoryHistory = createMemoryHistory;
+exports.createRouter = createRouter;
+exports.createWebHashHistory = createWebHashHistory;
+exports.createWebHistory = createWebHistory;
+exports.setCurrentRouter = setCurrentRouter;
+exports.useLink = useLink;
+exports.useRoute = useRoute;
+exports.useRouter = useRouter;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map