@quicktvui/ai 1.0.6 → 1.0.8

package/rules/.source/ESRouter/src/router.ts

@@ -0,0 +1,1930 @@
+import registerPageRouteView from "./page/PageRouteView";
+import registerPageView from "./page/PageView";
+import registerSlotRootView from "./slot/SlotRootView";
+import registerSlotView from "./slot/SlotView";
+
+import {
+  isRouteName,
+  Lazy,
+  MatcherLocationRaw,
+  NavigationGuardWithThis,
+  NavigationHookAfter,
+  RouteLocation,
+  RouteLocationMatched,
+  RouteLocationNormalized,
+  RouteLocationNormalizedLoaded,
+  RouteLocationOptions,
+  RouteLocationRaw,
+  RouteParams,
+  RouteRecordName,
+  RouteRecordRaw,
+  START_LOCATION_NORMALIZED,
+} from "./types";
+import {
+  HistoryLocation,
+  HistoryState,
+  NavigationType,
+  RouterHistory,
+} from "./history/common";
+import {
+  _ScrollPositionNormalized,
+  computeScrollPosition,
+  getSavedScrollPosition,
+  getScrollKey,
+  saveScrollPosition,
+  ScrollPosition,
+  scrollToPosition,
+} from "./scrollBehavior";
+import { createRouterMatcher, PathParserOptions } from "./matcher";
+import {
+  createRouterError,
+  ErrorTypes,
+  isNavigationFailure,
+  NavigationFailure,
+  NavigationRedirectError,
+} from "./errors";
+import { applyToParams, assign, isArray, isBrowser, noop } from "./utils";
+import { useCallbacks } from "./utils/callbacks";
+import { decode, encodeHash, encodeParam } from "./encoding";
+import {
+  LocationQuery,
+  normalizeQuery,
+  parseQuery as originalParseQuery,
+  stringifyQuery as originalStringifyQuery,
+} from "./query";
+import {
+  App,
+  ComponentPublicInstance,
+  computed,
+  ComputedRef,
+  nextTick,
+  reactive,
+  Ref,
+  ref,
+  shallowRef,
+  unref,
+} from "vue";
+import {
+  ESRouteLaunchMode,
+  ESRouteType,
+  LifecycleState,
+  RouteRecord,
+  RouteRecordNormalized,
+} from "./matcher/types";
+import {
+  isSameRouteLocation,
+  isSameRouteRecord,
+  parseURL,
+  stringifyURL,
+} from "./location";
+import { extractComponentsGuards, guardToPromiseFn } from "./navigationGuards";
+import { warn } from "./warning";
+import { RouterLink } from "./RouterLink";
+
+import { RouterView } from "./RouterView";
+import { SlotView } from "./SlotView";
+
+import { RouteResult } from "./result/RouteResult";
+
+import {
+  nativeRouterKey,
+  navigationTypeKey,
+  routeLocationKey,
+  routerComponentInstanceKey,
+  routerHistoryKey,
+  routerKey,
+  routerRecordRawKey,
+  routerViewLocationKey,
+  routerViewNameKey,
+  routerViewInstanceKey,
+  routeViewInstancesKey,
+} from "./injectionSymbols";
+import { addDevtools } from "./devtools";
+import { createESNativeRouterForAndroid } from "./es/ESNativeRouter.android";
+import { createESNativeRouterForHarmony } from "./es/ESNativeRouter.harmony";
+import { info } from "./log/info";
+import { Native } from "@extscreen/es3-vue";
+import { triggerESLifecycle } from "@extscreen/es3-vue";
+
+/**
+ * Internal type to define an ErrorHandler
+ *
+ * @param error - error thrown
+ * @param to - location we were navigating to when the error happened
+ * @param from - location we were navigating from when the error happened
+ * @internal
+ */
+export type _ErrorHandler = (
+  error: any,
+  to: RouteLocationNormalized,
+  from: RouteLocationNormalizedLoaded,
+) => any;
+// resolve, reject arguments of Promise constructor
+type OnReadyCallback = [() => void, (reason?: any) => void];
+
+type Awaitable<T> = T | Promise<T>;
+
+/**
+ * Type of the `scrollBehavior` option that can be passed to `createRouter`.
+ */
+export interface RouterScrollBehavior {
+  /**
+   * @param to - Route location where we are navigating to
+   * @param from - Route location where we are navigating from
+   * @param savedPosition - saved position if it exists, `null` otherwise
+   */
+  (
+    to: RouteLocationNormalized,
+    from: RouteLocationNormalizedLoaded,
+    savedPosition: _ScrollPositionNormalized | null,
+  ): Awaitable<ScrollPosition | false | void>;
+}
+
+/**
+ * Options to initialize a {@link Router} instance.
+ */
+export interface RouterOptions extends PathParserOptions {
+  /**
+   * History implementation used by the router. Most web applications should use
+   * `createWebHistory` but it requires the server to be properly configured.
+   * You can also use a _hash_ based history with `createWebHashHistory` that
+   * does not require any configuration on the server but isn't handled at all
+   * by search engines and does poorly on SEO.
+   *
+   * @example
+   * ```js
+   * createRouter({
+   *   history: createWebHistory(),
+   *   // other options...
+   * })
+   * ```
+   */
+  history: RouterHistory;
+  /**
+   * Initial list of routes that should be added to the router.
+   */
+  routes: Readonly<RouteRecordRaw[]>;
+  /**
+   * Function to control scrolling when navigating between pages. Can return a
+   * Promise to delay scrolling. Check {@link ScrollBehavior}.
+   *
+   * @example
+   * ```js
+   * function scrollBehavior(to, from, savedPosition) {
+   *   // `to` and `from` are both route locations
+   *   // `savedPosition` can be null if there isn't one
+   * }
+   * ```
+   */
+  scrollBehavior?: RouterScrollBehavior;
+  /**
+   * Custom implementation to parse a query. See its counterpart,
+   * {@link RouterOptions.stringifyQuery}.
+   *
+   * @example
+   * Let's say you want to use the [qs package](https://github.com/ljharb/qs)
+   * to parse queries, you can provide both `parseQuery` and `stringifyQuery`:
+   * ```js
+   * import qs from 'qs'
+   *
+   * createRouter({
+   *   // other options...
+   *   parseQuery: qs.parse,
+   *   stringifyQuery: qs.stringify,
+   * })
+   * ```
+   */
+  parseQuery?: typeof originalParseQuery;
+  /**
+   * Custom implementation to stringify a query object. Should not prepend a leading `?`.
+   * {@link RouterOptions.parseQuery | parseQuery} counterpart to handle query parsing.
+   */
+  stringifyQuery?: typeof originalStringifyQuery;
+  /**
+   * Default class applied to active {@link RouterLink}. If none is provided,
+   * `router-link-active` will be applied.
+   */
+  linkActiveClass?: string;
+  /**
+   * Default class applied to exact active {@link RouterLink}. If none is provided,
+   * `router-link-exact-active` will be applied.
+   */
+  linkExactActiveClass?: string;
+  /**
+   * Default class applied to non-active {@link RouterLink}. If none is provided,
+   * `router-link-inactive` will be applied.
+   */
+  // linkInactiveClass?: string
+
+  /**
+   * router history stack limit number
+   */
+  limit?: number;
+
+  /**
+   * main router
+   */
+  main?: string;
+
+  /**
+   * error router
+   */
+  error?: string;
+
+  /**
+   * types
+   */
+  types: Array<ESRouteType>;
+}
+
+/**
+ * Router instance.
+ */
+export interface Router {
+  /**
+   * @internal
+   */
+  // readonly history: RouterHistory
+  /**
+   * Current {@link RouteLocationNormalized}
+   */
+  readonly currentRoute: Ref<RouteLocationNormalizedLoaded>;
+  /**
+   * Original options object passed to create the Router
+   */
+  readonly options: RouterOptions;
+
+  /**
+   * Allows turning off the listening of history events. This is a low level api for micro-frontends.
+   */
+  listening: boolean;
+
+  /**
+   * Add a new {@link RouteRecordRaw | route record} as the child of an existing route.
+   *
+   * @param parentName - Parent Route Record where `route` should be appended at
+   * @param route - Route Record to add
+   */
+  addRoute(parentName: RouteRecordName, route: RouteRecordRaw): () => void;
+
+  /**
+   * Add a new {@link RouteRecordRaw | route record} to the router.
+   *
+   * @param route - Route Record to add
+   */
+  addRoute(route: RouteRecordRaw): () => void;
+
+  /**
+   * Remove an existing route by its name.
+   *
+   * @param name - Name of the route to remove
+   */
+  removeRoute(name: RouteRecordName): void;
+
+  /**
+   * Checks if a route with a given name exists
+   *
+   * @param name - Name of the route to check
+   */
+  hasRoute(name: RouteRecordName): boolean;
+
+  /**
+   * Get a full list of all the {@link RouteRecord | route records}.
+   */
+  getRoutes(): RouteRecord[];
+
+  /**
+   *
+   */
+  getRouterHistory(): RouterHistory;
+
+  /**
+   * Get RouteRecord | route records.
+   * @param name - Name of the route to check
+   */
+  getRoute(name: RouteRecordName): RouteRecord | undefined;
+
+  /**
+   * Returns the {@link RouteLocation | normalized version} of a
+   * {@link RouteLocationRaw | route location}. Also includes an `href` property
+   * that includes any existing `base`. By default, the `currentLocation` used is
+   * `router.currentRoute` and should only be overridden in advanced use cases.
+   *
+   * @param to - Raw route location to resolve
+   * @param currentLocation - Optional current location to resolve against
+   */
+  resolve(
+    to: RouteLocationRaw,
+    currentLocation?: RouteLocationNormalizedLoaded,
+  ): RouteLocation & { href: string };
+
+  /**
+   * Programmatically navigate to a new URL by pushing an entry in the history
+   * stack.
+   *
+   * @param to - Route location to navigate to
+   */
+  push(to: RouteLocationRaw): Promise<NavigationFailure | void | undefined>;
+
+  /**
+   * Programmatically navigate to a new URL by replacing the current entry in
+   * the history stack.
+   *
+   * @param to - Route location to navigate to
+   */
+  replace(to: RouteLocationRaw): Promise<NavigationFailure | void | undefined>;
+
+  /**
+   *
+   * @param to - Route location to navigate to
+   */
+  splice(to: RouteLocationRaw): boolean;
+
+  /**
+   *
+   * @param result
+   */
+  setResult(result: RouteResult): Promise<any>;
+
+  /**
+   * Go back in history if possible by calling `history.back()`. Equivalent to
+   * `router.go(-1)`.
+   */
+  back(): ReturnType<Router["go"]>;
+
+  /**
+   * Go forward in history if possible by calling `history.forward()`.
+   * Equivalent to `router.go(1)`.
+   */
+  forward(): ReturnType<Router["go"]>;
+
+  /**
+   * Allows you to move forward or backward through the history. Calls
+   * `history.go()`.
+   *
+   * @param delta - The position in the history to which you want to move,
+   * relative to the current page
+   */
+  go(delta: number): boolean;
+
+  /**
+   * Add a navigation guard that executes before any navigation. Returns a
+   * function that removes the registered guard.
+   *
+   * @param guard - navigation guard to add
+   */
+  beforeEach(guard: NavigationGuardWithThis<undefined>): () => void;
+
+  /**
+   * Add a navigation guard that executes before navigation is about to be
+   * resolved. At this state all component have been fetched and other
+   * navigation guards have been successful. Returns a function that removes the
+   * registered guard.
+   *
+   * @example
+   * ```js
+   * router.beforeResolve(to => {
+   *   if (to.meta.requiresAuth && !isAuthenticated) return false
+   * })
+   * ```
+   *
+   * @param guard - navigation guard to add
+   */
+  beforeResolve(guard: NavigationGuardWithThis<undefined>): () => void;
+
+  /**
+   * Add a navigation hook that is executed after every navigation. Returns a
+   * function that removes the registered hook.
+   *
+   * @example
+   * ```js
+   * router.afterEach((to, from, failure) => {
+   *   if (isNavigationFailure(failure)) {
+   *     console.log('failed navigation', failure)
+   *   }
+   * })
+   * ```
+   *
+   * @param guard - navigation hook to add
+   */
+  afterEach(guard: NavigationHookAfter): () => void;
+
+  /**
+   * Adds an error handler that is called every time a non caught error happens
+   * during navigation. This includes errors thrown synchronously and
+   * asynchronously, errors returned or passed to `next` in any navigation
+   * guard, and errors occurred when trying to resolve an async component that
+   * is required to render a route.
+   *
+   * @param handler - error handler to register
+   */
+  onError(handler: _ErrorHandler): () => void;
+
+  /**
+   * Returns a Promise that resolves when the router has completed the initial
+   * navigation, which means it has resolved all async enter hooks and async
+   * components that are associated with the initial route. If the initial
+   * navigation already happened, the promise resolves immediately.
+   *
+   * This is useful in server-side rendering to ensure consistent output on both
+   * the server and the client. Note that on server side, you need to manually
+   * push the initial location while on client side, the router automatically
+   * picks it up from the URL.
+   */
+  isReady(): Promise<void>;
+
+  /**
+   * Called automatically by `app.use(router)`. Should not be called manually by
+   * the user. This will trigger the initial navigation when on client side.
+   *
+   * @internal
+   * @param app - Application that uses the router
+   */
+  install(app: App): void;
+
+  /**
+   *  当前是否处于前台
+   */
+  readonly active: boolean;
+
+  setActive(active: boolean): void;
+}
+
+/**
+ * Creates a Router instance that can be used by a Vue app.
+ *
+ * @param options - {@link RouterOptions}
+ */
+export function createRouter(options: RouterOptions): Router {
+  const matcher = createRouterMatcher(options.routes, options);
+  const parseQuery = options.parseQuery || originalParseQuery;
+  const stringifyQuery = options.stringifyQuery || originalStringifyQuery;
+  const routerHistory = options.history;
+  const routeRecordRawList: RouteLocationRaw[] = options.routes;
+  const limit: number | undefined = options.limit;
+  const routeTypes: Array<ESRouteType> = options.types;
+
+  //---------------------------------------------------------------
+  const _active = ref(true);
+
+  function getActive(): boolean {
+    return _active.value;
+  }
+
+  function setActive(active: boolean): void {
+    info("router setActive:", active);
+    _active.value = active;
+  }
+
+  //---------------------------------------------------------------
+
+  function isSupportSlotType() {
+    const index = routeTypes.findIndex(
+      (type) => type == ESRouteType.ES_ROUTE_TYPE_SLOT,
+    );
+    return index > -1;
+  }
+
+  //原生路由
+  const nativeRouter = Native.isAndroid()
+    ? createESNativeRouterForAndroid(isSupportSlotType())
+    : createESNativeRouterForHarmony(isSupportSlotType());
+
+  if (__DEV__ && !routerHistory)
+    throw new Error(
+      'Provide the "history" option when calling "createRouter()":' +
+        " https://next.router.vuejs.org/api/#history.",
+    );
+
+  const beforeGuards = useCallbacks<NavigationGuardWithThis<undefined>>();
+  const beforeResolveGuards =
+    useCallbacks<NavigationGuardWithThis<undefined>>();
+  const afterGuards = useCallbacks<NavigationHookAfter>();
+  const currentRoute = shallowRef<RouteLocationNormalizedLoaded>(
+    START_LOCATION_NORMALIZED,
+  );
+  let pendingLocation: RouteLocation = START_LOCATION_NORMALIZED;
+
+  //
+  const navigationType = shallowRef<NavigationType>(NavigationType.push);
+
+  //router view name : default
+  const routerViewName = shallowRef<string>();
+
+  //
+  const routerComponentInstance = ref<ComponentPublicInstance | undefined>();
+  const routerViewInstance = ref<ComponentPublicInstance | undefined>();
+  const routeViewInstanceList: Ref<ComponentPublicInstance | undefined>[] = [];
+  // leave the scrollRestoration if no scrollBehavior is provided
+  if (isBrowser && options.scrollBehavior && "scrollRestoration" in history) {
+    history.scrollRestoration = "manual";
+  }
+
+  const normalizeParams = applyToParams.bind(
+    null,
+    (paramValue) => "" + paramValue,
+  );
+  const encodeParams = applyToParams.bind(null, encodeParam);
+  const decodeParams: (params: RouteParams | undefined) => RouteParams =
+    // @ts-expect-error: intentionally avoid the type check
+    applyToParams.bind(null, decode);
+
+  function addRoute(
+    parentOrRoute: RouteRecordName | RouteRecordRaw,
+    route?: RouteRecordRaw,
+  ) {
+    let parent: Parameters<(typeof matcher)["addRoute"]>[1] | undefined;
+    let record: RouteRecordRaw;
+    if (isRouteName(parentOrRoute)) {
+      parent = matcher.getRecordMatcher(parentOrRoute);
+      record = route!;
+    } else {
+      record = parentOrRoute;
+    }
+
+    return matcher.addRoute(record, parent);
+  }
+
+  function removeRoute(name: RouteRecordName) {
+    const recordMatcher = matcher.getRecordMatcher(name);
+    if (recordMatcher) {
+      matcher.removeRoute(recordMatcher);
+    } else if (__DEV__) {
+      warn(`Cannot remove non-existent route "${String(name)}"`);
+    }
+  }
+
+  function getRoutes() {
+    return matcher.getRoutes().map((routeMatcher) => routeMatcher.record);
+  }
+
+  function getRouterHistory() {
+    return routerHistory;
+  }
+
+  function getRoute(name: RouteRecordName) {
+    const routeRecordMatcher = matcher.getRecordMatcher(name);
+    if (routeRecordMatcher) {
+      return routeRecordMatcher.record;
+    }
+    return undefined;
+  }
+
+  function hasRoute(name: RouteRecordName): boolean {
+    return !!matcher.getRecordMatcher(name);
+  }
+
+  function resolve(
+    rawLocation: Readonly<RouteLocationRaw>,
+    currentLocation?: RouteLocationNormalizedLoaded,
+  ): RouteLocation & { href: string } {
+    //
+    let key: string = new Date().getTime().toString();
+
+    // const objectLocation = routerLocationAsObject(rawLocation)
+    // we create a copy to modify it later
+    currentLocation = assign({}, currentLocation || currentRoute.value);
+    if (typeof rawLocation === "string") {
+      const locationNormalized = parseURL(
+        parseQuery,
+        rawLocation,
+        currentLocation.path,
+      );
+      const matchedRoute = matcher.resolve(
+        { path: locationNormalized.path },
+        currentLocation,
+      );
+
+      const href = routerHistory.createHref(locationNormalized.fullPath);
+      if (__DEV__) {
+        if (href.startsWith("//"))
+          warn(
+            `Location "${rawLocation}" resolved to "${href}". A resolved location cannot start with multiple slashes.`,
+          );
+        else if (!matchedRoute.matched.length) {
+          warn(`No match found for location with path "${rawLocation}"`);
+        }
+      }
+
+      // locationNormalized is always a new object
+      return assign(locationNormalized, matchedRoute, {
+        key: key,
+        params: decodeParams(matchedRoute.params),
+        hash: decode(locationNormalized.hash),
+        redirectedFrom: undefined,
+        href,
+      });
+    }
+
+    let matcherLocation: MatcherLocationRaw;
+
+    // path could be relative in object as well
+    if ("path" in rawLocation) {
+      if (
+        __DEV__ &&
+        "params" in rawLocation &&
+        !("name" in rawLocation) &&
+        // @ts-expect-error: the type is never
+        Object.keys(rawLocation.params).length
+      ) {
+        warn(
+          `Path "${rawLocation.path}" was passed with params but they will be ignored. Use a named route alongside params instead.`,
+        );
+      }
+      matcherLocation = assign({}, rawLocation, {
+        path: parseURL(parseQuery, rawLocation.path, currentLocation.path).path,
+      });
+    } else {
+      // remove any nullish param
+      const targetParams = assign({}, rawLocation.params);
+      for (const key in targetParams) {
+        if (targetParams[key] == null) {
+          delete targetParams[key];
+        }
+      }
+      // pass encoded values to the matcher, so it can produce encoded path and fullPath
+      matcherLocation = assign({}, rawLocation, {
+        params: encodeParams(targetParams),
+      });
+      // current location params are decoded, we need to encode them in case the
+      // matcher merges the params
+      currentLocation.params = encodeParams(currentLocation.params);
+    }
+
+    const matchedRoute = matcher.resolve(matcherLocation, currentLocation);
+    const hash = rawLocation.hash || "";
+
+    if (__DEV__ && hash && !hash.startsWith("#")) {
+      warn(
+        `A \`hash\` should always start with the character "#". Replace "${hash}" with "#${hash}".`,
+      );
+    }
+
+    // the matcher might have merged current location params, so
+    // we need to run the decoding again
+    matchedRoute.params = normalizeParams(decodeParams(matchedRoute.params));
+
+    const fullPath = stringifyURL(
+      stringifyQuery,
+      assign({}, rawLocation, {
+        hash: encodeHash(hash),
+        path: matchedRoute.path,
+      }),
+    );
+
+    const href = routerHistory.createHref(fullPath);
+    if (__DEV__) {
+      if (href.startsWith("//")) {
+        warn(
+          `Location "${rawLocation}" resolved to "${href}". A resolved location cannot start with multiple slashes.`,
+        );
+      } else if (!matchedRoute.matched.length) {
+        warn(
+          `No match found for location with path "${
+            "path" in rawLocation ? rawLocation.path : rawLocation
+          }"`,
+        );
+      }
+    }
+
+    let resultCallback = {};
+
+    if (typeof rawLocation === "object") {
+      const rawKey = (rawLocation as RouteLocationOptions).key;
+      if (rawKey) {
+        key = rawKey;
+      }
+      //
+      const callback = (rawLocation as RouteLocationOptions).resultCallback;
+      if (callback) {
+        resultCallback = {
+          resultCallback: callback,
+        };
+      }
+    }
+
+    /**
+     * TODO LIULIPENG 参数转换
+     */
+    return assign(
+      {
+        key: key,
+        fullPath,
+        // keep the hash encoded so fullPath is effectively path + encodedQuery +
+        // hash
+        hash,
+        query:
+          // if the user is using a custom query lib like qs, we might have
+          // nested objects, so we keep the query as is, meaning it can contain
+          // numbers at `$route.query`, but at the point, the user will have to
+          // use their own type anyway.
+          // https://github.com/vuejs/router/issues/328#issuecomment-649481567
+          stringifyQuery === originalStringifyQuery
+            ? normalizeQuery(rawLocation.query)
+            : ((rawLocation.query || {}) as LocationQuery),
+      },
+      matchedRoute,
+      {
+        redirectedFrom: undefined,
+        href,
+      },
+      resultCallback,
+    );
+  }
+
+  function locationAsObject(
+    to: RouteLocationRaw | RouteLocationNormalized,
+  ): Exclude<RouteLocationRaw, string> | RouteLocationNormalized {
+    return typeof to === "string"
+      ? parseURL(parseQuery, to, currentRoute.value.path)
+      : assign({}, to);
+  }
+
+  function checkCanceledNavigation(
+    to: RouteLocationNormalized,
+    from: RouteLocationNormalized,
+  ): NavigationFailure | void {
+    if (pendingLocation !== to) {
+      return createRouterError<NavigationFailure>(
+        ErrorTypes.NAVIGATION_CANCELLED,
+        {
+          from,
+          to,
+        },
+      );
+    }
+  }
+
+  function setResult(result: RouteResult): Promise<any> {
+    try {
+      const historyLocationList = routerHistory.getHistoryLocations();
+      if (historyLocationList && historyLocationList.length > 0) {
+        const topHistoryLocation: HistoryLocation =
+          historyLocationList[historyLocationList.length - 1];
+        console.log(
+          "ESRouter:setResult: route:",
+          topHistoryLocation.location,
+          " lifecycle:" + topHistoryLocation.lifecycle,
+        );
+        if (topHistoryLocation && topHistoryLocation.resultCallback) {
+          const ret = topHistoryLocation.resultCallback.onResult(result);
+          console.log("ESRouter:setResult: onResult:", ret);
+          if (ret instanceof Promise) {
+            return ret as Promise<any>;
+          }
+          return Promise.resolve();
+        } else {
+          console.log("ESRouter:setResult: resultCallback is null ...");
+        }
+      }
+    } catch (e) {
+      console.log("ESRouter:setResult: error", e);
+    }
+    return Promise.reject();
+  }
+
+  function push(to: RouteLocationRaw) {
+    navigationType.value = NavigationType.push;
+    return pushWithRedirect(to);
+  }
+
+  function replace(to: RouteLocationRaw) {
+    navigationType.value = NavigationType.pop;
+    return push(assign(locationAsObject(to), { replace: true }));
+  }
+
+  function splice(to: RouteLocationRaw): boolean {
+    navigationType.value = NavigationType.splice;
+    const targetLocation: RouteLocation = (pendingLocation = resolve(to));
+    const toLocation = targetLocation as RouteLocationNormalized;
+    const location = resolveHistoryLocation(
+      toLocation.key,
+      toLocation.fullPath,
+      toLocation.resultCallback,
+    );
+    //
+    let ret = routerHistory.splice(location);
+    console.log("ESRouter:splice location: ", location, "result:" + ret);
+    return ret;
+  }
+
+  function handleRedirectRecord(to: RouteLocation): RouteLocationRaw | void {
+    const lastMatched = to.matched[to.matched.length - 1];
+    if (lastMatched && lastMatched.redirect) {
+      const { redirect } = lastMatched;
+      let newTargetLocation =
+        typeof redirect === "function" ? redirect(to) : redirect;
+
+      if (typeof newTargetLocation === "string") {
+        newTargetLocation =
+          newTargetLocation.includes("?") || newTargetLocation.includes("#")
+            ? (newTargetLocation = locationAsObject(newTargetLocation))
+            : // force empty params
+              { path: newTargetLocation };
+        // @ts-expect-error: force empty params when a string is passed to let
+        // the router parse them again
+        newTargetLocation.params = {};
+      }
+
+      if (
+        __DEV__ &&
+        !("path" in newTargetLocation) &&
+        !("name" in newTargetLocation)
+      ) {
+        warn(
+          `Invalid redirect found:\n${JSON.stringify(
+            newTargetLocation,
+            null,
+            2,
+          )}\n when navigating to "${
+            to.fullPath
+          }". A redirect must contain a name or path. This will break in production.`,
+        );
+        throw new Error("Invalid redirect");
+      }
+
+      return assign(
+        {
+          query: to.query,
+          hash: to.hash,
+          // avoid transferring params if the redirect has a path
+          params: "path" in newTargetLocation ? {} : to.params,
+        },
+        newTargetLocation,
+      );
+    }
+  }
+
+  function pushWithRedirect(
+    to: RouteLocationRaw | RouteLocation,
+    redirectedFrom?: RouteLocation,
+  ): Promise<NavigationFailure | void | undefined> {
+    const targetLocation: RouteLocation = (pendingLocation = resolve(to));
+    const from = currentRoute.value;
+    const data: HistoryState | undefined = (to as RouteLocationOptions).state;
+    const force: boolean | undefined = (to as RouteLocationOptions).force;
+    // to could be a string where `replace` is a function
+    const replace = (to as RouteLocationOptions).replace === true;
+
+    const shouldRedirect = handleRedirectRecord(targetLocation);
+
+    if (shouldRedirect)
+      return pushWithRedirect(
+        assign(locationAsObject(shouldRedirect), {
+          state:
+            typeof shouldRedirect === "object"
+              ? assign({}, data, shouldRedirect.state)
+              : data,
+          force,
+          replace,
+        }),
+        // keep original redirectedFrom if it exists
+        redirectedFrom || targetLocation,
+      );
+
+    // if it was a redirect we already called `pushWithRedirect` above
+    const toLocation = targetLocation as RouteLocationNormalized;
+
+    toLocation.redirectedFrom = redirectedFrom;
+    let failure: NavigationFailure | void | undefined;
+    return (failure ? Promise.resolve(failure) : navigate(toLocation, from))
+      .catch((error: NavigationFailure | NavigationRedirectError) =>
+        isNavigationFailure(error)
+          ? // navigation redirects still mark the router as ready
+            isNavigationFailure(error, ErrorTypes.NAVIGATION_GUARD_REDIRECT)
+            ? error
+            : markAsReady(error) // also returns the error
+          : // reject any unknown error
+            triggerError(error, toLocation, from),
+      )
+      .then((failure: NavigationFailure | NavigationRedirectError | void) => {
+        if (failure) {
+          if (
+            isNavigationFailure(failure, ErrorTypes.NAVIGATION_GUARD_REDIRECT)
+          ) {
+            if (
+              __DEV__ &&
+              // we are redirecting to the same location we were already at
+              isSameRouteLocation(
+                stringifyQuery,
+                resolve(failure.to),
+                toLocation,
+              ) &&
+              // and we have done it a couple of times
+              redirectedFrom &&
+              // @ts-expect-error: added only in dev
+              (redirectedFrom._count = redirectedFrom._count
+                ? // @ts-expect-error
+                  redirectedFrom._count + 1
+                : 1) > 30
+            ) {
+              warn(
+                `Detected a possibly infinite redirection in a navigation guard when going from "${from.fullPath}" to "${toLocation.fullPath}". Aborting to avoid a Stack Overflow.\n Are you always returning a new location within a navigation guard? That would lead to this error. Only return when redirecting or aborting, that should fix this. This might break in production if not fixed.`,
+              );
+              return Promise.reject(
+                new Error("Infinite redirect in navigation guard"),
+              );
+            }
+
+            return pushWithRedirect(
+              // keep options
+              assign(
+                {
+                  // preserve an existing replacement but allow the redirect to override it
+                  replace,
+                },
+                locationAsObject(failure.to),
+                {
+                  state:
+                    typeof failure.to === "object"
+                      ? assign({}, data, failure.to.state)
+                      : data,
+                  force,
+                },
+              ),
+              // preserve the original redirectedFrom if any
+              redirectedFrom || toLocation,
+            );
+          }
+        } else {
+          // if we fail we don't finalize the navigation
+          failure = finalizeNavigation(
+            toLocation as RouteLocationNormalizedLoaded,
+            from,
+            true,
+            replace,
+            data,
+          );
+        }
+        triggerAfterEach(
+          toLocation as RouteLocationNormalizedLoaded,
+          from,
+          failure,
+        );
+        return failure;
+      });
+  }
+
+  /**
+   * Helper to reject and skip all navigation guards if a new navigation happened
+   * @param to
+   * @param from
+   */
+  function checkCanceledNavigationAndReject(
+    to: RouteLocationNormalized,
+    from: RouteLocationNormalized,
+  ): Promise<void> {
+    const error = checkCanceledNavigation(to, from);
+    return error ? Promise.reject(error) : Promise.resolve();
+  }
+
+  function runWithContext<T>(fn: () => T): T {
+    const app: App | undefined = installedApps.values().next().value;
+    // support Vue < 3.3
+    return app && typeof app.runWithContext === "function"
+      ? app.runWithContext(fn)
+      : fn();
+  }
+
+  // TODO: refactor the whole before guards by internally using router.beforeEach
+
+  function navigate(
+    to: RouteLocationNormalized,
+    from: RouteLocationNormalizedLoaded,
+  ): Promise<any> {
+    let guards: Lazy<any>[];
+
+    const [leavingRecords, updatingRecords, enteringRecords] =
+      extractChangingRecords(to, from);
+
+    // all components here have been resolved once because we are leaving
+    guards = extractComponentsGuards(
+      leavingRecords.reverse(),
+      "beforeRouteLeave",
+      to,
+      from,
+    );
+
+    // leavingRecords is already reversed
+    for (const record of leavingRecords) {
+      record.leaveGuards.forEach((guard) => {
+        guards.push(guardToPromiseFn(guard, to, from));
+      });
+    }
+
+    const canceledNavigationCheck = checkCanceledNavigationAndReject.bind(
+      null,
+      to,
+      from,
+    );
+
+    guards.push(canceledNavigationCheck);
+
+    // run the queue of per route beforeRouteLeave guards
+    return (
+      runGuardQueue(guards)
+        .then(() => {
+          // check global guards beforeEach
+          guards = [];
+          for (const guard of beforeGuards.list()) {
+            guards.push(guardToPromiseFn(guard, to, from));
+          }
+          guards.push(canceledNavigationCheck);
+
+          return runGuardQueue(guards);
+        })
+        .then(() => {
+          // check in components beforeRouteUpdate
+          guards = extractComponentsGuards(
+            updatingRecords,
+            "beforeRouteUpdate",
+            to,
+            from,
+          );
+
+          for (const record of updatingRecords) {
+            record.updateGuards.forEach((guard) => {
+              guards.push(guardToPromiseFn(guard, to, from));
+            });
+          }
+          guards.push(canceledNavigationCheck);
+
+          // run the queue of per route beforeEnter guards
+          return runGuardQueue(guards);
+        })
+        .then(() => {
+          // check the route beforeEnter
+          guards = [];
+          for (const record of to.matched) {
+            // do not trigger beforeEnter on reused views
+            if (record.beforeEnter && !from.matched.includes(record)) {
+              if (isArray(record.beforeEnter)) {
+                for (const beforeEnter of record.beforeEnter)
+                  guards.push(guardToPromiseFn(beforeEnter, to, from));
+              } else {
+                guards.push(guardToPromiseFn(record.beforeEnter, to, from));
+              }
+            }
+          }
+          guards.push(canceledNavigationCheck);
+
+          // run the queue of per route beforeEnter guards
+          return runGuardQueue(guards);
+        })
+        .then(() => {
+          // NOTE: at this point to.matched is normalized and does not contain any () => Promise<Component>
+
+          // clear existing enterCallbacks, these are added by extractComponentsGuards
+          to.matched.forEach((record) => (record.enterCallbacks = {}));
+
+          // check in-component beforeRouteEnter
+          guards = extractComponentsGuards(
+            enteringRecords,
+            "beforeRouteEnter",
+            to,
+            from,
+          );
+          guards.push(canceledNavigationCheck);
+
+          // run the queue of per route beforeEnter guards
+          return runGuardQueue(guards);
+        })
+        .then(() => {
+          // check global guards beforeResolve
+          guards = [];
+          for (const guard of beforeResolveGuards.list()) {
+            guards.push(guardToPromiseFn(guard, to, from));
+          }
+          guards.push(canceledNavigationCheck);
+
+          return runGuardQueue(guards);
+        })
+        // catch any navigation canceled
+        .catch((err) =>
+          isNavigationFailure(err, ErrorTypes.NAVIGATION_CANCELLED)
+            ? err
+            : Promise.reject(err),
+        )
+    );
+  }
+
+  function triggerAfterEach(
+    to: RouteLocationNormalizedLoaded,
+    from: RouteLocationNormalizedLoaded,
+    failure?: NavigationFailure | void,
+  ): void {
+    // navigation is confirmed, call afterGuards
+    // TODO: wrap with error handlers
+    for (const guard of afterGuards.list()) {
+      runWithContext(() => guard(to, from, failure));
+    }
+  }
+
+  /**
+   * - Cleans up any navigation guards
+   * - Changes the url if necessary
+   * - Calls the scrollBehavior
+   */
+  function finalizeNavigation(
+    toLocation: RouteLocationNormalizedLoaded,
+    from: RouteLocationNormalizedLoaded,
+    isPush: boolean,
+    replace?: boolean,
+    data?: HistoryState,
+  ): NavigationFailure | void {
+    // a more recent navigation took place
+    const error = checkCanceledNavigation(toLocation, from);
+    if (error) return error;
+
+    // only consider as push if it's not the first navigation
+    const isFirstNavigation = from === START_LOCATION_NORMALIZED;
+    const state: Partial<HistoryState> | null = !isBrowser ? {} : history.state;
+
+    // change URL only if the user did a push/replace and if it's not the initial navigation because
+    // it's just reflecting the url
+    if (isPush) {
+      info("router::isPush start...", toLocation);
+      //---------------------------TODO LIULIPENG---------------------------
+      const routeLocationMatched = resolveRouteLocationMatched(toLocation);
+      console.log("toLocation: ", toLocation);
+      console.log("RouteLocationMatched: ", routeLocationMatched);
+
+      if (!isSupportSlotType()) {
+        //resume
+        const toHistoryLocation = findHistoryLocation(toLocation);
+        if (toHistoryLocation) {
+          if (toHistoryLocation.lifecycle >= LifecycleState.destroy) {
+            toHistoryLocation.lifecycle = LifecycleState.initialized;
+          }
+        }
+
+        //clear task
+        if (
+          routeLocationMatched.launchMode ===
+          ESRouteLaunchMode.ES_ROUTE_LAUNCH_MODE_CLEAR_TASK
+        ) {
+          if (!isFirstNavigation) {
+            resolveClearTaskLifecycle(routeLocationMatched);
+          }
+        }
+        //single task
+        else if (
+          routeLocationMatched.launchMode ===
+          ESRouteLaunchMode.ES_ROUTE_LAUNCH_MODE_SINGLE_TASK
+        ) {
+          resolveSingleTaskLifecycle(routeLocationMatched, toLocation, replace);
+        }
+        //standard
+        else {
+          resolveStandardLifecycle(routeLocationMatched, replace);
+        }
+      }
+      //--------------------------------------------------------------
+      // TODO replace + clear task  = clear task ==> 不执行replace操作(replace 操作没有意义)
+      //
+      // on the initial navigation, we want to reuse the scroll position from
+      // history state if it exists
+      if (
+        replace &&
+        routeLocationMatched.launchMode !==
+          ESRouteLaunchMode.ES_ROUTE_LAUNCH_MODE_CLEAR_TASK
+      ) {
+        info("router::replace start...", toLocation);
+        routerHistory.replace(
+          resolveHistoryLocation(
+            toLocation.key,
+            toLocation.fullPath,
+            toLocation.resultCallback,
+          ),
+          assign(
+            {
+              scroll: isFirstNavigation && state && state.scroll,
+            },
+            data,
+          ),
+        );
+      } else {
+        if (
+          routeLocationMatched.launchMode ===
+          ESRouteLaunchMode.ES_ROUTE_LAUNCH_MODE_SINGLE_TASK
+        ) {
+          const index = findHistoryLocationIndex(toLocation);
+          if (index <= -1) {
+            routerHistory.push(
+              resolveHistoryLocation(
+                toLocation.key,
+                toLocation.fullPath,
+                toLocation.resultCallback,
+              ),
+              data,
+            );
+          }
+        } else {
+          routerHistory.push(
+            resolveHistoryLocation(
+              toLocation.key,
+              toLocation.fullPath,
+              toLocation.resultCallback,
+            ),
+            data,
+          );
+        }
+      }
+    }
+    // TODO
+    // accept current navigation
+    currentRoute.value = toLocation;
+    //
+    handleScroll(toLocation, from, isPush, isFirstNavigation);
+    //
+    markAsReady();
+  }
+
+  /**
+   * TODO LIULIPENG 参数转换
+   */
+  function resolveHistoryLocation(
+    key?: string,
+    location: string,
+    resultCallback?: RouteResultCallback,
+  ): HistoryLocation {
+    return {
+      key: key,
+      location: location,
+      lifecycle: LifecycleState.uninitialized,
+      saveInstanceState: {},
+      resultCallback: resultCallback,
+    };
+  }
+
+  let removeHistoryListener: undefined | null | (() => void);
+
+  //------------------------------------清空堆栈--------------------------------------
+  function resolveClearTaskLifecycle(routeLocationMatched) {
+    info("router::resolveClearTaskLifecycle ...");
+    console.log("ESRouter: resolveClearTaskLifecycle");
+    const historyLocationList: HistoryLocation[] =
+      routerHistory.clearHistoryLocations();
+    if (historyLocationList && historyLocationList.length > 0) {
+      historyLocationList.forEach((historyLocation, index) => {
+        if (historyLocation) {
+          pauseStopDestroyRoute(historyLocation, true, true, false);
+        }
+      });
+    }
+  }
+
+  function findHistoryLocationIndex(toLocation) {
+    const historyLocationList = routerHistory.getHistoryLocations();
+    if (historyLocationList && historyLocationList.length > 0) {
+      for (let i = 0; i < historyLocationList.length; i++) {
+        const location = historyLocationList[i];
+        if (location && location.location === toLocation.fullPath) {
+          return i;
+        }
+      }
+    }
+    return -1;
+  }
+
+  function findHistoryLocation(toLocation) {
+    const historyLocationList = routerHistory.getHistoryLocations();
+    if (historyLocationList && historyLocationList.length > 0) {
+      for (let i = 0; i < historyLocationList.length; i++) {
+        const location = historyLocationList[i];
+        if (
+          location &&
+          location.location === toLocation.fullPath &&
+          location.key === toLocation.key
+        ) {
+          return location;
+        }
+      }
+    }
+    return null;
+  }
+
+  //------------------------------------单例--------------------------------------
+  function resolveSingleTaskLifecycle(
+    routeLocationMatched,
+    toLocation,
+    replace: boolean,
+  ) {
+    const historyLocationList = routerHistory.getHistoryLocations();
+    const length = historyLocationList.length;
+    const index = findHistoryLocationIndex(toLocation);
+    if (index > -1) {
+      const locationList = routerHistory.popHistoryLocations(
+        length - index - 1,
+      );
+      if (locationList && locationList.length > 0) {
+        locationList.forEach((historyLocation, index) => {
+          if (historyLocation) {
+            pauseStopDestroyRoute(historyLocation, true, true, false);
+          }
+        });
+      }
+      if (replace) {
+        resolveStandardLifecycle(routeLocationMatched, replace);
+      }
+    }
+    //
+    else {
+      resolveStandardLifecycle(routeLocationMatched, replace);
+    }
+  }
+
+  //------------------------------------标准模式--------------------------------------
+  function resolveStandardLifecycle(routeLocationMatched, replace?: boolean) {
+    const historyLocationList = routerHistory.getHistoryLocations();
+    if (historyLocationList && historyLocationList.length > 0) {
+      const length = historyLocationList.length;
+      //stack bottom
+      try {
+        if (limit && length + 1 > limit) {
+          const historyLocation = historyLocationList[length - limit];
+          if (historyLocation) {
+            pauseStopDestroyRoute(historyLocation, true, true, true);
+          }
+        }
+      } catch (e) {
+        console.log(
+          "invoke stack bottom component instance pause stop error...",
+          e,
+        );
+      }
+
+      const isDialogType =
+        routeLocationMatched.type == ESRouteType.ES_ROUTE_TYPE_DIALOG;
+      console.log(
+        "RouteLocationMatched: isDialogType",
+        routeLocationMatched,
+        isDialogType,
+      );
+
+      //stack middle
+      if (!isDialogType) {
+        for (let i = 0; i < historyLocationList.length - 1; i++) {
+          const location = historyLocationList[i];
+          if (location) {
+            pauseStopDestroyRoute(location, true, false, false);
+          }
+        }
+      }
+
+      //stack top
+      try {
+        const historyLocation = historyLocationList[length - 1];
+        if (historyLocation) {
+          const stop = replace || !isDialogType;
+          const destroy = replace;
+          pauseStopDestroyRoute(historyLocation, stop, destroy, false);
+        }
+      } catch (e) {
+        console.log(
+          "invoke stack top component instance pause stop error...",
+          e,
+        );
+      }
+    }
+  }
+
+  function pauseStopDestroyRoute(
+    historyLocation: HistoryLocation,
+    stop: boolean,
+    destroy: boolean,
+    saveInstanceState: boolean,
+  ) {
+    console.log(
+      "PauseStopDestroyRoute: " +
+        " Location" +
+        historyLocation.location +
+        " stop:" +
+        stop +
+        " destroy:" +
+        destroy +
+        " saveInstanceState:" +
+        saveInstanceState,
+    );
+    //
+    const instance = historyLocation.instances;
+    //onESPause
+    if (historyLocation.lifecycle < LifecycleState.pause) {
+      historyLocation.lifecycle = LifecycleState.pause;
+      try {
+        if (instance) {
+          try {
+            triggerESLifecycle(instance, "pause");
+          } catch (e) {}
+
+          // @ts-ignore
+          if (isFunction(instance.onESPause)) {
+            // @ts-ignore
+            instance.onESPause();
+          }
+        }
+      } catch (e) {
+        console.log(
+          "invoke " +
+            historyLocation +
+            " component instance onESPause error...",
+          e,
+        );
+      }
+    }
+    //onESStop
+    if (stop && historyLocation.lifecycle < LifecycleState.stop) {
+      historyLocation.lifecycle = LifecycleState.stop;
+      try {
+        if (instance) {
+          try {
+            triggerESLifecycle(instance, "stop");
+          } catch (e) {}
+
+          // @ts-ignore
+          if (isFunction(instance.onESStop)) {
+            // @ts-ignore
+            instance.onESStop();
+          }
+        }
+      } catch (e) {
+        console.log(
+          "invoke " + historyLocation + " component instance onESStop error...",
+          e,
+        );
+      }
+    }
+
+    //onESSaveInstanceState
+    if (
+      stop &&
+      saveInstanceState &&
+      historyLocation.lifecycle < LifecycleState.saveInstanceState
+    ) {
+      historyLocation.lifecycle = LifecycleState.saveInstanceState;
+      try {
+        if (instance) {
+          try {
+            triggerESLifecycle(
+              instance,
+              "saveInstanceState",
+              historyLocation.saveInstanceState,
+            );
+          } catch (e) {}
+
+          // @ts-ignore
+          if (isFunction(instance.onESSaveInstanceState)) {
+            // @ts-ignore
+            instance.onESSaveInstanceState(historyLocation.saveInstanceState);
+          }
+        }
+      } catch (e) {
+        console.log(
+          "invoke " +
+            historyLocation +
+            " component instance onESSaveInstanceState error...",
+          e,
+        );
+      }
+    }
+
+    //onESDestroy
+    if (stop && destroy && historyLocation.lifecycle < LifecycleState.destroy) {
+      historyLocation.lifecycle = LifecycleState.destroy;
+      try {
+        if (instance) {
+          try {
+            triggerESLifecycle(instance, "destroy");
+          } catch (e) {}
+          // @ts-ignore
+          if (isFunction(instance.onESDestroy)) {
+            // @ts-ignore
+            instance.onESDestroy();
+          }
+        }
+      } catch (e) {
+        console.log(
+          "invoke " +
+            historyLocation +
+            " component instance onESDestroy error...",
+          e,
+        );
+      }
+      //
+      historyLocation.instances = null;
+    }
+  }
+
+  function resolveRouteLocationMatched(
+    targetLocation: RouteLocation,
+  ): RouteLocationMatched {
+    let initialDepth = 0;
+    const { matched } = targetLocation;
+    let matchedRoute: RouteLocationMatched | undefined;
+    while ((matchedRoute = matched[initialDepth]) && !matchedRoute.components) {
+      initialDepth++;
+    }
+    return matched[initialDepth];
+  }
+
+  function isFunction(func) {
+    return Object.prototype.toString.call(func) === "[object Function]";
+  }
+
+  // attach listener to history to trigger navigations
+  function setupListeners() {
+    // avoid setting up listeners twice due to an invalid first navigation
+    if (removeHistoryListener) return;
+    removeHistoryListener = routerHistory.listen((to, _from, info) => {
+      if (!router.listening) return;
+      // cannot be a redirect route because it was in history
+      const toLocation = resolve(to.location) as RouteLocationNormalized;
+
+      // due to dynamic routing, and to hash history with manual navigation
+      // (manually changing the url or calling history.hash = '#/somewhere'),
+      // there could be a redirect record in history
+      const shouldRedirect = handleRedirectRecord(toLocation);
+      if (shouldRedirect) {
+        pushWithRedirect(
+          assign(shouldRedirect, { replace: true }),
+          toLocation,
+        ).catch(noop);
+        return;
+      }
+
+      pendingLocation = toLocation;
+      const from = currentRoute.value;
+
+      //-------------------------TODO LIULIPENG----------------------
+      //resume
+      if (to) {
+        if (to.lifecycle >= LifecycleState.destroy) {
+          to.lifecycle = LifecycleState.initialized;
+        }
+      }
+      //---------------------------------------------------------
+      // TODO: should be moved to web history?
+      if (isBrowser) {
+        saveScrollPosition(
+          getScrollKey(from.fullPath, info.delta),
+          computeScrollPosition(),
+        );
+      }
+
+      navigate(toLocation, from)
+        .catch((error: NavigationFailure | NavigationRedirectError) => {
+          if (
+            isNavigationFailure(
+              error,
+              ErrorTypes.NAVIGATION_ABORTED | ErrorTypes.NAVIGATION_CANCELLED,
+            )
+          ) {
+            return error;
+          }
+          if (
+            isNavigationFailure(error, ErrorTypes.NAVIGATION_GUARD_REDIRECT)
+          ) {
+            // Here we could call if (info.delta) routerHistory.go(-info.delta,
+            // false) but this is bug prone as we have no way to wait the
+            // navigation to be finished before calling pushWithRedirect. Using
+            // a setTimeout of 16ms seems to work but there is no guarantee for
+            // it to work on every browser. So instead we do not restore the
+            // history entry and trigger a new navigation as requested by the
+            // navigation guard.
+
+            // the error is already handled by router.push we just want to avoid
+            // logging the error
+            pushWithRedirect(
+              (error as NavigationRedirectError).to,
+              toLocation,
+              // avoid an uncaught rejection, let push call triggerError
+            )
+              .then((failure) => {
+                // manual change in hash history #916 ending up in the URL not
+                // changing, but it was changed by the manual url change, so we
+                // need to manually change it ourselves
+                if (
+                  isNavigationFailure(
+                    failure,
+                    ErrorTypes.NAVIGATION_ABORTED |
+                      ErrorTypes.NAVIGATION_DUPLICATED,
+                  ) &&
+                  !info.delta &&
+                  info.type === NavigationType.pop
+                ) {
+                  routerHistory.go(-1, false);
+                }
+              })
+              .catch(noop);
+            // avoid the then branch
+            return Promise.reject();
+          }
+          // do not restore history on unknown direction
+          if (info.delta) {
+            routerHistory.go(-info.delta, false);
+          }
+          // unrecognized error, transfer to the global handler
+          return triggerError(error, toLocation, from);
+        })
+        .then((failure: NavigationFailure | void) => {
+          failure =
+            failure ||
+            finalizeNavigation(
+              // after navigation, all matched components are resolved
+              toLocation as RouteLocationNormalizedLoaded,
+              from,
+              false,
+            );
+
+          // revert the navigation
+          if (failure) {
+            if (
+              info.delta &&
+              // a new navigation has been triggered, so we do not want to revert, that will change the current history
+              // entry while a different route is displayed
+              !isNavigationFailure(failure, ErrorTypes.NAVIGATION_CANCELLED)
+            ) {
+              routerHistory.go(-info.delta, false);
+            } else if (
+              info.type === NavigationType.pop &&
+              isNavigationFailure(
+                failure,
+                ErrorTypes.NAVIGATION_ABORTED |
+                  ErrorTypes.NAVIGATION_DUPLICATED,
+              )
+            ) {
+              // manual change in hash history #916
+              // it's like a push but lacks the information of the direction
+              routerHistory.go(-1, false);
+            }
+          }
+
+          triggerAfterEach(
+            toLocation as RouteLocationNormalizedLoaded,
+            from,
+            failure,
+          );
+        })
+        .catch(noop);
+    });
+  }
+
+  // Initialization and Errors
+
+  let readyHandlers = useCallbacks<OnReadyCallback>();
+  let errorHandlers = useCallbacks<_ErrorHandler>();
+  let ready: boolean;
+
+  /**
+   * Trigger errorHandlers added via onError and throws the error as well
+   *
+   * @param error - error to throw
+   * @param to - location we were navigating to when the error happened
+   * @param from - location we were navigating from when the error happened
+   * @returns the error as a rejected promise
+   */
+  function triggerError(
+    error: any,
+    to: RouteLocationNormalized,
+    from: RouteLocationNormalizedLoaded,
+  ): Promise<unknown> {
+    markAsReady(error);
+    const list = errorHandlers.list();
+    if (list.length) {
+      list.forEach((handler) => handler(error, to, from));
+    } else {
+      if (__DEV__) {
+        warn("uncaught error during route navigation:");
+      }
+      console.error(error);
+    }
+    return Promise.reject(error);
+  }
+
+  function isReady(): Promise<void> {
+    if (ready && currentRoute.value !== START_LOCATION_NORMALIZED)
+      return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      readyHandlers.add([resolve, reject]);
+    });
+  }
+
+  /**
+   * Mark the router as ready, resolving the promised returned by isReady(). Can
+   * only be called once, otherwise does nothing.
+   * @param err - optional error
+   */
+  function markAsReady<E = any>(err: E): E;
+  function markAsReady<E = any>(): void;
+  function markAsReady<E = any>(err?: E): E | void {
+    if (!ready) {
+      // still not ready if an error happened
+      ready = !err;
+      setupListeners();
+      readyHandlers
+        .list()
+        .forEach(([resolve, reject]) => (err ? reject(err) : resolve()));
+      readyHandlers.reset();
+    }
+    return err;
+  }
+
+  // Scroll behavior
+  function handleScroll(
+    to: RouteLocationNormalizedLoaded,
+    from: RouteLocationNormalizedLoaded,
+    isPush: boolean,
+    isFirstNavigation: boolean,
+  ): Promise<any> {
+    const { scrollBehavior } = options;
+    if (!isBrowser || !scrollBehavior) return Promise.resolve();
+
+    const scrollPosition: _ScrollPositionNormalized | null =
+      (!isPush && getSavedScrollPosition(getScrollKey(to.fullPath, 0))) ||
+      ((isFirstNavigation || !isPush) &&
+        (history.state as HistoryState) &&
+        history.state.scroll) ||
+      null;
+
+    return nextTick()
+      .then(() => scrollBehavior(to, from, scrollPosition))
+      .then((position) => position && scrollToPosition(position))
+      .catch((err) => triggerError(err, to, from));
+  }
+
+  function go(delta) {
+    navigationType.value = delta < 0 ? NavigationType.pop : NavigationType.push;
+    //
+    if (delta < 0) {
+      pauseStopDestroyRoute(routerHistory.getLocation(), true, true, false);
+    }
+    //
+    let ret = routerHistory.go(delta);
+    console.log("ESRouter:go result:" + ret);
+    if (!ret || isSupportSlotType()) {
+      console.log("call native router:go start:" + delta);
+      ret = nativeRouter.go(delta);
+      console.log("call native router:go result:" + ret);
+    }
+    return ret;
+  }
+
+  let started: boolean | undefined;
+  const installedApps = new Set<App>();
+
+  const router: Router = {
+    //----------------------------------------------
+    get active() {
+      return getActive();
+    },
+    setActive,
+    //----------------------------------------------
+    currentRoute,
+    listening: true,
+
+    addRoute,
+    removeRoute,
+    hasRoute,
+    getRoutes,
+    getRouterHistory,
+    getRoute,
+    resolve,
+    options,
+
+    //
+    push,
+    replace,
+    splice,
+    go,
+    back: () => go(-1),
+    forward: () => go(1),
+
+    //
+    setResult,
+
+    //
+    beforeEach: beforeGuards.add,
+    beforeResolve: beforeResolveGuards.add,
+    afterEach: afterGuards.add,
+
+    onError: errorHandlers.add,
+    isReady,
+
+    install: function (app: App) {
+      const router = this;
+      app.component("EsRouterLink", RouterLink);
+      app.component("EsRouterView", RouterView);
+      app.component("EsSlotView", SlotView);
+
+      registerPageRouteView(app);
+      registerPageView(app);
+      registerSlotRootView(app);
+      registerSlotView(app);
+
+      app.config.globalProperties.$router = router;
+      Object.defineProperty(app.config.globalProperties, "$route", {
+        enumerable: true,
+        get: () => unref(currentRoute),
+      });
+
+      // this initial navigation is only necessary on client, on server it doesn't
+      // make sense because it will create an extra unnecessary navigation and could
+      // lead to problems
+      if (
+        isBrowser &&
+        // used for the initial navigation client side to avoid pushing
+        // multiple times when the router is used in multiple apps
+        !started &&
+        currentRoute.value === START_LOCATION_NORMALIZED
+      ) {
+        // see above
+        started = true;
+        push(routerHistory.location).catch((err) => {
+          if (__DEV__) warn("Unexpected error when starting the router:", err);
+        });
+      }
+
+      const reactiveRoute = {} as {
+        [k in keyof RouteLocationNormalizedLoaded]: ComputedRef<
+          RouteLocationNormalizedLoaded[k]
+        >;
+      };
+      for (const key in START_LOCATION_NORMALIZED) {
+        // @ts-expect-error: the key matches
+        reactiveRoute[key] = computed(() => currentRoute.value[key]);
+      }
+
+      app.provide(routerKey, router);
+      app.provide(routeLocationKey, reactive(reactiveRoute));
+      app.provide(routerViewLocationKey, currentRoute);
+      app.provide(routerHistoryKey, options.history);
+      app.provide(routerRecordRawKey, options.routes);
+      app.provide(navigationTypeKey, navigationType);
+      app.provide(routerComponentInstanceKey, routerComponentInstance);
+      app.provide(routerViewNameKey, routerViewName);
+      app.provide(nativeRouterKey, nativeRouter);
+      app.provide(routerViewInstanceKey, routerViewInstance);
+      app.provide(routeViewInstancesKey, routeViewInstanceList);
+
+      const unmountApp = app.unmount;
+      installedApps.add(app);
+      app.unmount = function () {
+        installedApps.delete(app);
+        // the router is not attached to an app anymore
+        if (installedApps.size < 1) {
+          // invalidate the current navigation
+          pendingLocation = START_LOCATION_NORMALIZED;
+          removeHistoryListener && removeHistoryListener();
+          removeHistoryListener = null;
+          currentRoute.value = START_LOCATION_NORMALIZED;
+          started = false;
+          ready = false;
+        }
+        unmountApp();
+      };
+
+      // TODO: this probably needs to be updated so it can be used by vue-termui
+      if ((__DEV__ || __FEATURE_PROD_DEVTOOLS__) && isBrowser) {
+        addDevtools(app, router, matcher);
+      }
+    },
+  };
+
+  // TODO: type this as NavigationGuardReturn or similar instead of any
+  function runGuardQueue(guards: Lazy<any>[]): Promise<any> {
+    return guards.reduce(
+      (promise, guard) => promise.then(() => runWithContext(guard)),
+      Promise.resolve(),
+    );
+  }
+
+  return router;
+}
+
+function extractChangingRecords(
+  to: RouteLocationNormalized,
+  from: RouteLocationNormalizedLoaded,
+) {
+  const leavingRecords: RouteRecordNormalized[] = [];
+  const updatingRecords: RouteRecordNormalized[] = [];
+  const enteringRecords: RouteRecordNormalized[] = [];
+
+  const len = Math.max(from.matched.length, to.matched.length);
+  for (let i = 0; i < len; i++) {
+    const recordFrom = from.matched[i];
+    if (recordFrom) {
+      if (to.matched.find((record) => isSameRouteRecord(record, recordFrom)))
+        updatingRecords.push(recordFrom);
+      else leavingRecords.push(recordFrom);
+    }
+    const recordTo = to.matched[i];
+    if (recordTo) {
+      // the type doesn't matter because we are comparing per reference
+      if (!from.matched.find((record) => isSameRouteRecord(record, recordTo))) {
+        enteringRecords.push(recordTo);
+      }
+    }
+  }
+
+  return [leavingRecords, updatingRecords, enteringRecords];
+}