vitarx-router 0.0.1

package/dist/vitarx-router.js

@@ -0,0 +1,1223 @@
+var D = Object.defineProperty;
+var j = (e) => {
+  throw TypeError(e);
+};
+var M = (e, t, i) => t in e ? D(e, t, { enumerable: !0, configurable: !0, writable: !0, value: i }) : e[t] = i;
+var l = (e, t, i) => M(e, typeof t != "symbol" ? t + "" : t, i), B = (e, t, i) => t.has(e) || j("Cannot " + i);
+var f = (e, t, i) => (B(e, t, "read from private field"), i ? i.call(e) : t.get(e)), x = (e, t, i) => t.has(e) ? j("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, i), v = (e, t, i, n) => (B(e, t, "write to private field"), n ? n.call(e, i) : t.set(e, i), i);
+import { reactive as U, shallowReactive as G, createElement as V, LazyWidget as q, deepEqual as k, deepClone as K, Widget as J, shallowRef as Q, inject as X, provide as Z, watch as N, Fragment as tt } from "vitarx";
+var g = /* @__PURE__ */ ((e) => (e[e.success = 0] = "success", e[e.aborted = 1] = "aborted", e[e.cancelled = 2] = "cancelled", e[e.duplicated = 3] = "duplicated", e[e.not_matched = 4] = "not_matched", e[e.exception = 5] = "exception", e))(g || {});
+function T(e) {
+  return typeof e == "boolean" || typeof e == "function" || typeof e == "object" && e !== null;
+}
+function et(e) {
+  if (e.widget === void 0) return;
+  if (!("injectProps" in e)) {
+    e.injectProps = I(e, !0);
+    return;
+  }
+  const t = e.injectProps;
+  if (typeof t == "object")
+    it(t) ? nt(e, t) : st(e, t);
+  else if (T(t))
+    e.injectProps = I(e, t);
+  else
+    throw new TypeError(
+      `[Vitarx.Router][TYPE_ERROR]：${e.path} 路由线路配置的 injectProps 类型有误，它可以是布尔值、函数，亦或是一个{string:any}类型的对象。`
+    );
+}
+function it(e) {
+  return Object.keys(e).length === 1 && "default" in e;
+}
+function nt(e, t) {
+  if (!T(t.default))
+    throw new TypeError(
+      `[Vitarx.Router][TYPE_ERROR]：${e.path} 路由线路配置的 injectProps.default 类型有误，它可以是布尔值、函数，亦或是一个{string:any}类型的对象。`
+    );
+}
+function st(e, t) {
+  for (const i of Object.keys(e.widget))
+    if (i in t) {
+      if (!T(t[i]))
+        throw new TypeError(
+          `[Vitarx.Router][TYPE_ERROR]：${e.path} 路由线路配置的 injectProps.${i} 类型有误，它可以是布尔值、函数，亦或是一个{string:any}类型的对象。`
+        );
+    } else
+      t[i] = !0;
+}
+function I(e, t) {
+  const i = {};
+  for (const n of Object.keys(e.widget))
+    i[n] = t;
+  return i;
+}
+function rt(e) {
+  if (!("widget" in e)) {
+    if (e.children.length === 0)
+      throw new TypeError(
+        `[Vitarx.Router][TYPE_ERROR]：${e.path} 路由线路配置的 widget 属性缺失，它可以是函数式小部件、类小部件，亦或是一个惰性加载器。`
+      );
+    e.widget = void 0;
+    return;
+  }
+  if (typeof e.widget == "function")
+    e.widget = { default: e.widget };
+  else if (typeof e.widget == "object" && e.widget !== null) {
+    if (Object.keys(e.widget).length === 0)
+      e.widget = void 0;
+    else
+      for (const t in e.widget)
+        if (typeof e.widget[t] != "function")
+          throw new TypeError(
+            `[Vitarx.Router][TYPE_ERROR]：${e.path} 路由线路配置的 widget 命名视图 ${t} 类型有误，它可以是函数式小部件、类小部件，亦或是一个惰性加载器。`
+          );
+  } else
+    throw new TypeError(
+      `[Vitarx.Router][TYPE_ERROR]：${e.path} 路由线路配置的 widget 类型有误，它可以是函数式小部件、类小部件，亦或是一个惰性加载器。`
+    );
+}
+const F = Symbol("LazyLoader");
+function O(e) {
+  return /\{[^}]+}/.test(e);
+}
+function ot(e) {
+  const t = e.replace(/\s+/g, ""), i = /\{[\w-]+\?}/g, n = t.match(i);
+  return n ? n.length : 0;
+}
+function H(e) {
+  return "children" in e && e.children !== void 0 && e.children.length > 0;
+}
+function ct(e, t, i, n) {
+  let s = 0;
+  const r = (h, c) => {
+    const _ = t[h];
+    if (_ ? _ instanceof RegExp || (console.warn(
+      `[Vitarx.Router][WARN]：${e} 动态路径${h}变量的自定义正则表达式必须是 RegExp 类型`
+    ), t[h] = n) : t[h] = n, c)
+      return s++, `(?:(${t[h].source}))?`;
+    if (s)
+      throw new Error(
+        `[Vitarx.Router][ERROR]：动态路径 ${e} 中，可选变量 ${h} 后不能存在任何必填变量`
+      );
+    return `(${t[h].source})`;
+  }, o = e.replace(/{([^}?]+)\?}/g, (h, c) => r(c, !0)).replace(/{([^}]+)}/g, (h, c) => r(c, !1)).replace(/\//g, "\\/").replace(/\/?$/, "/?"), u = i ? "" : "i", a = e.replace(/^\/|\/$/g, "").split("/").length;
+  return {
+    regex: new RegExp(`^${o}$`, u),
+    length: a,
+    optional: s
+  };
+}
+function d(e) {
+  return e = e.replace(/\s+/g, "").replace(/\/+/g, "/"), e.length ? e === "/" || e === "/#/" ? e : e.replace(/\/$/, "") : "/";
+}
+function S(e, t) {
+  if (!O(e)) return e;
+  const i = e;
+  return e = e.replace(/{([^}]+)\?*}/g, (n, s) => {
+    const r = s.endsWith("?");
+    if (r && (s = s.slice(0, -1)), t[s] === void 0) {
+      if (r) return "";
+      throw new TypeError(
+        `[Vitarx.Router.mergePathParams] 访问路由${i}时缺少参数：${s}`
+      );
+    }
+    return String(t[s]).replace(/\s+/g, "_");
+  }), d(e);
+}
+function at(e) {
+  return typeof e == "function" && e[F];
+}
+function W(e, t) {
+  return typeof e != "string" || !e ? "" : (e = e.trim(), e.startsWith("#") ? e : `#${e}`);
+}
+function L(e) {
+  e = decodeURIComponent(e);
+  const t = new URLSearchParams(
+    e.startsWith("?") ? e.substring(1) : e
+  ), i = {};
+  return t.forEach((n, s) => i[s] = n), i;
+}
+function ht(e) {
+  const t = new URLSearchParams(e).toString();
+  return t ? `?${t}` : "";
+}
+function ut(e, t, i) {
+  let n = decodeURIComponent(e.pathname), s = decodeURIComponent(e.hash), r;
+  if (t === "path")
+    return r = L(e.search), n.startsWith(i) ? n = d(n.slice(i.length)) : n = d(n), { index: n, hash: s, query: r };
+  if (s.includes("#")) {
+    const o = s.slice(1), [u, a] = o.split("#"), [h, c] = u.split("?");
+    n = d(h || ""), s = a ? `#${a}` : "", r = L(c || "");
+  } else
+    n = i, r = L(e.search);
+  return { index: n, hash: s, query: r };
+}
+function lt(e) {
+  const t = Y(e);
+  return t && (e = e.slice(0, -t.length)), {
+    path: e,
+    suffix: t
+  };
+}
+function Y(e) {
+  const t = e.match(/^(.*?)(\.[a-zA-Z0-9]+)$/);
+  return t ? t[2] : "";
+}
+function ft(e) {
+  if (typeof e != "object" || e === null) return !1;
+  const t = [
+    "index",
+    "fullPath",
+    "path",
+    "hash",
+    "params",
+    "query",
+    "matched"
+  ];
+  for (const i of t)
+    if (!Object.prototype.hasOwnProperty.call(e, i)) return !1;
+  return !0;
+}
+function dt(e) {
+  if (e.meta = e.meta || {}, e.pattern = e.pattern || {}, e.children = e.children || [], !Array.isArray(e.children))
+    throw new TypeError(
+      `[Vitarx.Router][TYPE_ERROR]：${e.path} 路由线路配置 children 类型错误，它必须是数组类型。`
+    );
+  if (!e.path.trim())
+    throw new TypeError("[Vitarx.Router][TYPE_ERROR]：路由线路配置 path 不能为空");
+  return e.path = d(e.path), rt(e), et(e), e;
+}
+const pt = ["path", "hash", "index", "fullPath"];
+function Rt(e, t) {
+  gt(e.matched, t.matched), A(e.params, t.params), A(e.query, t.query);
+  for (const i of pt)
+    e[i] !== t[i] && (e[i] = t[i]);
+}
+function gt(e, t) {
+  for (let i = 0; i < t.length; i++)
+    e[i] !== t[i] && (e[i] = t[i]);
+  e.length > t.length && (e.length = t.length);
+}
+function A(e, t) {
+  const i = Object.keys(e), n = Object.keys(t);
+  for (const s of n)
+    t.hasOwnProperty(s) && (e[s] = t[s]);
+  for (const s in i)
+    s in t || delete e[s];
+}
+var m;
+const R = class R {
+  constructor(t) {
+    // 配置
+    l(this, "_options");
+    // 命名路由映射
+    l(this, "_namedRoutes", /* @__PURE__ */ new Map());
+    // 动态路由正则，按长度分组
+    l(this, "_dynamicRoutes", /* @__PURE__ */ new Map());
+    // 路由path映射
+    l(this, "_pathRoutes", /* @__PURE__ */ new Map());
+    // 父路由映射
+    l(this, "_parentRoute", /* @__PURE__ */ new WeakMap());
+    // 当前任务 ID
+    l(this, "_currentTaskId", null);
+    // 用于生成唯一任务 ID
+    l(this, "_taskCounter", 0);
+    /**
+     * 是否正在执行 replace 操作
+     *
+     * @private
+     */
+    l(this, "_pendingReplace", null);
+    /**
+     * 是否正在执行 push 操作
+     *
+     * @private
+     */
+    l(this, "_pendingPush", null);
+    // 滚动行为处理器
+    l(this, "_scrollBehaviorHandler");
+    // 当前路由数据
+    l(this, "_currentRouteLocation");
+    // 是否运行在浏览器端
+    l(this, "_isBrowser", typeof window < "u" && typeof window.document < "u");
+    // 滚动行为
+    l(this, "_scrollBehavior", "auto");
+    if (f(R, m))
+      throw new Error("[Vitarx.Router.constructor]：路由器实例已存在，不能创建多个实例");
+    this._options = {
+      base: "/",
+      strict: !1,
+      mode: "path",
+      scrollBehavior: "smooth",
+      suffix: !1,
+      pattern: /[\w.]+/,
+      ...t
+    }, this._options.base = `/${this._options.base.replace(/^\/+|\/+$/g, "")}`, this._currentRouteLocation = U({
+      index: this._options.base,
+      path: this._options.base,
+      hash: "",
+      fullPath: this._options.base,
+      params: {},
+      query: {},
+      matched: G([])
+    });
+  }
+  /**
+   * 获取单例实例
+   *
+   * @return {Router} - 路由器实例
+   */
+  static get instance() {
+    if (!f(R, m))
+      throw new Error("[Vitarx.Router.instance]：路由器实例未初始化");
+    return f(R, m);
+  }
+  /**
+   * 是否运行在浏览器端
+   */
+  get isBrowser() {
+    return this._isBrowser;
+  }
+  /**
+   * 滚动行为
+   *
+   * 如果options.scrollBehavior为函数，则scrollBehavior固定为auto'。
+   */
+  get scrollBehavior() {
+    return this._scrollBehavior;
+  }
+  /**
+   * 获取配置
+   *
+   * @return {Readonly<InitializedRouterOptions>} - 初始化配置
+   */
+  get options() {
+    return this._options;
+  }
+  /**
+   * 路由器模式
+   */
+  get mode() {
+    return this._options.mode;
+  }
+  /**
+   * 获取所有路由映射
+   *
+   * map键值是path，值是路由对象
+   *
+   * @return {Map<string, Route>}
+   */
+  get pathRoutes() {
+    return this._pathRoutes;
+  }
+  /**
+   * 获取所有命名路由映射
+   *
+   * map键值是name，值是路由对象
+   *
+   * @return {Map<string, Route>}
+   */
+  get namedRoutes() {
+    return this._namedRoutes;
+  }
+  /**
+   * 动态路由记录
+   *
+   * map键值是path段长度，值是Array<{regex: RegExp,route:RouteNormalized}>
+   */
+  get dynamicRoutes() {
+    return this._dynamicRoutes;
+  }
+  /**
+   * ## 获取已规范的路由表
+   *
+   * 它的内存地址始终指向的是初始化时传入的路由表，但它的数据结构是经过内部规范化处理过的。
+   *
+   * 所有嵌套`Route`的path都会被自动补全为完整的路径
+   *
+   * > 注意：不要尝试修改已规范化的路由表！请使用`removeRoute`和`addRoute`方法实现路由的变更。
+   *
+   * @return {RouteNormalized[]}
+   */
+  get routes() {
+    return this._options.routes;
+  }
+  /**
+   * 基本路径
+   */
+  get basePath() {
+    return this._options.base;
+  }
+  /**
+   * 判断路由器是否初始化完成
+   *
+   * @return {boolean} - 如果初始化完成，返回true，否则返回false
+   */
+  get initialized() {
+    return f(R, m) !== void 0;
+  }
+  /**
+   * 受支持的`path`后缀名
+   */
+  get suffix() {
+    return this._options.suffix;
+  }
+  /**
+   * 当前路由数据
+   *
+   * 它是只读的，不要在外部修改它！
+   *
+   * @return {Readonly<RouteLocation>} - 当前路由数据
+   */
+  get currentRouteLocation() {
+    return this._currentRouteLocation;
+  }
+  /**
+   * 是否处于等待状态
+   *
+   * @protected
+   */
+  get isPendingNavigation() {
+    return !!(this._pendingReplace || this._pendingPush);
+  }
+  /**
+   * 等待替换完成的数据
+   *
+   * @protected
+   */
+  get pendingReplaceData() {
+    return this._pendingReplace;
+  }
+  /**
+   * 等待跳转完成的数据
+   *
+   * @protected
+   */
+  get pendingPushData() {
+    return this._pendingPush;
+  }
+  /**
+   * 路由视图
+   *
+   * 内部方法，用于获取路由线路对应的视图元素虚拟节点。
+   *
+   * @internal
+   * @param {RouteNormalized} route - 路由对象
+   * @param {string} name - 视图名称
+   * @return {VNode<WidgetType> | undefined} - 视图元素虚拟节点
+   */
+  static routeView(t, i) {
+    const n = t.widget;
+    if (!n.hasOwnProperty(i)) return;
+    const s = n[i];
+    return at(s) ? V(q, { children: s, key: t.path }) : V(s);
+  }
+  /**
+   * 后退到上一个历史记录
+   */
+  back() {
+    return this.go(-1);
+  }
+  /**
+   * 前进到下一个历史记录
+   */
+  forward() {
+    return this.go(1);
+  }
+  /**
+   * 替换当前页面
+   *
+   * @param {RouteTarget} target - 目标
+   * @return {boolean} - 是否跳转成功，非内存模式始终返回true
+   */
+  replace(t) {
+    return typeof t == "string" ? this.navigate({ index: t, isReplace: !0 }) : (t.isReplace = !0, this.navigate(t));
+  }
+  /**
+   * 跳转到新的页面
+   *
+   * @param {RouteTarget} target - 目标
+   * @return {boolean} - 是否跳转成功，非内存模式始终返回true
+   */
+  push(t) {
+    return typeof t == "string" ? this.navigate({ index: t, isReplace: !1 }) : (t.isReplace = !1, this.navigate(t));
+  }
+  /**
+   * 删除路由
+   *
+   * @param {string} index 路由索引，如果/开头则匹配path，其他匹配name
+   * @param {boolean} isRemoveFromRoutes 是否从路由表中移除，内部递归时传递的参数，无需外部传入！
+   */
+  removeRoute(t, i = !0) {
+    const n = this.findRoute(t);
+    if (n) {
+      if (H(n))
+        for (const s of n.children)
+          this.removeRoute(s.path, !1);
+      this._pathRoutes.delete(n.path), n.name && this._namedRoutes.delete(n.name), this.removeDynamicRoute(n.path), i && this.removedFromRoutes(n);
+    }
+  }
+  /**
+   * 添加路由
+   *
+   * @param {Route} route - 路由描述对象
+   * @param {string} parent - 父路由的path或name，不传入则添加至路由表根节点
+   */
+  addRoute(t, i) {
+    if (i) {
+      const n = this.findRoute(i);
+      if (!n) throw new Error(`[Vitarx.Router.addRoute][ERROR]：父路由${i}不存在`);
+      this.registerRoute(t, n);
+    } else
+      this.registerRoute(t), this._options.routes.push(t);
+  }
+  /**
+   * 超找路由
+   *
+   * 传入的是`path`则会调用`matchRoute`方法，传入的是`name`则会调用`getNamedRoute`方法
+   *
+   * @param {RouteIndex|RouteTarget} target - 路由索引，如果index以/开头则匹配path，其他匹配name
+   * @return {RouteNormalized | undefined} - 路由对象，如果不存在则返回undefined
+   */
+  findRoute(t) {
+    const i = typeof t == "object", n = i ? t.index : t;
+    if (typeof n != "string")
+      throw new TypeError(
+        `[Vitarx.Router.getRoute][ERROR]：路由索引${t}类型错误，必须给定字符串类型`
+      );
+    if (n.startsWith("/")) {
+      const s = this.matchRoute(n);
+      return s ? (s.params && i && (t.params = Object.assign(t.params || {}, s.params)), s.route) : void 0;
+    }
+    return this.findNamedRoute(n);
+  }
+  /**
+   * 查找命名路由
+   *
+   * @param {string} name - 路由名称
+   */
+  findNamedRoute(t) {
+    return this._namedRoutes.get(t);
+  }
+  /**
+   * 初始化路由器
+   *
+   * 只能初始化一次，多次初始化无效。
+   *
+   * 如果你使用的`createRouter(options)`助手函数创建的路由器实例则无需调用该方法。
+   *
+   * @return {this} - 返回当前路由器实例
+   */
+  initialize() {
+    return f(R, m) ? this : (this.setupRoutes(this._options.routes), typeof this.options.scrollBehavior == "function" ? this._scrollBehaviorHandler = this.options.scrollBehavior : this._scrollBehavior = this.options.scrollBehavior, this.initializeRouter(), v(R, m, this), this);
+  }
+  /**
+   * 此方法用于浏览器端滚动到指定位置
+   *
+   * @param scrollTarget
+   * @protected
+   */
+  scrollTo(t) {
+    if (!(this.isBrowser || !t || typeof t != "object")) {
+      if ("el" in t) {
+        const { el: i, ...n } = t, s = typeof i == "string" ? document.querySelector(i) : i;
+        s && s instanceof Element ? s.scrollIntoView ? s.scrollIntoView({ behavior: this.scrollBehavior, ...n }) : window.scrollTo({
+          behavior: this.scrollBehavior,
+          top: s.getBoundingClientRect().top + window.scrollY,
+          // 获取元素位置并滚动
+          left: s.getBoundingClientRect().left + window.scrollX
+        }) : console.warn(`[Vitarx.Router.scrollTo][WARN]：元素${i}不存在，无法完成滚动到目标元素操作`);
+        return;
+      }
+      window.scrollTo({ behavior: this.scrollBehavior, ...t });
+    }
+  }
+  /**
+   * 获取路由的父路由
+   *
+   * @param route - 路由对象
+   * @return {RouteNormalized | undefined}
+   */
+  findParentRoute(t) {
+    return this._parentRoute.get(t);
+  }
+  /**
+   * 该方法提供给`RouterView`完成渲染时调用
+   *
+   * @internal
+   */
+  _completeViewRender() {
+  }
+  /**
+   * 完成导航
+   *
+   * 所有子类在完成导航的后续处理过后必须调用该方法！
+   *
+   * @param {RouteLocation} data - 如果是由`replace`或`push`方法发起的导航则无需传入此参数。
+   * @param {_ScrollToOptions} savedPosition - 保存的滚动位置信息，用于恢复滚动位置
+   * @protected
+   */
+  completeNavigation(t, i) {
+    const n = this._currentRouteLocation;
+    if (this._completeViewRender = () => {
+      this.onScrollBehavior(this.currentRouteLocation, n, i).then(), this.onAfterEach(this.currentRouteLocation, n);
+    }, t)
+      this.updateRouteLocation(t);
+    else if (this._pendingReplace)
+      this.updateRouteLocation(this._pendingReplace);
+    else if (this._pendingPush)
+      this.updateRouteLocation(this._pendingPush);
+    else
+      throw new Error("[Vitarx.Router.completeNavigation][ERROR]：没有处于等待状态的导航请求。");
+    this._pendingReplace = null, this._pendingPush = null;
+  }
+  /**
+   * 更新当前导航数据中的query参数
+   *
+   * 会同步更新`fullPath`
+   *
+   * @param {Record<string, string>} query - 新的query参数对象
+   * @protected
+   */
+  updateQuery(t) {
+    k(this._currentRouteLocation.query, t) || (this._currentRouteLocation.query = t, this._currentRouteLocation.fullPath = this.makeFullPath(
+      this._currentRouteLocation.path,
+      t,
+      this._currentRouteLocation.hash
+    ));
+  }
+  /**
+   * 更新当前导航数据中的hash参数
+   *
+   * 会同步更新`fullPath`
+   *
+   * @param {`#${string}` | ''} hash - 新的hash参数，如果为空则表示无hash
+   * @protected
+   */
+  updateHash(t) {
+    typeof t != "string" && console.warn(`[Vitarx.Router.updateHash][WARN]：hash值只能是字符串类型，给定${t}`);
+    const i = W(t);
+    i !== this._currentRouteLocation.hash && (this._currentRouteLocation.hash = i, this._currentRouteLocation.fullPath = this.makeFullPath(
+      this._currentRouteLocation.path,
+      this._currentRouteLocation.query,
+      i
+    ));
+  }
+  /**
+   * 路由匹配
+   *
+   *
+   * @param {string} path - 路径
+   *
+   * @return {MatchResult} 如果匹配失败则返回undefined
+   */
+  matchRoute(t) {
+    if (t = d(t), this._options.strict || (t = t.toLowerCase()), this.suffix) {
+      const { path: s, suffix: r } = lt(t);
+      if (!this.isAllowedSuffix(r))
+        return;
+      t = s;
+    }
+    if (this._pathRoutes.has(t))
+      return { route: this._pathRoutes.get(t), params: void 0 };
+    const i = t.split("/").filter(Boolean).length, n = this._dynamicRoutes.get(i);
+    if (n) {
+      t = `${t}/`;
+      for (const { regex: s, route: r } of n) {
+        const o = s.exec(t);
+        if (o) {
+          const u = {};
+          return Object.keys(r.pattern).forEach((h, c) => {
+            u[h] = o[c + 1];
+          }), { route: r, params: u };
+        }
+      }
+    }
+  }
+  /**
+   * 创建完整路径
+   *
+   * @protected
+   * @param path - 路径
+   * @param query - ?查询参数
+   * @param hash - #哈希值
+   */
+  makeFullPath(t, i, n) {
+    return n && !n.startsWith("#") && (n = `#${n}`), typeof i == "object" && (i = ht(i)), this.mode === "hash" ? d(`${this.basePath}/#${t}${i}${n}`) : d(`${this.basePath}${t}${i}${n}`);
+  }
+  /**
+   * 判断是否相同的导航请求
+   *
+   * @param to
+   * @param from
+   * @protected
+   */
+  isSameNavigate(t, i) {
+    return k(t, i);
+  }
+  /**
+   * 根据路由目标创建导航数据
+   *
+   * @param {RouteTarget} target - 路由目标
+   * @protected
+   */
+  createRouteLocation(t) {
+    if (ft(t)) return t;
+    const i = this.findRoute(t), { index: n, query: s = {}, params: r = {}, hash: o = "" } = t;
+    let u;
+    const a = [];
+    if (i) {
+      let _ = Y(n);
+      this.suffix && _ && !i.path.endsWith(_) ? u = S(i.path + _, r) : u = S(i.path, r);
+      let E = this.findParentRoute(i);
+      for (; E; )
+        E.widget && a.unshift(E), E = this.findParentRoute(E);
+      a.push(i);
+    } else
+      u = d(n);
+    const h = W(o), c = this.makeFullPath(u, s, h);
+    return {
+      index: n,
+      path: u,
+      hash: h,
+      fullPath: c,
+      params: r,
+      query: s,
+      matched: a
+    };
+  }
+  /**
+   * 触发路由前置守卫
+   *
+   * @param {DeepReadonly<RouteLocation>} to - 路由目标对象
+   * @param {DeepReadonly<RouteLocation>} from - 前路由对象
+   * @return {false | RouteTarget} - 返回false表示阻止导航，返回新的路由目标对象则表示导航到新的目标
+   */
+  onBeforeEach(t, i) {
+    var n;
+    return (n = this._options.beforeEach) == null ? void 0 : n.call(this, t, i);
+  }
+  /**
+   * 触发路由后置守卫
+   *
+   * @param {DeepReadonly<RouteLocation>} to - 路由目标对象
+   * @param {DeepReadonly<RouteLocation>} from - 前路由对象
+   */
+  onAfterEach(t, i) {
+    var n;
+    return (n = this._options.afterEach) == null ? void 0 : n.call(this, t, i);
+  }
+  /**
+   * 路由跳转的通用方法
+   *
+   * 仅供内部使用，外部请使用`push`|`replace`方法
+   *
+   * @protected
+   * @param {RouteTarget} target - 目标
+   * @return {Promise<NavigateResult>} - 是否导航成功
+   */
+  navigate(t) {
+    const i = ++this._taskCounter;
+    this._currentTaskId = i;
+    const n = () => this._currentTaskId === i, s = K(this.currentRouteLocation), r = async (o, u) => {
+      const a = this.createRouteLocation(o), h = (c = {}) => ({
+        from: s,
+        to: a,
+        status: g.success,
+        message: "导航成功",
+        redirectFrom: u ? t : void 0,
+        ...c
+      });
+      if (this.isSameNavigate(a, this.currentRouteLocation))
+        return h({
+          status: g.duplicated,
+          message: "导航到相同的路由，被系统阻止！"
+        });
+      try {
+        const c = await this.onBeforeEach(a, this.currentRouteLocation);
+        return c === !1 ? h({
+          status: g.aborted,
+          message: "导航被前置守卫钩子阻止"
+        }) : n() ? typeof c == "object" && c.index !== o.index ? (c.isReplace ?? (c.isReplace = !1), r(c, !0)) : a.matched.length ? (o.isReplace ? (this._pendingReplace = a, this.replaceHistory(a)) : (this._pendingPush = a, this.pushHistory(a)), h()) : h({
+          status: g.not_matched,
+          message: "未匹配到任何路由规则，被系统阻止！请检测目标索引是否正确。"
+        }) : h({
+          status: g.cancelled,
+          message: "已被新的导航请求替代，取消此次导航！"
+        });
+      } catch (c) {
+        return console.error("[Vitarx.Router.navigate][ERROR]：导航时捕获到了异常", c), h({
+          status: g.exception,
+          message: "导航时捕获到了异常",
+          error: c
+        });
+      }
+    };
+    return r(t, !1);
+  }
+  /**
+   * 更新路由数据
+   *
+   * @private
+   * @param {RouteLocation} newLocation - 新的路由数据对象
+   */
+  updateRouteLocation(t) {
+    Rt(this._currentRouteLocation, t);
+  }
+  /**
+   * 判断是否为允许的后缀
+   *
+   * @param suffix
+   * @private
+   */
+  isAllowedSuffix(t) {
+    return t ? this.suffix ? this.suffix === "*" ? !0 : Array.isArray(this.suffix) ? this.suffix.includes(t) : this.suffix === t : !1 : !0;
+  }
+  /**
+   * 触发滚动行为
+   *
+   * @param {RouteLocation} to - 目标导航数据对象
+   * @param {RouteLocation} from - 前导航数据对象
+   * @param {_ScrollToOptions | undefined} savedPosition - 保存的滚动位置
+   * @private
+   */
+  async onScrollBehavior(t, i, n) {
+    try {
+      if (this._scrollBehaviorHandler) {
+        const s = await this._scrollBehaviorHandler(t, i, n);
+        s && this.scrollTo(s);
+      } else
+        this.scrollTo(n);
+    } catch (s) {
+      console.error("[Vitarx.Router.onScrollBehavior]['ERROR']：处理滚动行为时捕获到了异常", s);
+    }
+  }
+  /**
+   * 从源路由表中删除路由
+   *
+   * @param route
+   * @protected
+   */
+  removedFromRoutes(t) {
+    const i = this.findParentRoute(t);
+    if (i != null && i.children) {
+      const n = i.children.indexOf(t);
+      n !== -1 && i.children.splice(n, 1);
+    } else {
+      const n = this._options.routes.indexOf(t);
+      n !== -1 && this._options.routes.splice(n, 1);
+    }
+  }
+  /**
+   * 删除动态路由映射
+   *
+   * @param path
+   * @protected
+   */
+  removeDynamicRoute(t) {
+    if (!O(t)) return;
+    const n = t.split("/").filter(Boolean).length, s = (o) => {
+      const u = this._dynamicRoutes.get(o);
+      if (u) {
+        for (let a = 0; a < u.length; a++)
+          if (u[a].route.path === t) {
+            u.splice(a, 1);
+            break;
+          }
+      }
+    };
+    s(n);
+    const r = ot(t);
+    if (r > 0)
+      for (let o = 1; o <= r; o++)
+        s(n - o);
+  }
+  /**
+   * 初始化路由表
+   *
+   * @param routes
+   */
+  setupRoutes(t) {
+    for (const i of t)
+      this.registerRoute(i);
+  }
+  /**
+   * 注册路由
+   *
+   * @param {Route} route - 路由对象
+   * @param {RouteNormalized} group - 路由所在的分组
+   * @protected
+   */
+  registerRoute(t, i) {
+    const n = dt(t);
+    if (i && (n.path = d(`${i.path}${n.path}`), this._parentRoute.set(n, i)), H(n)) {
+      t.widget && this.recordRoute(n);
+      for (const s of n.children)
+        this.registerRoute(s, n);
+    } else
+      this.recordRoute(n);
+  }
+  /**
+   * 如果路径是严格匹配，则转换为小写
+   *
+   * @param path
+   * @private
+   */
+  strictPath(t) {
+    return this._options.strict ? t : t.toLowerCase();
+  }
+  /**
+   * 记录路由
+   *
+   * @param {Route} route - 路由对象
+   * @protected
+   */
+  recordRoute(t) {
+    if (t.name) {
+      if (t.name.startsWith("/") && (t.name = t.name.replace(/^\//, ""), console.warn(
+        `[Vitarx.Router][WARN]：命名路由(name)不要以/开头: ${t.name}，因为内部需要使用/区分path、name`
+      )), this._namedRoutes.has(t.name))
+        throw new Error(`[Vitarx.Router][ERROR]：检测到重复的路由名称(name): ${t.name}`);
+      this._namedRoutes.set(t.name, t);
+    }
+    const i = this.strictPath(t.path);
+    if (this._pathRoutes.has(i))
+      throw new Error(`[Vitarx.Router][ERROR]：检测到重复的路由路径(path): ${t.path}`);
+    this._pathRoutes.set(i, t), O(t.path) && this.recordDynamicRoute(t);
+  }
+  /**
+   * 添加动态路由
+   * @param route
+   */
+  recordDynamicRoute(t) {
+    const { regex: i, length: n, optional: s } = ct(
+      t.path,
+      t.pattern,
+      this.options.strict,
+      this.options.pattern
+    ), r = (o) => {
+      this._dynamicRoutes.has(o) || this._dynamicRoutes.set(o, []), this._dynamicRoutes.get(o).push({ regex: i, route: t });
+    };
+    if (r(n), s > 0)
+      for (let o = 1; o <= s; o++)
+        r(n - o);
+  }
+};
+m = new WeakMap(), /**
+ * 路由器实例，单例模式，用于全局获取路由器实例
+ */
+x(R, m);
+let p = R;
+class mt extends p {
+  constructor(t) {
+    super(t), ["path", "hash"].includes(t.mode) && (t.mode = "path"), t.mode === "hash" && this.ensureHash();
+  }
+  /**
+   * 当前路由目标
+   *
+   * @returns {RouteTarget} - 包含 index、hash 和 query 的对象
+   */
+  get currentRouteTarget() {
+    return ut(window.location, this.mode, this.basePath);
+  }
+  /**
+   * window.history
+   *
+   * @private
+   */
+  get webHistory() {
+    return window.history;
+  }
+  /**
+   * @inheritDoc
+   */
+  go(t) {
+    this.webHistory.go(t);
+  }
+  /**
+   * @inheritDoc
+   */
+  initializeRouter() {
+    window.addEventListener("popstate", this.onPopState.bind(this)), this.replace(this.currentRouteTarget).then();
+  }
+  /**
+   * @inheritDoc
+   */
+  pushHistory(t) {
+    this.saveCurrentScrollPosition(), this.webHistory.pushState(this.createState(t), "", t.fullPath), this.completeNavigation(t);
+  }
+  /**
+   * @inheritDoc
+   */
+  replaceHistory(t) {
+    var n;
+    const i = (n = this.webHistory.state) == null ? void 0 : n.scrollPosition;
+    this.webHistory.replaceState(this.createState(t), "", t.fullPath), this.completeNavigation(t, i);
+  }
+  /**
+   * 保存当前页面滚动位置
+   *
+   * @private
+   */
+  saveCurrentScrollPosition() {
+    const t = {
+      left: window.scrollX,
+      top: window.scrollY,
+      behavior: this.scrollBehavior
+    };
+    this.webHistory.replaceState(
+      {
+        ...this.webHistory.state,
+        scrollPosition: t
+      },
+      "",
+      window.location.href
+    );
+  }
+  /**
+   * 创建历史记录状态
+   *
+   * 用于在浏览器历史记录中存储路由信息，以支持前进、后退等操作。
+   *
+   * @param data - 路由数据
+   * @param hash - 要替换的哈希值
+   * @param query - 要替换的查询参数
+   * @private
+   */
+  createState(t, i, n) {
+    const { matched: s, ...r } = t;
+    return typeof i == "string" && (r.hash = i), typeof n == "object" && (r.query = n), JSON.parse(JSON.stringify(r));
+  }
+  /**
+   * 处理浏览器历史记录的返回/前进事件
+   */
+  onPopState(t) {
+    var n;
+    let i;
+    (n = t.state) != null && n.index ? i = {
+      index: t.state.index,
+      hash: t.state.hash,
+      query: t.state.query
+    } : i = this.currentRouteTarget, this.replace(i).then((s) => {
+      if (!s.redirectFrom && s.status === g.not_matched && this.mode === "hash" && s.to.index.startsWith("/")) {
+        const r = s.to.index.slice(1), o = window.document.getElementById(r);
+        o && o.scrollIntoView({ behavior: this.scrollBehavior }), this.updateHash(`#${r}`), this.webHistory.replaceState(this.createState(s.from), "", s.from.fullPath);
+      }
+    });
+  }
+  /**
+   * 确保路径是 hash 格式
+   *
+   * @private
+   */
+  ensureHash() {
+    const { pathname: t, search: i, hash: n } = window.location;
+    if (!t.startsWith(this.basePath)) {
+      const s = `${this.basePath}/#${t}${i}${n}`;
+      return window.location.replace(s);
+    }
+  }
+}
+class C extends p {
+  constructor(i) {
+    super(i);
+    // 路由历史记录数组
+    l(this, "_history", []);
+    // 标记是否有go方法触发的导航
+    l(this, "_pendingGo", null);
+    /// 当前历史路由索引
+    l(this, "_currentIndex", 0);
+    i.mode = "memory";
+  }
+  /**
+   * 当前历史路由索引
+   *
+   * @protected
+   */
+  get currentIndex() {
+    return this._currentIndex;
+  }
+  /**
+   * @inheritDoc
+   */
+  go(i) {
+    if (!i) return;
+    const n = this.currentIndex, s = Math.max(0, Math.min(this._history.length - 1, n + i));
+    if (s === n) return;
+    const r = this._history[s];
+    this._pendingGo = s, this.navigate(r).then((o) => {
+      o.status !== g.success && (this._pendingGo = null);
+    });
+  }
+  /**
+   * @inheritDoc
+   */
+  initializeRouter() {
+    this._history.push(this.currentRouteLocation);
+  }
+  /**
+   * 添加历史记录
+   */
+  pushHistory(i) {
+    this._updateHistory(i, !1);
+  }
+  /**
+   * 替换历史记录
+   */
+  replaceHistory(i) {
+    this._updateHistory(i, !0);
+  }
+  /**
+   * 更新历史记录
+   *
+   * @param {RouteLocation} data - 目标路由
+   * @param {boolean} isReplace - 是否为替换操作
+   * @private
+   */
+  _updateHistory(i, n) {
+    let s;
+    if (this._pendingGo !== null)
+      this._history[this._pendingGo] = i, s = this._pendingGo;
+    else if (n)
+      this._history[this.currentIndex] = i, s = this.currentIndex;
+    else {
+      const r = this.currentIndex + 1;
+      r < this._history.length ? (this._history[r] = i, this._history.length = r + 1, s = r) : (this._history.push(i), s = this._history.length - 1);
+    }
+    this._currentIndex = s, this.completeNavigation(i), this._pendingGo = null;
+  }
+}
+function _t(...e) {
+  return e;
+}
+function xt(e) {
+  return e;
+}
+function Pt(e) {
+  let t;
+  return !(window != null && window.location) && e.mode !== "memory" ? (console.warn("当前环境非浏览器端，强制使用内存模式路由"), e.mode = "memory", new C(e).initialize()) : (e.mode === "memory" ? t = new C(e) : t = new mt(e), t.initialize());
+}
+function Et() {
+  return p.instance;
+}
+function vt() {
+  return p.instance.currentRouteLocation;
+}
+function bt(e) {
+  return e[F] = !0, e;
+}
+var $, y, w, P;
+const b = class b extends J {
+  constructor(i) {
+    super(i);
+    // 自身index
+    x(this, y);
+    // 当前匹配的路由配置
+    x(this, w);
+    // 当前视图元素
+    x(this, P, Q());
+    const n = X(f(b, $), -1, this);
+    v(this, y, n + 1), Z(f(b, $), f(this, y), this), v(this, w, this.matchedRoute), f(this, w) && (f(this, P).value = p.routeView(f(this, w), this.name)), N(this.location.matched, (s, r) => {
+      const o = r[this.index];
+      o !== f(this, w) && (v(this, w, o), f(this, P).value = o ? p.routeView(o, this.name) : void 0);
+    });
+  }
+  /**
+   * 当前路由器视图所在层级索引
+   *
+   * `index`的值从0开始，它与`RouteLocation.matched`数组下标一一对应
+   */
+  get index() {
+    return f(this, y);
+  }
+  /**
+   * 是否为最后一个路由视图
+   */
+  get isLastView() {
+    return this.index === this.location.matched.length - 1 && this.name === "default";
+  }
+  /**
+   * 视图名称
+   *
+   * @default 'default'
+   */
+  get name() {
+    return this.props.name || "default";
+  }
+  get matchedRoute() {
+    return this.location.matched[f(this, y)];
+  }
+  /**
+   * 当前路由器视图要显示的虚拟节点
+   *
+   * 注意未匹配时会返回`undefined`，匹配成功时返回的是`VNode<WidgetType>`
+   *
+   * @protected
+   */
+  get currentElement() {
+    return f(this, P).value;
+  }
+  /**
+   * 当前的路由位置对象
+   *
+   * @protected
+   */
+  get location() {
+    return p.instance.currentRouteLocation;
+  }
+  /**
+   * @inheritDoc
+   */
+  onMounted() {
+    this.completeViewRender();
+  }
+  /**
+   * @inheritDoc
+   */
+  onUpdated() {
+    this.completeViewRender();
+  }
+  /**
+   * ## 构建视图
+   *
+   * 可以重写该方法添加自定义的视图元素
+   *
+   * 例如，使用`KeepAlive`组件缓存当前视图元素：
+   * ```tsx
+   * protected build() {
+   *   // 不可省略，因为`KeepAlive`不能渲染非组件节点。
+   *   if (!this.currentElement) return <></> // 使用空片段节点占位
+   *
+   *   // 将当前显示的视图元素(VNode<WidgetType>对象)传递给`KeepAlive`插槽，使用缓存功能。
+   *   return <KeepAlive onlyKey={this.matchedRoute?.path}>{this.currentElement}</KeepAlive>
+   * }
+   * ```
+   * @protected
+   */
+  build() {
+    return this.currentElement || V(tt);
+  }
+  /**
+   * 视图渲染完成通知路由器
+   *
+   * @private
+   */
+  completeViewRender() {
+    this.isLastView && p.instance._completeViewRender();
+  }
+};
+$ = new WeakMap(), y = new WeakMap(), w = new WeakMap(), P = new WeakMap(), x(b, $, Symbol("RouterViewCounter"));
+let z = b;
+export {
+  C as MemoryRouter,
+  g as NavigateStatus,
+  p as Router,
+  z as RouterView,
+  mt as WebHistoryRouter,
+  Pt as createRouter,
+  xt as defineRoute,
+  _t as defineRoutes,
+  bt as lazy,
+  vt as useRoute,
+  Et as useRouter
+};