diff --git a/packages/horizon-router/.prettierrc.js b/packages/horizon-router/.prettierrc.js
new file mode 100644
index 00000000..73dd0047
--- /dev/null
+++ b/packages/horizon-router/.prettierrc.js
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2020 Huawei Technologies Co.,Ltd.
+ *
+ * openGauss is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *          http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+'use strict';
+
+module.exports = {
+  printWidth: 120, //一行120字符数，如果超过会进行换行
+  tabWidth: 2, //tab等2个空格
+  useTabs: false, //用空格缩进行
+  semi: true, //行尾使用分号
+  singleQuote: true, //字符串使用单引号
+  quoteProps: 'as-needed', //仅在需要时在对象属性添加引号
+  jsxSingleQuote: false, //在JSX中使用双引号
+  trailingComma: 'es5', //使用尾逗号(对象、数组等)
+  bracketSpacing: true, //对象的括号间增加空格
+  bracketSameLine: false, //将多行JSX元素的>放在最后一行的末尾
+  arrowParens: 'avoid', //在唯一的arrow函数参数周围省略括号
+  vueIndentScriptAndStyle: false, //不缩进Vue文件中的<script>和<style>标记内的代码
+  endOfLine: 'lf', //仅限换行（\n）
+};
diff --git a/packages/horizon-router/README.md b/packages/horizon-router/README.md
new file mode 100644
index 00000000..3f87a0ee
--- /dev/null
+++ b/packages/horizon-router/README.md
@@ -0,0 +1,109 @@
+# Horizon-router
+
+Horizon-router 是Horizon生态组建的一部分，为Horizon提供前端路由的能力，是构建大型应用必要组件。
+
+Horizon-router涵盖react-router、history、connect-react-router的功能。
+
+## 从react-router切换
+
+Horizon-router 在API设计上兼容react-router V5。
+
+在切换时只需在`package.json`的dependencies中加入`horizon-router`
+，并将原有的API引用从`react-router-dom`、`history`、`connected-react-router
+`切换到`horizon-router`。
+
+切换样例代码如下:
+
+### react-router-dom
+
+**切换前**
+
+```typescript
+import { Switch, Route } from 'react-router-dom';
+```
+
+**切换后**
+
+```typescript
+import { Switch, Route } from 'horizon-router';
+```
+
+### history
+
+**切换前**
+
+```typescript
+import { createHashHistory, createBrowserHistory } from 'history';
+```
+
+**切换后**
+
+```typescript
+import { createHashHistory, createBrowserHistory } from 'horizon-router';
+```
+
+### connected-react-router
+
+**切换前**
+
+```typescript
+import { ConnectedRouter, routerMiddleware, connectRouter } from 'connected-react-router';
+```
+
+**切换后**
+
+```typescript
+import { ConnectedRouter, routerMiddleware, connectRouter } from 'horizon-router';
+```
+
+## Horizon-router API列表
+
+history 兼容API
+---
+
+- createBrowserHistory
+- createHashHistory
+
+react-router-dom 兼容API
+---
+
+- __RouterContext
+- matchPath
+- generatePath
+- useHistory
+- useLocation
+- useParams
+- useRouteMatch
+- Route
+- Router
+- Switch
+- Redirect
+- Prompt
+- withRouter
+- HashRouter
+- BrowserRouter
+- Link
+- NavLink
+
+react-router-dom 类型兼容API
+---
+
+- RouteComponentProps
+- RouteChildrenProps
+- RouteProps
+
+connected-react-router 兼容API
+---
+
+- connectRouter
+- routerMiddleware
+- ConnectedRouter
+
+connected-react-router 新增API
+---
+
+- ConnectedHRouter(在HorizonX的Redux兼容模式中使用)
+
+## 问题反馈
+
+Horizon-router问题与bug反馈，请联系00800104 黄轩
\ No newline at end of file
diff --git a/packages/horizon-router/babel.config.js b/packages/horizon-router/babel.config.js
new file mode 100644
index 00000000..93a39aee
--- /dev/null
+++ b/packages/horizon-router/babel.config.js
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2020 Huawei Technologies Co.,Ltd.
+ *
+ * openGauss is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *          http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+export default {
+  presets: ['@babel/preset-typescript', ['@babel/preset-env', { targets: { node: 'current' } }]],
+  plugins: [
+    '@babel/plugin-syntax-jsx',
+    [
+      '@babel/plugin-transform-react-jsx',
+      {
+        pragma: 'React.createElement',
+        pragmaFrag: 'React.Fragment',
+      },
+    ],
+    ['@babel/plugin-proposal-class-properties', { loose: true }],
+    ['@babel/plugin-proposal-private-methods', { loose: true }],
+    ['@babel/plugin-proposal-private-property-in-object', { loose: true }],
+    '@babel/plugin-transform-object-assign',
+    '@babel/plugin-transform-object-super',
+    ['@babel/plugin-proposal-object-rest-spread', { loose: true, useBuiltIns: true }],
+    ['@babel/plugin-transform-template-literals', { loose: true }],
+    '@babel/plugin-transform-arrow-functions',
+    '@babel/plugin-transform-literals',
+    '@babel/plugin-transform-for-of',
+    '@babel/plugin-transform-block-scoped-functions',
+    '@babel/plugin-transform-classes',
+    '@babel/plugin-transform-shorthand-properties',
+    '@babel/plugin-transform-computed-properties',
+    '@babel/plugin-transform-parameters',
+    ['@babel/plugin-transform-spread', { loose: true, useBuiltIns: true }],
+    ['@babel/plugin-transform-block-scoping', { throwIfClosureRequired: false }],
+    ['@babel/plugin-transform-destructuring', { loose: true, useBuiltIns: true }],
+    '@babel/plugin-transform-runtime',
+    '@babel/plugin-proposal-nullish-coalescing-operator',
+    '@babel/plugin-proposal-optional-chaining',
+  ],
+};
diff --git a/packages/horizon-router/build.js b/packages/horizon-router/build.js
new file mode 100644
index 00000000..02251d4e
--- /dev/null
+++ b/packages/horizon-router/build.js
@@ -0,0 +1,100 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import babel from '@rollup/plugin-babel';
+import nodeResolve from '@rollup/plugin-node-resolve';
+import execute from 'rollup-plugin-execute';
+import fs from 'fs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const routerEntry = path.join(__dirname, '/src/router/index.ts');
+const connectRouterEntry = path.join(__dirname, '/src/router/index2.ts');
+
+const output = __dirname;
+
+const extensions = ['.js', '.ts', '.tsx'];
+
+if (!fs.existsSync(path.join(output, 'connectRouter'))) {
+  fs.mkdirSync(path.join(output, 'connectRouter'), { recursive: true });
+}
+
+const routerBuildConfig = {
+  input: { router: routerEntry },
+  output: [
+    {
+      dir: path.resolve(output, 'router/cjs'),
+      sourcemap: 'inline',
+      format: 'cjs',
+    },
+    {
+      dir: path.resolve(output, 'router/esm'),
+      sourcemap: 'inline',
+      format: 'esm',
+    },
+  ],
+  plugins: [
+    nodeResolve({
+      extensions,
+      modulesOnly: true,
+    }),
+    babel({
+      exclude: 'node_modules/**',
+      configFile: path.join(__dirname, '/babel.config.js'),
+      babelHelpers: 'runtime',
+      extensions,
+    }),
+    execute('npm run build-types-router'),
+  ],
+};
+
+const connectRouterConfig = {
+  input: { connectRouter: connectRouterEntry },
+  output: [
+    {
+      dir: path.resolve(output, 'connectRouter/cjs'),
+      sourcemap: 'inline',
+      format: 'cjs',
+    },
+    {
+      dir: path.resolve(output, 'connectRouter/esm'),
+      sourcemap: 'inline',
+      format: 'esm',
+    },
+  ],
+  plugins: [
+    nodeResolve({
+      extensions,
+      modulesOnly: true,
+    }),
+    babel({
+      exclude: 'node_modules/**',
+      configFile: path.join(__dirname, '/babel.config.js'),
+      babelHelpers: 'runtime',
+      extensions,
+    }),
+    execute('npm run build-types-all'),
+    copyFiles([
+      {
+        from: path.join(__dirname, 'src/configs/package.json'),
+        to: path.join(output, '/connectRouter/package.json'),
+      },
+    ]),
+  ],
+};
+
+
+function copyFiles(copyPairs) {
+  return {
+    name: 'copy-files',
+    generateBundle() {
+      copyPairs.forEach(({ from, to }) => {
+        console.log(`copy files: ${from} → ${to}`);
+        fs.copyFileSync(from, to);
+      });
+    },
+  };
+}
+
+
+export default [routerBuildConfig, connectRouterConfig];
diff --git a/packages/horizon-router/connectRouter/@types/connect-router/actions.d.ts b/packages/horizon-router/connectRouter/@types/connect-router/actions.d.ts
new file mode 100644
index 00000000..965f7ee7
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/connect-router/actions.d.ts
@@ -0,0 +1,25 @@
+import { Action, Path } from '../history/types';
+type Location = Partial<Path>;
+export declare enum ActionName {
+    LOCATION_CHANGE = "$horizon-router/LOCATION_CHANGE",
+    CALL_HISTORY_METHOD = "$horizon-router/CALL_HISTORY_METHOD"
+}
+export type ActionMessage = {
+    type: ActionName.LOCATION_CHANGE;
+    payload: {
+        location: Location;
+        action: Action;
+        isFirstRendering: boolean;
+    };
+} | {
+    type: ActionName.CALL_HISTORY_METHOD;
+    payload: {
+        method: string;
+        args: any;
+    };
+};
+export declare const onLocationChanged: (location: Location, action: Action, isFirstRendering?: boolean) => ActionMessage;
+export declare const push: (...args: any) => ActionMessage;
+export declare const replace: (...args: any) => ActionMessage;
+export declare const go: (...args: any) => ActionMessage;
+export {};
diff --git a/packages/horizon-router/connectRouter/@types/connect-router/dispatch.d.ts b/packages/horizon-router/connectRouter/@types/connect-router/dispatch.d.ts
new file mode 100644
index 00000000..48424699
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/connect-router/dispatch.d.ts
@@ -0,0 +1,3 @@
+import { ActionMessage } from './actions';
+import { History } from '../history/types';
+export declare function routerMiddleware(history: History): (_: any) => (next: any) => (action: ActionMessage) => any;
diff --git a/packages/horizon-router/connectRouter/@types/connect-router/index.d.ts b/packages/horizon-router/connectRouter/@types/connect-router/index.d.ts
new file mode 100644
index 00000000..38b43283
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/connect-router/index.d.ts
@@ -0,0 +1,11 @@
+export { getConnectedRouter } from './connectedRouter';
+export declare const connectRouter: (history: import("../router").History<unknown>) => (state?: {
+    location: Partial<import("../router").Location<unknown>> & {
+        query?: Record<string, any>;
+    };
+    action: import("../history/types").Action;
+}, { type, payload }?: {
+    type?: import("./actions").ActionName;
+    payload?: any;
+}) => any;
+export { routerMiddleware } from './dispatch';
diff --git a/packages/horizon-router/connectRouter/@types/connect-router/reducer.d.ts b/packages/horizon-router/connectRouter/@types/connect-router/reducer.d.ts
new file mode 100644
index 00000000..3de2b851
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/connect-router/reducer.d.ts
@@ -0,0 +1,16 @@
+import { ActionName } from './actions';
+import { Action, History } from '../history/types';
+import { Location } from '../router';
+type LocationWithQuery = Partial<Location> & {
+    query?: Record<string, any>;
+};
+type InitRouterState = {
+    location: LocationWithQuery;
+    action: Action;
+};
+type Payload = {
+    type?: ActionName;
+    payload?: any;
+};
+export declare function createConnectRouter(): (history: History) => (state?: InitRouterState, { type, payload }?: Payload) => any;
+export {};
diff --git a/packages/horizon-router/connectRouter/@types/history/baseHistory.d.ts b/packages/horizon-router/connectRouter/@types/history/baseHistory.d.ts
new file mode 100644
index 00000000..74892c1e
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/history/baseHistory.d.ts
@@ -0,0 +1,10 @@
+import { HistoryProps, Listener, Navigation, Prompt } from './types';
+import transitionManager from './transitionManager';
+export declare function getBaseHistory<S>(transitionManager: transitionManager<S>, setListener: (delta: number) => void, browserHistory: History): {
+    go: (step: number) => void;
+    goBack: () => void;
+    goForward: () => void;
+    listen: (listener: Listener<S>) => () => void;
+    block: (prompt?: Prompt<S>) => () => void;
+    getUpdateStateFunc: (historyProps: HistoryProps<S>) => (nextState: Navigation<S> | undefined) => void;
+};
diff --git a/packages/horizon-router/connectRouter/@types/history/browerHistory.d.ts b/packages/horizon-router/connectRouter/@types/history/browerHistory.d.ts
new file mode 100644
index 00000000..000d1ad2
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/history/browerHistory.d.ts
@@ -0,0 +1,8 @@
+import { BaseOption, DefaultStateType, History } from './types';
+export type BrowserHistoryOption = {
+    /**
+     * forceRefresh为True时跳转时会强制刷新页面
+     */
+    forceRefresh?: boolean;
+} & BaseOption;
+export declare function createBrowserHistory<S = DefaultStateType>(options?: BrowserHistoryOption): History<S>;
diff --git a/packages/horizon-router/connectRouter/@types/history/dom.d.ts b/packages/horizon-router/connectRouter/@types/history/dom.d.ts
new file mode 100644
index 00000000..b889eef2
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/history/dom.d.ts
@@ -0,0 +1,4 @@
+export declare function isBrowser(): boolean;
+export declare function getDefaultConfirmation(message: string, callBack: (result: boolean) => void): void;
+export declare function isSupportHistory(): boolean;
+export declare function isSupportsPopState(): boolean;
diff --git a/packages/horizon-router/connectRouter/@types/history/hashHistory.d.ts b/packages/horizon-router/connectRouter/@types/history/hashHistory.d.ts
new file mode 100644
index 00000000..a8cf1959
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/history/hashHistory.d.ts
@@ -0,0 +1,7 @@
+import { BaseOption, DefaultStateType, History } from './types';
+export type urlHashType = 'slash' | 'noslash';
+type HashHistoryOption = {
+    hashType?: urlHashType;
+} & BaseOption;
+export declare function createHashHistory<S = DefaultStateType>(option?: HashHistoryOption): History<S>;
+export {};
diff --git a/packages/horizon-router/connectRouter/@types/history/transitionManager.d.ts b/packages/horizon-router/connectRouter/@types/history/transitionManager.d.ts
new file mode 100644
index 00000000..45edc03f
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/history/transitionManager.d.ts
@@ -0,0 +1,11 @@
+import { Action, CallBackFunc, ConfirmationFunc, Listener, Location, Navigation, Prompt, TManager } from './types';
+declare class TransitionManager<S> implements TManager<S> {
+    private prompt;
+    private listeners;
+    constructor();
+    setPrompt(prompt: Prompt<S>): () => void;
+    addListener(func: Listener<S>): () => void;
+    notifyListeners(args: Navigation<S>): void;
+    confirmJumpTo(location: Location<S>, action: Action, userConfirmationFunc: ConfirmationFunc, callBack: CallBackFunc): void;
+}
+export default TransitionManager;
diff --git a/packages/horizon-router/connectRouter/@types/history/types.d.ts b/packages/horizon-router/connectRouter/@types/history/types.d.ts
new file mode 100644
index 00000000..6a8a8636
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/history/types.d.ts
@@ -0,0 +1,56 @@
+export type BaseOption = {
+    basename?: string;
+    getUserConfirmation?: ConfirmationFunc;
+};
+export interface HistoryProps<T = unknown> {
+    readonly action: Action;
+    readonly location: Location<T>;
+    length: number;
+}
+export interface History<T = unknown> extends HistoryProps<T> {
+    createHref(path: Partial<Path>): string;
+    push(to: To, state?: T): void;
+    replace(to: To, state?: T): void;
+    listen(listener: Listener<T>): () => void;
+    block(prompt: Prompt<T>): () => void;
+    go(index: number): void;
+    goBack(): void;
+    goForward(): void;
+}
+export declare enum Action {
+    pop = "POP",
+    push = "PUSH",
+    replace = "REPLACE"
+}
+export declare enum EventType {
+    PopState = "popstate",
+    HashChange = "hashchange"
+}
+export type Path = {
+    pathname: string;
+    search: string;
+    hash: string;
+};
+export type HistoryState<T> = {
+    state?: T;
+    key: string;
+};
+export type DefaultStateType = unknown;
+export type Location<T = unknown> = Path & HistoryState<T>;
+export type To = string | Partial<Path>;
+export interface Listener<T = unknown> {
+    (navigation: Navigation<T>): void;
+}
+export interface Navigation<T = unknown> {
+    action: Action;
+    location: Location<T>;
+}
+export type Prompt<S> = string | boolean | null | ((location: Location<S>, action: Action) => void);
+export type CallBackFunc = (isJump: boolean) => void;
+export type ConfirmationFunc = (message: string, callBack: CallBackFunc) => void;
+export interface TManager<S> {
+    setPrompt(next: Prompt<S>): () => void;
+    addListener(func: (navigation: Navigation<S>) => void): () => void;
+    notifyListeners(args: Navigation<S>): void;
+    confirmJumpTo(location: Location<S>, action: Action, userConfirmationFunc: ConfirmationFunc, callBack: CallBackFunc): void;
+}
diff --git a/packages/horizon-router/connectRouter/@types/history/utils.d.ts b/packages/horizon-router/connectRouter/@types/history/utils.d.ts
new file mode 100644
index 00000000..adee264f
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/history/utils.d.ts
@@ -0,0 +1,14 @@
+import { Action, Location, Path, To } from './types';
+export declare function createPath(path: Partial<Path>): string;
+export declare function parsePath(url: string): Partial<Path>;
+export declare function createLocation<S>(current: string | Location, to: To, state?: S, key?: string): Readonly<Location<S>>;
+export declare function isLocationEqual(p1: Partial<Path>, p2: Partial<Path>): boolean;
+export declare function addHeadSlash(path: string): string;
+export declare function stripHeadSlash(path: string): string;
+export declare function normalizeSlash(path: string): string;
+export declare function hasBasename(path: string, prefix: string): Boolean;
+export declare function stripBasename(path: string, prefix: string): string;
+export declare function createMemoryRecord<T, S>(initVal: S, fn: (arg: S) => T): {
+    getDelta: (to: S, form: S) => number;
+    addRecord: (current: S, newRecord: S, action: Action) => void;
+};
diff --git a/packages/horizon-router/connectRouter/@types/history/waring.d.ts b/packages/horizon-router/connectRouter/@types/history/waring.d.ts
new file mode 100644
index 00000000..18f09cb7
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/history/waring.d.ts
@@ -0,0 +1,2 @@
+declare function warning(condition: any, message: string): void;
+export default warning;
diff --git a/packages/horizon-router/connectRouter/@types/router/BrowserRouter.d.ts b/packages/horizon-router/connectRouter/@types/router/BrowserRouter.d.ts
new file mode 100644
index 00000000..b91dd697
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/router/BrowserRouter.d.ts
@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+import { ConfirmationFunc } from '../history/types';
+export type BaseRouterProps = {
+    basename: string;
+    getUserConfirmation: ConfirmationFunc;
+    children?: ReactNode;
+};
+export type BrowserRouterProps = BaseRouterProps & {
+    forceRefresh: boolean;
+};
+declare function BrowserRouter<P extends Partial<BrowserRouterProps>>(props: P): JSX.Element;
+export default BrowserRouter;
diff --git a/packages/horizon-router/connectRouter/@types/router/HashRouter.d.ts b/packages/horizon-router/connectRouter/@types/router/HashRouter.d.ts
new file mode 100644
index 00000000..ff09ad81
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/router/HashRouter.d.ts
@@ -0,0 +1,7 @@
+import { BaseRouterProps } from './BrowserRouter';
+import { urlHashType } from '../history/hashHistory';
+export type HashRouterProps = BaseRouterProps & {
+    hashType: urlHashType;
+};
+declare function HashRouter<P extends Partial<HashRouterProps>>(props: P): JSX.Element;
+export default HashRouter;
diff --git a/packages/horizon-router/connectRouter/@types/router/Link.d.ts b/packages/horizon-router/connectRouter/@types/router/Link.d.ts
new file mode 100644
index 00000000..48ec51d8
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/router/Link.d.ts
@@ -0,0 +1,18 @@
+import * as React from 'react';
+import { Location } from './index';
+export type LinkProps = {
+    component?: React.ComponentType<any>;
+    to: Partial<Location> | string | ((location: Location) => string | Partial<Location>);
+    replace?: boolean;
+    tag?: string;
+    /**
+     * @deprecated
+     * React16以后不再需要该属性
+     **/
+    innerRef?: React.Ref<HTMLAnchorElement>;
+} & React.AnchorHTMLAttributes<HTMLAnchorElement>;
+declare function Link<P extends LinkProps>(props: P): React.DOMElement<{
+    href: string;
+    onClick: (event: React.MouseEvent<HTMLAnchorElement>) => void;
+} & Omit<P, "replace" | "to" | "component" | "onClick" | "target">, Element>;
+export default Link;
diff --git a/packages/horizon-router/connectRouter/@types/router/NavLink.d.ts b/packages/horizon-router/connectRouter/@types/router/NavLink.d.ts
new file mode 100644
index 00000000..a7181526
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/router/NavLink.d.ts
@@ -0,0 +1,10 @@
+import type { LinkProps } from './Link';
+import { Location } from './index';
+import { Matched } from './matcher/parser';
+type NavLinkProps = {
+    to: Partial<Location> | string | ((location: Location) => string | Partial<Location>);
+    isActive?: (match: Matched | null, location: Location) => boolean;
+    [key: string]: any;
+} & LinkProps;
+declare function NavLink<P extends NavLinkProps>(props: P): JSX.Element;
+export default NavLink;
diff --git a/packages/horizon-router/connectRouter/@types/router/Prompt.d.ts b/packages/horizon-router/connectRouter/@types/router/Prompt.d.ts
new file mode 100644
index 00000000..84752997
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/router/Prompt.d.ts
@@ -0,0 +1,8 @@
+import { Location } from './index';
+import { Action } from '../history/types';
+type PromptProps = {
+    message?: string | ((location: Partial<Location>, action: Action) => void);
+    when?: boolean | ((location: Partial<Location>) => boolean);
+};
+declare function Prompt<P extends PromptProps>(props: P): JSX.Element;
+export default Prompt;
diff --git a/packages/horizon-router/connectRouter/@types/router/Redirect.d.ts b/packages/horizon-router/connectRouter/@types/router/Redirect.d.ts
new file mode 100644
index 00000000..e1569e31
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/router/Redirect.d.ts
@@ -0,0 +1,13 @@
+import { Matched } from './matcher/parser';
+import { Location } from './index';
+export type RedirectProps = {
+    to: string | Partial<Location>;
+    push?: boolean;
+    path?: string;
+    from?: string;
+    exact?: boolean;
+    strict?: boolean;
+    readonly computed?: Matched | null;
+};
+declare function Redirect<P extends RedirectProps>(props: P): JSX.Element;
+export default Redirect;
diff --git a/packages/horizon-router/connectRouter/@types/router/Route.d.ts b/packages/horizon-router/connectRouter/@types/router/Route.d.ts
new file mode 100644
index 00000000..b8939efb
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/router/Route.d.ts
@@ -0,0 +1,23 @@
+import * as React from 'react';
+import { History, Location } from './index';
+import { Matched } from './matcher/parser';
+import { GetURLParams } from './matcher/types';
+export type RouteComponentProps<P extends Record<string, any> = {}, S = unknown> = RouteChildrenProps<P, S>;
+export type RouteChildrenProps<P extends Record<string, any> = {}, S = unknown> = {
+    history: History<S>;
+    location: Location<S>;
+    match: Matched<P> | null;
+};
+export type RouteProps<P extends Record<string, any> = {}, Path extends string = string> = {
+    location?: Location;
+    component?: React.ComponentType<RouteComponentProps<P>> | React.ComponentType<any> | undefined;
+    children?: ((props: RouteChildrenProps<P>) => React.ReactNode) | React.ReactNode;
+    render?: (props: RouteComponentProps<P>) => React.ReactNode;
+    path?: Path | Path[];
+    exact?: boolean;
+    sensitive?: boolean;
+    strict?: boolean;
+    computed?: Matched<P>;
+};
+declare function Route<Path extends string, P extends Record<string, any> = GetURLParams<Path>>(props: RouteProps<P, Path>): JSX.Element;
+export default Route;
diff --git a/packages/horizon-router/connectRouter/@types/router/Router.d.ts b/packages/horizon-router/connectRouter/@types/router/Router.d.ts
new file mode 100644
index 00000000..53751b67
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/router/Router.d.ts
@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { History } from '../history/types';
+export type RouterProps = {
+    history: History;
+    children?: React.ReactNode;
+};
+declare function Router<P extends RouterProps>(props: P): JSX.Element;
+export default Router;
diff --git a/packages/horizon-router/connectRouter/@types/router/Switch.d.ts b/packages/horizon-router/connectRouter/@types/router/Switch.d.ts
new file mode 100644
index 00000000..53ea8c32
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/router/Switch.d.ts
@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { Location } from './index';
+export type SwitchProps = {
+    location?: Location;
+    children?: React.ReactNode;
+};
+declare function Switch<P extends SwitchProps>(props: P): React.ReactElement | null;
+export default Switch;
diff --git a/packages/horizon-router/connectRouter/@types/router/__tests__/router.test.d.ts b/packages/horizon-router/connectRouter/@types/router/__tests__/router.test.d.ts
new file mode 100644
index 00000000..7b0828bf
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/router/__tests__/router.test.d.ts
@@ -0,0 +1 @@
+import '@testing-library/jest-dom';
diff --git a/packages/horizon-router/connectRouter/@types/router/__tests__/test_app.d.ts b/packages/horizon-router/connectRouter/@types/router/__tests__/test_app.d.ts
new file mode 100644
index 00000000..c36ab167
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/router/__tests__/test_app.d.ts
@@ -0,0 +1,8 @@
+import { History, Location } from '../index';
+export declare let historyHook: History;
+export declare let locationHook: Location;
+export declare const LocationDisplay: () => JSX.Element;
+export declare const Test_Demo: () => JSX.Element;
+export declare const Test_Demo2: () => JSX.Element;
+export declare const Test_Demo3: () => JSX.Element;
+export declare const Test_Demo4: () => JSX.Element;
diff --git a/packages/horizon-router/connectRouter/@types/router/context.d.ts b/packages/horizon-router/connectRouter/@types/router/context.d.ts
new file mode 100644
index 00000000..8a39bd8c
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/router/context.d.ts
@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { History, Location } from './index';
+import { Matched } from './matcher/parser';
+export type RouterContextValue = {
+    history: History;
+    location: Location;
+    match: Matched | null;
+};
+declare const RouterContext: import("react").Context<RouterContextValue>;
+export default RouterContext;
diff --git a/packages/horizon-router/connectRouter/@types/router/hooks.d.ts b/packages/horizon-router/connectRouter/@types/router/hooks.d.ts
new file mode 100644
index 00000000..7ff53865
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/router/hooks.d.ts
@@ -0,0 +1,8 @@
+import { Matched, Params } from './matcher/parser';
+import { History } from '../history/types';
+import { Location } from './index';
+declare function useHistory<S>(): History<S>;
+declare function useLocation<S>(): Location<S>;
+declare function useParams<P>(): Params<P> | {};
+declare function useRouteMatch<P>(path?: string): Matched<P> | null;
+export { useHistory, useLocation, useParams, useRouteMatch };
diff --git a/packages/horizon-router/connectRouter/@types/router/index.d.ts b/packages/horizon-router/connectRouter/@types/router/index.d.ts
new file mode 100644
index 00000000..01659cc3
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/router/index.d.ts
@@ -0,0 +1,20 @@
+import { Location as HLocation } from '../history/types';
+type Location<S = unknown> = Omit<HLocation<S>, 'key'>;
+export { Location };
+export type { History } from '../history/types';
+export { createBrowserHistory } from '../history/browerHistory';
+export { createHashHistory } from '../history/hashHistory';
+export { default as __RouterContext } from './context';
+export { matchPath, generatePath } from './matcher/parser';
+export { useHistory, useLocation, useParams, useRouteMatch } from './hooks';
+export { default as Route } from './Route';
+export { default as Router } from './Router';
+export { default as Switch } from './Switch';
+export { default as Redirect } from './Redirect';
+export { default as Prompt } from './Prompt';
+export { default as withRouter } from './withRouter';
+export { default as HashRouter } from './HashRouter';
+export { default as BrowserRouter } from './BrowserRouter';
+export { default as Link } from './Link';
+export { default as NavLink } from './NavLink';
+export type { RouteComponentProps, RouteChildrenProps, RouteProps } from './Route';
diff --git a/packages/horizon-router/connectRouter/@types/router/index2.d.ts b/packages/horizon-router/connectRouter/@types/router/index2.d.ts
new file mode 100644
index 00000000..77801836
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/router/index2.d.ts
@@ -0,0 +1,23 @@
+import { Location as HLocation } from '../history/types';
+type Location<S = unknown> = Omit<HLocation<S>, 'key'>;
+export { Location };
+export type { History } from '../history/types';
+export { createBrowserHistory } from '../history/browerHistory';
+export { createHashHistory } from '../history/hashHistory';
+export { default as __RouterContext } from './context';
+export { matchPath, generatePath } from './matcher/parser';
+export { useHistory, useLocation, useParams, useRouteMatch } from './hooks';
+export { default as Route } from './Route';
+export { default as Router } from './Router';
+export { default as Switch } from './Switch';
+export { default as Redirect } from './Redirect';
+export { default as Prompt } from './Prompt';
+export { default as withRouter } from './withRouter';
+export { default as HashRouter } from './HashRouter';
+export { default as BrowserRouter } from './BrowserRouter';
+export { default as Link } from './Link';
+export { default as NavLink } from './NavLink';
+export type { RouteComponentProps, RouteChildrenProps, RouteProps } from './Route';
+export { connectRouter, routerMiddleware } from '../connect-router';
+export declare const ConnectedRouter: any;
+export declare const ConnectedHRouter: any;
diff --git a/packages/horizon-router/connectRouter/@types/router/lifeCycleHook.d.ts b/packages/horizon-router/connectRouter/@types/router/lifeCycleHook.d.ts
new file mode 100644
index 00000000..6837c2c0
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/router/lifeCycleHook.d.ts
@@ -0,0 +1,7 @@
+export type LifeCycleProps = {
+    onMount?: () => void;
+    onUpdate?: (prevProps?: LifeCycleProps) => void;
+    onUnmount?: () => void;
+    data?: any;
+};
+export declare function LifeCycle(props: LifeCycleProps): any;
diff --git a/packages/horizon-router/connectRouter/@types/router/matcher/__tests__/lexer.test.d.ts b/packages/horizon-router/connectRouter/@types/router/matcher/__tests__/lexer.test.d.ts
new file mode 100644
index 00000000..cb0ff5c3
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/router/matcher/__tests__/lexer.test.d.ts
@@ -0,0 +1 @@
+export {};
diff --git a/packages/horizon-router/connectRouter/@types/router/matcher/__tests__/parser.test.d.ts b/packages/horizon-router/connectRouter/@types/router/matcher/__tests__/parser.test.d.ts
new file mode 100644
index 00000000..cb0ff5c3
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/router/matcher/__tests__/parser.test.d.ts
@@ -0,0 +1 @@
+export {};
diff --git a/packages/horizon-router/connectRouter/@types/router/matcher/__tests__/utils.test.d.ts b/packages/horizon-router/connectRouter/@types/router/matcher/__tests__/utils.test.d.ts
new file mode 100644
index 00000000..cb0ff5c3
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/router/matcher/__tests__/utils.test.d.ts
@@ -0,0 +1 @@
+export {};
diff --git a/packages/horizon-router/connectRouter/@types/router/matcher/lexer.d.ts b/packages/horizon-router/connectRouter/@types/router/matcher/lexer.d.ts
new file mode 100644
index 00000000..6137743a
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/router/matcher/lexer.d.ts
@@ -0,0 +1,2 @@
+import { Token } from './types';
+export declare function lexer(path: string): Token[];
diff --git a/packages/horizon-router/connectRouter/@types/router/matcher/parser.d.ts b/packages/horizon-router/connectRouter/@types/router/matcher/parser.d.ts
new file mode 100644
index 00000000..ee672cf9
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/router/matcher/parser.d.ts
@@ -0,0 +1,18 @@
+import { GetURLParams, Parser, ParserOption } from './types';
+export type Params<P> = {
+    [K in keyof P]?: P[K];
+};
+export type Matched<P = any> = {
+    score: number[];
+    params: Params<P>;
+    path: string;
+    url: string;
+    isExact: boolean;
+};
+export declare function createPathParser<Str extends string>(pathname: Str, option?: ParserOption): Parser<GetURLParams<Str>>;
+export declare function createPathParser<P = unknown>(pathname: string, option?: ParserOption): Parser<P>;
+/**
+ * @description 依次使用pathname与pattern进行匹配，根据匹配分数取得分数最高结果
+ */
+export declare function matchPath<P = any>(pathname: string, pattern: string | string[], option?: ParserOption): Matched<P> | null;
+export declare function generatePath<P = any>(path: string, params: Params<P>): string;
diff --git a/packages/horizon-router/connectRouter/@types/router/matcher/types.d.ts b/packages/horizon-router/connectRouter/@types/router/matcher/types.d.ts
new file mode 100644
index 00000000..971fbe5b
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/router/matcher/types.d.ts
@@ -0,0 +1,36 @@
+import { Matched, Params } from './parser';
+export type Token = {
+    type: TokenType;
+    value: string;
+};
+export declare enum TokenType {
+    Delimiter = "delimiter",
+    Static = "static",
+    Param = "param",
+    WildCard = "wildcard",
+    LBracket = "(",
+    RBracket = ")",
+    Pattern = "pattern"
+}
+export interface Parser<P> {
+    regexp: RegExp;
+    keys: string[];
+    parse(url: string): Matched<P> | null;
+    compile(params: Params<P>): string;
+}
+export type ParserOption = {
+    caseSensitive?: boolean;
+    strictMode?: boolean;
+    exact?: boolean;
+};
+type ClearLeading<U extends string> = U extends `/${infer R}` ? ClearLeading<R> : U;
+type ClearTailing<U extends string> = U extends `${infer L}/` ? ClearTailing<L> : U;
+type ParseParam<Param extends string> = Param extends `:${infer R}` ? {
+    [K in R]: string;
+} : {};
+type MergeParams<OneParam extends Record<string, any>, OtherParam extends Record<string, any>> = {
+    readonly [Key in keyof OneParam | keyof OtherParam]?: string;
+};
+type ParseURLString<Str extends string> = Str extends `${infer Param}/${infer Rest}` ? MergeParams<ParseParam<Param>, ParseURLString<ClearLeading<Rest>>> : ParseParam<Str>;
+export type GetURLParams<U extends string> = ParseURLString<ClearLeading<ClearTailing<U>>>;
+export {};
diff --git a/packages/horizon-router/connectRouter/@types/router/matcher/utils.d.ts b/packages/horizon-router/connectRouter/@types/router/matcher/utils.d.ts
new file mode 100644
index 00000000..8b739ae7
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/router/matcher/utils.d.ts
@@ -0,0 +1,6 @@
+/**
+ * @description 将url中的//转换为/
+ */
+export declare function cleanPath(path: string): string;
+export declare function scoreCompare(score1: number[], score2: number[]): number;
+export declare function escapeStr(str: string): string;
diff --git a/packages/horizon-router/connectRouter/@types/router/withRouter.d.ts b/packages/horizon-router/connectRouter/@types/router/withRouter.d.ts
new file mode 100644
index 00000000..b6c398cd
--- /dev/null
+++ b/packages/horizon-router/connectRouter/@types/router/withRouter.d.ts
@@ -0,0 +1,3 @@
+import * as React from 'react';
+declare function withRouter<C extends React.ComponentType>(Component: C): (props: any) => JSX.Element;
+export default withRouter;
diff --git a/packages/horizon-router/connectRouter/cjs/connectRouter.js b/packages/horizon-router/connectRouter/cjs/connectRouter.js
new file mode 100644
index 00000000..645c43d3
--- /dev/null
+++ b/packages/horizon-router/connectRouter/cjs/connectRouter.js
@@ -0,0 +1,1787 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var reactRedux = require('react-redux');
+var horizon = require('@cloudsop/horizon');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+
+// 定义位置变化和history方法调用的Action type
+var ActionName = /*#__PURE__*/function (ActionName) {
+  ActionName["LOCATION_CHANGE"] = "$horizon-router/LOCATION_CHANGE";
+  ActionName["CALL_HISTORY_METHOD"] = "$horizon-router/CALL_HISTORY_METHOD";
+  return ActionName;
+}({});
+
+// 定义Action的两种数据类型
+
+var onLocationChanged = function (location, action) {
+  var isFirstRendering = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  return {
+    type: ActionName.LOCATION_CHANGE,
+    payload: {
+      location: location,
+      action: action,
+      isFirstRendering: isFirstRendering
+    }
+  };
+};
+
+// 解析location对象，将其中的query参数解析并注入
+function injectQueryParams(location) {
+  if (location && location.query) {
+    return location;
+  }
+  var queryString = location && location.search;
+  if (!queryString) {
+    return _extends({}, location, {
+      query: {}
+    });
+  }
+  var queryObject = {};
+  var params = new URLSearchParams(queryString);
+  params.forEach(function (value, key) {
+    return queryObject[key] = value;
+  });
+  return _extends({}, location, {
+    query: queryObject
+  });
+}
+function createConnectRouter() {
+  // 初始化redux State
+  return function (history) {
+    var initRouterState = {
+      location: injectQueryParams(history.location),
+      action: history.action
+    };
+
+    // 定义connect-router对应的redux reducer函数
+    return function () {
+      var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initRouterState;
+      var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+        type = _ref.type,
+        payload = _ref.payload;
+      if (type === ActionName.LOCATION_CHANGE) {
+        var location = payload.location,
+          action = payload.action,
+          isFirstRendering = payload.isFirstRendering;
+        if (isFirstRendering) {
+          return state;
+        }
+        return _extends({}, state, {
+          location: injectQueryParams(location),
+          action: action
+        });
+      }
+      return state;
+    };
+  };
+}
+
+function isBrowser() {
+  return typeof window !== 'undefined' && window.document && typeof window.document.createElement === 'function';
+}
+function getDefaultConfirmation(message, callBack) {
+  callBack(window.confirm(message));
+}
+
+// 判断浏览器是否支持pushState方法，pushState是browserHistory实现的基础
+function isSupportHistory() {
+  return isBrowser() && window.history && 'pushState' in window.history;
+}
+
+// 判断浏览器是否支持PopState事件
+function isSupportsPopState() {
+  return window.navigator.userAgent.indexOf('Trident') === -1;
+}
+
+var Action = /*#__PURE__*/function (Action) {
+  Action["pop"] = "POP";
+  Action["push"] = "PUSH";
+  Action["replace"] = "REPLACE";
+  return Action;
+}({});
+var EventType = /*#__PURE__*/function (EventType) {
+  EventType["PopState"] = "popstate";
+  EventType["HashChange"] = "hashchange";
+  return EventType;
+}({});
+
+function createPath(path) {
+  var search = path.search,
+    hash = path.hash;
+  var pathname = path.pathname || '/';
+  if (search && search !== '?') {
+    pathname += search.startsWith('?') ? search : '?' + search;
+  }
+  if (hash && hash !== '#') {
+    pathname += hash.startsWith('#') ? hash : '#' + hash;
+  }
+  return pathname;
+}
+function parsePath(url) {
+  if (!url) {
+    return {};
+  }
+  var parsedPath = {};
+  var hashIdx = url.indexOf('#');
+  if (hashIdx > -1) {
+    parsedPath.hash = url.substring(hashIdx);
+    url = url.substring(0, hashIdx);
+  }
+  var searchIdx = url.indexOf('?');
+  if (searchIdx > -1) {
+    parsedPath.search = url.substring(searchIdx);
+    url = url.substring(0, searchIdx);
+  }
+  if (url) {
+    parsedPath.pathname = url;
+  }
+  return parsedPath;
+}
+function createLocation(current, to, state, key) {
+  var pathname = typeof current === 'string' ? current : current.pathname;
+  var urlObj = typeof to === 'string' ? parsePath(to) : to;
+  // 随机key长度取6
+  var getRandKey = genRandomKey(6);
+  var location = _extends({
+    pathname: pathname,
+    search: '',
+    hash: '',
+    state: state,
+    key: typeof key === 'string' ? key : getRandKey()
+  }, urlObj);
+  if (!location.pathname) {
+    location.pathname = '/';
+  }
+  return location;
+}
+function isLocationEqual(p1, p2) {
+  return p1.pathname === p2.pathname && p1.search === p2.search && p1.hash === p2.hash;
+}
+function addHeadSlash(path) {
+  if (path[0] === '/') {
+    return path;
+  }
+  return '/' + path;
+}
+function stripHeadSlash(path) {
+  if (path[0] === '/') {
+    return path.substring(1);
+  }
+  return path;
+}
+function normalizeSlash(path) {
+  var tempPath = addHeadSlash(path);
+  if (tempPath[tempPath.length - 1] === '/') {
+    return tempPath.substring(0, tempPath.length - 1);
+  }
+  return tempPath;
+}
+function hasBasename(path, prefix) {
+  return path.toLowerCase().indexOf(prefix.toLowerCase()) === 0 && ['/', '?', '#', ''].includes(path.charAt(prefix.length));
+}
+function stripBasename(path, prefix) {
+  return hasBasename(path, prefix) ? path.substring(prefix.length) : path;
+}
+
+// 使用随机生成的Key记录被访问过的URL，当Block被被触发时利用delta值跳转到之前的页面
+function createMemoryRecord(initVal, fn) {
+  var visitedRecord = [fn(initVal)];
+  function getDelta(to, form) {
+    var toIdx = visitedRecord.lastIndexOf(fn(to));
+    if (toIdx === -1) {
+      toIdx = 0;
+    }
+    var fromIdx = visitedRecord.lastIndexOf(fn(form));
+    if (fromIdx === -1) {
+      fromIdx = 0;
+    }
+    return toIdx - fromIdx;
+  }
+  function addRecord(current, newRecord, action) {
+    var curVal = fn(current);
+    var NewVal = fn(newRecord);
+    if (action === Action.push) {
+      var prevIdx = visitedRecord.lastIndexOf(curVal);
+      var newVisitedRecord = visitedRecord.slice(0, prevIdx + 1);
+      newVisitedRecord.push(NewVal);
+      visitedRecord = newVisitedRecord;
+    }
+    if (action === Action.replace) {
+      var _prevIdx = visitedRecord.lastIndexOf(curVal);
+      if (_prevIdx !== -1) {
+        visitedRecord[_prevIdx] = NewVal;
+      }
+    }
+  }
+  return {
+    getDelta: getDelta,
+    addRecord: addRecord
+  };
+}
+function genRandomKey(length) {
+  var end = length + 2;
+  return function () {
+    return Math.random().toString(18).substring(2, end);
+  };
+}
+
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+  }, _typeof(obj);
+}
+
+function _toPrimitive(input, hint) {
+  if (_typeof(input) !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (_typeof(res) !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return _typeof(key) === "symbol" ? key : String(key);
+}
+
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+
+function _createForOfIteratorHelper$1(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$1(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function () {}; return { s: F, n: function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function (e) { throw e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function () { it = it.call(o); }, n: function () { var step = it.next(); normalCompletion = step.done; return step; }, e: function (e) { didErr = true; err = e; }, f: function () { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray$1(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$1(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$1(o, minLen); }
+function _arrayLikeToArray$1(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+var TransitionManager = /*#__PURE__*/function () {
+  function TransitionManager() {
+    _classCallCheck(this, TransitionManager);
+    this.prompt = void 0;
+    this.listeners = void 0;
+    this.prompt = null;
+    this.listeners = [];
+  }
+  _createClass(TransitionManager, [{
+    key: "setPrompt",
+    value: function setPrompt(prompt) {
+      var _this = this;
+      this.prompt = prompt;
+
+      // 清除Prompt
+      return function () {
+        if (_this.prompt === prompt) {
+          _this.prompt = null;
+        }
+      };
+    }
+
+    // 使用发布订阅模式管理history的监听者
+  }, {
+    key: "addListener",
+    value: function addListener(func) {
+      var _this2 = this;
+      var isActive = true;
+      var listener = function (args) {
+        if (isActive) {
+          func(args);
+        }
+      };
+      this.listeners.push(listener);
+      return function () {
+        isActive = false;
+        // 移除对应的监听者
+        _this2.listeners = _this2.listeners.filter(function (item) {
+          return item !== listener;
+        });
+      };
+    }
+  }, {
+    key: "notifyListeners",
+    value: function notifyListeners(args) {
+      var _iterator = _createForOfIteratorHelper$1(this.listeners),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var listener = _step.value;
+          listener(args);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+  }, {
+    key: "confirmJumpTo",
+    value: function confirmJumpTo(location, action, userConfirmationFunc, callBack) {
+      if (this.prompt !== null) {
+        var result = typeof this.prompt === 'function' ? this.prompt(location, action) : this.prompt;
+        if (typeof result === 'string') {
+          typeof userConfirmationFunc === 'function' ? userConfirmationFunc(result, callBack) : callBack(true);
+        } else {
+          callBack(result !== false);
+        }
+      } else {
+        callBack(true);
+      }
+    }
+  }]);
+  return TransitionManager;
+}();
+
+function warning(condition, message) {
+  if (condition) {
+    if (console && typeof console.warn === 'function') {
+      console.warn(message);
+    }
+  }
+}
+
+// 抽取BrowserHistory和HashHistory中相同的方法
+function getBaseHistory(transitionManager, setListener, browserHistory) {
+  function go(step) {
+    browserHistory.go(step);
+  }
+  function goBack() {
+    browserHistory.go(-1);
+  }
+  function goForward() {
+    browserHistory.go(1);
+  }
+  function listen(listener) {
+    var cancel = transitionManager.addListener(listener);
+    setListener(1);
+    return function () {
+      setListener(-1);
+      cancel();
+    };
+  }
+  var isBlocked = false;
+  function block() {
+    var prompt = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    var unblock = transitionManager.setPrompt(prompt);
+    if (!isBlocked) {
+      setListener(1);
+      isBlocked = true;
+    }
+    return function () {
+      if (isBlocked) {
+        isBlocked = false;
+        setListener(-1);
+      }
+      unblock();
+    };
+  }
+  function getUpdateStateFunc(historyProps) {
+    return function (nextState) {
+      if (nextState) {
+        _extends(historyProps, nextState);
+      }
+      historyProps.length = browserHistory.length;
+      var args = {
+        location: historyProps.location,
+        action: historyProps.action
+      };
+      transitionManager.notifyListeners(args);
+    };
+  }
+  return {
+    go: go,
+    goBack: goBack,
+    goForward: goForward,
+    listen: listen,
+    block: block,
+    getUpdateStateFunc: getUpdateStateFunc
+  };
+}
+
+function createBrowserHistory() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var supportHistory = isSupportHistory();
+  var isSupportPopState = isSupportsPopState();
+  var browserHistory = window.history;
+  var _options$forceRefresh = options.forceRefresh,
+    forceRefresh = _options$forceRefresh === void 0 ? false : _options$forceRefresh,
+    _options$getUserConfi = options.getUserConfirmation,
+    getUserConfirmation = _options$getUserConfi === void 0 ? getDefaultConfirmation : _options$getUserConfi;
+  var basename = options.basename ? normalizeSlash(options.basename) : '';
+  var initLocation = getLocation(getHistoryState());
+  var recordOperator = createMemoryRecord(initLocation, function (l) {
+    return l.key;
+  });
+  var transitionManager = new TransitionManager();
+  var _getBaseHistory = getBaseHistory(transitionManager, setListener, browserHistory),
+    go = _getBaseHistory.go,
+    goBack = _getBaseHistory.goBack,
+    goForward = _getBaseHistory.goForward,
+    listen = _getBaseHistory.listen,
+    block = _getBaseHistory.block,
+    getUpdateStateFunc = _getBaseHistory.getUpdateStateFunc;
+  var history = {
+    action: Action.pop,
+    length: browserHistory.length,
+    location: initLocation,
+    go: go,
+    goBack: goBack,
+    goForward: goForward,
+    listen: listen,
+    block: block,
+    push: push,
+    replace: replace,
+    createHref: createHref
+  };
+  var updateState = getUpdateStateFunc(history);
+  function getHistoryState() {
+    return supportHistory ? window.history.state : {};
+  }
+  function getLocation(historyState) {
+    var _window$location = window.location,
+      search = _window$location.search,
+      hash = _window$location.hash;
+    var _ref = historyState || {},
+      key = _ref.key,
+      state = _ref.state;
+    var pathname = window.location.pathname;
+    pathname = basename ? stripBasename(pathname, basename) : pathname;
+    return createLocation('', {
+      pathname: pathname,
+      search: search,
+      hash: hash
+    }, state, key);
+  }
+
+  // 拦截页面POP事件后，防止返回到的页面被重复拦截
+  var forceJump = false;
+  function handlePopState(location) {
+    if (forceJump) {
+      forceJump = false;
+      updateState(undefined);
+    } else {
+      var action = Action.pop;
+      var callback = function (isJump) {
+        if (isJump) {
+          // 执行跳转行为
+          updateState({
+            action: action,
+            location: location
+          });
+        } else {
+          revertPopState(location, history.location);
+        }
+      };
+      transitionManager.confirmJumpTo(location, action, getUserConfirmation, callback);
+    }
+  }
+  function popStateListener(event) {
+    handlePopState(getLocation(event.state));
+  }
+  function hashChangeListener() {
+    var location = getLocation(getHistoryState());
+    handlePopState(location);
+  }
+  var listenerCount = 0;
+  function setListener(count) {
+    listenerCount += count;
+    if (listenerCount === 1 && count === 1) {
+      window.addEventListener(EventType.PopState, popStateListener);
+      if (!isSupportPopState) {
+        window.addEventListener(EventType.HashChange, hashChangeListener);
+      }
+    } else if (listenerCount === 0) {
+      window.removeEventListener(EventType.PopState, popStateListener);
+      if (!isSupportPopState) {
+        window.removeEventListener(EventType.HashChange, hashChangeListener);
+      }
+    }
+  }
+
+  // 取消页面跳转并恢复到跳转前的页面
+  function revertPopState(form, to) {
+    var delta = recordOperator.getDelta(to, form);
+    if (delta !== 0) {
+      go(delta);
+      forceJump = true;
+    }
+  }
+  function createHref(path) {
+    return basename + createPath(path);
+  }
+  function push(to, state) {
+    var action = Action.push;
+    var location = createLocation(history.location, to, state, undefined);
+    transitionManager.confirmJumpTo(location, action, getUserConfirmation, function (isJump) {
+      if (!isJump) {
+        return;
+      }
+      var href = createHref(location);
+      var key = location.key,
+        state = location.state;
+      if (supportHistory) {
+        if (forceRefresh) {
+          window.location.href = href;
+        } else {
+          browserHistory.pushState({
+            key: key,
+            state: state
+          }, '', href);
+          recordOperator.addRecord(history.location, location, action);
+          updateState({
+            action: action,
+            location: location
+          });
+        }
+      } else {
+        warning(state !== undefined, 'Browser history cannot push state in browsers that do not support HTML5 history');
+        window.location.href = href;
+      }
+    });
+  }
+  function replace(to, state) {
+    var action = Action.replace;
+    var location = createLocation(history.location, to, state, undefined);
+    transitionManager.confirmJumpTo(location, action, getUserConfirmation, function (isJump) {
+      if (!isJump) {
+        return;
+      }
+      var href = createHref(location);
+      var key = location.key,
+        state = location.state;
+      if (supportHistory) {
+        if (forceRefresh) {
+          window.location.replace(href);
+        } else {
+          browserHistory.replaceState({
+            key: key,
+            state: state
+          }, '', href);
+          recordOperator.addRecord(history.location, location, action);
+          updateState({
+            action: action,
+            location: location
+          });
+        }
+      } else {
+        warning(state !== undefined, 'Browser history cannot push state in browsers that do not support HTML5 history');
+        window.location.replace(href);
+      }
+    });
+  }
+  return history;
+}
+
+// 获取#前的内容
+function stripHash(path) {
+  var idx = path.indexOf('#');
+  return idx === -1 ? path : path.substring(0, idx);
+}
+
+// 获取#后的内容
+function getHashContent(path) {
+  var idx = path.indexOf('#');
+  return idx === -1 ? '' : path.substring(idx + 1);
+}
+function createHashHistory() {
+  var option = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var browserHistory = window.history;
+  var _option$hashType = option.hashType,
+    hashType = _option$hashType === void 0 ? 'slash' : _option$hashType,
+    _option$getUserConfir = option.getUserConfirmation,
+    getUserConfirmation = _option$getUserConfir === void 0 ? getDefaultConfirmation : _option$getUserConfir;
+  var basename = option.basename ? normalizeSlash(option.basename) : '';
+  var pathDecoder = addHeadSlash;
+  var pathEncoder = hashType === 'slash' ? addHeadSlash : stripHeadSlash;
+  function getLocation() {
+    var hashPath = pathDecoder(getHashContent(window.location.hash));
+    if (basename) {
+      hashPath = stripBasename(hashPath, basename);
+    }
+    return createLocation('', hashPath, undefined, 'default');
+  }
+  var initLocation = getLocation();
+  var memRecords = createMemoryRecord(initLocation, createPath);
+  var transitionManager = new TransitionManager();
+  function createHref(location) {
+    var tag = document.querySelector('base');
+    var base = tag && tag.getAttribute('href') ? stripHash(window.location.href) : '';
+    return base + '#' + pathEncoder(basename + createPath(location));
+  }
+  var forceNextPop = false;
+  var ignorePath = null;
+  var _getBaseHistory = getBaseHistory(transitionManager, setListener, browserHistory),
+    go = _getBaseHistory.go,
+    goBack = _getBaseHistory.goBack,
+    goForward = _getBaseHistory.goForward,
+    listen = _getBaseHistory.listen,
+    block = _getBaseHistory.block,
+    getUpdateStateFunc = _getBaseHistory.getUpdateStateFunc;
+  var history = {
+    action: Action.pop,
+    length: browserHistory.length,
+    location: initLocation,
+    go: go,
+    goBack: goBack,
+    goForward: goForward,
+    push: push,
+    replace: replace,
+    listen: listen,
+    block: block,
+    createHref: createHref
+  };
+  var updateState = getUpdateStateFunc(history);
+  function push(to, state) {
+    warning(state !== undefined, 'Hash history does not support state, it will be ignored');
+    var action = Action.push;
+    var location = createLocation(history.location, to, undefined, '');
+    transitionManager.confirmJumpTo(location, action, getUserConfirmation, function (isJump) {
+      if (!isJump) {
+        return;
+      }
+      var path = createPath(location);
+      var encodedPath = pathEncoder(basename + path);
+      // 前后hash不一样才进行跳转
+      if (getHashContent(window.location.href) !== encodedPath) {
+        ignorePath = encodedPath;
+        window.location.hash = encodedPath;
+        memRecords.addRecord(history.location, location, action);
+        updateState({
+          action: action,
+          location: location
+        });
+      } else {
+        updateState(undefined);
+      }
+    });
+  }
+  function replace(to, state) {
+    warning(state !== undefined, 'Hash history does not support state, it will be ignored');
+    var action = Action.replace;
+    var location = createLocation(history.location, to, undefined, '');
+    transitionManager.confirmJumpTo(location, action, getUserConfirmation, function (isJump) {
+      if (!isJump) {
+        return;
+      }
+      var path = createPath(location);
+      var encodedPath = pathEncoder(basename + path);
+      if (getHashContent(window.location.href) !== encodedPath) {
+        ignorePath = path;
+        window.location.replace(stripHash(window.location.href) + '#' + encodedPath);
+      }
+      memRecords.addRecord(history.location, location, action);
+      updateState({
+        action: action,
+        location: location
+      });
+    });
+  }
+  function handleHashChange() {
+    var hashPath = getHashContent(window.location.href);
+    var encodedPath = pathEncoder(hashPath);
+    if (hashPath !== encodedPath) {
+      window.location.replace(stripHash(window.location.href) + '#' + encodedPath);
+    } else {
+      var location = getLocation();
+      var prevLocation = history.location;
+      if (!forceNextPop && isLocationEqual(location, prevLocation)) {
+        return;
+      }
+      if (ignorePath === createPath(location)) {
+        return;
+      }
+      ignorePath = null;
+      handlePopState(location);
+    }
+  }
+  function handlePopState(location) {
+    if (forceNextPop) {
+      forceNextPop = false;
+      updateState(undefined);
+    } else {
+      var action = Action.pop;
+      var callback = function (isJump) {
+        if (isJump) {
+          updateState({
+            action: action,
+            location: location
+          });
+        } else {
+          revertPopState(location);
+        }
+      };
+      transitionManager.confirmJumpTo(location, action, getUserConfirmation, callback);
+    }
+  }
+
+  // 在跳转行为被Block后，用History.go()跳转回之前的页面
+  function revertPopState(form) {
+    var to = history.location;
+    var delta = memRecords.getDelta(to, form);
+    if (delta !== 0) {
+      go(delta);
+      forceNextPop = true;
+    }
+  }
+  var listenerCount = 0;
+  function setListener(delta) {
+    listenerCount += delta;
+    if (listenerCount === 1 && delta === 1) {
+      window.addEventListener(EventType.HashChange, handleHashChange);
+    } else if (listenerCount === 0) {
+      window.removeEventListener(EventType.HashChange, handleHashChange);
+    }
+  }
+  return history;
+}
+
+function createNamedContext(name, defaultValue) {
+  var context = React.createContext(defaultValue);
+  context.displayName = name;
+  return context;
+}
+var RouterContext = createNamedContext('Router', {});
+
+var TokenType = /*#__PURE__*/function (TokenType) {
+  TokenType["Delimiter"] = "delimiter";
+  TokenType["Static"] = "static";
+  TokenType["Param"] = "param";
+  TokenType["WildCard"] = "wildcard";
+  TokenType["LBracket"] = "(";
+  TokenType["RBracket"] = ")";
+  TokenType["Pattern"] = "pattern";
+  return TokenType;
+}({});
+
+// 解析URL中的动态参数，以实现TypeScript提示功能
+
+/**
+ * @description 将url中的//转换为/
+ */
+function cleanPath(path) {
+  return path.replace(/\/+/g, '/');
+}
+function scoreCompare(score1, score2) {
+  var score1Length = score1.length;
+  var score2Length = score2.length;
+  var end = Math.min(score1Length, score2Length);
+  for (var i = 0; i < end; i++) {
+    var delta = score2[i] - score1[i];
+    if (delta !== 0) {
+      return delta;
+    }
+  }
+  if (score1Length === score2Length) {
+    return 0;
+  }
+  return score1Length > score2Length ? -1 : 1;
+}
+
+// 把正则表达式的特殊符号加两个反斜杠进行转义
+function escapeStr(str) {
+  return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, '\\$1');
+}
+
+var validChar = /[^/:*()]/;
+
+// 对Url模板进行词法解析，解析结果为Tokens
+function lexer(path) {
+  var tokens = [];
+  if (!path) {
+    return tokens;
+  }
+  var urlPath = cleanPath(path);
+  if (urlPath !== '*' && !urlPath.startsWith('/')) {
+    throw new Error("Url must start with \"/\".");
+  }
+  var getLiteral = function () {
+    var name = '';
+    while (i < urlPath.length && validChar.test(urlPath[i])) {
+      name += urlPath[i];
+      skipChar(1);
+    }
+    return name;
+  };
+  var skipChar = function (step) {
+    i += step;
+  };
+  var i = 0;
+  while (i < urlPath.length) {
+    var curChar = urlPath[i];
+    var prevChar = urlPath[i - 1];
+    if (curChar === '/') {
+      tokens.push({
+        type: TokenType.Delimiter,
+        value: urlPath[i]
+      });
+      skipChar(1);
+      continue;
+    }
+    // dynamic params (/:a)
+    if (prevChar === '/' && curChar === ':') {
+      skipChar(1);
+      tokens.push({
+        type: TokenType.Param,
+        value: getLiteral()
+      });
+      continue;
+    }
+    // wildCard params (/:*)
+    if ((prevChar === '/' || prevChar === undefined) && curChar === '*') {
+      tokens.push({
+        type: TokenType.WildCard,
+        value: urlPath[i]
+      });
+      skipChar(1);
+      continue;
+    }
+    // static params
+    if (prevChar === '/' && validChar.test(curChar)) {
+      tokens.push({
+        type: TokenType.Static,
+        value: getLiteral()
+      });
+      continue;
+    }
+    if (curChar === '(') {
+      tokens.push({
+        type: TokenType.LBracket,
+        value: '('
+      });
+      skipChar(1);
+      continue;
+    }
+    if (curChar === ')') {
+      tokens.push({
+        type: TokenType.RBracket,
+        value: ')'
+      });
+      skipChar(1);
+      continue;
+    }
+    if (validChar.test(curChar)) {
+      tokens.push({
+        type: TokenType.Pattern,
+        value: getLiteral()
+      });
+      continue;
+    }
+    // 跳过非法字符
+    skipChar(1);
+  }
+  return tokens;
+}
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function () {}; return { s: F, n: function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function (e) { throw e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function () { it = it.call(o); }, n: function () { var step = it.next(); normalCompletion = step.done; return step; }, e: function (e) { didErr = true; err = e; }, f: function () { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+// 不同类型参数的匹配得分
+var MatchScore = /*#__PURE__*/function (MatchScore) {
+  MatchScore[MatchScore["static"] = 10] = "static";
+  MatchScore[MatchScore["param"] = 6] = "param";
+  MatchScore[MatchScore["wildcard"] = 3] = "wildcard";
+  MatchScore[MatchScore["placeholder"] = -1] = "placeholder";
+  return MatchScore;
+}(MatchScore || {}); // 兼容 react v5 matched类型
+var defaultOption = {
+  // url匹配时是否大小写敏感
+  caseSensitive: true,
+  // 是否严格匹配url结尾的/
+  strictMode: false,
+  // 是否完全精确匹配
+  exact: false
+};
+// 正则表达式中需要转义的字符
+var REGEX_CHARS_RE = /[.+*?^${}()[\]/\\]/g;
+// 用于匹配两个//中的的值
+var BASE_PARAM_PATTERN = '[^/]+';
+var DefaultDelimiter = '/#?';
+function createPathParser(pathname) {
+  var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultOption;
+  var _option$caseSensitive = option.caseSensitive,
+    caseSensitive = _option$caseSensitive === void 0 ? defaultOption.caseSensitive : _option$caseSensitive,
+    _option$strictMode = option.strictMode,
+    strictMode = _option$strictMode === void 0 ? defaultOption.strictMode : _option$strictMode,
+    _option$exact = option.exact,
+    exact = _option$exact === void 0 ? defaultOption.exact : _option$exact;
+  /**
+   * URL匹配整体流程
+   * 1.词法解析，将URL模板解析为Token
+   * 2.使用Token生成正则表达式
+   * 3.利用正则表达式解析URL中参数或填充URL模板
+   */
+  var pattern = '^';
+  var keys = [];
+  var scores = [];
+  var tokens = lexer(pathname);
+  var onlyHasWildCard = tokens.length === 1 && tokens[0].type === TokenType.WildCard;
+  var tokenCount = tokens.length;
+  var lastToken = tokens[tokenCount - 1];
+  for (var tokenIdx = 0; tokenIdx < tokenCount; tokenIdx++) {
+    var token = tokens[tokenIdx];
+    var nextToken = tokens[tokenIdx + 1];
+    switch (token.type) {
+      case TokenType.Delimiter:
+        pattern += '/';
+        break;
+      case TokenType.Static:
+        pattern += token.value.replace(REGEX_CHARS_RE, '\\$&');
+        scores.push(MatchScore.static);
+        break;
+      case TokenType.Param:
+        var paramRegexp = '';
+        if (nextToken && nextToken.type === TokenType.LBracket) {
+          // 跳过当前Token和左括号
+          tokenIdx += 2;
+          while (tokens[tokenIdx].type !== TokenType.RBracket) {
+            paramRegexp += tokens[tokenIdx].value;
+            tokenIdx++;
+          }
+        }
+        pattern += paramRegexp ? "((?:" + paramRegexp + "))" : "(" + BASE_PARAM_PATTERN + ")";
+        keys.push(token.value);
+        scores.push(MatchScore.param);
+        break;
+      case TokenType.WildCard:
+        keys.push(token.value);
+        pattern += "((?:" + BASE_PARAM_PATTERN + ")" + (onlyHasWildCard ? '?' : '') + "(?:/(?:" + BASE_PARAM_PATTERN + "))*)";
+        scores.push(onlyHasWildCard ? MatchScore.wildcard : MatchScore.placeholder);
+        break;
+    }
+  }
+  var isWildCard = lastToken.type === TokenType.WildCard;
+  if (!isWildCard && !exact) {
+    if (!strictMode) {
+      pattern += "(?:[" + escapeStr(DefaultDelimiter) + "](?=$))?";
+    }
+    if (lastToken.type !== TokenType.Delimiter) {
+      pattern += "(?=[" + escapeStr(DefaultDelimiter) + "]|$)";
+    }
+  } else {
+    pattern += strictMode ? '$' : "[" + escapeStr(DefaultDelimiter) + "]?$";
+  }
+  var flag = caseSensitive ? '' : 'i';
+  var regexp = new RegExp(pattern, flag);
+
+  /**
+   * @description 根据给定Pattern解析path
+   */
+  function parse(path) {
+    var reMatch = path.match(regexp);
+    if (!reMatch) {
+      return null;
+    }
+    var matchedPath = reMatch[0];
+    var params = {};
+    var parseScore = Array.from(scores);
+    for (var i = 1; i < reMatch.length; i++) {
+      var param = reMatch[i];
+      var key = keys[i - 1];
+      if (key === '*' && param) {
+        var value = param.split('/');
+        if (!Array.isArray(params['*'])) {
+          params['*'] = value;
+        } else {
+          var _params$;
+          (_params$ = params['*']).push.apply(_params$, value);
+        }
+        // 完成通配符参数解析后将placeholder替换为wildcard参数的分值
+        parseScore.splice.apply(parseScore, [scores.indexOf(MatchScore.placeholder), 1].concat(new Array(value.length).fill(MatchScore.wildcard)));
+      } else {
+        params[key] = param ? param : [];
+      }
+    }
+    var isExact = path === matchedPath;
+    var url = path === '/' && matchedPath === '' ? '/' : matchedPath;
+    return {
+      isExact: isExact,
+      path: pathname,
+      url: url,
+      score: parseScore,
+      params: params
+    };
+  }
+
+  /**
+   * @description 使用给定参数填充pattern，得到目标URL
+   */
+  function compile(params) {
+    var path = '';
+    var _iterator = _createForOfIteratorHelper(tokens),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _token = _step.value;
+        switch (_token.type) {
+          case TokenType.Static:
+            path += _token.value;
+            break;
+          case TokenType.Param:
+            if (!params[_token.value]) {
+              throw new Error('Param is invalid.');
+            }
+            path += params[_token.value];
+            break;
+          case TokenType.WildCard:
+            var wildCard = params['*'];
+            if (wildCard instanceof Array) {
+              path += wildCard.join('/');
+            } else {
+              path += wildCard;
+            }
+            break;
+          case TokenType.Delimiter:
+            path += _token.value;
+            break;
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return path;
+  }
+  return {
+    get regexp() {
+      return regexp;
+    },
+    get keys() {
+      return keys;
+    },
+    compile: compile,
+    parse: parse
+  };
+}
+
+/**
+ * @description 依次使用pathname与pattern进行匹配，根据匹配分数取得分数最高结果
+ */
+function matchPath(pathname, pattern, option) {
+  var patterns = Array.isArray(pattern) ? [].concat(pattern) : [pattern];
+  var matchedResults = [];
+  var _iterator2 = _createForOfIteratorHelper(patterns),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var item = _step2.value;
+      var parser = createPathParser(item, option);
+      var matched = parser.parse(pathname);
+      if (matched) {
+        matchedResults.push(matched);
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return !matchedResults.length ? null : matchedResults.sort(function (a, b) {
+    return scoreCompare(a.score, b.score);
+  })[0];
+}
+function generatePath(path, params) {
+  var parser = createPathParser(path);
+  return parser.compile(params);
+}
+
+function useHistory() {
+  return React.useContext(RouterContext).history;
+}
+function useLocation() {
+  return React.useContext(RouterContext).location;
+}
+function useParams() {
+  var match = React.useContext(RouterContext).match;
+  return match ? match.params : {};
+}
+function useRouteMatch(path) {
+  var pathname = useLocation().pathname;
+  var match = React.useContext(RouterContext).match;
+  if (path) {
+    return matchPath(pathname, path);
+  }
+  return match;
+}
+
+function Route(props) {
+  var context = React.useContext(RouterContext);
+  var computed = props.computed,
+    location = props.location,
+    path = props.path;
+  var children = props.children,
+    component = props.component,
+    render = props.render;
+  var match;
+  var routeLocation = location || context.location;
+  if (computed) {
+    match = computed;
+  } else if (path) {
+    match = matchPath(routeLocation.pathname, path);
+  } else {
+    match = context.match;
+  }
+  var newProps = _extends({}, context, {
+    location: routeLocation,
+    match: match
+  });
+  if (Array.isArray(children) && React.Children.count(children) === 0) {
+    children = null;
+  }
+
+  /**
+   * 按顺序获取需要渲染的组件
+   * 1.children
+   * 2.component
+   * 3.render
+   * 都没有匹配到返回Null
+   */
+  var getChildren = function () {
+    // 如果 match 存在
+    if (newProps.match) {
+      if (children) {
+        if (typeof children === 'function') {
+          return children(newProps);
+        }
+        return children;
+      }
+      if (component) {
+        return React.createElement(component, newProps);
+      } else if (render) {
+        return render(newProps);
+      } else {
+        return null;
+      }
+    } else {
+      // match为null
+      if (typeof children === 'function') {
+        return children(newProps);
+      }
+      return null;
+    }
+  };
+  return /*#__PURE__*/React__namespace.createElement(RouterContext.Provider, {
+    value: newProps
+  }, getChildren());
+}
+
+function Router(props) {
+  var history = props.history,
+    _props$children = props.children,
+    children = _props$children === void 0 ? null : _props$children;
+  var _useState = React.useState(props.history.location),
+    location = _useState[0],
+    setLocation = _useState[1];
+  var pendingLocation = React.useRef(null);
+
+  // 在Router加载时就监听history地址变化，以保证在始渲染时重定向能正确触发
+  var unListen = history.listen(function (arg) {
+    pendingLocation.current = arg.location;
+  });
+
+  // 模拟componentDidMount和componentWillUnmount
+  React.useLayoutEffect(function () {
+    if (unListen) {
+      unListen();
+    }
+    // 监听history中的位置变化
+    unListen = history.listen(function (arg) {
+      setLocation(arg.location);
+    });
+    if (pendingLocation.current) {
+      setLocation(pendingLocation.current);
+    }
+    return function () {
+      if (unListen) {
+        unListen();
+        unListen = null;
+        pendingLocation.current = null;
+      }
+    };
+  }, []);
+  var initContextValue = React.useMemo(function () {
+    return {
+      history: history,
+      location: location,
+      match: {
+        isExact: location.pathname === '/',
+        params: {},
+        path: '/',
+        score: [],
+        url: '/'
+      }
+    };
+  }, [location]);
+  return /*#__PURE__*/React__namespace.createElement(RouterContext.Provider, {
+    value: initContextValue,
+    children: children
+  });
+}
+
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+  return target;
+}
+
+function LifeCycle(props) {
+  // 使用ref保存上一次的props，防止重新渲染
+  var prevProps = React.useRef(null);
+  var isMount = React.useRef(false);
+  var onMount = props.onMount,
+    onUpdate = props.onUpdate,
+    onUnmount = props.onUnmount;
+  React.useLayoutEffect(function () {
+    // 首次挂载 模拟componentDidMount
+    if (!isMount.current) {
+      isMount.current = true;
+      if (onMount) {
+        onMount();
+      }
+    } else {
+      // 不是首次渲染 模拟componentDidUpdate
+      if (onUpdate) {
+        prevProps.current ? onUpdate(prevProps.current) : onUpdate();
+      }
+    }
+    prevProps.current = props;
+  });
+
+  // 模拟componentWillUnmount
+  React.useLayoutEffect(function () {
+    return function () {
+      if (onUnmount) {
+        onUnmount();
+      }
+    };
+  }, []);
+  return null;
+}
+
+var _excluded$2 = ["state"];
+function Redirect(props) {
+  var to = props.to,
+    _props$push = props.push,
+    push = _props$push === void 0 ? false : _props$push,
+    computed = props.computed;
+  var context = React.useContext(RouterContext);
+  var history = context.history;
+  var calcLocation = function () {
+    if (computed) {
+      if (typeof to === 'string') {
+        var parser = createPathParser(to);
+        var target = parser.compile(computed.params);
+        return parsePath(target);
+      } else {
+        var pathname = to.pathname ? addHeadSlash(to.pathname) : '/';
+        var _parser = createPathParser(pathname);
+        var _target = _parser.compile(computed.params);
+        return _extends({}, to, {
+          pathname: _target
+        });
+      }
+    }
+    return typeof to === 'string' ? parsePath(to) : to;
+  };
+  var navigate = push ? history.push : history.replace;
+  var _calcLocation = calcLocation(),
+    state = _calcLocation.state,
+    path = _objectWithoutPropertiesLoose(_calcLocation, _excluded$2);
+  var onMountFunc = function () {
+    navigate(path, state);
+  };
+  var onUpdateFunc = function (prevProps) {
+    // 如果当前页面与重定向前页面不一致，执行跳转
+    var prevPath = prevProps === null || prevProps === void 0 ? void 0 : prevProps.data;
+    if (!isLocationEqual(prevPath, path)) {
+      navigate(path, state);
+    }
+  };
+  return /*#__PURE__*/React__namespace.createElement(LifeCycle, {
+    onMount: onMountFunc,
+    onUpdate: onUpdateFunc,
+    data: path
+  });
+}
+
+function Switch(props) {
+  var context = React.useContext(RouterContext);
+  var location = props.location || context.location;
+  var element = null;
+  var match = null;
+
+  // 使用forEach不会给React.ReactNode增加key属性,防止重新渲染
+  React.Children.forEach(props.children, function (node) {
+    if (match === null && React.isValidElement(node)) {
+      element = node;
+      var strict;
+      var sensitive;
+      var path;
+      var from;
+
+      // node可能是Route和Redirect
+      if (node.type === Route) {
+        var _props = node.props;
+        strict = _props.strict;
+        sensitive = _props.sensitive;
+        path = _props.path;
+      } else if (node.type === Redirect) {
+        var _props2 = node.props;
+        path = _props2.path;
+        strict = _props2.strict;
+        from = _props2.from;
+      }
+      var exact = node.props.exact;
+      var target = path || from;
+
+      // 更新匹配状态，一旦匹配到停止遍历
+      if (target) {
+        match = matchPath(location.pathname, target, {
+          strictMode: strict,
+          caseSensitive: sensitive,
+          exact: exact
+        });
+      } else {
+        match = context.match;
+      }
+    }
+  });
+  if (match && element) {
+    // 使用cloneElement复制已有组件并更新其Props
+    return React.cloneElement(element, {
+      location: location,
+      computed: match
+    });
+  }
+  return null;
+}
+
+function Prompt(props) {
+  var context = React.useContext(RouterContext);
+  var message = props.message,
+    _props$when = props.when,
+    when = _props$when === void 0 ? true : _props$when;
+  if (typeof when === 'function' && when(context.location) === false || !when) {
+    return null;
+  }
+  var navigate = context.history.block;
+  var release = null;
+  var onMountFunc = function () {
+    release = message ? navigate(message) : null;
+  };
+  var onUpdateFunc = function (prevProps) {
+    if (prevProps && prevProps.data !== message) {
+      if (release) {
+        release();
+      }
+      release = message ? navigate(message) : null;
+    }
+  };
+  var onUnmountFunc = function () {
+    if (release) {
+      release();
+    }
+    release = null;
+  };
+  return /*#__PURE__*/React__namespace.createElement(LifeCycle, {
+    onMount: onMountFunc,
+    onUpdate: onUpdateFunc,
+    onUnmount: onUnmountFunc,
+    data: message
+  });
+}
+
+function withRouter(Component) {
+  function ComponentWithRouterProp(props) {
+    var _useContext = React.useContext(RouterContext),
+      history = _useContext.history,
+      location = _useContext.location,
+      match = _useContext.match;
+    var routeProps = {
+      history: history,
+      location: location,
+      match: match
+    };
+    return /*#__PURE__*/React__namespace.createElement(Component, _extends({}, props, routeProps));
+  }
+  return ComponentWithRouterProp;
+}
+
+function HashRouter(props) {
+  var historyRef = React.useRef();
+  if (historyRef.current === null || historyRef.current === undefined) {
+    historyRef.current = createHashHistory({
+      basename: props.basename,
+      getUserConfirmation: props.getUserConfirmation,
+      hashType: props.hashType
+    });
+  }
+  return /*#__PURE__*/React__namespace.createElement(Router, {
+    history: historyRef.current
+  }, props.children);
+}
+
+function BrowserRouter(props) {
+  // 使用Ref持有History对象，防止重复渲染
+  var historyRef = React.useRef();
+  if (historyRef.current === null || historyRef.current === undefined) {
+    historyRef.current = createBrowserHistory({
+      basename: props.basename,
+      forceRefresh: props.forceRefresh,
+      getUserConfirmation: props.getUserConfirmation
+    });
+  }
+  return /*#__PURE__*/React__namespace.createElement(Router, {
+    history: historyRef.current
+  }, props.children);
+}
+
+var _excluded$1 = ["to", "replace", "component", "onClick", "target"];
+var isModifiedEvent = function (event) {
+  return event.metaKey || event.altKey || event.ctrlKey || event.shiftKey;
+};
+var checkTarget = function (target) {
+  return !target || target === '_self';
+};
+function Link(props) {
+  var to = props.to,
+    replace = props.replace;
+    props.component;
+    var onClick = props.onClick,
+    target = props.target,
+    other = _objectWithoutPropertiesLoose(props, _excluded$1);
+  var tag = props.tag || 'a';
+  var context = React.useContext(RouterContext);
+  var history = context.history;
+  var location = typeof to === 'function' ? to(context.location) : to;
+  var state;
+  var path;
+  if (typeof location === 'string') {
+    path = parsePath(location);
+  } else {
+    var pathname = location.pathname,
+      hash = location.hash,
+      search = location.search;
+    path = {
+      pathname: pathname,
+      hash: hash,
+      search: search
+    };
+    state = location.state;
+  }
+  var href = history.createHref(path);
+  var linkClickEvent = function (event) {
+    try {
+      if (onClick) {
+        onClick(event);
+      }
+    } catch (e) {
+      event.preventDefault();
+      throw e;
+    }
+    if (!event.defaultPrevented && event.button === 0 && checkTarget(target) && !isModifiedEvent(event)) {
+      // 不是相同的路径执行push操作，是相同的路径执行replace
+      var isSamePath = createPath(context.location) === createPath(path);
+      var navigate = replace || isSamePath ? history.replace : history.push;
+      event.preventDefault();
+      navigate(path, state);
+    }
+  };
+  var linkProps = _extends({
+    href: href,
+    onClick: linkClickEvent
+  }, other);
+  return React__namespace.createElement(tag, linkProps);
+}
+
+var _excluded = ["to", "isActive"];
+function NavLink(props) {
+  var to = props.to,
+    isActive = props.isActive,
+    rest = _objectWithoutPropertiesLoose(props, _excluded);
+  var context = React.useContext(RouterContext);
+  var toLocation = typeof to === 'function' ? to(context.location) : to;
+  var _ref = typeof toLocation === 'string' ? parsePath(toLocation) : toLocation,
+    path = _ref.pathname;
+  // 把正则表达式的特殊符号加两个反斜杠进行转义
+  var escapedPath = path ? escapeStr(path) : '';
+  var match = escapedPath ? matchPath(context.location.pathname, escapedPath) : null;
+  var isLinkActive = match && isActive ? isActive(match, context.location) : false;
+  var page = 'page';
+  var otherProps = _extends({
+    'aria-current': isLinkActive ? page : false
+  }, rest);
+  return /*#__PURE__*/React__namespace.createElement(Link, _extends({
+    to: to
+  }, otherProps));
+}
+
+// 获取redux state中的值
+function getIn(state, path) {
+  if (!state) {
+    return state;
+  }
+  var length = path.length;
+  if (!length) {
+    return undefined;
+  }
+  var res = state;
+  for (var i = 0; i < length && !!res; ++i) {
+    res = res[path[i]];
+  }
+  return res;
+}
+
+// 从store的state中获取Router、Location、Action、Hash等信息
+var stateReader = function (storeType) {
+  var isRouter = function (value) {
+    return value !== null && typeof value === 'object' && !!getIn(value, ['location']) && !!getIn(value, ['action']);
+  };
+  var getRouter = function (state) {
+    var router = getIn(state, ['router']);
+    if (!isRouter(router)) {
+      throw new Error("Could not find router reducer in " + storeType + " store, it must be mounted under \"router\"");
+    }
+    return router;
+  };
+  var getLocation = function (state) {
+    return getIn(getRouter(state), ['location']);
+  };
+  var getAction = function (state) {
+    return getIn(getRouter(state), ['action']);
+  };
+  var getSearch = function (state) {
+    return getIn(getRouter(state), ['location', 'search']);
+  };
+  var getHash = function (state) {
+    return getIn(getRouter(state), ['location', 'hash']);
+  };
+  return {
+    getHash: getHash,
+    getAction: getAction,
+    getSearch: getSearch,
+    getRouter: getRouter,
+    getLocation: getLocation
+  };
+};
+
+var hConnect = horizon.reduxAdapter.connect;
+function ConnectedRouterWithoutMemo(props) {
+  var store = props.store,
+    history = props.history,
+    onLocationChanged = props.onLocationChanged,
+    omitRouter = props.omitRouter,
+    children = props.children,
+    storeType = props.storeType;
+  var _stateReader = stateReader(storeType),
+    getLocation = _stateReader.getLocation;
+
+  // 监听store变化
+  var unsubscribe = store.subscribe(function () {
+    // 获取redux State中的location信息
+    var _getLocation = getLocation(store.getState()),
+      pathnameInStore = _getLocation.pathname,
+      searchInStore = _getLocation.search,
+      hashInStore = _getLocation.hash,
+      stateInStore = _getLocation.state;
+
+    // 获取当前history对象中的location信息
+    var _history$location = history.location,
+      pathnameInHistory = _history$location.pathname,
+      searchInHistory = _history$location.search,
+      hashInHistory = _history$location.hash,
+      stateInHistory = _history$location.state;
+
+    // 两个location不一致 执行跳转
+    if (history.action === 'PUSH' && (pathnameInHistory !== pathnameInStore || searchInHistory !== searchInStore || hashInHistory !== hashInStore || stateInHistory !== stateInStore)) {
+      history.push({
+        pathname: pathnameInStore,
+        search: searchInStore,
+        hash: hashInStore
+      }, stateInStore);
+    }
+  });
+  var handleLocationChange = function (args) {
+    var isFirstRendering = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    var location = args.location,
+      action = args.action;
+    onLocationChanged(location, action, isFirstRendering);
+  };
+
+  // 监听history更新
+  var unListen = function () {
+    return history.listen(handleLocationChange);
+  };
+  React.useLayoutEffect(function () {
+    return function () {
+      unListen();
+      unsubscribe();
+    };
+  }, []);
+  if (!props.noInitialPop) {
+    // 传递初始时位置信息，isFirstRendering设为true防止重复渲染
+    handleLocationChange({
+      location: history.location,
+      action: history.action
+    }, true);
+  }
+  if (omitRouter) {
+    return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, children);
+  }
+  var childrenNode;
+  if (typeof children === 'function') {
+    childrenNode = children();
+  } else {
+    childrenNode = children;
+  }
+  return /*#__PURE__*/React__namespace.createElement(Router, {
+    history: history
+  }, childrenNode);
+}
+function getConnectedRouter(type) {
+  var mapDispatchToProps = function (dispatch) {
+    return {
+      onLocationChanged: function (location, action, isFirstRendering) {
+        return dispatch(onLocationChanged(location, action, isFirstRendering));
+      }
+    };
+  };
+  var ConnectedRouter = React__namespace.memo(ConnectedRouterWithoutMemo);
+  var ConnectedRouterWithContext = function (props) {
+    var Context = props.context || reactRedux.ReactReduxContext;
+    return /*#__PURE__*/React__namespace.createElement(Context.Consumer, null, function (_ref) {
+      var store = _ref.store;
+      return /*#__PURE__*/React__namespace.createElement(ConnectedRouter, _extends({
+        store: store,
+        storeType: type
+      }, props));
+    });
+  };
+
+  // 针对不同的Store类型，使用对应的connect函数
+  if (type === 'HorizonXCompat') {
+    return hConnect(null, mapDispatchToProps)(ConnectedRouterWithContext);
+  }
+  if (type === 'Redux') {
+    return reactRedux.connect(null, mapDispatchToProps)(ConnectedRouterWithContext);
+  } else {
+    throw new Error('Invalid store type');
+  }
+}
+
+// 定义connect-router对应的redux dispatch函数
+function routerMiddleware(history) {
+  return function (_) {
+    return function (next) {
+      return function (action) {
+        if (action.type !== ActionName.CALL_HISTORY_METHOD) {
+          return next(action);
+        }
+        var _action$payload = action.payload,
+          method = _action$payload.method,
+          args = _action$payload.args;
+        if (method in history) {
+          var _ref;
+          (_ref = history)[method].apply(_ref, args);
+        }
+      };
+    };
+  };
+}
+
+var connectRouter = createConnectRouter();
+
+var ConnectedRouter = getConnectedRouter('Redux');
+var ConnectedHRouter = getConnectedRouter('HorizonXCompat');
+
+exports.BrowserRouter = BrowserRouter;
+exports.ConnectedHRouter = ConnectedHRouter;
+exports.ConnectedRouter = ConnectedRouter;
+exports.HashRouter = HashRouter;
+exports.Link = Link;
+exports.NavLink = NavLink;
+exports.Prompt = Prompt;
+exports.Redirect = Redirect;
+exports.Route = Route;
+exports.Router = Router;
+exports.Switch = Switch;
+exports.__RouterContext = RouterContext;
+exports.connectRouter = connectRouter;
+exports.createBrowserHistory = createBrowserHistory;
+exports.createHashHistory = createHashHistory;
+exports.generatePath = generatePath;
+exports.matchPath = matchPath;
+exports.routerMiddleware = routerMiddleware;
+exports.useHistory = useHistory;
+exports.useLocation = useLocation;
+exports.useParams = useParams;
+exports.useRouteMatch = useRouteMatch;
+exports.withRouter = withRouter;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"connectRouter.js","sources":["../../../../node_modules/@babel/runtime/helpers/esm/extends.js","../../src/connect-router/actions.ts","../../src/connect-router/reducer.ts","../../src/history/dom.ts","../../src/history/types.ts","../../src/history/utils.ts","../../../../node_modules/@babel/runtime/helpers/esm/classCallCheck.js","../../../../node_modules/@babel/runtime/helpers/esm/typeof.js","../../../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js","../../../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js","../../../../node_modules/@babel/runtime/helpers/esm/createClass.js","../../src/history/transitionManager.ts","../../src/history/waring.ts","../../src/history/baseHistory.ts","../../src/history/browerHistory.ts","../../src/history/hashHistory.ts","../../src/router/context.tsx","../../src/router/matcher/types.ts","../../src/router/matcher/utils.ts","../../src/router/matcher/lexer.ts","../../src/router/matcher/parser.ts","../../src/router/hooks.ts","../../src/router/Route.tsx","../../src/router/Router.tsx","../../../../node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js","../../src/router/lifeCycleHook.ts","../../src/router/Redirect.tsx","../../src/router/Switch.tsx","../../src/router/Prompt.tsx","../../src/router/withRouter.tsx","../../src/router/HashRouter.tsx","../../src/router/BrowserRouter.tsx","../../src/router/Link.tsx","../../src/router/NavLink.tsx","../../src/connect-router/reduxUtils.ts","../../src/connect-router/connectedRouter.tsx","../../src/connect-router/dispatch.ts","../../src/connect-router/index.ts","../../src/router/index2.ts"],"sourcesContent":["export default function _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}","import { Action, Path } from '../history/types';\r\n\r\ntype Location = Partial<Path>\r\n\r\n// 定义位置变化和history方法调用的Action type\r\nexport enum ActionName {\r\n  LOCATION_CHANGE = '$horizon-router/LOCATION_CHANGE',\r\n  CALL_HISTORY_METHOD = '$horizon-router/CALL_HISTORY_METHOD'\r\n}\r\n\r\n// 定义Action的两种数据类型\r\nexport type ActionMessage = {\r\n  type: ActionName.LOCATION_CHANGE\r\n  payload: {\r\n    location: Location,\r\n    action: Action\r\n    isFirstRendering: boolean\r\n  }\r\n} | {\r\n  type: ActionName.CALL_HISTORY_METHOD\r\n  payload: {\r\n    method: string,\r\n    args: any\r\n  }\r\n}\r\n\r\n\r\nexport const onLocationChanged = (location: Location, action: Action, isFirstRendering = false): ActionMessage => {\r\n  return {\r\n    type: ActionName.LOCATION_CHANGE,\r\n    payload: {\r\n      location,\r\n      action,\r\n      isFirstRendering,\r\n    },\r\n  };\r\n};\r\n\r\nconst updateLocation = (method: string): (...args: any) => ActionMessage => {\r\n  return (...args: any) => ({\r\n    type: ActionName.CALL_HISTORY_METHOD,\r\n    payload: {\r\n      method,\r\n      args,\r\n    },\r\n  });\r\n};\r\n\r\nexport const push = updateLocation('push');\r\nexport const replace = updateLocation('replace');\r\nexport const go = updateLocation('go');","import { ActionName } from './actions';\r\nimport { Action, History } from '../history/types';\r\nimport { Location } from '../router';\r\n\r\ntype LocationWithQuery = Partial<Location> & { query?: Record<string, any> };\r\n\r\n// 解析location对象，将其中的query参数解析并注入\r\nfunction injectQueryParams(location?: LocationWithQuery): LocationWithQuery {\r\n  if (location && location.query) {\r\n    return location;\r\n  }\r\n\r\n  const queryString = location && location.search;\r\n\r\n  if (!queryString) {\r\n    return {\r\n      ...location,\r\n      query: {},\r\n    };\r\n  }\r\n  const queryObject: Record<string, any> = {};\r\n\r\n  const params = new URLSearchParams(queryString);\r\n  params.forEach((value, key) => (queryObject[key] = value));\r\n\r\n  return {\r\n    ...location,\r\n    query: queryObject,\r\n  };\r\n}\r\n\r\ntype InitRouterState = {\r\n  location: LocationWithQuery;\r\n  action: Action;\r\n};\r\n\r\ntype Payload = {\r\n  type?: ActionName;\r\n  payload?: any;\r\n};\r\n\r\nexport function createConnectRouter() {\r\n  // 初始化redux State\r\n  return (history: History) => {\r\n    const initRouterState = {\r\n      location: injectQueryParams(history.location),\r\n      action: history.action,\r\n    };\r\n\r\n    // 定义connect-router对应的redux reducer函数\r\n    return (state: InitRouterState = initRouterState, { type, payload }: Payload = {}): any => {\r\n      if (type === ActionName.LOCATION_CHANGE) {\r\n        const { location, action, isFirstRendering } = payload;\r\n        if (isFirstRendering) {\r\n          return state;\r\n        }\r\n        return { ...state, location: injectQueryParams(location), action: action };\r\n      }\r\n      return state;\r\n    };\r\n  };\r\n}\r\n","export function isBrowser(): boolean {\r\n  return typeof window !== 'undefined' && window.document && typeof window.document.createElement === 'function';\r\n}\r\n\r\nexport function getDefaultConfirmation(message: string, callBack: (result: boolean) => void) {\r\n  callBack(window.confirm(message));\r\n}\r\n\r\n// 判断浏览器是否支持pushState方法，pushState是browserHistory实现的基础\r\nexport function isSupportHistory(): boolean {\r\n  return isBrowser() && window.history && 'pushState' in window.history;\r\n}\r\n\r\n// 判断浏览器是否支持PopState事件\r\nexport function isSupportsPopState(): boolean {\r\n  return window.navigator.userAgent.indexOf('Trident') === -1;\r\n}\r\n","export type BaseOption = {\r\n  basename?: string;\r\n  getUserConfirmation?: ConfirmationFunc;\r\n};\r\n\r\nexport interface HistoryProps<T = unknown> {\r\n  readonly action: Action;\r\n\r\n  readonly location: Location<T>;\r\n\r\n  length: number;\r\n}\r\n\r\nexport interface History<T = unknown> extends HistoryProps<T> {\r\n  createHref(path: Partial<Path>): string;\r\n\r\n  push(to: To, state?: T): void;\r\n\r\n  replace(to: To, state?: T): void;\r\n\r\n  listen(listener: Listener<T>): () => void;\r\n\r\n  block(prompt: Prompt<T>): () => void;\r\n\r\n  go(index: number): void;\r\n\r\n  goBack(): void;\r\n\r\n  goForward(): void;\r\n}\r\n\r\nexport enum Action {\r\n  pop = 'POP',\r\n  push = 'PUSH',\r\n  replace = 'REPLACE',\r\n}\r\n\r\nexport enum EventType {\r\n  PopState = 'popstate',\r\n  HashChange = 'hashchange',\r\n}\r\n\r\nexport type Path = {\r\n  pathname: string;\r\n\r\n  search: string;\r\n\r\n  hash: string;\r\n};\r\n\r\nexport type HistoryState<T> = {\r\n  state?: T;\r\n\r\n  key: string;\r\n};\r\n\r\nexport type DefaultStateType = unknown;\r\n\r\nexport type Location<T = unknown> = Path & HistoryState<T>;\r\n\r\nexport type To = string | Partial<Path>;\r\n\r\nexport interface Listener<T = unknown> {\r\n  (navigation: Navigation<T>): void;\r\n}\r\n\r\nexport interface Navigation<T = unknown> {\r\n  action: Action;\r\n\r\n  location: Location<T>;\r\n}\r\n\r\nexport type Prompt<S> = string | boolean | null | ((location: Location<S>, action: Action) => void);\r\n\r\nexport type CallBackFunc = (isJump: boolean) => void;\r\n\r\nexport type ConfirmationFunc = (message: string, callBack: CallBackFunc) => void;\r\n\r\nexport interface TManager<S> {\r\n  setPrompt(next: Prompt<S>): () => void;\r\n\r\n  addListener(func: (navigation: Navigation<S>) => void): () => void;\r\n\r\n  notifyListeners(args: Navigation<S>): void;\r\n\r\n  confirmJumpTo(\r\n    location: Location<S>,\r\n    action: Action,\r\n    userConfirmationFunc: ConfirmationFunc,\r\n    callBack: CallBackFunc,\r\n  ): void;\r\n}\r\n","import { Action, Location, Path, To } from './types';\r\n\r\nexport function createPath(path: Partial<Path>): string {\r\n  const { search, hash } = path;\r\n  let pathname = path.pathname || '/';\r\n  if (search && search !== '?') {\r\n    pathname += search.startsWith('?') ? search : '?' + search;\r\n  }\r\n  if (hash && hash !== '#') {\r\n    pathname += hash.startsWith('#') ? hash : '#' + hash;\r\n  }\r\n  return pathname;\r\n}\r\n\r\nexport function parsePath(url: string): Partial<Path> {\r\n  if (!url) {\r\n    return {};\r\n  }\r\n  let parsedPath: Partial<Path> = {};\r\n\r\n  let hashIdx = url.indexOf('#');\r\n  if (hashIdx > -1) {\r\n    parsedPath.hash = url.substring(hashIdx);\r\n    url = url.substring(0, hashIdx);\r\n  }\r\n\r\n  let searchIdx = url.indexOf('?');\r\n  if (searchIdx > -1) {\r\n    parsedPath.search = url.substring(searchIdx);\r\n    url = url.substring(0, searchIdx);\r\n  }\r\n  if (url) {\r\n    parsedPath.pathname = url;\r\n  }\r\n  return parsedPath;\r\n}\r\n\r\nexport function createLocation<S>(current: string | Location, to: To, state?: S, key?: string): Readonly<Location<S>> {\r\n  let pathname = typeof current === 'string' ? current : current.pathname;\r\n  let urlObj = typeof to === 'string' ? parsePath(to) : to;\r\n  // 随机key长度取6\r\n  const getRandKey = genRandomKey(6);\r\n  const location = {\r\n    pathname: pathname,\r\n    search: '',\r\n    hash: '',\r\n    state: state,\r\n    key: typeof key === 'string' ? key : getRandKey(),\r\n    ...urlObj,\r\n  };\r\n  if (!location.pathname) {\r\n    location.pathname = '/';\r\n  }\r\n  return location;\r\n}\r\n\r\nexport function isLocationEqual(p1: Partial<Path>, p2: Partial<Path>) {\r\n  return p1.pathname === p2.pathname && p1.search === p2.search && p1.hash === p2.hash;\r\n}\r\n\r\nexport function addHeadSlash(path: string): string {\r\n  if (path[0] === '/') {\r\n    return path;\r\n  }\r\n  return '/' + path;\r\n}\r\n\r\nexport function stripHeadSlash(path: string): string {\r\n  if (path[0] === '/') {\r\n    return path.substring(1);\r\n  }\r\n  return path;\r\n}\r\n\r\nexport function normalizeSlash(path: string): string {\r\n  const tempPath = addHeadSlash(path);\r\n  if (tempPath[tempPath.length - 1] === '/') {\r\n    return tempPath.substring(0, tempPath.length - 1);\r\n  }\r\n  return tempPath;\r\n}\r\n\r\nexport function hasBasename(path: string, prefix: string): Boolean {\r\n  return (\r\n    path.toLowerCase().indexOf(prefix.toLowerCase()) === 0 && ['/', '?', '#', ''].includes(path.charAt(prefix.length))\r\n  );\r\n}\r\n\r\nexport function stripBasename(path: string, prefix: string): string {\r\n  return hasBasename(path, prefix) ? path.substring(prefix.length) : path;\r\n}\r\n\r\n// 使用随机生成的Key记录被访问过的URL，当Block被被触发时利用delta值跳转到之前的页面\r\nexport function createMemoryRecord<T, S>(initVal: S, fn: (arg: S) => T) {\r\n  let visitedRecord: T[] = [fn(initVal)];\r\n\r\n  function getDelta(to: S, form: S): number {\r\n    let toIdx = visitedRecord.lastIndexOf(fn(to));\r\n    if (toIdx === -1) {\r\n      toIdx = 0;\r\n    }\r\n    let fromIdx = visitedRecord.lastIndexOf(fn(form));\r\n    if (fromIdx === -1) {\r\n      fromIdx = 0;\r\n    }\r\n    return toIdx - fromIdx;\r\n  }\r\n\r\n  function addRecord(current: S, newRecord: S, action: Action) {\r\n    const curVal = fn(current);\r\n    const NewVal = fn(newRecord);\r\n    if (action === Action.push) {\r\n      const prevIdx = visitedRecord.lastIndexOf(curVal);\r\n      const newVisitedRecord = visitedRecord.slice(0, prevIdx + 1);\r\n      newVisitedRecord.push(NewVal);\r\n      visitedRecord = newVisitedRecord;\r\n    }\r\n    if (action === Action.replace) {\r\n      const prevIdx = visitedRecord.lastIndexOf(curVal);\r\n      if (prevIdx !== -1) {\r\n        visitedRecord[prevIdx] = NewVal;\r\n      }\r\n    }\r\n  }\r\n\r\n  return { getDelta, addRecord };\r\n}\r\n\r\nfunction genRandomKey(length: number): () => string {\r\n  const end = length + 2;\r\n  return () => {\r\n    return Math.random().toString(18).substring(2, end);\r\n  };\r\n}\r\n","export default function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}","export default function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n    return typeof obj;\n  } : function (obj) {\n    return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n  }, _typeof(obj);\n}","import _typeof from \"./typeof.js\";\nexport default function _toPrimitive(input, hint) {\n  if (_typeof(input) !== \"object\" || input === null) return input;\n  var prim = input[Symbol.toPrimitive];\n  if (prim !== undefined) {\n    var res = prim.call(input, hint || \"default\");\n    if (_typeof(res) !== \"object\") return res;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (hint === \"string\" ? String : Number)(input);\n}","import _typeof from \"./typeof.js\";\nimport toPrimitive from \"./toPrimitive.js\";\nexport default function _toPropertyKey(arg) {\n  var key = toPrimitive(arg, \"string\");\n  return _typeof(key) === \"symbol\" ? key : String(key);\n}","import toPropertyKey from \"./toPropertyKey.js\";\nfunction _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, toPropertyKey(descriptor.key), descriptor);\n  }\n}\nexport default function _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  Object.defineProperty(Constructor, \"prototype\", {\n    writable: false\n  });\n  return Constructor;\n}","import { Action, CallBackFunc, ConfirmationFunc, Listener, Location, Navigation, Prompt, TManager } from './types';\r\n\r\nclass TransitionManager<S> implements TManager<S> {\r\n  private prompt: Prompt<S>;\r\n  private listeners: Listener<S>[];\r\n\r\n  constructor() {\r\n    this.prompt = null;\r\n    this.listeners = [];\r\n  }\r\n\r\n  public setPrompt(prompt: Prompt<S>): () => void {\r\n    this.prompt = prompt;\r\n\r\n    // 清除Prompt\r\n    return () => {\r\n      if (this.prompt === prompt) {\r\n        this.prompt = null;\r\n      }\r\n    };\r\n  }\r\n\r\n  // 使用发布订阅模式管理history的监听者\r\n  public addListener(func: Listener<S>): () => void {\r\n    let isActive = true;\r\n    const listener = (args: Navigation<S>) => {\r\n      if (isActive) {\r\n        func(args);\r\n      }\r\n    };\r\n    this.listeners.push(listener);\r\n    return () => {\r\n      isActive = false;\r\n      // 移除对应的监听者\r\n      this.listeners = this.listeners.filter(item => item !== listener);\r\n    };\r\n  }\r\n\r\n  public notifyListeners(args: Navigation<S>) {\r\n    for (const listener of this.listeners) {\r\n      listener(args);\r\n    }\r\n  }\r\n\r\n  public confirmJumpTo(\r\n    location: Location<S>,\r\n    action: Action,\r\n    userConfirmationFunc: ConfirmationFunc,\r\n    callBack: CallBackFunc\r\n  ) {\r\n    if (this.prompt !== null) {\r\n      const result = typeof this.prompt === 'function' ? this.prompt(location, action) : this.prompt;\r\n      if (typeof result === 'string') {\r\n        typeof userConfirmationFunc === 'function' ? userConfirmationFunc(result, callBack) : callBack(true);\r\n      } else {\r\n        callBack(result !== false);\r\n      }\r\n    } else {\r\n      callBack(true);\r\n    }\r\n  }\r\n}\r\n\r\nexport default TransitionManager;\r\n","function warning(condition: any, message: string) {\r\n  if (condition) {\r\n    if (console && typeof console.warn === 'function') {\r\n      console.warn(message);\r\n    }\r\n  }\r\n}\r\n\r\nexport default warning;","import { HistoryProps, Listener, Navigation, Prompt } from './types';\r\nimport transitionManager from './transitionManager';\r\n\r\n// 抽取BrowserHistory和HashHistory中相同的方法\r\nexport function getBaseHistory<S>(\r\n  transitionManager: transitionManager<S>,\r\n  setListener: (delta: number) => void,\r\n  browserHistory: History,\r\n) {\r\n  function go(step: number) {\r\n    browserHistory.go(step);\r\n  }\r\n\r\n  function goBack() {\r\n    browserHistory.go(-1);\r\n  }\r\n\r\n  function goForward() {\r\n    browserHistory.go(1);\r\n  }\r\n\r\n  function listen(listener: Listener<S>): () => void {\r\n    const cancel = transitionManager.addListener(listener);\r\n    setListener(1);\r\n    return () => {\r\n      setListener(-1);\r\n      cancel();\r\n    };\r\n  }\r\n\r\n  let isBlocked = false;\r\n\r\n  function block(prompt: Prompt<S> = false): () => void {\r\n    const unblock = transitionManager.setPrompt(prompt);\r\n    if (!isBlocked) {\r\n      setListener(1);\r\n      isBlocked = true;\r\n    }\r\n    return () => {\r\n      if (isBlocked) {\r\n        isBlocked = false;\r\n        setListener(-1);\r\n      }\r\n      unblock();\r\n    };\r\n  }\r\n\r\n  function getUpdateStateFunc(historyProps: HistoryProps<S>) {\r\n    return function (nextState: Navigation<S> | undefined) {\r\n      if (nextState) {\r\n        Object.assign(historyProps, nextState);\r\n      }\r\n      historyProps.length = browserHistory.length;\r\n      const args = { location: historyProps.location, action: historyProps.action };\r\n      transitionManager.notifyListeners(args);\r\n    };\r\n  }\r\n\r\n  return { go, goBack, goForward, listen, block, getUpdateStateFunc };\r\n}\r\n","import { getDefaultConfirmation, isSupportHistory, isSupportsPopState } from './dom';\r\nimport { Action, BaseOption, DefaultStateType, EventType, History, HistoryState, Location, Path, To } from './types';\r\nimport { normalizeSlash, createMemoryRecord, createPath, createLocation, stripBasename } from './utils';\r\nimport TransitionManager from './transitionManager';\r\n\r\nimport warning from './waring';\r\nimport { getBaseHistory } from './baseHistory';\r\n\r\nexport type BrowserHistoryOption = {\r\n  /**\r\n   * forceRefresh为True时跳转时会强制刷新页面\r\n   */\r\n  forceRefresh?: boolean;\r\n} & BaseOption;\r\n\r\nexport function createBrowserHistory<S = DefaultStateType>(options: BrowserHistoryOption = {}): History<S> {\r\n  const supportHistory = isSupportHistory();\r\n  const isSupportPopState = isSupportsPopState();\r\n  const browserHistory = window.history;\r\n  const { forceRefresh = false, getUserConfirmation = getDefaultConfirmation } = options;\r\n\r\n  const basename = options.basename ? normalizeSlash(options.basename) : '';\r\n\r\n  const initLocation = getLocation(getHistoryState());\r\n\r\n  const recordOperator = createMemoryRecord<string, Location<S>>(initLocation, l => l.key);\r\n\r\n  const transitionManager = new TransitionManager<S>();\r\n\r\n  const { go, goBack, goForward, listen, block, getUpdateStateFunc } = getBaseHistory<S>(\r\n    transitionManager,\r\n    setListener,\r\n    browserHistory,\r\n  );\r\n\r\n  const history: History<S> = {\r\n    action: Action.pop,\r\n    length: browserHistory.length,\r\n    location: initLocation,\r\n    go,\r\n    goBack,\r\n    goForward,\r\n    listen,\r\n    block,\r\n    push,\r\n    replace,\r\n    createHref,\r\n  };\r\n\r\n  const updateState = getUpdateStateFunc(history);\r\n\r\n  function getHistoryState() {\r\n    return supportHistory ? window.history.state : {};\r\n  }\r\n\r\n  function getLocation(historyState: Partial<HistoryState<S>>) {\r\n    const { search, hash } = window.location;\r\n    const { key, state } = historyState || {};\r\n    let pathname = window.location.pathname;\r\n    pathname = basename ? stripBasename(pathname, basename) : pathname;\r\n\r\n    return createLocation<S>('', { pathname, search, hash }, state, key);\r\n  }\r\n\r\n  // 拦截页面POP事件后，防止返回到的页面被重复拦截\r\n  let forceJump = false;\r\n\r\n  function handlePopState(location: Location<S>) {\r\n    if (forceJump) {\r\n      forceJump = false;\r\n      updateState(undefined);\r\n    } else {\r\n      const action = Action.pop;\r\n\r\n      const callback = (isJump: boolean) => {\r\n        if (isJump) {\r\n          // 执行跳转行为\r\n          updateState({ action: action, location: location });\r\n        } else {\r\n          revertPopState(location, history.location);\r\n        }\r\n      };\r\n\r\n      transitionManager.confirmJumpTo(location, action, getUserConfirmation, callback);\r\n    }\r\n  }\r\n\r\n  function popStateListener(event: PopStateEvent) {\r\n    handlePopState(getLocation(event.state));\r\n  }\r\n\r\n  function hashChangeListener() {\r\n    const location = getLocation(getHistoryState());\r\n    handlePopState(location);\r\n  }\r\n\r\n  let listenerCount = 0;\r\n\r\n  function setListener(count: number) {\r\n    listenerCount += count;\r\n    if (listenerCount === 1 && count === 1) {\r\n      window.addEventListener(EventType.PopState, popStateListener);\r\n      if (!isSupportPopState) {\r\n        window.addEventListener(EventType.HashChange, hashChangeListener);\r\n      }\r\n    } else if (listenerCount === 0) {\r\n      window.removeEventListener(EventType.PopState, popStateListener);\r\n      if (!isSupportPopState) {\r\n        window.removeEventListener(EventType.HashChange, hashChangeListener);\r\n      }\r\n    }\r\n  }\r\n\r\n  // 取消页面跳转并恢复到跳转前的页面\r\n  function revertPopState(form: Location<S>, to: Location<S>) {\r\n    const delta = recordOperator.getDelta(to, form);\r\n    if (delta !== 0) {\r\n      go(delta);\r\n      forceJump = true;\r\n    }\r\n  }\r\n\r\n  function createHref(path: Partial<Path>) {\r\n    return basename + createPath(path);\r\n  }\r\n\r\n  function push(to: To, state?: S) {\r\n    const action = Action.push;\r\n    const location = createLocation<S>(history.location, to, state, undefined);\r\n\r\n    transitionManager.confirmJumpTo(location, action, getUserConfirmation, isJump => {\r\n      if (!isJump) {\r\n        return;\r\n      }\r\n      const href = createHref(location);\r\n      const { key, state } = location;\r\n\r\n      if (supportHistory) {\r\n        if (forceRefresh) {\r\n          window.location.href = href;\r\n        } else {\r\n          browserHistory.pushState({ key: key, state: state }, '', href);\r\n          recordOperator.addRecord(history.location, location, action);\r\n          updateState({ action, location });\r\n        }\r\n      } else {\r\n        warning(state !== undefined, 'Browser history cannot push state in browsers that do not support HTML5 history');\r\n        window.location.href = href;\r\n      }\r\n    });\r\n  }\r\n\r\n  function replace(to: To, state?: S) {\r\n    const action = Action.replace;\r\n    const location = createLocation<S>(history.location, to, state, undefined);\r\n\r\n    transitionManager.confirmJumpTo(location, action, getUserConfirmation, isJump => {\r\n      if (!isJump) {\r\n        return;\r\n      }\r\n      const href = createHref(location);\r\n      const { key, state } = location;\r\n      if (supportHistory) {\r\n        if (forceRefresh) {\r\n          window.location.replace(href);\r\n        } else {\r\n          browserHistory.replaceState({ key: key, state: state }, '', href);\r\n          recordOperator.addRecord(history.location, location, action);\r\n          updateState({ action, location });\r\n        }\r\n      } else {\r\n        warning(state !== undefined, 'Browser history cannot push state in browsers that do not support HTML5 history');\r\n        window.location.replace(href);\r\n      }\r\n    });\r\n  }\r\n\r\n  return history;\r\n}\r\n","import { Action, BaseOption, DefaultStateType, EventType, History, Location, To } from './types';\r\nimport {\r\n  addHeadSlash,\r\n  normalizeSlash,\r\n  createMemoryRecord,\r\n  createPath,\r\n  createLocation,\r\n  isLocationEqual,\r\n  stripBasename,\r\n  stripHeadSlash,\r\n} from './utils';\r\nimport { getDefaultConfirmation } from './dom';\r\nimport TransitionManager from './transitionManager';\r\n\r\nimport warning from './waring';\r\nimport { getBaseHistory } from './baseHistory';\r\n\r\nexport type urlHashType = 'slash' | 'noslash';\r\n\r\ntype HashHistoryOption = {\r\n  hashType?: urlHashType;\r\n} & BaseOption;\r\n\r\n// 获取#前的内容\r\nfunction stripHash(path: string): string {\r\n  const idx = path.indexOf('#');\r\n  return idx === -1 ? path : path.substring(0, idx);\r\n}\r\n\r\n// 获取#后的内容\r\nfunction getHashContent(path: string): string {\r\n  const idx = path.indexOf('#');\r\n  return idx === -1 ? '' : path.substring(idx + 1);\r\n}\r\n\r\nexport function createHashHistory<S = DefaultStateType>(option: HashHistoryOption = {}): History<S> {\r\n  const browserHistory = window.history;\r\n  const { hashType = 'slash', getUserConfirmation = getDefaultConfirmation } = option;\r\n\r\n  const basename = option.basename ? normalizeSlash(option.basename) : '';\r\n\r\n  const pathDecoder = addHeadSlash;\r\n  const pathEncoder = hashType === 'slash' ? addHeadSlash : stripHeadSlash;\r\n\r\n  function getLocation() {\r\n    let hashPath = pathDecoder(getHashContent(window.location.hash));\r\n    if (basename) {\r\n      hashPath = stripBasename(hashPath, basename);\r\n    }\r\n\r\n    return createLocation<S>('', hashPath, undefined, 'default');\r\n  }\r\n\r\n  const initLocation = getLocation();\r\n\r\n  const memRecords = createMemoryRecord<string, Location<S>>(initLocation, createPath);\r\n\r\n  const transitionManager = new TransitionManager<S>();\r\n\r\n  function createHref(location: Location<S>) {\r\n    const tag = document.querySelector('base');\r\n    const base = tag && tag.getAttribute('href') ? stripHash(window.location.href) : '';\r\n    return base + '#' + pathEncoder(basename + createPath(location));\r\n  }\r\n\r\n  let forceNextPop = false;\r\n  let ignorePath: null | string = null;\r\n\r\n  const { go, goBack, goForward, listen, block, getUpdateStateFunc } = getBaseHistory(\r\n    transitionManager,\r\n    setListener,\r\n    browserHistory,\r\n  );\r\n\r\n  const history: History<S> = {\r\n    action: Action.pop,\r\n    length: browserHistory.length,\r\n    location: initLocation,\r\n    go,\r\n    goBack,\r\n    goForward,\r\n    push,\r\n    replace,\r\n    listen,\r\n    block,\r\n    createHref,\r\n  };\r\n\r\n  const updateState = getUpdateStateFunc(history);\r\n\r\n  function push(to: To, state?: S) {\r\n    warning(state !== undefined, 'Hash history does not support state, it will be ignored');\r\n\r\n    const action = Action.push;\r\n    const location = createLocation<S>(history.location, to, undefined, '');\r\n\r\n    transitionManager.confirmJumpTo(location, action, getUserConfirmation, isJump => {\r\n      if (!isJump) {\r\n        return;\r\n      }\r\n      const path = createPath(location);\r\n      const encodedPath = pathEncoder(basename + path);\r\n      // 前后hash不一样才进行跳转\r\n      if (getHashContent(window.location.href) !== encodedPath) {\r\n        ignorePath = encodedPath;\r\n        window.location.hash = encodedPath;\r\n\r\n        memRecords.addRecord(history.location, location, action);\r\n\r\n        updateState({ action, location });\r\n      } else {\r\n        updateState(undefined);\r\n      }\r\n    });\r\n  }\r\n\r\n  function replace(to: To, state?: S) {\r\n    warning(state !== undefined, 'Hash history does not support state, it will be ignored');\r\n    const action = Action.replace;\r\n    const location = createLocation<S>(history.location, to, undefined, '');\r\n\r\n    transitionManager.confirmJumpTo(location, action, getUserConfirmation, isJump => {\r\n      if (!isJump) {\r\n        return;\r\n      }\r\n      const path = createPath(location);\r\n      const encodedPath = pathEncoder(basename + path);\r\n      if (getHashContent(window.location.href) !== encodedPath) {\r\n        ignorePath = path;\r\n        window.location.replace(stripHash(window.location.href) + '#' + encodedPath);\r\n      }\r\n      memRecords.addRecord(history.location, location, action);\r\n      updateState({ action, location });\r\n    });\r\n  }\r\n\r\n  function handleHashChange() {\r\n    const hashPath = getHashContent(window.location.href);\r\n    const encodedPath = pathEncoder(hashPath);\r\n    if (hashPath !== encodedPath) {\r\n      window.location.replace(stripHash(window.location.href) + '#' + encodedPath);\r\n    } else {\r\n      const location = getLocation();\r\n      const prevLocation = history.location;\r\n      if (!forceNextPop && isLocationEqual(location, prevLocation)) {\r\n        return;\r\n      }\r\n      if (ignorePath === createPath(location)) {\r\n        return;\r\n      }\r\n      ignorePath = null;\r\n      handlePopState(location);\r\n    }\r\n  }\r\n\r\n  function handlePopState(location: Location<S>) {\r\n    if (forceNextPop) {\r\n      forceNextPop = false;\r\n      updateState(undefined);\r\n    } else {\r\n      const action = Action.pop;\r\n\r\n      const callback = (isJump: boolean) => {\r\n        if (isJump) {\r\n          updateState({ action: action, location: location });\r\n        } else {\r\n          revertPopState(location);\r\n        }\r\n      };\r\n\r\n      transitionManager.confirmJumpTo(location, action, getUserConfirmation, callback);\r\n    }\r\n  }\r\n\r\n  // 在跳转行为被Block后，用History.go()跳转回之前的页面\r\n  function revertPopState(form: Location<S>) {\r\n    const to = history.location;\r\n    const delta = memRecords.getDelta(to, form);\r\n    if (delta !== 0) {\r\n      go(delta);\r\n      forceNextPop = true;\r\n    }\r\n  }\r\n\r\n  let listenerCount = 0;\r\n\r\n  function setListener(delta: number) {\r\n    listenerCount += delta;\r\n    if (listenerCount === 1 && delta === 1) {\r\n      window.addEventListener(EventType.HashChange, handleHashChange);\r\n    } else if (listenerCount === 0) {\r\n      window.removeEventListener(EventType.HashChange, handleHashChange);\r\n    }\r\n  }\r\n\r\n  return history;\r\n}\r\n","import { createContext } from 'react';\r\nimport { History, Location } from './index';\r\nimport { Matched } from './matcher/parser';\r\n\r\nfunction createNamedContext<T>(name: string, defaultValue: T) {\r\n  const context = createContext<T>(defaultValue);\r\n  context.displayName = name;\r\n  return context;\r\n}\r\n\r\nexport type RouterContextValue = {\r\n  history: History;\r\n  location: Location;\r\n  match: Matched | null;\r\n};\r\n\r\nconst RouterContext = createNamedContext<RouterContextValue>('Router', {} as any);\r\n\r\nexport default RouterContext;","import { Matched, Params } from './parser';\r\n\r\nexport type Token = {\r\n  type: TokenType;\r\n  value: string;\r\n};\r\n\r\nexport enum TokenType {\r\n  Delimiter = 'delimiter',\r\n  Static = 'static',\r\n  Param = 'param',\r\n  WildCard = 'wildcard',\r\n  LBracket = '(',\r\n  RBracket = ')',\r\n  Pattern = 'pattern',\r\n}\r\n\r\nexport interface Parser<P> {\r\n  regexp: RegExp;\r\n\r\n  keys: string[];\r\n\r\n  parse(url: string): Matched<P> | null;\r\n\r\n  compile(params: Params<P>): string;\r\n}\r\n\r\nexport type ParserOption = {\r\n  // 是否大小写敏感\r\n  caseSensitive?: boolean;\r\n  // 是否启用严格模式\r\n  strictMode?: boolean;\r\n  // 精准匹配 兼容 React-RouterV5\r\n  exact?: boolean;\r\n};\r\n\r\ntype ClearLeading<U extends string> = U extends `/${infer R}` ? ClearLeading<R> : U;\r\ntype ClearTailing<U extends string> = U extends `${infer L}/` ? ClearTailing<L> : U;\r\n\r\ntype ParseParam<Param extends string> = Param extends `:${infer R}`\r\n  ? {\r\n    [K in R]: string;\r\n  }\r\n  : {};\r\n\r\ntype MergeParams<OneParam extends Record<string, any>, OtherParam extends Record<string, any>> = {\r\n  readonly [Key in keyof OneParam | keyof OtherParam]?: string;\r\n};\r\n\r\ntype ParseURLString<Str extends string> = Str extends `${infer Param}/${infer Rest}`\r\n  ? MergeParams<ParseParam<Param>, ParseURLString<ClearLeading<Rest>>>\r\n  : ParseParam<Str>;\r\n\r\n// 解析URL中的动态参数，以实现TypeScript提示功能\r\nexport type GetURLParams<U extends string> = ParseURLString<ClearLeading<ClearTailing<U>>>;\r\n","/**\r\n * @description 将url中的//转换为/\r\n */\r\nexport function cleanPath(path: string): string {\r\n  return path.replace(/\\/+/g, '/');\r\n}\r\n\r\nexport function scoreCompare(score1: number[], score2: number[]): number {\r\n  const score1Length = score1.length;\r\n  const score2Length = score2.length;\r\n  const end = Math.min(score1Length, score2Length);\r\n  for (let i = 0; i < end; i++) {\r\n    const delta = score2[i] - score1[i];\r\n    if (delta !== 0) {\r\n      return delta;\r\n    }\r\n  }\r\n  if (score1Length === score2Length) {\r\n    return 0;\r\n  }\r\n  return score1Length > score2Length ? -1 : 1;\r\n}\r\n\r\n// 把正则表达式的特殊符号加两个反斜杠进行转义\r\nexport function escapeStr(str: string) {\r\n  return str.replace(/([.+*?=^!:${}()[\\]|/\\\\])/g, '\\\\$1');\r\n}\r\n","import { Token, TokenType } from './types';\r\nimport { cleanPath } from './utils';\r\n\r\nconst validChar = /[^/:*()]/;\r\n\r\n// 对Url模板进行词法解析，解析结果为Tokens\r\nexport function lexer(path: string): Token[] {\r\n  const tokens: Token[] = [];\r\n\r\n  if (!path) {\r\n    return tokens;\r\n  }\r\n\r\n  let urlPath = cleanPath(path);\r\n  if (urlPath !== '*' && !urlPath.startsWith('/')) {\r\n    throw new Error(`Url must start with \"/\".`);\r\n  }\r\n\r\n  const getLiteral = () => {\r\n    let name = '';\r\n    while (i < urlPath.length && validChar.test(urlPath[i])) {\r\n      name += urlPath[i];\r\n      skipChar(1);\r\n    }\r\n    return name;\r\n  };\r\n\r\n  const skipChar = (step: number) => {\r\n    i += step;\r\n  };\r\n\r\n  let i = 0;\r\n  while (i < urlPath.length) {\r\n    const curChar = urlPath[i];\r\n    const prevChar = urlPath[i - 1];\r\n\r\n    if (curChar === '/') {\r\n      tokens.push({ type: TokenType.Delimiter, value: urlPath[i] });\r\n      skipChar(1);\r\n      continue;\r\n    }\r\n    // dynamic params (/:a)\r\n    if (prevChar === '/' && curChar === ':') {\r\n      skipChar(1);\r\n      tokens.push({ type: TokenType.Param, value: getLiteral() });\r\n      continue;\r\n    }\r\n    // wildCard params (/:*)\r\n    if ((prevChar === '/' || prevChar === undefined) && curChar === '*') {\r\n      tokens.push({ type: TokenType.WildCard, value: urlPath[i] });\r\n      skipChar(1);\r\n      continue;\r\n    }\r\n    // static params\r\n    if (prevChar === '/' && validChar.test(curChar)) {\r\n      tokens.push({ type: TokenType.Static, value: getLiteral() });\r\n      continue;\r\n    }\r\n    if (curChar === '(') {\r\n      tokens.push({ type: TokenType.LBracket, value: '(' });\r\n      skipChar(1);\r\n      continue;\r\n    }\r\n    if (curChar === ')') {\r\n      tokens.push({ type: TokenType.RBracket, value: ')' });\r\n      skipChar(1);\r\n      continue;\r\n    }\r\n    if (validChar.test(curChar)) {\r\n      tokens.push({ type: TokenType.Pattern, value: getLiteral() });\r\n      continue;\r\n    }\r\n    // 跳过非法字符\r\n    skipChar(1);\r\n  }\r\n\r\n  return tokens;\r\n}\r\n","import { GetURLParams, Parser, ParserOption, TokenType } from './types';\r\nimport { lexer } from './lexer';\r\nimport { escapeStr, scoreCompare } from './utils';\r\n\r\n// 不同类型参数的匹配得分\r\nenum MatchScore {\r\n  // 固定参数\r\n  static = 10,\r\n  // 动态参数\r\n  param = 6,\r\n  // 通配符参数\r\n  wildcard = 3,\r\n  placeholder = -1,\r\n}\r\n\r\nexport type Params<P> = { [K in keyof P]?: P[K] };\r\n\r\n// 兼容 react v5 matched类型\r\nexport type Matched<P = any> = {\r\n  score: number[];\r\n  params: Params<P>;\r\n  path: string;\r\n  url: string;\r\n  isExact: boolean;\r\n};\r\n\r\nconst defaultOption: Required<ParserOption> = {\r\n  // url匹配时是否大小写敏感\r\n  caseSensitive: true,\r\n  // 是否严格匹配url结尾的/\r\n  strictMode: false,\r\n  // 是否完全精确匹配\r\n  exact: false,\r\n};\r\n// 正则表达式中需要转义的字符\r\nconst REGEX_CHARS_RE = /[.+*?^${}()[\\]/\\\\]/g;\r\n// 用于匹配两个//中的的值\r\nconst BASE_PARAM_PATTERN = '[^/]+';\r\n\r\nconst DefaultDelimiter = '/#?';\r\n\r\nexport function createPathParser<Str extends string>(pathname: Str, option?: ParserOption): Parser<GetURLParams<Str>>;\r\nexport function createPathParser<P = unknown>(pathname: string, option?: ParserOption): Parser<P>;\r\nexport function createPathParser<P = unknown>(pathname: string, option: ParserOption = defaultOption): Parser<P> {\r\n  const {\r\n    caseSensitive = defaultOption.caseSensitive,\r\n    strictMode = defaultOption.strictMode,\r\n    exact = defaultOption.exact,\r\n  } = option;\r\n  /**\r\n   * URL匹配整体流程\r\n   * 1.词法解析，将URL模板解析为Token\r\n   * 2.使用Token生成正则表达式\r\n   * 3.利用正则表达式解析URL中参数或填充URL模板\r\n   */\r\n  let pattern = '^';\r\n  const keys: string[] = [];\r\n  const scores: number[] = [];\r\n\r\n  const tokens = lexer(pathname);\r\n  const onlyHasWildCard = tokens.length === 1 && tokens[0].type === TokenType.WildCard;\r\n  const tokenCount = tokens.length;\r\n  const lastToken = tokens[tokenCount - 1];\r\n\r\n  for (let tokenIdx = 0; tokenIdx < tokenCount; tokenIdx++) {\r\n    const token = tokens[tokenIdx];\r\n    const nextToken = tokens[tokenIdx + 1];\r\n    switch (token.type) {\r\n      case TokenType.Delimiter:\r\n        pattern += '/';\r\n        break;\r\n      case TokenType.Static:\r\n        pattern += token.value.replace(REGEX_CHARS_RE, '\\\\$&');\r\n        scores.push(MatchScore.static);\r\n        break;\r\n      case TokenType.Param:\r\n        let paramRegexp = '';\r\n        if (nextToken && nextToken.type === TokenType.LBracket) {\r\n          // 跳过当前Token和左括号\r\n          tokenIdx += 2;\r\n          while (tokens[tokenIdx].type !== TokenType.RBracket) {\r\n            paramRegexp += tokens[tokenIdx].value;\r\n            tokenIdx++;\r\n          }\r\n        }\r\n        pattern += paramRegexp ? `((?:${paramRegexp}))` : `(${BASE_PARAM_PATTERN})`;\r\n        keys.push(token.value);\r\n        scores.push(MatchScore.param);\r\n        break;\r\n      case TokenType.WildCard:\r\n        keys.push(token.value);\r\n        pattern += `((?:${BASE_PARAM_PATTERN})${onlyHasWildCard ? '?' : ''}(?:/(?:${BASE_PARAM_PATTERN}))*)`;\r\n        scores.push(onlyHasWildCard ? MatchScore.wildcard : MatchScore.placeholder);\r\n        break;\r\n    }\r\n  }\r\n  const isWildCard = lastToken.type === TokenType.WildCard;\r\n\r\n  if (!isWildCard && !exact) {\r\n    if (!strictMode) {\r\n      pattern += `(?:[${escapeStr(DefaultDelimiter)}](?=$))?`;\r\n    }\r\n    if (lastToken.type !== TokenType.Delimiter) {\r\n      pattern += `(?=[${escapeStr(DefaultDelimiter)}]|$)`;\r\n    }\r\n  } else {\r\n    pattern += strictMode ? '$' : `[${escapeStr(DefaultDelimiter)}]?$`;\r\n  }\r\n\r\n  const flag = caseSensitive ? '' : 'i';\r\n  const regexp = new RegExp(pattern, flag);\r\n\r\n  /**\r\n   * @description 根据给定Pattern解析path\r\n   */\r\n  function parse(path: string): Matched<P> | null {\r\n    const reMatch = path.match(regexp);\r\n\r\n    if (!reMatch) {\r\n      return null;\r\n    }\r\n    const matchedPath = reMatch[0];\r\n    let params: Params<P> = {};\r\n    let parseScore: number[] = Array.from(scores);\r\n    for (let i = 1; i < reMatch.length; i++) {\r\n      let param = reMatch[i];\r\n      let key = keys[i - 1];\r\n      if (key === '*' && param) {\r\n        let value = param.split('/');\r\n        if (!Array.isArray(params['*'])) {\r\n          params['*'] = value;\r\n        } else {\r\n          params['*'].push(...value);\r\n        }\r\n        // 完成通配符参数解析后将placeholder替换为wildcard参数的分值\r\n        parseScore.splice(\r\n          scores.indexOf(MatchScore.placeholder),\r\n          1,\r\n          ...new Array(value.length).fill(MatchScore.wildcard),\r\n        );\r\n      } else {\r\n        params[key] = param ? param : [];\r\n      }\r\n    }\r\n\r\n    const isExact = path === matchedPath;\r\n    const url = path === '/' && matchedPath === '' ? '/' : matchedPath;\r\n    return { isExact: isExact, path: pathname, url: url, score: parseScore, params: params };\r\n  }\r\n\r\n  /**\r\n   * @description 使用给定参数填充pattern，得到目标URL\r\n   */\r\n  function compile(params: Params<P>): string {\r\n    let path = '';\r\n    for (const token of tokens) {\r\n      switch (token.type) {\r\n        case TokenType.Static:\r\n          path += token.value;\r\n          break;\r\n        case TokenType.Param:\r\n          if (!params[token.value]) {\r\n            throw new Error('Param is invalid.');\r\n          }\r\n          path += params[token.value];\r\n          break;\r\n        case TokenType.WildCard:\r\n          let wildCard = params['*'];\r\n          if (wildCard instanceof Array) {\r\n            path += wildCard.join('/');\r\n          } else {\r\n            path += wildCard;\r\n          }\r\n          break;\r\n        case TokenType.Delimiter:\r\n          path += token.value;\r\n          break;\r\n      }\r\n    }\r\n    return path;\r\n  }\r\n\r\n  return {\r\n    get regexp() {\r\n      return regexp;\r\n    },\r\n    get keys() {\r\n      return keys;\r\n    },\r\n    compile,\r\n    parse,\r\n  };\r\n}\r\n\r\n/**\r\n * @description 依次使用pathname与pattern进行匹配，根据匹配分数取得分数最高结果\r\n */\r\nexport function matchPath<P = any>(\r\n  pathname: string,\r\n  pattern: string | string[],\r\n  option?: ParserOption,\r\n): Matched<P> | null {\r\n  const patterns = Array.isArray(pattern) ? [...pattern] : [pattern];\r\n  const matchedResults: Matched<P>[] = [];\r\n  for (const item of patterns) {\r\n    const parser = createPathParser(item, option);\r\n    const matched = parser.parse(pathname);\r\n    if (matched) {\r\n      matchedResults.push(matched);\r\n    }\r\n  }\r\n  return !matchedResults.length ? null : matchedResults.sort((a, b) => scoreCompare(a.score, b.score))[0];\r\n}\r\n\r\nexport function generatePath<P = any>(path: string, params: Params<P>) {\r\n  const parser = createPathParser(path);\r\n  return parser.compile(params);\r\n}","import { useContext } from 'react';\r\nimport RouterContext from './context';\r\nimport { Matched, matchPath, Params } from './matcher/parser';\r\nimport { History } from '../history/types';\r\nimport { Location } from './index';\r\n\r\nfunction useHistory<S>(): History<S>;\r\nfunction useHistory() {\r\n  return useContext(RouterContext).history;\r\n}\r\n\r\nfunction useLocation<S>(): Location<S>;\r\nfunction useLocation() {\r\n  return useContext(RouterContext).location;\r\n}\r\n\r\nfunction useParams<P>(): Params<P> | {};\r\nfunction useParams() {\r\n  const match = useContext(RouterContext).match;\r\n  return match ? match.params : {};\r\n}\r\n\r\nfunction useRouteMatch<P>(path?: string): Matched<P> | null;\r\nfunction useRouteMatch(path?: string) {\r\n  const pathname = useLocation().pathname;\r\n  const match = useContext(RouterContext).match;\r\n  if (path) {\r\n    return matchPath(pathname, path);\r\n  }\r\n  return match;\r\n}\r\n\r\nexport { useHistory, useLocation, useParams, useRouteMatch };\r\n","import * as React from 'react';\r\nimport { History, Location } from './index';\r\nimport { Matched, matchPath } from './matcher/parser';\r\nimport { useContext, Children, createElement } from 'react';\r\nimport RouterContext from './context';\r\nimport { GetURLParams } from './matcher/types';\r\n\r\nexport type RouteComponentProps<P extends Record<string, any> = {}, S = unknown> = RouteChildrenProps<P, S>;\r\n\r\nexport type RouteChildrenProps<P extends Record<string, any> = {}, S = unknown> = {\r\n  history: History<S>;\r\n  location: Location<S>;\r\n  match: Matched<P> | null\r\n}\r\n\r\nexport type RouteProps<P extends Record<string, any> = {}, Path extends string = string> = {\r\n  location?: Location;\r\n  component?: React.ComponentType<RouteComponentProps<P>> | React.ComponentType<any> | undefined;\r\n  children?: ((props: RouteChildrenProps<P>) => React.ReactNode) | React.ReactNode;\r\n  render?: (props: RouteComponentProps<P>) => React.ReactNode;\r\n  path?: Path | Path[];\r\n  exact?: boolean;\r\n  sensitive?: boolean;\r\n  strict?: boolean;\r\n  computed?: Matched<P>;\r\n};\r\n\r\nfunction Route<Path extends string, P extends Record<string, any> = GetURLParams<Path>>(props: RouteProps<P, Path>) {\r\n  const context = useContext(RouterContext);\r\n\r\n  const { computed, location, path } = props;\r\n  let { children, component, render } = props;\r\n  let match: Matched<P> | null;\r\n\r\n  const routeLocation = location || context.location;\r\n  if (computed) {\r\n    match = computed;\r\n  } else if (path) {\r\n    match = matchPath<P>(routeLocation.pathname, path);\r\n  } else {\r\n    match = context.match;\r\n  }\r\n  const newProps = { ...context, location: routeLocation, match: match };\r\n\r\n  if (Array.isArray(children) && Children.count(children) === 0) {\r\n    children = null;\r\n  }\r\n\r\n  /**\r\n   * 按顺序获取需要渲染的组件\r\n   * 1.children\r\n   * 2.component\r\n   * 3.render\r\n   * 都没有匹配到返回Null\r\n   */\r\n  const getChildren = (): React.ReactNode | null => {\r\n    // 如果 match 存在\r\n    if (newProps.match) {\r\n      if (children) {\r\n        if (typeof children === 'function') {\r\n          return children(newProps);\r\n        }\r\n        return children;\r\n      }\r\n\r\n      if (component) {\r\n        return createElement(component, newProps);\r\n      } else if (render) {\r\n        return render(newProps);\r\n      } else {\r\n        return null;\r\n      }\r\n    } else {\r\n      // match为null\r\n      if (typeof children === 'function') {\r\n        return children(newProps);\r\n      }\r\n      return null;\r\n    }\r\n  };\r\n\r\n  return <RouterContext.Provider value={newProps}>{getChildren()}</RouterContext.Provider>;\r\n}\r\n\r\nexport default Route;\r\n","import * as React from 'react';\r\nimport { useLayoutEffect, useMemo, useRef, useState } from 'react';\r\n\r\nimport { History, Location } from '../history/types';\r\n\r\nimport RouterContext, { RouterContextValue } from './context';\r\n\r\nexport type RouterProps = {\r\n  history: History;\r\n  children?: React.ReactNode;\r\n};\r\n\r\nfunction Router<P extends RouterProps>(props: P) {\r\n  const { history, children = null } = props;\r\n  const [location, setLocation] = useState(props.history.location);\r\n  const pendingLocation = useRef<Location | null>(null);\r\n\r\n  // 在Router加载时就监听history地址变化，以保证在始渲染时重定向能正确触发\r\n  let unListen: null | (() => void) = history.listen(arg => {\r\n    pendingLocation.current = arg.location;\r\n  });\r\n\r\n  // 模拟componentDidMount和componentWillUnmount\r\n  useLayoutEffect(() => {\r\n    if (unListen) {\r\n      unListen();\r\n    }\r\n    // 监听history中的位置变化\r\n    unListen = history.listen(arg => {\r\n      setLocation(arg.location);\r\n    });\r\n\r\n    if (pendingLocation.current) {\r\n      setLocation(pendingLocation.current);\r\n    }\r\n\r\n    return () => {\r\n      if (unListen) {\r\n        unListen();\r\n        unListen = null;\r\n        pendingLocation.current = null;\r\n      }\r\n    };\r\n  }, []);\r\n\r\n  const initContextValue: RouterContextValue = useMemo(\r\n    () => ({\r\n      history: history,\r\n      location: location,\r\n      match: { isExact: location.pathname === '/', params: {}, path: '/', score: [], url: '/' },\r\n    }),\r\n    [location],\r\n  );\r\n\r\n  return <RouterContext.Provider value={initContextValue} children={children} />;\r\n}\r\n\r\nexport default Router;\r\n","export default function _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n  return target;\n}","import { useLayoutEffect, useRef } from 'react';\r\n\r\nexport type LifeCycleProps = {\r\n  onMount?: () => void;\r\n  onUpdate?: (prevProps?: LifeCycleProps) => void;\r\n  onUnmount?: () => void;\r\n  data?: any;\r\n};\r\n\r\nexport function LifeCycle(props: LifeCycleProps) {\r\n  // 使用ref保存上一次的props，防止重新渲染\r\n  const prevProps = useRef<LifeCycleProps | null>(null);\r\n  const isMount = useRef(false);\r\n\r\n  const { onMount, onUpdate, onUnmount } = props;\r\n\r\n  useLayoutEffect(() => {\r\n    // 首次挂载 模拟componentDidMount\r\n    if (!isMount.current) {\r\n      isMount.current = true;\r\n      if (onMount) {\r\n        onMount();\r\n      }\r\n    } else {\r\n      // 不是首次渲染 模拟componentDidUpdate\r\n      if (onUpdate) {\r\n        prevProps.current ? onUpdate(prevProps.current) : onUpdate();\r\n      }\r\n    }\r\n    prevProps.current = props;\r\n  });\r\n\r\n  // 模拟componentWillUnmount\r\n  useLayoutEffect(() => {\r\n    return () => {\r\n      if (onUnmount) {\r\n        onUnmount();\r\n      }\r\n    };\r\n  }, []);\r\n\r\n  return null;\r\n}\r\n","import * as React from 'react';\r\nimport { useContext } from 'react';\r\nimport RouterContext from './context';\r\nimport { LifeCycle, LifeCycleProps } from './lifeCycleHook';\r\nimport { Matched, createPathParser } from './matcher/parser';\r\nimport { addHeadSlash, isLocationEqual, parsePath } from '../history/utils';\r\nimport { Location } from './index';\r\n\r\nexport type RedirectProps = {\r\n  to: string | Partial<Location>;\r\n  push?: boolean;\r\n  path?: string;\r\n  from?: string;\r\n  exact?: boolean;\r\n  strict?: boolean;\r\n\r\n  // 由Switch计算得到\r\n  readonly computed?: Matched | null;\r\n};\r\n\r\nfunction Redirect<P extends RedirectProps>(props: P) {\r\n  const { to, push = false, computed } = props;\r\n\r\n  const context = useContext(RouterContext);\r\n  const { history } = context;\r\n\r\n  const calcLocation = (): Partial<Location> => {\r\n    if (computed) {\r\n      if (typeof to === 'string') {\r\n        const parser = createPathParser(to);\r\n        const target = parser.compile(computed.params);\r\n        return parsePath(target);\r\n      } else {\r\n        const pathname = to.pathname ? addHeadSlash(to.pathname) : '/';\r\n        const parser = createPathParser(pathname);\r\n        const target = parser.compile(computed.params);\r\n        return { ...to, pathname: target };\r\n      }\r\n    }\r\n    return typeof to === 'string' ? parsePath(to) : to;\r\n  };\r\n\r\n  const navigate = push ? history.push : history.replace;\r\n  const { state, ...path } = calcLocation();\r\n\r\n  const onMountFunc = () => {\r\n    navigate(path, state);\r\n  };\r\n\r\n  const onUpdateFunc = (prevProps?: LifeCycleProps) => {\r\n    // 如果当前页面与重定向前页面不一致，执行跳转\r\n    const prevPath = prevProps?.data as Location;\r\n    if (!isLocationEqual(prevPath, path)) {\r\n      navigate(path, state);\r\n    }\r\n  };\r\n\r\n  return <LifeCycle onMount={onMountFunc} onUpdate={onUpdateFunc} data={path} />;\r\n}\r\n\r\nexport default Redirect;\r\n","import * as React from 'react';\r\nimport { useContext, Children, isValidElement, cloneElement } from 'react';\r\n\r\nimport { Location } from './index';\r\nimport RouterContext from './context';\r\nimport { Matched, matchPath } from './matcher/parser';\r\nimport Route, { RouteProps } from './Route';\r\nimport Redirect, { RedirectProps } from './Redirect';\r\n\r\nexport type SwitchProps = {\r\n  location?: Location;\r\n  children?: React.ReactNode;\r\n};\r\n\r\nfunction Switch<P extends SwitchProps>(props: P): React.ReactElement | null {\r\n  const context = useContext(RouterContext);\r\n  const location = props.location || context.location;\r\n\r\n  let element: React.ReactElement | null = null;\r\n  let match: Matched | null = null;\r\n\r\n  // 使用forEach不会给React.ReactNode增加key属性,防止重新渲染\r\n  Children.forEach(props.children, node => {\r\n    if (match === null && isValidElement(node)) {\r\n      element = node;\r\n\r\n      let strict: boolean | undefined;\r\n      let sensitive: boolean | undefined;\r\n      let path: string | string[] | undefined;\r\n      let from: string | undefined;\r\n\r\n      // node可能是Route和Redirect\r\n      if (node.type === Route) {\r\n        const props = node.props as RouteProps;\r\n        strict = props.strict;\r\n        sensitive = props.sensitive;\r\n        path = props.path;\r\n      } else if (node.type === Redirect) {\r\n        const props = node.props as RedirectProps;\r\n        path = props.path;\r\n        strict = props.strict;\r\n        from = props.from;\r\n      }\r\n\r\n      const exact = node.props.exact;\r\n      const target = path || from;\r\n\r\n      // 更新匹配状态，一旦匹配到停止遍历\r\n      if (target) {\r\n        match = matchPath(location.pathname, target, {\r\n          strictMode: strict,\r\n          caseSensitive: sensitive,\r\n          exact: exact,\r\n        });\r\n      } else {\r\n        match = context.match;\r\n      }\r\n    }\r\n  });\r\n\r\n  if (match && element) {\r\n    // 使用cloneElement复制已有组件并更新其Props\r\n    return cloneElement(element, { location: location, computed: match });\r\n  }\r\n  return null;\r\n}\r\n\r\nexport default Switch;\r\n","import * as React from 'react';\r\nimport { useContext } from 'react';\r\nimport { LifeCycle, LifeCycleProps } from './lifeCycleHook';\r\nimport { Location } from './index';\r\nimport { Action } from '../history/types';\r\nimport RouterContext from './context';\r\n\r\ntype PromptProps = {\r\n  message?: string | ((location: Partial<Location>, action: Action) => void);\r\n  when?: boolean | ((location: Partial<Location>) => boolean);\r\n};\r\n\r\nfunction Prompt<P extends PromptProps>(props: P) {\r\n  const context = useContext(RouterContext);\r\n\r\n  const { message, when = true } = props;\r\n\r\n  if ((typeof when === 'function' && when(context.location) === false) || !when) {\r\n    return null;\r\n  }\r\n\r\n  const navigate = context.history.block;\r\n\r\n  let release: (() => void) | null = null;\r\n\r\n  const onMountFunc = () => {\r\n    release = message ? navigate(message) : null;\r\n  };\r\n\r\n  const onUpdateFunc = (prevProps?: LifeCycleProps) => {\r\n    if (prevProps && prevProps.data !== message) {\r\n      if (release) {\r\n        release();\r\n      }\r\n      release = message ? navigate(message) : null;\r\n    }\r\n  };\r\n\r\n  const onUnmountFunc = () => {\r\n    if (release) {\r\n      release();\r\n    }\r\n    release = null;\r\n  };\r\n\r\n  return <LifeCycle onMount={onMountFunc} onUpdate={onUpdateFunc} onUnmount={onUnmountFunc} data={message} />;\r\n}\r\n\r\nexport default Prompt;\r\n","import * as React from 'react';\r\nimport { useContext } from 'react';\r\nimport RouterContext from './context';\r\n\r\nfunction withRouter<C extends React.ComponentType>(Component: C) {\r\n\r\n  function ComponentWithRouterProp(props: any) {\r\n    const { history, location, match } = useContext(RouterContext);\r\n    const routeProps = { history: history, location: location, match: match };\r\n\r\n    return <Component {...props} {...routeProps} />;\r\n  }\r\n\r\n  return ComponentWithRouterProp;\r\n}\r\n\r\nexport default withRouter;","import * as React from 'react';\r\nimport { useRef } from 'react';\r\nimport { History } from '../history/types';\r\nimport { BaseRouterProps } from './BrowserRouter';\r\nimport { createHashHistory, urlHashType } from '../history/hashHistory';\r\nimport Router from './Router';\r\n\r\nexport type HashRouterProps = BaseRouterProps & {\r\n  hashType: urlHashType;\r\n};\r\n\r\nfunction HashRouter<P extends Partial<HashRouterProps>>(props: P) {\r\n  let historyRef = useRef<History>();\r\n  if (historyRef.current === null || historyRef.current === undefined) {\r\n    historyRef.current = createHashHistory({\r\n      basename: props.basename,\r\n      getUserConfirmation: props.getUserConfirmation,\r\n      hashType: props.hashType,\r\n    });\r\n  }\r\n\r\n  return <Router history={historyRef.current}>{props.children}</Router>;\r\n}\r\n\r\nexport default HashRouter;","import * as React from 'react';\r\nimport { useRef, ReactNode } from 'react';\r\nimport Router from './Router';\r\nimport { createBrowserHistory } from '../history/browerHistory';\r\nimport { ConfirmationFunc, History } from '../history/types';\r\n\r\nexport type BaseRouterProps = {\r\n  basename: string;\r\n  getUserConfirmation: ConfirmationFunc;\r\n  children?: ReactNode;\r\n};\r\n\r\nexport type BrowserRouterProps = BaseRouterProps & {\r\n  forceRefresh: boolean;\r\n};\r\n\r\nfunction BrowserRouter<P extends Partial<BrowserRouterProps>>(props: P) {\r\n  // 使用Ref持有History对象，防止重复渲染\r\n  let historyRef = useRef<History>();\r\n\r\n  if (historyRef.current === null || historyRef.current === undefined) {\r\n    historyRef.current = createBrowserHistory({\r\n      basename: props.basename,\r\n      forceRefresh: props.forceRefresh,\r\n      getUserConfirmation: props.getUserConfirmation,\r\n    });\r\n  }\r\n\r\n  return <Router history={historyRef.current}>{props.children}</Router>;\r\n}\r\n\r\nexport default BrowserRouter;","import * as React from 'react';\r\nimport { useContext } from 'react';\r\nimport RouterContext from './context';\r\nimport { Location } from './index';\r\nimport { createPath, parsePath } from '../history/utils';\r\nimport { Path } from '../history/types';\r\n\r\nexport type LinkProps = {\r\n  component?: React.ComponentType<any>;\r\n  to: Partial<Location> | string | ((location: Location) => string | Partial<Location>);\r\n  replace?: boolean;\r\n  tag?: string;\r\n  /**\r\n   * @deprecated\r\n   * React16以后不再需要该属性\r\n   **/\r\n  innerRef?: React.Ref<HTMLAnchorElement>;\r\n} & React.AnchorHTMLAttributes<HTMLAnchorElement>;\r\n\r\nconst isModifiedEvent = (event: React.MouseEvent) => {\r\n  return event.metaKey || event.altKey || event.ctrlKey || event.shiftKey;\r\n};\r\n\r\nconst checkTarget = (target?: React.HTMLAttributeAnchorTarget) => {\r\n  return !target || target === '_self';\r\n};\r\n\r\n\r\nfunction Link<P extends LinkProps>(props: P) {\r\n  const { to, replace, component, onClick, target, ...other } = props;\r\n\r\n  const tag = props.tag || 'a';\r\n\r\n  const context = useContext(RouterContext);\r\n  const history = context.history;\r\n\r\n  let location = typeof to === 'function' ? to(context.location) : to;\r\n\r\n  let state: any;\r\n  let path: Partial<Path>;\r\n  if (typeof location === 'string') {\r\n    path = parsePath(location);\r\n  } else {\r\n    const { pathname, hash, search } = location;\r\n    path = { pathname, hash, search };\r\n    state = location.state;\r\n  }\r\n  const href = history.createHref(path);\r\n\r\n  const linkClickEvent = (event: React.MouseEvent<HTMLAnchorElement>) => {\r\n    try {\r\n      if (onClick) {\r\n        onClick(event);\r\n      }\r\n    } catch (e) {\r\n      event.preventDefault();\r\n      throw e;\r\n    }\r\n\r\n    if (!event.defaultPrevented && event.button === 0 && checkTarget(target) && !isModifiedEvent(event)) {\r\n      // 不是相同的路径执行push操作，是相同的路径执行replace\r\n      const isSamePath = createPath(context.location) === createPath(path);\r\n      const navigate = replace || isSamePath ? history.replace : history.push;\r\n      event.preventDefault();\r\n      navigate(path, state);\r\n    }\r\n  };\r\n\r\n  const linkProps = { href: href, onClick: linkClickEvent, ...other };\r\n  return React.createElement(tag, linkProps);\r\n}\r\n\r\nexport default Link;","import * as React from 'react';\r\nimport { useContext } from 'react';\r\nimport type { LinkProps } from './Link';\r\nimport Link from './Link';\r\nimport { Location, matchPath } from './index';\r\nimport { Matched } from './matcher/parser';\r\nimport Context from './context';\r\nimport { parsePath } from '../history/utils';\r\nimport { escapeStr } from './matcher/utils';\r\n\r\ntype NavLinkProps = {\r\n  to: Partial<Location> | string | ((location: Location) => string | Partial<Location>);\r\n  isActive?: (match: Matched | null, location: Location) => boolean;\r\n  // compat react-router NavLink props type\r\n  [key: string]: any;\r\n} & LinkProps;\r\n\r\ntype Page = 'page';\r\n\r\nfunction NavLink<P extends NavLinkProps>(props: P) {\r\n  const { to, isActive, ...rest } = props;\r\n  const context = useContext(Context);\r\n\r\n  const toLocation = typeof to === 'function' ? to(context.location) : to;\r\n\r\n  const { pathname: path } = typeof toLocation === 'string' ? parsePath(toLocation) : toLocation;\r\n  // 把正则表达式的特殊符号加两个反斜杠进行转义\r\n  const escapedPath = path ? escapeStr(path) : '';\r\n  const match = escapedPath ? matchPath(context.location.pathname, escapedPath) : null;\r\n\r\n  const isLinkActive = match && isActive ? isActive(match, context.location) : false;\r\n\r\n  const page: Page = 'page';\r\n  const otherProps = {\r\n    'aria-current': isLinkActive ? page : false,\r\n    ...rest,\r\n  };\r\n\r\n  return <Link to={to} {...otherProps} />;\r\n}\r\n\r\nexport default NavLink;\r\n","import { Location } from '../router';\r\nimport { Action } from '../history/types';\r\n\r\n// 获取redux state中的值\r\nexport function getIn(state: Record<string, any>, path: string[]): any {\r\n  if (!state) {\r\n    return state;\r\n  }\r\n  const length = path.length;\r\n  if (!length) {\r\n    return undefined;\r\n  }\r\n  let res = state;\r\n  for (let i = 0; i < length && !!res; ++i) {\r\n    res = res[path[i]];\r\n  }\r\n  return res;\r\n}\r\n\r\n// 从store的state中获取Router、Location、Action、Hash等信息\r\nconst stateReader = (storeType: string) => {\r\n  const isRouter = (value: unknown) => {\r\n    return value !== null && typeof value === 'object' && !!getIn(value, ['location']) && !!getIn(value, ['action']);\r\n  };\r\n\r\n  const getRouter = (state: any) => {\r\n    const router = getIn(state, ['router']);\r\n    if (!isRouter(router)) {\r\n      throw new Error(`Could not find router reducer in ${storeType} store, it must be mounted under \"router\"`);\r\n    }\r\n    return router!;\r\n  };\r\n\r\n  const getLocation = <S>(state: any): Partial<Location<S>> => getIn(getRouter(state), ['location']);\r\n  const getAction = (state: any): Action => getIn(getRouter(state), ['action']);\r\n  const getSearch = (state: any): string => getIn(getRouter(state), ['location', 'search']);\r\n  const getHash = (state: any): string => getIn(getRouter(state), ['location', 'hash']);\r\n\r\n  return {\r\n    getHash,\r\n    getAction,\r\n    getSearch,\r\n    getRouter,\r\n    getLocation,\r\n  };\r\n};\r\n\r\nexport default stateReader","import * as React from 'react';\r\nimport { useLayoutEffect } from 'react';\r\nimport { connect, ReactReduxContext } from 'react-redux';\r\nimport { Store } from 'redux';\r\nimport { reduxAdapter } from '@cloudsop/horizon';\r\nimport { History, Location, Router } from '../router';\r\nimport { Action, DefaultStateType, Navigation } from '../history/types';\r\nimport { ActionMessage, onLocationChanged } from './actions';\r\nimport stateReader from './reduxUtils';\r\n\r\ntype StoreType = 'HorizonXCompat' | 'Redux';\r\n\r\ntype ConnectedRouter<S> = {\r\n  store: Store;\r\n  history: History<S>;\r\n  basename: string;\r\n  children?: (() => React.ReactNode) | React.ReactNode;\r\n  onLocationChanged: (location: Location<S>, action: Action, isFirstRendering: boolean) => ActionMessage;\r\n  noInitialPop: boolean;\r\n  omitRouter: boolean;\r\n  storeType: StoreType;\r\n};\r\n\r\nconst { connect: hConnect } = reduxAdapter;\r\n\r\nfunction ConnectedRouterWithoutMemo<S>(props: ConnectedRouter<S>) {\r\n  const { store, history, onLocationChanged, omitRouter, children, storeType } = props;\r\n  const { getLocation } = stateReader(storeType);\r\n\r\n  // 监听store变化\r\n  const unsubscribe = store.subscribe(() => {\r\n    // 获取redux State中的location信息\r\n    const {\r\n      pathname: pathnameInStore,\r\n      search: searchInStore,\r\n      hash: hashInStore,\r\n      state: stateInStore,\r\n    } = getLocation<S>(store.getState());\r\n\r\n    // 获取当前history对象中的location信息\r\n    const {\r\n      pathname: pathnameInHistory,\r\n      search: searchInHistory,\r\n      hash: hashInHistory,\r\n      state: stateInHistory,\r\n    } = history.location;\r\n\r\n    // 两个location不一致 执行跳转\r\n    if (\r\n      history.action === 'PUSH' &&\r\n      (pathnameInHistory !== pathnameInStore ||\r\n        searchInHistory !== searchInStore ||\r\n        hashInHistory !== hashInStore ||\r\n        stateInHistory !== stateInStore)\r\n    ) {\r\n      history.push(\r\n        {\r\n          pathname: pathnameInStore,\r\n          search: searchInStore,\r\n          hash: hashInStore,\r\n        },\r\n        stateInStore,\r\n      );\r\n    }\r\n  });\r\n\r\n  const handleLocationChange = (args: Navigation<S>, isFirstRendering: boolean = false) => {\r\n    const { location, action } = args;\r\n    onLocationChanged(location, action, isFirstRendering);\r\n  };\r\n\r\n  // 监听history更新\r\n  const unListen = () => history.listen(handleLocationChange);\r\n\r\n  useLayoutEffect(() => {\r\n    return () => {\r\n      unListen();\r\n      unsubscribe();\r\n    };\r\n  }, []);\r\n\r\n  if (!props.noInitialPop) {\r\n    // 传递初始时位置信息，isFirstRendering设为true防止重复渲染\r\n    handleLocationChange({ location: history.location, action: history.action }, true);\r\n  }\r\n\r\n  if (omitRouter) {\r\n    return <>{children}</>;\r\n  }\r\n  let childrenNode: React.ReactNode;\r\n  if (typeof children === 'function') {\r\n    childrenNode = children();\r\n  } else {\r\n    childrenNode = children;\r\n  }\r\n\r\n  return <Router history={history}>{childrenNode}</Router>;\r\n}\r\n\r\nfunction getConnectedRouter<S = DefaultStateType>(type: StoreType) {\r\n  const mapDispatchToProps = (dispatch: any) => ({\r\n    onLocationChanged: (location: Location, action: Action, isFirstRendering: boolean) =>\r\n      dispatch(onLocationChanged(location, action, isFirstRendering)),\r\n  });\r\n  const ConnectedRouter = React.memo(ConnectedRouterWithoutMemo<S>);\r\n\r\n  const ConnectedRouterWithContext = (props: any) => {\r\n    const Context = props.context || ReactReduxContext;\r\n\r\n    return (\r\n      <Context.Consumer>\r\n        {({ store }: any) => <ConnectedRouter store={store} storeType={type} {...props} />}\r\n      </Context.Consumer>\r\n    );\r\n  };\r\n\r\n  // 针对不同的Store类型，使用对应的connect函数\r\n  if (type === 'HorizonXCompat') {\r\n    return hConnect(null, mapDispatchToProps)(ConnectedRouterWithContext);\r\n  }\r\n  if (type === 'Redux') {\r\n    return connect(null, mapDispatchToProps)(ConnectedRouterWithContext);\r\n  } else {\r\n    throw new Error('Invalid store type');\r\n  }\r\n}\r\n\r\nexport { getConnectedRouter };\r\n","import { ActionMessage, ActionName } from './actions';\r\nimport { History } from '../history/types';\r\n\r\n// 定义connect-router对应的redux dispatch函数\r\nexport function routerMiddleware(history: History) {\r\n  return function(_: any) {\r\n    return function(next: any) {\r\n      return function(action: ActionMessage) {\r\n        if (action.type !== ActionName.CALL_HISTORY_METHOD) {\r\n          return next(action);\r\n        }\r\n        const { payload: { method, args } } = action;\r\n        if (method in history) {\r\n          (history as any)[method](...args);\r\n        }\r\n      };\r\n    };\r\n  };\r\n}\r\n","import { createConnectRouter } from './reducer';\r\n\r\nexport { getConnectedRouter } from './connectedRouter';\r\nexport const connectRouter = createConnectRouter();\r\nexport { routerMiddleware } from './dispatch';\r\n","import { Location as HLocation } from '../history/types';\r\nimport { getConnectedRouter } from '../connect-router';\r\n\r\ntype Location<S = unknown> = Omit<HLocation<S>, 'key'>;\r\n\r\n// ============================ history ============================\r\n\r\nexport { Location };\r\nexport type { History } from '../history/types';\r\n\r\nexport { createBrowserHistory } from '../history/browerHistory';\r\nexport { createHashHistory } from '../history/hashHistory';\r\n\r\nexport { default as __RouterContext } from './context';\r\n\r\n// ============================ URL parser ============================\r\n\r\nexport { matchPath, generatePath } from './matcher/parser';\r\n\r\n// ============================ Router Hooks ============================\r\n\r\nexport { useHistory, useLocation, useParams, useRouteMatch } from './hooks';\r\n\r\n// ============================ Router function component ============================\r\n\r\nexport { default as Route } from './Route';\r\nexport { default as Router } from './Router';\r\nexport { default as Switch } from './Switch';\r\nexport { default as Redirect } from './Redirect';\r\nexport { default as Prompt } from './Prompt';\r\nexport { default as withRouter } from './withRouter';\r\nexport { default as HashRouter } from './HashRouter';\r\nexport { default as BrowserRouter } from './BrowserRouter';\r\nexport { default as Link } from './Link';\r\nexport { default as NavLink } from './NavLink';\r\n\r\n// ============================ Router Types ============================\r\n\r\nexport type { RouteComponentProps, RouteChildrenProps, RouteProps } from './Route';\r\n\r\n// ============================ Connect-router ============================\r\n\r\nexport { connectRouter, routerMiddleware } from '../connect-router';\r\nexport const ConnectedRouter = getConnectedRouter('Redux');\r\nexport const ConnectedHRouter = getConnectedRouter('HorizonXCompat');"],"names":["_extends","Object","assign","bind","target","i","arguments","length","source","key","prototype","hasOwnProperty","call","apply","ActionName","onLocationChanged","location","action","isFirstRendering","undefined","type","LOCATION_CHANGE","payload","injectQueryParams","query","queryString","search","queryObject","params","URLSearchParams","forEach","value","createConnectRouter","history","initRouterState","state","_ref","isBrowser","window","document","createElement","getDefaultConfirmation","message","callBack","confirm","isSupportHistory","isSupportsPopState","navigator","userAgent","indexOf","Action","EventType","createPath","path","hash","pathname","startsWith","parsePath","url","parsedPath","hashIdx","substring","searchIdx","createLocation","current","to","urlObj","getRandKey","genRandomKey","isLocationEqual","p1","p2","addHeadSlash","stripHeadSlash","normalizeSlash","tempPath","hasBasename","prefix","toLowerCase","includes","charAt","stripBasename","createMemoryRecord","initVal","fn","visitedRecord","getDelta","form","toIdx","lastIndexOf","fromIdx","addRecord","newRecord","curVal","NewVal","push","prevIdx","newVisitedRecord","slice","replace","end","Math","random","toString","_classCallCheck","instance","Constructor","TypeError","_typeof","obj","Symbol","iterator","constructor","_toPrimitive","input","hint","prim","toPrimitive","res","String","Number","_toPropertyKey","arg","_defineProperties","props","descriptor","enumerable","configurable","writable","defineProperty","toPropertyKey","_createClass","protoProps","staticProps","TransitionManager","prompt","listeners","setPrompt","_this","addListener","func","_this2","isActive","listener","args","filter","item","notifyListeners","_iterator","_createForOfIteratorHelper","_step","s","n","done","err","e","f","confirmJumpTo","userConfirmationFunc","result","warning","condition","console","warn","getBaseHistory","transitionManager","setListener","browserHistory","go","step","goBack","goForward","listen","cancel","isBlocked","block","unblock","getUpdateStateFunc","historyProps","nextState","createBrowserHistory","options","supportHistory","isSupportPopState","_options$forceRefresh","forceRefresh","_options$getUserConfi","getUserConfirmation","basename","initLocation","getLocation","getHistoryState","recordOperator","l","_getBaseHistory","pop","createHref","updateState","historyState","_window$location","forceJump","handlePopState","callback","isJump","revertPopState","popStateListener","event","hashChangeListener","listenerCount","count","addEventListener","PopState","HashChange","removeEventListener","delta","href","pushState","replaceState","stripHash","idx","getHashContent","createHashHistory","option","_option$hashType","hashType","_option$getUserConfir","pathDecoder","pathEncoder","hashPath","memRecords","tag","querySelector","base","getAttribute","forceNextPop","ignorePath","encodedPath","handleHashChange","prevLocation","createNamedContext","name","defaultValue","context","createContext","displayName","RouterContext","TokenType","cleanPath","scoreCompare","score1","score2","score1Length","score2Length","min","escapeStr","str","validChar","lexer","tokens","urlPath","Error","getLiteral","test","skipChar","curChar","prevChar","Delimiter","Param","WildCard","Static","LBracket","RBracket","Pattern","MatchScore","defaultOption","caseSensitive","strictMode","exact","REGEX_CHARS_RE","BASE_PARAM_PATTERN","DefaultDelimiter","createPathParser","_option$caseSensitive","_option$strictMode","_option$exact","pattern","keys","scores","onlyHasWildCard","tokenCount","lastToken","tokenIdx","token","nextToken","static","paramRegexp","param","wildcard","placeholder","isWildCard","flag","regexp","RegExp","parse","reMatch","match","matchedPath","parseScore","Array","from","split","isArray","_params$","splice","concat","fill","isExact","score","compile","wildCard","join","matchPath","patterns","matchedResults","_iterator2","_step2","parser","matched","sort","a","b","generatePath","useHistory","useContext","useLocation","useParams","useRouteMatch","Route","computed","children","component","render","routeLocation","newProps","Children","getChildren","React","Provider","Router","_props$children","_useState","useState","setLocation","pendingLocation","useRef","unListen","useLayoutEffect","initContextValue","useMemo","_objectWithoutPropertiesLoose","excluded","sourceKeys","LifeCycle","prevProps","isMount","onMount","onUpdate","onUnmount","Redirect","_props$push","calcLocation","navigate","_calcLocation","_excluded","onMountFunc","onUpdateFunc","prevPath","data","Switch","element","node","isValidElement","strict","sensitive","cloneElement","Prompt","_props$when","when","release","onUnmountFunc","withRouter","Component","ComponentWithRouterProp","_useContext","routeProps","HashRouter","historyRef","BrowserRouter","isModifiedEvent","metaKey","altKey","ctrlKey","shiftKey","checkTarget","Link","onClick","other","linkClickEvent","preventDefault","defaultPrevented","button","isSamePath","linkProps","NavLink","rest","Context","toLocation","escapedPath","isLinkActive","page","otherProps","getIn","stateReader","storeType","isRouter","getRouter","router","getAction","getSearch","getHash","hConnect","reduxAdapter","connect","ConnectedRouterWithoutMemo","store","omitRouter","_stateReader","unsubscribe","subscribe","_getLocation","getState","pathnameInStore","searchInStore","hashInStore","stateInStore","_history$location","pathnameInHistory","searchInHistory","hashInHistory","stateInHistory","handleLocationChange","noInitialPop","Fragment","childrenNode","getConnectedRouter","mapDispatchToProps","dispatch","ConnectedRouter","memo","ConnectedRouterWithContext","ReactReduxContext","Consumer","routerMiddleware","_","next","CALL_HISTORY_METHOD","_action$payload","method","connectRouter","ConnectedHRouter"],"mappings":"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"}
diff --git a/packages/horizon-router/connectRouter/esm/connectRouter.js b/packages/horizon-router/connectRouter/esm/connectRouter.js
new file mode 100644
index 00000000..798c7413
--- /dev/null
+++ b/packages/horizon-router/connectRouter/esm/connectRouter.js
@@ -0,0 +1,1742 @@
+import * as React from 'react';
+import { createContext, useContext, Children, createElement, useState, useRef, useLayoutEffect, useMemo, isValidElement, cloneElement } from 'react';
+import { connect, ReactReduxContext } from 'react-redux';
+import { reduxAdapter } from '@cloudsop/horizon';
+
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+
+// 定义位置变化和history方法调用的Action type
+var ActionName = /*#__PURE__*/function (ActionName) {
+  ActionName["LOCATION_CHANGE"] = "$horizon-router/LOCATION_CHANGE";
+  ActionName["CALL_HISTORY_METHOD"] = "$horizon-router/CALL_HISTORY_METHOD";
+  return ActionName;
+}({});
+
+// 定义Action的两种数据类型
+
+var onLocationChanged = function (location, action) {
+  var isFirstRendering = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  return {
+    type: ActionName.LOCATION_CHANGE,
+    payload: {
+      location: location,
+      action: action,
+      isFirstRendering: isFirstRendering
+    }
+  };
+};
+
+// 解析location对象，将其中的query参数解析并注入
+function injectQueryParams(location) {
+  if (location && location.query) {
+    return location;
+  }
+  var queryString = location && location.search;
+  if (!queryString) {
+    return _extends({}, location, {
+      query: {}
+    });
+  }
+  var queryObject = {};
+  var params = new URLSearchParams(queryString);
+  params.forEach(function (value, key) {
+    return queryObject[key] = value;
+  });
+  return _extends({}, location, {
+    query: queryObject
+  });
+}
+function createConnectRouter() {
+  // 初始化redux State
+  return function (history) {
+    var initRouterState = {
+      location: injectQueryParams(history.location),
+      action: history.action
+    };
+
+    // 定义connect-router对应的redux reducer函数
+    return function () {
+      var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initRouterState;
+      var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+        type = _ref.type,
+        payload = _ref.payload;
+      if (type === ActionName.LOCATION_CHANGE) {
+        var location = payload.location,
+          action = payload.action,
+          isFirstRendering = payload.isFirstRendering;
+        if (isFirstRendering) {
+          return state;
+        }
+        return _extends({}, state, {
+          location: injectQueryParams(location),
+          action: action
+        });
+      }
+      return state;
+    };
+  };
+}
+
+function isBrowser() {
+  return typeof window !== 'undefined' && window.document && typeof window.document.createElement === 'function';
+}
+function getDefaultConfirmation(message, callBack) {
+  callBack(window.confirm(message));
+}
+
+// 判断浏览器是否支持pushState方法，pushState是browserHistory实现的基础
+function isSupportHistory() {
+  return isBrowser() && window.history && 'pushState' in window.history;
+}
+
+// 判断浏览器是否支持PopState事件
+function isSupportsPopState() {
+  return window.navigator.userAgent.indexOf('Trident') === -1;
+}
+
+var Action = /*#__PURE__*/function (Action) {
+  Action["pop"] = "POP";
+  Action["push"] = "PUSH";
+  Action["replace"] = "REPLACE";
+  return Action;
+}({});
+var EventType = /*#__PURE__*/function (EventType) {
+  EventType["PopState"] = "popstate";
+  EventType["HashChange"] = "hashchange";
+  return EventType;
+}({});
+
+function createPath(path) {
+  var search = path.search,
+    hash = path.hash;
+  var pathname = path.pathname || '/';
+  if (search && search !== '?') {
+    pathname += search.startsWith('?') ? search : '?' + search;
+  }
+  if (hash && hash !== '#') {
+    pathname += hash.startsWith('#') ? hash : '#' + hash;
+  }
+  return pathname;
+}
+function parsePath(url) {
+  if (!url) {
+    return {};
+  }
+  var parsedPath = {};
+  var hashIdx = url.indexOf('#');
+  if (hashIdx > -1) {
+    parsedPath.hash = url.substring(hashIdx);
+    url = url.substring(0, hashIdx);
+  }
+  var searchIdx = url.indexOf('?');
+  if (searchIdx > -1) {
+    parsedPath.search = url.substring(searchIdx);
+    url = url.substring(0, searchIdx);
+  }
+  if (url) {
+    parsedPath.pathname = url;
+  }
+  return parsedPath;
+}
+function createLocation(current, to, state, key) {
+  var pathname = typeof current === 'string' ? current : current.pathname;
+  var urlObj = typeof to === 'string' ? parsePath(to) : to;
+  // 随机key长度取6
+  var getRandKey = genRandomKey(6);
+  var location = _extends({
+    pathname: pathname,
+    search: '',
+    hash: '',
+    state: state,
+    key: typeof key === 'string' ? key : getRandKey()
+  }, urlObj);
+  if (!location.pathname) {
+    location.pathname = '/';
+  }
+  return location;
+}
+function isLocationEqual(p1, p2) {
+  return p1.pathname === p2.pathname && p1.search === p2.search && p1.hash === p2.hash;
+}
+function addHeadSlash(path) {
+  if (path[0] === '/') {
+    return path;
+  }
+  return '/' + path;
+}
+function stripHeadSlash(path) {
+  if (path[0] === '/') {
+    return path.substring(1);
+  }
+  return path;
+}
+function normalizeSlash(path) {
+  var tempPath = addHeadSlash(path);
+  if (tempPath[tempPath.length - 1] === '/') {
+    return tempPath.substring(0, tempPath.length - 1);
+  }
+  return tempPath;
+}
+function hasBasename(path, prefix) {
+  return path.toLowerCase().indexOf(prefix.toLowerCase()) === 0 && ['/', '?', '#', ''].includes(path.charAt(prefix.length));
+}
+function stripBasename(path, prefix) {
+  return hasBasename(path, prefix) ? path.substring(prefix.length) : path;
+}
+
+// 使用随机生成的Key记录被访问过的URL，当Block被被触发时利用delta值跳转到之前的页面
+function createMemoryRecord(initVal, fn) {
+  var visitedRecord = [fn(initVal)];
+  function getDelta(to, form) {
+    var toIdx = visitedRecord.lastIndexOf(fn(to));
+    if (toIdx === -1) {
+      toIdx = 0;
+    }
+    var fromIdx = visitedRecord.lastIndexOf(fn(form));
+    if (fromIdx === -1) {
+      fromIdx = 0;
+    }
+    return toIdx - fromIdx;
+  }
+  function addRecord(current, newRecord, action) {
+    var curVal = fn(current);
+    var NewVal = fn(newRecord);
+    if (action === Action.push) {
+      var prevIdx = visitedRecord.lastIndexOf(curVal);
+      var newVisitedRecord = visitedRecord.slice(0, prevIdx + 1);
+      newVisitedRecord.push(NewVal);
+      visitedRecord = newVisitedRecord;
+    }
+    if (action === Action.replace) {
+      var _prevIdx = visitedRecord.lastIndexOf(curVal);
+      if (_prevIdx !== -1) {
+        visitedRecord[_prevIdx] = NewVal;
+      }
+    }
+  }
+  return {
+    getDelta: getDelta,
+    addRecord: addRecord
+  };
+}
+function genRandomKey(length) {
+  var end = length + 2;
+  return function () {
+    return Math.random().toString(18).substring(2, end);
+  };
+}
+
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+  }, _typeof(obj);
+}
+
+function _toPrimitive(input, hint) {
+  if (_typeof(input) !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (_typeof(res) !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return _typeof(key) === "symbol" ? key : String(key);
+}
+
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+
+function _createForOfIteratorHelper$1(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$1(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function () {}; return { s: F, n: function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function (e) { throw e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function () { it = it.call(o); }, n: function () { var step = it.next(); normalCompletion = step.done; return step; }, e: function (e) { didErr = true; err = e; }, f: function () { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray$1(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$1(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$1(o, minLen); }
+function _arrayLikeToArray$1(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+var TransitionManager = /*#__PURE__*/function () {
+  function TransitionManager() {
+    _classCallCheck(this, TransitionManager);
+    this.prompt = void 0;
+    this.listeners = void 0;
+    this.prompt = null;
+    this.listeners = [];
+  }
+  _createClass(TransitionManager, [{
+    key: "setPrompt",
+    value: function setPrompt(prompt) {
+      var _this = this;
+      this.prompt = prompt;
+
+      // 清除Prompt
+      return function () {
+        if (_this.prompt === prompt) {
+          _this.prompt = null;
+        }
+      };
+    }
+
+    // 使用发布订阅模式管理history的监听者
+  }, {
+    key: "addListener",
+    value: function addListener(func) {
+      var _this2 = this;
+      var isActive = true;
+      var listener = function (args) {
+        if (isActive) {
+          func(args);
+        }
+      };
+      this.listeners.push(listener);
+      return function () {
+        isActive = false;
+        // 移除对应的监听者
+        _this2.listeners = _this2.listeners.filter(function (item) {
+          return item !== listener;
+        });
+      };
+    }
+  }, {
+    key: "notifyListeners",
+    value: function notifyListeners(args) {
+      var _iterator = _createForOfIteratorHelper$1(this.listeners),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var listener = _step.value;
+          listener(args);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+  }, {
+    key: "confirmJumpTo",
+    value: function confirmJumpTo(location, action, userConfirmationFunc, callBack) {
+      if (this.prompt !== null) {
+        var result = typeof this.prompt === 'function' ? this.prompt(location, action) : this.prompt;
+        if (typeof result === 'string') {
+          typeof userConfirmationFunc === 'function' ? userConfirmationFunc(result, callBack) : callBack(true);
+        } else {
+          callBack(result !== false);
+        }
+      } else {
+        callBack(true);
+      }
+    }
+  }]);
+  return TransitionManager;
+}();
+
+function warning(condition, message) {
+  if (condition) {
+    if (console && typeof console.warn === 'function') {
+      console.warn(message);
+    }
+  }
+}
+
+// 抽取BrowserHistory和HashHistory中相同的方法
+function getBaseHistory(transitionManager, setListener, browserHistory) {
+  function go(step) {
+    browserHistory.go(step);
+  }
+  function goBack() {
+    browserHistory.go(-1);
+  }
+  function goForward() {
+    browserHistory.go(1);
+  }
+  function listen(listener) {
+    var cancel = transitionManager.addListener(listener);
+    setListener(1);
+    return function () {
+      setListener(-1);
+      cancel();
+    };
+  }
+  var isBlocked = false;
+  function block() {
+    var prompt = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    var unblock = transitionManager.setPrompt(prompt);
+    if (!isBlocked) {
+      setListener(1);
+      isBlocked = true;
+    }
+    return function () {
+      if (isBlocked) {
+        isBlocked = false;
+        setListener(-1);
+      }
+      unblock();
+    };
+  }
+  function getUpdateStateFunc(historyProps) {
+    return function (nextState) {
+      if (nextState) {
+        _extends(historyProps, nextState);
+      }
+      historyProps.length = browserHistory.length;
+      var args = {
+        location: historyProps.location,
+        action: historyProps.action
+      };
+      transitionManager.notifyListeners(args);
+    };
+  }
+  return {
+    go: go,
+    goBack: goBack,
+    goForward: goForward,
+    listen: listen,
+    block: block,
+    getUpdateStateFunc: getUpdateStateFunc
+  };
+}
+
+function createBrowserHistory() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var supportHistory = isSupportHistory();
+  var isSupportPopState = isSupportsPopState();
+  var browserHistory = window.history;
+  var _options$forceRefresh = options.forceRefresh,
+    forceRefresh = _options$forceRefresh === void 0 ? false : _options$forceRefresh,
+    _options$getUserConfi = options.getUserConfirmation,
+    getUserConfirmation = _options$getUserConfi === void 0 ? getDefaultConfirmation : _options$getUserConfi;
+  var basename = options.basename ? normalizeSlash(options.basename) : '';
+  var initLocation = getLocation(getHistoryState());
+  var recordOperator = createMemoryRecord(initLocation, function (l) {
+    return l.key;
+  });
+  var transitionManager = new TransitionManager();
+  var _getBaseHistory = getBaseHistory(transitionManager, setListener, browserHistory),
+    go = _getBaseHistory.go,
+    goBack = _getBaseHistory.goBack,
+    goForward = _getBaseHistory.goForward,
+    listen = _getBaseHistory.listen,
+    block = _getBaseHistory.block,
+    getUpdateStateFunc = _getBaseHistory.getUpdateStateFunc;
+  var history = {
+    action: Action.pop,
+    length: browserHistory.length,
+    location: initLocation,
+    go: go,
+    goBack: goBack,
+    goForward: goForward,
+    listen: listen,
+    block: block,
+    push: push,
+    replace: replace,
+    createHref: createHref
+  };
+  var updateState = getUpdateStateFunc(history);
+  function getHistoryState() {
+    return supportHistory ? window.history.state : {};
+  }
+  function getLocation(historyState) {
+    var _window$location = window.location,
+      search = _window$location.search,
+      hash = _window$location.hash;
+    var _ref = historyState || {},
+      key = _ref.key,
+      state = _ref.state;
+    var pathname = window.location.pathname;
+    pathname = basename ? stripBasename(pathname, basename) : pathname;
+    return createLocation('', {
+      pathname: pathname,
+      search: search,
+      hash: hash
+    }, state, key);
+  }
+
+  // 拦截页面POP事件后，防止返回到的页面被重复拦截
+  var forceJump = false;
+  function handlePopState(location) {
+    if (forceJump) {
+      forceJump = false;
+      updateState(undefined);
+    } else {
+      var action = Action.pop;
+      var callback = function (isJump) {
+        if (isJump) {
+          // 执行跳转行为
+          updateState({
+            action: action,
+            location: location
+          });
+        } else {
+          revertPopState(location, history.location);
+        }
+      };
+      transitionManager.confirmJumpTo(location, action, getUserConfirmation, callback);
+    }
+  }
+  function popStateListener(event) {
+    handlePopState(getLocation(event.state));
+  }
+  function hashChangeListener() {
+    var location = getLocation(getHistoryState());
+    handlePopState(location);
+  }
+  var listenerCount = 0;
+  function setListener(count) {
+    listenerCount += count;
+    if (listenerCount === 1 && count === 1) {
+      window.addEventListener(EventType.PopState, popStateListener);
+      if (!isSupportPopState) {
+        window.addEventListener(EventType.HashChange, hashChangeListener);
+      }
+    } else if (listenerCount === 0) {
+      window.removeEventListener(EventType.PopState, popStateListener);
+      if (!isSupportPopState) {
+        window.removeEventListener(EventType.HashChange, hashChangeListener);
+      }
+    }
+  }
+
+  // 取消页面跳转并恢复到跳转前的页面
+  function revertPopState(form, to) {
+    var delta = recordOperator.getDelta(to, form);
+    if (delta !== 0) {
+      go(delta);
+      forceJump = true;
+    }
+  }
+  function createHref(path) {
+    return basename + createPath(path);
+  }
+  function push(to, state) {
+    var action = Action.push;
+    var location = createLocation(history.location, to, state, undefined);
+    transitionManager.confirmJumpTo(location, action, getUserConfirmation, function (isJump) {
+      if (!isJump) {
+        return;
+      }
+      var href = createHref(location);
+      var key = location.key,
+        state = location.state;
+      if (supportHistory) {
+        if (forceRefresh) {
+          window.location.href = href;
+        } else {
+          browserHistory.pushState({
+            key: key,
+            state: state
+          }, '', href);
+          recordOperator.addRecord(history.location, location, action);
+          updateState({
+            action: action,
+            location: location
+          });
+        }
+      } else {
+        warning(state !== undefined, 'Browser history cannot push state in browsers that do not support HTML5 history');
+        window.location.href = href;
+      }
+    });
+  }
+  function replace(to, state) {
+    var action = Action.replace;
+    var location = createLocation(history.location, to, state, undefined);
+    transitionManager.confirmJumpTo(location, action, getUserConfirmation, function (isJump) {
+      if (!isJump) {
+        return;
+      }
+      var href = createHref(location);
+      var key = location.key,
+        state = location.state;
+      if (supportHistory) {
+        if (forceRefresh) {
+          window.location.replace(href);
+        } else {
+          browserHistory.replaceState({
+            key: key,
+            state: state
+          }, '', href);
+          recordOperator.addRecord(history.location, location, action);
+          updateState({
+            action: action,
+            location: location
+          });
+        }
+      } else {
+        warning(state !== undefined, 'Browser history cannot push state in browsers that do not support HTML5 history');
+        window.location.replace(href);
+      }
+    });
+  }
+  return history;
+}
+
+// 获取#前的内容
+function stripHash(path) {
+  var idx = path.indexOf('#');
+  return idx === -1 ? path : path.substring(0, idx);
+}
+
+// 获取#后的内容
+function getHashContent(path) {
+  var idx = path.indexOf('#');
+  return idx === -1 ? '' : path.substring(idx + 1);
+}
+function createHashHistory() {
+  var option = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var browserHistory = window.history;
+  var _option$hashType = option.hashType,
+    hashType = _option$hashType === void 0 ? 'slash' : _option$hashType,
+    _option$getUserConfir = option.getUserConfirmation,
+    getUserConfirmation = _option$getUserConfir === void 0 ? getDefaultConfirmation : _option$getUserConfir;
+  var basename = option.basename ? normalizeSlash(option.basename) : '';
+  var pathDecoder = addHeadSlash;
+  var pathEncoder = hashType === 'slash' ? addHeadSlash : stripHeadSlash;
+  function getLocation() {
+    var hashPath = pathDecoder(getHashContent(window.location.hash));
+    if (basename) {
+      hashPath = stripBasename(hashPath, basename);
+    }
+    return createLocation('', hashPath, undefined, 'default');
+  }
+  var initLocation = getLocation();
+  var memRecords = createMemoryRecord(initLocation, createPath);
+  var transitionManager = new TransitionManager();
+  function createHref(location) {
+    var tag = document.querySelector('base');
+    var base = tag && tag.getAttribute('href') ? stripHash(window.location.href) : '';
+    return base + '#' + pathEncoder(basename + createPath(location));
+  }
+  var forceNextPop = false;
+  var ignorePath = null;
+  var _getBaseHistory = getBaseHistory(transitionManager, setListener, browserHistory),
+    go = _getBaseHistory.go,
+    goBack = _getBaseHistory.goBack,
+    goForward = _getBaseHistory.goForward,
+    listen = _getBaseHistory.listen,
+    block = _getBaseHistory.block,
+    getUpdateStateFunc = _getBaseHistory.getUpdateStateFunc;
+  var history = {
+    action: Action.pop,
+    length: browserHistory.length,
+    location: initLocation,
+    go: go,
+    goBack: goBack,
+    goForward: goForward,
+    push: push,
+    replace: replace,
+    listen: listen,
+    block: block,
+    createHref: createHref
+  };
+  var updateState = getUpdateStateFunc(history);
+  function push(to, state) {
+    warning(state !== undefined, 'Hash history does not support state, it will be ignored');
+    var action = Action.push;
+    var location = createLocation(history.location, to, undefined, '');
+    transitionManager.confirmJumpTo(location, action, getUserConfirmation, function (isJump) {
+      if (!isJump) {
+        return;
+      }
+      var path = createPath(location);
+      var encodedPath = pathEncoder(basename + path);
+      // 前后hash不一样才进行跳转
+      if (getHashContent(window.location.href) !== encodedPath) {
+        ignorePath = encodedPath;
+        window.location.hash = encodedPath;
+        memRecords.addRecord(history.location, location, action);
+        updateState({
+          action: action,
+          location: location
+        });
+      } else {
+        updateState(undefined);
+      }
+    });
+  }
+  function replace(to, state) {
+    warning(state !== undefined, 'Hash history does not support state, it will be ignored');
+    var action = Action.replace;
+    var location = createLocation(history.location, to, undefined, '');
+    transitionManager.confirmJumpTo(location, action, getUserConfirmation, function (isJump) {
+      if (!isJump) {
+        return;
+      }
+      var path = createPath(location);
+      var encodedPath = pathEncoder(basename + path);
+      if (getHashContent(window.location.href) !== encodedPath) {
+        ignorePath = path;
+        window.location.replace(stripHash(window.location.href) + '#' + encodedPath);
+      }
+      memRecords.addRecord(history.location, location, action);
+      updateState({
+        action: action,
+        location: location
+      });
+    });
+  }
+  function handleHashChange() {
+    var hashPath = getHashContent(window.location.href);
+    var encodedPath = pathEncoder(hashPath);
+    if (hashPath !== encodedPath) {
+      window.location.replace(stripHash(window.location.href) + '#' + encodedPath);
+    } else {
+      var location = getLocation();
+      var prevLocation = history.location;
+      if (!forceNextPop && isLocationEqual(location, prevLocation)) {
+        return;
+      }
+      if (ignorePath === createPath(location)) {
+        return;
+      }
+      ignorePath = null;
+      handlePopState(location);
+    }
+  }
+  function handlePopState(location) {
+    if (forceNextPop) {
+      forceNextPop = false;
+      updateState(undefined);
+    } else {
+      var action = Action.pop;
+      var callback = function (isJump) {
+        if (isJump) {
+          updateState({
+            action: action,
+            location: location
+          });
+        } else {
+          revertPopState(location);
+        }
+      };
+      transitionManager.confirmJumpTo(location, action, getUserConfirmation, callback);
+    }
+  }
+
+  // 在跳转行为被Block后，用History.go()跳转回之前的页面
+  function revertPopState(form) {
+    var to = history.location;
+    var delta = memRecords.getDelta(to, form);
+    if (delta !== 0) {
+      go(delta);
+      forceNextPop = true;
+    }
+  }
+  var listenerCount = 0;
+  function setListener(delta) {
+    listenerCount += delta;
+    if (listenerCount === 1 && delta === 1) {
+      window.addEventListener(EventType.HashChange, handleHashChange);
+    } else if (listenerCount === 0) {
+      window.removeEventListener(EventType.HashChange, handleHashChange);
+    }
+  }
+  return history;
+}
+
+function createNamedContext(name, defaultValue) {
+  var context = createContext(defaultValue);
+  context.displayName = name;
+  return context;
+}
+var RouterContext = createNamedContext('Router', {});
+
+var TokenType = /*#__PURE__*/function (TokenType) {
+  TokenType["Delimiter"] = "delimiter";
+  TokenType["Static"] = "static";
+  TokenType["Param"] = "param";
+  TokenType["WildCard"] = "wildcard";
+  TokenType["LBracket"] = "(";
+  TokenType["RBracket"] = ")";
+  TokenType["Pattern"] = "pattern";
+  return TokenType;
+}({});
+
+// 解析URL中的动态参数，以实现TypeScript提示功能
+
+/**
+ * @description 将url中的//转换为/
+ */
+function cleanPath(path) {
+  return path.replace(/\/+/g, '/');
+}
+function scoreCompare(score1, score2) {
+  var score1Length = score1.length;
+  var score2Length = score2.length;
+  var end = Math.min(score1Length, score2Length);
+  for (var i = 0; i < end; i++) {
+    var delta = score2[i] - score1[i];
+    if (delta !== 0) {
+      return delta;
+    }
+  }
+  if (score1Length === score2Length) {
+    return 0;
+  }
+  return score1Length > score2Length ? -1 : 1;
+}
+
+// 把正则表达式的特殊符号加两个反斜杠进行转义
+function escapeStr(str) {
+  return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, '\\$1');
+}
+
+var validChar = /[^/:*()]/;
+
+// 对Url模板进行词法解析，解析结果为Tokens
+function lexer(path) {
+  var tokens = [];
+  if (!path) {
+    return tokens;
+  }
+  var urlPath = cleanPath(path);
+  if (urlPath !== '*' && !urlPath.startsWith('/')) {
+    throw new Error("Url must start with \"/\".");
+  }
+  var getLiteral = function () {
+    var name = '';
+    while (i < urlPath.length && validChar.test(urlPath[i])) {
+      name += urlPath[i];
+      skipChar(1);
+    }
+    return name;
+  };
+  var skipChar = function (step) {
+    i += step;
+  };
+  var i = 0;
+  while (i < urlPath.length) {
+    var curChar = urlPath[i];
+    var prevChar = urlPath[i - 1];
+    if (curChar === '/') {
+      tokens.push({
+        type: TokenType.Delimiter,
+        value: urlPath[i]
+      });
+      skipChar(1);
+      continue;
+    }
+    // dynamic params (/:a)
+    if (prevChar === '/' && curChar === ':') {
+      skipChar(1);
+      tokens.push({
+        type: TokenType.Param,
+        value: getLiteral()
+      });
+      continue;
+    }
+    // wildCard params (/:*)
+    if ((prevChar === '/' || prevChar === undefined) && curChar === '*') {
+      tokens.push({
+        type: TokenType.WildCard,
+        value: urlPath[i]
+      });
+      skipChar(1);
+      continue;
+    }
+    // static params
+    if (prevChar === '/' && validChar.test(curChar)) {
+      tokens.push({
+        type: TokenType.Static,
+        value: getLiteral()
+      });
+      continue;
+    }
+    if (curChar === '(') {
+      tokens.push({
+        type: TokenType.LBracket,
+        value: '('
+      });
+      skipChar(1);
+      continue;
+    }
+    if (curChar === ')') {
+      tokens.push({
+        type: TokenType.RBracket,
+        value: ')'
+      });
+      skipChar(1);
+      continue;
+    }
+    if (validChar.test(curChar)) {
+      tokens.push({
+        type: TokenType.Pattern,
+        value: getLiteral()
+      });
+      continue;
+    }
+    // 跳过非法字符
+    skipChar(1);
+  }
+  return tokens;
+}
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function () {}; return { s: F, n: function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function (e) { throw e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function () { it = it.call(o); }, n: function () { var step = it.next(); normalCompletion = step.done; return step; }, e: function (e) { didErr = true; err = e; }, f: function () { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+// 不同类型参数的匹配得分
+var MatchScore = /*#__PURE__*/function (MatchScore) {
+  MatchScore[MatchScore["static"] = 10] = "static";
+  MatchScore[MatchScore["param"] = 6] = "param";
+  MatchScore[MatchScore["wildcard"] = 3] = "wildcard";
+  MatchScore[MatchScore["placeholder"] = -1] = "placeholder";
+  return MatchScore;
+}(MatchScore || {}); // 兼容 react v5 matched类型
+var defaultOption = {
+  // url匹配时是否大小写敏感
+  caseSensitive: true,
+  // 是否严格匹配url结尾的/
+  strictMode: false,
+  // 是否完全精确匹配
+  exact: false
+};
+// 正则表达式中需要转义的字符
+var REGEX_CHARS_RE = /[.+*?^${}()[\]/\\]/g;
+// 用于匹配两个//中的的值
+var BASE_PARAM_PATTERN = '[^/]+';
+var DefaultDelimiter = '/#?';
+function createPathParser(pathname) {
+  var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultOption;
+  var _option$caseSensitive = option.caseSensitive,
+    caseSensitive = _option$caseSensitive === void 0 ? defaultOption.caseSensitive : _option$caseSensitive,
+    _option$strictMode = option.strictMode,
+    strictMode = _option$strictMode === void 0 ? defaultOption.strictMode : _option$strictMode,
+    _option$exact = option.exact,
+    exact = _option$exact === void 0 ? defaultOption.exact : _option$exact;
+  /**
+   * URL匹配整体流程
+   * 1.词法解析，将URL模板解析为Token
+   * 2.使用Token生成正则表达式
+   * 3.利用正则表达式解析URL中参数或填充URL模板
+   */
+  var pattern = '^';
+  var keys = [];
+  var scores = [];
+  var tokens = lexer(pathname);
+  var onlyHasWildCard = tokens.length === 1 && tokens[0].type === TokenType.WildCard;
+  var tokenCount = tokens.length;
+  var lastToken = tokens[tokenCount - 1];
+  for (var tokenIdx = 0; tokenIdx < tokenCount; tokenIdx++) {
+    var token = tokens[tokenIdx];
+    var nextToken = tokens[tokenIdx + 1];
+    switch (token.type) {
+      case TokenType.Delimiter:
+        pattern += '/';
+        break;
+      case TokenType.Static:
+        pattern += token.value.replace(REGEX_CHARS_RE, '\\$&');
+        scores.push(MatchScore.static);
+        break;
+      case TokenType.Param:
+        var paramRegexp = '';
+        if (nextToken && nextToken.type === TokenType.LBracket) {
+          // 跳过当前Token和左括号
+          tokenIdx += 2;
+          while (tokens[tokenIdx].type !== TokenType.RBracket) {
+            paramRegexp += tokens[tokenIdx].value;
+            tokenIdx++;
+          }
+        }
+        pattern += paramRegexp ? "((?:" + paramRegexp + "))" : "(" + BASE_PARAM_PATTERN + ")";
+        keys.push(token.value);
+        scores.push(MatchScore.param);
+        break;
+      case TokenType.WildCard:
+        keys.push(token.value);
+        pattern += "((?:" + BASE_PARAM_PATTERN + ")" + (onlyHasWildCard ? '?' : '') + "(?:/(?:" + BASE_PARAM_PATTERN + "))*)";
+        scores.push(onlyHasWildCard ? MatchScore.wildcard : MatchScore.placeholder);
+        break;
+    }
+  }
+  var isWildCard = lastToken.type === TokenType.WildCard;
+  if (!isWildCard && !exact) {
+    if (!strictMode) {
+      pattern += "(?:[" + escapeStr(DefaultDelimiter) + "](?=$))?";
+    }
+    if (lastToken.type !== TokenType.Delimiter) {
+      pattern += "(?=[" + escapeStr(DefaultDelimiter) + "]|$)";
+    }
+  } else {
+    pattern += strictMode ? '$' : "[" + escapeStr(DefaultDelimiter) + "]?$";
+  }
+  var flag = caseSensitive ? '' : 'i';
+  var regexp = new RegExp(pattern, flag);
+
+  /**
+   * @description 根据给定Pattern解析path
+   */
+  function parse(path) {
+    var reMatch = path.match(regexp);
+    if (!reMatch) {
+      return null;
+    }
+    var matchedPath = reMatch[0];
+    var params = {};
+    var parseScore = Array.from(scores);
+    for (var i = 1; i < reMatch.length; i++) {
+      var param = reMatch[i];
+      var key = keys[i - 1];
+      if (key === '*' && param) {
+        var value = param.split('/');
+        if (!Array.isArray(params['*'])) {
+          params['*'] = value;
+        } else {
+          var _params$;
+          (_params$ = params['*']).push.apply(_params$, value);
+        }
+        // 完成通配符参数解析后将placeholder替换为wildcard参数的分值
+        parseScore.splice.apply(parseScore, [scores.indexOf(MatchScore.placeholder), 1].concat(new Array(value.length).fill(MatchScore.wildcard)));
+      } else {
+        params[key] = param ? param : [];
+      }
+    }
+    var isExact = path === matchedPath;
+    var url = path === '/' && matchedPath === '' ? '/' : matchedPath;
+    return {
+      isExact: isExact,
+      path: pathname,
+      url: url,
+      score: parseScore,
+      params: params
+    };
+  }
+
+  /**
+   * @description 使用给定参数填充pattern，得到目标URL
+   */
+  function compile(params) {
+    var path = '';
+    var _iterator = _createForOfIteratorHelper(tokens),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _token = _step.value;
+        switch (_token.type) {
+          case TokenType.Static:
+            path += _token.value;
+            break;
+          case TokenType.Param:
+            if (!params[_token.value]) {
+              throw new Error('Param is invalid.');
+            }
+            path += params[_token.value];
+            break;
+          case TokenType.WildCard:
+            var wildCard = params['*'];
+            if (wildCard instanceof Array) {
+              path += wildCard.join('/');
+            } else {
+              path += wildCard;
+            }
+            break;
+          case TokenType.Delimiter:
+            path += _token.value;
+            break;
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return path;
+  }
+  return {
+    get regexp() {
+      return regexp;
+    },
+    get keys() {
+      return keys;
+    },
+    compile: compile,
+    parse: parse
+  };
+}
+
+/**
+ * @description 依次使用pathname与pattern进行匹配，根据匹配分数取得分数最高结果
+ */
+function matchPath(pathname, pattern, option) {
+  var patterns = Array.isArray(pattern) ? [].concat(pattern) : [pattern];
+  var matchedResults = [];
+  var _iterator2 = _createForOfIteratorHelper(patterns),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var item = _step2.value;
+      var parser = createPathParser(item, option);
+      var matched = parser.parse(pathname);
+      if (matched) {
+        matchedResults.push(matched);
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return !matchedResults.length ? null : matchedResults.sort(function (a, b) {
+    return scoreCompare(a.score, b.score);
+  })[0];
+}
+function generatePath(path, params) {
+  var parser = createPathParser(path);
+  return parser.compile(params);
+}
+
+function useHistory() {
+  return useContext(RouterContext).history;
+}
+function useLocation() {
+  return useContext(RouterContext).location;
+}
+function useParams() {
+  var match = useContext(RouterContext).match;
+  return match ? match.params : {};
+}
+function useRouteMatch(path) {
+  var pathname = useLocation().pathname;
+  var match = useContext(RouterContext).match;
+  if (path) {
+    return matchPath(pathname, path);
+  }
+  return match;
+}
+
+function Route(props) {
+  var context = useContext(RouterContext);
+  var computed = props.computed,
+    location = props.location,
+    path = props.path;
+  var children = props.children,
+    component = props.component,
+    render = props.render;
+  var match;
+  var routeLocation = location || context.location;
+  if (computed) {
+    match = computed;
+  } else if (path) {
+    match = matchPath(routeLocation.pathname, path);
+  } else {
+    match = context.match;
+  }
+  var newProps = _extends({}, context, {
+    location: routeLocation,
+    match: match
+  });
+  if (Array.isArray(children) && Children.count(children) === 0) {
+    children = null;
+  }
+
+  /**
+   * 按顺序获取需要渲染的组件
+   * 1.children
+   * 2.component
+   * 3.render
+   * 都没有匹配到返回Null
+   */
+  var getChildren = function () {
+    // 如果 match 存在
+    if (newProps.match) {
+      if (children) {
+        if (typeof children === 'function') {
+          return children(newProps);
+        }
+        return children;
+      }
+      if (component) {
+        return createElement(component, newProps);
+      } else if (render) {
+        return render(newProps);
+      } else {
+        return null;
+      }
+    } else {
+      // match为null
+      if (typeof children === 'function') {
+        return children(newProps);
+      }
+      return null;
+    }
+  };
+  return /*#__PURE__*/React.createElement(RouterContext.Provider, {
+    value: newProps
+  }, getChildren());
+}
+
+function Router(props) {
+  var history = props.history,
+    _props$children = props.children,
+    children = _props$children === void 0 ? null : _props$children;
+  var _useState = useState(props.history.location),
+    location = _useState[0],
+    setLocation = _useState[1];
+  var pendingLocation = useRef(null);
+
+  // 在Router加载时就监听history地址变化，以保证在始渲染时重定向能正确触发
+  var unListen = history.listen(function (arg) {
+    pendingLocation.current = arg.location;
+  });
+
+  // 模拟componentDidMount和componentWillUnmount
+  useLayoutEffect(function () {
+    if (unListen) {
+      unListen();
+    }
+    // 监听history中的位置变化
+    unListen = history.listen(function (arg) {
+      setLocation(arg.location);
+    });
+    if (pendingLocation.current) {
+      setLocation(pendingLocation.current);
+    }
+    return function () {
+      if (unListen) {
+        unListen();
+        unListen = null;
+        pendingLocation.current = null;
+      }
+    };
+  }, []);
+  var initContextValue = useMemo(function () {
+    return {
+      history: history,
+      location: location,
+      match: {
+        isExact: location.pathname === '/',
+        params: {},
+        path: '/',
+        score: [],
+        url: '/'
+      }
+    };
+  }, [location]);
+  return /*#__PURE__*/React.createElement(RouterContext.Provider, {
+    value: initContextValue,
+    children: children
+  });
+}
+
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+  return target;
+}
+
+function LifeCycle(props) {
+  // 使用ref保存上一次的props，防止重新渲染
+  var prevProps = useRef(null);
+  var isMount = useRef(false);
+  var onMount = props.onMount,
+    onUpdate = props.onUpdate,
+    onUnmount = props.onUnmount;
+  useLayoutEffect(function () {
+    // 首次挂载 模拟componentDidMount
+    if (!isMount.current) {
+      isMount.current = true;
+      if (onMount) {
+        onMount();
+      }
+    } else {
+      // 不是首次渲染 模拟componentDidUpdate
+      if (onUpdate) {
+        prevProps.current ? onUpdate(prevProps.current) : onUpdate();
+      }
+    }
+    prevProps.current = props;
+  });
+
+  // 模拟componentWillUnmount
+  useLayoutEffect(function () {
+    return function () {
+      if (onUnmount) {
+        onUnmount();
+      }
+    };
+  }, []);
+  return null;
+}
+
+var _excluded$2 = ["state"];
+function Redirect(props) {
+  var to = props.to,
+    _props$push = props.push,
+    push = _props$push === void 0 ? false : _props$push,
+    computed = props.computed;
+  var context = useContext(RouterContext);
+  var history = context.history;
+  var calcLocation = function () {
+    if (computed) {
+      if (typeof to === 'string') {
+        var parser = createPathParser(to);
+        var target = parser.compile(computed.params);
+        return parsePath(target);
+      } else {
+        var pathname = to.pathname ? addHeadSlash(to.pathname) : '/';
+        var _parser = createPathParser(pathname);
+        var _target = _parser.compile(computed.params);
+        return _extends({}, to, {
+          pathname: _target
+        });
+      }
+    }
+    return typeof to === 'string' ? parsePath(to) : to;
+  };
+  var navigate = push ? history.push : history.replace;
+  var _calcLocation = calcLocation(),
+    state = _calcLocation.state,
+    path = _objectWithoutPropertiesLoose(_calcLocation, _excluded$2);
+  var onMountFunc = function () {
+    navigate(path, state);
+  };
+  var onUpdateFunc = function (prevProps) {
+    // 如果当前页面与重定向前页面不一致，执行跳转
+    var prevPath = prevProps === null || prevProps === void 0 ? void 0 : prevProps.data;
+    if (!isLocationEqual(prevPath, path)) {
+      navigate(path, state);
+    }
+  };
+  return /*#__PURE__*/React.createElement(LifeCycle, {
+    onMount: onMountFunc,
+    onUpdate: onUpdateFunc,
+    data: path
+  });
+}
+
+function Switch(props) {
+  var context = useContext(RouterContext);
+  var location = props.location || context.location;
+  var element = null;
+  var match = null;
+
+  // 使用forEach不会给React.ReactNode增加key属性,防止重新渲染
+  Children.forEach(props.children, function (node) {
+    if (match === null && isValidElement(node)) {
+      element = node;
+      var strict;
+      var sensitive;
+      var path;
+      var from;
+
+      // node可能是Route和Redirect
+      if (node.type === Route) {
+        var _props = node.props;
+        strict = _props.strict;
+        sensitive = _props.sensitive;
+        path = _props.path;
+      } else if (node.type === Redirect) {
+        var _props2 = node.props;
+        path = _props2.path;
+        strict = _props2.strict;
+        from = _props2.from;
+      }
+      var exact = node.props.exact;
+      var target = path || from;
+
+      // 更新匹配状态，一旦匹配到停止遍历
+      if (target) {
+        match = matchPath(location.pathname, target, {
+          strictMode: strict,
+          caseSensitive: sensitive,
+          exact: exact
+        });
+      } else {
+        match = context.match;
+      }
+    }
+  });
+  if (match && element) {
+    // 使用cloneElement复制已有组件并更新其Props
+    return cloneElement(element, {
+      location: location,
+      computed: match
+    });
+  }
+  return null;
+}
+
+function Prompt(props) {
+  var context = useContext(RouterContext);
+  var message = props.message,
+    _props$when = props.when,
+    when = _props$when === void 0 ? true : _props$when;
+  if (typeof when === 'function' && when(context.location) === false || !when) {
+    return null;
+  }
+  var navigate = context.history.block;
+  var release = null;
+  var onMountFunc = function () {
+    release = message ? navigate(message) : null;
+  };
+  var onUpdateFunc = function (prevProps) {
+    if (prevProps && prevProps.data !== message) {
+      if (release) {
+        release();
+      }
+      release = message ? navigate(message) : null;
+    }
+  };
+  var onUnmountFunc = function () {
+    if (release) {
+      release();
+    }
+    release = null;
+  };
+  return /*#__PURE__*/React.createElement(LifeCycle, {
+    onMount: onMountFunc,
+    onUpdate: onUpdateFunc,
+    onUnmount: onUnmountFunc,
+    data: message
+  });
+}
+
+function withRouter(Component) {
+  function ComponentWithRouterProp(props) {
+    var _useContext = useContext(RouterContext),
+      history = _useContext.history,
+      location = _useContext.location,
+      match = _useContext.match;
+    var routeProps = {
+      history: history,
+      location: location,
+      match: match
+    };
+    return /*#__PURE__*/React.createElement(Component, _extends({}, props, routeProps));
+  }
+  return ComponentWithRouterProp;
+}
+
+function HashRouter(props) {
+  var historyRef = useRef();
+  if (historyRef.current === null || historyRef.current === undefined) {
+    historyRef.current = createHashHistory({
+      basename: props.basename,
+      getUserConfirmation: props.getUserConfirmation,
+      hashType: props.hashType
+    });
+  }
+  return /*#__PURE__*/React.createElement(Router, {
+    history: historyRef.current
+  }, props.children);
+}
+
+function BrowserRouter(props) {
+  // 使用Ref持有History对象，防止重复渲染
+  var historyRef = useRef();
+  if (historyRef.current === null || historyRef.current === undefined) {
+    historyRef.current = createBrowserHistory({
+      basename: props.basename,
+      forceRefresh: props.forceRefresh,
+      getUserConfirmation: props.getUserConfirmation
+    });
+  }
+  return /*#__PURE__*/React.createElement(Router, {
+    history: historyRef.current
+  }, props.children);
+}
+
+var _excluded$1 = ["to", "replace", "component", "onClick", "target"];
+var isModifiedEvent = function (event) {
+  return event.metaKey || event.altKey || event.ctrlKey || event.shiftKey;
+};
+var checkTarget = function (target) {
+  return !target || target === '_self';
+};
+function Link(props) {
+  var to = props.to,
+    replace = props.replace;
+    props.component;
+    var onClick = props.onClick,
+    target = props.target,
+    other = _objectWithoutPropertiesLoose(props, _excluded$1);
+  var tag = props.tag || 'a';
+  var context = useContext(RouterContext);
+  var history = context.history;
+  var location = typeof to === 'function' ? to(context.location) : to;
+  var state;
+  var path;
+  if (typeof location === 'string') {
+    path = parsePath(location);
+  } else {
+    var pathname = location.pathname,
+      hash = location.hash,
+      search = location.search;
+    path = {
+      pathname: pathname,
+      hash: hash,
+      search: search
+    };
+    state = location.state;
+  }
+  var href = history.createHref(path);
+  var linkClickEvent = function (event) {
+    try {
+      if (onClick) {
+        onClick(event);
+      }
+    } catch (e) {
+      event.preventDefault();
+      throw e;
+    }
+    if (!event.defaultPrevented && event.button === 0 && checkTarget(target) && !isModifiedEvent(event)) {
+      // 不是相同的路径执行push操作，是相同的路径执行replace
+      var isSamePath = createPath(context.location) === createPath(path);
+      var navigate = replace || isSamePath ? history.replace : history.push;
+      event.preventDefault();
+      navigate(path, state);
+    }
+  };
+  var linkProps = _extends({
+    href: href,
+    onClick: linkClickEvent
+  }, other);
+  return React.createElement(tag, linkProps);
+}
+
+var _excluded = ["to", "isActive"];
+function NavLink(props) {
+  var to = props.to,
+    isActive = props.isActive,
+    rest = _objectWithoutPropertiesLoose(props, _excluded);
+  var context = useContext(RouterContext);
+  var toLocation = typeof to === 'function' ? to(context.location) : to;
+  var _ref = typeof toLocation === 'string' ? parsePath(toLocation) : toLocation,
+    path = _ref.pathname;
+  // 把正则表达式的特殊符号加两个反斜杠进行转义
+  var escapedPath = path ? escapeStr(path) : '';
+  var match = escapedPath ? matchPath(context.location.pathname, escapedPath) : null;
+  var isLinkActive = match && isActive ? isActive(match, context.location) : false;
+  var page = 'page';
+  var otherProps = _extends({
+    'aria-current': isLinkActive ? page : false
+  }, rest);
+  return /*#__PURE__*/React.createElement(Link, _extends({
+    to: to
+  }, otherProps));
+}
+
+// 获取redux state中的值
+function getIn(state, path) {
+  if (!state) {
+    return state;
+  }
+  var length = path.length;
+  if (!length) {
+    return undefined;
+  }
+  var res = state;
+  for (var i = 0; i < length && !!res; ++i) {
+    res = res[path[i]];
+  }
+  return res;
+}
+
+// 从store的state中获取Router、Location、Action、Hash等信息
+var stateReader = function (storeType) {
+  var isRouter = function (value) {
+    return value !== null && typeof value === 'object' && !!getIn(value, ['location']) && !!getIn(value, ['action']);
+  };
+  var getRouter = function (state) {
+    var router = getIn(state, ['router']);
+    if (!isRouter(router)) {
+      throw new Error("Could not find router reducer in " + storeType + " store, it must be mounted under \"router\"");
+    }
+    return router;
+  };
+  var getLocation = function (state) {
+    return getIn(getRouter(state), ['location']);
+  };
+  var getAction = function (state) {
+    return getIn(getRouter(state), ['action']);
+  };
+  var getSearch = function (state) {
+    return getIn(getRouter(state), ['location', 'search']);
+  };
+  var getHash = function (state) {
+    return getIn(getRouter(state), ['location', 'hash']);
+  };
+  return {
+    getHash: getHash,
+    getAction: getAction,
+    getSearch: getSearch,
+    getRouter: getRouter,
+    getLocation: getLocation
+  };
+};
+
+var hConnect = reduxAdapter.connect;
+function ConnectedRouterWithoutMemo(props) {
+  var store = props.store,
+    history = props.history,
+    onLocationChanged = props.onLocationChanged,
+    omitRouter = props.omitRouter,
+    children = props.children,
+    storeType = props.storeType;
+  var _stateReader = stateReader(storeType),
+    getLocation = _stateReader.getLocation;
+
+  // 监听store变化
+  var unsubscribe = store.subscribe(function () {
+    // 获取redux State中的location信息
+    var _getLocation = getLocation(store.getState()),
+      pathnameInStore = _getLocation.pathname,
+      searchInStore = _getLocation.search,
+      hashInStore = _getLocation.hash,
+      stateInStore = _getLocation.state;
+
+    // 获取当前history对象中的location信息
+    var _history$location = history.location,
+      pathnameInHistory = _history$location.pathname,
+      searchInHistory = _history$location.search,
+      hashInHistory = _history$location.hash,
+      stateInHistory = _history$location.state;
+
+    // 两个location不一致 执行跳转
+    if (history.action === 'PUSH' && (pathnameInHistory !== pathnameInStore || searchInHistory !== searchInStore || hashInHistory !== hashInStore || stateInHistory !== stateInStore)) {
+      history.push({
+        pathname: pathnameInStore,
+        search: searchInStore,
+        hash: hashInStore
+      }, stateInStore);
+    }
+  });
+  var handleLocationChange = function (args) {
+    var isFirstRendering = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    var location = args.location,
+      action = args.action;
+    onLocationChanged(location, action, isFirstRendering);
+  };
+
+  // 监听history更新
+  var unListen = function () {
+    return history.listen(handleLocationChange);
+  };
+  useLayoutEffect(function () {
+    return function () {
+      unListen();
+      unsubscribe();
+    };
+  }, []);
+  if (!props.noInitialPop) {
+    // 传递初始时位置信息，isFirstRendering设为true防止重复渲染
+    handleLocationChange({
+      location: history.location,
+      action: history.action
+    }, true);
+  }
+  if (omitRouter) {
+    return /*#__PURE__*/React.createElement(React.Fragment, null, children);
+  }
+  var childrenNode;
+  if (typeof children === 'function') {
+    childrenNode = children();
+  } else {
+    childrenNode = children;
+  }
+  return /*#__PURE__*/React.createElement(Router, {
+    history: history
+  }, childrenNode);
+}
+function getConnectedRouter(type) {
+  var mapDispatchToProps = function (dispatch) {
+    return {
+      onLocationChanged: function (location, action, isFirstRendering) {
+        return dispatch(onLocationChanged(location, action, isFirstRendering));
+      }
+    };
+  };
+  var ConnectedRouter = React.memo(ConnectedRouterWithoutMemo);
+  var ConnectedRouterWithContext = function (props) {
+    var Context = props.context || ReactReduxContext;
+    return /*#__PURE__*/React.createElement(Context.Consumer, null, function (_ref) {
+      var store = _ref.store;
+      return /*#__PURE__*/React.createElement(ConnectedRouter, _extends({
+        store: store,
+        storeType: type
+      }, props));
+    });
+  };
+
+  // 针对不同的Store类型，使用对应的connect函数
+  if (type === 'HorizonXCompat') {
+    return hConnect(null, mapDispatchToProps)(ConnectedRouterWithContext);
+  }
+  if (type === 'Redux') {
+    return connect(null, mapDispatchToProps)(ConnectedRouterWithContext);
+  } else {
+    throw new Error('Invalid store type');
+  }
+}
+
+// 定义connect-router对应的redux dispatch函数
+function routerMiddleware(history) {
+  return function (_) {
+    return function (next) {
+      return function (action) {
+        if (action.type !== ActionName.CALL_HISTORY_METHOD) {
+          return next(action);
+        }
+        var _action$payload = action.payload,
+          method = _action$payload.method,
+          args = _action$payload.args;
+        if (method in history) {
+          var _ref;
+          (_ref = history)[method].apply(_ref, args);
+        }
+      };
+    };
+  };
+}
+
+var connectRouter = createConnectRouter();
+
+var ConnectedRouter = getConnectedRouter('Redux');
+var ConnectedHRouter = getConnectedRouter('HorizonXCompat');
+
+export { BrowserRouter, ConnectedHRouter, ConnectedRouter, HashRouter, Link, NavLink, Prompt, Redirect, Route, Router, Switch, RouterContext as __RouterContext, connectRouter, createBrowserHistory, createHashHistory, generatePath, matchPath, routerMiddleware, useHistory, useLocation, useParams, useRouteMatch, withRouter };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"connectRouter.js","sources":["../../../../node_modules/@babel/runtime/helpers/esm/extends.js","../../src/connect-router/actions.ts","../../src/connect-router/reducer.ts","../../src/history/dom.ts","../../src/history/types.ts","../../src/history/utils.ts","../../../../node_modules/@babel/runtime/helpers/esm/classCallCheck.js","../../../../node_modules/@babel/runtime/helpers/esm/typeof.js","../../../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js","../../../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js","../../../../node_modules/@babel/runtime/helpers/esm/createClass.js","../../src/history/transitionManager.ts","../../src/history/waring.ts","../../src/history/baseHistory.ts","../../src/history/browerHistory.ts","../../src/history/hashHistory.ts","../../src/router/context.tsx","../../src/router/matcher/types.ts","../../src/router/matcher/utils.ts","../../src/router/matcher/lexer.ts","../../src/router/matcher/parser.ts","../../src/router/hooks.ts","../../src/router/Route.tsx","../../src/router/Router.tsx","../../../../node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js","../../src/router/lifeCycleHook.ts","../../src/router/Redirect.tsx","../../src/router/Switch.tsx","../../src/router/Prompt.tsx","../../src/router/withRouter.tsx","../../src/router/HashRouter.tsx","../../src/router/BrowserRouter.tsx","../../src/router/Link.tsx","../../src/router/NavLink.tsx","../../src/connect-router/reduxUtils.ts","../../src/connect-router/connectedRouter.tsx","../../src/connect-router/dispatch.ts","../../src/connect-router/index.ts","../../src/router/index2.ts"],"sourcesContent":["export default function _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}","import { Action, Path } from '../history/types';\r\n\r\ntype Location = Partial<Path>\r\n\r\n// 定义位置变化和history方法调用的Action type\r\nexport enum ActionName {\r\n  LOCATION_CHANGE = '$horizon-router/LOCATION_CHANGE',\r\n  CALL_HISTORY_METHOD = '$horizon-router/CALL_HISTORY_METHOD'\r\n}\r\n\r\n// 定义Action的两种数据类型\r\nexport type ActionMessage = {\r\n  type: ActionName.LOCATION_CHANGE\r\n  payload: {\r\n    location: Location,\r\n    action: Action\r\n    isFirstRendering: boolean\r\n  }\r\n} | {\r\n  type: ActionName.CALL_HISTORY_METHOD\r\n  payload: {\r\n    method: string,\r\n    args: any\r\n  }\r\n}\r\n\r\n\r\nexport const onLocationChanged = (location: Location, action: Action, isFirstRendering = false): ActionMessage => {\r\n  return {\r\n    type: ActionName.LOCATION_CHANGE,\r\n    payload: {\r\n      location,\r\n      action,\r\n      isFirstRendering,\r\n    },\r\n  };\r\n};\r\n\r\nconst updateLocation = (method: string): (...args: any) => ActionMessage => {\r\n  return (...args: any) => ({\r\n    type: ActionName.CALL_HISTORY_METHOD,\r\n    payload: {\r\n      method,\r\n      args,\r\n    },\r\n  });\r\n};\r\n\r\nexport const push = updateLocation('push');\r\nexport const replace = updateLocation('replace');\r\nexport const go = updateLocation('go');","import { ActionName } from './actions';\r\nimport { Action, History } from '../history/types';\r\nimport { Location } from '../router';\r\n\r\ntype LocationWithQuery = Partial<Location> & { query?: Record<string, any> };\r\n\r\n// 解析location对象，将其中的query参数解析并注入\r\nfunction injectQueryParams(location?: LocationWithQuery): LocationWithQuery {\r\n  if (location && location.query) {\r\n    return location;\r\n  }\r\n\r\n  const queryString = location && location.search;\r\n\r\n  if (!queryString) {\r\n    return {\r\n      ...location,\r\n      query: {},\r\n    };\r\n  }\r\n  const queryObject: Record<string, any> = {};\r\n\r\n  const params = new URLSearchParams(queryString);\r\n  params.forEach((value, key) => (queryObject[key] = value));\r\n\r\n  return {\r\n    ...location,\r\n    query: queryObject,\r\n  };\r\n}\r\n\r\ntype InitRouterState = {\r\n  location: LocationWithQuery;\r\n  action: Action;\r\n};\r\n\r\ntype Payload = {\r\n  type?: ActionName;\r\n  payload?: any;\r\n};\r\n\r\nexport function createConnectRouter() {\r\n  // 初始化redux State\r\n  return (history: History) => {\r\n    const initRouterState = {\r\n      location: injectQueryParams(history.location),\r\n      action: history.action,\r\n    };\r\n\r\n    // 定义connect-router对应的redux reducer函数\r\n    return (state: InitRouterState = initRouterState, { type, payload }: Payload = {}): any => {\r\n      if (type === ActionName.LOCATION_CHANGE) {\r\n        const { location, action, isFirstRendering } = payload;\r\n        if (isFirstRendering) {\r\n          return state;\r\n        }\r\n        return { ...state, location: injectQueryParams(location), action: action };\r\n      }\r\n      return state;\r\n    };\r\n  };\r\n}\r\n","export function isBrowser(): boolean {\r\n  return typeof window !== 'undefined' && window.document && typeof window.document.createElement === 'function';\r\n}\r\n\r\nexport function getDefaultConfirmation(message: string, callBack: (result: boolean) => void) {\r\n  callBack(window.confirm(message));\r\n}\r\n\r\n// 判断浏览器是否支持pushState方法，pushState是browserHistory实现的基础\r\nexport function isSupportHistory(): boolean {\r\n  return isBrowser() && window.history && 'pushState' in window.history;\r\n}\r\n\r\n// 判断浏览器是否支持PopState事件\r\nexport function isSupportsPopState(): boolean {\r\n  return window.navigator.userAgent.indexOf('Trident') === -1;\r\n}\r\n","export type BaseOption = {\r\n  basename?: string;\r\n  getUserConfirmation?: ConfirmationFunc;\r\n};\r\n\r\nexport interface HistoryProps<T = unknown> {\r\n  readonly action: Action;\r\n\r\n  readonly location: Location<T>;\r\n\r\n  length: number;\r\n}\r\n\r\nexport interface History<T = unknown> extends HistoryProps<T> {\r\n  createHref(path: Partial<Path>): string;\r\n\r\n  push(to: To, state?: T): void;\r\n\r\n  replace(to: To, state?: T): void;\r\n\r\n  listen(listener: Listener<T>): () => void;\r\n\r\n  block(prompt: Prompt<T>): () => void;\r\n\r\n  go(index: number): void;\r\n\r\n  goBack(): void;\r\n\r\n  goForward(): void;\r\n}\r\n\r\nexport enum Action {\r\n  pop = 'POP',\r\n  push = 'PUSH',\r\n  replace = 'REPLACE',\r\n}\r\n\r\nexport enum EventType {\r\n  PopState = 'popstate',\r\n  HashChange = 'hashchange',\r\n}\r\n\r\nexport type Path = {\r\n  pathname: string;\r\n\r\n  search: string;\r\n\r\n  hash: string;\r\n};\r\n\r\nexport type HistoryState<T> = {\r\n  state?: T;\r\n\r\n  key: string;\r\n};\r\n\r\nexport type DefaultStateType = unknown;\r\n\r\nexport type Location<T = unknown> = Path & HistoryState<T>;\r\n\r\nexport type To = string | Partial<Path>;\r\n\r\nexport interface Listener<T = unknown> {\r\n  (navigation: Navigation<T>): void;\r\n}\r\n\r\nexport interface Navigation<T = unknown> {\r\n  action: Action;\r\n\r\n  location: Location<T>;\r\n}\r\n\r\nexport type Prompt<S> = string | boolean | null | ((location: Location<S>, action: Action) => void);\r\n\r\nexport type CallBackFunc = (isJump: boolean) => void;\r\n\r\nexport type ConfirmationFunc = (message: string, callBack: CallBackFunc) => void;\r\n\r\nexport interface TManager<S> {\r\n  setPrompt(next: Prompt<S>): () => void;\r\n\r\n  addListener(func: (navigation: Navigation<S>) => void): () => void;\r\n\r\n  notifyListeners(args: Navigation<S>): void;\r\n\r\n  confirmJumpTo(\r\n    location: Location<S>,\r\n    action: Action,\r\n    userConfirmationFunc: ConfirmationFunc,\r\n    callBack: CallBackFunc,\r\n  ): void;\r\n}\r\n","import { Action, Location, Path, To } from './types';\r\n\r\nexport function createPath(path: Partial<Path>): string {\r\n  const { search, hash } = path;\r\n  let pathname = path.pathname || '/';\r\n  if (search && search !== '?') {\r\n    pathname += search.startsWith('?') ? search : '?' + search;\r\n  }\r\n  if (hash && hash !== '#') {\r\n    pathname += hash.startsWith('#') ? hash : '#' + hash;\r\n  }\r\n  return pathname;\r\n}\r\n\r\nexport function parsePath(url: string): Partial<Path> {\r\n  if (!url) {\r\n    return {};\r\n  }\r\n  let parsedPath: Partial<Path> = {};\r\n\r\n  let hashIdx = url.indexOf('#');\r\n  if (hashIdx > -1) {\r\n    parsedPath.hash = url.substring(hashIdx);\r\n    url = url.substring(0, hashIdx);\r\n  }\r\n\r\n  let searchIdx = url.indexOf('?');\r\n  if (searchIdx > -1) {\r\n    parsedPath.search = url.substring(searchIdx);\r\n    url = url.substring(0, searchIdx);\r\n  }\r\n  if (url) {\r\n    parsedPath.pathname = url;\r\n  }\r\n  return parsedPath;\r\n}\r\n\r\nexport function createLocation<S>(current: string | Location, to: To, state?: S, key?: string): Readonly<Location<S>> {\r\n  let pathname = typeof current === 'string' ? current : current.pathname;\r\n  let urlObj = typeof to === 'string' ? parsePath(to) : to;\r\n  // 随机key长度取6\r\n  const getRandKey = genRandomKey(6);\r\n  const location = {\r\n    pathname: pathname,\r\n    search: '',\r\n    hash: '',\r\n    state: state,\r\n    key: typeof key === 'string' ? key : getRandKey(),\r\n    ...urlObj,\r\n  };\r\n  if (!location.pathname) {\r\n    location.pathname = '/';\r\n  }\r\n  return location;\r\n}\r\n\r\nexport function isLocationEqual(p1: Partial<Path>, p2: Partial<Path>) {\r\n  return p1.pathname === p2.pathname && p1.search === p2.search && p1.hash === p2.hash;\r\n}\r\n\r\nexport function addHeadSlash(path: string): string {\r\n  if (path[0] === '/') {\r\n    return path;\r\n  }\r\n  return '/' + path;\r\n}\r\n\r\nexport function stripHeadSlash(path: string): string {\r\n  if (path[0] === '/') {\r\n    return path.substring(1);\r\n  }\r\n  return path;\r\n}\r\n\r\nexport function normalizeSlash(path: string): string {\r\n  const tempPath = addHeadSlash(path);\r\n  if (tempPath[tempPath.length - 1] === '/') {\r\n    return tempPath.substring(0, tempPath.length - 1);\r\n  }\r\n  return tempPath;\r\n}\r\n\r\nexport function hasBasename(path: string, prefix: string): Boolean {\r\n  return (\r\n    path.toLowerCase().indexOf(prefix.toLowerCase()) === 0 && ['/', '?', '#', ''].includes(path.charAt(prefix.length))\r\n  );\r\n}\r\n\r\nexport function stripBasename(path: string, prefix: string): string {\r\n  return hasBasename(path, prefix) ? path.substring(prefix.length) : path;\r\n}\r\n\r\n// 使用随机生成的Key记录被访问过的URL，当Block被被触发时利用delta值跳转到之前的页面\r\nexport function createMemoryRecord<T, S>(initVal: S, fn: (arg: S) => T) {\r\n  let visitedRecord: T[] = [fn(initVal)];\r\n\r\n  function getDelta(to: S, form: S): number {\r\n    let toIdx = visitedRecord.lastIndexOf(fn(to));\r\n    if (toIdx === -1) {\r\n      toIdx = 0;\r\n    }\r\n    let fromIdx = visitedRecord.lastIndexOf(fn(form));\r\n    if (fromIdx === -1) {\r\n      fromIdx = 0;\r\n    }\r\n    return toIdx - fromIdx;\r\n  }\r\n\r\n  function addRecord(current: S, newRecord: S, action: Action) {\r\n    const curVal = fn(current);\r\n    const NewVal = fn(newRecord);\r\n    if (action === Action.push) {\r\n      const prevIdx = visitedRecord.lastIndexOf(curVal);\r\n      const newVisitedRecord = visitedRecord.slice(0, prevIdx + 1);\r\n      newVisitedRecord.push(NewVal);\r\n      visitedRecord = newVisitedRecord;\r\n    }\r\n    if (action === Action.replace) {\r\n      const prevIdx = visitedRecord.lastIndexOf(curVal);\r\n      if (prevIdx !== -1) {\r\n        visitedRecord[prevIdx] = NewVal;\r\n      }\r\n    }\r\n  }\r\n\r\n  return { getDelta, addRecord };\r\n}\r\n\r\nfunction genRandomKey(length: number): () => string {\r\n  const end = length + 2;\r\n  return () => {\r\n    return Math.random().toString(18).substring(2, end);\r\n  };\r\n}\r\n","export default function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}","export default function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n    return typeof obj;\n  } : function (obj) {\n    return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n  }, _typeof(obj);\n}","import _typeof from \"./typeof.js\";\nexport default function _toPrimitive(input, hint) {\n  if (_typeof(input) !== \"object\" || input === null) return input;\n  var prim = input[Symbol.toPrimitive];\n  if (prim !== undefined) {\n    var res = prim.call(input, hint || \"default\");\n    if (_typeof(res) !== \"object\") return res;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (hint === \"string\" ? String : Number)(input);\n}","import _typeof from \"./typeof.js\";\nimport toPrimitive from \"./toPrimitive.js\";\nexport default function _toPropertyKey(arg) {\n  var key = toPrimitive(arg, \"string\");\n  return _typeof(key) === \"symbol\" ? key : String(key);\n}","import toPropertyKey from \"./toPropertyKey.js\";\nfunction _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, toPropertyKey(descriptor.key), descriptor);\n  }\n}\nexport default function _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  Object.defineProperty(Constructor, \"prototype\", {\n    writable: false\n  });\n  return Constructor;\n}","import { Action, CallBackFunc, ConfirmationFunc, Listener, Location, Navigation, Prompt, TManager } from './types';\r\n\r\nclass TransitionManager<S> implements TManager<S> {\r\n  private prompt: Prompt<S>;\r\n  private listeners: Listener<S>[];\r\n\r\n  constructor() {\r\n    this.prompt = null;\r\n    this.listeners = [];\r\n  }\r\n\r\n  public setPrompt(prompt: Prompt<S>): () => void {\r\n    this.prompt = prompt;\r\n\r\n    // 清除Prompt\r\n    return () => {\r\n      if (this.prompt === prompt) {\r\n        this.prompt = null;\r\n      }\r\n    };\r\n  }\r\n\r\n  // 使用发布订阅模式管理history的监听者\r\n  public addListener(func: Listener<S>): () => void {\r\n    let isActive = true;\r\n    const listener = (args: Navigation<S>) => {\r\n      if (isActive) {\r\n        func(args);\r\n      }\r\n    };\r\n    this.listeners.push(listener);\r\n    return () => {\r\n      isActive = false;\r\n      // 移除对应的监听者\r\n      this.listeners = this.listeners.filter(item => item !== listener);\r\n    };\r\n  }\r\n\r\n  public notifyListeners(args: Navigation<S>) {\r\n    for (const listener of this.listeners) {\r\n      listener(args);\r\n    }\r\n  }\r\n\r\n  public confirmJumpTo(\r\n    location: Location<S>,\r\n    action: Action,\r\n    userConfirmationFunc: ConfirmationFunc,\r\n    callBack: CallBackFunc\r\n  ) {\r\n    if (this.prompt !== null) {\r\n      const result = typeof this.prompt === 'function' ? this.prompt(location, action) : this.prompt;\r\n      if (typeof result === 'string') {\r\n        typeof userConfirmationFunc === 'function' ? userConfirmationFunc(result, callBack) : callBack(true);\r\n      } else {\r\n        callBack(result !== false);\r\n      }\r\n    } else {\r\n      callBack(true);\r\n    }\r\n  }\r\n}\r\n\r\nexport default TransitionManager;\r\n","function warning(condition: any, message: string) {\r\n  if (condition) {\r\n    if (console && typeof console.warn === 'function') {\r\n      console.warn(message);\r\n    }\r\n  }\r\n}\r\n\r\nexport default warning;","import { HistoryProps, Listener, Navigation, Prompt } from './types';\r\nimport transitionManager from './transitionManager';\r\n\r\n// 抽取BrowserHistory和HashHistory中相同的方法\r\nexport function getBaseHistory<S>(\r\n  transitionManager: transitionManager<S>,\r\n  setListener: (delta: number) => void,\r\n  browserHistory: History,\r\n) {\r\n  function go(step: number) {\r\n    browserHistory.go(step);\r\n  }\r\n\r\n  function goBack() {\r\n    browserHistory.go(-1);\r\n  }\r\n\r\n  function goForward() {\r\n    browserHistory.go(1);\r\n  }\r\n\r\n  function listen(listener: Listener<S>): () => void {\r\n    const cancel = transitionManager.addListener(listener);\r\n    setListener(1);\r\n    return () => {\r\n      setListener(-1);\r\n      cancel();\r\n    };\r\n  }\r\n\r\n  let isBlocked = false;\r\n\r\n  function block(prompt: Prompt<S> = false): () => void {\r\n    const unblock = transitionManager.setPrompt(prompt);\r\n    if (!isBlocked) {\r\n      setListener(1);\r\n      isBlocked = true;\r\n    }\r\n    return () => {\r\n      if (isBlocked) {\r\n        isBlocked = false;\r\n        setListener(-1);\r\n      }\r\n      unblock();\r\n    };\r\n  }\r\n\r\n  function getUpdateStateFunc(historyProps: HistoryProps<S>) {\r\n    return function (nextState: Navigation<S> | undefined) {\r\n      if (nextState) {\r\n        Object.assign(historyProps, nextState);\r\n      }\r\n      historyProps.length = browserHistory.length;\r\n      const args = { location: historyProps.location, action: historyProps.action };\r\n      transitionManager.notifyListeners(args);\r\n    };\r\n  }\r\n\r\n  return { go, goBack, goForward, listen, block, getUpdateStateFunc };\r\n}\r\n","import { getDefaultConfirmation, isSupportHistory, isSupportsPopState } from './dom';\r\nimport { Action, BaseOption, DefaultStateType, EventType, History, HistoryState, Location, Path, To } from './types';\r\nimport { normalizeSlash, createMemoryRecord, createPath, createLocation, stripBasename } from './utils';\r\nimport TransitionManager from './transitionManager';\r\n\r\nimport warning from './waring';\r\nimport { getBaseHistory } from './baseHistory';\r\n\r\nexport type BrowserHistoryOption = {\r\n  /**\r\n   * forceRefresh为True时跳转时会强制刷新页面\r\n   */\r\n  forceRefresh?: boolean;\r\n} & BaseOption;\r\n\r\nexport function createBrowserHistory<S = DefaultStateType>(options: BrowserHistoryOption = {}): History<S> {\r\n  const supportHistory = isSupportHistory();\r\n  const isSupportPopState = isSupportsPopState();\r\n  const browserHistory = window.history;\r\n  const { forceRefresh = false, getUserConfirmation = getDefaultConfirmation } = options;\r\n\r\n  const basename = options.basename ? normalizeSlash(options.basename) : '';\r\n\r\n  const initLocation = getLocation(getHistoryState());\r\n\r\n  const recordOperator = createMemoryRecord<string, Location<S>>(initLocation, l => l.key);\r\n\r\n  const transitionManager = new TransitionManager<S>();\r\n\r\n  const { go, goBack, goForward, listen, block, getUpdateStateFunc } = getBaseHistory<S>(\r\n    transitionManager,\r\n    setListener,\r\n    browserHistory,\r\n  );\r\n\r\n  const history: History<S> = {\r\n    action: Action.pop,\r\n    length: browserHistory.length,\r\n    location: initLocation,\r\n    go,\r\n    goBack,\r\n    goForward,\r\n    listen,\r\n    block,\r\n    push,\r\n    replace,\r\n    createHref,\r\n  };\r\n\r\n  const updateState = getUpdateStateFunc(history);\r\n\r\n  function getHistoryState() {\r\n    return supportHistory ? window.history.state : {};\r\n  }\r\n\r\n  function getLocation(historyState: Partial<HistoryState<S>>) {\r\n    const { search, hash } = window.location;\r\n    const { key, state } = historyState || {};\r\n    let pathname = window.location.pathname;\r\n    pathname = basename ? stripBasename(pathname, basename) : pathname;\r\n\r\n    return createLocation<S>('', { pathname, search, hash }, state, key);\r\n  }\r\n\r\n  // 拦截页面POP事件后，防止返回到的页面被重复拦截\r\n  let forceJump = false;\r\n\r\n  function handlePopState(location: Location<S>) {\r\n    if (forceJump) {\r\n      forceJump = false;\r\n      updateState(undefined);\r\n    } else {\r\n      const action = Action.pop;\r\n\r\n      const callback = (isJump: boolean) => {\r\n        if (isJump) {\r\n          // 执行跳转行为\r\n          updateState({ action: action, location: location });\r\n        } else {\r\n          revertPopState(location, history.location);\r\n        }\r\n      };\r\n\r\n      transitionManager.confirmJumpTo(location, action, getUserConfirmation, callback);\r\n    }\r\n  }\r\n\r\n  function popStateListener(event: PopStateEvent) {\r\n    handlePopState(getLocation(event.state));\r\n  }\r\n\r\n  function hashChangeListener() {\r\n    const location = getLocation(getHistoryState());\r\n    handlePopState(location);\r\n  }\r\n\r\n  let listenerCount = 0;\r\n\r\n  function setListener(count: number) {\r\n    listenerCount += count;\r\n    if (listenerCount === 1 && count === 1) {\r\n      window.addEventListener(EventType.PopState, popStateListener);\r\n      if (!isSupportPopState) {\r\n        window.addEventListener(EventType.HashChange, hashChangeListener);\r\n      }\r\n    } else if (listenerCount === 0) {\r\n      window.removeEventListener(EventType.PopState, popStateListener);\r\n      if (!isSupportPopState) {\r\n        window.removeEventListener(EventType.HashChange, hashChangeListener);\r\n      }\r\n    }\r\n  }\r\n\r\n  // 取消页面跳转并恢复到跳转前的页面\r\n  function revertPopState(form: Location<S>, to: Location<S>) {\r\n    const delta = recordOperator.getDelta(to, form);\r\n    if (delta !== 0) {\r\n      go(delta);\r\n      forceJump = true;\r\n    }\r\n  }\r\n\r\n  function createHref(path: Partial<Path>) {\r\n    return basename + createPath(path);\r\n  }\r\n\r\n  function push(to: To, state?: S) {\r\n    const action = Action.push;\r\n    const location = createLocation<S>(history.location, to, state, undefined);\r\n\r\n    transitionManager.confirmJumpTo(location, action, getUserConfirmation, isJump => {\r\n      if (!isJump) {\r\n        return;\r\n      }\r\n      const href = createHref(location);\r\n      const { key, state } = location;\r\n\r\n      if (supportHistory) {\r\n        if (forceRefresh) {\r\n          window.location.href = href;\r\n        } else {\r\n          browserHistory.pushState({ key: key, state: state }, '', href);\r\n          recordOperator.addRecord(history.location, location, action);\r\n          updateState({ action, location });\r\n        }\r\n      } else {\r\n        warning(state !== undefined, 'Browser history cannot push state in browsers that do not support HTML5 history');\r\n        window.location.href = href;\r\n      }\r\n    });\r\n  }\r\n\r\n  function replace(to: To, state?: S) {\r\n    const action = Action.replace;\r\n    const location = createLocation<S>(history.location, to, state, undefined);\r\n\r\n    transitionManager.confirmJumpTo(location, action, getUserConfirmation, isJump => {\r\n      if (!isJump) {\r\n        return;\r\n      }\r\n      const href = createHref(location);\r\n      const { key, state } = location;\r\n      if (supportHistory) {\r\n        if (forceRefresh) {\r\n          window.location.replace(href);\r\n        } else {\r\n          browserHistory.replaceState({ key: key, state: state }, '', href);\r\n          recordOperator.addRecord(history.location, location, action);\r\n          updateState({ action, location });\r\n        }\r\n      } else {\r\n        warning(state !== undefined, 'Browser history cannot push state in browsers that do not support HTML5 history');\r\n        window.location.replace(href);\r\n      }\r\n    });\r\n  }\r\n\r\n  return history;\r\n}\r\n","import { Action, BaseOption, DefaultStateType, EventType, History, Location, To } from './types';\r\nimport {\r\n  addHeadSlash,\r\n  normalizeSlash,\r\n  createMemoryRecord,\r\n  createPath,\r\n  createLocation,\r\n  isLocationEqual,\r\n  stripBasename,\r\n  stripHeadSlash,\r\n} from './utils';\r\nimport { getDefaultConfirmation } from './dom';\r\nimport TransitionManager from './transitionManager';\r\n\r\nimport warning from './waring';\r\nimport { getBaseHistory } from './baseHistory';\r\n\r\nexport type urlHashType = 'slash' | 'noslash';\r\n\r\ntype HashHistoryOption = {\r\n  hashType?: urlHashType;\r\n} & BaseOption;\r\n\r\n// 获取#前的内容\r\nfunction stripHash(path: string): string {\r\n  const idx = path.indexOf('#');\r\n  return idx === -1 ? path : path.substring(0, idx);\r\n}\r\n\r\n// 获取#后的内容\r\nfunction getHashContent(path: string): string {\r\n  const idx = path.indexOf('#');\r\n  return idx === -1 ? '' : path.substring(idx + 1);\r\n}\r\n\r\nexport function createHashHistory<S = DefaultStateType>(option: HashHistoryOption = {}): History<S> {\r\n  const browserHistory = window.history;\r\n  const { hashType = 'slash', getUserConfirmation = getDefaultConfirmation } = option;\r\n\r\n  const basename = option.basename ? normalizeSlash(option.basename) : '';\r\n\r\n  const pathDecoder = addHeadSlash;\r\n  const pathEncoder = hashType === 'slash' ? addHeadSlash : stripHeadSlash;\r\n\r\n  function getLocation() {\r\n    let hashPath = pathDecoder(getHashContent(window.location.hash));\r\n    if (basename) {\r\n      hashPath = stripBasename(hashPath, basename);\r\n    }\r\n\r\n    return createLocation<S>('', hashPath, undefined, 'default');\r\n  }\r\n\r\n  const initLocation = getLocation();\r\n\r\n  const memRecords = createMemoryRecord<string, Location<S>>(initLocation, createPath);\r\n\r\n  const transitionManager = new TransitionManager<S>();\r\n\r\n  function createHref(location: Location<S>) {\r\n    const tag = document.querySelector('base');\r\n    const base = tag && tag.getAttribute('href') ? stripHash(window.location.href) : '';\r\n    return base + '#' + pathEncoder(basename + createPath(location));\r\n  }\r\n\r\n  let forceNextPop = false;\r\n  let ignorePath: null | string = null;\r\n\r\n  const { go, goBack, goForward, listen, block, getUpdateStateFunc } = getBaseHistory(\r\n    transitionManager,\r\n    setListener,\r\n    browserHistory,\r\n  );\r\n\r\n  const history: History<S> = {\r\n    action: Action.pop,\r\n    length: browserHistory.length,\r\n    location: initLocation,\r\n    go,\r\n    goBack,\r\n    goForward,\r\n    push,\r\n    replace,\r\n    listen,\r\n    block,\r\n    createHref,\r\n  };\r\n\r\n  const updateState = getUpdateStateFunc(history);\r\n\r\n  function push(to: To, state?: S) {\r\n    warning(state !== undefined, 'Hash history does not support state, it will be ignored');\r\n\r\n    const action = Action.push;\r\n    const location = createLocation<S>(history.location, to, undefined, '');\r\n\r\n    transitionManager.confirmJumpTo(location, action, getUserConfirmation, isJump => {\r\n      if (!isJump) {\r\n        return;\r\n      }\r\n      const path = createPath(location);\r\n      const encodedPath = pathEncoder(basename + path);\r\n      // 前后hash不一样才进行跳转\r\n      if (getHashContent(window.location.href) !== encodedPath) {\r\n        ignorePath = encodedPath;\r\n        window.location.hash = encodedPath;\r\n\r\n        memRecords.addRecord(history.location, location, action);\r\n\r\n        updateState({ action, location });\r\n      } else {\r\n        updateState(undefined);\r\n      }\r\n    });\r\n  }\r\n\r\n  function replace(to: To, state?: S) {\r\n    warning(state !== undefined, 'Hash history does not support state, it will be ignored');\r\n    const action = Action.replace;\r\n    const location = createLocation<S>(history.location, to, undefined, '');\r\n\r\n    transitionManager.confirmJumpTo(location, action, getUserConfirmation, isJump => {\r\n      if (!isJump) {\r\n        return;\r\n      }\r\n      const path = createPath(location);\r\n      const encodedPath = pathEncoder(basename + path);\r\n      if (getHashContent(window.location.href) !== encodedPath) {\r\n        ignorePath = path;\r\n        window.location.replace(stripHash(window.location.href) + '#' + encodedPath);\r\n      }\r\n      memRecords.addRecord(history.location, location, action);\r\n      updateState({ action, location });\r\n    });\r\n  }\r\n\r\n  function handleHashChange() {\r\n    const hashPath = getHashContent(window.location.href);\r\n    const encodedPath = pathEncoder(hashPath);\r\n    if (hashPath !== encodedPath) {\r\n      window.location.replace(stripHash(window.location.href) + '#' + encodedPath);\r\n    } else {\r\n      const location = getLocation();\r\n      const prevLocation = history.location;\r\n      if (!forceNextPop && isLocationEqual(location, prevLocation)) {\r\n        return;\r\n      }\r\n      if (ignorePath === createPath(location)) {\r\n        return;\r\n      }\r\n      ignorePath = null;\r\n      handlePopState(location);\r\n    }\r\n  }\r\n\r\n  function handlePopState(location: Location<S>) {\r\n    if (forceNextPop) {\r\n      forceNextPop = false;\r\n      updateState(undefined);\r\n    } else {\r\n      const action = Action.pop;\r\n\r\n      const callback = (isJump: boolean) => {\r\n        if (isJump) {\r\n          updateState({ action: action, location: location });\r\n        } else {\r\n          revertPopState(location);\r\n        }\r\n      };\r\n\r\n      transitionManager.confirmJumpTo(location, action, getUserConfirmation, callback);\r\n    }\r\n  }\r\n\r\n  // 在跳转行为被Block后，用History.go()跳转回之前的页面\r\n  function revertPopState(form: Location<S>) {\r\n    const to = history.location;\r\n    const delta = memRecords.getDelta(to, form);\r\n    if (delta !== 0) {\r\n      go(delta);\r\n      forceNextPop = true;\r\n    }\r\n  }\r\n\r\n  let listenerCount = 0;\r\n\r\n  function setListener(delta: number) {\r\n    listenerCount += delta;\r\n    if (listenerCount === 1 && delta === 1) {\r\n      window.addEventListener(EventType.HashChange, handleHashChange);\r\n    } else if (listenerCount === 0) {\r\n      window.removeEventListener(EventType.HashChange, handleHashChange);\r\n    }\r\n  }\r\n\r\n  return history;\r\n}\r\n","import { createContext } from 'react';\r\nimport { History, Location } from './index';\r\nimport { Matched } from './matcher/parser';\r\n\r\nfunction createNamedContext<T>(name: string, defaultValue: T) {\r\n  const context = createContext<T>(defaultValue);\r\n  context.displayName = name;\r\n  return context;\r\n}\r\n\r\nexport type RouterContextValue = {\r\n  history: History;\r\n  location: Location;\r\n  match: Matched | null;\r\n};\r\n\r\nconst RouterContext = createNamedContext<RouterContextValue>('Router', {} as any);\r\n\r\nexport default RouterContext;","import { Matched, Params } from './parser';\r\n\r\nexport type Token = {\r\n  type: TokenType;\r\n  value: string;\r\n};\r\n\r\nexport enum TokenType {\r\n  Delimiter = 'delimiter',\r\n  Static = 'static',\r\n  Param = 'param',\r\n  WildCard = 'wildcard',\r\n  LBracket = '(',\r\n  RBracket = ')',\r\n  Pattern = 'pattern',\r\n}\r\n\r\nexport interface Parser<P> {\r\n  regexp: RegExp;\r\n\r\n  keys: string[];\r\n\r\n  parse(url: string): Matched<P> | null;\r\n\r\n  compile(params: Params<P>): string;\r\n}\r\n\r\nexport type ParserOption = {\r\n  // 是否大小写敏感\r\n  caseSensitive?: boolean;\r\n  // 是否启用严格模式\r\n  strictMode?: boolean;\r\n  // 精准匹配 兼容 React-RouterV5\r\n  exact?: boolean;\r\n};\r\n\r\ntype ClearLeading<U extends string> = U extends `/${infer R}` ? ClearLeading<R> : U;\r\ntype ClearTailing<U extends string> = U extends `${infer L}/` ? ClearTailing<L> : U;\r\n\r\ntype ParseParam<Param extends string> = Param extends `:${infer R}`\r\n  ? {\r\n    [K in R]: string;\r\n  }\r\n  : {};\r\n\r\ntype MergeParams<OneParam extends Record<string, any>, OtherParam extends Record<string, any>> = {\r\n  readonly [Key in keyof OneParam | keyof OtherParam]?: string;\r\n};\r\n\r\ntype ParseURLString<Str extends string> = Str extends `${infer Param}/${infer Rest}`\r\n  ? MergeParams<ParseParam<Param>, ParseURLString<ClearLeading<Rest>>>\r\n  : ParseParam<Str>;\r\n\r\n// 解析URL中的动态参数，以实现TypeScript提示功能\r\nexport type GetURLParams<U extends string> = ParseURLString<ClearLeading<ClearTailing<U>>>;\r\n","/**\r\n * @description 将url中的//转换为/\r\n */\r\nexport function cleanPath(path: string): string {\r\n  return path.replace(/\\/+/g, '/');\r\n}\r\n\r\nexport function scoreCompare(score1: number[], score2: number[]): number {\r\n  const score1Length = score1.length;\r\n  const score2Length = score2.length;\r\n  const end = Math.min(score1Length, score2Length);\r\n  for (let i = 0; i < end; i++) {\r\n    const delta = score2[i] - score1[i];\r\n    if (delta !== 0) {\r\n      return delta;\r\n    }\r\n  }\r\n  if (score1Length === score2Length) {\r\n    return 0;\r\n  }\r\n  return score1Length > score2Length ? -1 : 1;\r\n}\r\n\r\n// 把正则表达式的特殊符号加两个反斜杠进行转义\r\nexport function escapeStr(str: string) {\r\n  return str.replace(/([.+*?=^!:${}()[\\]|/\\\\])/g, '\\\\$1');\r\n}\r\n","import { Token, TokenType } from './types';\r\nimport { cleanPath } from './utils';\r\n\r\nconst validChar = /[^/:*()]/;\r\n\r\n// 对Url模板进行词法解析，解析结果为Tokens\r\nexport function lexer(path: string): Token[] {\r\n  const tokens: Token[] = [];\r\n\r\n  if (!path) {\r\n    return tokens;\r\n  }\r\n\r\n  let urlPath = cleanPath(path);\r\n  if (urlPath !== '*' && !urlPath.startsWith('/')) {\r\n    throw new Error(`Url must start with \"/\".`);\r\n  }\r\n\r\n  const getLiteral = () => {\r\n    let name = '';\r\n    while (i < urlPath.length && validChar.test(urlPath[i])) {\r\n      name += urlPath[i];\r\n      skipChar(1);\r\n    }\r\n    return name;\r\n  };\r\n\r\n  const skipChar = (step: number) => {\r\n    i += step;\r\n  };\r\n\r\n  let i = 0;\r\n  while (i < urlPath.length) {\r\n    const curChar = urlPath[i];\r\n    const prevChar = urlPath[i - 1];\r\n\r\n    if (curChar === '/') {\r\n      tokens.push({ type: TokenType.Delimiter, value: urlPath[i] });\r\n      skipChar(1);\r\n      continue;\r\n    }\r\n    // dynamic params (/:a)\r\n    if (prevChar === '/' && curChar === ':') {\r\n      skipChar(1);\r\n      tokens.push({ type: TokenType.Param, value: getLiteral() });\r\n      continue;\r\n    }\r\n    // wildCard params (/:*)\r\n    if ((prevChar === '/' || prevChar === undefined) && curChar === '*') {\r\n      tokens.push({ type: TokenType.WildCard, value: urlPath[i] });\r\n      skipChar(1);\r\n      continue;\r\n    }\r\n    // static params\r\n    if (prevChar === '/' && validChar.test(curChar)) {\r\n      tokens.push({ type: TokenType.Static, value: getLiteral() });\r\n      continue;\r\n    }\r\n    if (curChar === '(') {\r\n      tokens.push({ type: TokenType.LBracket, value: '(' });\r\n      skipChar(1);\r\n      continue;\r\n    }\r\n    if (curChar === ')') {\r\n      tokens.push({ type: TokenType.RBracket, value: ')' });\r\n      skipChar(1);\r\n      continue;\r\n    }\r\n    if (validChar.test(curChar)) {\r\n      tokens.push({ type: TokenType.Pattern, value: getLiteral() });\r\n      continue;\r\n    }\r\n    // 跳过非法字符\r\n    skipChar(1);\r\n  }\r\n\r\n  return tokens;\r\n}\r\n","import { GetURLParams, Parser, ParserOption, TokenType } from './types';\r\nimport { lexer } from './lexer';\r\nimport { escapeStr, scoreCompare } from './utils';\r\n\r\n// 不同类型参数的匹配得分\r\nenum MatchScore {\r\n  // 固定参数\r\n  static = 10,\r\n  // 动态参数\r\n  param = 6,\r\n  // 通配符参数\r\n  wildcard = 3,\r\n  placeholder = -1,\r\n}\r\n\r\nexport type Params<P> = { [K in keyof P]?: P[K] };\r\n\r\n// 兼容 react v5 matched类型\r\nexport type Matched<P = any> = {\r\n  score: number[];\r\n  params: Params<P>;\r\n  path: string;\r\n  url: string;\r\n  isExact: boolean;\r\n};\r\n\r\nconst defaultOption: Required<ParserOption> = {\r\n  // url匹配时是否大小写敏感\r\n  caseSensitive: true,\r\n  // 是否严格匹配url结尾的/\r\n  strictMode: false,\r\n  // 是否完全精确匹配\r\n  exact: false,\r\n};\r\n// 正则表达式中需要转义的字符\r\nconst REGEX_CHARS_RE = /[.+*?^${}()[\\]/\\\\]/g;\r\n// 用于匹配两个//中的的值\r\nconst BASE_PARAM_PATTERN = '[^/]+';\r\n\r\nconst DefaultDelimiter = '/#?';\r\n\r\nexport function createPathParser<Str extends string>(pathname: Str, option?: ParserOption): Parser<GetURLParams<Str>>;\r\nexport function createPathParser<P = unknown>(pathname: string, option?: ParserOption): Parser<P>;\r\nexport function createPathParser<P = unknown>(pathname: string, option: ParserOption = defaultOption): Parser<P> {\r\n  const {\r\n    caseSensitive = defaultOption.caseSensitive,\r\n    strictMode = defaultOption.strictMode,\r\n    exact = defaultOption.exact,\r\n  } = option;\r\n  /**\r\n   * URL匹配整体流程\r\n   * 1.词法解析，将URL模板解析为Token\r\n   * 2.使用Token生成正则表达式\r\n   * 3.利用正则表达式解析URL中参数或填充URL模板\r\n   */\r\n  let pattern = '^';\r\n  const keys: string[] = [];\r\n  const scores: number[] = [];\r\n\r\n  const tokens = lexer(pathname);\r\n  const onlyHasWildCard = tokens.length === 1 && tokens[0].type === TokenType.WildCard;\r\n  const tokenCount = tokens.length;\r\n  const lastToken = tokens[tokenCount - 1];\r\n\r\n  for (let tokenIdx = 0; tokenIdx < tokenCount; tokenIdx++) {\r\n    const token = tokens[tokenIdx];\r\n    const nextToken = tokens[tokenIdx + 1];\r\n    switch (token.type) {\r\n      case TokenType.Delimiter:\r\n        pattern += '/';\r\n        break;\r\n      case TokenType.Static:\r\n        pattern += token.value.replace(REGEX_CHARS_RE, '\\\\$&');\r\n        scores.push(MatchScore.static);\r\n        break;\r\n      case TokenType.Param:\r\n        let paramRegexp = '';\r\n        if (nextToken && nextToken.type === TokenType.LBracket) {\r\n          // 跳过当前Token和左括号\r\n          tokenIdx += 2;\r\n          while (tokens[tokenIdx].type !== TokenType.RBracket) {\r\n            paramRegexp += tokens[tokenIdx].value;\r\n            tokenIdx++;\r\n          }\r\n        }\r\n        pattern += paramRegexp ? `((?:${paramRegexp}))` : `(${BASE_PARAM_PATTERN})`;\r\n        keys.push(token.value);\r\n        scores.push(MatchScore.param);\r\n        break;\r\n      case TokenType.WildCard:\r\n        keys.push(token.value);\r\n        pattern += `((?:${BASE_PARAM_PATTERN})${onlyHasWildCard ? '?' : ''}(?:/(?:${BASE_PARAM_PATTERN}))*)`;\r\n        scores.push(onlyHasWildCard ? MatchScore.wildcard : MatchScore.placeholder);\r\n        break;\r\n    }\r\n  }\r\n  const isWildCard = lastToken.type === TokenType.WildCard;\r\n\r\n  if (!isWildCard && !exact) {\r\n    if (!strictMode) {\r\n      pattern += `(?:[${escapeStr(DefaultDelimiter)}](?=$))?`;\r\n    }\r\n    if (lastToken.type !== TokenType.Delimiter) {\r\n      pattern += `(?=[${escapeStr(DefaultDelimiter)}]|$)`;\r\n    }\r\n  } else {\r\n    pattern += strictMode ? '$' : `[${escapeStr(DefaultDelimiter)}]?$`;\r\n  }\r\n\r\n  const flag = caseSensitive ? '' : 'i';\r\n  const regexp = new RegExp(pattern, flag);\r\n\r\n  /**\r\n   * @description 根据给定Pattern解析path\r\n   */\r\n  function parse(path: string): Matched<P> | null {\r\n    const reMatch = path.match(regexp);\r\n\r\n    if (!reMatch) {\r\n      return null;\r\n    }\r\n    const matchedPath = reMatch[0];\r\n    let params: Params<P> = {};\r\n    let parseScore: number[] = Array.from(scores);\r\n    for (let i = 1; i < reMatch.length; i++) {\r\n      let param = reMatch[i];\r\n      let key = keys[i - 1];\r\n      if (key === '*' && param) {\r\n        let value = param.split('/');\r\n        if (!Array.isArray(params['*'])) {\r\n          params['*'] = value;\r\n        } else {\r\n          params['*'].push(...value);\r\n        }\r\n        // 完成通配符参数解析后将placeholder替换为wildcard参数的分值\r\n        parseScore.splice(\r\n          scores.indexOf(MatchScore.placeholder),\r\n          1,\r\n          ...new Array(value.length).fill(MatchScore.wildcard),\r\n        );\r\n      } else {\r\n        params[key] = param ? param : [];\r\n      }\r\n    }\r\n\r\n    const isExact = path === matchedPath;\r\n    const url = path === '/' && matchedPath === '' ? '/' : matchedPath;\r\n    return { isExact: isExact, path: pathname, url: url, score: parseScore, params: params };\r\n  }\r\n\r\n  /**\r\n   * @description 使用给定参数填充pattern，得到目标URL\r\n   */\r\n  function compile(params: Params<P>): string {\r\n    let path = '';\r\n    for (const token of tokens) {\r\n      switch (token.type) {\r\n        case TokenType.Static:\r\n          path += token.value;\r\n          break;\r\n        case TokenType.Param:\r\n          if (!params[token.value]) {\r\n            throw new Error('Param is invalid.');\r\n          }\r\n          path += params[token.value];\r\n          break;\r\n        case TokenType.WildCard:\r\n          let wildCard = params['*'];\r\n          if (wildCard instanceof Array) {\r\n            path += wildCard.join('/');\r\n          } else {\r\n            path += wildCard;\r\n          }\r\n          break;\r\n        case TokenType.Delimiter:\r\n          path += token.value;\r\n          break;\r\n      }\r\n    }\r\n    return path;\r\n  }\r\n\r\n  return {\r\n    get regexp() {\r\n      return regexp;\r\n    },\r\n    get keys() {\r\n      return keys;\r\n    },\r\n    compile,\r\n    parse,\r\n  };\r\n}\r\n\r\n/**\r\n * @description 依次使用pathname与pattern进行匹配，根据匹配分数取得分数最高结果\r\n */\r\nexport function matchPath<P = any>(\r\n  pathname: string,\r\n  pattern: string | string[],\r\n  option?: ParserOption,\r\n): Matched<P> | null {\r\n  const patterns = Array.isArray(pattern) ? [...pattern] : [pattern];\r\n  const matchedResults: Matched<P>[] = [];\r\n  for (const item of patterns) {\r\n    const parser = createPathParser(item, option);\r\n    const matched = parser.parse(pathname);\r\n    if (matched) {\r\n      matchedResults.push(matched);\r\n    }\r\n  }\r\n  return !matchedResults.length ? null : matchedResults.sort((a, b) => scoreCompare(a.score, b.score))[0];\r\n}\r\n\r\nexport function generatePath<P = any>(path: string, params: Params<P>) {\r\n  const parser = createPathParser(path);\r\n  return parser.compile(params);\r\n}","import { useContext } from 'react';\r\nimport RouterContext from './context';\r\nimport { Matched, matchPath, Params } from './matcher/parser';\r\nimport { History } from '../history/types';\r\nimport { Location } from './index';\r\n\r\nfunction useHistory<S>(): History<S>;\r\nfunction useHistory() {\r\n  return useContext(RouterContext).history;\r\n}\r\n\r\nfunction useLocation<S>(): Location<S>;\r\nfunction useLocation() {\r\n  return useContext(RouterContext).location;\r\n}\r\n\r\nfunction useParams<P>(): Params<P> | {};\r\nfunction useParams() {\r\n  const match = useContext(RouterContext).match;\r\n  return match ? match.params : {};\r\n}\r\n\r\nfunction useRouteMatch<P>(path?: string): Matched<P> | null;\r\nfunction useRouteMatch(path?: string) {\r\n  const pathname = useLocation().pathname;\r\n  const match = useContext(RouterContext).match;\r\n  if (path) {\r\n    return matchPath(pathname, path);\r\n  }\r\n  return match;\r\n}\r\n\r\nexport { useHistory, useLocation, useParams, useRouteMatch };\r\n","import * as React from 'react';\r\nimport { History, Location } from './index';\r\nimport { Matched, matchPath } from './matcher/parser';\r\nimport { useContext, Children, createElement } from 'react';\r\nimport RouterContext from './context';\r\nimport { GetURLParams } from './matcher/types';\r\n\r\nexport type RouteComponentProps<P extends Record<string, any> = {}, S = unknown> = RouteChildrenProps<P, S>;\r\n\r\nexport type RouteChildrenProps<P extends Record<string, any> = {}, S = unknown> = {\r\n  history: History<S>;\r\n  location: Location<S>;\r\n  match: Matched<P> | null\r\n}\r\n\r\nexport type RouteProps<P extends Record<string, any> = {}, Path extends string = string> = {\r\n  location?: Location;\r\n  component?: React.ComponentType<RouteComponentProps<P>> | React.ComponentType<any> | undefined;\r\n  children?: ((props: RouteChildrenProps<P>) => React.ReactNode) | React.ReactNode;\r\n  render?: (props: RouteComponentProps<P>) => React.ReactNode;\r\n  path?: Path | Path[];\r\n  exact?: boolean;\r\n  sensitive?: boolean;\r\n  strict?: boolean;\r\n  computed?: Matched<P>;\r\n};\r\n\r\nfunction Route<Path extends string, P extends Record<string, any> = GetURLParams<Path>>(props: RouteProps<P, Path>) {\r\n  const context = useContext(RouterContext);\r\n\r\n  const { computed, location, path } = props;\r\n  let { children, component, render } = props;\r\n  let match: Matched<P> | null;\r\n\r\n  const routeLocation = location || context.location;\r\n  if (computed) {\r\n    match = computed;\r\n  } else if (path) {\r\n    match = matchPath<P>(routeLocation.pathname, path);\r\n  } else {\r\n    match = context.match;\r\n  }\r\n  const newProps = { ...context, location: routeLocation, match: match };\r\n\r\n  if (Array.isArray(children) && Children.count(children) === 0) {\r\n    children = null;\r\n  }\r\n\r\n  /**\r\n   * 按顺序获取需要渲染的组件\r\n   * 1.children\r\n   * 2.component\r\n   * 3.render\r\n   * 都没有匹配到返回Null\r\n   */\r\n  const getChildren = (): React.ReactNode | null => {\r\n    // 如果 match 存在\r\n    if (newProps.match) {\r\n      if (children) {\r\n        if (typeof children === 'function') {\r\n          return children(newProps);\r\n        }\r\n        return children;\r\n      }\r\n\r\n      if (component) {\r\n        return createElement(component, newProps);\r\n      } else if (render) {\r\n        return render(newProps);\r\n      } else {\r\n        return null;\r\n      }\r\n    } else {\r\n      // match为null\r\n      if (typeof children === 'function') {\r\n        return children(newProps);\r\n      }\r\n      return null;\r\n    }\r\n  };\r\n\r\n  return <RouterContext.Provider value={newProps}>{getChildren()}</RouterContext.Provider>;\r\n}\r\n\r\nexport default Route;\r\n","import * as React from 'react';\r\nimport { useLayoutEffect, useMemo, useRef, useState } from 'react';\r\n\r\nimport { History, Location } from '../history/types';\r\n\r\nimport RouterContext, { RouterContextValue } from './context';\r\n\r\nexport type RouterProps = {\r\n  history: History;\r\n  children?: React.ReactNode;\r\n};\r\n\r\nfunction Router<P extends RouterProps>(props: P) {\r\n  const { history, children = null } = props;\r\n  const [location, setLocation] = useState(props.history.location);\r\n  const pendingLocation = useRef<Location | null>(null);\r\n\r\n  // 在Router加载时就监听history地址变化，以保证在始渲染时重定向能正确触发\r\n  let unListen: null | (() => void) = history.listen(arg => {\r\n    pendingLocation.current = arg.location;\r\n  });\r\n\r\n  // 模拟componentDidMount和componentWillUnmount\r\n  useLayoutEffect(() => {\r\n    if (unListen) {\r\n      unListen();\r\n    }\r\n    // 监听history中的位置变化\r\n    unListen = history.listen(arg => {\r\n      setLocation(arg.location);\r\n    });\r\n\r\n    if (pendingLocation.current) {\r\n      setLocation(pendingLocation.current);\r\n    }\r\n\r\n    return () => {\r\n      if (unListen) {\r\n        unListen();\r\n        unListen = null;\r\n        pendingLocation.current = null;\r\n      }\r\n    };\r\n  }, []);\r\n\r\n  const initContextValue: RouterContextValue = useMemo(\r\n    () => ({\r\n      history: history,\r\n      location: location,\r\n      match: { isExact: location.pathname === '/', params: {}, path: '/', score: [], url: '/' },\r\n    }),\r\n    [location],\r\n  );\r\n\r\n  return <RouterContext.Provider value={initContextValue} children={children} />;\r\n}\r\n\r\nexport default Router;\r\n","export default function _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n  return target;\n}","import { useLayoutEffect, useRef } from 'react';\r\n\r\nexport type LifeCycleProps = {\r\n  onMount?: () => void;\r\n  onUpdate?: (prevProps?: LifeCycleProps) => void;\r\n  onUnmount?: () => void;\r\n  data?: any;\r\n};\r\n\r\nexport function LifeCycle(props: LifeCycleProps) {\r\n  // 使用ref保存上一次的props，防止重新渲染\r\n  const prevProps = useRef<LifeCycleProps | null>(null);\r\n  const isMount = useRef(false);\r\n\r\n  const { onMount, onUpdate, onUnmount } = props;\r\n\r\n  useLayoutEffect(() => {\r\n    // 首次挂载 模拟componentDidMount\r\n    if (!isMount.current) {\r\n      isMount.current = true;\r\n      if (onMount) {\r\n        onMount();\r\n      }\r\n    } else {\r\n      // 不是首次渲染 模拟componentDidUpdate\r\n      if (onUpdate) {\r\n        prevProps.current ? onUpdate(prevProps.current) : onUpdate();\r\n      }\r\n    }\r\n    prevProps.current = props;\r\n  });\r\n\r\n  // 模拟componentWillUnmount\r\n  useLayoutEffect(() => {\r\n    return () => {\r\n      if (onUnmount) {\r\n        onUnmount();\r\n      }\r\n    };\r\n  }, []);\r\n\r\n  return null;\r\n}\r\n","import * as React from 'react';\r\nimport { useContext } from 'react';\r\nimport RouterContext from './context';\r\nimport { LifeCycle, LifeCycleProps } from './lifeCycleHook';\r\nimport { Matched, createPathParser } from './matcher/parser';\r\nimport { addHeadSlash, isLocationEqual, parsePath } from '../history/utils';\r\nimport { Location } from './index';\r\n\r\nexport type RedirectProps = {\r\n  to: string | Partial<Location>;\r\n  push?: boolean;\r\n  path?: string;\r\n  from?: string;\r\n  exact?: boolean;\r\n  strict?: boolean;\r\n\r\n  // 由Switch计算得到\r\n  readonly computed?: Matched | null;\r\n};\r\n\r\nfunction Redirect<P extends RedirectProps>(props: P) {\r\n  const { to, push = false, computed } = props;\r\n\r\n  const context = useContext(RouterContext);\r\n  const { history } = context;\r\n\r\n  const calcLocation = (): Partial<Location> => {\r\n    if (computed) {\r\n      if (typeof to === 'string') {\r\n        const parser = createPathParser(to);\r\n        const target = parser.compile(computed.params);\r\n        return parsePath(target);\r\n      } else {\r\n        const pathname = to.pathname ? addHeadSlash(to.pathname) : '/';\r\n        const parser = createPathParser(pathname);\r\n        const target = parser.compile(computed.params);\r\n        return { ...to, pathname: target };\r\n      }\r\n    }\r\n    return typeof to === 'string' ? parsePath(to) : to;\r\n  };\r\n\r\n  const navigate = push ? history.push : history.replace;\r\n  const { state, ...path } = calcLocation();\r\n\r\n  const onMountFunc = () => {\r\n    navigate(path, state);\r\n  };\r\n\r\n  const onUpdateFunc = (prevProps?: LifeCycleProps) => {\r\n    // 如果当前页面与重定向前页面不一致，执行跳转\r\n    const prevPath = prevProps?.data as Location;\r\n    if (!isLocationEqual(prevPath, path)) {\r\n      navigate(path, state);\r\n    }\r\n  };\r\n\r\n  return <LifeCycle onMount={onMountFunc} onUpdate={onUpdateFunc} data={path} />;\r\n}\r\n\r\nexport default Redirect;\r\n","import * as React from 'react';\r\nimport { useContext, Children, isValidElement, cloneElement } from 'react';\r\n\r\nimport { Location } from './index';\r\nimport RouterContext from './context';\r\nimport { Matched, matchPath } from './matcher/parser';\r\nimport Route, { RouteProps } from './Route';\r\nimport Redirect, { RedirectProps } from './Redirect';\r\n\r\nexport type SwitchProps = {\r\n  location?: Location;\r\n  children?: React.ReactNode;\r\n};\r\n\r\nfunction Switch<P extends SwitchProps>(props: P): React.ReactElement | null {\r\n  const context = useContext(RouterContext);\r\n  const location = props.location || context.location;\r\n\r\n  let element: React.ReactElement | null = null;\r\n  let match: Matched | null = null;\r\n\r\n  // 使用forEach不会给React.ReactNode增加key属性,防止重新渲染\r\n  Children.forEach(props.children, node => {\r\n    if (match === null && isValidElement(node)) {\r\n      element = node;\r\n\r\n      let strict: boolean | undefined;\r\n      let sensitive: boolean | undefined;\r\n      let path: string | string[] | undefined;\r\n      let from: string | undefined;\r\n\r\n      // node可能是Route和Redirect\r\n      if (node.type === Route) {\r\n        const props = node.props as RouteProps;\r\n        strict = props.strict;\r\n        sensitive = props.sensitive;\r\n        path = props.path;\r\n      } else if (node.type === Redirect) {\r\n        const props = node.props as RedirectProps;\r\n        path = props.path;\r\n        strict = props.strict;\r\n        from = props.from;\r\n      }\r\n\r\n      const exact = node.props.exact;\r\n      const target = path || from;\r\n\r\n      // 更新匹配状态，一旦匹配到停止遍历\r\n      if (target) {\r\n        match = matchPath(location.pathname, target, {\r\n          strictMode: strict,\r\n          caseSensitive: sensitive,\r\n          exact: exact,\r\n        });\r\n      } else {\r\n        match = context.match;\r\n      }\r\n    }\r\n  });\r\n\r\n  if (match && element) {\r\n    // 使用cloneElement复制已有组件并更新其Props\r\n    return cloneElement(element, { location: location, computed: match });\r\n  }\r\n  return null;\r\n}\r\n\r\nexport default Switch;\r\n","import * as React from 'react';\r\nimport { useContext } from 'react';\r\nimport { LifeCycle, LifeCycleProps } from './lifeCycleHook';\r\nimport { Location } from './index';\r\nimport { Action } from '../history/types';\r\nimport RouterContext from './context';\r\n\r\ntype PromptProps = {\r\n  message?: string | ((location: Partial<Location>, action: Action) => void);\r\n  when?: boolean | ((location: Partial<Location>) => boolean);\r\n};\r\n\r\nfunction Prompt<P extends PromptProps>(props: P) {\r\n  const context = useContext(RouterContext);\r\n\r\n  const { message, when = true } = props;\r\n\r\n  if ((typeof when === 'function' && when(context.location) === false) || !when) {\r\n    return null;\r\n  }\r\n\r\n  const navigate = context.history.block;\r\n\r\n  let release: (() => void) | null = null;\r\n\r\n  const onMountFunc = () => {\r\n    release = message ? navigate(message) : null;\r\n  };\r\n\r\n  const onUpdateFunc = (prevProps?: LifeCycleProps) => {\r\n    if (prevProps && prevProps.data !== message) {\r\n      if (release) {\r\n        release();\r\n      }\r\n      release = message ? navigate(message) : null;\r\n    }\r\n  };\r\n\r\n  const onUnmountFunc = () => {\r\n    if (release) {\r\n      release();\r\n    }\r\n    release = null;\r\n  };\r\n\r\n  return <LifeCycle onMount={onMountFunc} onUpdate={onUpdateFunc} onUnmount={onUnmountFunc} data={message} />;\r\n}\r\n\r\nexport default Prompt;\r\n","import * as React from 'react';\r\nimport { useContext } from 'react';\r\nimport RouterContext from './context';\r\n\r\nfunction withRouter<C extends React.ComponentType>(Component: C) {\r\n\r\n  function ComponentWithRouterProp(props: any) {\r\n    const { history, location, match } = useContext(RouterContext);\r\n    const routeProps = { history: history, location: location, match: match };\r\n\r\n    return <Component {...props} {...routeProps} />;\r\n  }\r\n\r\n  return ComponentWithRouterProp;\r\n}\r\n\r\nexport default withRouter;","import * as React from 'react';\r\nimport { useRef } from 'react';\r\nimport { History } from '../history/types';\r\nimport { BaseRouterProps } from './BrowserRouter';\r\nimport { createHashHistory, urlHashType } from '../history/hashHistory';\r\nimport Router from './Router';\r\n\r\nexport type HashRouterProps = BaseRouterProps & {\r\n  hashType: urlHashType;\r\n};\r\n\r\nfunction HashRouter<P extends Partial<HashRouterProps>>(props: P) {\r\n  let historyRef = useRef<History>();\r\n  if (historyRef.current === null || historyRef.current === undefined) {\r\n    historyRef.current = createHashHistory({\r\n      basename: props.basename,\r\n      getUserConfirmation: props.getUserConfirmation,\r\n      hashType: props.hashType,\r\n    });\r\n  }\r\n\r\n  return <Router history={historyRef.current}>{props.children}</Router>;\r\n}\r\n\r\nexport default HashRouter;","import * as React from 'react';\r\nimport { useRef, ReactNode } from 'react';\r\nimport Router from './Router';\r\nimport { createBrowserHistory } from '../history/browerHistory';\r\nimport { ConfirmationFunc, History } from '../history/types';\r\n\r\nexport type BaseRouterProps = {\r\n  basename: string;\r\n  getUserConfirmation: ConfirmationFunc;\r\n  children?: ReactNode;\r\n};\r\n\r\nexport type BrowserRouterProps = BaseRouterProps & {\r\n  forceRefresh: boolean;\r\n};\r\n\r\nfunction BrowserRouter<P extends Partial<BrowserRouterProps>>(props: P) {\r\n  // 使用Ref持有History对象，防止重复渲染\r\n  let historyRef = useRef<History>();\r\n\r\n  if (historyRef.current === null || historyRef.current === undefined) {\r\n    historyRef.current = createBrowserHistory({\r\n      basename: props.basename,\r\n      forceRefresh: props.forceRefresh,\r\n      getUserConfirmation: props.getUserConfirmation,\r\n    });\r\n  }\r\n\r\n  return <Router history={historyRef.current}>{props.children}</Router>;\r\n}\r\n\r\nexport default BrowserRouter;","import * as React from 'react';\r\nimport { useContext } from 'react';\r\nimport RouterContext from './context';\r\nimport { Location } from './index';\r\nimport { createPath, parsePath } from '../history/utils';\r\nimport { Path } from '../history/types';\r\n\r\nexport type LinkProps = {\r\n  component?: React.ComponentType<any>;\r\n  to: Partial<Location> | string | ((location: Location) => string | Partial<Location>);\r\n  replace?: boolean;\r\n  tag?: string;\r\n  /**\r\n   * @deprecated\r\n   * React16以后不再需要该属性\r\n   **/\r\n  innerRef?: React.Ref<HTMLAnchorElement>;\r\n} & React.AnchorHTMLAttributes<HTMLAnchorElement>;\r\n\r\nconst isModifiedEvent = (event: React.MouseEvent) => {\r\n  return event.metaKey || event.altKey || event.ctrlKey || event.shiftKey;\r\n};\r\n\r\nconst checkTarget = (target?: React.HTMLAttributeAnchorTarget) => {\r\n  return !target || target === '_self';\r\n};\r\n\r\n\r\nfunction Link<P extends LinkProps>(props: P) {\r\n  const { to, replace, component, onClick, target, ...other } = props;\r\n\r\n  const tag = props.tag || 'a';\r\n\r\n  const context = useContext(RouterContext);\r\n  const history = context.history;\r\n\r\n  let location = typeof to === 'function' ? to(context.location) : to;\r\n\r\n  let state: any;\r\n  let path: Partial<Path>;\r\n  if (typeof location === 'string') {\r\n    path = parsePath(location);\r\n  } else {\r\n    const { pathname, hash, search } = location;\r\n    path = { pathname, hash, search };\r\n    state = location.state;\r\n  }\r\n  const href = history.createHref(path);\r\n\r\n  const linkClickEvent = (event: React.MouseEvent<HTMLAnchorElement>) => {\r\n    try {\r\n      if (onClick) {\r\n        onClick(event);\r\n      }\r\n    } catch (e) {\r\n      event.preventDefault();\r\n      throw e;\r\n    }\r\n\r\n    if (!event.defaultPrevented && event.button === 0 && checkTarget(target) && !isModifiedEvent(event)) {\r\n      // 不是相同的路径执行push操作，是相同的路径执行replace\r\n      const isSamePath = createPath(context.location) === createPath(path);\r\n      const navigate = replace || isSamePath ? history.replace : history.push;\r\n      event.preventDefault();\r\n      navigate(path, state);\r\n    }\r\n  };\r\n\r\n  const linkProps = { href: href, onClick: linkClickEvent, ...other };\r\n  return React.createElement(tag, linkProps);\r\n}\r\n\r\nexport default Link;","import * as React from 'react';\r\nimport { useContext } from 'react';\r\nimport type { LinkProps } from './Link';\r\nimport Link from './Link';\r\nimport { Location, matchPath } from './index';\r\nimport { Matched } from './matcher/parser';\r\nimport Context from './context';\r\nimport { parsePath } from '../history/utils';\r\nimport { escapeStr } from './matcher/utils';\r\n\r\ntype NavLinkProps = {\r\n  to: Partial<Location> | string | ((location: Location) => string | Partial<Location>);\r\n  isActive?: (match: Matched | null, location: Location) => boolean;\r\n  // compat react-router NavLink props type\r\n  [key: string]: any;\r\n} & LinkProps;\r\n\r\ntype Page = 'page';\r\n\r\nfunction NavLink<P extends NavLinkProps>(props: P) {\r\n  const { to, isActive, ...rest } = props;\r\n  const context = useContext(Context);\r\n\r\n  const toLocation = typeof to === 'function' ? to(context.location) : to;\r\n\r\n  const { pathname: path } = typeof toLocation === 'string' ? parsePath(toLocation) : toLocation;\r\n  // 把正则表达式的特殊符号加两个反斜杠进行转义\r\n  const escapedPath = path ? escapeStr(path) : '';\r\n  const match = escapedPath ? matchPath(context.location.pathname, escapedPath) : null;\r\n\r\n  const isLinkActive = match && isActive ? isActive(match, context.location) : false;\r\n\r\n  const page: Page = 'page';\r\n  const otherProps = {\r\n    'aria-current': isLinkActive ? page : false,\r\n    ...rest,\r\n  };\r\n\r\n  return <Link to={to} {...otherProps} />;\r\n}\r\n\r\nexport default NavLink;\r\n","import { Location } from '../router';\r\nimport { Action } from '../history/types';\r\n\r\n// 获取redux state中的值\r\nexport function getIn(state: Record<string, any>, path: string[]): any {\r\n  if (!state) {\r\n    return state;\r\n  }\r\n  const length = path.length;\r\n  if (!length) {\r\n    return undefined;\r\n  }\r\n  let res = state;\r\n  for (let i = 0; i < length && !!res; ++i) {\r\n    res = res[path[i]];\r\n  }\r\n  return res;\r\n}\r\n\r\n// 从store的state中获取Router、Location、Action、Hash等信息\r\nconst stateReader = (storeType: string) => {\r\n  const isRouter = (value: unknown) => {\r\n    return value !== null && typeof value === 'object' && !!getIn(value, ['location']) && !!getIn(value, ['action']);\r\n  };\r\n\r\n  const getRouter = (state: any) => {\r\n    const router = getIn(state, ['router']);\r\n    if (!isRouter(router)) {\r\n      throw new Error(`Could not find router reducer in ${storeType} store, it must be mounted under \"router\"`);\r\n    }\r\n    return router!;\r\n  };\r\n\r\n  const getLocation = <S>(state: any): Partial<Location<S>> => getIn(getRouter(state), ['location']);\r\n  const getAction = (state: any): Action => getIn(getRouter(state), ['action']);\r\n  const getSearch = (state: any): string => getIn(getRouter(state), ['location', 'search']);\r\n  const getHash = (state: any): string => getIn(getRouter(state), ['location', 'hash']);\r\n\r\n  return {\r\n    getHash,\r\n    getAction,\r\n    getSearch,\r\n    getRouter,\r\n    getLocation,\r\n  };\r\n};\r\n\r\nexport default stateReader","import * as React from 'react';\r\nimport { useLayoutEffect } from 'react';\r\nimport { connect, ReactReduxContext } from 'react-redux';\r\nimport { Store } from 'redux';\r\nimport { reduxAdapter } from '@cloudsop/horizon';\r\nimport { History, Location, Router } from '../router';\r\nimport { Action, DefaultStateType, Navigation } from '../history/types';\r\nimport { ActionMessage, onLocationChanged } from './actions';\r\nimport stateReader from './reduxUtils';\r\n\r\ntype StoreType = 'HorizonXCompat' | 'Redux';\r\n\r\ntype ConnectedRouter<S> = {\r\n  store: Store;\r\n  history: History<S>;\r\n  basename: string;\r\n  children?: (() => React.ReactNode) | React.ReactNode;\r\n  onLocationChanged: (location: Location<S>, action: Action, isFirstRendering: boolean) => ActionMessage;\r\n  noInitialPop: boolean;\r\n  omitRouter: boolean;\r\n  storeType: StoreType;\r\n};\r\n\r\nconst { connect: hConnect } = reduxAdapter;\r\n\r\nfunction ConnectedRouterWithoutMemo<S>(props: ConnectedRouter<S>) {\r\n  const { store, history, onLocationChanged, omitRouter, children, storeType } = props;\r\n  const { getLocation } = stateReader(storeType);\r\n\r\n  // 监听store变化\r\n  const unsubscribe = store.subscribe(() => {\r\n    // 获取redux State中的location信息\r\n    const {\r\n      pathname: pathnameInStore,\r\n      search: searchInStore,\r\n      hash: hashInStore,\r\n      state: stateInStore,\r\n    } = getLocation<S>(store.getState());\r\n\r\n    // 获取当前history对象中的location信息\r\n    const {\r\n      pathname: pathnameInHistory,\r\n      search: searchInHistory,\r\n      hash: hashInHistory,\r\n      state: stateInHistory,\r\n    } = history.location;\r\n\r\n    // 两个location不一致 执行跳转\r\n    if (\r\n      history.action === 'PUSH' &&\r\n      (pathnameInHistory !== pathnameInStore ||\r\n        searchInHistory !== searchInStore ||\r\n        hashInHistory !== hashInStore ||\r\n        stateInHistory !== stateInStore)\r\n    ) {\r\n      history.push(\r\n        {\r\n          pathname: pathnameInStore,\r\n          search: searchInStore,\r\n          hash: hashInStore,\r\n        },\r\n        stateInStore,\r\n      );\r\n    }\r\n  });\r\n\r\n  const handleLocationChange = (args: Navigation<S>, isFirstRendering: boolean = false) => {\r\n    const { location, action } = args;\r\n    onLocationChanged(location, action, isFirstRendering);\r\n  };\r\n\r\n  // 监听history更新\r\n  const unListen = () => history.listen(handleLocationChange);\r\n\r\n  useLayoutEffect(() => {\r\n    return () => {\r\n      unListen();\r\n      unsubscribe();\r\n    };\r\n  }, []);\r\n\r\n  if (!props.noInitialPop) {\r\n    // 传递初始时位置信息，isFirstRendering设为true防止重复渲染\r\n    handleLocationChange({ location: history.location, action: history.action }, true);\r\n  }\r\n\r\n  if (omitRouter) {\r\n    return <>{children}</>;\r\n  }\r\n  let childrenNode: React.ReactNode;\r\n  if (typeof children === 'function') {\r\n    childrenNode = children();\r\n  } else {\r\n    childrenNode = children;\r\n  }\r\n\r\n  return <Router history={history}>{childrenNode}</Router>;\r\n}\r\n\r\nfunction getConnectedRouter<S = DefaultStateType>(type: StoreType) {\r\n  const mapDispatchToProps = (dispatch: any) => ({\r\n    onLocationChanged: (location: Location, action: Action, isFirstRendering: boolean) =>\r\n      dispatch(onLocationChanged(location, action, isFirstRendering)),\r\n  });\r\n  const ConnectedRouter = React.memo(ConnectedRouterWithoutMemo<S>);\r\n\r\n  const ConnectedRouterWithContext = (props: any) => {\r\n    const Context = props.context || ReactReduxContext;\r\n\r\n    return (\r\n      <Context.Consumer>\r\n        {({ store }: any) => <ConnectedRouter store={store} storeType={type} {...props} />}\r\n      </Context.Consumer>\r\n    );\r\n  };\r\n\r\n  // 针对不同的Store类型，使用对应的connect函数\r\n  if (type === 'HorizonXCompat') {\r\n    return hConnect(null, mapDispatchToProps)(ConnectedRouterWithContext);\r\n  }\r\n  if (type === 'Redux') {\r\n    return connect(null, mapDispatchToProps)(ConnectedRouterWithContext);\r\n  } else {\r\n    throw new Error('Invalid store type');\r\n  }\r\n}\r\n\r\nexport { getConnectedRouter };\r\n","import { ActionMessage, ActionName } from './actions';\r\nimport { History } from '../history/types';\r\n\r\n// 定义connect-router对应的redux dispatch函数\r\nexport function routerMiddleware(history: History) {\r\n  return function(_: any) {\r\n    return function(next: any) {\r\n      return function(action: ActionMessage) {\r\n        if (action.type !== ActionName.CALL_HISTORY_METHOD) {\r\n          return next(action);\r\n        }\r\n        const { payload: { method, args } } = action;\r\n        if (method in history) {\r\n          (history as any)[method](...args);\r\n        }\r\n      };\r\n    };\r\n  };\r\n}\r\n","import { createConnectRouter } from './reducer';\r\n\r\nexport { getConnectedRouter } from './connectedRouter';\r\nexport const connectRouter = createConnectRouter();\r\nexport { routerMiddleware } from './dispatch';\r\n","import { Location as HLocation } from '../history/types';\r\nimport { getConnectedRouter } from '../connect-router';\r\n\r\ntype Location<S = unknown> = Omit<HLocation<S>, 'key'>;\r\n\r\n// ============================ history ============================\r\n\r\nexport { Location };\r\nexport type { History } from '../history/types';\r\n\r\nexport { createBrowserHistory } from '../history/browerHistory';\r\nexport { createHashHistory } from '../history/hashHistory';\r\n\r\nexport { default as __RouterContext } from './context';\r\n\r\n// ============================ URL parser ============================\r\n\r\nexport { matchPath, generatePath } from './matcher/parser';\r\n\r\n// ============================ Router Hooks ============================\r\n\r\nexport { useHistory, useLocation, useParams, useRouteMatch } from './hooks';\r\n\r\n// ============================ Router function component ============================\r\n\r\nexport { default as Route } from './Route';\r\nexport { default as Router } from './Router';\r\nexport { default as Switch } from './Switch';\r\nexport { default as Redirect } from './Redirect';\r\nexport { default as Prompt } from './Prompt';\r\nexport { default as withRouter } from './withRouter';\r\nexport { default as HashRouter } from './HashRouter';\r\nexport { default as BrowserRouter } from './BrowserRouter';\r\nexport { default as Link } from './Link';\r\nexport { default as NavLink } from './NavLink';\r\n\r\n// ============================ Router Types ============================\r\n\r\nexport type { RouteComponentProps, RouteChildrenProps, RouteProps } from './Route';\r\n\r\n// ============================ Connect-router ============================\r\n\r\nexport { connectRouter, routerMiddleware } from '../connect-router';\r\nexport const ConnectedRouter = getConnectedRouter('Redux');\r\nexport const ConnectedHRouter = getConnectedRouter('HorizonXCompat');"],"names":["_extends","Object","assign","bind","target","i","arguments","length","source","key","prototype","hasOwnProperty","call","apply","ActionName","onLocationChanged","location","action","isFirstRendering","undefined","type","LOCATION_CHANGE","payload","injectQueryParams","query","queryString","search","queryObject","params","URLSearchParams","forEach","value","createConnectRouter","history","initRouterState","state","_ref","isBrowser","window","document","createElement","getDefaultConfirmation","message","callBack","confirm","isSupportHistory","isSupportsPopState","navigator","userAgent","indexOf","Action","EventType","createPath","path","hash","pathname","startsWith","parsePath","url","parsedPath","hashIdx","substring","searchIdx","createLocation","current","to","urlObj","getRandKey","genRandomKey","isLocationEqual","p1","p2","addHeadSlash","stripHeadSlash","normalizeSlash","tempPath","hasBasename","prefix","toLowerCase","includes","charAt","stripBasename","createMemoryRecord","initVal","fn","visitedRecord","getDelta","form","toIdx","lastIndexOf","fromIdx","addRecord","newRecord","curVal","NewVal","push","prevIdx","newVisitedRecord","slice","replace","end","Math","random","toString","_classCallCheck","instance","Constructor","TypeError","_typeof","obj","Symbol","iterator","constructor","_toPrimitive","input","hint","prim","toPrimitive","res","String","Number","_toPropertyKey","arg","_defineProperties","props","descriptor","enumerable","configurable","writable","defineProperty","toPropertyKey","_createClass","protoProps","staticProps","TransitionManager","prompt","listeners","setPrompt","_this","addListener","func","_this2","isActive","listener","args","filter","item","notifyListeners","_iterator","_createForOfIteratorHelper","_step","s","n","done","err","e","f","confirmJumpTo","userConfirmationFunc","result","warning","condition","console","warn","getBaseHistory","transitionManager","setListener","browserHistory","go","step","goBack","goForward","listen","cancel","isBlocked","block","unblock","getUpdateStateFunc","historyProps","nextState","createBrowserHistory","options","supportHistory","isSupportPopState","_options$forceRefresh","forceRefresh","_options$getUserConfi","getUserConfirmation","basename","initLocation","getLocation","getHistoryState","recordOperator","l","_getBaseHistory","pop","createHref","updateState","historyState","_window$location","forceJump","handlePopState","callback","isJump","revertPopState","popStateListener","event","hashChangeListener","listenerCount","count","addEventListener","PopState","HashChange","removeEventListener","delta","href","pushState","replaceState","stripHash","idx","getHashContent","createHashHistory","option","_option$hashType","hashType","_option$getUserConfir","pathDecoder","pathEncoder","hashPath","memRecords","tag","querySelector","base","getAttribute","forceNextPop","ignorePath","encodedPath","handleHashChange","prevLocation","createNamedContext","name","defaultValue","context","createContext","displayName","RouterContext","TokenType","cleanPath","scoreCompare","score1","score2","score1Length","score2Length","min","escapeStr","str","validChar","lexer","tokens","urlPath","Error","getLiteral","test","skipChar","curChar","prevChar","Delimiter","Param","WildCard","Static","LBracket","RBracket","Pattern","MatchScore","defaultOption","caseSensitive","strictMode","exact","REGEX_CHARS_RE","BASE_PARAM_PATTERN","DefaultDelimiter","createPathParser","_option$caseSensitive","_option$strictMode","_option$exact","pattern","keys","scores","onlyHasWildCard","tokenCount","lastToken","tokenIdx","token","nextToken","static","paramRegexp","param","wildcard","placeholder","isWildCard","flag","regexp","RegExp","parse","reMatch","match","matchedPath","parseScore","Array","from","split","isArray","_params$","splice","concat","fill","isExact","score","compile","wildCard","join","matchPath","patterns","matchedResults","_iterator2","_step2","parser","matched","sort","a","b","generatePath","useHistory","useContext","useLocation","useParams","useRouteMatch","Route","computed","children","component","render","routeLocation","newProps","Children","getChildren","React","Provider","Router","_props$children","_useState","useState","setLocation","pendingLocation","useRef","unListen","useLayoutEffect","initContextValue","useMemo","_objectWithoutPropertiesLoose","excluded","sourceKeys","LifeCycle","prevProps","isMount","onMount","onUpdate","onUnmount","Redirect","_props$push","calcLocation","navigate","_calcLocation","_excluded","onMountFunc","onUpdateFunc","prevPath","data","Switch","element","node","isValidElement","strict","sensitive","cloneElement","Prompt","_props$when","when","release","onUnmountFunc","withRouter","Component","ComponentWithRouterProp","_useContext","routeProps","HashRouter","historyRef","BrowserRouter","isModifiedEvent","metaKey","altKey","ctrlKey","shiftKey","checkTarget","Link","onClick","other","linkClickEvent","preventDefault","defaultPrevented","button","isSamePath","linkProps","NavLink","rest","Context","toLocation","escapedPath","isLinkActive","page","otherProps","getIn","stateReader","storeType","isRouter","getRouter","router","getAction","getSearch","getHash","hConnect","reduxAdapter","connect","ConnectedRouterWithoutMemo","store","omitRouter","_stateReader","unsubscribe","subscribe","_getLocation","getState","pathnameInStore","searchInStore","hashInStore","stateInStore","_history$location","pathnameInHistory","searchInHistory","hashInHistory","stateInHistory","handleLocationChange","noInitialPop","Fragment","childrenNode","getConnectedRouter","mapDispatchToProps","dispatch","ConnectedRouter","memo","ConnectedRouterWithContext","ReactReduxContext","Consumer","routerMiddleware","_","next","CALL_HISTORY_METHOD","_action$payload","method","connectRouter","ConnectedHRouter"],"mappings":";;;;;AAAe,SAASA,QAAQA,GAAG;AACjCA,EAAAA,QAAQ,GAAGC,MAAM,CAACC,MAAM,GAAGD,MAAM,CAACC,MAAM,CAACC,IAAI,EAAE,GAAG,UAAUC,MAAM,EAAE;AAClE,IAAA,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGC,SAAS,CAACC,MAAM,EAAEF,CAAC,EAAE,EAAE;AACzC,MAAA,IAAIG,MAAM,GAAGF,SAAS,CAACD,CAAC,CAAC,CAAA;AACzB,MAAA,KAAK,IAAII,GAAG,IAAID,MAAM,EAAE;AACtB,QAAA,IAAIP,MAAM,CAACS,SAAS,CAACC,cAAc,CAACC,IAAI,CAACJ,MAAM,EAAEC,GAAG,CAAC,EAAE;AACrDL,UAAAA,MAAM,CAACK,GAAG,CAAC,GAAGD,MAAM,CAACC,GAAG,CAAC,CAAA;AAC3B,SAAA;AACF,OAAA;AACF,KAAA;AACA,IAAA,OAAOL,MAAM,CAAA;GACd,CAAA;AACD,EAAA,OAAOJ,QAAQ,CAACa,KAAK,CAAC,IAAI,EAAEP,SAAS,CAAC,CAAA;AACxC;;ACTA;AACYQ,IAAAA,UAAU,0BAAVA,UAAU,EAAA;EAAVA,UAAU,CAAA,iBAAA,CAAA,GAAA,iCAAA,CAAA;EAAVA,UAAU,CAAA,qBAAA,CAAA,GAAA,qCAAA,CAAA;AAAA,EAAA,OAAVA,UAAU,CAAA;AAAA,CAAA,CAAA,EAAA,CAAA,CAAA;;AAKtB;;AAiBO,IAAMC,iBAAiB,GAAG,UAACC,QAAkB,EAAEC,MAAc,EAA8C;AAAA,EAAA,IAA5CC,gBAAgB,GAAAZ,SAAA,CAAAC,MAAA,GAAA,CAAA,IAAAD,SAAA,CAAA,CAAA,CAAA,KAAAa,SAAA,GAAAb,SAAA,CAAA,CAAA,CAAA,GAAG,KAAK,CAAA;EAC5F,OAAO;IACLc,IAAI,EAAEN,UAAU,CAACO,eAAe;AAChCC,IAAAA,OAAO,EAAE;AACPN,MAAAA,QAAQ,EAARA,QAAQ;AACRC,MAAAA,MAAM,EAANA,MAAM;AACNC,MAAAA,gBAAgB,EAAhBA,gBAAAA;AACF,KAAA;GACD,CAAA;AACH,CAAC;;AC9BD;AACA,SAASK,iBAAiBA,CAACP,QAA4B,EAAqB;AAC1E,EAAA,IAAIA,QAAQ,IAAIA,QAAQ,CAACQ,KAAK,EAAE;AAC9B,IAAA,OAAOR,QAAQ,CAAA;AACjB,GAAA;AAEA,EAAA,IAAMS,WAAW,GAAGT,QAAQ,IAAIA,QAAQ,CAACU,MAAM,CAAA;EAE/C,IAAI,CAACD,WAAW,EAAE;IAChB,OAAAzB,QAAA,KACKgB,QAAQ,EAAA;AACXQ,MAAAA,KAAK,EAAE,EAAC;AAAC,KAAA,CAAA,CAAA;AAEb,GAAA;EACA,IAAMG,WAAgC,GAAG,EAAE,CAAA;AAE3C,EAAA,IAAMC,MAAM,GAAG,IAAIC,eAAe,CAACJ,WAAW,CAAC,CAAA;AAC/CG,EAAAA,MAAM,CAACE,OAAO,CAAC,UAACC,KAAK,EAAEtB,GAAG,EAAA;AAAA,IAAA,OAAMkB,WAAW,CAAClB,GAAG,CAAC,GAAGsB,KAAK,CAAA;AAAA,GAAC,CAAC,CAAA;EAE1D,OAAA/B,QAAA,KACKgB,QAAQ,EAAA;AACXQ,IAAAA,KAAK,EAAEG,WAAAA;AAAW,GAAA,CAAA,CAAA;AAEtB,CAAA;AAYO,SAASK,mBAAmBA,GAAG;AACpC;EACA,OAAO,UAACC,OAAgB,EAAK;AAC3B,IAAA,IAAMC,eAAe,GAAG;AACtBlB,MAAAA,QAAQ,EAAEO,iBAAiB,CAACU,OAAO,CAACjB,QAAQ,CAAC;MAC7CC,MAAM,EAAEgB,OAAO,CAAChB,MAAAA;KACjB,CAAA;;AAED;AACA,IAAA,OAAO,YAAoF;AAAA,MAAA,IAAnFkB,KAAsB,GAAA7B,SAAA,CAAAC,MAAA,GAAA,CAAA,IAAAD,SAAA,CAAA,CAAA,CAAA,KAAAa,SAAA,GAAAb,SAAA,CAAA,CAAA,CAAA,GAAG4B,eAAe,CAAA;AAAA,MAAA,IAAAE,IAAA,GAAA9B,SAAA,CAAAC,MAAA,GAAA,CAAA,IAAAD,SAAA,CAAA,CAAA,CAAA,KAAAa,SAAA,GAAAb,SAAA,CAAA,CAAA,CAAA,GAA+B,EAAE;QAA7Bc,IAAI,GAAAgB,IAAA,CAAJhB,IAAI;QAAEE,OAAO,GAAAc,IAAA,CAAPd,OAAO,CAAA;AAC/D,MAAA,IAAIF,IAAI,KAAKN,UAAU,CAACO,eAAe,EAAE;AACvC,QAAA,IAAQL,QAAQ,GAA+BM,OAAO,CAA9CN,QAAQ;UAAEC,MAAM,GAAuBK,OAAO,CAApCL,MAAM;UAAEC,gBAAgB,GAAKI,OAAO,CAA5BJ,gBAAgB,CAAA;AAC1C,QAAA,IAAIA,gBAAgB,EAAE;AACpB,UAAA,OAAOiB,KAAK,CAAA;AACd,SAAA;QACA,OAAAnC,QAAA,KAAYmC,KAAK,EAAA;AAAEnB,UAAAA,QAAQ,EAAEO,iBAAiB,CAACP,QAAQ,CAAC;AAAEC,UAAAA,MAAM,EAAEA,MAAAA;AAAM,SAAA,CAAA,CAAA;AAC1E,OAAA;AACA,MAAA,OAAOkB,KAAK,CAAA;KACb,CAAA;GACF,CAAA;AACH;;AC7DO,SAASE,SAASA,GAAY;AACnC,EAAA,OAAO,OAAOC,MAAM,KAAK,WAAW,IAAIA,MAAM,CAACC,QAAQ,IAAI,OAAOD,MAAM,CAACC,QAAQ,CAACC,aAAa,KAAK,UAAU,CAAA;AAChH,CAAA;AAEO,SAASC,sBAAsBA,CAACC,OAAe,EAAEC,QAAmC,EAAE;AAC3FA,EAAAA,QAAQ,CAACL,MAAM,CAACM,OAAO,CAACF,OAAO,CAAC,CAAC,CAAA;AACnC,CAAA;;AAEA;AACO,SAASG,gBAAgBA,GAAY;AAC1C,EAAA,OAAOR,SAAS,EAAE,IAAIC,MAAM,CAACL,OAAO,IAAI,WAAW,IAAIK,MAAM,CAACL,OAAO,CAAA;AACvE,CAAA;;AAEA;AACO,SAASa,kBAAkBA,GAAY;AAC5C,EAAA,OAAOR,MAAM,CAACS,SAAS,CAACC,SAAS,CAACC,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAA;AAC7D;;ACeYC,IAAAA,MAAM,0BAANA,MAAM,EAAA;EAANA,MAAM,CAAA,KAAA,CAAA,GAAA,KAAA,CAAA;EAANA,MAAM,CAAA,MAAA,CAAA,GAAA,MAAA,CAAA;EAANA,MAAM,CAAA,SAAA,CAAA,GAAA,SAAA,CAAA;AAAA,EAAA,OAANA,MAAM,CAAA;AAAA,CAAA,CAAA,EAAA,CAAA,CAAA;AAMNC,IAAAA,SAAS,0BAATA,SAAS,EAAA;EAATA,SAAS,CAAA,UAAA,CAAA,GAAA,UAAA,CAAA;EAATA,SAAS,CAAA,YAAA,CAAA,GAAA,YAAA,CAAA;AAAA,EAAA,OAATA,SAAS,CAAA;AAAA,CAAA,CAAA,EAAA,CAAA;;ACnCd,SAASC,UAAUA,CAACC,IAAmB,EAAU;AACtD,EAAA,IAAQ3B,MAAM,GAAW2B,IAAI,CAArB3B,MAAM;IAAE4B,IAAI,GAAKD,IAAI,CAAbC,IAAI,CAAA;AACpB,EAAA,IAAIC,QAAQ,GAAGF,IAAI,CAACE,QAAQ,IAAI,GAAG,CAAA;AACnC,EAAA,IAAI7B,MAAM,IAAIA,MAAM,KAAK,GAAG,EAAE;AAC5B6B,IAAAA,QAAQ,IAAI7B,MAAM,CAAC8B,UAAU,CAAC,GAAG,CAAC,GAAG9B,MAAM,GAAG,GAAG,GAAGA,MAAM,CAAA;AAC5D,GAAA;AACA,EAAA,IAAI4B,IAAI,IAAIA,IAAI,KAAK,GAAG,EAAE;AACxBC,IAAAA,QAAQ,IAAID,IAAI,CAACE,UAAU,CAAC,GAAG,CAAC,GAAGF,IAAI,GAAG,GAAG,GAAGA,IAAI,CAAA;AACtD,GAAA;AACA,EAAA,OAAOC,QAAQ,CAAA;AACjB,CAAA;AAEO,SAASE,SAASA,CAACC,GAAW,EAAiB;EACpD,IAAI,CAACA,GAAG,EAAE;AACR,IAAA,OAAO,EAAE,CAAA;AACX,GAAA;EACA,IAAIC,UAAyB,GAAG,EAAE,CAAA;AAElC,EAAA,IAAIC,OAAO,GAAGF,GAAG,CAACT,OAAO,CAAC,GAAG,CAAC,CAAA;AAC9B,EAAA,IAAIW,OAAO,GAAG,CAAC,CAAC,EAAE;IAChBD,UAAU,CAACL,IAAI,GAAGI,GAAG,CAACG,SAAS,CAACD,OAAO,CAAC,CAAA;IACxCF,GAAG,GAAGA,GAAG,CAACG,SAAS,CAAC,CAAC,EAAED,OAAO,CAAC,CAAA;AACjC,GAAA;AAEA,EAAA,IAAIE,SAAS,GAAGJ,GAAG,CAACT,OAAO,CAAC,GAAG,CAAC,CAAA;AAChC,EAAA,IAAIa,SAAS,GAAG,CAAC,CAAC,EAAE;IAClBH,UAAU,CAACjC,MAAM,GAAGgC,GAAG,CAACG,SAAS,CAACC,SAAS,CAAC,CAAA;IAC5CJ,GAAG,GAAGA,GAAG,CAACG,SAAS,CAAC,CAAC,EAAEC,SAAS,CAAC,CAAA;AACnC,GAAA;AACA,EAAA,IAAIJ,GAAG,EAAE;IACPC,UAAU,CAACJ,QAAQ,GAAGG,GAAG,CAAA;AAC3B,GAAA;AACA,EAAA,OAAOC,UAAU,CAAA;AACnB,CAAA;AAEO,SAASI,cAAcA,CAAIC,OAA0B,EAAEC,EAAM,EAAE9B,KAAS,EAAE1B,GAAY,EAAyB;EACpH,IAAI8C,QAAQ,GAAG,OAAOS,OAAO,KAAK,QAAQ,GAAGA,OAAO,GAAGA,OAAO,CAACT,QAAQ,CAAA;AACvE,EAAA,IAAIW,MAAM,GAAG,OAAOD,EAAE,KAAK,QAAQ,GAAGR,SAAS,CAACQ,EAAE,CAAC,GAAGA,EAAE,CAAA;AACxD;AACA,EAAA,IAAME,UAAU,GAAGC,YAAY,CAAC,CAAC,CAAC,CAAA;EAClC,IAAMpD,QAAQ,GAAAhB,QAAA,CAAA;AACZuD,IAAAA,QAAQ,EAAEA,QAAQ;AAClB7B,IAAAA,MAAM,EAAE,EAAE;AACV4B,IAAAA,IAAI,EAAE,EAAE;AACRnB,IAAAA,KAAK,EAAEA,KAAK;IACZ1B,GAAG,EAAE,OAAOA,GAAG,KAAK,QAAQ,GAAGA,GAAG,GAAG0D,UAAU,EAAC;AAAC,GAAA,EAC9CD,MAAM,CACV,CAAA;AACD,EAAA,IAAI,CAAClD,QAAQ,CAACuC,QAAQ,EAAE;IACtBvC,QAAQ,CAACuC,QAAQ,GAAG,GAAG,CAAA;AACzB,GAAA;AACA,EAAA,OAAOvC,QAAQ,CAAA;AACjB,CAAA;AAEO,SAASqD,eAAeA,CAACC,EAAiB,EAAEC,EAAiB,EAAE;EACpE,OAAOD,EAAE,CAACf,QAAQ,KAAKgB,EAAE,CAAChB,QAAQ,IAAIe,EAAE,CAAC5C,MAAM,KAAK6C,EAAE,CAAC7C,MAAM,IAAI4C,EAAE,CAAChB,IAAI,KAAKiB,EAAE,CAACjB,IAAI,CAAA;AACtF,CAAA;AAEO,SAASkB,YAAYA,CAACnB,IAAY,EAAU;AACjD,EAAA,IAAIA,IAAI,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE;AACnB,IAAA,OAAOA,IAAI,CAAA;AACb,GAAA;EACA,OAAO,GAAG,GAAGA,IAAI,CAAA;AACnB,CAAA;AAEO,SAASoB,cAAcA,CAACpB,IAAY,EAAU;AACnD,EAAA,IAAIA,IAAI,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE;AACnB,IAAA,OAAOA,IAAI,CAACQ,SAAS,CAAC,CAAC,CAAC,CAAA;AAC1B,GAAA;AACA,EAAA,OAAOR,IAAI,CAAA;AACb,CAAA;AAEO,SAASqB,cAAcA,CAACrB,IAAY,EAAU;AACnD,EAAA,IAAMsB,QAAQ,GAAGH,YAAY,CAACnB,IAAI,CAAC,CAAA;EACnC,IAAIsB,QAAQ,CAACA,QAAQ,CAACpE,MAAM,GAAG,CAAC,CAAC,KAAK,GAAG,EAAE;IACzC,OAAOoE,QAAQ,CAACd,SAAS,CAAC,CAAC,EAAEc,QAAQ,CAACpE,MAAM,GAAG,CAAC,CAAC,CAAA;AACnD,GAAA;AACA,EAAA,OAAOoE,QAAQ,CAAA;AACjB,CAAA;AAEO,SAASC,WAAWA,CAACvB,IAAY,EAAEwB,MAAc,EAAW;AACjE,EAAA,OACExB,IAAI,CAACyB,WAAW,EAAE,CAAC7B,OAAO,CAAC4B,MAAM,CAACC,WAAW,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,CAACC,QAAQ,CAAC1B,IAAI,CAAC2B,MAAM,CAACH,MAAM,CAACtE,MAAM,CAAC,CAAC,CAAA;AAEtH,CAAA;AAEO,SAAS0E,aAAaA,CAAC5B,IAAY,EAAEwB,MAAc,EAAU;AAClE,EAAA,OAAOD,WAAW,CAACvB,IAAI,EAAEwB,MAAM,CAAC,GAAGxB,IAAI,CAACQ,SAAS,CAACgB,MAAM,CAACtE,MAAM,CAAC,GAAG8C,IAAI,CAAA;AACzE,CAAA;;AAEA;AACO,SAAS6B,kBAAkBA,CAAOC,OAAU,EAAEC,EAAiB,EAAE;AACtE,EAAA,IAAIC,aAAkB,GAAG,CAACD,EAAE,CAACD,OAAO,CAAC,CAAC,CAAA;AAEtC,EAAA,SAASG,QAAQA,CAACrB,EAAK,EAAEsB,IAAO,EAAU;IACxC,IAAIC,KAAK,GAAGH,aAAa,CAACI,WAAW,CAACL,EAAE,CAACnB,EAAE,CAAC,CAAC,CAAA;AAC7C,IAAA,IAAIuB,KAAK,KAAK,CAAC,CAAC,EAAE;AAChBA,MAAAA,KAAK,GAAG,CAAC,CAAA;AACX,KAAA;IACA,IAAIE,OAAO,GAAGL,aAAa,CAACI,WAAW,CAACL,EAAE,CAACG,IAAI,CAAC,CAAC,CAAA;AACjD,IAAA,IAAIG,OAAO,KAAK,CAAC,CAAC,EAAE;AAClBA,MAAAA,OAAO,GAAG,CAAC,CAAA;AACb,KAAA;IACA,OAAOF,KAAK,GAAGE,OAAO,CAAA;AACxB,GAAA;AAEA,EAAA,SAASC,SAASA,CAAC3B,OAAU,EAAE4B,SAAY,EAAE3E,MAAc,EAAE;AAC3D,IAAA,IAAM4E,MAAM,GAAGT,EAAE,CAACpB,OAAO,CAAC,CAAA;AAC1B,IAAA,IAAM8B,MAAM,GAAGV,EAAE,CAACQ,SAAS,CAAC,CAAA;AAC5B,IAAA,IAAI3E,MAAM,KAAKiC,MAAM,CAAC6C,IAAI,EAAE;AAC1B,MAAA,IAAMC,OAAO,GAAGX,aAAa,CAACI,WAAW,CAACI,MAAM,CAAC,CAAA;MACjD,IAAMI,gBAAgB,GAAGZ,aAAa,CAACa,KAAK,CAAC,CAAC,EAAEF,OAAO,GAAG,CAAC,CAAC,CAAA;AAC5DC,MAAAA,gBAAgB,CAACF,IAAI,CAACD,MAAM,CAAC,CAAA;AAC7BT,MAAAA,aAAa,GAAGY,gBAAgB,CAAA;AAClC,KAAA;AACA,IAAA,IAAIhF,MAAM,KAAKiC,MAAM,CAACiD,OAAO,EAAE;AAC7B,MAAA,IAAMH,QAAO,GAAGX,aAAa,CAACI,WAAW,CAACI,MAAM,CAAC,CAAA;AACjD,MAAA,IAAIG,QAAO,KAAK,CAAC,CAAC,EAAE;AAClBX,QAAAA,aAAa,CAACW,QAAO,CAAC,GAAGF,MAAM,CAAA;AACjC,OAAA;AACF,KAAA;AACF,GAAA;EAEA,OAAO;AAAER,IAAAA,QAAQ,EAARA,QAAQ;AAAEK,IAAAA,SAAS,EAATA,SAAAA;GAAW,CAAA;AAChC,CAAA;AAEA,SAASvB,YAAYA,CAAC7D,MAAc,EAAgB;AAClD,EAAA,IAAM6F,GAAG,GAAG7F,MAAM,GAAG,CAAC,CAAA;AACtB,EAAA,OAAO,YAAM;AACX,IAAA,OAAO8F,IAAI,CAACC,MAAM,EAAE,CAACC,QAAQ,CAAC,EAAE,CAAC,CAAC1C,SAAS,CAAC,CAAC,EAAEuC,GAAG,CAAC,CAAA;GACpD,CAAA;AACH;;ACrIe,SAASI,eAAeA,CAACC,QAAQ,EAAEC,WAAW,EAAE;AAC7D,EAAA,IAAI,EAAED,QAAQ,YAAYC,WAAW,CAAC,EAAE;AACtC,IAAA,MAAM,IAAIC,SAAS,CAAC,mCAAmC,CAAC,CAAA;AAC1D,GAAA;AACF;;ACJe,SAASC,OAAOA,CAACC,GAAG,EAAE;EACnC,yBAAyB,CAAA;;AAEzB,EAAA,OAAOD,OAAO,GAAG,UAAU,IAAI,OAAOE,MAAM,IAAI,QAAQ,IAAI,OAAOA,MAAM,CAACC,QAAQ,GAAG,UAAUF,GAAG,EAAE;AAClG,IAAA,OAAO,OAAOA,GAAG,CAAA;GAClB,GAAG,UAAUA,GAAG,EAAE;IACjB,OAAOA,GAAG,IAAI,UAAU,IAAI,OAAOC,MAAM,IAAID,GAAG,CAACG,WAAW,KAAKF,MAAM,IAAID,GAAG,KAAKC,MAAM,CAACpG,SAAS,GAAG,QAAQ,GAAG,OAAOmG,GAAG,CAAA;AAC7H,GAAC,EAAED,OAAO,CAACC,GAAG,CAAC,CAAA;AACjB;;ACPe,SAASI,YAAYA,CAACC,KAAK,EAAEC,IAAI,EAAE;AAChD,EAAA,IAAIP,OAAO,CAACM,KAAK,CAAC,KAAK,QAAQ,IAAIA,KAAK,KAAK,IAAI,EAAE,OAAOA,KAAK,CAAA;AAC/D,EAAA,IAAIE,IAAI,GAAGF,KAAK,CAACJ,MAAM,CAACO,WAAW,CAAC,CAAA;EACpC,IAAID,IAAI,KAAKjG,SAAS,EAAE;IACtB,IAAImG,GAAG,GAAGF,IAAI,CAACxG,IAAI,CAACsG,KAAK,EAAEC,IAAI,IAAI,SAAS,CAAC,CAAA;IAC7C,IAAIP,OAAO,CAACU,GAAG,CAAC,KAAK,QAAQ,EAAE,OAAOA,GAAG,CAAA;AACzC,IAAA,MAAM,IAAIX,SAAS,CAAC,8CAA8C,CAAC,CAAA;AACrE,GAAA;EACA,OAAO,CAACQ,IAAI,KAAK,QAAQ,GAAGI,MAAM,GAAGC,MAAM,EAAEN,KAAK,CAAC,CAAA;AACrD;;ACRe,SAASO,cAAcA,CAACC,GAAG,EAAE;AAC1C,EAAA,IAAIjH,GAAG,GAAG4G,YAAW,CAACK,GAAG,EAAE,QAAQ,CAAC,CAAA;AACpC,EAAA,OAAOd,OAAO,CAACnG,GAAG,CAAC,KAAK,QAAQ,GAAGA,GAAG,GAAG8G,MAAM,CAAC9G,GAAG,CAAC,CAAA;AACtD;;ACJA,SAASkH,iBAAiBA,CAACvH,MAAM,EAAEwH,KAAK,EAAE;AACxC,EAAA,KAAK,IAAIvH,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGuH,KAAK,CAACrH,MAAM,EAAEF,CAAC,EAAE,EAAE;AACrC,IAAA,IAAIwH,UAAU,GAAGD,KAAK,CAACvH,CAAC,CAAC,CAAA;AACzBwH,IAAAA,UAAU,CAACC,UAAU,GAAGD,UAAU,CAACC,UAAU,IAAI,KAAK,CAAA;IACtDD,UAAU,CAACE,YAAY,GAAG,IAAI,CAAA;IAC9B,IAAI,OAAO,IAAIF,UAAU,EAAEA,UAAU,CAACG,QAAQ,GAAG,IAAI,CAAA;AACrD/H,IAAAA,MAAM,CAACgI,cAAc,CAAC7H,MAAM,EAAE8H,cAAa,CAACL,UAAU,CAACpH,GAAG,CAAC,EAAEoH,UAAU,CAAC,CAAA;AAC1E,GAAA;AACF,CAAA;AACe,SAASM,YAAYA,CAACzB,WAAW,EAAE0B,UAAU,EAAEC,WAAW,EAAE;EACzE,IAAID,UAAU,EAAET,iBAAiB,CAACjB,WAAW,CAAChG,SAAS,EAAE0H,UAAU,CAAC,CAAA;AACpE,EAAA,IAAIC,WAAW,EAAEV,iBAAiB,CAACjB,WAAW,EAAE2B,WAAW,CAAC,CAAA;AAC5DpI,EAAAA,MAAM,CAACgI,cAAc,CAACvB,WAAW,EAAE,WAAW,EAAE;AAC9CsB,IAAAA,QAAQ,EAAE,KAAA;AACZ,GAAC,CAAC,CAAA;AACF,EAAA,OAAOtB,WAAW,CAAA;AACpB;;;;;ICfM4B,iBAAiB,gBAAA,YAAA;AAIrB,EAAA,SAAAA,oBAAc;AAAA9B,IAAAA,eAAA,OAAA8B,iBAAA,CAAA,CAAA;AAAA,IAAA,IAAA,CAHNC,MAAM,GAAA,KAAA,CAAA,CAAA;AAAA,IAAA,IAAA,CACNC,SAAS,GAAA,KAAA,CAAA,CAAA;IAGf,IAAI,CAACD,MAAM,GAAG,IAAI,CAAA;IAClB,IAAI,CAACC,SAAS,GAAG,EAAE,CAAA;AACrB,GAAA;AAACL,EAAAA,YAAA,CAAAG,iBAAA,EAAA,CAAA;IAAA7H,GAAA,EAAA,WAAA;AAAAsB,IAAAA,KAAA,EAED,SAAA0G,SAAiBF,CAAAA,MAAiB,EAAc;AAAA,MAAA,IAAAG,KAAA,GAAA,IAAA,CAAA;MAC9C,IAAI,CAACH,MAAM,GAAGA,MAAM,CAAA;;AAEpB;AACA,MAAA,OAAO,YAAM;AACX,QAAA,IAAIG,KAAI,CAACH,MAAM,KAAKA,MAAM,EAAE;UAC1BG,KAAI,CAACH,MAAM,GAAG,IAAI,CAAA;AACpB,SAAA;OACD,CAAA;AACH,KAAA;;AAEA;AAAA,GAAA,EAAA;IAAA9H,GAAA,EAAA,aAAA;AAAAsB,IAAAA,KAAA,EACA,SAAA4G,WAAmBC,CAAAA,IAAiB,EAAc;AAAA,MAAA,IAAAC,MAAA,GAAA,IAAA,CAAA;MAChD,IAAIC,QAAQ,GAAG,IAAI,CAAA;AACnB,MAAA,IAAMC,QAAQ,GAAG,UAACC,IAAmB,EAAK;AACxC,QAAA,IAAIF,QAAQ,EAAE;UACZF,IAAI,CAACI,IAAI,CAAC,CAAA;AACZ,SAAA;OACD,CAAA;AACD,MAAA,IAAI,CAACR,SAAS,CAACzC,IAAI,CAACgD,QAAQ,CAAC,CAAA;AAC7B,MAAA,OAAO,YAAM;AACXD,QAAAA,QAAQ,GAAG,KAAK,CAAA;AAChB;QACAD,MAAI,CAACL,SAAS,GAAGK,MAAI,CAACL,SAAS,CAACS,MAAM,CAAC,UAAAC,IAAI,EAAA;UAAA,OAAIA,IAAI,KAAKH,QAAQ,CAAA;SAAC,CAAA,CAAA;OAClE,CAAA;AACH,KAAA;AAAC,GAAA,EAAA;IAAAtI,GAAA,EAAA,iBAAA;AAAAsB,IAAAA,KAAA,EAED,SAAAoH,eAAuBH,CAAAA,IAAmB,EAAE;AAAA,MAAA,IAAAI,SAAA,GAAAC,4BAAA,CACnB,IAAI,CAACb,SAAS,CAAA;QAAAc,KAAA,CAAA;AAAA,MAAA,IAAA;QAArC,KAAAF,SAAA,CAAAG,CAAA,EAAAD,EAAAA,CAAAA,CAAAA,KAAA,GAAAF,SAAA,CAAAI,CAAA,EAAAC,EAAAA,IAAA,GAAuC;AAAA,UAAA,IAA5BV,QAAQ,GAAAO,KAAA,CAAAvH,KAAA,CAAA;UACjBgH,QAAQ,CAACC,IAAI,CAAC,CAAA;AAChB,SAAA;AAAC,OAAA,CAAA,OAAAU,GAAA,EAAA;QAAAN,SAAA,CAAAO,CAAA,CAAAD,GAAA,CAAA,CAAA;AAAA,OAAA,SAAA;AAAAN,QAAAA,SAAA,CAAAQ,CAAA,EAAA,CAAA;AAAA,OAAA;AACH,KAAA;AAAC,GAAA,EAAA;IAAAnJ,GAAA,EAAA,eAAA;IAAAsB,KAAA,EAED,SAAA8H,aAAAA,CACE7I,QAAqB,EACrBC,MAAc,EACd6I,oBAAsC,EACtCnH,QAAsB,EACtB;AACA,MAAA,IAAI,IAAI,CAAC4F,MAAM,KAAK,IAAI,EAAE;QACxB,IAAMwB,MAAM,GAAG,OAAO,IAAI,CAACxB,MAAM,KAAK,UAAU,GAAG,IAAI,CAACA,MAAM,CAACvH,QAAQ,EAAEC,MAAM,CAAC,GAAG,IAAI,CAACsH,MAAM,CAAA;AAC9F,QAAA,IAAI,OAAOwB,MAAM,KAAK,QAAQ,EAAE;AAC9B,UAAA,OAAOD,oBAAoB,KAAK,UAAU,GAAGA,oBAAoB,CAACC,MAAM,EAAEpH,QAAQ,CAAC,GAAGA,QAAQ,CAAC,IAAI,CAAC,CAAA;AACtG,SAAC,MAAM;AACLA,UAAAA,QAAQ,CAACoH,MAAM,KAAK,KAAK,CAAC,CAAA;AAC5B,SAAA;AACF,OAAC,MAAM;QACLpH,QAAQ,CAAC,IAAI,CAAC,CAAA;AAChB,OAAA;AACF,KAAA;AAAC,GAAA,CAAA,CAAA,CAAA;AAAA,EAAA,OAAA2F,iBAAA,CAAA;AAAA,CAAA,EAAA;;AC5DH,SAAS0B,OAAOA,CAACC,SAAc,EAAEvH,OAAe,EAAE;AAChD,EAAA,IAAIuH,SAAS,EAAE;IACb,IAAIC,OAAO,IAAI,OAAOA,OAAO,CAACC,IAAI,KAAK,UAAU,EAAE;AACjDD,MAAAA,OAAO,CAACC,IAAI,CAACzH,OAAO,CAAC,CAAA;AACvB,KAAA;AACF,GAAA;AACF;;ACHA;AACO,SAAS0H,cAAcA,CAC5BC,iBAAuC,EACvCC,WAAoC,EACpCC,cAAuB,EACvB;EACA,SAASC,EAAEA,CAACC,IAAY,EAAE;AACxBF,IAAAA,cAAc,CAACC,EAAE,CAACC,IAAI,CAAC,CAAA;AACzB,GAAA;EAEA,SAASC,MAAMA,GAAG;AAChBH,IAAAA,cAAc,CAACC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;AACvB,GAAA;EAEA,SAASG,SAASA,GAAG;AACnBJ,IAAAA,cAAc,CAACC,EAAE,CAAC,CAAC,CAAC,CAAA;AACtB,GAAA;EAEA,SAASI,MAAMA,CAAC7B,QAAqB,EAAc;AACjD,IAAA,IAAM8B,MAAM,GAAGR,iBAAiB,CAAC1B,WAAW,CAACI,QAAQ,CAAC,CAAA;IACtDuB,WAAW,CAAC,CAAC,CAAC,CAAA;AACd,IAAA,OAAO,YAAM;MACXA,WAAW,CAAC,CAAC,CAAC,CAAC,CAAA;AACfO,MAAAA,MAAM,EAAE,CAAA;KACT,CAAA;AACH,GAAA;EAEA,IAAIC,SAAS,GAAG,KAAK,CAAA;EAErB,SAASC,KAAKA,GAAwC;AAAA,IAAA,IAAvCxC,MAAiB,GAAAjI,SAAA,CAAAC,MAAA,GAAA,CAAA,IAAAD,SAAA,CAAA,CAAA,CAAA,KAAAa,SAAA,GAAAb,SAAA,CAAA,CAAA,CAAA,GAAG,KAAK,CAAA;AACtC,IAAA,IAAM0K,OAAO,GAAGX,iBAAiB,CAAC5B,SAAS,CAACF,MAAM,CAAC,CAAA;IACnD,IAAI,CAACuC,SAAS,EAAE;MACdR,WAAW,CAAC,CAAC,CAAC,CAAA;AACdQ,MAAAA,SAAS,GAAG,IAAI,CAAA;AAClB,KAAA;AACA,IAAA,OAAO,YAAM;AACX,MAAA,IAAIA,SAAS,EAAE;AACbA,QAAAA,SAAS,GAAG,KAAK,CAAA;QACjBR,WAAW,CAAC,CAAC,CAAC,CAAC,CAAA;AACjB,OAAA;AACAU,MAAAA,OAAO,EAAE,CAAA;KACV,CAAA;AACH,GAAA;EAEA,SAASC,kBAAkBA,CAACC,YAA6B,EAAE;IACzD,OAAO,UAAUC,SAAoC,EAAE;AACrD,MAAA,IAAIA,SAAS,EAAE;AACbnL,QAAAA,QAAA,CAAckL,YAAY,EAAEC,SAAS,CAAC,CAAA;AACxC,OAAA;AACAD,MAAAA,YAAY,CAAC3K,MAAM,GAAGgK,cAAc,CAAChK,MAAM,CAAA;AAC3C,MAAA,IAAMyI,IAAI,GAAG;QAAEhI,QAAQ,EAAEkK,YAAY,CAAClK,QAAQ;QAAEC,MAAM,EAAEiK,YAAY,CAACjK,MAAAA;OAAQ,CAAA;AAC7EoJ,MAAAA,iBAAiB,CAAClB,eAAe,CAACH,IAAI,CAAC,CAAA;KACxC,CAAA;AACH,GAAA;EAEA,OAAO;AAAEwB,IAAAA,EAAE,EAAFA,EAAE;AAAEE,IAAAA,MAAM,EAANA,MAAM;AAAEC,IAAAA,SAAS,EAATA,SAAS;AAAEC,IAAAA,MAAM,EAANA,MAAM;AAAEG,IAAAA,KAAK,EAALA,KAAK;AAAEE,IAAAA,kBAAkB,EAAlBA,kBAAAA;GAAoB,CAAA;AACrE;;AC5CO,SAASG,oBAAoBA,GAAuE;AAAA,EAAA,IAAhDC,OAA6B,GAAA/K,SAAA,CAAAC,MAAA,GAAA,CAAA,IAAAD,SAAA,CAAA,CAAA,CAAA,KAAAa,SAAA,GAAAb,SAAA,CAAA,CAAA,CAAA,GAAG,EAAE,CAAA;AAC3F,EAAA,IAAMgL,cAAc,GAAGzI,gBAAgB,EAAE,CAAA;AACzC,EAAA,IAAM0I,iBAAiB,GAAGzI,kBAAkB,EAAE,CAAA;AAC9C,EAAA,IAAMyH,cAAc,GAAGjI,MAAM,CAACL,OAAO,CAAA;AACrC,EAAA,IAAAuJ,qBAAA,GAA+EH,OAAO,CAA9EI,YAAY;AAAZA,IAAAA,YAAY,GAAAD,qBAAA,KAAG,KAAA,CAAA,GAAA,KAAK,GAAAA,qBAAA;IAAAE,qBAAA,GAAmDL,OAAO,CAAxDM,mBAAmB;AAAnBA,IAAAA,mBAAmB,GAAAD,qBAAA,KAAGjJ,KAAAA,CAAAA,GAAAA,sBAAsB,GAAAiJ,qBAAA,CAAA;AAE1E,EAAA,IAAME,QAAQ,GAAGP,OAAO,CAACO,QAAQ,GAAGlH,cAAc,CAAC2G,OAAO,CAACO,QAAQ,CAAC,GAAG,EAAE,CAAA;AAEzE,EAAA,IAAMC,YAAY,GAAGC,WAAW,CAACC,eAAe,EAAE,CAAC,CAAA;AAEnD,EAAA,IAAMC,cAAc,GAAG9G,kBAAkB,CAAsB2G,YAAY,EAAE,UAAAI,CAAC,EAAA;IAAA,OAAIA,CAAC,CAACxL,GAAG,CAAA;GAAC,CAAA,CAAA;AAExF,EAAA,IAAM4J,iBAAiB,GAAG,IAAI/B,iBAAiB,EAAK,CAAA;EAEpD,IAAA4D,eAAA,GAAqE9B,cAAc,CACjFC,iBAAiB,EACjBC,WAAW,EACXC,cACF,CAAC;IAJOC,EAAE,GAAA0B,eAAA,CAAF1B,EAAE;IAAEE,MAAM,GAAAwB,eAAA,CAANxB,MAAM;IAAEC,SAAS,GAAAuB,eAAA,CAATvB,SAAS;IAAEC,MAAM,GAAAsB,eAAA,CAANtB,MAAM;IAAEG,KAAK,GAAAmB,eAAA,CAALnB,KAAK;IAAEE,kBAAkB,GAAAiB,eAAA,CAAlBjB,kBAAkB,CAAA;AAMhE,EAAA,IAAMhJ,OAAmB,GAAG;IAC1BhB,MAAM,EAAEiC,MAAM,CAACiJ,GAAG;IAClB5L,MAAM,EAAEgK,cAAc,CAAChK,MAAM;AAC7BS,IAAAA,QAAQ,EAAE6K,YAAY;AACtBrB,IAAAA,EAAE,EAAFA,EAAE;AACFE,IAAAA,MAAM,EAANA,MAAM;AACNC,IAAAA,SAAS,EAATA,SAAS;AACTC,IAAAA,MAAM,EAANA,MAAM;AACNG,IAAAA,KAAK,EAALA,KAAK;AACLhF,IAAAA,IAAI,EAAJA,IAAI;AACJI,IAAAA,OAAO,EAAPA,OAAO;AACPiG,IAAAA,UAAU,EAAVA,UAAAA;GACD,CAAA;AAED,EAAA,IAAMC,WAAW,GAAGpB,kBAAkB,CAAChJ,OAAO,CAAC,CAAA;EAE/C,SAAS8J,eAAeA,GAAG;IACzB,OAAOT,cAAc,GAAGhJ,MAAM,CAACL,OAAO,CAACE,KAAK,GAAG,EAAE,CAAA;AACnD,GAAA;EAEA,SAAS2J,WAAWA,CAACQ,YAAsC,EAAE;AAC3D,IAAA,IAAAC,gBAAA,GAAyBjK,MAAM,CAACtB,QAAQ;MAAhCU,MAAM,GAAA6K,gBAAA,CAAN7K,MAAM;MAAE4B,IAAI,GAAAiJ,gBAAA,CAAJjJ,IAAI,CAAA;AACpB,IAAA,IAAAlB,IAAA,GAAuBkK,YAAY,IAAI,EAAE;MAAjC7L,GAAG,GAAA2B,IAAA,CAAH3B,GAAG;MAAE0B,KAAK,GAAAC,IAAA,CAALD,KAAK,CAAA;AAClB,IAAA,IAAIoB,QAAQ,GAAGjB,MAAM,CAACtB,QAAQ,CAACuC,QAAQ,CAAA;IACvCA,QAAQ,GAAGqI,QAAQ,GAAG3G,aAAa,CAAC1B,QAAQ,EAAEqI,QAAQ,CAAC,GAAGrI,QAAQ,CAAA;IAElE,OAAOQ,cAAc,CAAI,EAAE,EAAE;AAAER,MAAAA,QAAQ,EAARA,QAAQ;AAAE7B,MAAAA,MAAM,EAANA,MAAM;AAAE4B,MAAAA,IAAI,EAAJA,IAAAA;AAAK,KAAC,EAAEnB,KAAK,EAAE1B,GAAG,CAAC,CAAA;AACtE,GAAA;;AAEA;EACA,IAAI+L,SAAS,GAAG,KAAK,CAAA;EAErB,SAASC,cAAcA,CAACzL,QAAqB,EAAE;AAC7C,IAAA,IAAIwL,SAAS,EAAE;AACbA,MAAAA,SAAS,GAAG,KAAK,CAAA;MACjBH,WAAW,CAAClL,SAAS,CAAC,CAAA;AACxB,KAAC,MAAM;AACL,MAAA,IAAMF,MAAM,GAAGiC,MAAM,CAACiJ,GAAG,CAAA;AAEzB,MAAA,IAAMO,QAAQ,GAAG,UAACC,MAAe,EAAK;AACpC,QAAA,IAAIA,MAAM,EAAE;AACV;AACAN,UAAAA,WAAW,CAAC;AAAEpL,YAAAA,MAAM,EAAEA,MAAM;AAAED,YAAAA,QAAQ,EAAEA,QAAAA;AAAS,WAAC,CAAC,CAAA;AACrD,SAAC,MAAM;AACL4L,UAAAA,cAAc,CAAC5L,QAAQ,EAAEiB,OAAO,CAACjB,QAAQ,CAAC,CAAA;AAC5C,SAAA;OACD,CAAA;MAEDqJ,iBAAiB,CAACR,aAAa,CAAC7I,QAAQ,EAAEC,MAAM,EAAE0K,mBAAmB,EAAEe,QAAQ,CAAC,CAAA;AAClF,KAAA;AACF,GAAA;EAEA,SAASG,gBAAgBA,CAACC,KAAoB,EAAE;AAC9CL,IAAAA,cAAc,CAACX,WAAW,CAACgB,KAAK,CAAC3K,KAAK,CAAC,CAAC,CAAA;AAC1C,GAAA;EAEA,SAAS4K,kBAAkBA,GAAG;AAC5B,IAAA,IAAM/L,QAAQ,GAAG8K,WAAW,CAACC,eAAe,EAAE,CAAC,CAAA;IAC/CU,cAAc,CAACzL,QAAQ,CAAC,CAAA;AAC1B,GAAA;EAEA,IAAIgM,aAAa,GAAG,CAAC,CAAA;EAErB,SAAS1C,WAAWA,CAAC2C,KAAa,EAAE;AAClCD,IAAAA,aAAa,IAAIC,KAAK,CAAA;AACtB,IAAA,IAAID,aAAa,KAAK,CAAC,IAAIC,KAAK,KAAK,CAAC,EAAE;MACtC3K,MAAM,CAAC4K,gBAAgB,CAAC/J,SAAS,CAACgK,QAAQ,EAAEN,gBAAgB,CAAC,CAAA;MAC7D,IAAI,CAACtB,iBAAiB,EAAE;QACtBjJ,MAAM,CAAC4K,gBAAgB,CAAC/J,SAAS,CAACiK,UAAU,EAAEL,kBAAkB,CAAC,CAAA;AACnE,OAAA;AACF,KAAC,MAAM,IAAIC,aAAa,KAAK,CAAC,EAAE;MAC9B1K,MAAM,CAAC+K,mBAAmB,CAAClK,SAAS,CAACgK,QAAQ,EAAEN,gBAAgB,CAAC,CAAA;MAChE,IAAI,CAACtB,iBAAiB,EAAE;QACtBjJ,MAAM,CAAC+K,mBAAmB,CAAClK,SAAS,CAACiK,UAAU,EAAEL,kBAAkB,CAAC,CAAA;AACtE,OAAA;AACF,KAAA;AACF,GAAA;;AAEA;AACA,EAAA,SAASH,cAAcA,CAACrH,IAAiB,EAAEtB,EAAe,EAAE;IAC1D,IAAMqJ,KAAK,GAAGtB,cAAc,CAAC1G,QAAQ,CAACrB,EAAE,EAAEsB,IAAI,CAAC,CAAA;IAC/C,IAAI+H,KAAK,KAAK,CAAC,EAAE;MACf9C,EAAE,CAAC8C,KAAK,CAAC,CAAA;AACTd,MAAAA,SAAS,GAAG,IAAI,CAAA;AAClB,KAAA;AACF,GAAA;EAEA,SAASJ,UAAUA,CAAC/I,IAAmB,EAAE;AACvC,IAAA,OAAOuI,QAAQ,GAAGxI,UAAU,CAACC,IAAI,CAAC,CAAA;AACpC,GAAA;AAEA,EAAA,SAAS0C,IAAIA,CAAC9B,EAAM,EAAE9B,KAAS,EAAE;AAC/B,IAAA,IAAMlB,MAAM,GAAGiC,MAAM,CAAC6C,IAAI,CAAA;AAC1B,IAAA,IAAM/E,QAAQ,GAAG+C,cAAc,CAAI9B,OAAO,CAACjB,QAAQ,EAAEiD,EAAE,EAAE9B,KAAK,EAAEhB,SAAS,CAAC,CAAA;IAE1EkJ,iBAAiB,CAACR,aAAa,CAAC7I,QAAQ,EAAEC,MAAM,EAAE0K,mBAAmB,EAAE,UAAAgB,MAAM,EAAI;MAC/E,IAAI,CAACA,MAAM,EAAE;AACX,QAAA,OAAA;AACF,OAAA;AACA,MAAA,IAAMY,IAAI,GAAGnB,UAAU,CAACpL,QAAQ,CAAC,CAAA;AACjC,MAAA,IAAQP,GAAG,GAAYO,QAAQ,CAAvBP,GAAG;QAAE0B,KAAK,GAAKnB,QAAQ,CAAlBmB,KAAK,CAAA;AAElB,MAAA,IAAImJ,cAAc,EAAE;AAClB,QAAA,IAAIG,YAAY,EAAE;AAChBnJ,UAAAA,MAAM,CAACtB,QAAQ,CAACuM,IAAI,GAAGA,IAAI,CAAA;AAC7B,SAAC,MAAM;UACLhD,cAAc,CAACiD,SAAS,CAAC;AAAE/M,YAAAA,GAAG,EAAEA,GAAG;AAAE0B,YAAAA,KAAK,EAAEA,KAAAA;AAAM,WAAC,EAAE,EAAE,EAAEoL,IAAI,CAAC,CAAA;UAC9DvB,cAAc,CAACrG,SAAS,CAAC1D,OAAO,CAACjB,QAAQ,EAAEA,QAAQ,EAAEC,MAAM,CAAC,CAAA;AAC5DoL,UAAAA,WAAW,CAAC;AAAEpL,YAAAA,MAAM,EAANA,MAAM;AAAED,YAAAA,QAAQ,EAARA,QAAAA;AAAS,WAAC,CAAC,CAAA;AACnC,SAAA;AACF,OAAC,MAAM;AACLgJ,QAAAA,OAAO,CAAC7H,KAAK,KAAKhB,SAAS,EAAE,iFAAiF,CAAC,CAAA;AAC/GmB,QAAAA,MAAM,CAACtB,QAAQ,CAACuM,IAAI,GAAGA,IAAI,CAAA;AAC7B,OAAA;AACF,KAAC,CAAC,CAAA;AACJ,GAAA;AAEA,EAAA,SAASpH,OAAOA,CAAClC,EAAM,EAAE9B,KAAS,EAAE;AAClC,IAAA,IAAMlB,MAAM,GAAGiC,MAAM,CAACiD,OAAO,CAAA;AAC7B,IAAA,IAAMnF,QAAQ,GAAG+C,cAAc,CAAI9B,OAAO,CAACjB,QAAQ,EAAEiD,EAAE,EAAE9B,KAAK,EAAEhB,SAAS,CAAC,CAAA;IAE1EkJ,iBAAiB,CAACR,aAAa,CAAC7I,QAAQ,EAAEC,MAAM,EAAE0K,mBAAmB,EAAE,UAAAgB,MAAM,EAAI;MAC/E,IAAI,CAACA,MAAM,EAAE;AACX,QAAA,OAAA;AACF,OAAA;AACA,MAAA,IAAMY,IAAI,GAAGnB,UAAU,CAACpL,QAAQ,CAAC,CAAA;AACjC,MAAA,IAAQP,GAAG,GAAYO,QAAQ,CAAvBP,GAAG;QAAE0B,KAAK,GAAKnB,QAAQ,CAAlBmB,KAAK,CAAA;AAClB,MAAA,IAAImJ,cAAc,EAAE;AAClB,QAAA,IAAIG,YAAY,EAAE;AAChBnJ,UAAAA,MAAM,CAACtB,QAAQ,CAACmF,OAAO,CAACoH,IAAI,CAAC,CAAA;AAC/B,SAAC,MAAM;UACLhD,cAAc,CAACkD,YAAY,CAAC;AAAEhN,YAAAA,GAAG,EAAEA,GAAG;AAAE0B,YAAAA,KAAK,EAAEA,KAAAA;AAAM,WAAC,EAAE,EAAE,EAAEoL,IAAI,CAAC,CAAA;UACjEvB,cAAc,CAACrG,SAAS,CAAC1D,OAAO,CAACjB,QAAQ,EAAEA,QAAQ,EAAEC,MAAM,CAAC,CAAA;AAC5DoL,UAAAA,WAAW,CAAC;AAAEpL,YAAAA,MAAM,EAANA,MAAM;AAAED,YAAAA,QAAQ,EAARA,QAAAA;AAAS,WAAC,CAAC,CAAA;AACnC,SAAA;AACF,OAAC,MAAM;AACLgJ,QAAAA,OAAO,CAAC7H,KAAK,KAAKhB,SAAS,EAAE,iFAAiF,CAAC,CAAA;AAC/GmB,QAAAA,MAAM,CAACtB,QAAQ,CAACmF,OAAO,CAACoH,IAAI,CAAC,CAAA;AAC/B,OAAA;AACF,KAAC,CAAC,CAAA;AACJ,GAAA;AAEA,EAAA,OAAOtL,OAAO,CAAA;AAChB;;AC3JA;AACA,SAASyL,SAASA,CAACrK,IAAY,EAAU;AACvC,EAAA,IAAMsK,GAAG,GAAGtK,IAAI,CAACJ,OAAO,CAAC,GAAG,CAAC,CAAA;AAC7B,EAAA,OAAO0K,GAAG,KAAK,CAAC,CAAC,GAAGtK,IAAI,GAAGA,IAAI,CAACQ,SAAS,CAAC,CAAC,EAAE8J,GAAG,CAAC,CAAA;AACnD,CAAA;;AAEA;AACA,SAASC,cAAcA,CAACvK,IAAY,EAAU;AAC5C,EAAA,IAAMsK,GAAG,GAAGtK,IAAI,CAACJ,OAAO,CAAC,GAAG,CAAC,CAAA;AAC7B,EAAA,OAAO0K,GAAG,KAAK,CAAC,CAAC,GAAG,EAAE,GAAGtK,IAAI,CAACQ,SAAS,CAAC8J,GAAG,GAAG,CAAC,CAAC,CAAA;AAClD,CAAA;AAEO,SAASE,iBAAiBA,GAAmE;AAAA,EAAA,IAA5CC,MAAyB,GAAAxN,SAAA,CAAAC,MAAA,GAAA,CAAA,IAAAD,SAAA,CAAA,CAAA,CAAA,KAAAa,SAAA,GAAAb,SAAA,CAAA,CAAA,CAAA,GAAG,EAAE,CAAA;AACpF,EAAA,IAAMiK,cAAc,GAAGjI,MAAM,CAACL,OAAO,CAAA;AACrC,EAAA,IAAA8L,gBAAA,GAA6ED,MAAM,CAA3EE,QAAQ;AAARA,IAAAA,QAAQ,GAAAD,gBAAA,KAAG,KAAA,CAAA,GAAA,OAAO,GAAAA,gBAAA;IAAAE,qBAAA,GAAmDH,MAAM,CAAvDnC,mBAAmB;AAAnBA,IAAAA,mBAAmB,GAAAsC,qBAAA,KAAGxL,KAAAA,CAAAA,GAAAA,sBAAsB,GAAAwL,qBAAA,CAAA;AAExE,EAAA,IAAMrC,QAAQ,GAAGkC,MAAM,CAAClC,QAAQ,GAAGlH,cAAc,CAACoJ,MAAM,CAAClC,QAAQ,CAAC,GAAG,EAAE,CAAA;EAEvE,IAAMsC,WAAW,GAAG1J,YAAY,CAAA;EAChC,IAAM2J,WAAW,GAAGH,QAAQ,KAAK,OAAO,GAAGxJ,YAAY,GAAGC,cAAc,CAAA;EAExE,SAASqH,WAAWA,GAAG;AACrB,IAAA,IAAIsC,QAAQ,GAAGF,WAAW,CAACN,cAAc,CAACtL,MAAM,CAACtB,QAAQ,CAACsC,IAAI,CAAC,CAAC,CAAA;AAChE,IAAA,IAAIsI,QAAQ,EAAE;AACZwC,MAAAA,QAAQ,GAAGnJ,aAAa,CAACmJ,QAAQ,EAAExC,QAAQ,CAAC,CAAA;AAC9C,KAAA;IAEA,OAAO7H,cAAc,CAAI,EAAE,EAAEqK,QAAQ,EAAEjN,SAAS,EAAE,SAAS,CAAC,CAAA;AAC9D,GAAA;AAEA,EAAA,IAAM0K,YAAY,GAAGC,WAAW,EAAE,CAAA;AAElC,EAAA,IAAMuC,UAAU,GAAGnJ,kBAAkB,CAAsB2G,YAAY,EAAEzI,UAAU,CAAC,CAAA;AAEpF,EAAA,IAAMiH,iBAAiB,GAAG,IAAI/B,iBAAiB,EAAK,CAAA;EAEpD,SAAS8D,UAAUA,CAACpL,QAAqB,EAAE;AACzC,IAAA,IAAMsN,GAAG,GAAG/L,QAAQ,CAACgM,aAAa,CAAC,MAAM,CAAC,CAAA;IAC1C,IAAMC,IAAI,GAAGF,GAAG,IAAIA,GAAG,CAACG,YAAY,CAAC,MAAM,CAAC,GAAGf,SAAS,CAACpL,MAAM,CAACtB,QAAQ,CAACuM,IAAI,CAAC,GAAG,EAAE,CAAA;AACnF,IAAA,OAAOiB,IAAI,GAAG,GAAG,GAAGL,WAAW,CAACvC,QAAQ,GAAGxI,UAAU,CAACpC,QAAQ,CAAC,CAAC,CAAA;AAClE,GAAA;EAEA,IAAI0N,YAAY,GAAG,KAAK,CAAA;EACxB,IAAIC,UAAyB,GAAG,IAAI,CAAA;EAEpC,IAAAzC,eAAA,GAAqE9B,cAAc,CACjFC,iBAAiB,EACjBC,WAAW,EACXC,cACF,CAAC;IAJOC,EAAE,GAAA0B,eAAA,CAAF1B,EAAE;IAAEE,MAAM,GAAAwB,eAAA,CAANxB,MAAM;IAAEC,SAAS,GAAAuB,eAAA,CAATvB,SAAS;IAAEC,MAAM,GAAAsB,eAAA,CAANtB,MAAM;IAAEG,KAAK,GAAAmB,eAAA,CAALnB,KAAK;IAAEE,kBAAkB,GAAAiB,eAAA,CAAlBjB,kBAAkB,CAAA;AAMhE,EAAA,IAAMhJ,OAAmB,GAAG;IAC1BhB,MAAM,EAAEiC,MAAM,CAACiJ,GAAG;IAClB5L,MAAM,EAAEgK,cAAc,CAAChK,MAAM;AAC7BS,IAAAA,QAAQ,EAAE6K,YAAY;AACtBrB,IAAAA,EAAE,EAAFA,EAAE;AACFE,IAAAA,MAAM,EAANA,MAAM;AACNC,IAAAA,SAAS,EAATA,SAAS;AACT5E,IAAAA,IAAI,EAAJA,IAAI;AACJI,IAAAA,OAAO,EAAPA,OAAO;AACPyE,IAAAA,MAAM,EAANA,MAAM;AACNG,IAAAA,KAAK,EAALA,KAAK;AACLqB,IAAAA,UAAU,EAAVA,UAAAA;GACD,CAAA;AAED,EAAA,IAAMC,WAAW,GAAGpB,kBAAkB,CAAChJ,OAAO,CAAC,CAAA;AAE/C,EAAA,SAAS8D,IAAIA,CAAC9B,EAAM,EAAE9B,KAAS,EAAE;AAC/B6H,IAAAA,OAAO,CAAC7H,KAAK,KAAKhB,SAAS,EAAE,yDAAyD,CAAC,CAAA;AAEvF,IAAA,IAAMF,MAAM,GAAGiC,MAAM,CAAC6C,IAAI,CAAA;AAC1B,IAAA,IAAM/E,QAAQ,GAAG+C,cAAc,CAAI9B,OAAO,CAACjB,QAAQ,EAAEiD,EAAE,EAAE9C,SAAS,EAAE,EAAE,CAAC,CAAA;IAEvEkJ,iBAAiB,CAACR,aAAa,CAAC7I,QAAQ,EAAEC,MAAM,EAAE0K,mBAAmB,EAAE,UAAAgB,MAAM,EAAI;MAC/E,IAAI,CAACA,MAAM,EAAE;AACX,QAAA,OAAA;AACF,OAAA;AACA,MAAA,IAAMtJ,IAAI,GAAGD,UAAU,CAACpC,QAAQ,CAAC,CAAA;AACjC,MAAA,IAAM4N,WAAW,GAAGT,WAAW,CAACvC,QAAQ,GAAGvI,IAAI,CAAC,CAAA;AAChD;MACA,IAAIuK,cAAc,CAACtL,MAAM,CAACtB,QAAQ,CAACuM,IAAI,CAAC,KAAKqB,WAAW,EAAE;AACxDD,QAAAA,UAAU,GAAGC,WAAW,CAAA;AACxBtM,QAAAA,MAAM,CAACtB,QAAQ,CAACsC,IAAI,GAAGsL,WAAW,CAAA;QAElCP,UAAU,CAAC1I,SAAS,CAAC1D,OAAO,CAACjB,QAAQ,EAAEA,QAAQ,EAAEC,MAAM,CAAC,CAAA;AAExDoL,QAAAA,WAAW,CAAC;AAAEpL,UAAAA,MAAM,EAANA,MAAM;AAAED,UAAAA,QAAQ,EAARA,QAAAA;AAAS,SAAC,CAAC,CAAA;AACnC,OAAC,MAAM;QACLqL,WAAW,CAAClL,SAAS,CAAC,CAAA;AACxB,OAAA;AACF,KAAC,CAAC,CAAA;AACJ,GAAA;AAEA,EAAA,SAASgF,OAAOA,CAAClC,EAAM,EAAE9B,KAAS,EAAE;AAClC6H,IAAAA,OAAO,CAAC7H,KAAK,KAAKhB,SAAS,EAAE,yDAAyD,CAAC,CAAA;AACvF,IAAA,IAAMF,MAAM,GAAGiC,MAAM,CAACiD,OAAO,CAAA;AAC7B,IAAA,IAAMnF,QAAQ,GAAG+C,cAAc,CAAI9B,OAAO,CAACjB,QAAQ,EAAEiD,EAAE,EAAE9C,SAAS,EAAE,EAAE,CAAC,CAAA;IAEvEkJ,iBAAiB,CAACR,aAAa,CAAC7I,QAAQ,EAAEC,MAAM,EAAE0K,mBAAmB,EAAE,UAAAgB,MAAM,EAAI;MAC/E,IAAI,CAACA,MAAM,EAAE;AACX,QAAA,OAAA;AACF,OAAA;AACA,MAAA,IAAMtJ,IAAI,GAAGD,UAAU,CAACpC,QAAQ,CAAC,CAAA;AACjC,MAAA,IAAM4N,WAAW,GAAGT,WAAW,CAACvC,QAAQ,GAAGvI,IAAI,CAAC,CAAA;MAChD,IAAIuK,cAAc,CAACtL,MAAM,CAACtB,QAAQ,CAACuM,IAAI,CAAC,KAAKqB,WAAW,EAAE;AACxDD,QAAAA,UAAU,GAAGtL,IAAI,CAAA;AACjBf,QAAAA,MAAM,CAACtB,QAAQ,CAACmF,OAAO,CAACuH,SAAS,CAACpL,MAAM,CAACtB,QAAQ,CAACuM,IAAI,CAAC,GAAG,GAAG,GAAGqB,WAAW,CAAC,CAAA;AAC9E,OAAA;MACAP,UAAU,CAAC1I,SAAS,CAAC1D,OAAO,CAACjB,QAAQ,EAAEA,QAAQ,EAAEC,MAAM,CAAC,CAAA;AACxDoL,MAAAA,WAAW,CAAC;AAAEpL,QAAAA,MAAM,EAANA,MAAM;AAAED,QAAAA,QAAQ,EAARA,QAAAA;AAAS,OAAC,CAAC,CAAA;AACnC,KAAC,CAAC,CAAA;AACJ,GAAA;EAEA,SAAS6N,gBAAgBA,GAAG;IAC1B,IAAMT,QAAQ,GAAGR,cAAc,CAACtL,MAAM,CAACtB,QAAQ,CAACuM,IAAI,CAAC,CAAA;AACrD,IAAA,IAAMqB,WAAW,GAAGT,WAAW,CAACC,QAAQ,CAAC,CAAA;IACzC,IAAIA,QAAQ,KAAKQ,WAAW,EAAE;AAC5BtM,MAAAA,MAAM,CAACtB,QAAQ,CAACmF,OAAO,CAACuH,SAAS,CAACpL,MAAM,CAACtB,QAAQ,CAACuM,IAAI,CAAC,GAAG,GAAG,GAAGqB,WAAW,CAAC,CAAA;AAC9E,KAAC,MAAM;AACL,MAAA,IAAM5N,QAAQ,GAAG8K,WAAW,EAAE,CAAA;AAC9B,MAAA,IAAMgD,YAAY,GAAG7M,OAAO,CAACjB,QAAQ,CAAA;MACrC,IAAI,CAAC0N,YAAY,IAAIrK,eAAe,CAACrD,QAAQ,EAAE8N,YAAY,CAAC,EAAE;AAC5D,QAAA,OAAA;AACF,OAAA;AACA,MAAA,IAAIH,UAAU,KAAKvL,UAAU,CAACpC,QAAQ,CAAC,EAAE;AACvC,QAAA,OAAA;AACF,OAAA;AACA2N,MAAAA,UAAU,GAAG,IAAI,CAAA;MACjBlC,cAAc,CAACzL,QAAQ,CAAC,CAAA;AAC1B,KAAA;AACF,GAAA;EAEA,SAASyL,cAAcA,CAACzL,QAAqB,EAAE;AAC7C,IAAA,IAAI0N,YAAY,EAAE;AAChBA,MAAAA,YAAY,GAAG,KAAK,CAAA;MACpBrC,WAAW,CAAClL,SAAS,CAAC,CAAA;AACxB,KAAC,MAAM;AACL,MAAA,IAAMF,MAAM,GAAGiC,MAAM,CAACiJ,GAAG,CAAA;AAEzB,MAAA,IAAMO,QAAQ,GAAG,UAACC,MAAe,EAAK;AACpC,QAAA,IAAIA,MAAM,EAAE;AACVN,UAAAA,WAAW,CAAC;AAAEpL,YAAAA,MAAM,EAAEA,MAAM;AAAED,YAAAA,QAAQ,EAAEA,QAAAA;AAAS,WAAC,CAAC,CAAA;AACrD,SAAC,MAAM;UACL4L,cAAc,CAAC5L,QAAQ,CAAC,CAAA;AAC1B,SAAA;OACD,CAAA;MAEDqJ,iBAAiB,CAACR,aAAa,CAAC7I,QAAQ,EAAEC,MAAM,EAAE0K,mBAAmB,EAAEe,QAAQ,CAAC,CAAA;AAClF,KAAA;AACF,GAAA;;AAEA;EACA,SAASE,cAAcA,CAACrH,IAAiB,EAAE;AACzC,IAAA,IAAMtB,EAAE,GAAGhC,OAAO,CAACjB,QAAQ,CAAA;IAC3B,IAAMsM,KAAK,GAAGe,UAAU,CAAC/I,QAAQ,CAACrB,EAAE,EAAEsB,IAAI,CAAC,CAAA;IAC3C,IAAI+H,KAAK,KAAK,CAAC,EAAE;MACf9C,EAAE,CAAC8C,KAAK,CAAC,CAAA;AACToB,MAAAA,YAAY,GAAG,IAAI,CAAA;AACrB,KAAA;AACF,GAAA;EAEA,IAAI1B,aAAa,GAAG,CAAC,CAAA;EAErB,SAAS1C,WAAWA,CAACgD,KAAa,EAAE;AAClCN,IAAAA,aAAa,IAAIM,KAAK,CAAA;AACtB,IAAA,IAAIN,aAAa,KAAK,CAAC,IAAIM,KAAK,KAAK,CAAC,EAAE;MACtChL,MAAM,CAAC4K,gBAAgB,CAAC/J,SAAS,CAACiK,UAAU,EAAEyB,gBAAgB,CAAC,CAAA;AACjE,KAAC,MAAM,IAAI7B,aAAa,KAAK,CAAC,EAAE;MAC9B1K,MAAM,CAAC+K,mBAAmB,CAAClK,SAAS,CAACiK,UAAU,EAAEyB,gBAAgB,CAAC,CAAA;AACpE,KAAA;AACF,GAAA;AAEA,EAAA,OAAO5M,OAAO,CAAA;AAChB;;AChMA,SAAS8M,kBAAkBA,CAAIC,IAAY,EAAEC,YAAe,EAAE;AAC5D,EAAA,IAAMC,OAAO,GAAGC,aAAa,CAAIF,YAAY,CAAC,CAAA;EAC9CC,OAAO,CAACE,WAAW,GAAGJ,IAAI,CAAA;AAC1B,EAAA,OAAOE,OAAO,CAAA;AAChB,CAAA;AAQMG,IAAAA,aAAa,GAAGN,kBAAkB,CAAqB,QAAQ,EAAE,EAAS;;ACTpEO,IAAAA,SAAS,0BAATA,SAAS,EAAA;EAATA,SAAS,CAAA,WAAA,CAAA,GAAA,WAAA,CAAA;EAATA,SAAS,CAAA,QAAA,CAAA,GAAA,QAAA,CAAA;EAATA,SAAS,CAAA,OAAA,CAAA,GAAA,OAAA,CAAA;EAATA,SAAS,CAAA,UAAA,CAAA,GAAA,UAAA,CAAA;EAATA,SAAS,CAAA,UAAA,CAAA,GAAA,GAAA,CAAA;EAATA,SAAS,CAAA,UAAA,CAAA,GAAA,GAAA,CAAA;EAATA,SAAS,CAAA,SAAA,CAAA,GAAA,SAAA,CAAA;AAAA,EAAA,OAATA,SAAS,CAAA;AAAA,CAAA,CAAA,EAAA,CAAA,CAAA;;AA8CrB;;ACrDA;AACA;AACA;AACO,SAASC,SAASA,CAAClM,IAAY,EAAU;AAC9C,EAAA,OAAOA,IAAI,CAAC8C,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;AAClC,CAAA;AAEO,SAASqJ,YAAYA,CAACC,MAAgB,EAAEC,MAAgB,EAAU;AACvE,EAAA,IAAMC,YAAY,GAAGF,MAAM,CAAClP,MAAM,CAAA;AAClC,EAAA,IAAMqP,YAAY,GAAGF,MAAM,CAACnP,MAAM,CAAA;EAClC,IAAM6F,GAAG,GAAGC,IAAI,CAACwJ,GAAG,CAACF,YAAY,EAAEC,YAAY,CAAC,CAAA;EAChD,KAAK,IAAIvP,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAG+F,GAAG,EAAE/F,CAAC,EAAE,EAAE;IAC5B,IAAMiN,KAAK,GAAGoC,MAAM,CAACrP,CAAC,CAAC,GAAGoP,MAAM,CAACpP,CAAC,CAAC,CAAA;IACnC,IAAIiN,KAAK,KAAK,CAAC,EAAE;AACf,MAAA,OAAOA,KAAK,CAAA;AACd,KAAA;AACF,GAAA;EACA,IAAIqC,YAAY,KAAKC,YAAY,EAAE;AACjC,IAAA,OAAO,CAAC,CAAA;AACV,GAAA;AACA,EAAA,OAAOD,YAAY,GAAGC,YAAY,GAAG,CAAC,CAAC,GAAG,CAAC,CAAA;AAC7C,CAAA;;AAEA;AACO,SAASE,SAASA,CAACC,GAAW,EAAE;AACrC,EAAA,OAAOA,GAAG,CAAC5J,OAAO,CAAC,2BAA2B,EAAE,MAAM,CAAC,CAAA;AACzD;;ACvBA,IAAM6J,SAAS,GAAG,UAAU,CAAA;;AAE5B;AACO,SAASC,KAAKA,CAAC5M,IAAY,EAAW;EAC3C,IAAM6M,MAAe,GAAG,EAAE,CAAA;EAE1B,IAAI,CAAC7M,IAAI,EAAE;AACT,IAAA,OAAO6M,MAAM,CAAA;AACf,GAAA;AAEA,EAAA,IAAIC,OAAO,GAAGZ,SAAS,CAAClM,IAAI,CAAC,CAAA;EAC7B,IAAI8M,OAAO,KAAK,GAAG,IAAI,CAACA,OAAO,CAAC3M,UAAU,CAAC,GAAG,CAAC,EAAE;IAC/C,MAAM,IAAI4M,KAAK,CAAA,4BAA2B,CAAC,CAAA;AAC7C,GAAA;AAEA,EAAA,IAAMC,UAAU,GAAG,YAAM;IACvB,IAAIrB,IAAI,GAAG,EAAE,CAAA;AACb,IAAA,OAAO3O,CAAC,GAAG8P,OAAO,CAAC5P,MAAM,IAAIyP,SAAS,CAACM,IAAI,CAACH,OAAO,CAAC9P,CAAC,CAAC,CAAC,EAAE;AACvD2O,MAAAA,IAAI,IAAImB,OAAO,CAAC9P,CAAC,CAAC,CAAA;MAClBkQ,QAAQ,CAAC,CAAC,CAAC,CAAA;AACb,KAAA;AACA,IAAA,OAAOvB,IAAI,CAAA;GACZ,CAAA;AAED,EAAA,IAAMuB,QAAQ,GAAG,UAAC9F,IAAY,EAAK;AACjCpK,IAAAA,CAAC,IAAIoK,IAAI,CAAA;GACV,CAAA;EAED,IAAIpK,CAAC,GAAG,CAAC,CAAA;AACT,EAAA,OAAOA,CAAC,GAAG8P,OAAO,CAAC5P,MAAM,EAAE;AACzB,IAAA,IAAMiQ,OAAO,GAAGL,OAAO,CAAC9P,CAAC,CAAC,CAAA;AAC1B,IAAA,IAAMoQ,QAAQ,GAAGN,OAAO,CAAC9P,CAAC,GAAG,CAAC,CAAC,CAAA;IAE/B,IAAImQ,OAAO,KAAK,GAAG,EAAE;MACnBN,MAAM,CAACnK,IAAI,CAAC;QAAE3E,IAAI,EAAEkO,SAAS,CAACoB,SAAS;QAAE3O,KAAK,EAAEoO,OAAO,CAAC9P,CAAC,CAAA;AAAE,OAAC,CAAC,CAAA;MAC7DkQ,QAAQ,CAAC,CAAC,CAAC,CAAA;AACX,MAAA,SAAA;AACF,KAAA;AACA;AACA,IAAA,IAAIE,QAAQ,KAAK,GAAG,IAAID,OAAO,KAAK,GAAG,EAAE;MACvCD,QAAQ,CAAC,CAAC,CAAC,CAAA;MACXL,MAAM,CAACnK,IAAI,CAAC;QAAE3E,IAAI,EAAEkO,SAAS,CAACqB,KAAK;QAAE5O,KAAK,EAAEsO,UAAU,EAAC;AAAE,OAAC,CAAC,CAAA;AAC3D,MAAA,SAAA;AACF,KAAA;AACA;AACA,IAAA,IAAI,CAACI,QAAQ,KAAK,GAAG,IAAIA,QAAQ,KAAKtP,SAAS,KAAKqP,OAAO,KAAK,GAAG,EAAE;MACnEN,MAAM,CAACnK,IAAI,CAAC;QAAE3E,IAAI,EAAEkO,SAAS,CAACsB,QAAQ;QAAE7O,KAAK,EAAEoO,OAAO,CAAC9P,CAAC,CAAA;AAAE,OAAC,CAAC,CAAA;MAC5DkQ,QAAQ,CAAC,CAAC,CAAC,CAAA;AACX,MAAA,SAAA;AACF,KAAA;AACA;IACA,IAAIE,QAAQ,KAAK,GAAG,IAAIT,SAAS,CAACM,IAAI,CAACE,OAAO,CAAC,EAAE;MAC/CN,MAAM,CAACnK,IAAI,CAAC;QAAE3E,IAAI,EAAEkO,SAAS,CAACuB,MAAM;QAAE9O,KAAK,EAAEsO,UAAU,EAAC;AAAE,OAAC,CAAC,CAAA;AAC5D,MAAA,SAAA;AACF,KAAA;IACA,IAAIG,OAAO,KAAK,GAAG,EAAE;MACnBN,MAAM,CAACnK,IAAI,CAAC;QAAE3E,IAAI,EAAEkO,SAAS,CAACwB,QAAQ;AAAE/O,QAAAA,KAAK,EAAE,GAAA;AAAI,OAAC,CAAC,CAAA;MACrDwO,QAAQ,CAAC,CAAC,CAAC,CAAA;AACX,MAAA,SAAA;AACF,KAAA;IACA,IAAIC,OAAO,KAAK,GAAG,EAAE;MACnBN,MAAM,CAACnK,IAAI,CAAC;QAAE3E,IAAI,EAAEkO,SAAS,CAACyB,QAAQ;AAAEhP,QAAAA,KAAK,EAAE,GAAA;AAAI,OAAC,CAAC,CAAA;MACrDwO,QAAQ,CAAC,CAAC,CAAC,CAAA;AACX,MAAA,SAAA;AACF,KAAA;AACA,IAAA,IAAIP,SAAS,CAACM,IAAI,CAACE,OAAO,CAAC,EAAE;MAC3BN,MAAM,CAACnK,IAAI,CAAC;QAAE3E,IAAI,EAAEkO,SAAS,CAAC0B,OAAO;QAAEjP,KAAK,EAAEsO,UAAU,EAAC;AAAE,OAAC,CAAC,CAAA;AAC7D,MAAA,SAAA;AACF,KAAA;AACA;IACAE,QAAQ,CAAC,CAAC,CAAC,CAAA;AACb,GAAA;AAEA,EAAA,OAAOL,MAAM,CAAA;AACf;;;;;;ACzEA;AAAA,IACKe,UAAU,0BAAVA,UAAU,EAAA;AAAVA,EAAAA,UAAU,CAAVA,UAAU,CAAA,QAAA,CAAA,GAAA,EAAA,CAAA,GAAA,QAAA,CAAA;AAAVA,EAAAA,UAAU,CAAVA,UAAU,CAAA,OAAA,CAAA,GAAA,CAAA,CAAA,GAAA,OAAA,CAAA;AAAVA,EAAAA,UAAU,CAAVA,UAAU,CAAA,UAAA,CAAA,GAAA,CAAA,CAAA,GAAA,UAAA,CAAA;AAAVA,EAAAA,UAAU,CAAVA,UAAU,CAAA,aAAA,CAAA,GAAA,CAAA,CAAA,CAAA,GAAA,aAAA,CAAA;AAAA,EAAA,OAAVA,UAAU,CAAA;AAAA,CAAA,CAAVA,UAAU,IAYf,EAAA,CAAA,CAAA;AASA,IAAMC,aAAqC,GAAG;AAC5C;AACAC,EAAAA,aAAa,EAAE,IAAI;AACnB;AACAC,EAAAA,UAAU,EAAE,KAAK;AACjB;AACAC,EAAAA,KAAK,EAAE,KAAA;AACT,CAAC,CAAA;AACD;AACA,IAAMC,cAAc,GAAG,qBAAqB,CAAA;AAC5C;AACA,IAAMC,kBAAkB,GAAG,OAAO,CAAA;AAElC,IAAMC,gBAAgB,GAAG,KAAK,CAAA;AAIvB,SAASC,gBAAgBA,CAAclO,QAAgB,EAAmD;AAAA,EAAA,IAAjDuK,MAAoB,GAAAxN,SAAA,CAAAC,MAAA,GAAA,CAAA,IAAAD,SAAA,CAAA,CAAA,CAAA,KAAAa,SAAA,GAAAb,SAAA,CAAA,CAAA,CAAA,GAAG4Q,aAAa,CAAA;AAClG,EAAA,IAAAQ,qBAAA,GAII5D,MAAM,CAHRqD,aAAa;AAAbA,IAAAA,aAAa,GAAAO,qBAAA,KAAA,KAAA,CAAA,GAAGR,aAAa,CAACC,aAAa,GAAAO,qBAAA;IAAAC,kBAAA,GAGzC7D,MAAM,CAFRsD,UAAU;AAAVA,IAAAA,UAAU,GAAAO,kBAAA,KAAA,KAAA,CAAA,GAAGT,aAAa,CAACE,UAAU,GAAAO,kBAAA;IAAAC,aAAA,GAEnC9D,MAAM,CADRuD,KAAK;AAALA,IAAAA,KAAK,GAAAO,aAAA,KAAA,KAAA,CAAA,GAAGV,aAAa,CAACG,KAAK,GAAAO,aAAA,CAAA;AAE7B;AACF;AACA;AACA;AACA;AACA;EACE,IAAIC,OAAO,GAAG,GAAG,CAAA;EACjB,IAAMC,IAAc,GAAG,EAAE,CAAA;EACzB,IAAMC,MAAgB,GAAG,EAAE,CAAA;AAE3B,EAAA,IAAM7B,MAAM,GAAGD,KAAK,CAAC1M,QAAQ,CAAC,CAAA;AAC9B,EAAA,IAAMyO,eAAe,GAAG9B,MAAM,CAAC3P,MAAM,KAAK,CAAC,IAAI2P,MAAM,CAAC,CAAC,CAAC,CAAC9O,IAAI,KAAKkO,SAAS,CAACsB,QAAQ,CAAA;AACpF,EAAA,IAAMqB,UAAU,GAAG/B,MAAM,CAAC3P,MAAM,CAAA;AAChC,EAAA,IAAM2R,SAAS,GAAGhC,MAAM,CAAC+B,UAAU,GAAG,CAAC,CAAC,CAAA;EAExC,KAAK,IAAIE,QAAQ,GAAG,CAAC,EAAEA,QAAQ,GAAGF,UAAU,EAAEE,QAAQ,EAAE,EAAE;AACxD,IAAA,IAAMC,KAAK,GAAGlC,MAAM,CAACiC,QAAQ,CAAC,CAAA;AAC9B,IAAA,IAAME,SAAS,GAAGnC,MAAM,CAACiC,QAAQ,GAAG,CAAC,CAAC,CAAA;IACtC,QAAQC,KAAK,CAAChR,IAAI;MAChB,KAAKkO,SAAS,CAACoB,SAAS;AACtBmB,QAAAA,OAAO,IAAI,GAAG,CAAA;AACd,QAAA,MAAA;MACF,KAAKvC,SAAS,CAACuB,MAAM;QACnBgB,OAAO,IAAIO,KAAK,CAACrQ,KAAK,CAACoE,OAAO,CAACmL,cAAc,EAAE,MAAM,CAAC,CAAA;AACtDS,QAAAA,MAAM,CAAChM,IAAI,CAACkL,UAAU,CAACqB,MAAM,CAAC,CAAA;AAC9B,QAAA,MAAA;MACF,KAAKhD,SAAS,CAACqB,KAAK;QAClB,IAAI4B,WAAW,GAAG,EAAE,CAAA;QACpB,IAAIF,SAAS,IAAIA,SAAS,CAACjR,IAAI,KAAKkO,SAAS,CAACwB,QAAQ,EAAE;AACtD;AACAqB,UAAAA,QAAQ,IAAI,CAAC,CAAA;UACb,OAAOjC,MAAM,CAACiC,QAAQ,CAAC,CAAC/Q,IAAI,KAAKkO,SAAS,CAACyB,QAAQ,EAAE;AACnDwB,YAAAA,WAAW,IAAIrC,MAAM,CAACiC,QAAQ,CAAC,CAACpQ,KAAK,CAAA;AACrCoQ,YAAAA,QAAQ,EAAE,CAAA;AACZ,WAAA;AACF,SAAA;AACAN,QAAAA,OAAO,IAAIU,WAAW,GAAA,MAAA,GAAUA,WAAW,GAAA,IAAA,GAAA,GAAA,GAAWhB,kBAAkB,GAAG,GAAA,CAAA;AAC3EO,QAAAA,IAAI,CAAC/L,IAAI,CAACqM,KAAK,CAACrQ,KAAK,CAAC,CAAA;AACtBgQ,QAAAA,MAAM,CAAChM,IAAI,CAACkL,UAAU,CAACuB,KAAK,CAAC,CAAA;AAC7B,QAAA,MAAA;MACF,KAAKlD,SAAS,CAACsB,QAAQ;AACrBkB,QAAAA,IAAI,CAAC/L,IAAI,CAACqM,KAAK,CAACrQ,KAAK,CAAC,CAAA;QACtB8P,OAAO,IAAA,MAAA,GAAWN,kBAAkB,GAAA,GAAA,IAAIS,eAAe,GAAG,GAAG,GAAG,EAAE,CAAUT,GAAAA,SAAAA,GAAAA,kBAAkB,GAAM,MAAA,CAAA;AACpGQ,QAAAA,MAAM,CAAChM,IAAI,CAACiM,eAAe,GAAGf,UAAU,CAACwB,QAAQ,GAAGxB,UAAU,CAACyB,WAAW,CAAC,CAAA;AAC3E,QAAA,MAAA;AACJ,KAAA;AACF,GAAA;EACA,IAAMC,UAAU,GAAGT,SAAS,CAAC9Q,IAAI,KAAKkO,SAAS,CAACsB,QAAQ,CAAA;AAExD,EAAA,IAAI,CAAC+B,UAAU,IAAI,CAACtB,KAAK,EAAE;IACzB,IAAI,CAACD,UAAU,EAAE;AACfS,MAAAA,OAAO,IAAW/B,MAAAA,GAAAA,SAAS,CAAC0B,gBAAgB,CAAC,GAAU,UAAA,CAAA;AACzD,KAAA;AACA,IAAA,IAAIU,SAAS,CAAC9Q,IAAI,KAAKkO,SAAS,CAACoB,SAAS,EAAE;AAC1CmB,MAAAA,OAAO,IAAW/B,MAAAA,GAAAA,SAAS,CAAC0B,gBAAgB,CAAC,GAAM,MAAA,CAAA;AACrD,KAAA;AACF,GAAC,MAAM;IACLK,OAAO,IAAIT,UAAU,GAAG,GAAG,SAAOtB,SAAS,CAAC0B,gBAAgB,CAAC,GAAK,KAAA,CAAA;AACpE,GAAA;AAEA,EAAA,IAAMoB,IAAI,GAAGzB,aAAa,GAAG,EAAE,GAAG,GAAG,CAAA;EACrC,IAAM0B,MAAM,GAAG,IAAIC,MAAM,CAACjB,OAAO,EAAEe,IAAI,CAAC,CAAA;;AAExC;AACF;AACA;EACE,SAASG,KAAKA,CAAC1P,IAAY,EAAqB;AAC9C,IAAA,IAAM2P,OAAO,GAAG3P,IAAI,CAAC4P,KAAK,CAACJ,MAAM,CAAC,CAAA;IAElC,IAAI,CAACG,OAAO,EAAE;AACZ,MAAA,OAAO,IAAI,CAAA;AACb,KAAA;AACA,IAAA,IAAME,WAAW,GAAGF,OAAO,CAAC,CAAC,CAAC,CAAA;IAC9B,IAAIpR,MAAiB,GAAG,EAAE,CAAA;AAC1B,IAAA,IAAIuR,UAAoB,GAAGC,KAAK,CAACC,IAAI,CAACtB,MAAM,CAAC,CAAA;AAC7C,IAAA,KAAK,IAAI1R,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAG2S,OAAO,CAACzS,MAAM,EAAEF,CAAC,EAAE,EAAE;AACvC,MAAA,IAAImS,KAAK,GAAGQ,OAAO,CAAC3S,CAAC,CAAC,CAAA;AACtB,MAAA,IAAII,GAAG,GAAGqR,IAAI,CAACzR,CAAC,GAAG,CAAC,CAAC,CAAA;AACrB,MAAA,IAAII,GAAG,KAAK,GAAG,IAAI+R,KAAK,EAAE;AACxB,QAAA,IAAIzQ,KAAK,GAAGyQ,KAAK,CAACc,KAAK,CAAC,GAAG,CAAC,CAAA;QAC5B,IAAI,CAACF,KAAK,CAACG,OAAO,CAAC3R,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE;AAC/BA,UAAAA,MAAM,CAAC,GAAG,CAAC,GAAGG,KAAK,CAAA;AACrB,SAAC,MAAM;AAAA,UAAA,IAAAyR,QAAA,CAAA;AACL,UAAA,CAAAA,QAAA,GAAA5R,MAAM,CAAC,GAAG,CAAC,EAACmE,IAAI,CAAAlF,KAAA,CAAA2S,QAAA,EAAIzR,KAAK,CAAC,CAAA;AAC5B,SAAA;AACA;AACAoR,QAAAA,UAAU,CAACM,MAAM,CAAA5S,KAAA,CAAjBsS,UAAU,EAAA,CACRpB,MAAM,CAAC9O,OAAO,CAACgO,UAAU,CAACyB,WAAW,CAAC,EACtC,CAAC,CAAAgB,CAAAA,MAAA,CACE,IAAIN,KAAK,CAACrR,KAAK,CAACxB,MAAM,CAAC,CAACoT,IAAI,CAAC1C,UAAU,CAACwB,QAAQ,CAAC,CACtD,CAAC,CAAA;AACH,OAAC,MAAM;QACL7Q,MAAM,CAACnB,GAAG,CAAC,GAAG+R,KAAK,GAAGA,KAAK,GAAG,EAAE,CAAA;AAClC,OAAA;AACF,KAAA;AAEA,IAAA,IAAMoB,OAAO,GAAGvQ,IAAI,KAAK6P,WAAW,CAAA;AACpC,IAAA,IAAMxP,GAAG,GAAGL,IAAI,KAAK,GAAG,IAAI6P,WAAW,KAAK,EAAE,GAAG,GAAG,GAAGA,WAAW,CAAA;IAClE,OAAO;AAAEU,MAAAA,OAAO,EAAEA,OAAO;AAAEvQ,MAAAA,IAAI,EAAEE,QAAQ;AAAEG,MAAAA,GAAG,EAAEA,GAAG;AAAEmQ,MAAAA,KAAK,EAAEV,UAAU;AAAEvR,MAAAA,MAAM,EAAEA,MAAAA;KAAQ,CAAA;AAC1F,GAAA;;AAEA;AACF;AACA;EACE,SAASkS,OAAOA,CAAClS,MAAiB,EAAU;IAC1C,IAAIyB,IAAI,GAAG,EAAE,CAAA;AAAC,IAAA,IAAA+F,SAAA,GAAAC,0BAAA,CACM6G,MAAM,CAAA;MAAA5G,KAAA,CAAA;AAAA,IAAA,IAAA;MAA1B,KAAAF,SAAA,CAAAG,CAAA,EAAAD,EAAAA,CAAAA,CAAAA,KAAA,GAAAF,SAAA,CAAAI,CAAA,EAAAC,EAAAA,IAAA,GAA4B;AAAA,QAAA,IAAjB2I,MAAK,GAAA9I,KAAA,CAAAvH,KAAA,CAAA;QACd,QAAQqQ,MAAK,CAAChR,IAAI;UAChB,KAAKkO,SAAS,CAACuB,MAAM;YACnBxN,IAAI,IAAI+O,MAAK,CAACrQ,KAAK,CAAA;AACnB,YAAA,MAAA;UACF,KAAKuN,SAAS,CAACqB,KAAK;AAClB,YAAA,IAAI,CAAC/O,MAAM,CAACwQ,MAAK,CAACrQ,KAAK,CAAC,EAAE;AACxB,cAAA,MAAM,IAAIqO,KAAK,CAAC,mBAAmB,CAAC,CAAA;AACtC,aAAA;AACA/M,YAAAA,IAAI,IAAIzB,MAAM,CAACwQ,MAAK,CAACrQ,KAAK,CAAC,CAAA;AAC3B,YAAA,MAAA;UACF,KAAKuN,SAAS,CAACsB,QAAQ;AACrB,YAAA,IAAImD,QAAQ,GAAGnS,MAAM,CAAC,GAAG,CAAC,CAAA;YAC1B,IAAImS,QAAQ,YAAYX,KAAK,EAAE;AAC7B/P,cAAAA,IAAI,IAAI0Q,QAAQ,CAACC,IAAI,CAAC,GAAG,CAAC,CAAA;AAC5B,aAAC,MAAM;AACL3Q,cAAAA,IAAI,IAAI0Q,QAAQ,CAAA;AAClB,aAAA;AACA,YAAA,MAAA;UACF,KAAKzE,SAAS,CAACoB,SAAS;YACtBrN,IAAI,IAAI+O,MAAK,CAACrQ,KAAK,CAAA;AACnB,YAAA,MAAA;AACJ,SAAA;AACF,OAAA;AAAC,KAAA,CAAA,OAAA2H,GAAA,EAAA;MAAAN,SAAA,CAAAO,CAAA,CAAAD,GAAA,CAAA,CAAA;AAAA,KAAA,SAAA;AAAAN,MAAAA,SAAA,CAAAQ,CAAA,EAAA,CAAA;AAAA,KAAA;AACD,IAAA,OAAOvG,IAAI,CAAA;AACb,GAAA;EAEA,OAAO;IACL,IAAIwP,MAAMA,GAAG;AACX,MAAA,OAAOA,MAAM,CAAA;KACd;IACD,IAAIf,IAAIA,GAAG;AACT,MAAA,OAAOA,IAAI,CAAA;KACZ;AACDgC,IAAAA,OAAO,EAAPA,OAAO;AACPf,IAAAA,KAAK,EAALA,KAAAA;GACD,CAAA;AACH,CAAA;;AAEA;AACA;AACA;AACO,SAASkB,SAASA,CACvB1Q,QAAgB,EAChBsO,OAA0B,EAC1B/D,MAAqB,EACF;AACnB,EAAA,IAAMoG,QAAQ,GAAGd,KAAK,CAACG,OAAO,CAAC1B,OAAO,CAAC,GAAA,EAAA,CAAA6B,MAAA,CAAO7B,OAAO,CAAI,GAAA,CAACA,OAAO,CAAC,CAAA;EAClE,IAAMsC,cAA4B,GAAG,EAAE,CAAA;AAAC,EAAA,IAAAC,UAAA,GAAA/K,0BAAA,CACrB6K,QAAQ,CAAA;IAAAG,MAAA,CAAA;AAAA,EAAA,IAAA;IAA3B,KAAAD,UAAA,CAAA7K,CAAA,EAAA8K,EAAAA,CAAAA,CAAAA,MAAA,GAAAD,UAAA,CAAA5K,CAAA,EAAAC,EAAAA,IAAA,GAA6B;AAAA,MAAA,IAAlBP,IAAI,GAAAmL,MAAA,CAAAtS,KAAA,CAAA;AACb,MAAA,IAAMuS,MAAM,GAAG7C,gBAAgB,CAACvI,IAAI,EAAE4E,MAAM,CAAC,CAAA;AAC7C,MAAA,IAAMyG,OAAO,GAAGD,MAAM,CAACvB,KAAK,CAACxP,QAAQ,CAAC,CAAA;AACtC,MAAA,IAAIgR,OAAO,EAAE;AACXJ,QAAAA,cAAc,CAACpO,IAAI,CAACwO,OAAO,CAAC,CAAA;AAC9B,OAAA;AACF,KAAA;AAAC,GAAA,CAAA,OAAA7K,GAAA,EAAA;IAAA0K,UAAA,CAAAzK,CAAA,CAAAD,GAAA,CAAA,CAAA;AAAA,GAAA,SAAA;AAAA0K,IAAAA,UAAA,CAAAxK,CAAA,EAAA,CAAA;AAAA,GAAA;AACD,EAAA,OAAO,CAACuK,cAAc,CAAC5T,MAAM,GAAG,IAAI,GAAG4T,cAAc,CAACK,IAAI,CAAC,UAACC,CAAC,EAAEC,CAAC,EAAA;IAAA,OAAKlF,YAAY,CAACiF,CAAC,CAACZ,KAAK,EAAEa,CAAC,CAACb,KAAK,CAAC,CAAA;GAAC,CAAA,CAAC,CAAC,CAAC,CAAA;AACzG,CAAA;AAEO,SAASc,YAAYA,CAAUtR,IAAY,EAAEzB,MAAiB,EAAE;AACrE,EAAA,IAAM0S,MAAM,GAAG7C,gBAAgB,CAACpO,IAAI,CAAC,CAAA;AACrC,EAAA,OAAOiR,MAAM,CAACR,OAAO,CAAClS,MAAM,CAAC,CAAA;AAC/B;;AClNA,SAASgT,UAAUA,GAAG;AACpB,EAAA,OAAOC,UAAU,CAACxF,aAAa,CAAC,CAACpN,OAAO,CAAA;AAC1C,CAAA;AAGA,SAAS6S,WAAWA,GAAG;AACrB,EAAA,OAAOD,UAAU,CAACxF,aAAa,CAAC,CAACrO,QAAQ,CAAA;AAC3C,CAAA;AAGA,SAAS+T,SAASA,GAAG;AACnB,EAAA,IAAM9B,KAAK,GAAG4B,UAAU,CAACxF,aAAa,CAAC,CAAC4D,KAAK,CAAA;AAC7C,EAAA,OAAOA,KAAK,GAAGA,KAAK,CAACrR,MAAM,GAAG,EAAE,CAAA;AAClC,CAAA;AAGA,SAASoT,aAAaA,CAAC3R,IAAa,EAAE;AACpC,EAAA,IAAME,QAAQ,GAAGuR,WAAW,EAAE,CAACvR,QAAQ,CAAA;AACvC,EAAA,IAAM0P,KAAK,GAAG4B,UAAU,CAACxF,aAAa,CAAC,CAAC4D,KAAK,CAAA;AAC7C,EAAA,IAAI5P,IAAI,EAAE;AACR,IAAA,OAAO4Q,SAAS,CAAC1Q,QAAQ,EAAEF,IAAI,CAAC,CAAA;AAClC,GAAA;AACA,EAAA,OAAO4P,KAAK,CAAA;AACd;;ACHA,SAASgC,KAAKA,CAA0ErN,KAA0B,EAAE;AAClH,EAAA,IAAMsH,OAAO,GAAG2F,UAAU,CAACxF,aAAa,CAAC,CAAA;AAEzC,EAAA,IAAQ6F,QAAQ,GAAqBtN,KAAK,CAAlCsN,QAAQ;IAAElU,QAAQ,GAAW4G,KAAK,CAAxB5G,QAAQ;IAAEqC,IAAI,GAAKuE,KAAK,CAAdvE,IAAI,CAAA;AAChC,EAAA,IAAM8R,QAAQ,GAAwBvN,KAAK,CAArCuN,QAAQ;IAAEC,SAAS,GAAaxN,KAAK,CAA3BwN,SAAS;IAAEC,MAAM,GAAKzN,KAAK,CAAhByN,MAAM,CAAA;AACjC,EAAA,IAAIpC,KAAwB,CAAA;AAE5B,EAAA,IAAMqC,aAAa,GAAGtU,QAAQ,IAAIkO,OAAO,CAAClO,QAAQ,CAAA;AAClD,EAAA,IAAIkU,QAAQ,EAAE;AACZjC,IAAAA,KAAK,GAAGiC,QAAQ,CAAA;GACjB,MAAM,IAAI7R,IAAI,EAAE;IACf4P,KAAK,GAAGgB,SAAS,CAAIqB,aAAa,CAAC/R,QAAQ,EAAEF,IAAI,CAAC,CAAA;AACpD,GAAC,MAAM;IACL4P,KAAK,GAAG/D,OAAO,CAAC+D,KAAK,CAAA;AACvB,GAAA;AACA,EAAA,IAAMsC,QAAQ,GAAAvV,QAAA,CAAA,EAAA,EAAQkP,OAAO,EAAA;AAAElO,IAAAA,QAAQ,EAAEsU,aAAa;AAAErC,IAAAA,KAAK,EAAEA,KAAAA;GAAO,CAAA,CAAA;AAEtE,EAAA,IAAIG,KAAK,CAACG,OAAO,CAAC4B,QAAQ,CAAC,IAAIK,QAAQ,CAACvI,KAAK,CAACkI,QAAQ,CAAC,KAAK,CAAC,EAAE;AAC7DA,IAAAA,QAAQ,GAAG,IAAI,CAAA;AACjB,GAAA;;AAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACE,EAAA,IAAMM,WAAW,GAAG,YAA8B;AAChD;IACA,IAAIF,QAAQ,CAACtC,KAAK,EAAE;AAClB,MAAA,IAAIkC,QAAQ,EAAE;AACZ,QAAA,IAAI,OAAOA,QAAQ,KAAK,UAAU,EAAE;UAClC,OAAOA,QAAQ,CAACI,QAAQ,CAAC,CAAA;AAC3B,SAAA;AACA,QAAA,OAAOJ,QAAQ,CAAA;AACjB,OAAA;AAEA,MAAA,IAAIC,SAAS,EAAE;AACb,QAAA,OAAO5S,aAAa,CAAC4S,SAAS,EAAEG,QAAQ,CAAC,CAAA;OAC1C,MAAM,IAAIF,MAAM,EAAE;QACjB,OAAOA,MAAM,CAACE,QAAQ,CAAC,CAAA;AACzB,OAAC,MAAM;AACL,QAAA,OAAO,IAAI,CAAA;AACb,OAAA;AACF,KAAC,MAAM;AACL;AACA,MAAA,IAAI,OAAOJ,QAAQ,KAAK,UAAU,EAAE;QAClC,OAAOA,QAAQ,CAACI,QAAQ,CAAC,CAAA;AAC3B,OAAA;AACA,MAAA,OAAO,IAAI,CAAA;AACb,KAAA;GACD,CAAA;AAED,EAAA,oBAAOG,KAAA,CAAAlT,aAAA,CAAC6M,aAAa,CAACsG,QAAQ,EAAA;AAAC5T,IAAAA,KAAK,EAAEwT,QAAAA;GAAWE,EAAAA,WAAW,EAA2B,CAAC,CAAA;AAC1F;;ACtEA,SAASG,MAAMA,CAAwBhO,KAAQ,EAAE;AAC/C,EAAA,IAAQ3F,OAAO,GAAsB2F,KAAK,CAAlC3F,OAAO;IAAA4T,eAAA,GAAsBjO,KAAK,CAAzBuN,QAAQ;AAARA,IAAAA,QAAQ,GAAAU,eAAA,KAAG,KAAA,CAAA,GAAA,IAAI,GAAAA,eAAA,CAAA;EAChC,IAAAC,SAAA,GAAgCC,QAAQ,CAACnO,KAAK,CAAC3F,OAAO,CAACjB,QAAQ,CAAC;AAAzDA,IAAAA,QAAQ,GAAA8U,SAAA,CAAA,CAAA,CAAA;AAAEE,IAAAA,WAAW,GAAAF,SAAA,CAAA,CAAA,CAAA,CAAA;AAC5B,EAAA,IAAMG,eAAe,GAAGC,MAAM,CAAkB,IAAI,CAAC,CAAA;;AAErD;EACA,IAAIC,QAA6B,GAAGlU,OAAO,CAAC2I,MAAM,CAAC,UAAAlD,GAAG,EAAI;AACxDuO,IAAAA,eAAe,CAACjS,OAAO,GAAG0D,GAAG,CAAC1G,QAAQ,CAAA;AACxC,GAAC,CAAC,CAAA;;AAEF;AACAoV,EAAAA,eAAe,CAAC,YAAM;AACpB,IAAA,IAAID,QAAQ,EAAE;AACZA,MAAAA,QAAQ,EAAE,CAAA;AACZ,KAAA;AACA;AACAA,IAAAA,QAAQ,GAAGlU,OAAO,CAAC2I,MAAM,CAAC,UAAAlD,GAAG,EAAI;AAC/BsO,MAAAA,WAAW,CAACtO,GAAG,CAAC1G,QAAQ,CAAC,CAAA;AAC3B,KAAC,CAAC,CAAA;IAEF,IAAIiV,eAAe,CAACjS,OAAO,EAAE;AAC3BgS,MAAAA,WAAW,CAACC,eAAe,CAACjS,OAAO,CAAC,CAAA;AACtC,KAAA;AAEA,IAAA,OAAO,YAAM;AACX,MAAA,IAAImS,QAAQ,EAAE;AACZA,QAAAA,QAAQ,EAAE,CAAA;AACVA,QAAAA,QAAQ,GAAG,IAAI,CAAA;QACfF,eAAe,CAACjS,OAAO,GAAG,IAAI,CAAA;AAChC,OAAA;KACD,CAAA;GACF,EAAE,EAAE,CAAC,CAAA;EAEN,IAAMqS,gBAAoC,GAAGC,OAAO,CAClD,YAAA;IAAA,OAAO;AACLrU,MAAAA,OAAO,EAAEA,OAAO;AAChBjB,MAAAA,QAAQ,EAAEA,QAAQ;AAClBiS,MAAAA,KAAK,EAAE;AAAEW,QAAAA,OAAO,EAAE5S,QAAQ,CAACuC,QAAQ,KAAK,GAAG;QAAE3B,MAAM,EAAE,EAAE;AAAEyB,QAAAA,IAAI,EAAE,GAAG;AAAEwQ,QAAAA,KAAK,EAAE,EAAE;AAAEnQ,QAAAA,GAAG,EAAE,GAAA;AAAI,OAAA;KACzF,CAAA;AAAA,GAAC,EACF,CAAC1C,QAAQ,CACX,CAAC,CAAA;AAED,EAAA,oBAAO0U,KAAA,CAAAlT,aAAA,CAAC6M,aAAa,CAACsG,QAAQ,EAAA;AAAC5T,IAAAA,KAAK,EAAEsU,gBAAiB;AAAClB,IAAAA,QAAQ,EAAEA,QAAAA;AAAS,GAAE,CAAC,CAAA;AAChF;;ACvDe,SAASoB,6BAA6BA,CAAC/V,MAAM,EAAEgW,QAAQ,EAAE;AACtE,EAAA,IAAIhW,MAAM,IAAI,IAAI,EAAE,OAAO,EAAE,CAAA;EAC7B,IAAIJ,MAAM,GAAG,EAAE,CAAA;AACf,EAAA,IAAIqW,UAAU,GAAGxW,MAAM,CAAC6R,IAAI,CAACtR,MAAM,CAAC,CAAA;EACpC,IAAIC,GAAG,EAAEJ,CAAC,CAAA;AACV,EAAA,KAAKA,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGoW,UAAU,CAAClW,MAAM,EAAEF,CAAC,EAAE,EAAE;AACtCI,IAAAA,GAAG,GAAGgW,UAAU,CAACpW,CAAC,CAAC,CAAA;IACnB,IAAImW,QAAQ,CAACvT,OAAO,CAACxC,GAAG,CAAC,IAAI,CAAC,EAAE,SAAA;AAChCL,IAAAA,MAAM,CAACK,GAAG,CAAC,GAAGD,MAAM,CAACC,GAAG,CAAC,CAAA;AAC3B,GAAA;AACA,EAAA,OAAOL,MAAM,CAAA;AACf;;ACFO,SAASsW,SAASA,CAAC9O,KAAqB,EAAE;AAC/C;AACA,EAAA,IAAM+O,SAAS,GAAGT,MAAM,CAAwB,IAAI,CAAC,CAAA;AACrD,EAAA,IAAMU,OAAO,GAAGV,MAAM,CAAC,KAAK,CAAC,CAAA;AAE7B,EAAA,IAAQW,OAAO,GAA0BjP,KAAK,CAAtCiP,OAAO;IAAEC,QAAQ,GAAgBlP,KAAK,CAA7BkP,QAAQ;IAAEC,SAAS,GAAKnP,KAAK,CAAnBmP,SAAS,CAAA;AAEpCX,EAAAA,eAAe,CAAC,YAAM;AACpB;AACA,IAAA,IAAI,CAACQ,OAAO,CAAC5S,OAAO,EAAE;MACpB4S,OAAO,CAAC5S,OAAO,GAAG,IAAI,CAAA;AACtB,MAAA,IAAI6S,OAAO,EAAE;AACXA,QAAAA,OAAO,EAAE,CAAA;AACX,OAAA;AACF,KAAC,MAAM;AACL;AACA,MAAA,IAAIC,QAAQ,EAAE;AACZH,QAAAA,SAAS,CAAC3S,OAAO,GAAG8S,QAAQ,CAACH,SAAS,CAAC3S,OAAO,CAAC,GAAG8S,QAAQ,EAAE,CAAA;AAC9D,OAAA;AACF,KAAA;IACAH,SAAS,CAAC3S,OAAO,GAAG4D,KAAK,CAAA;AAC3B,GAAC,CAAC,CAAA;;AAEF;AACAwO,EAAAA,eAAe,CAAC,YAAM;AACpB,IAAA,OAAO,YAAM;AACX,MAAA,IAAIW,SAAS,EAAE;AACbA,QAAAA,SAAS,EAAE,CAAA;AACb,OAAA;KACD,CAAA;GACF,EAAE,EAAE,CAAC,CAAA;AAEN,EAAA,OAAO,IAAI,CAAA;AACb;;;ACtBA,SAASC,QAAQA,CAA0BpP,KAAQ,EAAE;AACnD,EAAA,IAAQ3D,EAAE,GAA6B2D,KAAK,CAApC3D,EAAE;IAAAgT,WAAA,GAA6BrP,KAAK,CAAhC7B,IAAI;AAAJA,IAAAA,IAAI,GAAAkR,WAAA,KAAG,KAAA,CAAA,GAAA,KAAK,GAAAA,WAAA;IAAE/B,QAAQ,GAAKtN,KAAK,CAAlBsN,QAAQ,CAAA;AAElC,EAAA,IAAMhG,OAAO,GAAG2F,UAAU,CAACxF,aAAa,CAAC,CAAA;AACzC,EAAA,IAAQpN,OAAO,GAAKiN,OAAO,CAAnBjN,OAAO,CAAA;AAEf,EAAA,IAAMiV,YAAY,GAAG,YAAyB;AAC5C,IAAA,IAAIhC,QAAQ,EAAE;AACZ,MAAA,IAAI,OAAOjR,EAAE,KAAK,QAAQ,EAAE;AAC1B,QAAA,IAAMqQ,MAAM,GAAG7C,gBAAgB,CAACxN,EAAE,CAAC,CAAA;QACnC,IAAM7D,MAAM,GAAGkU,MAAM,CAACR,OAAO,CAACoB,QAAQ,CAACtT,MAAM,CAAC,CAAA;QAC9C,OAAO6B,SAAS,CAACrD,MAAM,CAAC,CAAA;AAC1B,OAAC,MAAM;AACL,QAAA,IAAMmD,QAAQ,GAAGU,EAAE,CAACV,QAAQ,GAAGiB,YAAY,CAACP,EAAE,CAACV,QAAQ,CAAC,GAAG,GAAG,CAAA;AAC9D,QAAA,IAAM+Q,OAAM,GAAG7C,gBAAgB,CAAClO,QAAQ,CAAC,CAAA;QACzC,IAAMnD,OAAM,GAAGkU,OAAM,CAACR,OAAO,CAACoB,QAAQ,CAACtT,MAAM,CAAC,CAAA;QAC9C,OAAA5B,QAAA,KAAYiE,EAAE,EAAA;AAAEV,UAAAA,QAAQ,EAAEnD,OAAAA;AAAM,SAAA,CAAA,CAAA;AAClC,OAAA;AACF,KAAA;IACA,OAAO,OAAO6D,EAAE,KAAK,QAAQ,GAAGR,SAAS,CAACQ,EAAE,CAAC,GAAGA,EAAE,CAAA;GACnD,CAAA;EAED,IAAMkT,QAAQ,GAAGpR,IAAI,GAAG9D,OAAO,CAAC8D,IAAI,GAAG9D,OAAO,CAACkE,OAAO,CAAA;AACtD,EAAA,IAAAiR,aAAA,GAA2BF,YAAY,EAAE;IAAjC/U,KAAK,GAAAiV,aAAA,CAALjV,KAAK;AAAKkB,IAAAA,IAAI,GAAAkT,6BAAA,CAAAa,aAAA,EAAAC,WAAA,CAAA,CAAA;AAEtB,EAAA,IAAMC,WAAW,GAAG,YAAM;AACxBH,IAAAA,QAAQ,CAAC9T,IAAI,EAAElB,KAAK,CAAC,CAAA;GACtB,CAAA;AAED,EAAA,IAAMoV,YAAY,GAAG,UAACZ,SAA0B,EAAK;AACnD;IACA,IAAMa,QAAQ,GAAGb,SAAS,KAAA,IAAA,IAATA,SAAS,KAATA,KAAAA,CAAAA,GAAAA,KAAAA,CAAAA,GAAAA,SAAS,CAAEc,IAAgB,CAAA;AAC5C,IAAA,IAAI,CAACpT,eAAe,CAACmT,QAAQ,EAAEnU,IAAI,CAAC,EAAE;AACpC8T,MAAAA,QAAQ,CAAC9T,IAAI,EAAElB,KAAK,CAAC,CAAA;AACvB,KAAA;GACD,CAAA;AAED,EAAA,oBAAOuT,KAAA,CAAAlT,aAAA,CAACkU,SAAS,EAAA;AAACG,IAAAA,OAAO,EAAES,WAAY;AAACR,IAAAA,QAAQ,EAAES,YAAa;AAACE,IAAAA,IAAI,EAAEpU,IAAAA;AAAK,GAAE,CAAC,CAAA;AAChF;;AC5CA,SAASqU,MAAMA,CAAwB9P,KAAQ,EAA6B;AAC1E,EAAA,IAAMsH,OAAO,GAAG2F,UAAU,CAACxF,aAAa,CAAC,CAAA;EACzC,IAAMrO,QAAQ,GAAG4G,KAAK,CAAC5G,QAAQ,IAAIkO,OAAO,CAAClO,QAAQ,CAAA;EAEnD,IAAI2W,OAAkC,GAAG,IAAI,CAAA;EAC7C,IAAI1E,KAAqB,GAAG,IAAI,CAAA;;AAEhC;EACAuC,QAAQ,CAAC1T,OAAO,CAAC8F,KAAK,CAACuN,QAAQ,EAAE,UAAAyC,IAAI,EAAI;IACvC,IAAI3E,KAAK,KAAK,IAAI,IAAI4E,cAAc,CAACD,IAAI,CAAC,EAAE;AAC1CD,MAAAA,OAAO,GAAGC,IAAI,CAAA;AAEd,MAAA,IAAIE,MAA2B,CAAA;AAC/B,MAAA,IAAIC,SAA8B,CAAA;AAClC,MAAA,IAAI1U,IAAmC,CAAA;AACvC,MAAA,IAAIgQ,IAAwB,CAAA;;AAE5B;AACA,MAAA,IAAIuE,IAAI,CAACxW,IAAI,KAAK6T,KAAK,EAAE;AACvB,QAAA,IAAMrN,MAAK,GAAGgQ,IAAI,CAAChQ,KAAmB,CAAA;QACtCkQ,MAAM,GAAGlQ,MAAK,CAACkQ,MAAM,CAAA;QACrBC,SAAS,GAAGnQ,MAAK,CAACmQ,SAAS,CAAA;QAC3B1U,IAAI,GAAGuE,MAAK,CAACvE,IAAI,CAAA;AACnB,OAAC,MAAM,IAAIuU,IAAI,CAACxW,IAAI,KAAK4V,QAAQ,EAAE;AACjC,QAAA,IAAMpP,OAAK,GAAGgQ,IAAI,CAAChQ,KAAsB,CAAA;QACzCvE,IAAI,GAAGuE,OAAK,CAACvE,IAAI,CAAA;QACjByU,MAAM,GAAGlQ,OAAK,CAACkQ,MAAM,CAAA;QACrBzE,IAAI,GAAGzL,OAAK,CAACyL,IAAI,CAAA;AACnB,OAAA;AAEA,MAAA,IAAMhC,KAAK,GAAGuG,IAAI,CAAChQ,KAAK,CAACyJ,KAAK,CAAA;AAC9B,MAAA,IAAMjR,MAAM,GAAGiD,IAAI,IAAIgQ,IAAI,CAAA;;AAE3B;AACA,MAAA,IAAIjT,MAAM,EAAE;QACV6S,KAAK,GAAGgB,SAAS,CAACjT,QAAQ,CAACuC,QAAQ,EAAEnD,MAAM,EAAE;AAC3CgR,UAAAA,UAAU,EAAE0G,MAAM;AAClB3G,UAAAA,aAAa,EAAE4G,SAAS;AACxB1G,UAAAA,KAAK,EAAEA,KAAAA;AACT,SAAC,CAAC,CAAA;AACJ,OAAC,MAAM;QACL4B,KAAK,GAAG/D,OAAO,CAAC+D,KAAK,CAAA;AACvB,OAAA;AACF,KAAA;AACF,GAAC,CAAC,CAAA;EAEF,IAAIA,KAAK,IAAI0E,OAAO,EAAE;AACpB;IACA,OAAOK,YAAY,CAACL,OAAO,EAAE;AAAE3W,MAAAA,QAAQ,EAAEA,QAAQ;AAAEkU,MAAAA,QAAQ,EAAEjC,KAAAA;AAAM,KAAC,CAAC,CAAA;AACvE,GAAA;AACA,EAAA,OAAO,IAAI,CAAA;AACb;;ACrDA,SAASgF,MAAMA,CAAwBrQ,KAAQ,EAAE;AAC/C,EAAA,IAAMsH,OAAO,GAAG2F,UAAU,CAACxF,aAAa,CAAC,CAAA;AAEzC,EAAA,IAAQ3M,OAAO,GAAkBkF,KAAK,CAA9BlF,OAAO;IAAAwV,WAAA,GAAkBtQ,KAAK,CAArBuQ,IAAI;AAAJA,IAAAA,IAAI,GAAAD,WAAA,KAAG,KAAA,CAAA,GAAA,IAAI,GAAAA,WAAA,CAAA;AAE5B,EAAA,IAAK,OAAOC,IAAI,KAAK,UAAU,IAAIA,IAAI,CAACjJ,OAAO,CAAClO,QAAQ,CAAC,KAAK,KAAK,IAAK,CAACmX,IAAI,EAAE;AAC7E,IAAA,OAAO,IAAI,CAAA;AACb,GAAA;AAEA,EAAA,IAAMhB,QAAQ,GAAGjI,OAAO,CAACjN,OAAO,CAAC8I,KAAK,CAAA;EAEtC,IAAIqN,OAA4B,GAAG,IAAI,CAAA;AAEvC,EAAA,IAAMd,WAAW,GAAG,YAAM;IACxBc,OAAO,GAAG1V,OAAO,GAAGyU,QAAQ,CAACzU,OAAO,CAAC,GAAG,IAAI,CAAA;GAC7C,CAAA;AAED,EAAA,IAAM6U,YAAY,GAAG,UAACZ,SAA0B,EAAK;AACnD,IAAA,IAAIA,SAAS,IAAIA,SAAS,CAACc,IAAI,KAAK/U,OAAO,EAAE;AAC3C,MAAA,IAAI0V,OAAO,EAAE;AACXA,QAAAA,OAAO,EAAE,CAAA;AACX,OAAA;MACAA,OAAO,GAAG1V,OAAO,GAAGyU,QAAQ,CAACzU,OAAO,CAAC,GAAG,IAAI,CAAA;AAC9C,KAAA;GACD,CAAA;AAED,EAAA,IAAM2V,aAAa,GAAG,YAAM;AAC1B,IAAA,IAAID,OAAO,EAAE;AACXA,MAAAA,OAAO,EAAE,CAAA;AACX,KAAA;AACAA,IAAAA,OAAO,GAAG,IAAI,CAAA;GACf,CAAA;AAED,EAAA,oBAAO1C,KAAA,CAAAlT,aAAA,CAACkU,SAAS,EAAA;AAACG,IAAAA,OAAO,EAAES,WAAY;AAACR,IAAAA,QAAQ,EAAES,YAAa;AAACR,IAAAA,SAAS,EAAEsB,aAAc;AAACZ,IAAAA,IAAI,EAAE/U,OAAAA;AAAQ,GAAE,CAAC,CAAA;AAC7G;;AC1CA,SAAS4V,UAAUA,CAAgCC,SAAY,EAAE;EAE/D,SAASC,uBAAuBA,CAAC5Q,KAAU,EAAE;AAC3C,IAAA,IAAA6Q,WAAA,GAAqC5D,UAAU,CAACxF,aAAa,CAAC;MAAtDpN,OAAO,GAAAwW,WAAA,CAAPxW,OAAO;MAAEjB,QAAQ,GAAAyX,WAAA,CAARzX,QAAQ;MAAEiS,KAAK,GAAAwF,WAAA,CAALxF,KAAK,CAAA;AAChC,IAAA,IAAMyF,UAAU,GAAG;AAAEzW,MAAAA,OAAO,EAAEA,OAAO;AAAEjB,MAAAA,QAAQ,EAAEA,QAAQ;AAAEiS,MAAAA,KAAK,EAAEA,KAAAA;KAAO,CAAA;AAEzE,IAAA,oBAAOyC,KAAA,CAAAlT,aAAA,CAAC+V,SAAS,EAAAvY,QAAA,CAAA,EAAA,EAAK4H,KAAK,EAAM8Q,UAAU,CAAG,CAAC,CAAA;AACjD,GAAA;AAEA,EAAA,OAAOF,uBAAuB,CAAA;AAChC;;ACHA,SAASG,UAAUA,CAAqC/Q,KAAQ,EAAE;AAChE,EAAA,IAAIgR,UAAU,GAAG1C,MAAM,EAAW,CAAA;EAClC,IAAI0C,UAAU,CAAC5U,OAAO,KAAK,IAAI,IAAI4U,UAAU,CAAC5U,OAAO,KAAK7C,SAAS,EAAE;AACnEyX,IAAAA,UAAU,CAAC5U,OAAO,GAAG6J,iBAAiB,CAAC;MACrCjC,QAAQ,EAAEhE,KAAK,CAACgE,QAAQ;MACxBD,mBAAmB,EAAE/D,KAAK,CAAC+D,mBAAmB;MAC9CqC,QAAQ,EAAEpG,KAAK,CAACoG,QAAAA;AAClB,KAAC,CAAC,CAAA;AACJ,GAAA;AAEA,EAAA,oBAAO0H,KAAA,CAAAlT,aAAA,CAACoT,MAAM,EAAA;IAAC3T,OAAO,EAAE2W,UAAU,CAAC5U,OAAAA;GAAU4D,EAAAA,KAAK,CAACuN,QAAiB,CAAC,CAAA;AACvE;;ACNA,SAAS0D,aAAaA,CAAwCjR,KAAQ,EAAE;AACtE;AACA,EAAA,IAAIgR,UAAU,GAAG1C,MAAM,EAAW,CAAA;EAElC,IAAI0C,UAAU,CAAC5U,OAAO,KAAK,IAAI,IAAI4U,UAAU,CAAC5U,OAAO,KAAK7C,SAAS,EAAE;AACnEyX,IAAAA,UAAU,CAAC5U,OAAO,GAAGoH,oBAAoB,CAAC;MACxCQ,QAAQ,EAAEhE,KAAK,CAACgE,QAAQ;MACxBH,YAAY,EAAE7D,KAAK,CAAC6D,YAAY;MAChCE,mBAAmB,EAAE/D,KAAK,CAAC+D,mBAAAA;AAC7B,KAAC,CAAC,CAAA;AACJ,GAAA;AAEA,EAAA,oBAAO+J,KAAA,CAAAlT,aAAA,CAACoT,MAAM,EAAA;IAAC3T,OAAO,EAAE2W,UAAU,CAAC5U,OAAAA;GAAU4D,EAAAA,KAAK,CAACuN,QAAiB,CAAC,CAAA;AACvE;;;ACVA,IAAM2D,eAAe,GAAG,UAAChM,KAAuB,EAAK;AACnD,EAAA,OAAOA,KAAK,CAACiM,OAAO,IAAIjM,KAAK,CAACkM,MAAM,IAAIlM,KAAK,CAACmM,OAAO,IAAInM,KAAK,CAACoM,QAAQ,CAAA;AACzE,CAAC,CAAA;AAED,IAAMC,WAAW,GAAG,UAAC/Y,MAAwC,EAAK;AAChE,EAAA,OAAO,CAACA,MAAM,IAAIA,MAAM,KAAK,OAAO,CAAA;AACtC,CAAC,CAAA;AAGD,SAASgZ,IAAIA,CAAsBxR,KAAQ,EAAE;AAC3C,EAAA,IAAQ3D,EAAE,GAAoD2D,KAAK,CAA3D3D,EAAE,CAAA;IAAEkC,OAAO,GAA2CyB,KAAK,CAAvDzB,OAAO,CAAA;IAA2CyB,KAAK,CAA9CwN,SAAS,CAAA;QAAEiE,OAAO,GAAuBzR,KAAK,CAAnCyR,OAAO,CAAA;IAAEjZ,MAAM,GAAewH,KAAK,CAA1BxH,MAAM,CAAA;AAAKkZ,IAAAA,KAAK,GAAA/C,6BAAA,CAAK3O,KAAK,EAAAyP,WAAA,EAAA;AAEnE,EAAA,IAAM/I,GAAG,GAAG1G,KAAK,CAAC0G,GAAG,IAAI,GAAG,CAAA;AAE5B,EAAA,IAAMY,OAAO,GAAG2F,UAAU,CAACxF,aAAa,CAAC,CAAA;AACzC,EAAA,IAAMpN,OAAO,GAAGiN,OAAO,CAACjN,OAAO,CAAA;AAE/B,EAAA,IAAIjB,QAAQ,GAAG,OAAOiD,EAAE,KAAK,UAAU,GAAGA,EAAE,CAACiL,OAAO,CAAClO,QAAQ,CAAC,GAAGiD,EAAE,CAAA;AAEnE,EAAA,IAAI9B,KAAU,CAAA;AACd,EAAA,IAAIkB,IAAmB,CAAA;AACvB,EAAA,IAAI,OAAOrC,QAAQ,KAAK,QAAQ,EAAE;AAChCqC,IAAAA,IAAI,GAAGI,SAAS,CAACzC,QAAQ,CAAC,CAAA;AAC5B,GAAC,MAAM;AACL,IAAA,IAAQuC,QAAQ,GAAmBvC,QAAQ,CAAnCuC,QAAQ;MAAED,IAAI,GAAatC,QAAQ,CAAzBsC,IAAI;MAAE5B,MAAM,GAAKV,QAAQ,CAAnBU,MAAM,CAAA;AAC9B2B,IAAAA,IAAI,GAAG;AAAEE,MAAAA,QAAQ,EAARA,QAAQ;AAAED,MAAAA,IAAI,EAAJA,IAAI;AAAE5B,MAAAA,MAAM,EAANA,MAAAA;KAAQ,CAAA;IACjCS,KAAK,GAAGnB,QAAQ,CAACmB,KAAK,CAAA;AACxB,GAAA;AACA,EAAA,IAAMoL,IAAI,GAAGtL,OAAO,CAACmK,UAAU,CAAC/I,IAAI,CAAC,CAAA;AAErC,EAAA,IAAMkW,cAAc,GAAG,UAACzM,KAA0C,EAAK;IACrE,IAAI;AACF,MAAA,IAAIuM,OAAO,EAAE;QACXA,OAAO,CAACvM,KAAK,CAAC,CAAA;AAChB,OAAA;KACD,CAAC,OAAOnD,CAAC,EAAE;MACVmD,KAAK,CAAC0M,cAAc,EAAE,CAAA;AACtB,MAAA,MAAM7P,CAAC,CAAA;AACT,KAAA;IAEA,IAAI,CAACmD,KAAK,CAAC2M,gBAAgB,IAAI3M,KAAK,CAAC4M,MAAM,KAAK,CAAC,IAAIP,WAAW,CAAC/Y,MAAM,CAAC,IAAI,CAAC0Y,eAAe,CAAChM,KAAK,CAAC,EAAE;AACnG;AACA,MAAA,IAAM6M,UAAU,GAAGvW,UAAU,CAAC8L,OAAO,CAAClO,QAAQ,CAAC,KAAKoC,UAAU,CAACC,IAAI,CAAC,CAAA;AACpE,MAAA,IAAM8T,QAAQ,GAAGhR,OAAO,IAAIwT,UAAU,GAAG1X,OAAO,CAACkE,OAAO,GAAGlE,OAAO,CAAC8D,IAAI,CAAA;MACvE+G,KAAK,CAAC0M,cAAc,EAAE,CAAA;AACtBrC,MAAAA,QAAQ,CAAC9T,IAAI,EAAElB,KAAK,CAAC,CAAA;AACvB,KAAA;GACD,CAAA;EAED,IAAMyX,SAAS,GAAA5Z,QAAA,CAAA;AAAKuN,IAAAA,IAAI,EAAEA,IAAI;AAAE8L,IAAAA,OAAO,EAAEE,cAAAA;AAAc,GAAA,EAAKD,KAAK,CAAE,CAAA;AACnE,EAAA,OAAO5D,KAAK,CAAClT,aAAa,CAAC8L,GAAG,EAAEsL,SAAS,CAAC,CAAA;AAC5C;;;ACnDA,SAASC,OAAOA,CAAyBjS,KAAQ,EAAE;AACjD,EAAA,IAAQ3D,EAAE,GAAwB2D,KAAK,CAA/B3D,EAAE;IAAE6E,QAAQ,GAAclB,KAAK,CAA3BkB,QAAQ;AAAKgR,IAAAA,IAAI,GAAAvD,6BAAA,CAAK3O,KAAK,EAAAyP,SAAA,CAAA,CAAA;AACvC,EAAA,IAAMnI,OAAO,GAAG2F,UAAU,CAACkF,aAAO,CAAC,CAAA;AAEnC,EAAA,IAAMC,UAAU,GAAG,OAAO/V,EAAE,KAAK,UAAU,GAAGA,EAAE,CAACiL,OAAO,CAAClO,QAAQ,CAAC,GAAGiD,EAAE,CAAA;AAEvE,EAAA,IAAA7B,IAAA,GAA2B,OAAO4X,UAAU,KAAK,QAAQ,GAAGvW,SAAS,CAACuW,UAAU,CAAC,GAAGA,UAAU;IAA5E3W,IAAI,GAAAjB,IAAA,CAAdmB,QAAQ,CAAA;AAChB;EACA,IAAM0W,WAAW,GAAG5W,IAAI,GAAGyM,SAAS,CAACzM,IAAI,CAAC,GAAG,EAAE,CAAA;AAC/C,EAAA,IAAM4P,KAAK,GAAGgH,WAAW,GAAGhG,SAAS,CAAC/E,OAAO,CAAClO,QAAQ,CAACuC,QAAQ,EAAE0W,WAAW,CAAC,GAAG,IAAI,CAAA;AAEpF,EAAA,IAAMC,YAAY,GAAGjH,KAAK,IAAInK,QAAQ,GAAGA,QAAQ,CAACmK,KAAK,EAAE/D,OAAO,CAAClO,QAAQ,CAAC,GAAG,KAAK,CAAA;EAElF,IAAMmZ,IAAU,GAAG,MAAM,CAAA;EACzB,IAAMC,UAAU,GAAApa,QAAA,CAAA;AACd,IAAA,cAAc,EAAEka,YAAY,GAAGC,IAAI,GAAG,KAAA;AAAK,GAAA,EACxCL,IAAI,CACR,CAAA;AAED,EAAA,oBAAOpE,KAAA,CAAAlT,aAAA,CAAC4W,IAAI,EAAApZ,QAAA,CAAA;AAACiE,IAAAA,EAAE,EAAEA,EAAAA;GAAQmW,EAAAA,UAAU,CAAG,CAAC,CAAA;AACzC;;ACpCA;AACO,SAASC,KAAKA,CAAClY,KAA0B,EAAEkB,IAAc,EAAO;EACrE,IAAI,CAAClB,KAAK,EAAE;AACV,IAAA,OAAOA,KAAK,CAAA;AACd,GAAA;AACA,EAAA,IAAM5B,MAAM,GAAG8C,IAAI,CAAC9C,MAAM,CAAA;EAC1B,IAAI,CAACA,MAAM,EAAE;AACX,IAAA,OAAOY,SAAS,CAAA;AAClB,GAAA;EACA,IAAImG,GAAG,GAAGnF,KAAK,CAAA;AACf,EAAA,KAAK,IAAI9B,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGE,MAAM,IAAI,CAAC,CAAC+G,GAAG,EAAE,EAAEjH,CAAC,EAAE;AACxCiH,IAAAA,GAAG,GAAGA,GAAG,CAACjE,IAAI,CAAChD,CAAC,CAAC,CAAC,CAAA;AACpB,GAAA;AACA,EAAA,OAAOiH,GAAG,CAAA;AACZ,CAAA;;AAEA;AACA,IAAMgT,WAAW,GAAG,UAACC,SAAiB,EAAK;AACzC,EAAA,IAAMC,QAAQ,GAAG,UAACzY,KAAc,EAAK;AACnC,IAAA,OAAOA,KAAK,KAAK,IAAI,IAAI,OAAOA,KAAK,KAAK,QAAQ,IAAI,CAAC,CAACsY,KAAK,CAACtY,KAAK,EAAE,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,CAACsY,KAAK,CAACtY,KAAK,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAA;GACjH,CAAA;AAED,EAAA,IAAM0Y,SAAS,GAAG,UAACtY,KAAU,EAAK;IAChC,IAAMuY,MAAM,GAAGL,KAAK,CAAClY,KAAK,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAA;AACvC,IAAA,IAAI,CAACqY,QAAQ,CAACE,MAAM,CAAC,EAAE;AACrB,MAAA,MAAM,IAAItK,KAAK,CAAqCmK,mCAAAA,GAAAA,SAAS,gDAA2C,CAAC,CAAA;AAC3G,KAAA;AACA,IAAA,OAAOG,MAAM,CAAA;GACd,CAAA;AAED,EAAA,IAAM5O,WAAW,GAAG,UAAI3J,KAAU,EAAA;IAAA,OAA2BkY,KAAK,CAACI,SAAS,CAACtY,KAAK,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC,CAAA;AAAA,GAAA,CAAA;AAClG,EAAA,IAAMwY,SAAS,GAAG,UAACxY,KAAU,EAAA;IAAA,OAAakY,KAAK,CAACI,SAAS,CAACtY,KAAK,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAA;AAAA,GAAA,CAAA;AAC7E,EAAA,IAAMyY,SAAS,GAAG,UAACzY,KAAU,EAAA;AAAA,IAAA,OAAakY,KAAK,CAACI,SAAS,CAACtY,KAAK,CAAC,EAAE,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC,CAAA;AAAA,GAAA,CAAA;AACzF,EAAA,IAAM0Y,OAAO,GAAG,UAAC1Y,KAAU,EAAA;AAAA,IAAA,OAAakY,KAAK,CAACI,SAAS,CAACtY,KAAK,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,CAAA;AAAA,GAAA,CAAA;EAErF,OAAO;AACL0Y,IAAAA,OAAO,EAAPA,OAAO;AACPF,IAAAA,SAAS,EAATA,SAAS;AACTC,IAAAA,SAAS,EAATA,SAAS;AACTH,IAAAA,SAAS,EAATA,SAAS;AACT3O,IAAAA,WAAW,EAAXA,WAAAA;GACD,CAAA;AACH,CAAC;;ACtBD,IAAiBgP,QAAQ,GAAKC,YAAY,CAAlCC,OAAO,CAAA;AAEf,SAASC,0BAA0BA,CAAIrT,KAAyB,EAAE;AAChE,EAAA,IAAQsT,KAAK,GAAkEtT,KAAK,CAA5EsT,KAAK;IAAEjZ,OAAO,GAAyD2F,KAAK,CAArE3F,OAAO;IAAElB,iBAAiB,GAAsC6G,KAAK,CAA5D7G,iBAAiB;IAAEoa,UAAU,GAA0BvT,KAAK,CAAzCuT,UAAU;IAAEhG,QAAQ,GAAgBvN,KAAK,CAA7BuN,QAAQ;IAAEoF,SAAS,GAAK3S,KAAK,CAAnB2S,SAAS,CAAA;AAC1E,EAAA,IAAAa,YAAA,GAAwBd,WAAW,CAACC,SAAS,CAAC;IAAtCzO,WAAW,GAAAsP,YAAA,CAAXtP,WAAW,CAAA;;AAEnB;AACA,EAAA,IAAMuP,WAAW,GAAGH,KAAK,CAACI,SAAS,CAAC,YAAM;AACxC;IACA,IAAAC,YAAA,GAKIzP,WAAW,CAAIoP,KAAK,CAACM,QAAQ,EAAE,CAAC;MAJxBC,eAAe,GAAAF,YAAA,CAAzBhY,QAAQ;MACAmY,aAAa,GAAAH,YAAA,CAArB7Z,MAAM;MACAia,WAAW,GAAAJ,YAAA,CAAjBjY,IAAI;MACGsY,YAAY,GAAAL,YAAA,CAAnBpZ,KAAK,CAAA;;AAGP;AACA,IAAA,IAAA0Z,iBAAA,GAKI5Z,OAAO,CAACjB,QAAQ;MAJR8a,iBAAiB,GAAAD,iBAAA,CAA3BtY,QAAQ;MACAwY,eAAe,GAAAF,iBAAA,CAAvBna,MAAM;MACAsa,aAAa,GAAAH,iBAAA,CAAnBvY,IAAI;MACG2Y,cAAc,GAAAJ,iBAAA,CAArB1Z,KAAK,CAAA;;AAGP;IACA,IACEF,OAAO,CAAChB,MAAM,KAAK,MAAM,KACxB6a,iBAAiB,KAAKL,eAAe,IACpCM,eAAe,KAAKL,aAAa,IACjCM,aAAa,KAAKL,WAAW,IAC7BM,cAAc,KAAKL,YAAY,CAAC,EAClC;MACA3Z,OAAO,CAAC8D,IAAI,CACV;AACExC,QAAAA,QAAQ,EAAEkY,eAAe;AACzB/Z,QAAAA,MAAM,EAAEga,aAAa;AACrBpY,QAAAA,IAAI,EAAEqY,WAAAA;OACP,EACDC,YACF,CAAC,CAAA;AACH,KAAA;AACF,GAAC,CAAC,CAAA;AAEF,EAAA,IAAMM,oBAAoB,GAAG,UAAClT,IAAmB,EAAwC;AAAA,IAAA,IAAtC9H,gBAAyB,GAAAZ,SAAA,CAAAC,MAAA,GAAA,CAAA,IAAAD,SAAA,CAAA,CAAA,CAAA,KAAAa,SAAA,GAAAb,SAAA,CAAA,CAAA,CAAA,GAAG,KAAK,CAAA;AAClF,IAAA,IAAQU,QAAQ,GAAagI,IAAI,CAAzBhI,QAAQ;MAAEC,MAAM,GAAK+H,IAAI,CAAf/H,MAAM,CAAA;AACxBF,IAAAA,iBAAiB,CAACC,QAAQ,EAAEC,MAAM,EAAEC,gBAAgB,CAAC,CAAA;GACtD,CAAA;;AAED;EACA,IAAMiV,QAAQ,GAAG,YAAA;AAAA,IAAA,OAAMlU,OAAO,CAAC2I,MAAM,CAACsR,oBAAoB,CAAC,CAAA;AAAA,GAAA,CAAA;AAE3D9F,EAAAA,eAAe,CAAC,YAAM;AACpB,IAAA,OAAO,YAAM;AACXD,MAAAA,QAAQ,EAAE,CAAA;AACVkF,MAAAA,WAAW,EAAE,CAAA;KACd,CAAA;GACF,EAAE,EAAE,CAAC,CAAA;AAEN,EAAA,IAAI,CAACzT,KAAK,CAACuU,YAAY,EAAE;AACvB;AACAD,IAAAA,oBAAoB,CAAC;MAAElb,QAAQ,EAAEiB,OAAO,CAACjB,QAAQ;MAAEC,MAAM,EAAEgB,OAAO,CAAChB,MAAAA;KAAQ,EAAE,IAAI,CAAC,CAAA;AACpF,GAAA;AAEA,EAAA,IAAIka,UAAU,EAAE;IACd,oBAAOzF,KAAA,CAAAlT,aAAA,CAAAkT,KAAA,CAAA0G,QAAA,EAAGjH,IAAAA,EAAAA,QAAW,CAAC,CAAA;AACxB,GAAA;AACA,EAAA,IAAIkH,YAA6B,CAAA;AACjC,EAAA,IAAI,OAAOlH,QAAQ,KAAK,UAAU,EAAE;IAClCkH,YAAY,GAAGlH,QAAQ,EAAE,CAAA;AAC3B,GAAC,MAAM;AACLkH,IAAAA,YAAY,GAAGlH,QAAQ,CAAA;AACzB,GAAA;AAEA,EAAA,oBAAOO,KAAA,CAAAlT,aAAA,CAACoT,MAAM,EAAA;AAAC3T,IAAAA,OAAO,EAAEA,OAAAA;AAAQ,GAAA,EAAEoa,YAAqB,CAAC,CAAA;AAC1D,CAAA;AAEA,SAASC,kBAAkBA,CAAuBlb,IAAe,EAAE;AACjE,EAAA,IAAMmb,kBAAkB,GAAG,UAACC,QAAa,EAAA;IAAA,OAAM;AAC7Czb,MAAAA,iBAAiB,EAAE,UAACC,QAAkB,EAAEC,MAAc,EAAEC,gBAAyB,EAAA;QAAA,OAC/Esb,QAAQ,CAACzb,iBAAiB,CAACC,QAAQ,EAAEC,MAAM,EAAEC,gBAAgB,CAAC,CAAC,CAAA;AAAA,OAAA;KAClE,CAAA;GAAC,CAAA;AACF,EAAA,IAAMub,eAAe,GAAG/G,KAAK,CAACgH,IAAI,CAACzB,0BAA6B,CAAC,CAAA;AAEjE,EAAA,IAAM0B,0BAA0B,GAAG,UAAC/U,KAAU,EAAK;AACjD,IAAA,IAAMmS,OAAO,GAAGnS,KAAK,CAACsH,OAAO,IAAI0N,iBAAiB,CAAA;IAElD,oBACElH,KAAA,CAAAlT,aAAA,CAACuX,OAAO,CAAC8C,QAAQ,EACd,IAAA,EAAA,UAAAza,IAAA,EAAA;AAAA,MAAA,IAAG8Y,KAAK,GAAA9Y,IAAA,CAAL8Y,KAAK,CAAA;AAAA,MAAA,oBAAYxF,KAAA,CAAAlT,aAAA,CAACia,eAAe,EAAAzc,QAAA,CAAA;AAACkb,QAAAA,KAAK,EAAEA,KAAM;AAACX,QAAAA,SAAS,EAAEnZ,IAAAA;OAAUwG,EAAAA,KAAK,CAAG,CAAC,CAAA;AAAA,KAClE,CAAC,CAAA;GAEtB,CAAA;;AAED;EACA,IAAIxG,IAAI,KAAK,gBAAgB,EAAE;IAC7B,OAAO0Z,QAAQ,CAAC,IAAI,EAAEyB,kBAAkB,CAAC,CAACI,0BAA0B,CAAC,CAAA;AACvE,GAAA;EACA,IAAIvb,IAAI,KAAK,OAAO,EAAE;IACpB,OAAO4Z,OAAO,CAAC,IAAI,EAAEuB,kBAAkB,CAAC,CAACI,0BAA0B,CAAC,CAAA;AACtE,GAAC,MAAM;AACL,IAAA,MAAM,IAAIvM,KAAK,CAAC,oBAAoB,CAAC,CAAA;AACvC,GAAA;AACF;;AC1HA;AACO,SAAS0M,gBAAgBA,CAAC7a,OAAgB,EAAE;EACjD,OAAO,UAAS8a,CAAM,EAAE;IACtB,OAAO,UAASC,IAAS,EAAE;MACzB,OAAO,UAAS/b,MAAqB,EAAE;AACrC,QAAA,IAAIA,MAAM,CAACG,IAAI,KAAKN,UAAU,CAACmc,mBAAmB,EAAE;UAClD,OAAOD,IAAI,CAAC/b,MAAM,CAAC,CAAA;AACrB,SAAA;AACA,QAAA,IAAAic,eAAA,GAAsCjc,MAAM,CAApCK,OAAO;UAAI6b,MAAM,GAAAD,eAAA,CAANC,MAAM;UAAEnU,IAAI,GAAAkU,eAAA,CAAJlU,IAAI,CAAA;QAC/B,IAAImU,MAAM,IAAIlb,OAAO,EAAE;AAAA,UAAA,IAAAG,IAAA,CAAA;AACrB,UAAA,CAAAA,IAAA,GAACH,OAAO,EAASkb,MAAM,CAAC,CAAAtc,KAAA,CAAAuB,IAAA,EAAI4G,IAAI,CAAC,CAAA;AACnC,SAAA;OACD,CAAA;KACF,CAAA;GACF,CAAA;AACH;;ACfaoU,IAAAA,aAAa,GAAGpb,mBAAmB;;ICwCnCya,eAAe,GAAGH,kBAAkB,CAAC,OAAO,EAAC;IAC7Ce,gBAAgB,GAAGf,kBAAkB,CAAC,gBAAgB;;;;"}
diff --git a/packages/horizon-router/connectRouter/package.json b/packages/horizon-router/connectRouter/package.json
new file mode 100644
index 00000000..0c8f9fe5
--- /dev/null
+++ b/packages/horizon-router/connectRouter/package.json
@@ -0,0 +1,9 @@
+{
+  "module": "./esm/connectRouter.js",
+  "main": "./cjs/connectRouter.js",
+  "types": "./@types/router/index2.d.ts",
+  "peerDependencies": {
+    "react-redux": "^6.0.0 || ^7.1.0",
+    "redux": "^3.6.0 || ^4.0.0"
+  }
+}
diff --git a/packages/horizon-router/jest.config.js b/packages/horizon-router/jest.config.js
new file mode 100644
index 00000000..2c23c4c0
--- /dev/null
+++ b/packages/horizon-router/jest.config.js
@@ -0,0 +1,8 @@
+export default {
+  preset: "ts-jest",
+  testMatch: ["**/__tests__/*.test.[jt]s?(x)"],
+  globals: {
+    __DEV__: true,
+  },
+  testEnvironment: 'jsdom'
+};
diff --git a/packages/horizon-router/package.json b/packages/horizon-router/package.json
new file mode 100644
index 00000000..379046a5
--- /dev/null
+++ b/packages/horizon-router/package.json
@@ -0,0 +1,93 @@
+{
+  "name": "@cloudsop/horizon-router",
+  "version": "0.0.12",
+  "description": "router for horizon framework, a part of horizon-ecosystem",
+  "main": "./router/cjs/router.js",
+  "module": "./router/esm/router.js",
+  "types": "./router/@types/router/index.d.ts",
+  "type": "module",
+  "files": [
+    "/connectRouter",
+    "/router",
+    "README.md"
+  ],
+  "bugs": {
+    "url": "https://open.codehub.huawei.com/innersource/fenghuang/horizon/horizon-ecosystem/issues"
+  },
+  "scripts": {
+    "test": "jest",
+    "build": "rollup -c build.js",
+    "build-types-router": "tsc -p src/router/index.ts --emitDeclarationOnly --declaration --declarationDir ./router/@types --skipLibCheck",
+    "build-types-all": "tsc -p src/router/index2.ts --emitDeclarationOnly --declaration --declarationDir ./connectRouter/@types --skipLibCheck"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://szv-open.codehub.huawei.com/innersource/fenghuang/horizon/horizon-ecosystem.git"
+  },
+  "devDependencies": {
+    "@babel/core": "7.21.3",
+    "@babel/plugin-proposal-class-properties": "7.16.7",
+    "@babel/plugin-proposal-nullish-coalescing-operator": "7.16.7",
+    "@babel/plugin-proposal-object-rest-spread": "7.16.7",
+    "@babel/plugin-proposal-optional-chaining": "7.16.7",
+    "@babel/plugin-syntax-jsx": "7.16.7",
+    "@babel/plugin-transform-arrow-functions": "7.16.7",
+    "@babel/plugin-transform-block-scoped-functions": "7.16.7",
+    "@babel/plugin-transform-block-scoping": "7.16.7",
+    "@babel/plugin-transform-classes": "7.16.7",
+    "@babel/plugin-transform-computed-properties": "7.16.7",
+    "@babel/plugin-transform-destructuring": "7.16.7",
+    "@babel/plugin-transform-for-of": "7.16.7",
+    "@babel/plugin-transform-literals": "7.16.7",
+    "@babel/plugin-transform-object-assign": "7.16.7",
+    "@babel/plugin-transform-object-super": "7.16.7",
+    "@babel/plugin-transform-parameters": "7.16.7",
+    "@babel/plugin-transform-react-jsx": "7.16.7",
+    "@babel/plugin-transform-react-jsx-source": "^7.16.7",
+    "@babel/plugin-transform-runtime": "7.16.7",
+    "@babel/plugin-transform-shorthand-properties": "7.16.7",
+    "@babel/plugin-transform-spread": "7.16.7",
+    "@babel/plugin-transform-template-literals": "7.16.7",
+    "@babel/preset-env": "7.16.7",
+    "@babel/preset-typescript": "^7.16.7",
+    "@cloudsop/horizon": "0.0.52",
+    "@rollup/plugin-babel": "^6.0.3",
+    "@rollup/plugin-node-resolve": "^15.1.0",
+    "@testing-library/jest-dom": "^5.16.5",
+    "@testing-library/react": "^14.0.0",
+    "@testing-library/user-event": "^14.4.3",
+    "@types/jest": "^29.2.3",
+    "@types/react": "18.0.25",
+    "@types/react-redux": "7.0.0",
+    "jest": "29.3.1",
+    "jest-environment-jsdom": "^29.5.0",
+    "jsdom": "^21.1.1",
+    "prettier": "2.8.8",
+    "react-redux": "^3.8.1 || ^4.0.0",
+    "rollup": "2.79.1",
+    "rollup-plugin-execute": "^1.1.1",
+    "ts-jest": "29.0.3",
+    "typescript": "4.9.3"
+  },
+  "dependencies": {
+    "@cloudsop/horizon": "^0.0.52",
+    "react": "18.2.0",
+    "react-dom": "18.2.0"
+  },
+  "browserslist": {
+    "production": [
+      ">0.2%",
+      "not dead",
+      "not op_mini all"
+    ],
+    "development": [
+      "last 1 chrome version",
+      "last 1 firefox version",
+      "last 1 safari version"
+    ]
+  },
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "engineStrict": true
+}
diff --git a/packages/horizon-router/router/@types/connect-router/actions.d.ts b/packages/horizon-router/router/@types/connect-router/actions.d.ts
new file mode 100644
index 00000000..965f7ee7
--- /dev/null
+++ b/packages/horizon-router/router/@types/connect-router/actions.d.ts
@@ -0,0 +1,25 @@
+import { Action, Path } from '../history/types';
+type Location = Partial<Path>;
+export declare enum ActionName {
+    LOCATION_CHANGE = "$horizon-router/LOCATION_CHANGE",
+    CALL_HISTORY_METHOD = "$horizon-router/CALL_HISTORY_METHOD"
+}
+export type ActionMessage = {
+    type: ActionName.LOCATION_CHANGE;
+    payload: {
+        location: Location;
+        action: Action;
+        isFirstRendering: boolean;
+    };
+} | {
+    type: ActionName.CALL_HISTORY_METHOD;
+    payload: {
+        method: string;
+        args: any;
+    };
+};
+export declare const onLocationChanged: (location: Location, action: Action, isFirstRendering?: boolean) => ActionMessage;
+export declare const push: (...args: any) => ActionMessage;
+export declare const replace: (...args: any) => ActionMessage;
+export declare const go: (...args: any) => ActionMessage;
+export {};
diff --git a/packages/horizon-router/router/@types/connect-router/dispatch.d.ts b/packages/horizon-router/router/@types/connect-router/dispatch.d.ts
new file mode 100644
index 00000000..48424699
--- /dev/null
+++ b/packages/horizon-router/router/@types/connect-router/dispatch.d.ts
@@ -0,0 +1,3 @@
+import { ActionMessage } from './actions';
+import { History } from '../history/types';
+export declare function routerMiddleware(history: History): (_: any) => (next: any) => (action: ActionMessage) => any;
diff --git a/packages/horizon-router/router/@types/connect-router/index.d.ts b/packages/horizon-router/router/@types/connect-router/index.d.ts
new file mode 100644
index 00000000..38b43283
--- /dev/null
+++ b/packages/horizon-router/router/@types/connect-router/index.d.ts
@@ -0,0 +1,11 @@
+export { getConnectedRouter } from './connectedRouter';
+export declare const connectRouter: (history: import("../router").History<unknown>) => (state?: {
+    location: Partial<import("../router").Location<unknown>> & {
+        query?: Record<string, any>;
+    };
+    action: import("../history/types").Action;
+}, { type, payload }?: {
+    type?: import("./actions").ActionName;
+    payload?: any;
+}) => any;
+export { routerMiddleware } from './dispatch';
diff --git a/packages/horizon-router/router/@types/connect-router/reducer.d.ts b/packages/horizon-router/router/@types/connect-router/reducer.d.ts
new file mode 100644
index 00000000..3de2b851
--- /dev/null
+++ b/packages/horizon-router/router/@types/connect-router/reducer.d.ts
@@ -0,0 +1,16 @@
+import { ActionName } from './actions';
+import { Action, History } from '../history/types';
+import { Location } from '../router';
+type LocationWithQuery = Partial<Location> & {
+    query?: Record<string, any>;
+};
+type InitRouterState = {
+    location: LocationWithQuery;
+    action: Action;
+};
+type Payload = {
+    type?: ActionName;
+    payload?: any;
+};
+export declare function createConnectRouter(): (history: History) => (state?: InitRouterState, { type, payload }?: Payload) => any;
+export {};
diff --git a/packages/horizon-router/router/@types/history/baseHistory.d.ts b/packages/horizon-router/router/@types/history/baseHistory.d.ts
new file mode 100644
index 00000000..74892c1e
--- /dev/null
+++ b/packages/horizon-router/router/@types/history/baseHistory.d.ts
@@ -0,0 +1,10 @@
+import { HistoryProps, Listener, Navigation, Prompt } from './types';
+import transitionManager from './transitionManager';
+export declare function getBaseHistory<S>(transitionManager: transitionManager<S>, setListener: (delta: number) => void, browserHistory: History): {
+    go: (step: number) => void;
+    goBack: () => void;
+    goForward: () => void;
+    listen: (listener: Listener<S>) => () => void;
+    block: (prompt?: Prompt<S>) => () => void;
+    getUpdateStateFunc: (historyProps: HistoryProps<S>) => (nextState: Navigation<S> | undefined) => void;
+};
diff --git a/packages/horizon-router/router/@types/history/browerHistory.d.ts b/packages/horizon-router/router/@types/history/browerHistory.d.ts
new file mode 100644
index 00000000..000d1ad2
--- /dev/null
+++ b/packages/horizon-router/router/@types/history/browerHistory.d.ts
@@ -0,0 +1,8 @@
+import { BaseOption, DefaultStateType, History } from './types';
+export type BrowserHistoryOption = {
+    /**
+     * forceRefresh为True时跳转时会强制刷新页面
+     */
+    forceRefresh?: boolean;
+} & BaseOption;
+export declare function createBrowserHistory<S = DefaultStateType>(options?: BrowserHistoryOption): History<S>;
diff --git a/packages/horizon-router/router/@types/history/dom.d.ts b/packages/horizon-router/router/@types/history/dom.d.ts
new file mode 100644
index 00000000..b889eef2
--- /dev/null
+++ b/packages/horizon-router/router/@types/history/dom.d.ts
@@ -0,0 +1,4 @@
+export declare function isBrowser(): boolean;
+export declare function getDefaultConfirmation(message: string, callBack: (result: boolean) => void): void;
+export declare function isSupportHistory(): boolean;
+export declare function isSupportsPopState(): boolean;
diff --git a/packages/horizon-router/router/@types/history/hashHistory.d.ts b/packages/horizon-router/router/@types/history/hashHistory.d.ts
new file mode 100644
index 00000000..a8cf1959
--- /dev/null
+++ b/packages/horizon-router/router/@types/history/hashHistory.d.ts
@@ -0,0 +1,7 @@
+import { BaseOption, DefaultStateType, History } from './types';
+export type urlHashType = 'slash' | 'noslash';
+type HashHistoryOption = {
+    hashType?: urlHashType;
+} & BaseOption;
+export declare function createHashHistory<S = DefaultStateType>(option?: HashHistoryOption): History<S>;
+export {};
diff --git a/packages/horizon-router/router/@types/history/transitionManager.d.ts b/packages/horizon-router/router/@types/history/transitionManager.d.ts
new file mode 100644
index 00000000..45edc03f
--- /dev/null
+++ b/packages/horizon-router/router/@types/history/transitionManager.d.ts
@@ -0,0 +1,11 @@
+import { Action, CallBackFunc, ConfirmationFunc, Listener, Location, Navigation, Prompt, TManager } from './types';
+declare class TransitionManager<S> implements TManager<S> {
+    private prompt;
+    private listeners;
+    constructor();
+    setPrompt(prompt: Prompt<S>): () => void;
+    addListener(func: Listener<S>): () => void;
+    notifyListeners(args: Navigation<S>): void;
+    confirmJumpTo(location: Location<S>, action: Action, userConfirmationFunc: ConfirmationFunc, callBack: CallBackFunc): void;
+}
+export default TransitionManager;
diff --git a/packages/horizon-router/router/@types/history/types.d.ts b/packages/horizon-router/router/@types/history/types.d.ts
new file mode 100644
index 00000000..6a8a8636
--- /dev/null
+++ b/packages/horizon-router/router/@types/history/types.d.ts
@@ -0,0 +1,56 @@
+export type BaseOption = {
+    basename?: string;
+    getUserConfirmation?: ConfirmationFunc;
+};
+export interface HistoryProps<T = unknown> {
+    readonly action: Action;
+    readonly location: Location<T>;
+    length: number;
+}
+export interface History<T = unknown> extends HistoryProps<T> {
+    createHref(path: Partial<Path>): string;
+    push(to: To, state?: T): void;
+    replace(to: To, state?: T): void;
+    listen(listener: Listener<T>): () => void;
+    block(prompt: Prompt<T>): () => void;
+    go(index: number): void;
+    goBack(): void;
+    goForward(): void;
+}
+export declare enum Action {
+    pop = "POP",
+    push = "PUSH",
+    replace = "REPLACE"
+}
+export declare enum EventType {
+    PopState = "popstate",
+    HashChange = "hashchange"
+}
+export type Path = {
+    pathname: string;
+    search: string;
+    hash: string;
+};
+export type HistoryState<T> = {
+    state?: T;
+    key: string;
+};
+export type DefaultStateType = unknown;
+export type Location<T = unknown> = Path & HistoryState<T>;
+export type To = string | Partial<Path>;
+export interface Listener<T = unknown> {
+    (navigation: Navigation<T>): void;
+}
+export interface Navigation<T = unknown> {
+    action: Action;
+    location: Location<T>;
+}
+export type Prompt<S> = string | boolean | null | ((location: Location<S>, action: Action) => void);
+export type CallBackFunc = (isJump: boolean) => void;
+export type ConfirmationFunc = (message: string, callBack: CallBackFunc) => void;
+export interface TManager<S> {
+    setPrompt(next: Prompt<S>): () => void;
+    addListener(func: (navigation: Navigation<S>) => void): () => void;
+    notifyListeners(args: Navigation<S>): void;
+    confirmJumpTo(location: Location<S>, action: Action, userConfirmationFunc: ConfirmationFunc, callBack: CallBackFunc): void;
+}
diff --git a/packages/horizon-router/router/@types/history/utils.d.ts b/packages/horizon-router/router/@types/history/utils.d.ts
new file mode 100644
index 00000000..adee264f
--- /dev/null
+++ b/packages/horizon-router/router/@types/history/utils.d.ts
@@ -0,0 +1,14 @@
+import { Action, Location, Path, To } from './types';
+export declare function createPath(path: Partial<Path>): string;
+export declare function parsePath(url: string): Partial<Path>;
+export declare function createLocation<S>(current: string | Location, to: To, state?: S, key?: string): Readonly<Location<S>>;
+export declare function isLocationEqual(p1: Partial<Path>, p2: Partial<Path>): boolean;
+export declare function addHeadSlash(path: string): string;
+export declare function stripHeadSlash(path: string): string;
+export declare function normalizeSlash(path: string): string;
+export declare function hasBasename(path: string, prefix: string): Boolean;
+export declare function stripBasename(path: string, prefix: string): string;
+export declare function createMemoryRecord<T, S>(initVal: S, fn: (arg: S) => T): {
+    getDelta: (to: S, form: S) => number;
+    addRecord: (current: S, newRecord: S, action: Action) => void;
+};
diff --git a/packages/horizon-router/router/@types/history/waring.d.ts b/packages/horizon-router/router/@types/history/waring.d.ts
new file mode 100644
index 00000000..18f09cb7
--- /dev/null
+++ b/packages/horizon-router/router/@types/history/waring.d.ts
@@ -0,0 +1,2 @@
+declare function warning(condition: any, message: string): void;
+export default warning;
diff --git a/packages/horizon-router/router/@types/router/BrowserRouter.d.ts b/packages/horizon-router/router/@types/router/BrowserRouter.d.ts
new file mode 100644
index 00000000..b91dd697
--- /dev/null
+++ b/packages/horizon-router/router/@types/router/BrowserRouter.d.ts
@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+import { ConfirmationFunc } from '../history/types';
+export type BaseRouterProps = {
+    basename: string;
+    getUserConfirmation: ConfirmationFunc;
+    children?: ReactNode;
+};
+export type BrowserRouterProps = BaseRouterProps & {
+    forceRefresh: boolean;
+};
+declare function BrowserRouter<P extends Partial<BrowserRouterProps>>(props: P): JSX.Element;
+export default BrowserRouter;
diff --git a/packages/horizon-router/router/@types/router/HashRouter.d.ts b/packages/horizon-router/router/@types/router/HashRouter.d.ts
new file mode 100644
index 00000000..ff09ad81
--- /dev/null
+++ b/packages/horizon-router/router/@types/router/HashRouter.d.ts
@@ -0,0 +1,7 @@
+import { BaseRouterProps } from './BrowserRouter';
+import { urlHashType } from '../history/hashHistory';
+export type HashRouterProps = BaseRouterProps & {
+    hashType: urlHashType;
+};
+declare function HashRouter<P extends Partial<HashRouterProps>>(props: P): JSX.Element;
+export default HashRouter;
diff --git a/packages/horizon-router/router/@types/router/Link.d.ts b/packages/horizon-router/router/@types/router/Link.d.ts
new file mode 100644
index 00000000..48ec51d8
--- /dev/null
+++ b/packages/horizon-router/router/@types/router/Link.d.ts
@@ -0,0 +1,18 @@
+import * as React from 'react';
+import { Location } from './index';
+export type LinkProps = {
+    component?: React.ComponentType<any>;
+    to: Partial<Location> | string | ((location: Location) => string | Partial<Location>);
+    replace?: boolean;
+    tag?: string;
+    /**
+     * @deprecated
+     * React16以后不再需要该属性
+     **/
+    innerRef?: React.Ref<HTMLAnchorElement>;
+} & React.AnchorHTMLAttributes<HTMLAnchorElement>;
+declare function Link<P extends LinkProps>(props: P): React.DOMElement<{
+    href: string;
+    onClick: (event: React.MouseEvent<HTMLAnchorElement>) => void;
+} & Omit<P, "replace" | "to" | "component" | "onClick" | "target">, Element>;
+export default Link;
diff --git a/packages/horizon-router/router/@types/router/NavLink.d.ts b/packages/horizon-router/router/@types/router/NavLink.d.ts
new file mode 100644
index 00000000..a7181526
--- /dev/null
+++ b/packages/horizon-router/router/@types/router/NavLink.d.ts
@@ -0,0 +1,10 @@
+import type { LinkProps } from './Link';
+import { Location } from './index';
+import { Matched } from './matcher/parser';
+type NavLinkProps = {
+    to: Partial<Location> | string | ((location: Location) => string | Partial<Location>);
+    isActive?: (match: Matched | null, location: Location) => boolean;
+    [key: string]: any;
+} & LinkProps;
+declare function NavLink<P extends NavLinkProps>(props: P): JSX.Element;
+export default NavLink;
diff --git a/packages/horizon-router/router/@types/router/Prompt.d.ts b/packages/horizon-router/router/@types/router/Prompt.d.ts
new file mode 100644
index 00000000..84752997
--- /dev/null
+++ b/packages/horizon-router/router/@types/router/Prompt.d.ts
@@ -0,0 +1,8 @@
+import { Location } from './index';
+import { Action } from '../history/types';
+type PromptProps = {
+    message?: string | ((location: Partial<Location>, action: Action) => void);
+    when?: boolean | ((location: Partial<Location>) => boolean);
+};
+declare function Prompt<P extends PromptProps>(props: P): JSX.Element;
+export default Prompt;
diff --git a/packages/horizon-router/router/@types/router/Redirect.d.ts b/packages/horizon-router/router/@types/router/Redirect.d.ts
new file mode 100644
index 00000000..e1569e31
--- /dev/null
+++ b/packages/horizon-router/router/@types/router/Redirect.d.ts
@@ -0,0 +1,13 @@
+import { Matched } from './matcher/parser';
+import { Location } from './index';
+export type RedirectProps = {
+    to: string | Partial<Location>;
+    push?: boolean;
+    path?: string;
+    from?: string;
+    exact?: boolean;
+    strict?: boolean;
+    readonly computed?: Matched | null;
+};
+declare function Redirect<P extends RedirectProps>(props: P): JSX.Element;
+export default Redirect;
diff --git a/packages/horizon-router/router/@types/router/Route.d.ts b/packages/horizon-router/router/@types/router/Route.d.ts
new file mode 100644
index 00000000..b8939efb
--- /dev/null
+++ b/packages/horizon-router/router/@types/router/Route.d.ts
@@ -0,0 +1,23 @@
+import * as React from 'react';
+import { History, Location } from './index';
+import { Matched } from './matcher/parser';
+import { GetURLParams } from './matcher/types';
+export type RouteComponentProps<P extends Record<string, any> = {}, S = unknown> = RouteChildrenProps<P, S>;
+export type RouteChildrenProps<P extends Record<string, any> = {}, S = unknown> = {
+    history: History<S>;
+    location: Location<S>;
+    match: Matched<P> | null;
+};
+export type RouteProps<P extends Record<string, any> = {}, Path extends string = string> = {
+    location?: Location;
+    component?: React.ComponentType<RouteComponentProps<P>> | React.ComponentType<any> | undefined;
+    children?: ((props: RouteChildrenProps<P>) => React.ReactNode) | React.ReactNode;
+    render?: (props: RouteComponentProps<P>) => React.ReactNode;
+    path?: Path | Path[];
+    exact?: boolean;
+    sensitive?: boolean;
+    strict?: boolean;
+    computed?: Matched<P>;
+};
+declare function Route<Path extends string, P extends Record<string, any> = GetURLParams<Path>>(props: RouteProps<P, Path>): JSX.Element;
+export default Route;
diff --git a/packages/horizon-router/router/@types/router/Router.d.ts b/packages/horizon-router/router/@types/router/Router.d.ts
new file mode 100644
index 00000000..53751b67
--- /dev/null
+++ b/packages/horizon-router/router/@types/router/Router.d.ts
@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { History } from '../history/types';
+export type RouterProps = {
+    history: History;
+    children?: React.ReactNode;
+};
+declare function Router<P extends RouterProps>(props: P): JSX.Element;
+export default Router;
diff --git a/packages/horizon-router/router/@types/router/Switch.d.ts b/packages/horizon-router/router/@types/router/Switch.d.ts
new file mode 100644
index 00000000..53ea8c32
--- /dev/null
+++ b/packages/horizon-router/router/@types/router/Switch.d.ts
@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { Location } from './index';
+export type SwitchProps = {
+    location?: Location;
+    children?: React.ReactNode;
+};
+declare function Switch<P extends SwitchProps>(props: P): React.ReactElement | null;
+export default Switch;
diff --git a/packages/horizon-router/router/@types/router/__tests__/router.test.d.ts b/packages/horizon-router/router/@types/router/__tests__/router.test.d.ts
new file mode 100644
index 00000000..7b0828bf
--- /dev/null
+++ b/packages/horizon-router/router/@types/router/__tests__/router.test.d.ts
@@ -0,0 +1 @@
+import '@testing-library/jest-dom';
diff --git a/packages/horizon-router/router/@types/router/__tests__/test_app.d.ts b/packages/horizon-router/router/@types/router/__tests__/test_app.d.ts
new file mode 100644
index 00000000..c36ab167
--- /dev/null
+++ b/packages/horizon-router/router/@types/router/__tests__/test_app.d.ts
@@ -0,0 +1,8 @@
+import { History, Location } from '../index';
+export declare let historyHook: History;
+export declare let locationHook: Location;
+export declare const LocationDisplay: () => JSX.Element;
+export declare const Test_Demo: () => JSX.Element;
+export declare const Test_Demo2: () => JSX.Element;
+export declare const Test_Demo3: () => JSX.Element;
+export declare const Test_Demo4: () => JSX.Element;
diff --git a/packages/horizon-router/router/@types/router/context.d.ts b/packages/horizon-router/router/@types/router/context.d.ts
new file mode 100644
index 00000000..8a39bd8c
--- /dev/null
+++ b/packages/horizon-router/router/@types/router/context.d.ts
@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { History, Location } from './index';
+import { Matched } from './matcher/parser';
+export type RouterContextValue = {
+    history: History;
+    location: Location;
+    match: Matched | null;
+};
+declare const RouterContext: import("react").Context<RouterContextValue>;
+export default RouterContext;
diff --git a/packages/horizon-router/router/@types/router/hooks.d.ts b/packages/horizon-router/router/@types/router/hooks.d.ts
new file mode 100644
index 00000000..7ff53865
--- /dev/null
+++ b/packages/horizon-router/router/@types/router/hooks.d.ts
@@ -0,0 +1,8 @@
+import { Matched, Params } from './matcher/parser';
+import { History } from '../history/types';
+import { Location } from './index';
+declare function useHistory<S>(): History<S>;
+declare function useLocation<S>(): Location<S>;
+declare function useParams<P>(): Params<P> | {};
+declare function useRouteMatch<P>(path?: string): Matched<P> | null;
+export { useHistory, useLocation, useParams, useRouteMatch };
diff --git a/packages/horizon-router/router/@types/router/index.d.ts b/packages/horizon-router/router/@types/router/index.d.ts
new file mode 100644
index 00000000..01659cc3
--- /dev/null
+++ b/packages/horizon-router/router/@types/router/index.d.ts
@@ -0,0 +1,20 @@
+import { Location as HLocation } from '../history/types';
+type Location<S = unknown> = Omit<HLocation<S>, 'key'>;
+export { Location };
+export type { History } from '../history/types';
+export { createBrowserHistory } from '../history/browerHistory';
+export { createHashHistory } from '../history/hashHistory';
+export { default as __RouterContext } from './context';
+export { matchPath, generatePath } from './matcher/parser';
+export { useHistory, useLocation, useParams, useRouteMatch } from './hooks';
+export { default as Route } from './Route';
+export { default as Router } from './Router';
+export { default as Switch } from './Switch';
+export { default as Redirect } from './Redirect';
+export { default as Prompt } from './Prompt';
+export { default as withRouter } from './withRouter';
+export { default as HashRouter } from './HashRouter';
+export { default as BrowserRouter } from './BrowserRouter';
+export { default as Link } from './Link';
+export { default as NavLink } from './NavLink';
+export type { RouteComponentProps, RouteChildrenProps, RouteProps } from './Route';
diff --git a/packages/horizon-router/router/@types/router/index2.d.ts b/packages/horizon-router/router/@types/router/index2.d.ts
new file mode 100644
index 00000000..77801836
--- /dev/null
+++ b/packages/horizon-router/router/@types/router/index2.d.ts
@@ -0,0 +1,23 @@
+import { Location as HLocation } from '../history/types';
+type Location<S = unknown> = Omit<HLocation<S>, 'key'>;
+export { Location };
+export type { History } from '../history/types';
+export { createBrowserHistory } from '../history/browerHistory';
+export { createHashHistory } from '../history/hashHistory';
+export { default as __RouterContext } from './context';
+export { matchPath, generatePath } from './matcher/parser';
+export { useHistory, useLocation, useParams, useRouteMatch } from './hooks';
+export { default as Route } from './Route';
+export { default as Router } from './Router';
+export { default as Switch } from './Switch';
+export { default as Redirect } from './Redirect';
+export { default as Prompt } from './Prompt';
+export { default as withRouter } from './withRouter';
+export { default as HashRouter } from './HashRouter';
+export { default as BrowserRouter } from './BrowserRouter';
+export { default as Link } from './Link';
+export { default as NavLink } from './NavLink';
+export type { RouteComponentProps, RouteChildrenProps, RouteProps } from './Route';
+export { connectRouter, routerMiddleware } from '../connect-router';
+export declare const ConnectedRouter: any;
+export declare const ConnectedHRouter: any;
diff --git a/packages/horizon-router/router/@types/router/lifeCycleHook.d.ts b/packages/horizon-router/router/@types/router/lifeCycleHook.d.ts
new file mode 100644
index 00000000..6837c2c0
--- /dev/null
+++ b/packages/horizon-router/router/@types/router/lifeCycleHook.d.ts
@@ -0,0 +1,7 @@
+export type LifeCycleProps = {
+    onMount?: () => void;
+    onUpdate?: (prevProps?: LifeCycleProps) => void;
+    onUnmount?: () => void;
+    data?: any;
+};
+export declare function LifeCycle(props: LifeCycleProps): any;
diff --git a/packages/horizon-router/router/@types/router/matcher/__tests__/lexer.test.d.ts b/packages/horizon-router/router/@types/router/matcher/__tests__/lexer.test.d.ts
new file mode 100644
index 00000000..cb0ff5c3
--- /dev/null
+++ b/packages/horizon-router/router/@types/router/matcher/__tests__/lexer.test.d.ts
@@ -0,0 +1 @@
+export {};
diff --git a/packages/horizon-router/router/@types/router/matcher/__tests__/parser.test.d.ts b/packages/horizon-router/router/@types/router/matcher/__tests__/parser.test.d.ts
new file mode 100644
index 00000000..cb0ff5c3
--- /dev/null
+++ b/packages/horizon-router/router/@types/router/matcher/__tests__/parser.test.d.ts
@@ -0,0 +1 @@
+export {};
diff --git a/packages/horizon-router/router/@types/router/matcher/__tests__/utils.test.d.ts b/packages/horizon-router/router/@types/router/matcher/__tests__/utils.test.d.ts
new file mode 100644
index 00000000..cb0ff5c3
--- /dev/null
+++ b/packages/horizon-router/router/@types/router/matcher/__tests__/utils.test.d.ts
@@ -0,0 +1 @@
+export {};
diff --git a/packages/horizon-router/router/@types/router/matcher/lexer.d.ts b/packages/horizon-router/router/@types/router/matcher/lexer.d.ts
new file mode 100644
index 00000000..6137743a
--- /dev/null
+++ b/packages/horizon-router/router/@types/router/matcher/lexer.d.ts
@@ -0,0 +1,2 @@
+import { Token } from './types';
+export declare function lexer(path: string): Token[];
diff --git a/packages/horizon-router/router/@types/router/matcher/parser.d.ts b/packages/horizon-router/router/@types/router/matcher/parser.d.ts
new file mode 100644
index 00000000..ee672cf9
--- /dev/null
+++ b/packages/horizon-router/router/@types/router/matcher/parser.d.ts
@@ -0,0 +1,18 @@
+import { GetURLParams, Parser, ParserOption } from './types';
+export type Params<P> = {
+    [K in keyof P]?: P[K];
+};
+export type Matched<P = any> = {
+    score: number[];
+    params: Params<P>;
+    path: string;
+    url: string;
+    isExact: boolean;
+};
+export declare function createPathParser<Str extends string>(pathname: Str, option?: ParserOption): Parser<GetURLParams<Str>>;
+export declare function createPathParser<P = unknown>(pathname: string, option?: ParserOption): Parser<P>;
+/**
+ * @description 依次使用pathname与pattern进行匹配，根据匹配分数取得分数最高结果
+ */
+export declare function matchPath<P = any>(pathname: string, pattern: string | string[], option?: ParserOption): Matched<P> | null;
+export declare function generatePath<P = any>(path: string, params: Params<P>): string;
diff --git a/packages/horizon-router/router/@types/router/matcher/types.d.ts b/packages/horizon-router/router/@types/router/matcher/types.d.ts
new file mode 100644
index 00000000..971fbe5b
--- /dev/null
+++ b/packages/horizon-router/router/@types/router/matcher/types.d.ts
@@ -0,0 +1,36 @@
+import { Matched, Params } from './parser';
+export type Token = {
+    type: TokenType;
+    value: string;
+};
+export declare enum TokenType {
+    Delimiter = "delimiter",
+    Static = "static",
+    Param = "param",
+    WildCard = "wildcard",
+    LBracket = "(",
+    RBracket = ")",
+    Pattern = "pattern"
+}
+export interface Parser<P> {
+    regexp: RegExp;
+    keys: string[];
+    parse(url: string): Matched<P> | null;
+    compile(params: Params<P>): string;
+}
+export type ParserOption = {
+    caseSensitive?: boolean;
+    strictMode?: boolean;
+    exact?: boolean;
+};
+type ClearLeading<U extends string> = U extends `/${infer R}` ? ClearLeading<R> : U;
+type ClearTailing<U extends string> = U extends `${infer L}/` ? ClearTailing<L> : U;
+type ParseParam<Param extends string> = Param extends `:${infer R}` ? {
+    [K in R]: string;
+} : {};
+type MergeParams<OneParam extends Record<string, any>, OtherParam extends Record<string, any>> = {
+    readonly [Key in keyof OneParam | keyof OtherParam]?: string;
+};
+type ParseURLString<Str extends string> = Str extends `${infer Param}/${infer Rest}` ? MergeParams<ParseParam<Param>, ParseURLString<ClearLeading<Rest>>> : ParseParam<Str>;
+export type GetURLParams<U extends string> = ParseURLString<ClearLeading<ClearTailing<U>>>;
+export {};
diff --git a/packages/horizon-router/router/@types/router/matcher/utils.d.ts b/packages/horizon-router/router/@types/router/matcher/utils.d.ts
new file mode 100644
index 00000000..8b739ae7
--- /dev/null
+++ b/packages/horizon-router/router/@types/router/matcher/utils.d.ts
@@ -0,0 +1,6 @@
+/**
+ * @description 将url中的//转换为/
+ */
+export declare function cleanPath(path: string): string;
+export declare function scoreCompare(score1: number[], score2: number[]): number;
+export declare function escapeStr(str: string): string;
diff --git a/packages/horizon-router/router/@types/router/withRouter.d.ts b/packages/horizon-router/router/@types/router/withRouter.d.ts
new file mode 100644
index 00000000..b6c398cd
--- /dev/null
+++ b/packages/horizon-router/router/@types/router/withRouter.d.ts
@@ -0,0 +1,3 @@
+import * as React from 'react';
+declare function withRouter<C extends React.ComponentType>(Component: C): (props: any) => JSX.Element;
+export default withRouter;
diff --git a/packages/horizon-router/router/cjs/router.js b/packages/horizon-router/router/cjs/router.js
new file mode 100644
index 00000000..989b246f
--- /dev/null
+++ b/packages/horizon-router/router/cjs/router.js
@@ -0,0 +1,1531 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+function isBrowser() {
+  return typeof window !== 'undefined' && window.document && typeof window.document.createElement === 'function';
+}
+function getDefaultConfirmation(message, callBack) {
+  callBack(window.confirm(message));
+}
+
+// 判断浏览器是否支持pushState方法，pushState是browserHistory实现的基础
+function isSupportHistory() {
+  return isBrowser() && window.history && 'pushState' in window.history;
+}
+
+// 判断浏览器是否支持PopState事件
+function isSupportsPopState() {
+  return window.navigator.userAgent.indexOf('Trident') === -1;
+}
+
+var Action = /*#__PURE__*/function (Action) {
+  Action["pop"] = "POP";
+  Action["push"] = "PUSH";
+  Action["replace"] = "REPLACE";
+  return Action;
+}({});
+var EventType = /*#__PURE__*/function (EventType) {
+  EventType["PopState"] = "popstate";
+  EventType["HashChange"] = "hashchange";
+  return EventType;
+}({});
+
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+
+function createPath(path) {
+  var search = path.search,
+    hash = path.hash;
+  var pathname = path.pathname || '/';
+  if (search && search !== '?') {
+    pathname += search.startsWith('?') ? search : '?' + search;
+  }
+  if (hash && hash !== '#') {
+    pathname += hash.startsWith('#') ? hash : '#' + hash;
+  }
+  return pathname;
+}
+function parsePath(url) {
+  if (!url) {
+    return {};
+  }
+  var parsedPath = {};
+  var hashIdx = url.indexOf('#');
+  if (hashIdx > -1) {
+    parsedPath.hash = url.substring(hashIdx);
+    url = url.substring(0, hashIdx);
+  }
+  var searchIdx = url.indexOf('?');
+  if (searchIdx > -1) {
+    parsedPath.search = url.substring(searchIdx);
+    url = url.substring(0, searchIdx);
+  }
+  if (url) {
+    parsedPath.pathname = url;
+  }
+  return parsedPath;
+}
+function createLocation(current, to, state, key) {
+  var pathname = typeof current === 'string' ? current : current.pathname;
+  var urlObj = typeof to === 'string' ? parsePath(to) : to;
+  // 随机key长度取6
+  var getRandKey = genRandomKey(6);
+  var location = _extends({
+    pathname: pathname,
+    search: '',
+    hash: '',
+    state: state,
+    key: typeof key === 'string' ? key : getRandKey()
+  }, urlObj);
+  if (!location.pathname) {
+    location.pathname = '/';
+  }
+  return location;
+}
+function isLocationEqual(p1, p2) {
+  return p1.pathname === p2.pathname && p1.search === p2.search && p1.hash === p2.hash;
+}
+function addHeadSlash(path) {
+  if (path[0] === '/') {
+    return path;
+  }
+  return '/' + path;
+}
+function stripHeadSlash(path) {
+  if (path[0] === '/') {
+    return path.substring(1);
+  }
+  return path;
+}
+function normalizeSlash(path) {
+  var tempPath = addHeadSlash(path);
+  if (tempPath[tempPath.length - 1] === '/') {
+    return tempPath.substring(0, tempPath.length - 1);
+  }
+  return tempPath;
+}
+function hasBasename(path, prefix) {
+  return path.toLowerCase().indexOf(prefix.toLowerCase()) === 0 && ['/', '?', '#', ''].includes(path.charAt(prefix.length));
+}
+function stripBasename(path, prefix) {
+  return hasBasename(path, prefix) ? path.substring(prefix.length) : path;
+}
+
+// 使用随机生成的Key记录被访问过的URL，当Block被被触发时利用delta值跳转到之前的页面
+function createMemoryRecord(initVal, fn) {
+  var visitedRecord = [fn(initVal)];
+  function getDelta(to, form) {
+    var toIdx = visitedRecord.lastIndexOf(fn(to));
+    if (toIdx === -1) {
+      toIdx = 0;
+    }
+    var fromIdx = visitedRecord.lastIndexOf(fn(form));
+    if (fromIdx === -1) {
+      fromIdx = 0;
+    }
+    return toIdx - fromIdx;
+  }
+  function addRecord(current, newRecord, action) {
+    var curVal = fn(current);
+    var NewVal = fn(newRecord);
+    if (action === Action.push) {
+      var prevIdx = visitedRecord.lastIndexOf(curVal);
+      var newVisitedRecord = visitedRecord.slice(0, prevIdx + 1);
+      newVisitedRecord.push(NewVal);
+      visitedRecord = newVisitedRecord;
+    }
+    if (action === Action.replace) {
+      var _prevIdx = visitedRecord.lastIndexOf(curVal);
+      if (_prevIdx !== -1) {
+        visitedRecord[_prevIdx] = NewVal;
+      }
+    }
+  }
+  return {
+    getDelta: getDelta,
+    addRecord: addRecord
+  };
+}
+function genRandomKey(length) {
+  var end = length + 2;
+  return function () {
+    return Math.random().toString(18).substring(2, end);
+  };
+}
+
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+  }, _typeof(obj);
+}
+
+function _toPrimitive(input, hint) {
+  if (_typeof(input) !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (_typeof(res) !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return _typeof(key) === "symbol" ? key : String(key);
+}
+
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+
+function _createForOfIteratorHelper$1(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$1(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function () {}; return { s: F, n: function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function (e) { throw e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function () { it = it.call(o); }, n: function () { var step = it.next(); normalCompletion = step.done; return step; }, e: function (e) { didErr = true; err = e; }, f: function () { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray$1(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$1(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$1(o, minLen); }
+function _arrayLikeToArray$1(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+var TransitionManager = /*#__PURE__*/function () {
+  function TransitionManager() {
+    _classCallCheck(this, TransitionManager);
+    this.prompt = void 0;
+    this.listeners = void 0;
+    this.prompt = null;
+    this.listeners = [];
+  }
+  _createClass(TransitionManager, [{
+    key: "setPrompt",
+    value: function setPrompt(prompt) {
+      var _this = this;
+      this.prompt = prompt;
+
+      // 清除Prompt
+      return function () {
+        if (_this.prompt === prompt) {
+          _this.prompt = null;
+        }
+      };
+    }
+
+    // 使用发布订阅模式管理history的监听者
+  }, {
+    key: "addListener",
+    value: function addListener(func) {
+      var _this2 = this;
+      var isActive = true;
+      var listener = function (args) {
+        if (isActive) {
+          func(args);
+        }
+      };
+      this.listeners.push(listener);
+      return function () {
+        isActive = false;
+        // 移除对应的监听者
+        _this2.listeners = _this2.listeners.filter(function (item) {
+          return item !== listener;
+        });
+      };
+    }
+  }, {
+    key: "notifyListeners",
+    value: function notifyListeners(args) {
+      var _iterator = _createForOfIteratorHelper$1(this.listeners),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var listener = _step.value;
+          listener(args);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+  }, {
+    key: "confirmJumpTo",
+    value: function confirmJumpTo(location, action, userConfirmationFunc, callBack) {
+      if (this.prompt !== null) {
+        var result = typeof this.prompt === 'function' ? this.prompt(location, action) : this.prompt;
+        if (typeof result === 'string') {
+          typeof userConfirmationFunc === 'function' ? userConfirmationFunc(result, callBack) : callBack(true);
+        } else {
+          callBack(result !== false);
+        }
+      } else {
+        callBack(true);
+      }
+    }
+  }]);
+  return TransitionManager;
+}();
+
+function warning(condition, message) {
+  if (condition) {
+    if (console && typeof console.warn === 'function') {
+      console.warn(message);
+    }
+  }
+}
+
+// 抽取BrowserHistory和HashHistory中相同的方法
+function getBaseHistory(transitionManager, setListener, browserHistory) {
+  function go(step) {
+    browserHistory.go(step);
+  }
+  function goBack() {
+    browserHistory.go(-1);
+  }
+  function goForward() {
+    browserHistory.go(1);
+  }
+  function listen(listener) {
+    var cancel = transitionManager.addListener(listener);
+    setListener(1);
+    return function () {
+      setListener(-1);
+      cancel();
+    };
+  }
+  var isBlocked = false;
+  function block() {
+    var prompt = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    var unblock = transitionManager.setPrompt(prompt);
+    if (!isBlocked) {
+      setListener(1);
+      isBlocked = true;
+    }
+    return function () {
+      if (isBlocked) {
+        isBlocked = false;
+        setListener(-1);
+      }
+      unblock();
+    };
+  }
+  function getUpdateStateFunc(historyProps) {
+    return function (nextState) {
+      if (nextState) {
+        _extends(historyProps, nextState);
+      }
+      historyProps.length = browserHistory.length;
+      var args = {
+        location: historyProps.location,
+        action: historyProps.action
+      };
+      transitionManager.notifyListeners(args);
+    };
+  }
+  return {
+    go: go,
+    goBack: goBack,
+    goForward: goForward,
+    listen: listen,
+    block: block,
+    getUpdateStateFunc: getUpdateStateFunc
+  };
+}
+
+function createBrowserHistory() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var supportHistory = isSupportHistory();
+  var isSupportPopState = isSupportsPopState();
+  var browserHistory = window.history;
+  var _options$forceRefresh = options.forceRefresh,
+    forceRefresh = _options$forceRefresh === void 0 ? false : _options$forceRefresh,
+    _options$getUserConfi = options.getUserConfirmation,
+    getUserConfirmation = _options$getUserConfi === void 0 ? getDefaultConfirmation : _options$getUserConfi;
+  var basename = options.basename ? normalizeSlash(options.basename) : '';
+  var initLocation = getLocation(getHistoryState());
+  var recordOperator = createMemoryRecord(initLocation, function (l) {
+    return l.key;
+  });
+  var transitionManager = new TransitionManager();
+  var _getBaseHistory = getBaseHistory(transitionManager, setListener, browserHistory),
+    go = _getBaseHistory.go,
+    goBack = _getBaseHistory.goBack,
+    goForward = _getBaseHistory.goForward,
+    listen = _getBaseHistory.listen,
+    block = _getBaseHistory.block,
+    getUpdateStateFunc = _getBaseHistory.getUpdateStateFunc;
+  var history = {
+    action: Action.pop,
+    length: browserHistory.length,
+    location: initLocation,
+    go: go,
+    goBack: goBack,
+    goForward: goForward,
+    listen: listen,
+    block: block,
+    push: push,
+    replace: replace,
+    createHref: createHref
+  };
+  var updateState = getUpdateStateFunc(history);
+  function getHistoryState() {
+    return supportHistory ? window.history.state : {};
+  }
+  function getLocation(historyState) {
+    var _window$location = window.location,
+      search = _window$location.search,
+      hash = _window$location.hash;
+    var _ref = historyState || {},
+      key = _ref.key,
+      state = _ref.state;
+    var pathname = window.location.pathname;
+    pathname = basename ? stripBasename(pathname, basename) : pathname;
+    return createLocation('', {
+      pathname: pathname,
+      search: search,
+      hash: hash
+    }, state, key);
+  }
+
+  // 拦截页面POP事件后，防止返回到的页面被重复拦截
+  var forceJump = false;
+  function handlePopState(location) {
+    if (forceJump) {
+      forceJump = false;
+      updateState(undefined);
+    } else {
+      var action = Action.pop;
+      var callback = function (isJump) {
+        if (isJump) {
+          // 执行跳转行为
+          updateState({
+            action: action,
+            location: location
+          });
+        } else {
+          revertPopState(location, history.location);
+        }
+      };
+      transitionManager.confirmJumpTo(location, action, getUserConfirmation, callback);
+    }
+  }
+  function popStateListener(event) {
+    handlePopState(getLocation(event.state));
+  }
+  function hashChangeListener() {
+    var location = getLocation(getHistoryState());
+    handlePopState(location);
+  }
+  var listenerCount = 0;
+  function setListener(count) {
+    listenerCount += count;
+    if (listenerCount === 1 && count === 1) {
+      window.addEventListener(EventType.PopState, popStateListener);
+      if (!isSupportPopState) {
+        window.addEventListener(EventType.HashChange, hashChangeListener);
+      }
+    } else if (listenerCount === 0) {
+      window.removeEventListener(EventType.PopState, popStateListener);
+      if (!isSupportPopState) {
+        window.removeEventListener(EventType.HashChange, hashChangeListener);
+      }
+    }
+  }
+
+  // 取消页面跳转并恢复到跳转前的页面
+  function revertPopState(form, to) {
+    var delta = recordOperator.getDelta(to, form);
+    if (delta !== 0) {
+      go(delta);
+      forceJump = true;
+    }
+  }
+  function createHref(path) {
+    return basename + createPath(path);
+  }
+  function push(to, state) {
+    var action = Action.push;
+    var location = createLocation(history.location, to, state, undefined);
+    transitionManager.confirmJumpTo(location, action, getUserConfirmation, function (isJump) {
+      if (!isJump) {
+        return;
+      }
+      var href = createHref(location);
+      var key = location.key,
+        state = location.state;
+      if (supportHistory) {
+        if (forceRefresh) {
+          window.location.href = href;
+        } else {
+          browserHistory.pushState({
+            key: key,
+            state: state
+          }, '', href);
+          recordOperator.addRecord(history.location, location, action);
+          updateState({
+            action: action,
+            location: location
+          });
+        }
+      } else {
+        warning(state !== undefined, 'Browser history cannot push state in browsers that do not support HTML5 history');
+        window.location.href = href;
+      }
+    });
+  }
+  function replace(to, state) {
+    var action = Action.replace;
+    var location = createLocation(history.location, to, state, undefined);
+    transitionManager.confirmJumpTo(location, action, getUserConfirmation, function (isJump) {
+      if (!isJump) {
+        return;
+      }
+      var href = createHref(location);
+      var key = location.key,
+        state = location.state;
+      if (supportHistory) {
+        if (forceRefresh) {
+          window.location.replace(href);
+        } else {
+          browserHistory.replaceState({
+            key: key,
+            state: state
+          }, '', href);
+          recordOperator.addRecord(history.location, location, action);
+          updateState({
+            action: action,
+            location: location
+          });
+        }
+      } else {
+        warning(state !== undefined, 'Browser history cannot push state in browsers that do not support HTML5 history');
+        window.location.replace(href);
+      }
+    });
+  }
+  return history;
+}
+
+// 获取#前的内容
+function stripHash(path) {
+  var idx = path.indexOf('#');
+  return idx === -1 ? path : path.substring(0, idx);
+}
+
+// 获取#后的内容
+function getHashContent(path) {
+  var idx = path.indexOf('#');
+  return idx === -1 ? '' : path.substring(idx + 1);
+}
+function createHashHistory() {
+  var option = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var browserHistory = window.history;
+  var _option$hashType = option.hashType,
+    hashType = _option$hashType === void 0 ? 'slash' : _option$hashType,
+    _option$getUserConfir = option.getUserConfirmation,
+    getUserConfirmation = _option$getUserConfir === void 0 ? getDefaultConfirmation : _option$getUserConfir;
+  var basename = option.basename ? normalizeSlash(option.basename) : '';
+  var pathDecoder = addHeadSlash;
+  var pathEncoder = hashType === 'slash' ? addHeadSlash : stripHeadSlash;
+  function getLocation() {
+    var hashPath = pathDecoder(getHashContent(window.location.hash));
+    if (basename) {
+      hashPath = stripBasename(hashPath, basename);
+    }
+    return createLocation('', hashPath, undefined, 'default');
+  }
+  var initLocation = getLocation();
+  var memRecords = createMemoryRecord(initLocation, createPath);
+  var transitionManager = new TransitionManager();
+  function createHref(location) {
+    var tag = document.querySelector('base');
+    var base = tag && tag.getAttribute('href') ? stripHash(window.location.href) : '';
+    return base + '#' + pathEncoder(basename + createPath(location));
+  }
+  var forceNextPop = false;
+  var ignorePath = null;
+  var _getBaseHistory = getBaseHistory(transitionManager, setListener, browserHistory),
+    go = _getBaseHistory.go,
+    goBack = _getBaseHistory.goBack,
+    goForward = _getBaseHistory.goForward,
+    listen = _getBaseHistory.listen,
+    block = _getBaseHistory.block,
+    getUpdateStateFunc = _getBaseHistory.getUpdateStateFunc;
+  var history = {
+    action: Action.pop,
+    length: browserHistory.length,
+    location: initLocation,
+    go: go,
+    goBack: goBack,
+    goForward: goForward,
+    push: push,
+    replace: replace,
+    listen: listen,
+    block: block,
+    createHref: createHref
+  };
+  var updateState = getUpdateStateFunc(history);
+  function push(to, state) {
+    warning(state !== undefined, 'Hash history does not support state, it will be ignored');
+    var action = Action.push;
+    var location = createLocation(history.location, to, undefined, '');
+    transitionManager.confirmJumpTo(location, action, getUserConfirmation, function (isJump) {
+      if (!isJump) {
+        return;
+      }
+      var path = createPath(location);
+      var encodedPath = pathEncoder(basename + path);
+      // 前后hash不一样才进行跳转
+      if (getHashContent(window.location.href) !== encodedPath) {
+        ignorePath = encodedPath;
+        window.location.hash = encodedPath;
+        memRecords.addRecord(history.location, location, action);
+        updateState({
+          action: action,
+          location: location
+        });
+      } else {
+        updateState(undefined);
+      }
+    });
+  }
+  function replace(to, state) {
+    warning(state !== undefined, 'Hash history does not support state, it will be ignored');
+    var action = Action.replace;
+    var location = createLocation(history.location, to, undefined, '');
+    transitionManager.confirmJumpTo(location, action, getUserConfirmation, function (isJump) {
+      if (!isJump) {
+        return;
+      }
+      var path = createPath(location);
+      var encodedPath = pathEncoder(basename + path);
+      if (getHashContent(window.location.href) !== encodedPath) {
+        ignorePath = path;
+        window.location.replace(stripHash(window.location.href) + '#' + encodedPath);
+      }
+      memRecords.addRecord(history.location, location, action);
+      updateState({
+        action: action,
+        location: location
+      });
+    });
+  }
+  function handleHashChange() {
+    var hashPath = getHashContent(window.location.href);
+    var encodedPath = pathEncoder(hashPath);
+    if (hashPath !== encodedPath) {
+      window.location.replace(stripHash(window.location.href) + '#' + encodedPath);
+    } else {
+      var location = getLocation();
+      var prevLocation = history.location;
+      if (!forceNextPop && isLocationEqual(location, prevLocation)) {
+        return;
+      }
+      if (ignorePath === createPath(location)) {
+        return;
+      }
+      ignorePath = null;
+      handlePopState(location);
+    }
+  }
+  function handlePopState(location) {
+    if (forceNextPop) {
+      forceNextPop = false;
+      updateState(undefined);
+    } else {
+      var action = Action.pop;
+      var callback = function (isJump) {
+        if (isJump) {
+          updateState({
+            action: action,
+            location: location
+          });
+        } else {
+          revertPopState(location);
+        }
+      };
+      transitionManager.confirmJumpTo(location, action, getUserConfirmation, callback);
+    }
+  }
+
+  // 在跳转行为被Block后，用History.go()跳转回之前的页面
+  function revertPopState(form) {
+    var to = history.location;
+    var delta = memRecords.getDelta(to, form);
+    if (delta !== 0) {
+      go(delta);
+      forceNextPop = true;
+    }
+  }
+  var listenerCount = 0;
+  function setListener(delta) {
+    listenerCount += delta;
+    if (listenerCount === 1 && delta === 1) {
+      window.addEventListener(EventType.HashChange, handleHashChange);
+    } else if (listenerCount === 0) {
+      window.removeEventListener(EventType.HashChange, handleHashChange);
+    }
+  }
+  return history;
+}
+
+function createNamedContext(name, defaultValue) {
+  var context = React.createContext(defaultValue);
+  context.displayName = name;
+  return context;
+}
+var RouterContext = createNamedContext('Router', {});
+
+var TokenType = /*#__PURE__*/function (TokenType) {
+  TokenType["Delimiter"] = "delimiter";
+  TokenType["Static"] = "static";
+  TokenType["Param"] = "param";
+  TokenType["WildCard"] = "wildcard";
+  TokenType["LBracket"] = "(";
+  TokenType["RBracket"] = ")";
+  TokenType["Pattern"] = "pattern";
+  return TokenType;
+}({});
+
+// 解析URL中的动态参数，以实现TypeScript提示功能
+
+/**
+ * @description 将url中的//转换为/
+ */
+function cleanPath(path) {
+  return path.replace(/\/+/g, '/');
+}
+function scoreCompare(score1, score2) {
+  var score1Length = score1.length;
+  var score2Length = score2.length;
+  var end = Math.min(score1Length, score2Length);
+  for (var i = 0; i < end; i++) {
+    var delta = score2[i] - score1[i];
+    if (delta !== 0) {
+      return delta;
+    }
+  }
+  if (score1Length === score2Length) {
+    return 0;
+  }
+  return score1Length > score2Length ? -1 : 1;
+}
+
+// 把正则表达式的特殊符号加两个反斜杠进行转义
+function escapeStr(str) {
+  return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, '\\$1');
+}
+
+var validChar = /[^/:*()]/;
+
+// 对Url模板进行词法解析，解析结果为Tokens
+function lexer(path) {
+  var tokens = [];
+  if (!path) {
+    return tokens;
+  }
+  var urlPath = cleanPath(path);
+  if (urlPath !== '*' && !urlPath.startsWith('/')) {
+    throw new Error("Url must start with \"/\".");
+  }
+  var getLiteral = function () {
+    var name = '';
+    while (i < urlPath.length && validChar.test(urlPath[i])) {
+      name += urlPath[i];
+      skipChar(1);
+    }
+    return name;
+  };
+  var skipChar = function (step) {
+    i += step;
+  };
+  var i = 0;
+  while (i < urlPath.length) {
+    var curChar = urlPath[i];
+    var prevChar = urlPath[i - 1];
+    if (curChar === '/') {
+      tokens.push({
+        type: TokenType.Delimiter,
+        value: urlPath[i]
+      });
+      skipChar(1);
+      continue;
+    }
+    // dynamic params (/:a)
+    if (prevChar === '/' && curChar === ':') {
+      skipChar(1);
+      tokens.push({
+        type: TokenType.Param,
+        value: getLiteral()
+      });
+      continue;
+    }
+    // wildCard params (/:*)
+    if ((prevChar === '/' || prevChar === undefined) && curChar === '*') {
+      tokens.push({
+        type: TokenType.WildCard,
+        value: urlPath[i]
+      });
+      skipChar(1);
+      continue;
+    }
+    // static params
+    if (prevChar === '/' && validChar.test(curChar)) {
+      tokens.push({
+        type: TokenType.Static,
+        value: getLiteral()
+      });
+      continue;
+    }
+    if (curChar === '(') {
+      tokens.push({
+        type: TokenType.LBracket,
+        value: '('
+      });
+      skipChar(1);
+      continue;
+    }
+    if (curChar === ')') {
+      tokens.push({
+        type: TokenType.RBracket,
+        value: ')'
+      });
+      skipChar(1);
+      continue;
+    }
+    if (validChar.test(curChar)) {
+      tokens.push({
+        type: TokenType.Pattern,
+        value: getLiteral()
+      });
+      continue;
+    }
+    // 跳过非法字符
+    skipChar(1);
+  }
+  return tokens;
+}
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function () {}; return { s: F, n: function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function (e) { throw e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function () { it = it.call(o); }, n: function () { var step = it.next(); normalCompletion = step.done; return step; }, e: function (e) { didErr = true; err = e; }, f: function () { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+// 不同类型参数的匹配得分
+var MatchScore = /*#__PURE__*/function (MatchScore) {
+  MatchScore[MatchScore["static"] = 10] = "static";
+  MatchScore[MatchScore["param"] = 6] = "param";
+  MatchScore[MatchScore["wildcard"] = 3] = "wildcard";
+  MatchScore[MatchScore["placeholder"] = -1] = "placeholder";
+  return MatchScore;
+}(MatchScore || {}); // 兼容 react v5 matched类型
+var defaultOption = {
+  // url匹配时是否大小写敏感
+  caseSensitive: true,
+  // 是否严格匹配url结尾的/
+  strictMode: false,
+  // 是否完全精确匹配
+  exact: false
+};
+// 正则表达式中需要转义的字符
+var REGEX_CHARS_RE = /[.+*?^${}()[\]/\\]/g;
+// 用于匹配两个//中的的值
+var BASE_PARAM_PATTERN = '[^/]+';
+var DefaultDelimiter = '/#?';
+function createPathParser(pathname) {
+  var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultOption;
+  var _option$caseSensitive = option.caseSensitive,
+    caseSensitive = _option$caseSensitive === void 0 ? defaultOption.caseSensitive : _option$caseSensitive,
+    _option$strictMode = option.strictMode,
+    strictMode = _option$strictMode === void 0 ? defaultOption.strictMode : _option$strictMode,
+    _option$exact = option.exact,
+    exact = _option$exact === void 0 ? defaultOption.exact : _option$exact;
+  /**
+   * URL匹配整体流程
+   * 1.词法解析，将URL模板解析为Token
+   * 2.使用Token生成正则表达式
+   * 3.利用正则表达式解析URL中参数或填充URL模板
+   */
+  var pattern = '^';
+  var keys = [];
+  var scores = [];
+  var tokens = lexer(pathname);
+  var onlyHasWildCard = tokens.length === 1 && tokens[0].type === TokenType.WildCard;
+  var tokenCount = tokens.length;
+  var lastToken = tokens[tokenCount - 1];
+  for (var tokenIdx = 0; tokenIdx < tokenCount; tokenIdx++) {
+    var token = tokens[tokenIdx];
+    var nextToken = tokens[tokenIdx + 1];
+    switch (token.type) {
+      case TokenType.Delimiter:
+        pattern += '/';
+        break;
+      case TokenType.Static:
+        pattern += token.value.replace(REGEX_CHARS_RE, '\\$&');
+        scores.push(MatchScore.static);
+        break;
+      case TokenType.Param:
+        var paramRegexp = '';
+        if (nextToken && nextToken.type === TokenType.LBracket) {
+          // 跳过当前Token和左括号
+          tokenIdx += 2;
+          while (tokens[tokenIdx].type !== TokenType.RBracket) {
+            paramRegexp += tokens[tokenIdx].value;
+            tokenIdx++;
+          }
+        }
+        pattern += paramRegexp ? "((?:" + paramRegexp + "))" : "(" + BASE_PARAM_PATTERN + ")";
+        keys.push(token.value);
+        scores.push(MatchScore.param);
+        break;
+      case TokenType.WildCard:
+        keys.push(token.value);
+        pattern += "((?:" + BASE_PARAM_PATTERN + ")" + (onlyHasWildCard ? '?' : '') + "(?:/(?:" + BASE_PARAM_PATTERN + "))*)";
+        scores.push(onlyHasWildCard ? MatchScore.wildcard : MatchScore.placeholder);
+        break;
+    }
+  }
+  var isWildCard = lastToken.type === TokenType.WildCard;
+  if (!isWildCard && !exact) {
+    if (!strictMode) {
+      pattern += "(?:[" + escapeStr(DefaultDelimiter) + "](?=$))?";
+    }
+    if (lastToken.type !== TokenType.Delimiter) {
+      pattern += "(?=[" + escapeStr(DefaultDelimiter) + "]|$)";
+    }
+  } else {
+    pattern += strictMode ? '$' : "[" + escapeStr(DefaultDelimiter) + "]?$";
+  }
+  var flag = caseSensitive ? '' : 'i';
+  var regexp = new RegExp(pattern, flag);
+
+  /**
+   * @description 根据给定Pattern解析path
+   */
+  function parse(path) {
+    var reMatch = path.match(regexp);
+    if (!reMatch) {
+      return null;
+    }
+    var matchedPath = reMatch[0];
+    var params = {};
+    var parseScore = Array.from(scores);
+    for (var i = 1; i < reMatch.length; i++) {
+      var param = reMatch[i];
+      var key = keys[i - 1];
+      if (key === '*' && param) {
+        var value = param.split('/');
+        if (!Array.isArray(params['*'])) {
+          params['*'] = value;
+        } else {
+          var _params$;
+          (_params$ = params['*']).push.apply(_params$, value);
+        }
+        // 完成通配符参数解析后将placeholder替换为wildcard参数的分值
+        parseScore.splice.apply(parseScore, [scores.indexOf(MatchScore.placeholder), 1].concat(new Array(value.length).fill(MatchScore.wildcard)));
+      } else {
+        params[key] = param ? param : [];
+      }
+    }
+    var isExact = path === matchedPath;
+    var url = path === '/' && matchedPath === '' ? '/' : matchedPath;
+    return {
+      isExact: isExact,
+      path: pathname,
+      url: url,
+      score: parseScore,
+      params: params
+    };
+  }
+
+  /**
+   * @description 使用给定参数填充pattern，得到目标URL
+   */
+  function compile(params) {
+    var path = '';
+    var _iterator = _createForOfIteratorHelper(tokens),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _token = _step.value;
+        switch (_token.type) {
+          case TokenType.Static:
+            path += _token.value;
+            break;
+          case TokenType.Param:
+            if (!params[_token.value]) {
+              throw new Error('Param is invalid.');
+            }
+            path += params[_token.value];
+            break;
+          case TokenType.WildCard:
+            var wildCard = params['*'];
+            if (wildCard instanceof Array) {
+              path += wildCard.join('/');
+            } else {
+              path += wildCard;
+            }
+            break;
+          case TokenType.Delimiter:
+            path += _token.value;
+            break;
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return path;
+  }
+  return {
+    get regexp() {
+      return regexp;
+    },
+    get keys() {
+      return keys;
+    },
+    compile: compile,
+    parse: parse
+  };
+}
+
+/**
+ * @description 依次使用pathname与pattern进行匹配，根据匹配分数取得分数最高结果
+ */
+function matchPath(pathname, pattern, option) {
+  var patterns = Array.isArray(pattern) ? [].concat(pattern) : [pattern];
+  var matchedResults = [];
+  var _iterator2 = _createForOfIteratorHelper(patterns),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var item = _step2.value;
+      var parser = createPathParser(item, option);
+      var matched = parser.parse(pathname);
+      if (matched) {
+        matchedResults.push(matched);
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return !matchedResults.length ? null : matchedResults.sort(function (a, b) {
+    return scoreCompare(a.score, b.score);
+  })[0];
+}
+function generatePath(path, params) {
+  var parser = createPathParser(path);
+  return parser.compile(params);
+}
+
+function useHistory() {
+  return React.useContext(RouterContext).history;
+}
+function useLocation() {
+  return React.useContext(RouterContext).location;
+}
+function useParams() {
+  var match = React.useContext(RouterContext).match;
+  return match ? match.params : {};
+}
+function useRouteMatch(path) {
+  var pathname = useLocation().pathname;
+  var match = React.useContext(RouterContext).match;
+  if (path) {
+    return matchPath(pathname, path);
+  }
+  return match;
+}
+
+function Route(props) {
+  var context = React.useContext(RouterContext);
+  var computed = props.computed,
+    location = props.location,
+    path = props.path;
+  var children = props.children,
+    component = props.component,
+    render = props.render;
+  var match;
+  var routeLocation = location || context.location;
+  if (computed) {
+    match = computed;
+  } else if (path) {
+    match = matchPath(routeLocation.pathname, path);
+  } else {
+    match = context.match;
+  }
+  var newProps = _extends({}, context, {
+    location: routeLocation,
+    match: match
+  });
+  if (Array.isArray(children) && React.Children.count(children) === 0) {
+    children = null;
+  }
+
+  /**
+   * 按顺序获取需要渲染的组件
+   * 1.children
+   * 2.component
+   * 3.render
+   * 都没有匹配到返回Null
+   */
+  var getChildren = function () {
+    // 如果 match 存在
+    if (newProps.match) {
+      if (children) {
+        if (typeof children === 'function') {
+          return children(newProps);
+        }
+        return children;
+      }
+      if (component) {
+        return React.createElement(component, newProps);
+      } else if (render) {
+        return render(newProps);
+      } else {
+        return null;
+      }
+    } else {
+      // match为null
+      if (typeof children === 'function') {
+        return children(newProps);
+      }
+      return null;
+    }
+  };
+  return /*#__PURE__*/React__namespace.createElement(RouterContext.Provider, {
+    value: newProps
+  }, getChildren());
+}
+
+function Router(props) {
+  var history = props.history,
+    _props$children = props.children,
+    children = _props$children === void 0 ? null : _props$children;
+  var _useState = React.useState(props.history.location),
+    location = _useState[0],
+    setLocation = _useState[1];
+  var pendingLocation = React.useRef(null);
+
+  // 在Router加载时就监听history地址变化，以保证在始渲染时重定向能正确触发
+  var unListen = history.listen(function (arg) {
+    pendingLocation.current = arg.location;
+  });
+
+  // 模拟componentDidMount和componentWillUnmount
+  React.useLayoutEffect(function () {
+    if (unListen) {
+      unListen();
+    }
+    // 监听history中的位置变化
+    unListen = history.listen(function (arg) {
+      setLocation(arg.location);
+    });
+    if (pendingLocation.current) {
+      setLocation(pendingLocation.current);
+    }
+    return function () {
+      if (unListen) {
+        unListen();
+        unListen = null;
+        pendingLocation.current = null;
+      }
+    };
+  }, []);
+  var initContextValue = React.useMemo(function () {
+    return {
+      history: history,
+      location: location,
+      match: {
+        isExact: location.pathname === '/',
+        params: {},
+        path: '/',
+        score: [],
+        url: '/'
+      }
+    };
+  }, [location]);
+  return /*#__PURE__*/React__namespace.createElement(RouterContext.Provider, {
+    value: initContextValue,
+    children: children
+  });
+}
+
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+  return target;
+}
+
+function LifeCycle(props) {
+  // 使用ref保存上一次的props，防止重新渲染
+  var prevProps = React.useRef(null);
+  var isMount = React.useRef(false);
+  var onMount = props.onMount,
+    onUpdate = props.onUpdate,
+    onUnmount = props.onUnmount;
+  React.useLayoutEffect(function () {
+    // 首次挂载 模拟componentDidMount
+    if (!isMount.current) {
+      isMount.current = true;
+      if (onMount) {
+        onMount();
+      }
+    } else {
+      // 不是首次渲染 模拟componentDidUpdate
+      if (onUpdate) {
+        prevProps.current ? onUpdate(prevProps.current) : onUpdate();
+      }
+    }
+    prevProps.current = props;
+  });
+
+  // 模拟componentWillUnmount
+  React.useLayoutEffect(function () {
+    return function () {
+      if (onUnmount) {
+        onUnmount();
+      }
+    };
+  }, []);
+  return null;
+}
+
+var _excluded$2 = ["state"];
+function Redirect(props) {
+  var to = props.to,
+    _props$push = props.push,
+    push = _props$push === void 0 ? false : _props$push,
+    computed = props.computed;
+  var context = React.useContext(RouterContext);
+  var history = context.history;
+  var calcLocation = function () {
+    if (computed) {
+      if (typeof to === 'string') {
+        var parser = createPathParser(to);
+        var target = parser.compile(computed.params);
+        return parsePath(target);
+      } else {
+        var pathname = to.pathname ? addHeadSlash(to.pathname) : '/';
+        var _parser = createPathParser(pathname);
+        var _target = _parser.compile(computed.params);
+        return _extends({}, to, {
+          pathname: _target
+        });
+      }
+    }
+    return typeof to === 'string' ? parsePath(to) : to;
+  };
+  var navigate = push ? history.push : history.replace;
+  var _calcLocation = calcLocation(),
+    state = _calcLocation.state,
+    path = _objectWithoutPropertiesLoose(_calcLocation, _excluded$2);
+  var onMountFunc = function () {
+    navigate(path, state);
+  };
+  var onUpdateFunc = function (prevProps) {
+    // 如果当前页面与重定向前页面不一致，执行跳转
+    var prevPath = prevProps === null || prevProps === void 0 ? void 0 : prevProps.data;
+    if (!isLocationEqual(prevPath, path)) {
+      navigate(path, state);
+    }
+  };
+  return /*#__PURE__*/React__namespace.createElement(LifeCycle, {
+    onMount: onMountFunc,
+    onUpdate: onUpdateFunc,
+    data: path
+  });
+}
+
+function Switch(props) {
+  var context = React.useContext(RouterContext);
+  var location = props.location || context.location;
+  var element = null;
+  var match = null;
+
+  // 使用forEach不会给React.ReactNode增加key属性,防止重新渲染
+  React.Children.forEach(props.children, function (node) {
+    if (match === null && React.isValidElement(node)) {
+      element = node;
+      var strict;
+      var sensitive;
+      var path;
+      var from;
+
+      // node可能是Route和Redirect
+      if (node.type === Route) {
+        var _props = node.props;
+        strict = _props.strict;
+        sensitive = _props.sensitive;
+        path = _props.path;
+      } else if (node.type === Redirect) {
+        var _props2 = node.props;
+        path = _props2.path;
+        strict = _props2.strict;
+        from = _props2.from;
+      }
+      var exact = node.props.exact;
+      var target = path || from;
+
+      // 更新匹配状态，一旦匹配到停止遍历
+      if (target) {
+        match = matchPath(location.pathname, target, {
+          strictMode: strict,
+          caseSensitive: sensitive,
+          exact: exact
+        });
+      } else {
+        match = context.match;
+      }
+    }
+  });
+  if (match && element) {
+    // 使用cloneElement复制已有组件并更新其Props
+    return React.cloneElement(element, {
+      location: location,
+      computed: match
+    });
+  }
+  return null;
+}
+
+function Prompt(props) {
+  var context = React.useContext(RouterContext);
+  var message = props.message,
+    _props$when = props.when,
+    when = _props$when === void 0 ? true : _props$when;
+  if (typeof when === 'function' && when(context.location) === false || !when) {
+    return null;
+  }
+  var navigate = context.history.block;
+  var release = null;
+  var onMountFunc = function () {
+    release = message ? navigate(message) : null;
+  };
+  var onUpdateFunc = function (prevProps) {
+    if (prevProps && prevProps.data !== message) {
+      if (release) {
+        release();
+      }
+      release = message ? navigate(message) : null;
+    }
+  };
+  var onUnmountFunc = function () {
+    if (release) {
+      release();
+    }
+    release = null;
+  };
+  return /*#__PURE__*/React__namespace.createElement(LifeCycle, {
+    onMount: onMountFunc,
+    onUpdate: onUpdateFunc,
+    onUnmount: onUnmountFunc,
+    data: message
+  });
+}
+
+function withRouter(Component) {
+  function ComponentWithRouterProp(props) {
+    var _useContext = React.useContext(RouterContext),
+      history = _useContext.history,
+      location = _useContext.location,
+      match = _useContext.match;
+    var routeProps = {
+      history: history,
+      location: location,
+      match: match
+    };
+    return /*#__PURE__*/React__namespace.createElement(Component, _extends({}, props, routeProps));
+  }
+  return ComponentWithRouterProp;
+}
+
+function HashRouter(props) {
+  var historyRef = React.useRef();
+  if (historyRef.current === null || historyRef.current === undefined) {
+    historyRef.current = createHashHistory({
+      basename: props.basename,
+      getUserConfirmation: props.getUserConfirmation,
+      hashType: props.hashType
+    });
+  }
+  return /*#__PURE__*/React__namespace.createElement(Router, {
+    history: historyRef.current
+  }, props.children);
+}
+
+function BrowserRouter(props) {
+  // 使用Ref持有History对象，防止重复渲染
+  var historyRef = React.useRef();
+  if (historyRef.current === null || historyRef.current === undefined) {
+    historyRef.current = createBrowserHistory({
+      basename: props.basename,
+      forceRefresh: props.forceRefresh,
+      getUserConfirmation: props.getUserConfirmation
+    });
+  }
+  return /*#__PURE__*/React__namespace.createElement(Router, {
+    history: historyRef.current
+  }, props.children);
+}
+
+var _excluded$1 = ["to", "replace", "component", "onClick", "target"];
+var isModifiedEvent = function (event) {
+  return event.metaKey || event.altKey || event.ctrlKey || event.shiftKey;
+};
+var checkTarget = function (target) {
+  return !target || target === '_self';
+};
+function Link(props) {
+  var to = props.to,
+    replace = props.replace;
+    props.component;
+    var onClick = props.onClick,
+    target = props.target,
+    other = _objectWithoutPropertiesLoose(props, _excluded$1);
+  var tag = props.tag || 'a';
+  var context = React.useContext(RouterContext);
+  var history = context.history;
+  var location = typeof to === 'function' ? to(context.location) : to;
+  var state;
+  var path;
+  if (typeof location === 'string') {
+    path = parsePath(location);
+  } else {
+    var pathname = location.pathname,
+      hash = location.hash,
+      search = location.search;
+    path = {
+      pathname: pathname,
+      hash: hash,
+      search: search
+    };
+    state = location.state;
+  }
+  var href = history.createHref(path);
+  var linkClickEvent = function (event) {
+    try {
+      if (onClick) {
+        onClick(event);
+      }
+    } catch (e) {
+      event.preventDefault();
+      throw e;
+    }
+    if (!event.defaultPrevented && event.button === 0 && checkTarget(target) && !isModifiedEvent(event)) {
+      // 不是相同的路径执行push操作，是相同的路径执行replace
+      var isSamePath = createPath(context.location) === createPath(path);
+      var navigate = replace || isSamePath ? history.replace : history.push;
+      event.preventDefault();
+      navigate(path, state);
+    }
+  };
+  var linkProps = _extends({
+    href: href,
+    onClick: linkClickEvent
+  }, other);
+  return React__namespace.createElement(tag, linkProps);
+}
+
+var _excluded = ["to", "isActive"];
+function NavLink(props) {
+  var to = props.to,
+    isActive = props.isActive,
+    rest = _objectWithoutPropertiesLoose(props, _excluded);
+  var context = React.useContext(RouterContext);
+  var toLocation = typeof to === 'function' ? to(context.location) : to;
+  var _ref = typeof toLocation === 'string' ? parsePath(toLocation) : toLocation,
+    path = _ref.pathname;
+  // 把正则表达式的特殊符号加两个反斜杠进行转义
+  var escapedPath = path ? escapeStr(path) : '';
+  var match = escapedPath ? matchPath(context.location.pathname, escapedPath) : null;
+  var isLinkActive = match && isActive ? isActive(match, context.location) : false;
+  var page = 'page';
+  var otherProps = _extends({
+    'aria-current': isLinkActive ? page : false
+  }, rest);
+  return /*#__PURE__*/React__namespace.createElement(Link, _extends({
+    to: to
+  }, otherProps));
+}
+
+exports.BrowserRouter = BrowserRouter;
+exports.HashRouter = HashRouter;
+exports.Link = Link;
+exports.NavLink = NavLink;
+exports.Prompt = Prompt;
+exports.Redirect = Redirect;
+exports.Route = Route;
+exports.Router = Router;
+exports.Switch = Switch;
+exports.__RouterContext = RouterContext;
+exports.createBrowserHistory = createBrowserHistory;
+exports.createHashHistory = createHashHistory;
+exports.generatePath = generatePath;
+exports.matchPath = matchPath;
+exports.useHistory = useHistory;
+exports.useLocation = useLocation;
+exports.useParams = useParams;
+exports.useRouteMatch = useRouteMatch;
+exports.withRouter = withRouter;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"router.js","sources":["../../src/history/dom.ts","../../src/history/types.ts","../../../../node_modules/@babel/runtime/helpers/esm/extends.js","../../src/history/utils.ts","../../../../node_modules/@babel/runtime/helpers/esm/classCallCheck.js","../../../../node_modules/@babel/runtime/helpers/esm/typeof.js","../../../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js","../../../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js","../../../../node_modules/@babel/runtime/helpers/esm/createClass.js","../../src/history/transitionManager.ts","../../src/history/waring.ts","../../src/history/baseHistory.ts","../../src/history/browerHistory.ts","../../src/history/hashHistory.ts","../../src/router/context.tsx","../../src/router/matcher/types.ts","../../src/router/matcher/utils.ts","../../src/router/matcher/lexer.ts","../../src/router/matcher/parser.ts","../../src/router/hooks.ts","../../src/router/Route.tsx","../../src/router/Router.tsx","../../../../node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js","../../src/router/lifeCycleHook.ts","../../src/router/Redirect.tsx","../../src/router/Switch.tsx","../../src/router/Prompt.tsx","../../src/router/withRouter.tsx","../../src/router/HashRouter.tsx","../../src/router/BrowserRouter.tsx","../../src/router/Link.tsx","../../src/router/NavLink.tsx"],"sourcesContent":["export function isBrowser(): boolean {\r\n  return typeof window !== 'undefined' && window.document && typeof window.document.createElement === 'function';\r\n}\r\n\r\nexport function getDefaultConfirmation(message: string, callBack: (result: boolean) => void) {\r\n  callBack(window.confirm(message));\r\n}\r\n\r\n// 判断浏览器是否支持pushState方法，pushState是browserHistory实现的基础\r\nexport function isSupportHistory(): boolean {\r\n  return isBrowser() && window.history && 'pushState' in window.history;\r\n}\r\n\r\n// 判断浏览器是否支持PopState事件\r\nexport function isSupportsPopState(): boolean {\r\n  return window.navigator.userAgent.indexOf('Trident') === -1;\r\n}\r\n","export type BaseOption = {\r\n  basename?: string;\r\n  getUserConfirmation?: ConfirmationFunc;\r\n};\r\n\r\nexport interface HistoryProps<T = unknown> {\r\n  readonly action: Action;\r\n\r\n  readonly location: Location<T>;\r\n\r\n  length: number;\r\n}\r\n\r\nexport interface History<T = unknown> extends HistoryProps<T> {\r\n  createHref(path: Partial<Path>): string;\r\n\r\n  push(to: To, state?: T): void;\r\n\r\n  replace(to: To, state?: T): void;\r\n\r\n  listen(listener: Listener<T>): () => void;\r\n\r\n  block(prompt: Prompt<T>): () => void;\r\n\r\n  go(index: number): void;\r\n\r\n  goBack(): void;\r\n\r\n  goForward(): void;\r\n}\r\n\r\nexport enum Action {\r\n  pop = 'POP',\r\n  push = 'PUSH',\r\n  replace = 'REPLACE',\r\n}\r\n\r\nexport enum EventType {\r\n  PopState = 'popstate',\r\n  HashChange = 'hashchange',\r\n}\r\n\r\nexport type Path = {\r\n  pathname: string;\r\n\r\n  search: string;\r\n\r\n  hash: string;\r\n};\r\n\r\nexport type HistoryState<T> = {\r\n  state?: T;\r\n\r\n  key: string;\r\n};\r\n\r\nexport type DefaultStateType = unknown;\r\n\r\nexport type Location<T = unknown> = Path & HistoryState<T>;\r\n\r\nexport type To = string | Partial<Path>;\r\n\r\nexport interface Listener<T = unknown> {\r\n  (navigation: Navigation<T>): void;\r\n}\r\n\r\nexport interface Navigation<T = unknown> {\r\n  action: Action;\r\n\r\n  location: Location<T>;\r\n}\r\n\r\nexport type Prompt<S> = string | boolean | null | ((location: Location<S>, action: Action) => void);\r\n\r\nexport type CallBackFunc = (isJump: boolean) => void;\r\n\r\nexport type ConfirmationFunc = (message: string, callBack: CallBackFunc) => void;\r\n\r\nexport interface TManager<S> {\r\n  setPrompt(next: Prompt<S>): () => void;\r\n\r\n  addListener(func: (navigation: Navigation<S>) => void): () => void;\r\n\r\n  notifyListeners(args: Navigation<S>): void;\r\n\r\n  confirmJumpTo(\r\n    location: Location<S>,\r\n    action: Action,\r\n    userConfirmationFunc: ConfirmationFunc,\r\n    callBack: CallBackFunc,\r\n  ): void;\r\n}\r\n","export default function _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}","import { Action, Location, Path, To } from './types';\r\n\r\nexport function createPath(path: Partial<Path>): string {\r\n  const { search, hash } = path;\r\n  let pathname = path.pathname || '/';\r\n  if (search && search !== '?') {\r\n    pathname += search.startsWith('?') ? search : '?' + search;\r\n  }\r\n  if (hash && hash !== '#') {\r\n    pathname += hash.startsWith('#') ? hash : '#' + hash;\r\n  }\r\n  return pathname;\r\n}\r\n\r\nexport function parsePath(url: string): Partial<Path> {\r\n  if (!url) {\r\n    return {};\r\n  }\r\n  let parsedPath: Partial<Path> = {};\r\n\r\n  let hashIdx = url.indexOf('#');\r\n  if (hashIdx > -1) {\r\n    parsedPath.hash = url.substring(hashIdx);\r\n    url = url.substring(0, hashIdx);\r\n  }\r\n\r\n  let searchIdx = url.indexOf('?');\r\n  if (searchIdx > -1) {\r\n    parsedPath.search = url.substring(searchIdx);\r\n    url = url.substring(0, searchIdx);\r\n  }\r\n  if (url) {\r\n    parsedPath.pathname = url;\r\n  }\r\n  return parsedPath;\r\n}\r\n\r\nexport function createLocation<S>(current: string | Location, to: To, state?: S, key?: string): Readonly<Location<S>> {\r\n  let pathname = typeof current === 'string' ? current : current.pathname;\r\n  let urlObj = typeof to === 'string' ? parsePath(to) : to;\r\n  // 随机key长度取6\r\n  const getRandKey = genRandomKey(6);\r\n  const location = {\r\n    pathname: pathname,\r\n    search: '',\r\n    hash: '',\r\n    state: state,\r\n    key: typeof key === 'string' ? key : getRandKey(),\r\n    ...urlObj,\r\n  };\r\n  if (!location.pathname) {\r\n    location.pathname = '/';\r\n  }\r\n  return location;\r\n}\r\n\r\nexport function isLocationEqual(p1: Partial<Path>, p2: Partial<Path>) {\r\n  return p1.pathname === p2.pathname && p1.search === p2.search && p1.hash === p2.hash;\r\n}\r\n\r\nexport function addHeadSlash(path: string): string {\r\n  if (path[0] === '/') {\r\n    return path;\r\n  }\r\n  return '/' + path;\r\n}\r\n\r\nexport function stripHeadSlash(path: string): string {\r\n  if (path[0] === '/') {\r\n    return path.substring(1);\r\n  }\r\n  return path;\r\n}\r\n\r\nexport function normalizeSlash(path: string): string {\r\n  const tempPath = addHeadSlash(path);\r\n  if (tempPath[tempPath.length - 1] === '/') {\r\n    return tempPath.substring(0, tempPath.length - 1);\r\n  }\r\n  return tempPath;\r\n}\r\n\r\nexport function hasBasename(path: string, prefix: string): Boolean {\r\n  return (\r\n    path.toLowerCase().indexOf(prefix.toLowerCase()) === 0 && ['/', '?', '#', ''].includes(path.charAt(prefix.length))\r\n  );\r\n}\r\n\r\nexport function stripBasename(path: string, prefix: string): string {\r\n  return hasBasename(path, prefix) ? path.substring(prefix.length) : path;\r\n}\r\n\r\n// 使用随机生成的Key记录被访问过的URL，当Block被被触发时利用delta值跳转到之前的页面\r\nexport function createMemoryRecord<T, S>(initVal: S, fn: (arg: S) => T) {\r\n  let visitedRecord: T[] = [fn(initVal)];\r\n\r\n  function getDelta(to: S, form: S): number {\r\n    let toIdx = visitedRecord.lastIndexOf(fn(to));\r\n    if (toIdx === -1) {\r\n      toIdx = 0;\r\n    }\r\n    let fromIdx = visitedRecord.lastIndexOf(fn(form));\r\n    if (fromIdx === -1) {\r\n      fromIdx = 0;\r\n    }\r\n    return toIdx - fromIdx;\r\n  }\r\n\r\n  function addRecord(current: S, newRecord: S, action: Action) {\r\n    const curVal = fn(current);\r\n    const NewVal = fn(newRecord);\r\n    if (action === Action.push) {\r\n      const prevIdx = visitedRecord.lastIndexOf(curVal);\r\n      const newVisitedRecord = visitedRecord.slice(0, prevIdx + 1);\r\n      newVisitedRecord.push(NewVal);\r\n      visitedRecord = newVisitedRecord;\r\n    }\r\n    if (action === Action.replace) {\r\n      const prevIdx = visitedRecord.lastIndexOf(curVal);\r\n      if (prevIdx !== -1) {\r\n        visitedRecord[prevIdx] = NewVal;\r\n      }\r\n    }\r\n  }\r\n\r\n  return { getDelta, addRecord };\r\n}\r\n\r\nfunction genRandomKey(length: number): () => string {\r\n  const end = length + 2;\r\n  return () => {\r\n    return Math.random().toString(18).substring(2, end);\r\n  };\r\n}\r\n","export default function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}","export default function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n    return typeof obj;\n  } : function (obj) {\n    return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n  }, _typeof(obj);\n}","import _typeof from \"./typeof.js\";\nexport default function _toPrimitive(input, hint) {\n  if (_typeof(input) !== \"object\" || input === null) return input;\n  var prim = input[Symbol.toPrimitive];\n  if (prim !== undefined) {\n    var res = prim.call(input, hint || \"default\");\n    if (_typeof(res) !== \"object\") return res;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (hint === \"string\" ? String : Number)(input);\n}","import _typeof from \"./typeof.js\";\nimport toPrimitive from \"./toPrimitive.js\";\nexport default function _toPropertyKey(arg) {\n  var key = toPrimitive(arg, \"string\");\n  return _typeof(key) === \"symbol\" ? key : String(key);\n}","import toPropertyKey from \"./toPropertyKey.js\";\nfunction _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, toPropertyKey(descriptor.key), descriptor);\n  }\n}\nexport default function _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  Object.defineProperty(Constructor, \"prototype\", {\n    writable: false\n  });\n  return Constructor;\n}","import { Action, CallBackFunc, ConfirmationFunc, Listener, Location, Navigation, Prompt, TManager } from './types';\r\n\r\nclass TransitionManager<S> implements TManager<S> {\r\n  private prompt: Prompt<S>;\r\n  private listeners: Listener<S>[];\r\n\r\n  constructor() {\r\n    this.prompt = null;\r\n    this.listeners = [];\r\n  }\r\n\r\n  public setPrompt(prompt: Prompt<S>): () => void {\r\n    this.prompt = prompt;\r\n\r\n    // 清除Prompt\r\n    return () => {\r\n      if (this.prompt === prompt) {\r\n        this.prompt = null;\r\n      }\r\n    };\r\n  }\r\n\r\n  // 使用发布订阅模式管理history的监听者\r\n  public addListener(func: Listener<S>): () => void {\r\n    let isActive = true;\r\n    const listener = (args: Navigation<S>) => {\r\n      if (isActive) {\r\n        func(args);\r\n      }\r\n    };\r\n    this.listeners.push(listener);\r\n    return () => {\r\n      isActive = false;\r\n      // 移除对应的监听者\r\n      this.listeners = this.listeners.filter(item => item !== listener);\r\n    };\r\n  }\r\n\r\n  public notifyListeners(args: Navigation<S>) {\r\n    for (const listener of this.listeners) {\r\n      listener(args);\r\n    }\r\n  }\r\n\r\n  public confirmJumpTo(\r\n    location: Location<S>,\r\n    action: Action,\r\n    userConfirmationFunc: ConfirmationFunc,\r\n    callBack: CallBackFunc\r\n  ) {\r\n    if (this.prompt !== null) {\r\n      const result = typeof this.prompt === 'function' ? this.prompt(location, action) : this.prompt;\r\n      if (typeof result === 'string') {\r\n        typeof userConfirmationFunc === 'function' ? userConfirmationFunc(result, callBack) : callBack(true);\r\n      } else {\r\n        callBack(result !== false);\r\n      }\r\n    } else {\r\n      callBack(true);\r\n    }\r\n  }\r\n}\r\n\r\nexport default TransitionManager;\r\n","function warning(condition: any, message: string) {\r\n  if (condition) {\r\n    if (console && typeof console.warn === 'function') {\r\n      console.warn(message);\r\n    }\r\n  }\r\n}\r\n\r\nexport default warning;","import { HistoryProps, Listener, Navigation, Prompt } from './types';\r\nimport transitionManager from './transitionManager';\r\n\r\n// 抽取BrowserHistory和HashHistory中相同的方法\r\nexport function getBaseHistory<S>(\r\n  transitionManager: transitionManager<S>,\r\n  setListener: (delta: number) => void,\r\n  browserHistory: History,\r\n) {\r\n  function go(step: number) {\r\n    browserHistory.go(step);\r\n  }\r\n\r\n  function goBack() {\r\n    browserHistory.go(-1);\r\n  }\r\n\r\n  function goForward() {\r\n    browserHistory.go(1);\r\n  }\r\n\r\n  function listen(listener: Listener<S>): () => void {\r\n    const cancel = transitionManager.addListener(listener);\r\n    setListener(1);\r\n    return () => {\r\n      setListener(-1);\r\n      cancel();\r\n    };\r\n  }\r\n\r\n  let isBlocked = false;\r\n\r\n  function block(prompt: Prompt<S> = false): () => void {\r\n    const unblock = transitionManager.setPrompt(prompt);\r\n    if (!isBlocked) {\r\n      setListener(1);\r\n      isBlocked = true;\r\n    }\r\n    return () => {\r\n      if (isBlocked) {\r\n        isBlocked = false;\r\n        setListener(-1);\r\n      }\r\n      unblock();\r\n    };\r\n  }\r\n\r\n  function getUpdateStateFunc(historyProps: HistoryProps<S>) {\r\n    return function (nextState: Navigation<S> | undefined) {\r\n      if (nextState) {\r\n        Object.assign(historyProps, nextState);\r\n      }\r\n      historyProps.length = browserHistory.length;\r\n      const args = { location: historyProps.location, action: historyProps.action };\r\n      transitionManager.notifyListeners(args);\r\n    };\r\n  }\r\n\r\n  return { go, goBack, goForward, listen, block, getUpdateStateFunc };\r\n}\r\n","import { getDefaultConfirmation, isSupportHistory, isSupportsPopState } from './dom';\r\nimport { Action, BaseOption, DefaultStateType, EventType, History, HistoryState, Location, Path, To } from './types';\r\nimport { normalizeSlash, createMemoryRecord, createPath, createLocation, stripBasename } from './utils';\r\nimport TransitionManager from './transitionManager';\r\n\r\nimport warning from './waring';\r\nimport { getBaseHistory } from './baseHistory';\r\n\r\nexport type BrowserHistoryOption = {\r\n  /**\r\n   * forceRefresh为True时跳转时会强制刷新页面\r\n   */\r\n  forceRefresh?: boolean;\r\n} & BaseOption;\r\n\r\nexport function createBrowserHistory<S = DefaultStateType>(options: BrowserHistoryOption = {}): History<S> {\r\n  const supportHistory = isSupportHistory();\r\n  const isSupportPopState = isSupportsPopState();\r\n  const browserHistory = window.history;\r\n  const { forceRefresh = false, getUserConfirmation = getDefaultConfirmation } = options;\r\n\r\n  const basename = options.basename ? normalizeSlash(options.basename) : '';\r\n\r\n  const initLocation = getLocation(getHistoryState());\r\n\r\n  const recordOperator = createMemoryRecord<string, Location<S>>(initLocation, l => l.key);\r\n\r\n  const transitionManager = new TransitionManager<S>();\r\n\r\n  const { go, goBack, goForward, listen, block, getUpdateStateFunc } = getBaseHistory<S>(\r\n    transitionManager,\r\n    setListener,\r\n    browserHistory,\r\n  );\r\n\r\n  const history: History<S> = {\r\n    action: Action.pop,\r\n    length: browserHistory.length,\r\n    location: initLocation,\r\n    go,\r\n    goBack,\r\n    goForward,\r\n    listen,\r\n    block,\r\n    push,\r\n    replace,\r\n    createHref,\r\n  };\r\n\r\n  const updateState = getUpdateStateFunc(history);\r\n\r\n  function getHistoryState() {\r\n    return supportHistory ? window.history.state : {};\r\n  }\r\n\r\n  function getLocation(historyState: Partial<HistoryState<S>>) {\r\n    const { search, hash } = window.location;\r\n    const { key, state } = historyState || {};\r\n    let pathname = window.location.pathname;\r\n    pathname = basename ? stripBasename(pathname, basename) : pathname;\r\n\r\n    return createLocation<S>('', { pathname, search, hash }, state, key);\r\n  }\r\n\r\n  // 拦截页面POP事件后，防止返回到的页面被重复拦截\r\n  let forceJump = false;\r\n\r\n  function handlePopState(location: Location<S>) {\r\n    if (forceJump) {\r\n      forceJump = false;\r\n      updateState(undefined);\r\n    } else {\r\n      const action = Action.pop;\r\n\r\n      const callback = (isJump: boolean) => {\r\n        if (isJump) {\r\n          // 执行跳转行为\r\n          updateState({ action: action, location: location });\r\n        } else {\r\n          revertPopState(location, history.location);\r\n        }\r\n      };\r\n\r\n      transitionManager.confirmJumpTo(location, action, getUserConfirmation, callback);\r\n    }\r\n  }\r\n\r\n  function popStateListener(event: PopStateEvent) {\r\n    handlePopState(getLocation(event.state));\r\n  }\r\n\r\n  function hashChangeListener() {\r\n    const location = getLocation(getHistoryState());\r\n    handlePopState(location);\r\n  }\r\n\r\n  let listenerCount = 0;\r\n\r\n  function setListener(count: number) {\r\n    listenerCount += count;\r\n    if (listenerCount === 1 && count === 1) {\r\n      window.addEventListener(EventType.PopState, popStateListener);\r\n      if (!isSupportPopState) {\r\n        window.addEventListener(EventType.HashChange, hashChangeListener);\r\n      }\r\n    } else if (listenerCount === 0) {\r\n      window.removeEventListener(EventType.PopState, popStateListener);\r\n      if (!isSupportPopState) {\r\n        window.removeEventListener(EventType.HashChange, hashChangeListener);\r\n      }\r\n    }\r\n  }\r\n\r\n  // 取消页面跳转并恢复到跳转前的页面\r\n  function revertPopState(form: Location<S>, to: Location<S>) {\r\n    const delta = recordOperator.getDelta(to, form);\r\n    if (delta !== 0) {\r\n      go(delta);\r\n      forceJump = true;\r\n    }\r\n  }\r\n\r\n  function createHref(path: Partial<Path>) {\r\n    return basename + createPath(path);\r\n  }\r\n\r\n  function push(to: To, state?: S) {\r\n    const action = Action.push;\r\n    const location = createLocation<S>(history.location, to, state, undefined);\r\n\r\n    transitionManager.confirmJumpTo(location, action, getUserConfirmation, isJump => {\r\n      if (!isJump) {\r\n        return;\r\n      }\r\n      const href = createHref(location);\r\n      const { key, state } = location;\r\n\r\n      if (supportHistory) {\r\n        if (forceRefresh) {\r\n          window.location.href = href;\r\n        } else {\r\n          browserHistory.pushState({ key: key, state: state }, '', href);\r\n          recordOperator.addRecord(history.location, location, action);\r\n          updateState({ action, location });\r\n        }\r\n      } else {\r\n        warning(state !== undefined, 'Browser history cannot push state in browsers that do not support HTML5 history');\r\n        window.location.href = href;\r\n      }\r\n    });\r\n  }\r\n\r\n  function replace(to: To, state?: S) {\r\n    const action = Action.replace;\r\n    const location = createLocation<S>(history.location, to, state, undefined);\r\n\r\n    transitionManager.confirmJumpTo(location, action, getUserConfirmation, isJump => {\r\n      if (!isJump) {\r\n        return;\r\n      }\r\n      const href = createHref(location);\r\n      const { key, state } = location;\r\n      if (supportHistory) {\r\n        if (forceRefresh) {\r\n          window.location.replace(href);\r\n        } else {\r\n          browserHistory.replaceState({ key: key, state: state }, '', href);\r\n          recordOperator.addRecord(history.location, location, action);\r\n          updateState({ action, location });\r\n        }\r\n      } else {\r\n        warning(state !== undefined, 'Browser history cannot push state in browsers that do not support HTML5 history');\r\n        window.location.replace(href);\r\n      }\r\n    });\r\n  }\r\n\r\n  return history;\r\n}\r\n","import { Action, BaseOption, DefaultStateType, EventType, History, Location, To } from './types';\r\nimport {\r\n  addHeadSlash,\r\n  normalizeSlash,\r\n  createMemoryRecord,\r\n  createPath,\r\n  createLocation,\r\n  isLocationEqual,\r\n  stripBasename,\r\n  stripHeadSlash,\r\n} from './utils';\r\nimport { getDefaultConfirmation } from './dom';\r\nimport TransitionManager from './transitionManager';\r\n\r\nimport warning from './waring';\r\nimport { getBaseHistory } from './baseHistory';\r\n\r\nexport type urlHashType = 'slash' | 'noslash';\r\n\r\ntype HashHistoryOption = {\r\n  hashType?: urlHashType;\r\n} & BaseOption;\r\n\r\n// 获取#前的内容\r\nfunction stripHash(path: string): string {\r\n  const idx = path.indexOf('#');\r\n  return idx === -1 ? path : path.substring(0, idx);\r\n}\r\n\r\n// 获取#后的内容\r\nfunction getHashContent(path: string): string {\r\n  const idx = path.indexOf('#');\r\n  return idx === -1 ? '' : path.substring(idx + 1);\r\n}\r\n\r\nexport function createHashHistory<S = DefaultStateType>(option: HashHistoryOption = {}): History<S> {\r\n  const browserHistory = window.history;\r\n  const { hashType = 'slash', getUserConfirmation = getDefaultConfirmation } = option;\r\n\r\n  const basename = option.basename ? normalizeSlash(option.basename) : '';\r\n\r\n  const pathDecoder = addHeadSlash;\r\n  const pathEncoder = hashType === 'slash' ? addHeadSlash : stripHeadSlash;\r\n\r\n  function getLocation() {\r\n    let hashPath = pathDecoder(getHashContent(window.location.hash));\r\n    if (basename) {\r\n      hashPath = stripBasename(hashPath, basename);\r\n    }\r\n\r\n    return createLocation<S>('', hashPath, undefined, 'default');\r\n  }\r\n\r\n  const initLocation = getLocation();\r\n\r\n  const memRecords = createMemoryRecord<string, Location<S>>(initLocation, createPath);\r\n\r\n  const transitionManager = new TransitionManager<S>();\r\n\r\n  function createHref(location: Location<S>) {\r\n    const tag = document.querySelector('base');\r\n    const base = tag && tag.getAttribute('href') ? stripHash(window.location.href) : '';\r\n    return base + '#' + pathEncoder(basename + createPath(location));\r\n  }\r\n\r\n  let forceNextPop = false;\r\n  let ignorePath: null | string = null;\r\n\r\n  const { go, goBack, goForward, listen, block, getUpdateStateFunc } = getBaseHistory(\r\n    transitionManager,\r\n    setListener,\r\n    browserHistory,\r\n  );\r\n\r\n  const history: History<S> = {\r\n    action: Action.pop,\r\n    length: browserHistory.length,\r\n    location: initLocation,\r\n    go,\r\n    goBack,\r\n    goForward,\r\n    push,\r\n    replace,\r\n    listen,\r\n    block,\r\n    createHref,\r\n  };\r\n\r\n  const updateState = getUpdateStateFunc(history);\r\n\r\n  function push(to: To, state?: S) {\r\n    warning(state !== undefined, 'Hash history does not support state, it will be ignored');\r\n\r\n    const action = Action.push;\r\n    const location = createLocation<S>(history.location, to, undefined, '');\r\n\r\n    transitionManager.confirmJumpTo(location, action, getUserConfirmation, isJump => {\r\n      if (!isJump) {\r\n        return;\r\n      }\r\n      const path = createPath(location);\r\n      const encodedPath = pathEncoder(basename + path);\r\n      // 前后hash不一样才进行跳转\r\n      if (getHashContent(window.location.href) !== encodedPath) {\r\n        ignorePath = encodedPath;\r\n        window.location.hash = encodedPath;\r\n\r\n        memRecords.addRecord(history.location, location, action);\r\n\r\n        updateState({ action, location });\r\n      } else {\r\n        updateState(undefined);\r\n      }\r\n    });\r\n  }\r\n\r\n  function replace(to: To, state?: S) {\r\n    warning(state !== undefined, 'Hash history does not support state, it will be ignored');\r\n    const action = Action.replace;\r\n    const location = createLocation<S>(history.location, to, undefined, '');\r\n\r\n    transitionManager.confirmJumpTo(location, action, getUserConfirmation, isJump => {\r\n      if (!isJump) {\r\n        return;\r\n      }\r\n      const path = createPath(location);\r\n      const encodedPath = pathEncoder(basename + path);\r\n      if (getHashContent(window.location.href) !== encodedPath) {\r\n        ignorePath = path;\r\n        window.location.replace(stripHash(window.location.href) + '#' + encodedPath);\r\n      }\r\n      memRecords.addRecord(history.location, location, action);\r\n      updateState({ action, location });\r\n    });\r\n  }\r\n\r\n  function handleHashChange() {\r\n    const hashPath = getHashContent(window.location.href);\r\n    const encodedPath = pathEncoder(hashPath);\r\n    if (hashPath !== encodedPath) {\r\n      window.location.replace(stripHash(window.location.href) + '#' + encodedPath);\r\n    } else {\r\n      const location = getLocation();\r\n      const prevLocation = history.location;\r\n      if (!forceNextPop && isLocationEqual(location, prevLocation)) {\r\n        return;\r\n      }\r\n      if (ignorePath === createPath(location)) {\r\n        return;\r\n      }\r\n      ignorePath = null;\r\n      handlePopState(location);\r\n    }\r\n  }\r\n\r\n  function handlePopState(location: Location<S>) {\r\n    if (forceNextPop) {\r\n      forceNextPop = false;\r\n      updateState(undefined);\r\n    } else {\r\n      const action = Action.pop;\r\n\r\n      const callback = (isJump: boolean) => {\r\n        if (isJump) {\r\n          updateState({ action: action, location: location });\r\n        } else {\r\n          revertPopState(location);\r\n        }\r\n      };\r\n\r\n      transitionManager.confirmJumpTo(location, action, getUserConfirmation, callback);\r\n    }\r\n  }\r\n\r\n  // 在跳转行为被Block后，用History.go()跳转回之前的页面\r\n  function revertPopState(form: Location<S>) {\r\n    const to = history.location;\r\n    const delta = memRecords.getDelta(to, form);\r\n    if (delta !== 0) {\r\n      go(delta);\r\n      forceNextPop = true;\r\n    }\r\n  }\r\n\r\n  let listenerCount = 0;\r\n\r\n  function setListener(delta: number) {\r\n    listenerCount += delta;\r\n    if (listenerCount === 1 && delta === 1) {\r\n      window.addEventListener(EventType.HashChange, handleHashChange);\r\n    } else if (listenerCount === 0) {\r\n      window.removeEventListener(EventType.HashChange, handleHashChange);\r\n    }\r\n  }\r\n\r\n  return history;\r\n}\r\n","import { createContext } from 'react';\r\nimport { History, Location } from './index';\r\nimport { Matched } from './matcher/parser';\r\n\r\nfunction createNamedContext<T>(name: string, defaultValue: T) {\r\n  const context = createContext<T>(defaultValue);\r\n  context.displayName = name;\r\n  return context;\r\n}\r\n\r\nexport type RouterContextValue = {\r\n  history: History;\r\n  location: Location;\r\n  match: Matched | null;\r\n};\r\n\r\nconst RouterContext = createNamedContext<RouterContextValue>('Router', {} as any);\r\n\r\nexport default RouterContext;","import { Matched, Params } from './parser';\r\n\r\nexport type Token = {\r\n  type: TokenType;\r\n  value: string;\r\n};\r\n\r\nexport enum TokenType {\r\n  Delimiter = 'delimiter',\r\n  Static = 'static',\r\n  Param = 'param',\r\n  WildCard = 'wildcard',\r\n  LBracket = '(',\r\n  RBracket = ')',\r\n  Pattern = 'pattern',\r\n}\r\n\r\nexport interface Parser<P> {\r\n  regexp: RegExp;\r\n\r\n  keys: string[];\r\n\r\n  parse(url: string): Matched<P> | null;\r\n\r\n  compile(params: Params<P>): string;\r\n}\r\n\r\nexport type ParserOption = {\r\n  // 是否大小写敏感\r\n  caseSensitive?: boolean;\r\n  // 是否启用严格模式\r\n  strictMode?: boolean;\r\n  // 精准匹配 兼容 React-RouterV5\r\n  exact?: boolean;\r\n};\r\n\r\ntype ClearLeading<U extends string> = U extends `/${infer R}` ? ClearLeading<R> : U;\r\ntype ClearTailing<U extends string> = U extends `${infer L}/` ? ClearTailing<L> : U;\r\n\r\ntype ParseParam<Param extends string> = Param extends `:${infer R}`\r\n  ? {\r\n    [K in R]: string;\r\n  }\r\n  : {};\r\n\r\ntype MergeParams<OneParam extends Record<string, any>, OtherParam extends Record<string, any>> = {\r\n  readonly [Key in keyof OneParam | keyof OtherParam]?: string;\r\n};\r\n\r\ntype ParseURLString<Str extends string> = Str extends `${infer Param}/${infer Rest}`\r\n  ? MergeParams<ParseParam<Param>, ParseURLString<ClearLeading<Rest>>>\r\n  : ParseParam<Str>;\r\n\r\n// 解析URL中的动态参数，以实现TypeScript提示功能\r\nexport type GetURLParams<U extends string> = ParseURLString<ClearLeading<ClearTailing<U>>>;\r\n","/**\r\n * @description 将url中的//转换为/\r\n */\r\nexport function cleanPath(path: string): string {\r\n  return path.replace(/\\/+/g, '/');\r\n}\r\n\r\nexport function scoreCompare(score1: number[], score2: number[]): number {\r\n  const score1Length = score1.length;\r\n  const score2Length = score2.length;\r\n  const end = Math.min(score1Length, score2Length);\r\n  for (let i = 0; i < end; i++) {\r\n    const delta = score2[i] - score1[i];\r\n    if (delta !== 0) {\r\n      return delta;\r\n    }\r\n  }\r\n  if (score1Length === score2Length) {\r\n    return 0;\r\n  }\r\n  return score1Length > score2Length ? -1 : 1;\r\n}\r\n\r\n// 把正则表达式的特殊符号加两个反斜杠进行转义\r\nexport function escapeStr(str: string) {\r\n  return str.replace(/([.+*?=^!:${}()[\\]|/\\\\])/g, '\\\\$1');\r\n}\r\n","import { Token, TokenType } from './types';\r\nimport { cleanPath } from './utils';\r\n\r\nconst validChar = /[^/:*()]/;\r\n\r\n// 对Url模板进行词法解析，解析结果为Tokens\r\nexport function lexer(path: string): Token[] {\r\n  const tokens: Token[] = [];\r\n\r\n  if (!path) {\r\n    return tokens;\r\n  }\r\n\r\n  let urlPath = cleanPath(path);\r\n  if (urlPath !== '*' && !urlPath.startsWith('/')) {\r\n    throw new Error(`Url must start with \"/\".`);\r\n  }\r\n\r\n  const getLiteral = () => {\r\n    let name = '';\r\n    while (i < urlPath.length && validChar.test(urlPath[i])) {\r\n      name += urlPath[i];\r\n      skipChar(1);\r\n    }\r\n    return name;\r\n  };\r\n\r\n  const skipChar = (step: number) => {\r\n    i += step;\r\n  };\r\n\r\n  let i = 0;\r\n  while (i < urlPath.length) {\r\n    const curChar = urlPath[i];\r\n    const prevChar = urlPath[i - 1];\r\n\r\n    if (curChar === '/') {\r\n      tokens.push({ type: TokenType.Delimiter, value: urlPath[i] });\r\n      skipChar(1);\r\n      continue;\r\n    }\r\n    // dynamic params (/:a)\r\n    if (prevChar === '/' && curChar === ':') {\r\n      skipChar(1);\r\n      tokens.push({ type: TokenType.Param, value: getLiteral() });\r\n      continue;\r\n    }\r\n    // wildCard params (/:*)\r\n    if ((prevChar === '/' || prevChar === undefined) && curChar === '*') {\r\n      tokens.push({ type: TokenType.WildCard, value: urlPath[i] });\r\n      skipChar(1);\r\n      continue;\r\n    }\r\n    // static params\r\n    if (prevChar === '/' && validChar.test(curChar)) {\r\n      tokens.push({ type: TokenType.Static, value: getLiteral() });\r\n      continue;\r\n    }\r\n    if (curChar === '(') {\r\n      tokens.push({ type: TokenType.LBracket, value: '(' });\r\n      skipChar(1);\r\n      continue;\r\n    }\r\n    if (curChar === ')') {\r\n      tokens.push({ type: TokenType.RBracket, value: ')' });\r\n      skipChar(1);\r\n      continue;\r\n    }\r\n    if (validChar.test(curChar)) {\r\n      tokens.push({ type: TokenType.Pattern, value: getLiteral() });\r\n      continue;\r\n    }\r\n    // 跳过非法字符\r\n    skipChar(1);\r\n  }\r\n\r\n  return tokens;\r\n}\r\n","import { GetURLParams, Parser, ParserOption, TokenType } from './types';\r\nimport { lexer } from './lexer';\r\nimport { escapeStr, scoreCompare } from './utils';\r\n\r\n// 不同类型参数的匹配得分\r\nenum MatchScore {\r\n  // 固定参数\r\n  static = 10,\r\n  // 动态参数\r\n  param = 6,\r\n  // 通配符参数\r\n  wildcard = 3,\r\n  placeholder = -1,\r\n}\r\n\r\nexport type Params<P> = { [K in keyof P]?: P[K] };\r\n\r\n// 兼容 react v5 matched类型\r\nexport type Matched<P = any> = {\r\n  score: number[];\r\n  params: Params<P>;\r\n  path: string;\r\n  url: string;\r\n  isExact: boolean;\r\n};\r\n\r\nconst defaultOption: Required<ParserOption> = {\r\n  // url匹配时是否大小写敏感\r\n  caseSensitive: true,\r\n  // 是否严格匹配url结尾的/\r\n  strictMode: false,\r\n  // 是否完全精确匹配\r\n  exact: false,\r\n};\r\n// 正则表达式中需要转义的字符\r\nconst REGEX_CHARS_RE = /[.+*?^${}()[\\]/\\\\]/g;\r\n// 用于匹配两个//中的的值\r\nconst BASE_PARAM_PATTERN = '[^/]+';\r\n\r\nconst DefaultDelimiter = '/#?';\r\n\r\nexport function createPathParser<Str extends string>(pathname: Str, option?: ParserOption): Parser<GetURLParams<Str>>;\r\nexport function createPathParser<P = unknown>(pathname: string, option?: ParserOption): Parser<P>;\r\nexport function createPathParser<P = unknown>(pathname: string, option: ParserOption = defaultOption): Parser<P> {\r\n  const {\r\n    caseSensitive = defaultOption.caseSensitive,\r\n    strictMode = defaultOption.strictMode,\r\n    exact = defaultOption.exact,\r\n  } = option;\r\n  /**\r\n   * URL匹配整体流程\r\n   * 1.词法解析，将URL模板解析为Token\r\n   * 2.使用Token生成正则表达式\r\n   * 3.利用正则表达式解析URL中参数或填充URL模板\r\n   */\r\n  let pattern = '^';\r\n  const keys: string[] = [];\r\n  const scores: number[] = [];\r\n\r\n  const tokens = lexer(pathname);\r\n  const onlyHasWildCard = tokens.length === 1 && tokens[0].type === TokenType.WildCard;\r\n  const tokenCount = tokens.length;\r\n  const lastToken = tokens[tokenCount - 1];\r\n\r\n  for (let tokenIdx = 0; tokenIdx < tokenCount; tokenIdx++) {\r\n    const token = tokens[tokenIdx];\r\n    const nextToken = tokens[tokenIdx + 1];\r\n    switch (token.type) {\r\n      case TokenType.Delimiter:\r\n        pattern += '/';\r\n        break;\r\n      case TokenType.Static:\r\n        pattern += token.value.replace(REGEX_CHARS_RE, '\\\\$&');\r\n        scores.push(MatchScore.static);\r\n        break;\r\n      case TokenType.Param:\r\n        let paramRegexp = '';\r\n        if (nextToken && nextToken.type === TokenType.LBracket) {\r\n          // 跳过当前Token和左括号\r\n          tokenIdx += 2;\r\n          while (tokens[tokenIdx].type !== TokenType.RBracket) {\r\n            paramRegexp += tokens[tokenIdx].value;\r\n            tokenIdx++;\r\n          }\r\n        }\r\n        pattern += paramRegexp ? `((?:${paramRegexp}))` : `(${BASE_PARAM_PATTERN})`;\r\n        keys.push(token.value);\r\n        scores.push(MatchScore.param);\r\n        break;\r\n      case TokenType.WildCard:\r\n        keys.push(token.value);\r\n        pattern += `((?:${BASE_PARAM_PATTERN})${onlyHasWildCard ? '?' : ''}(?:/(?:${BASE_PARAM_PATTERN}))*)`;\r\n        scores.push(onlyHasWildCard ? MatchScore.wildcard : MatchScore.placeholder);\r\n        break;\r\n    }\r\n  }\r\n  const isWildCard = lastToken.type === TokenType.WildCard;\r\n\r\n  if (!isWildCard && !exact) {\r\n    if (!strictMode) {\r\n      pattern += `(?:[${escapeStr(DefaultDelimiter)}](?=$))?`;\r\n    }\r\n    if (lastToken.type !== TokenType.Delimiter) {\r\n      pattern += `(?=[${escapeStr(DefaultDelimiter)}]|$)`;\r\n    }\r\n  } else {\r\n    pattern += strictMode ? '$' : `[${escapeStr(DefaultDelimiter)}]?$`;\r\n  }\r\n\r\n  const flag = caseSensitive ? '' : 'i';\r\n  const regexp = new RegExp(pattern, flag);\r\n\r\n  /**\r\n   * @description 根据给定Pattern解析path\r\n   */\r\n  function parse(path: string): Matched<P> | null {\r\n    const reMatch = path.match(regexp);\r\n\r\n    if (!reMatch) {\r\n      return null;\r\n    }\r\n    const matchedPath = reMatch[0];\r\n    let params: Params<P> = {};\r\n    let parseScore: number[] = Array.from(scores);\r\n    for (let i = 1; i < reMatch.length; i++) {\r\n      let param = reMatch[i];\r\n      let key = keys[i - 1];\r\n      if (key === '*' && param) {\r\n        let value = param.split('/');\r\n        if (!Array.isArray(params['*'])) {\r\n          params['*'] = value;\r\n        } else {\r\n          params['*'].push(...value);\r\n        }\r\n        // 完成通配符参数解析后将placeholder替换为wildcard参数的分值\r\n        parseScore.splice(\r\n          scores.indexOf(MatchScore.placeholder),\r\n          1,\r\n          ...new Array(value.length).fill(MatchScore.wildcard),\r\n        );\r\n      } else {\r\n        params[key] = param ? param : [];\r\n      }\r\n    }\r\n\r\n    const isExact = path === matchedPath;\r\n    const url = path === '/' && matchedPath === '' ? '/' : matchedPath;\r\n    return { isExact: isExact, path: pathname, url: url, score: parseScore, params: params };\r\n  }\r\n\r\n  /**\r\n   * @description 使用给定参数填充pattern，得到目标URL\r\n   */\r\n  function compile(params: Params<P>): string {\r\n    let path = '';\r\n    for (const token of tokens) {\r\n      switch (token.type) {\r\n        case TokenType.Static:\r\n          path += token.value;\r\n          break;\r\n        case TokenType.Param:\r\n          if (!params[token.value]) {\r\n            throw new Error('Param is invalid.');\r\n          }\r\n          path += params[token.value];\r\n          break;\r\n        case TokenType.WildCard:\r\n          let wildCard = params['*'];\r\n          if (wildCard instanceof Array) {\r\n            path += wildCard.join('/');\r\n          } else {\r\n            path += wildCard;\r\n          }\r\n          break;\r\n        case TokenType.Delimiter:\r\n          path += token.value;\r\n          break;\r\n      }\r\n    }\r\n    return path;\r\n  }\r\n\r\n  return {\r\n    get regexp() {\r\n      return regexp;\r\n    },\r\n    get keys() {\r\n      return keys;\r\n    },\r\n    compile,\r\n    parse,\r\n  };\r\n}\r\n\r\n/**\r\n * @description 依次使用pathname与pattern进行匹配，根据匹配分数取得分数最高结果\r\n */\r\nexport function matchPath<P = any>(\r\n  pathname: string,\r\n  pattern: string | string[],\r\n  option?: ParserOption,\r\n): Matched<P> | null {\r\n  const patterns = Array.isArray(pattern) ? [...pattern] : [pattern];\r\n  const matchedResults: Matched<P>[] = [];\r\n  for (const item of patterns) {\r\n    const parser = createPathParser(item, option);\r\n    const matched = parser.parse(pathname);\r\n    if (matched) {\r\n      matchedResults.push(matched);\r\n    }\r\n  }\r\n  return !matchedResults.length ? null : matchedResults.sort((a, b) => scoreCompare(a.score, b.score))[0];\r\n}\r\n\r\nexport function generatePath<P = any>(path: string, params: Params<P>) {\r\n  const parser = createPathParser(path);\r\n  return parser.compile(params);\r\n}","import { useContext } from 'react';\r\nimport RouterContext from './context';\r\nimport { Matched, matchPath, Params } from './matcher/parser';\r\nimport { History } from '../history/types';\r\nimport { Location } from './index';\r\n\r\nfunction useHistory<S>(): History<S>;\r\nfunction useHistory() {\r\n  return useContext(RouterContext).history;\r\n}\r\n\r\nfunction useLocation<S>(): Location<S>;\r\nfunction useLocation() {\r\n  return useContext(RouterContext).location;\r\n}\r\n\r\nfunction useParams<P>(): Params<P> | {};\r\nfunction useParams() {\r\n  const match = useContext(RouterContext).match;\r\n  return match ? match.params : {};\r\n}\r\n\r\nfunction useRouteMatch<P>(path?: string): Matched<P> | null;\r\nfunction useRouteMatch(path?: string) {\r\n  const pathname = useLocation().pathname;\r\n  const match = useContext(RouterContext).match;\r\n  if (path) {\r\n    return matchPath(pathname, path);\r\n  }\r\n  return match;\r\n}\r\n\r\nexport { useHistory, useLocation, useParams, useRouteMatch };\r\n","import * as React from 'react';\r\nimport { History, Location } from './index';\r\nimport { Matched, matchPath } from './matcher/parser';\r\nimport { useContext, Children, createElement } from 'react';\r\nimport RouterContext from './context';\r\nimport { GetURLParams } from './matcher/types';\r\n\r\nexport type RouteComponentProps<P extends Record<string, any> = {}, S = unknown> = RouteChildrenProps<P, S>;\r\n\r\nexport type RouteChildrenProps<P extends Record<string, any> = {}, S = unknown> = {\r\n  history: History<S>;\r\n  location: Location<S>;\r\n  match: Matched<P> | null\r\n}\r\n\r\nexport type RouteProps<P extends Record<string, any> = {}, Path extends string = string> = {\r\n  location?: Location;\r\n  component?: React.ComponentType<RouteComponentProps<P>> | React.ComponentType<any> | undefined;\r\n  children?: ((props: RouteChildrenProps<P>) => React.ReactNode) | React.ReactNode;\r\n  render?: (props: RouteComponentProps<P>) => React.ReactNode;\r\n  path?: Path | Path[];\r\n  exact?: boolean;\r\n  sensitive?: boolean;\r\n  strict?: boolean;\r\n  computed?: Matched<P>;\r\n};\r\n\r\nfunction Route<Path extends string, P extends Record<string, any> = GetURLParams<Path>>(props: RouteProps<P, Path>) {\r\n  const context = useContext(RouterContext);\r\n\r\n  const { computed, location, path } = props;\r\n  let { children, component, render } = props;\r\n  let match: Matched<P> | null;\r\n\r\n  const routeLocation = location || context.location;\r\n  if (computed) {\r\n    match = computed;\r\n  } else if (path) {\r\n    match = matchPath<P>(routeLocation.pathname, path);\r\n  } else {\r\n    match = context.match;\r\n  }\r\n  const newProps = { ...context, location: routeLocation, match: match };\r\n\r\n  if (Array.isArray(children) && Children.count(children) === 0) {\r\n    children = null;\r\n  }\r\n\r\n  /**\r\n   * 按顺序获取需要渲染的组件\r\n   * 1.children\r\n   * 2.component\r\n   * 3.render\r\n   * 都没有匹配到返回Null\r\n   */\r\n  const getChildren = (): React.ReactNode | null => {\r\n    // 如果 match 存在\r\n    if (newProps.match) {\r\n      if (children) {\r\n        if (typeof children === 'function') {\r\n          return children(newProps);\r\n        }\r\n        return children;\r\n      }\r\n\r\n      if (component) {\r\n        return createElement(component, newProps);\r\n      } else if (render) {\r\n        return render(newProps);\r\n      } else {\r\n        return null;\r\n      }\r\n    } else {\r\n      // match为null\r\n      if (typeof children === 'function') {\r\n        return children(newProps);\r\n      }\r\n      return null;\r\n    }\r\n  };\r\n\r\n  return <RouterContext.Provider value={newProps}>{getChildren()}</RouterContext.Provider>;\r\n}\r\n\r\nexport default Route;\r\n","import * as React from 'react';\r\nimport { useLayoutEffect, useMemo, useRef, useState } from 'react';\r\n\r\nimport { History, Location } from '../history/types';\r\n\r\nimport RouterContext, { RouterContextValue } from './context';\r\n\r\nexport type RouterProps = {\r\n  history: History;\r\n  children?: React.ReactNode;\r\n};\r\n\r\nfunction Router<P extends RouterProps>(props: P) {\r\n  const { history, children = null } = props;\r\n  const [location, setLocation] = useState(props.history.location);\r\n  const pendingLocation = useRef<Location | null>(null);\r\n\r\n  // 在Router加载时就监听history地址变化，以保证在始渲染时重定向能正确触发\r\n  let unListen: null | (() => void) = history.listen(arg => {\r\n    pendingLocation.current = arg.location;\r\n  });\r\n\r\n  // 模拟componentDidMount和componentWillUnmount\r\n  useLayoutEffect(() => {\r\n    if (unListen) {\r\n      unListen();\r\n    }\r\n    // 监听history中的位置变化\r\n    unListen = history.listen(arg => {\r\n      setLocation(arg.location);\r\n    });\r\n\r\n    if (pendingLocation.current) {\r\n      setLocation(pendingLocation.current);\r\n    }\r\n\r\n    return () => {\r\n      if (unListen) {\r\n        unListen();\r\n        unListen = null;\r\n        pendingLocation.current = null;\r\n      }\r\n    };\r\n  }, []);\r\n\r\n  const initContextValue: RouterContextValue = useMemo(\r\n    () => ({\r\n      history: history,\r\n      location: location,\r\n      match: { isExact: location.pathname === '/', params: {}, path: '/', score: [], url: '/' },\r\n    }),\r\n    [location],\r\n  );\r\n\r\n  return <RouterContext.Provider value={initContextValue} children={children} />;\r\n}\r\n\r\nexport default Router;\r\n","export default function _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n  return target;\n}","import { useLayoutEffect, useRef } from 'react';\r\n\r\nexport type LifeCycleProps = {\r\n  onMount?: () => void;\r\n  onUpdate?: (prevProps?: LifeCycleProps) => void;\r\n  onUnmount?: () => void;\r\n  data?: any;\r\n};\r\n\r\nexport function LifeCycle(props: LifeCycleProps) {\r\n  // 使用ref保存上一次的props，防止重新渲染\r\n  const prevProps = useRef<LifeCycleProps | null>(null);\r\n  const isMount = useRef(false);\r\n\r\n  const { onMount, onUpdate, onUnmount } = props;\r\n\r\n  useLayoutEffect(() => {\r\n    // 首次挂载 模拟componentDidMount\r\n    if (!isMount.current) {\r\n      isMount.current = true;\r\n      if (onMount) {\r\n        onMount();\r\n      }\r\n    } else {\r\n      // 不是首次渲染 模拟componentDidUpdate\r\n      if (onUpdate) {\r\n        prevProps.current ? onUpdate(prevProps.current) : onUpdate();\r\n      }\r\n    }\r\n    prevProps.current = props;\r\n  });\r\n\r\n  // 模拟componentWillUnmount\r\n  useLayoutEffect(() => {\r\n    return () => {\r\n      if (onUnmount) {\r\n        onUnmount();\r\n      }\r\n    };\r\n  }, []);\r\n\r\n  return null;\r\n}\r\n","import * as React from 'react';\r\nimport { useContext } from 'react';\r\nimport RouterContext from './context';\r\nimport { LifeCycle, LifeCycleProps } from './lifeCycleHook';\r\nimport { Matched, createPathParser } from './matcher/parser';\r\nimport { addHeadSlash, isLocationEqual, parsePath } from '../history/utils';\r\nimport { Location } from './index';\r\n\r\nexport type RedirectProps = {\r\n  to: string | Partial<Location>;\r\n  push?: boolean;\r\n  path?: string;\r\n  from?: string;\r\n  exact?: boolean;\r\n  strict?: boolean;\r\n\r\n  // 由Switch计算得到\r\n  readonly computed?: Matched | null;\r\n};\r\n\r\nfunction Redirect<P extends RedirectProps>(props: P) {\r\n  const { to, push = false, computed } = props;\r\n\r\n  const context = useContext(RouterContext);\r\n  const { history } = context;\r\n\r\n  const calcLocation = (): Partial<Location> => {\r\n    if (computed) {\r\n      if (typeof to === 'string') {\r\n        const parser = createPathParser(to);\r\n        const target = parser.compile(computed.params);\r\n        return parsePath(target);\r\n      } else {\r\n        const pathname = to.pathname ? addHeadSlash(to.pathname) : '/';\r\n        const parser = createPathParser(pathname);\r\n        const target = parser.compile(computed.params);\r\n        return { ...to, pathname: target };\r\n      }\r\n    }\r\n    return typeof to === 'string' ? parsePath(to) : to;\r\n  };\r\n\r\n  const navigate = push ? history.push : history.replace;\r\n  const { state, ...path } = calcLocation();\r\n\r\n  const onMountFunc = () => {\r\n    navigate(path, state);\r\n  };\r\n\r\n  const onUpdateFunc = (prevProps?: LifeCycleProps) => {\r\n    // 如果当前页面与重定向前页面不一致，执行跳转\r\n    const prevPath = prevProps?.data as Location;\r\n    if (!isLocationEqual(prevPath, path)) {\r\n      navigate(path, state);\r\n    }\r\n  };\r\n\r\n  return <LifeCycle onMount={onMountFunc} onUpdate={onUpdateFunc} data={path} />;\r\n}\r\n\r\nexport default Redirect;\r\n","import * as React from 'react';\r\nimport { useContext, Children, isValidElement, cloneElement } from 'react';\r\n\r\nimport { Location } from './index';\r\nimport RouterContext from './context';\r\nimport { Matched, matchPath } from './matcher/parser';\r\nimport Route, { RouteProps } from './Route';\r\nimport Redirect, { RedirectProps } from './Redirect';\r\n\r\nexport type SwitchProps = {\r\n  location?: Location;\r\n  children?: React.ReactNode;\r\n};\r\n\r\nfunction Switch<P extends SwitchProps>(props: P): React.ReactElement | null {\r\n  const context = useContext(RouterContext);\r\n  const location = props.location || context.location;\r\n\r\n  let element: React.ReactElement | null = null;\r\n  let match: Matched | null = null;\r\n\r\n  // 使用forEach不会给React.ReactNode增加key属性,防止重新渲染\r\n  Children.forEach(props.children, node => {\r\n    if (match === null && isValidElement(node)) {\r\n      element = node;\r\n\r\n      let strict: boolean | undefined;\r\n      let sensitive: boolean | undefined;\r\n      let path: string | string[] | undefined;\r\n      let from: string | undefined;\r\n\r\n      // node可能是Route和Redirect\r\n      if (node.type === Route) {\r\n        const props = node.props as RouteProps;\r\n        strict = props.strict;\r\n        sensitive = props.sensitive;\r\n        path = props.path;\r\n      } else if (node.type === Redirect) {\r\n        const props = node.props as RedirectProps;\r\n        path = props.path;\r\n        strict = props.strict;\r\n        from = props.from;\r\n      }\r\n\r\n      const exact = node.props.exact;\r\n      const target = path || from;\r\n\r\n      // 更新匹配状态，一旦匹配到停止遍历\r\n      if (target) {\r\n        match = matchPath(location.pathname, target, {\r\n          strictMode: strict,\r\n          caseSensitive: sensitive,\r\n          exact: exact,\r\n        });\r\n      } else {\r\n        match = context.match;\r\n      }\r\n    }\r\n  });\r\n\r\n  if (match && element) {\r\n    // 使用cloneElement复制已有组件并更新其Props\r\n    return cloneElement(element, { location: location, computed: match });\r\n  }\r\n  return null;\r\n}\r\n\r\nexport default Switch;\r\n","import * as React from 'react';\r\nimport { useContext } from 'react';\r\nimport { LifeCycle, LifeCycleProps } from './lifeCycleHook';\r\nimport { Location } from './index';\r\nimport { Action } from '../history/types';\r\nimport RouterContext from './context';\r\n\r\ntype PromptProps = {\r\n  message?: string | ((location: Partial<Location>, action: Action) => void);\r\n  when?: boolean | ((location: Partial<Location>) => boolean);\r\n};\r\n\r\nfunction Prompt<P extends PromptProps>(props: P) {\r\n  const context = useContext(RouterContext);\r\n\r\n  const { message, when = true } = props;\r\n\r\n  if ((typeof when === 'function' && when(context.location) === false) || !when) {\r\n    return null;\r\n  }\r\n\r\n  const navigate = context.history.block;\r\n\r\n  let release: (() => void) | null = null;\r\n\r\n  const onMountFunc = () => {\r\n    release = message ? navigate(message) : null;\r\n  };\r\n\r\n  const onUpdateFunc = (prevProps?: LifeCycleProps) => {\r\n    if (prevProps && prevProps.data !== message) {\r\n      if (release) {\r\n        release();\r\n      }\r\n      release = message ? navigate(message) : null;\r\n    }\r\n  };\r\n\r\n  const onUnmountFunc = () => {\r\n    if (release) {\r\n      release();\r\n    }\r\n    release = null;\r\n  };\r\n\r\n  return <LifeCycle onMount={onMountFunc} onUpdate={onUpdateFunc} onUnmount={onUnmountFunc} data={message} />;\r\n}\r\n\r\nexport default Prompt;\r\n","import * as React from 'react';\r\nimport { useContext } from 'react';\r\nimport RouterContext from './context';\r\n\r\nfunction withRouter<C extends React.ComponentType>(Component: C) {\r\n\r\n  function ComponentWithRouterProp(props: any) {\r\n    const { history, location, match } = useContext(RouterContext);\r\n    const routeProps = { history: history, location: location, match: match };\r\n\r\n    return <Component {...props} {...routeProps} />;\r\n  }\r\n\r\n  return ComponentWithRouterProp;\r\n}\r\n\r\nexport default withRouter;","import * as React from 'react';\r\nimport { useRef } from 'react';\r\nimport { History } from '../history/types';\r\nimport { BaseRouterProps } from './BrowserRouter';\r\nimport { createHashHistory, urlHashType } from '../history/hashHistory';\r\nimport Router from './Router';\r\n\r\nexport type HashRouterProps = BaseRouterProps & {\r\n  hashType: urlHashType;\r\n};\r\n\r\nfunction HashRouter<P extends Partial<HashRouterProps>>(props: P) {\r\n  let historyRef = useRef<History>();\r\n  if (historyRef.current === null || historyRef.current === undefined) {\r\n    historyRef.current = createHashHistory({\r\n      basename: props.basename,\r\n      getUserConfirmation: props.getUserConfirmation,\r\n      hashType: props.hashType,\r\n    });\r\n  }\r\n\r\n  return <Router history={historyRef.current}>{props.children}</Router>;\r\n}\r\n\r\nexport default HashRouter;","import * as React from 'react';\r\nimport { useRef, ReactNode } from 'react';\r\nimport Router from './Router';\r\nimport { createBrowserHistory } from '../history/browerHistory';\r\nimport { ConfirmationFunc, History } from '../history/types';\r\n\r\nexport type BaseRouterProps = {\r\n  basename: string;\r\n  getUserConfirmation: ConfirmationFunc;\r\n  children?: ReactNode;\r\n};\r\n\r\nexport type BrowserRouterProps = BaseRouterProps & {\r\n  forceRefresh: boolean;\r\n};\r\n\r\nfunction BrowserRouter<P extends Partial<BrowserRouterProps>>(props: P) {\r\n  // 使用Ref持有History对象，防止重复渲染\r\n  let historyRef = useRef<History>();\r\n\r\n  if (historyRef.current === null || historyRef.current === undefined) {\r\n    historyRef.current = createBrowserHistory({\r\n      basename: props.basename,\r\n      forceRefresh: props.forceRefresh,\r\n      getUserConfirmation: props.getUserConfirmation,\r\n    });\r\n  }\r\n\r\n  return <Router history={historyRef.current}>{props.children}</Router>;\r\n}\r\n\r\nexport default BrowserRouter;","import * as React from 'react';\r\nimport { useContext } from 'react';\r\nimport RouterContext from './context';\r\nimport { Location } from './index';\r\nimport { createPath, parsePath } from '../history/utils';\r\nimport { Path } from '../history/types';\r\n\r\nexport type LinkProps = {\r\n  component?: React.ComponentType<any>;\r\n  to: Partial<Location> | string | ((location: Location) => string | Partial<Location>);\r\n  replace?: boolean;\r\n  tag?: string;\r\n  /**\r\n   * @deprecated\r\n   * React16以后不再需要该属性\r\n   **/\r\n  innerRef?: React.Ref<HTMLAnchorElement>;\r\n} & React.AnchorHTMLAttributes<HTMLAnchorElement>;\r\n\r\nconst isModifiedEvent = (event: React.MouseEvent) => {\r\n  return event.metaKey || event.altKey || event.ctrlKey || event.shiftKey;\r\n};\r\n\r\nconst checkTarget = (target?: React.HTMLAttributeAnchorTarget) => {\r\n  return !target || target === '_self';\r\n};\r\n\r\n\r\nfunction Link<P extends LinkProps>(props: P) {\r\n  const { to, replace, component, onClick, target, ...other } = props;\r\n\r\n  const tag = props.tag || 'a';\r\n\r\n  const context = useContext(RouterContext);\r\n  const history = context.history;\r\n\r\n  let location = typeof to === 'function' ? to(context.location) : to;\r\n\r\n  let state: any;\r\n  let path: Partial<Path>;\r\n  if (typeof location === 'string') {\r\n    path = parsePath(location);\r\n  } else {\r\n    const { pathname, hash, search } = location;\r\n    path = { pathname, hash, search };\r\n    state = location.state;\r\n  }\r\n  const href = history.createHref(path);\r\n\r\n  const linkClickEvent = (event: React.MouseEvent<HTMLAnchorElement>) => {\r\n    try {\r\n      if (onClick) {\r\n        onClick(event);\r\n      }\r\n    } catch (e) {\r\n      event.preventDefault();\r\n      throw e;\r\n    }\r\n\r\n    if (!event.defaultPrevented && event.button === 0 && checkTarget(target) && !isModifiedEvent(event)) {\r\n      // 不是相同的路径执行push操作，是相同的路径执行replace\r\n      const isSamePath = createPath(context.location) === createPath(path);\r\n      const navigate = replace || isSamePath ? history.replace : history.push;\r\n      event.preventDefault();\r\n      navigate(path, state);\r\n    }\r\n  };\r\n\r\n  const linkProps = { href: href, onClick: linkClickEvent, ...other };\r\n  return React.createElement(tag, linkProps);\r\n}\r\n\r\nexport default Link;","import * as React from 'react';\r\nimport { useContext } from 'react';\r\nimport type { LinkProps } from './Link';\r\nimport Link from './Link';\r\nimport { Location, matchPath } from './index';\r\nimport { Matched } from './matcher/parser';\r\nimport Context from './context';\r\nimport { parsePath } from '../history/utils';\r\nimport { escapeStr } from './matcher/utils';\r\n\r\ntype NavLinkProps = {\r\n  to: Partial<Location> | string | ((location: Location) => string | Partial<Location>);\r\n  isActive?: (match: Matched | null, location: Location) => boolean;\r\n  // compat react-router NavLink props type\r\n  [key: string]: any;\r\n} & LinkProps;\r\n\r\ntype Page = 'page';\r\n\r\nfunction NavLink<P extends NavLinkProps>(props: P) {\r\n  const { to, isActive, ...rest } = props;\r\n  const context = useContext(Context);\r\n\r\n  const toLocation = typeof to === 'function' ? to(context.location) : to;\r\n\r\n  const { pathname: path } = typeof toLocation === 'string' ? parsePath(toLocation) : toLocation;\r\n  // 把正则表达式的特殊符号加两个反斜杠进行转义\r\n  const escapedPath = path ? escapeStr(path) : '';\r\n  const match = escapedPath ? matchPath(context.location.pathname, escapedPath) : null;\r\n\r\n  const isLinkActive = match && isActive ? isActive(match, context.location) : false;\r\n\r\n  const page: Page = 'page';\r\n  const otherProps = {\r\n    'aria-current': isLinkActive ? page : false,\r\n    ...rest,\r\n  };\r\n\r\n  return <Link to={to} {...otherProps} />;\r\n}\r\n\r\nexport default NavLink;\r\n"],"names":["isBrowser","window","document","createElement","getDefaultConfirmation","message","callBack","confirm","isSupportHistory","history","isSupportsPopState","navigator","userAgent","indexOf","Action","EventType","_extends","Object","assign","bind","target","i","arguments","length","source","key","prototype","hasOwnProperty","call","apply","createPath","path","search","hash","pathname","startsWith","parsePath","url","parsedPath","hashIdx","substring","searchIdx","createLocation","current","to","state","urlObj","getRandKey","genRandomKey","location","isLocationEqual","p1","p2","addHeadSlash","stripHeadSlash","normalizeSlash","tempPath","hasBasename","prefix","toLowerCase","includes","charAt","stripBasename","createMemoryRecord","initVal","fn","visitedRecord","getDelta","form","toIdx","lastIndexOf","fromIdx","addRecord","newRecord","action","curVal","NewVal","push","prevIdx","newVisitedRecord","slice","replace","end","Math","random","toString","_classCallCheck","instance","Constructor","TypeError","_typeof","obj","Symbol","iterator","constructor","_toPrimitive","input","hint","prim","toPrimitive","undefined","res","String","Number","_toPropertyKey","arg","_defineProperties","props","descriptor","enumerable","configurable","writable","defineProperty","toPropertyKey","_createClass","protoProps","staticProps","TransitionManager","prompt","listeners","value","setPrompt","_this","addListener","func","_this2","isActive","listener","args","filter","item","notifyListeners","_iterator","_createForOfIteratorHelper","_step","s","n","done","err","e","f","confirmJumpTo","userConfirmationFunc","result","warning","condition","console","warn","getBaseHistory","transitionManager","setListener","browserHistory","go","step","goBack","goForward","listen","cancel","isBlocked","block","unblock","getUpdateStateFunc","historyProps","nextState","createBrowserHistory","options","supportHistory","isSupportPopState","_options$forceRefresh","forceRefresh","_options$getUserConfi","getUserConfirmation","basename","initLocation","getLocation","getHistoryState","recordOperator","l","_getBaseHistory","pop","createHref","updateState","historyState","_window$location","_ref","forceJump","handlePopState","callback","isJump","revertPopState","popStateListener","event","hashChangeListener","listenerCount","count","addEventListener","PopState","HashChange","removeEventListener","delta","href","pushState","replaceState","stripHash","idx","getHashContent","createHashHistory","option","_option$hashType","hashType","_option$getUserConfir","pathDecoder","pathEncoder","hashPath","memRecords","tag","querySelector","base","getAttribute","forceNextPop","ignorePath","encodedPath","handleHashChange","prevLocation","createNamedContext","name","defaultValue","context","createContext","displayName","RouterContext","TokenType","cleanPath","scoreCompare","score1","score2","score1Length","score2Length","min","escapeStr","str","validChar","lexer","tokens","urlPath","Error","getLiteral","test","skipChar","curChar","prevChar","type","Delimiter","Param","WildCard","Static","LBracket","RBracket","Pattern","MatchScore","defaultOption","caseSensitive","strictMode","exact","REGEX_CHARS_RE","BASE_PARAM_PATTERN","DefaultDelimiter","createPathParser","_option$caseSensitive","_option$strictMode","_option$exact","pattern","keys","scores","onlyHasWildCard","tokenCount","lastToken","tokenIdx","token","nextToken","static","paramRegexp","param","wildcard","placeholder","isWildCard","flag","regexp","RegExp","parse","reMatch","match","matchedPath","params","parseScore","Array","from","split","isArray","_params$","splice","concat","fill","isExact","score","compile","wildCard","join","matchPath","patterns","matchedResults","_iterator2","_step2","parser","matched","sort","a","b","generatePath","useHistory","useContext","useLocation","useParams","useRouteMatch","Route","computed","children","component","render","routeLocation","newProps","Children","getChildren","React","Provider","Router","_props$children","_useState","useState","setLocation","pendingLocation","useRef","unListen","useLayoutEffect","initContextValue","useMemo","_objectWithoutPropertiesLoose","excluded","sourceKeys","LifeCycle","prevProps","isMount","onMount","onUpdate","onUnmount","Redirect","_props$push","calcLocation","navigate","_calcLocation","_excluded","onMountFunc","onUpdateFunc","prevPath","data","Switch","element","forEach","node","isValidElement","strict","sensitive","cloneElement","Prompt","_props$when","when","release","onUnmountFunc","withRouter","Component","ComponentWithRouterProp","_useContext","routeProps","HashRouter","historyRef","BrowserRouter","isModifiedEvent","metaKey","altKey","ctrlKey","shiftKey","checkTarget","Link","onClick","other","linkClickEvent","preventDefault","defaultPrevented","button","isSamePath","linkProps","NavLink","rest","Context","toLocation","escapedPath","isLinkActive","page","otherProps"],"mappings":"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"}
diff --git a/packages/horizon-router/router/esm/router.js b/packages/horizon-router/router/esm/router.js
new file mode 100644
index 00000000..91ea480e
--- /dev/null
+++ b/packages/horizon-router/router/esm/router.js
@@ -0,0 +1,1490 @@
+import * as React from 'react';
+import { createContext, useContext, Children, createElement, useState, useRef, useLayoutEffect, useMemo, isValidElement, cloneElement } from 'react';
+
+function isBrowser() {
+  return typeof window !== 'undefined' && window.document && typeof window.document.createElement === 'function';
+}
+function getDefaultConfirmation(message, callBack) {
+  callBack(window.confirm(message));
+}
+
+// 判断浏览器是否支持pushState方法，pushState是browserHistory实现的基础
+function isSupportHistory() {
+  return isBrowser() && window.history && 'pushState' in window.history;
+}
+
+// 判断浏览器是否支持PopState事件
+function isSupportsPopState() {
+  return window.navigator.userAgent.indexOf('Trident') === -1;
+}
+
+var Action = /*#__PURE__*/function (Action) {
+  Action["pop"] = "POP";
+  Action["push"] = "PUSH";
+  Action["replace"] = "REPLACE";
+  return Action;
+}({});
+var EventType = /*#__PURE__*/function (EventType) {
+  EventType["PopState"] = "popstate";
+  EventType["HashChange"] = "hashchange";
+  return EventType;
+}({});
+
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+
+function createPath(path) {
+  var search = path.search,
+    hash = path.hash;
+  var pathname = path.pathname || '/';
+  if (search && search !== '?') {
+    pathname += search.startsWith('?') ? search : '?' + search;
+  }
+  if (hash && hash !== '#') {
+    pathname += hash.startsWith('#') ? hash : '#' + hash;
+  }
+  return pathname;
+}
+function parsePath(url) {
+  if (!url) {
+    return {};
+  }
+  var parsedPath = {};
+  var hashIdx = url.indexOf('#');
+  if (hashIdx > -1) {
+    parsedPath.hash = url.substring(hashIdx);
+    url = url.substring(0, hashIdx);
+  }
+  var searchIdx = url.indexOf('?');
+  if (searchIdx > -1) {
+    parsedPath.search = url.substring(searchIdx);
+    url = url.substring(0, searchIdx);
+  }
+  if (url) {
+    parsedPath.pathname = url;
+  }
+  return parsedPath;
+}
+function createLocation(current, to, state, key) {
+  var pathname = typeof current === 'string' ? current : current.pathname;
+  var urlObj = typeof to === 'string' ? parsePath(to) : to;
+  // 随机key长度取6
+  var getRandKey = genRandomKey(6);
+  var location = _extends({
+    pathname: pathname,
+    search: '',
+    hash: '',
+    state: state,
+    key: typeof key === 'string' ? key : getRandKey()
+  }, urlObj);
+  if (!location.pathname) {
+    location.pathname = '/';
+  }
+  return location;
+}
+function isLocationEqual(p1, p2) {
+  return p1.pathname === p2.pathname && p1.search === p2.search && p1.hash === p2.hash;
+}
+function addHeadSlash(path) {
+  if (path[0] === '/') {
+    return path;
+  }
+  return '/' + path;
+}
+function stripHeadSlash(path) {
+  if (path[0] === '/') {
+    return path.substring(1);
+  }
+  return path;
+}
+function normalizeSlash(path) {
+  var tempPath = addHeadSlash(path);
+  if (tempPath[tempPath.length - 1] === '/') {
+    return tempPath.substring(0, tempPath.length - 1);
+  }
+  return tempPath;
+}
+function hasBasename(path, prefix) {
+  return path.toLowerCase().indexOf(prefix.toLowerCase()) === 0 && ['/', '?', '#', ''].includes(path.charAt(prefix.length));
+}
+function stripBasename(path, prefix) {
+  return hasBasename(path, prefix) ? path.substring(prefix.length) : path;
+}
+
+// 使用随机生成的Key记录被访问过的URL，当Block被被触发时利用delta值跳转到之前的页面
+function createMemoryRecord(initVal, fn) {
+  var visitedRecord = [fn(initVal)];
+  function getDelta(to, form) {
+    var toIdx = visitedRecord.lastIndexOf(fn(to));
+    if (toIdx === -1) {
+      toIdx = 0;
+    }
+    var fromIdx = visitedRecord.lastIndexOf(fn(form));
+    if (fromIdx === -1) {
+      fromIdx = 0;
+    }
+    return toIdx - fromIdx;
+  }
+  function addRecord(current, newRecord, action) {
+    var curVal = fn(current);
+    var NewVal = fn(newRecord);
+    if (action === Action.push) {
+      var prevIdx = visitedRecord.lastIndexOf(curVal);
+      var newVisitedRecord = visitedRecord.slice(0, prevIdx + 1);
+      newVisitedRecord.push(NewVal);
+      visitedRecord = newVisitedRecord;
+    }
+    if (action === Action.replace) {
+      var _prevIdx = visitedRecord.lastIndexOf(curVal);
+      if (_prevIdx !== -1) {
+        visitedRecord[_prevIdx] = NewVal;
+      }
+    }
+  }
+  return {
+    getDelta: getDelta,
+    addRecord: addRecord
+  };
+}
+function genRandomKey(length) {
+  var end = length + 2;
+  return function () {
+    return Math.random().toString(18).substring(2, end);
+  };
+}
+
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+  }, _typeof(obj);
+}
+
+function _toPrimitive(input, hint) {
+  if (_typeof(input) !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (_typeof(res) !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return _typeof(key) === "symbol" ? key : String(key);
+}
+
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+
+function _createForOfIteratorHelper$1(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$1(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function () {}; return { s: F, n: function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function (e) { throw e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function () { it = it.call(o); }, n: function () { var step = it.next(); normalCompletion = step.done; return step; }, e: function (e) { didErr = true; err = e; }, f: function () { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray$1(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$1(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$1(o, minLen); }
+function _arrayLikeToArray$1(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+var TransitionManager = /*#__PURE__*/function () {
+  function TransitionManager() {
+    _classCallCheck(this, TransitionManager);
+    this.prompt = void 0;
+    this.listeners = void 0;
+    this.prompt = null;
+    this.listeners = [];
+  }
+  _createClass(TransitionManager, [{
+    key: "setPrompt",
+    value: function setPrompt(prompt) {
+      var _this = this;
+      this.prompt = prompt;
+
+      // 清除Prompt
+      return function () {
+        if (_this.prompt === prompt) {
+          _this.prompt = null;
+        }
+      };
+    }
+
+    // 使用发布订阅模式管理history的监听者
+  }, {
+    key: "addListener",
+    value: function addListener(func) {
+      var _this2 = this;
+      var isActive = true;
+      var listener = function (args) {
+        if (isActive) {
+          func(args);
+        }
+      };
+      this.listeners.push(listener);
+      return function () {
+        isActive = false;
+        // 移除对应的监听者
+        _this2.listeners = _this2.listeners.filter(function (item) {
+          return item !== listener;
+        });
+      };
+    }
+  }, {
+    key: "notifyListeners",
+    value: function notifyListeners(args) {
+      var _iterator = _createForOfIteratorHelper$1(this.listeners),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var listener = _step.value;
+          listener(args);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+  }, {
+    key: "confirmJumpTo",
+    value: function confirmJumpTo(location, action, userConfirmationFunc, callBack) {
+      if (this.prompt !== null) {
+        var result = typeof this.prompt === 'function' ? this.prompt(location, action) : this.prompt;
+        if (typeof result === 'string') {
+          typeof userConfirmationFunc === 'function' ? userConfirmationFunc(result, callBack) : callBack(true);
+        } else {
+          callBack(result !== false);
+        }
+      } else {
+        callBack(true);
+      }
+    }
+  }]);
+  return TransitionManager;
+}();
+
+function warning(condition, message) {
+  if (condition) {
+    if (console && typeof console.warn === 'function') {
+      console.warn(message);
+    }
+  }
+}
+
+// 抽取BrowserHistory和HashHistory中相同的方法
+function getBaseHistory(transitionManager, setListener, browserHistory) {
+  function go(step) {
+    browserHistory.go(step);
+  }
+  function goBack() {
+    browserHistory.go(-1);
+  }
+  function goForward() {
+    browserHistory.go(1);
+  }
+  function listen(listener) {
+    var cancel = transitionManager.addListener(listener);
+    setListener(1);
+    return function () {
+      setListener(-1);
+      cancel();
+    };
+  }
+  var isBlocked = false;
+  function block() {
+    var prompt = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    var unblock = transitionManager.setPrompt(prompt);
+    if (!isBlocked) {
+      setListener(1);
+      isBlocked = true;
+    }
+    return function () {
+      if (isBlocked) {
+        isBlocked = false;
+        setListener(-1);
+      }
+      unblock();
+    };
+  }
+  function getUpdateStateFunc(historyProps) {
+    return function (nextState) {
+      if (nextState) {
+        _extends(historyProps, nextState);
+      }
+      historyProps.length = browserHistory.length;
+      var args = {
+        location: historyProps.location,
+        action: historyProps.action
+      };
+      transitionManager.notifyListeners(args);
+    };
+  }
+  return {
+    go: go,
+    goBack: goBack,
+    goForward: goForward,
+    listen: listen,
+    block: block,
+    getUpdateStateFunc: getUpdateStateFunc
+  };
+}
+
+function createBrowserHistory() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var supportHistory = isSupportHistory();
+  var isSupportPopState = isSupportsPopState();
+  var browserHistory = window.history;
+  var _options$forceRefresh = options.forceRefresh,
+    forceRefresh = _options$forceRefresh === void 0 ? false : _options$forceRefresh,
+    _options$getUserConfi = options.getUserConfirmation,
+    getUserConfirmation = _options$getUserConfi === void 0 ? getDefaultConfirmation : _options$getUserConfi;
+  var basename = options.basename ? normalizeSlash(options.basename) : '';
+  var initLocation = getLocation(getHistoryState());
+  var recordOperator = createMemoryRecord(initLocation, function (l) {
+    return l.key;
+  });
+  var transitionManager = new TransitionManager();
+  var _getBaseHistory = getBaseHistory(transitionManager, setListener, browserHistory),
+    go = _getBaseHistory.go,
+    goBack = _getBaseHistory.goBack,
+    goForward = _getBaseHistory.goForward,
+    listen = _getBaseHistory.listen,
+    block = _getBaseHistory.block,
+    getUpdateStateFunc = _getBaseHistory.getUpdateStateFunc;
+  var history = {
+    action: Action.pop,
+    length: browserHistory.length,
+    location: initLocation,
+    go: go,
+    goBack: goBack,
+    goForward: goForward,
+    listen: listen,
+    block: block,
+    push: push,
+    replace: replace,
+    createHref: createHref
+  };
+  var updateState = getUpdateStateFunc(history);
+  function getHistoryState() {
+    return supportHistory ? window.history.state : {};
+  }
+  function getLocation(historyState) {
+    var _window$location = window.location,
+      search = _window$location.search,
+      hash = _window$location.hash;
+    var _ref = historyState || {},
+      key = _ref.key,
+      state = _ref.state;
+    var pathname = window.location.pathname;
+    pathname = basename ? stripBasename(pathname, basename) : pathname;
+    return createLocation('', {
+      pathname: pathname,
+      search: search,
+      hash: hash
+    }, state, key);
+  }
+
+  // 拦截页面POP事件后，防止返回到的页面被重复拦截
+  var forceJump = false;
+  function handlePopState(location) {
+    if (forceJump) {
+      forceJump = false;
+      updateState(undefined);
+    } else {
+      var action = Action.pop;
+      var callback = function (isJump) {
+        if (isJump) {
+          // 执行跳转行为
+          updateState({
+            action: action,
+            location: location
+          });
+        } else {
+          revertPopState(location, history.location);
+        }
+      };
+      transitionManager.confirmJumpTo(location, action, getUserConfirmation, callback);
+    }
+  }
+  function popStateListener(event) {
+    handlePopState(getLocation(event.state));
+  }
+  function hashChangeListener() {
+    var location = getLocation(getHistoryState());
+    handlePopState(location);
+  }
+  var listenerCount = 0;
+  function setListener(count) {
+    listenerCount += count;
+    if (listenerCount === 1 && count === 1) {
+      window.addEventListener(EventType.PopState, popStateListener);
+      if (!isSupportPopState) {
+        window.addEventListener(EventType.HashChange, hashChangeListener);
+      }
+    } else if (listenerCount === 0) {
+      window.removeEventListener(EventType.PopState, popStateListener);
+      if (!isSupportPopState) {
+        window.removeEventListener(EventType.HashChange, hashChangeListener);
+      }
+    }
+  }
+
+  // 取消页面跳转并恢复到跳转前的页面
+  function revertPopState(form, to) {
+    var delta = recordOperator.getDelta(to, form);
+    if (delta !== 0) {
+      go(delta);
+      forceJump = true;
+    }
+  }
+  function createHref(path) {
+    return basename + createPath(path);
+  }
+  function push(to, state) {
+    var action = Action.push;
+    var location = createLocation(history.location, to, state, undefined);
+    transitionManager.confirmJumpTo(location, action, getUserConfirmation, function (isJump) {
+      if (!isJump) {
+        return;
+      }
+      var href = createHref(location);
+      var key = location.key,
+        state = location.state;
+      if (supportHistory) {
+        if (forceRefresh) {
+          window.location.href = href;
+        } else {
+          browserHistory.pushState({
+            key: key,
+            state: state
+          }, '', href);
+          recordOperator.addRecord(history.location, location, action);
+          updateState({
+            action: action,
+            location: location
+          });
+        }
+      } else {
+        warning(state !== undefined, 'Browser history cannot push state in browsers that do not support HTML5 history');
+        window.location.href = href;
+      }
+    });
+  }
+  function replace(to, state) {
+    var action = Action.replace;
+    var location = createLocation(history.location, to, state, undefined);
+    transitionManager.confirmJumpTo(location, action, getUserConfirmation, function (isJump) {
+      if (!isJump) {
+        return;
+      }
+      var href = createHref(location);
+      var key = location.key,
+        state = location.state;
+      if (supportHistory) {
+        if (forceRefresh) {
+          window.location.replace(href);
+        } else {
+          browserHistory.replaceState({
+            key: key,
+            state: state
+          }, '', href);
+          recordOperator.addRecord(history.location, location, action);
+          updateState({
+            action: action,
+            location: location
+          });
+        }
+      } else {
+        warning(state !== undefined, 'Browser history cannot push state in browsers that do not support HTML5 history');
+        window.location.replace(href);
+      }
+    });
+  }
+  return history;
+}
+
+// 获取#前的内容
+function stripHash(path) {
+  var idx = path.indexOf('#');
+  return idx === -1 ? path : path.substring(0, idx);
+}
+
+// 获取#后的内容
+function getHashContent(path) {
+  var idx = path.indexOf('#');
+  return idx === -1 ? '' : path.substring(idx + 1);
+}
+function createHashHistory() {
+  var option = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var browserHistory = window.history;
+  var _option$hashType = option.hashType,
+    hashType = _option$hashType === void 0 ? 'slash' : _option$hashType,
+    _option$getUserConfir = option.getUserConfirmation,
+    getUserConfirmation = _option$getUserConfir === void 0 ? getDefaultConfirmation : _option$getUserConfir;
+  var basename = option.basename ? normalizeSlash(option.basename) : '';
+  var pathDecoder = addHeadSlash;
+  var pathEncoder = hashType === 'slash' ? addHeadSlash : stripHeadSlash;
+  function getLocation() {
+    var hashPath = pathDecoder(getHashContent(window.location.hash));
+    if (basename) {
+      hashPath = stripBasename(hashPath, basename);
+    }
+    return createLocation('', hashPath, undefined, 'default');
+  }
+  var initLocation = getLocation();
+  var memRecords = createMemoryRecord(initLocation, createPath);
+  var transitionManager = new TransitionManager();
+  function createHref(location) {
+    var tag = document.querySelector('base');
+    var base = tag && tag.getAttribute('href') ? stripHash(window.location.href) : '';
+    return base + '#' + pathEncoder(basename + createPath(location));
+  }
+  var forceNextPop = false;
+  var ignorePath = null;
+  var _getBaseHistory = getBaseHistory(transitionManager, setListener, browserHistory),
+    go = _getBaseHistory.go,
+    goBack = _getBaseHistory.goBack,
+    goForward = _getBaseHistory.goForward,
+    listen = _getBaseHistory.listen,
+    block = _getBaseHistory.block,
+    getUpdateStateFunc = _getBaseHistory.getUpdateStateFunc;
+  var history = {
+    action: Action.pop,
+    length: browserHistory.length,
+    location: initLocation,
+    go: go,
+    goBack: goBack,
+    goForward: goForward,
+    push: push,
+    replace: replace,
+    listen: listen,
+    block: block,
+    createHref: createHref
+  };
+  var updateState = getUpdateStateFunc(history);
+  function push(to, state) {
+    warning(state !== undefined, 'Hash history does not support state, it will be ignored');
+    var action = Action.push;
+    var location = createLocation(history.location, to, undefined, '');
+    transitionManager.confirmJumpTo(location, action, getUserConfirmation, function (isJump) {
+      if (!isJump) {
+        return;
+      }
+      var path = createPath(location);
+      var encodedPath = pathEncoder(basename + path);
+      // 前后hash不一样才进行跳转
+      if (getHashContent(window.location.href) !== encodedPath) {
+        ignorePath = encodedPath;
+        window.location.hash = encodedPath;
+        memRecords.addRecord(history.location, location, action);
+        updateState({
+          action: action,
+          location: location
+        });
+      } else {
+        updateState(undefined);
+      }
+    });
+  }
+  function replace(to, state) {
+    warning(state !== undefined, 'Hash history does not support state, it will be ignored');
+    var action = Action.replace;
+    var location = createLocation(history.location, to, undefined, '');
+    transitionManager.confirmJumpTo(location, action, getUserConfirmation, function (isJump) {
+      if (!isJump) {
+        return;
+      }
+      var path = createPath(location);
+      var encodedPath = pathEncoder(basename + path);
+      if (getHashContent(window.location.href) !== encodedPath) {
+        ignorePath = path;
+        window.location.replace(stripHash(window.location.href) + '#' + encodedPath);
+      }
+      memRecords.addRecord(history.location, location, action);
+      updateState({
+        action: action,
+        location: location
+      });
+    });
+  }
+  function handleHashChange() {
+    var hashPath = getHashContent(window.location.href);
+    var encodedPath = pathEncoder(hashPath);
+    if (hashPath !== encodedPath) {
+      window.location.replace(stripHash(window.location.href) + '#' + encodedPath);
+    } else {
+      var location = getLocation();
+      var prevLocation = history.location;
+      if (!forceNextPop && isLocationEqual(location, prevLocation)) {
+        return;
+      }
+      if (ignorePath === createPath(location)) {
+        return;
+      }
+      ignorePath = null;
+      handlePopState(location);
+    }
+  }
+  function handlePopState(location) {
+    if (forceNextPop) {
+      forceNextPop = false;
+      updateState(undefined);
+    } else {
+      var action = Action.pop;
+      var callback = function (isJump) {
+        if (isJump) {
+          updateState({
+            action: action,
+            location: location
+          });
+        } else {
+          revertPopState(location);
+        }
+      };
+      transitionManager.confirmJumpTo(location, action, getUserConfirmation, callback);
+    }
+  }
+
+  // 在跳转行为被Block后，用History.go()跳转回之前的页面
+  function revertPopState(form) {
+    var to = history.location;
+    var delta = memRecords.getDelta(to, form);
+    if (delta !== 0) {
+      go(delta);
+      forceNextPop = true;
+    }
+  }
+  var listenerCount = 0;
+  function setListener(delta) {
+    listenerCount += delta;
+    if (listenerCount === 1 && delta === 1) {
+      window.addEventListener(EventType.HashChange, handleHashChange);
+    } else if (listenerCount === 0) {
+      window.removeEventListener(EventType.HashChange, handleHashChange);
+    }
+  }
+  return history;
+}
+
+function createNamedContext(name, defaultValue) {
+  var context = createContext(defaultValue);
+  context.displayName = name;
+  return context;
+}
+var RouterContext = createNamedContext('Router', {});
+
+var TokenType = /*#__PURE__*/function (TokenType) {
+  TokenType["Delimiter"] = "delimiter";
+  TokenType["Static"] = "static";
+  TokenType["Param"] = "param";
+  TokenType["WildCard"] = "wildcard";
+  TokenType["LBracket"] = "(";
+  TokenType["RBracket"] = ")";
+  TokenType["Pattern"] = "pattern";
+  return TokenType;
+}({});
+
+// 解析URL中的动态参数，以实现TypeScript提示功能
+
+/**
+ * @description 将url中的//转换为/
+ */
+function cleanPath(path) {
+  return path.replace(/\/+/g, '/');
+}
+function scoreCompare(score1, score2) {
+  var score1Length = score1.length;
+  var score2Length = score2.length;
+  var end = Math.min(score1Length, score2Length);
+  for (var i = 0; i < end; i++) {
+    var delta = score2[i] - score1[i];
+    if (delta !== 0) {
+      return delta;
+    }
+  }
+  if (score1Length === score2Length) {
+    return 0;
+  }
+  return score1Length > score2Length ? -1 : 1;
+}
+
+// 把正则表达式的特殊符号加两个反斜杠进行转义
+function escapeStr(str) {
+  return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, '\\$1');
+}
+
+var validChar = /[^/:*()]/;
+
+// 对Url模板进行词法解析，解析结果为Tokens
+function lexer(path) {
+  var tokens = [];
+  if (!path) {
+    return tokens;
+  }
+  var urlPath = cleanPath(path);
+  if (urlPath !== '*' && !urlPath.startsWith('/')) {
+    throw new Error("Url must start with \"/\".");
+  }
+  var getLiteral = function () {
+    var name = '';
+    while (i < urlPath.length && validChar.test(urlPath[i])) {
+      name += urlPath[i];
+      skipChar(1);
+    }
+    return name;
+  };
+  var skipChar = function (step) {
+    i += step;
+  };
+  var i = 0;
+  while (i < urlPath.length) {
+    var curChar = urlPath[i];
+    var prevChar = urlPath[i - 1];
+    if (curChar === '/') {
+      tokens.push({
+        type: TokenType.Delimiter,
+        value: urlPath[i]
+      });
+      skipChar(1);
+      continue;
+    }
+    // dynamic params (/:a)
+    if (prevChar === '/' && curChar === ':') {
+      skipChar(1);
+      tokens.push({
+        type: TokenType.Param,
+        value: getLiteral()
+      });
+      continue;
+    }
+    // wildCard params (/:*)
+    if ((prevChar === '/' || prevChar === undefined) && curChar === '*') {
+      tokens.push({
+        type: TokenType.WildCard,
+        value: urlPath[i]
+      });
+      skipChar(1);
+      continue;
+    }
+    // static params
+    if (prevChar === '/' && validChar.test(curChar)) {
+      tokens.push({
+        type: TokenType.Static,
+        value: getLiteral()
+      });
+      continue;
+    }
+    if (curChar === '(') {
+      tokens.push({
+        type: TokenType.LBracket,
+        value: '('
+      });
+      skipChar(1);
+      continue;
+    }
+    if (curChar === ')') {
+      tokens.push({
+        type: TokenType.RBracket,
+        value: ')'
+      });
+      skipChar(1);
+      continue;
+    }
+    if (validChar.test(curChar)) {
+      tokens.push({
+        type: TokenType.Pattern,
+        value: getLiteral()
+      });
+      continue;
+    }
+    // 跳过非法字符
+    skipChar(1);
+  }
+  return tokens;
+}
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function () {}; return { s: F, n: function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function (e) { throw e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function () { it = it.call(o); }, n: function () { var step = it.next(); normalCompletion = step.done; return step; }, e: function (e) { didErr = true; err = e; }, f: function () { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+// 不同类型参数的匹配得分
+var MatchScore = /*#__PURE__*/function (MatchScore) {
+  MatchScore[MatchScore["static"] = 10] = "static";
+  MatchScore[MatchScore["param"] = 6] = "param";
+  MatchScore[MatchScore["wildcard"] = 3] = "wildcard";
+  MatchScore[MatchScore["placeholder"] = -1] = "placeholder";
+  return MatchScore;
+}(MatchScore || {}); // 兼容 react v5 matched类型
+var defaultOption = {
+  // url匹配时是否大小写敏感
+  caseSensitive: true,
+  // 是否严格匹配url结尾的/
+  strictMode: false,
+  // 是否完全精确匹配
+  exact: false
+};
+// 正则表达式中需要转义的字符
+var REGEX_CHARS_RE = /[.+*?^${}()[\]/\\]/g;
+// 用于匹配两个//中的的值
+var BASE_PARAM_PATTERN = '[^/]+';
+var DefaultDelimiter = '/#?';
+function createPathParser(pathname) {
+  var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultOption;
+  var _option$caseSensitive = option.caseSensitive,
+    caseSensitive = _option$caseSensitive === void 0 ? defaultOption.caseSensitive : _option$caseSensitive,
+    _option$strictMode = option.strictMode,
+    strictMode = _option$strictMode === void 0 ? defaultOption.strictMode : _option$strictMode,
+    _option$exact = option.exact,
+    exact = _option$exact === void 0 ? defaultOption.exact : _option$exact;
+  /**
+   * URL匹配整体流程
+   * 1.词法解析，将URL模板解析为Token
+   * 2.使用Token生成正则表达式
+   * 3.利用正则表达式解析URL中参数或填充URL模板
+   */
+  var pattern = '^';
+  var keys = [];
+  var scores = [];
+  var tokens = lexer(pathname);
+  var onlyHasWildCard = tokens.length === 1 && tokens[0].type === TokenType.WildCard;
+  var tokenCount = tokens.length;
+  var lastToken = tokens[tokenCount - 1];
+  for (var tokenIdx = 0; tokenIdx < tokenCount; tokenIdx++) {
+    var token = tokens[tokenIdx];
+    var nextToken = tokens[tokenIdx + 1];
+    switch (token.type) {
+      case TokenType.Delimiter:
+        pattern += '/';
+        break;
+      case TokenType.Static:
+        pattern += token.value.replace(REGEX_CHARS_RE, '\\$&');
+        scores.push(MatchScore.static);
+        break;
+      case TokenType.Param:
+        var paramRegexp = '';
+        if (nextToken && nextToken.type === TokenType.LBracket) {
+          // 跳过当前Token和左括号
+          tokenIdx += 2;
+          while (tokens[tokenIdx].type !== TokenType.RBracket) {
+            paramRegexp += tokens[tokenIdx].value;
+            tokenIdx++;
+          }
+        }
+        pattern += paramRegexp ? "((?:" + paramRegexp + "))" : "(" + BASE_PARAM_PATTERN + ")";
+        keys.push(token.value);
+        scores.push(MatchScore.param);
+        break;
+      case TokenType.WildCard:
+        keys.push(token.value);
+        pattern += "((?:" + BASE_PARAM_PATTERN + ")" + (onlyHasWildCard ? '?' : '') + "(?:/(?:" + BASE_PARAM_PATTERN + "))*)";
+        scores.push(onlyHasWildCard ? MatchScore.wildcard : MatchScore.placeholder);
+        break;
+    }
+  }
+  var isWildCard = lastToken.type === TokenType.WildCard;
+  if (!isWildCard && !exact) {
+    if (!strictMode) {
+      pattern += "(?:[" + escapeStr(DefaultDelimiter) + "](?=$))?";
+    }
+    if (lastToken.type !== TokenType.Delimiter) {
+      pattern += "(?=[" + escapeStr(DefaultDelimiter) + "]|$)";
+    }
+  } else {
+    pattern += strictMode ? '$' : "[" + escapeStr(DefaultDelimiter) + "]?$";
+  }
+  var flag = caseSensitive ? '' : 'i';
+  var regexp = new RegExp(pattern, flag);
+
+  /**
+   * @description 根据给定Pattern解析path
+   */
+  function parse(path) {
+    var reMatch = path.match(regexp);
+    if (!reMatch) {
+      return null;
+    }
+    var matchedPath = reMatch[0];
+    var params = {};
+    var parseScore = Array.from(scores);
+    for (var i = 1; i < reMatch.length; i++) {
+      var param = reMatch[i];
+      var key = keys[i - 1];
+      if (key === '*' && param) {
+        var value = param.split('/');
+        if (!Array.isArray(params['*'])) {
+          params['*'] = value;
+        } else {
+          var _params$;
+          (_params$ = params['*']).push.apply(_params$, value);
+        }
+        // 完成通配符参数解析后将placeholder替换为wildcard参数的分值
+        parseScore.splice.apply(parseScore, [scores.indexOf(MatchScore.placeholder), 1].concat(new Array(value.length).fill(MatchScore.wildcard)));
+      } else {
+        params[key] = param ? param : [];
+      }
+    }
+    var isExact = path === matchedPath;
+    var url = path === '/' && matchedPath === '' ? '/' : matchedPath;
+    return {
+      isExact: isExact,
+      path: pathname,
+      url: url,
+      score: parseScore,
+      params: params
+    };
+  }
+
+  /**
+   * @description 使用给定参数填充pattern，得到目标URL
+   */
+  function compile(params) {
+    var path = '';
+    var _iterator = _createForOfIteratorHelper(tokens),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _token = _step.value;
+        switch (_token.type) {
+          case TokenType.Static:
+            path += _token.value;
+            break;
+          case TokenType.Param:
+            if (!params[_token.value]) {
+              throw new Error('Param is invalid.');
+            }
+            path += params[_token.value];
+            break;
+          case TokenType.WildCard:
+            var wildCard = params['*'];
+            if (wildCard instanceof Array) {
+              path += wildCard.join('/');
+            } else {
+              path += wildCard;
+            }
+            break;
+          case TokenType.Delimiter:
+            path += _token.value;
+            break;
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return path;
+  }
+  return {
+    get regexp() {
+      return regexp;
+    },
+    get keys() {
+      return keys;
+    },
+    compile: compile,
+    parse: parse
+  };
+}
+
+/**
+ * @description 依次使用pathname与pattern进行匹配，根据匹配分数取得分数最高结果
+ */
+function matchPath(pathname, pattern, option) {
+  var patterns = Array.isArray(pattern) ? [].concat(pattern) : [pattern];
+  var matchedResults = [];
+  var _iterator2 = _createForOfIteratorHelper(patterns),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var item = _step2.value;
+      var parser = createPathParser(item, option);
+      var matched = parser.parse(pathname);
+      if (matched) {
+        matchedResults.push(matched);
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return !matchedResults.length ? null : matchedResults.sort(function (a, b) {
+    return scoreCompare(a.score, b.score);
+  })[0];
+}
+function generatePath(path, params) {
+  var parser = createPathParser(path);
+  return parser.compile(params);
+}
+
+function useHistory() {
+  return useContext(RouterContext).history;
+}
+function useLocation() {
+  return useContext(RouterContext).location;
+}
+function useParams() {
+  var match = useContext(RouterContext).match;
+  return match ? match.params : {};
+}
+function useRouteMatch(path) {
+  var pathname = useLocation().pathname;
+  var match = useContext(RouterContext).match;
+  if (path) {
+    return matchPath(pathname, path);
+  }
+  return match;
+}
+
+function Route(props) {
+  var context = useContext(RouterContext);
+  var computed = props.computed,
+    location = props.location,
+    path = props.path;
+  var children = props.children,
+    component = props.component,
+    render = props.render;
+  var match;
+  var routeLocation = location || context.location;
+  if (computed) {
+    match = computed;
+  } else if (path) {
+    match = matchPath(routeLocation.pathname, path);
+  } else {
+    match = context.match;
+  }
+  var newProps = _extends({}, context, {
+    location: routeLocation,
+    match: match
+  });
+  if (Array.isArray(children) && Children.count(children) === 0) {
+    children = null;
+  }
+
+  /**
+   * 按顺序获取需要渲染的组件
+   * 1.children
+   * 2.component
+   * 3.render
+   * 都没有匹配到返回Null
+   */
+  var getChildren = function () {
+    // 如果 match 存在
+    if (newProps.match) {
+      if (children) {
+        if (typeof children === 'function') {
+          return children(newProps);
+        }
+        return children;
+      }
+      if (component) {
+        return createElement(component, newProps);
+      } else if (render) {
+        return render(newProps);
+      } else {
+        return null;
+      }
+    } else {
+      // match为null
+      if (typeof children === 'function') {
+        return children(newProps);
+      }
+      return null;
+    }
+  };
+  return /*#__PURE__*/React.createElement(RouterContext.Provider, {
+    value: newProps
+  }, getChildren());
+}
+
+function Router(props) {
+  var history = props.history,
+    _props$children = props.children,
+    children = _props$children === void 0 ? null : _props$children;
+  var _useState = useState(props.history.location),
+    location = _useState[0],
+    setLocation = _useState[1];
+  var pendingLocation = useRef(null);
+
+  // 在Router加载时就监听history地址变化，以保证在始渲染时重定向能正确触发
+  var unListen = history.listen(function (arg) {
+    pendingLocation.current = arg.location;
+  });
+
+  // 模拟componentDidMount和componentWillUnmount
+  useLayoutEffect(function () {
+    if (unListen) {
+      unListen();
+    }
+    // 监听history中的位置变化
+    unListen = history.listen(function (arg) {
+      setLocation(arg.location);
+    });
+    if (pendingLocation.current) {
+      setLocation(pendingLocation.current);
+    }
+    return function () {
+      if (unListen) {
+        unListen();
+        unListen = null;
+        pendingLocation.current = null;
+      }
+    };
+  }, []);
+  var initContextValue = useMemo(function () {
+    return {
+      history: history,
+      location: location,
+      match: {
+        isExact: location.pathname === '/',
+        params: {},
+        path: '/',
+        score: [],
+        url: '/'
+      }
+    };
+  }, [location]);
+  return /*#__PURE__*/React.createElement(RouterContext.Provider, {
+    value: initContextValue,
+    children: children
+  });
+}
+
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+  return target;
+}
+
+function LifeCycle(props) {
+  // 使用ref保存上一次的props，防止重新渲染
+  var prevProps = useRef(null);
+  var isMount = useRef(false);
+  var onMount = props.onMount,
+    onUpdate = props.onUpdate,
+    onUnmount = props.onUnmount;
+  useLayoutEffect(function () {
+    // 首次挂载 模拟componentDidMount
+    if (!isMount.current) {
+      isMount.current = true;
+      if (onMount) {
+        onMount();
+      }
+    } else {
+      // 不是首次渲染 模拟componentDidUpdate
+      if (onUpdate) {
+        prevProps.current ? onUpdate(prevProps.current) : onUpdate();
+      }
+    }
+    prevProps.current = props;
+  });
+
+  // 模拟componentWillUnmount
+  useLayoutEffect(function () {
+    return function () {
+      if (onUnmount) {
+        onUnmount();
+      }
+    };
+  }, []);
+  return null;
+}
+
+var _excluded$2 = ["state"];
+function Redirect(props) {
+  var to = props.to,
+    _props$push = props.push,
+    push = _props$push === void 0 ? false : _props$push,
+    computed = props.computed;
+  var context = useContext(RouterContext);
+  var history = context.history;
+  var calcLocation = function () {
+    if (computed) {
+      if (typeof to === 'string') {
+        var parser = createPathParser(to);
+        var target = parser.compile(computed.params);
+        return parsePath(target);
+      } else {
+        var pathname = to.pathname ? addHeadSlash(to.pathname) : '/';
+        var _parser = createPathParser(pathname);
+        var _target = _parser.compile(computed.params);
+        return _extends({}, to, {
+          pathname: _target
+        });
+      }
+    }
+    return typeof to === 'string' ? parsePath(to) : to;
+  };
+  var navigate = push ? history.push : history.replace;
+  var _calcLocation = calcLocation(),
+    state = _calcLocation.state,
+    path = _objectWithoutPropertiesLoose(_calcLocation, _excluded$2);
+  var onMountFunc = function () {
+    navigate(path, state);
+  };
+  var onUpdateFunc = function (prevProps) {
+    // 如果当前页面与重定向前页面不一致，执行跳转
+    var prevPath = prevProps === null || prevProps === void 0 ? void 0 : prevProps.data;
+    if (!isLocationEqual(prevPath, path)) {
+      navigate(path, state);
+    }
+  };
+  return /*#__PURE__*/React.createElement(LifeCycle, {
+    onMount: onMountFunc,
+    onUpdate: onUpdateFunc,
+    data: path
+  });
+}
+
+function Switch(props) {
+  var context = useContext(RouterContext);
+  var location = props.location || context.location;
+  var element = null;
+  var match = null;
+
+  // 使用forEach不会给React.ReactNode增加key属性,防止重新渲染
+  Children.forEach(props.children, function (node) {
+    if (match === null && isValidElement(node)) {
+      element = node;
+      var strict;
+      var sensitive;
+      var path;
+      var from;
+
+      // node可能是Route和Redirect
+      if (node.type === Route) {
+        var _props = node.props;
+        strict = _props.strict;
+        sensitive = _props.sensitive;
+        path = _props.path;
+      } else if (node.type === Redirect) {
+        var _props2 = node.props;
+        path = _props2.path;
+        strict = _props2.strict;
+        from = _props2.from;
+      }
+      var exact = node.props.exact;
+      var target = path || from;
+
+      // 更新匹配状态，一旦匹配到停止遍历
+      if (target) {
+        match = matchPath(location.pathname, target, {
+          strictMode: strict,
+          caseSensitive: sensitive,
+          exact: exact
+        });
+      } else {
+        match = context.match;
+      }
+    }
+  });
+  if (match && element) {
+    // 使用cloneElement复制已有组件并更新其Props
+    return cloneElement(element, {
+      location: location,
+      computed: match
+    });
+  }
+  return null;
+}
+
+function Prompt(props) {
+  var context = useContext(RouterContext);
+  var message = props.message,
+    _props$when = props.when,
+    when = _props$when === void 0 ? true : _props$when;
+  if (typeof when === 'function' && when(context.location) === false || !when) {
+    return null;
+  }
+  var navigate = context.history.block;
+  var release = null;
+  var onMountFunc = function () {
+    release = message ? navigate(message) : null;
+  };
+  var onUpdateFunc = function (prevProps) {
+    if (prevProps && prevProps.data !== message) {
+      if (release) {
+        release();
+      }
+      release = message ? navigate(message) : null;
+    }
+  };
+  var onUnmountFunc = function () {
+    if (release) {
+      release();
+    }
+    release = null;
+  };
+  return /*#__PURE__*/React.createElement(LifeCycle, {
+    onMount: onMountFunc,
+    onUpdate: onUpdateFunc,
+    onUnmount: onUnmountFunc,
+    data: message
+  });
+}
+
+function withRouter(Component) {
+  function ComponentWithRouterProp(props) {
+    var _useContext = useContext(RouterContext),
+      history = _useContext.history,
+      location = _useContext.location,
+      match = _useContext.match;
+    var routeProps = {
+      history: history,
+      location: location,
+      match: match
+    };
+    return /*#__PURE__*/React.createElement(Component, _extends({}, props, routeProps));
+  }
+  return ComponentWithRouterProp;
+}
+
+function HashRouter(props) {
+  var historyRef = useRef();
+  if (historyRef.current === null || historyRef.current === undefined) {
+    historyRef.current = createHashHistory({
+      basename: props.basename,
+      getUserConfirmation: props.getUserConfirmation,
+      hashType: props.hashType
+    });
+  }
+  return /*#__PURE__*/React.createElement(Router, {
+    history: historyRef.current
+  }, props.children);
+}
+
+function BrowserRouter(props) {
+  // 使用Ref持有History对象，防止重复渲染
+  var historyRef = useRef();
+  if (historyRef.current === null || historyRef.current === undefined) {
+    historyRef.current = createBrowserHistory({
+      basename: props.basename,
+      forceRefresh: props.forceRefresh,
+      getUserConfirmation: props.getUserConfirmation
+    });
+  }
+  return /*#__PURE__*/React.createElement(Router, {
+    history: historyRef.current
+  }, props.children);
+}
+
+var _excluded$1 = ["to", "replace", "component", "onClick", "target"];
+var isModifiedEvent = function (event) {
+  return event.metaKey || event.altKey || event.ctrlKey || event.shiftKey;
+};
+var checkTarget = function (target) {
+  return !target || target === '_self';
+};
+function Link(props) {
+  var to = props.to,
+    replace = props.replace;
+    props.component;
+    var onClick = props.onClick,
+    target = props.target,
+    other = _objectWithoutPropertiesLoose(props, _excluded$1);
+  var tag = props.tag || 'a';
+  var context = useContext(RouterContext);
+  var history = context.history;
+  var location = typeof to === 'function' ? to(context.location) : to;
+  var state;
+  var path;
+  if (typeof location === 'string') {
+    path = parsePath(location);
+  } else {
+    var pathname = location.pathname,
+      hash = location.hash,
+      search = location.search;
+    path = {
+      pathname: pathname,
+      hash: hash,
+      search: search
+    };
+    state = location.state;
+  }
+  var href = history.createHref(path);
+  var linkClickEvent = function (event) {
+    try {
+      if (onClick) {
+        onClick(event);
+      }
+    } catch (e) {
+      event.preventDefault();
+      throw e;
+    }
+    if (!event.defaultPrevented && event.button === 0 && checkTarget(target) && !isModifiedEvent(event)) {
+      // 不是相同的路径执行push操作，是相同的路径执行replace
+      var isSamePath = createPath(context.location) === createPath(path);
+      var navigate = replace || isSamePath ? history.replace : history.push;
+      event.preventDefault();
+      navigate(path, state);
+    }
+  };
+  var linkProps = _extends({
+    href: href,
+    onClick: linkClickEvent
+  }, other);
+  return React.createElement(tag, linkProps);
+}
+
+var _excluded = ["to", "isActive"];
+function NavLink(props) {
+  var to = props.to,
+    isActive = props.isActive,
+    rest = _objectWithoutPropertiesLoose(props, _excluded);
+  var context = useContext(RouterContext);
+  var toLocation = typeof to === 'function' ? to(context.location) : to;
+  var _ref = typeof toLocation === 'string' ? parsePath(toLocation) : toLocation,
+    path = _ref.pathname;
+  // 把正则表达式的特殊符号加两个反斜杠进行转义
+  var escapedPath = path ? escapeStr(path) : '';
+  var match = escapedPath ? matchPath(context.location.pathname, escapedPath) : null;
+  var isLinkActive = match && isActive ? isActive(match, context.location) : false;
+  var page = 'page';
+  var otherProps = _extends({
+    'aria-current': isLinkActive ? page : false
+  }, rest);
+  return /*#__PURE__*/React.createElement(Link, _extends({
+    to: to
+  }, otherProps));
+}
+
+export { BrowserRouter, HashRouter, Link, NavLink, Prompt, Redirect, Route, Router, Switch, RouterContext as __RouterContext, createBrowserHistory, createHashHistory, generatePath, matchPath, useHistory, useLocation, useParams, useRouteMatch, withRouter };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"router.js","sources":["../../src/history/dom.ts","../../src/history/types.ts","../../../../node_modules/@babel/runtime/helpers/esm/extends.js","../../src/history/utils.ts","../../../../node_modules/@babel/runtime/helpers/esm/classCallCheck.js","../../../../node_modules/@babel/runtime/helpers/esm/typeof.js","../../../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js","../../../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js","../../../../node_modules/@babel/runtime/helpers/esm/createClass.js","../../src/history/transitionManager.ts","../../src/history/waring.ts","../../src/history/baseHistory.ts","../../src/history/browerHistory.ts","../../src/history/hashHistory.ts","../../src/router/context.tsx","../../src/router/matcher/types.ts","../../src/router/matcher/utils.ts","../../src/router/matcher/lexer.ts","../../src/router/matcher/parser.ts","../../src/router/hooks.ts","../../src/router/Route.tsx","../../src/router/Router.tsx","../../../../node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js","../../src/router/lifeCycleHook.ts","../../src/router/Redirect.tsx","../../src/router/Switch.tsx","../../src/router/Prompt.tsx","../../src/router/withRouter.tsx","../../src/router/HashRouter.tsx","../../src/router/BrowserRouter.tsx","../../src/router/Link.tsx","../../src/router/NavLink.tsx"],"sourcesContent":["export function isBrowser(): boolean {\r\n  return typeof window !== 'undefined' && window.document && typeof window.document.createElement === 'function';\r\n}\r\n\r\nexport function getDefaultConfirmation(message: string, callBack: (result: boolean) => void) {\r\n  callBack(window.confirm(message));\r\n}\r\n\r\n// 判断浏览器是否支持pushState方法，pushState是browserHistory实现的基础\r\nexport function isSupportHistory(): boolean {\r\n  return isBrowser() && window.history && 'pushState' in window.history;\r\n}\r\n\r\n// 判断浏览器是否支持PopState事件\r\nexport function isSupportsPopState(): boolean {\r\n  return window.navigator.userAgent.indexOf('Trident') === -1;\r\n}\r\n","export type BaseOption = {\r\n  basename?: string;\r\n  getUserConfirmation?: ConfirmationFunc;\r\n};\r\n\r\nexport interface HistoryProps<T = unknown> {\r\n  readonly action: Action;\r\n\r\n  readonly location: Location<T>;\r\n\r\n  length: number;\r\n}\r\n\r\nexport interface History<T = unknown> extends HistoryProps<T> {\r\n  createHref(path: Partial<Path>): string;\r\n\r\n  push(to: To, state?: T): void;\r\n\r\n  replace(to: To, state?: T): void;\r\n\r\n  listen(listener: Listener<T>): () => void;\r\n\r\n  block(prompt: Prompt<T>): () => void;\r\n\r\n  go(index: number): void;\r\n\r\n  goBack(): void;\r\n\r\n  goForward(): void;\r\n}\r\n\r\nexport enum Action {\r\n  pop = 'POP',\r\n  push = 'PUSH',\r\n  replace = 'REPLACE',\r\n}\r\n\r\nexport enum EventType {\r\n  PopState = 'popstate',\r\n  HashChange = 'hashchange',\r\n}\r\n\r\nexport type Path = {\r\n  pathname: string;\r\n\r\n  search: string;\r\n\r\n  hash: string;\r\n};\r\n\r\nexport type HistoryState<T> = {\r\n  state?: T;\r\n\r\n  key: string;\r\n};\r\n\r\nexport type DefaultStateType = unknown;\r\n\r\nexport type Location<T = unknown> = Path & HistoryState<T>;\r\n\r\nexport type To = string | Partial<Path>;\r\n\r\nexport interface Listener<T = unknown> {\r\n  (navigation: Navigation<T>): void;\r\n}\r\n\r\nexport interface Navigation<T = unknown> {\r\n  action: Action;\r\n\r\n  location: Location<T>;\r\n}\r\n\r\nexport type Prompt<S> = string | boolean | null | ((location: Location<S>, action: Action) => void);\r\n\r\nexport type CallBackFunc = (isJump: boolean) => void;\r\n\r\nexport type ConfirmationFunc = (message: string, callBack: CallBackFunc) => void;\r\n\r\nexport interface TManager<S> {\r\n  setPrompt(next: Prompt<S>): () => void;\r\n\r\n  addListener(func: (navigation: Navigation<S>) => void): () => void;\r\n\r\n  notifyListeners(args: Navigation<S>): void;\r\n\r\n  confirmJumpTo(\r\n    location: Location<S>,\r\n    action: Action,\r\n    userConfirmationFunc: ConfirmationFunc,\r\n    callBack: CallBackFunc,\r\n  ): void;\r\n}\r\n","export default function _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}","import { Action, Location, Path, To } from './types';\r\n\r\nexport function createPath(path: Partial<Path>): string {\r\n  const { search, hash } = path;\r\n  let pathname = path.pathname || '/';\r\n  if (search && search !== '?') {\r\n    pathname += search.startsWith('?') ? search : '?' + search;\r\n  }\r\n  if (hash && hash !== '#') {\r\n    pathname += hash.startsWith('#') ? hash : '#' + hash;\r\n  }\r\n  return pathname;\r\n}\r\n\r\nexport function parsePath(url: string): Partial<Path> {\r\n  if (!url) {\r\n    return {};\r\n  }\r\n  let parsedPath: Partial<Path> = {};\r\n\r\n  let hashIdx = url.indexOf('#');\r\n  if (hashIdx > -1) {\r\n    parsedPath.hash = url.substring(hashIdx);\r\n    url = url.substring(0, hashIdx);\r\n  }\r\n\r\n  let searchIdx = url.indexOf('?');\r\n  if (searchIdx > -1) {\r\n    parsedPath.search = url.substring(searchIdx);\r\n    url = url.substring(0, searchIdx);\r\n  }\r\n  if (url) {\r\n    parsedPath.pathname = url;\r\n  }\r\n  return parsedPath;\r\n}\r\n\r\nexport function createLocation<S>(current: string | Location, to: To, state?: S, key?: string): Readonly<Location<S>> {\r\n  let pathname = typeof current === 'string' ? current : current.pathname;\r\n  let urlObj = typeof to === 'string' ? parsePath(to) : to;\r\n  // 随机key长度取6\r\n  const getRandKey = genRandomKey(6);\r\n  const location = {\r\n    pathname: pathname,\r\n    search: '',\r\n    hash: '',\r\n    state: state,\r\n    key: typeof key === 'string' ? key : getRandKey(),\r\n    ...urlObj,\r\n  };\r\n  if (!location.pathname) {\r\n    location.pathname = '/';\r\n  }\r\n  return location;\r\n}\r\n\r\nexport function isLocationEqual(p1: Partial<Path>, p2: Partial<Path>) {\r\n  return p1.pathname === p2.pathname && p1.search === p2.search && p1.hash === p2.hash;\r\n}\r\n\r\nexport function addHeadSlash(path: string): string {\r\n  if (path[0] === '/') {\r\n    return path;\r\n  }\r\n  return '/' + path;\r\n}\r\n\r\nexport function stripHeadSlash(path: string): string {\r\n  if (path[0] === '/') {\r\n    return path.substring(1);\r\n  }\r\n  return path;\r\n}\r\n\r\nexport function normalizeSlash(path: string): string {\r\n  const tempPath = addHeadSlash(path);\r\n  if (tempPath[tempPath.length - 1] === '/') {\r\n    return tempPath.substring(0, tempPath.length - 1);\r\n  }\r\n  return tempPath;\r\n}\r\n\r\nexport function hasBasename(path: string, prefix: string): Boolean {\r\n  return (\r\n    path.toLowerCase().indexOf(prefix.toLowerCase()) === 0 && ['/', '?', '#', ''].includes(path.charAt(prefix.length))\r\n  );\r\n}\r\n\r\nexport function stripBasename(path: string, prefix: string): string {\r\n  return hasBasename(path, prefix) ? path.substring(prefix.length) : path;\r\n}\r\n\r\n// 使用随机生成的Key记录被访问过的URL，当Block被被触发时利用delta值跳转到之前的页面\r\nexport function createMemoryRecord<T, S>(initVal: S, fn: (arg: S) => T) {\r\n  let visitedRecord: T[] = [fn(initVal)];\r\n\r\n  function getDelta(to: S, form: S): number {\r\n    let toIdx = visitedRecord.lastIndexOf(fn(to));\r\n    if (toIdx === -1) {\r\n      toIdx = 0;\r\n    }\r\n    let fromIdx = visitedRecord.lastIndexOf(fn(form));\r\n    if (fromIdx === -1) {\r\n      fromIdx = 0;\r\n    }\r\n    return toIdx - fromIdx;\r\n  }\r\n\r\n  function addRecord(current: S, newRecord: S, action: Action) {\r\n    const curVal = fn(current);\r\n    const NewVal = fn(newRecord);\r\n    if (action === Action.push) {\r\n      const prevIdx = visitedRecord.lastIndexOf(curVal);\r\n      const newVisitedRecord = visitedRecord.slice(0, prevIdx + 1);\r\n      newVisitedRecord.push(NewVal);\r\n      visitedRecord = newVisitedRecord;\r\n    }\r\n    if (action === Action.replace) {\r\n      const prevIdx = visitedRecord.lastIndexOf(curVal);\r\n      if (prevIdx !== -1) {\r\n        visitedRecord[prevIdx] = NewVal;\r\n      }\r\n    }\r\n  }\r\n\r\n  return { getDelta, addRecord };\r\n}\r\n\r\nfunction genRandomKey(length: number): () => string {\r\n  const end = length + 2;\r\n  return () => {\r\n    return Math.random().toString(18).substring(2, end);\r\n  };\r\n}\r\n","export default function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}","export default function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n    return typeof obj;\n  } : function (obj) {\n    return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n  }, _typeof(obj);\n}","import _typeof from \"./typeof.js\";\nexport default function _toPrimitive(input, hint) {\n  if (_typeof(input) !== \"object\" || input === null) return input;\n  var prim = input[Symbol.toPrimitive];\n  if (prim !== undefined) {\n    var res = prim.call(input, hint || \"default\");\n    if (_typeof(res) !== \"object\") return res;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (hint === \"string\" ? String : Number)(input);\n}","import _typeof from \"./typeof.js\";\nimport toPrimitive from \"./toPrimitive.js\";\nexport default function _toPropertyKey(arg) {\n  var key = toPrimitive(arg, \"string\");\n  return _typeof(key) === \"symbol\" ? key : String(key);\n}","import toPropertyKey from \"./toPropertyKey.js\";\nfunction _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, toPropertyKey(descriptor.key), descriptor);\n  }\n}\nexport default function _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  Object.defineProperty(Constructor, \"prototype\", {\n    writable: false\n  });\n  return Constructor;\n}","import { Action, CallBackFunc, ConfirmationFunc, Listener, Location, Navigation, Prompt, TManager } from './types';\r\n\r\nclass TransitionManager<S> implements TManager<S> {\r\n  private prompt: Prompt<S>;\r\n  private listeners: Listener<S>[];\r\n\r\n  constructor() {\r\n    this.prompt = null;\r\n    this.listeners = [];\r\n  }\r\n\r\n  public setPrompt(prompt: Prompt<S>): () => void {\r\n    this.prompt = prompt;\r\n\r\n    // 清除Prompt\r\n    return () => {\r\n      if (this.prompt === prompt) {\r\n        this.prompt = null;\r\n      }\r\n    };\r\n  }\r\n\r\n  // 使用发布订阅模式管理history的监听者\r\n  public addListener(func: Listener<S>): () => void {\r\n    let isActive = true;\r\n    const listener = (args: Navigation<S>) => {\r\n      if (isActive) {\r\n        func(args);\r\n      }\r\n    };\r\n    this.listeners.push(listener);\r\n    return () => {\r\n      isActive = false;\r\n      // 移除对应的监听者\r\n      this.listeners = this.listeners.filter(item => item !== listener);\r\n    };\r\n  }\r\n\r\n  public notifyListeners(args: Navigation<S>) {\r\n    for (const listener of this.listeners) {\r\n      listener(args);\r\n    }\r\n  }\r\n\r\n  public confirmJumpTo(\r\n    location: Location<S>,\r\n    action: Action,\r\n    userConfirmationFunc: ConfirmationFunc,\r\n    callBack: CallBackFunc\r\n  ) {\r\n    if (this.prompt !== null) {\r\n      const result = typeof this.prompt === 'function' ? this.prompt(location, action) : this.prompt;\r\n      if (typeof result === 'string') {\r\n        typeof userConfirmationFunc === 'function' ? userConfirmationFunc(result, callBack) : callBack(true);\r\n      } else {\r\n        callBack(result !== false);\r\n      }\r\n    } else {\r\n      callBack(true);\r\n    }\r\n  }\r\n}\r\n\r\nexport default TransitionManager;\r\n","function warning(condition: any, message: string) {\r\n  if (condition) {\r\n    if (console && typeof console.warn === 'function') {\r\n      console.warn(message);\r\n    }\r\n  }\r\n}\r\n\r\nexport default warning;","import { HistoryProps, Listener, Navigation, Prompt } from './types';\r\nimport transitionManager from './transitionManager';\r\n\r\n// 抽取BrowserHistory和HashHistory中相同的方法\r\nexport function getBaseHistory<S>(\r\n  transitionManager: transitionManager<S>,\r\n  setListener: (delta: number) => void,\r\n  browserHistory: History,\r\n) {\r\n  function go(step: number) {\r\n    browserHistory.go(step);\r\n  }\r\n\r\n  function goBack() {\r\n    browserHistory.go(-1);\r\n  }\r\n\r\n  function goForward() {\r\n    browserHistory.go(1);\r\n  }\r\n\r\n  function listen(listener: Listener<S>): () => void {\r\n    const cancel = transitionManager.addListener(listener);\r\n    setListener(1);\r\n    return () => {\r\n      setListener(-1);\r\n      cancel();\r\n    };\r\n  }\r\n\r\n  let isBlocked = false;\r\n\r\n  function block(prompt: Prompt<S> = false): () => void {\r\n    const unblock = transitionManager.setPrompt(prompt);\r\n    if (!isBlocked) {\r\n      setListener(1);\r\n      isBlocked = true;\r\n    }\r\n    return () => {\r\n      if (isBlocked) {\r\n        isBlocked = false;\r\n        setListener(-1);\r\n      }\r\n      unblock();\r\n    };\r\n  }\r\n\r\n  function getUpdateStateFunc(historyProps: HistoryProps<S>) {\r\n    return function (nextState: Navigation<S> | undefined) {\r\n      if (nextState) {\r\n        Object.assign(historyProps, nextState);\r\n      }\r\n      historyProps.length = browserHistory.length;\r\n      const args = { location: historyProps.location, action: historyProps.action };\r\n      transitionManager.notifyListeners(args);\r\n    };\r\n  }\r\n\r\n  return { go, goBack, goForward, listen, block, getUpdateStateFunc };\r\n}\r\n","import { getDefaultConfirmation, isSupportHistory, isSupportsPopState } from './dom';\r\nimport { Action, BaseOption, DefaultStateType, EventType, History, HistoryState, Location, Path, To } from './types';\r\nimport { normalizeSlash, createMemoryRecord, createPath, createLocation, stripBasename } from './utils';\r\nimport TransitionManager from './transitionManager';\r\n\r\nimport warning from './waring';\r\nimport { getBaseHistory } from './baseHistory';\r\n\r\nexport type BrowserHistoryOption = {\r\n  /**\r\n   * forceRefresh为True时跳转时会强制刷新页面\r\n   */\r\n  forceRefresh?: boolean;\r\n} & BaseOption;\r\n\r\nexport function createBrowserHistory<S = DefaultStateType>(options: BrowserHistoryOption = {}): History<S> {\r\n  const supportHistory = isSupportHistory();\r\n  const isSupportPopState = isSupportsPopState();\r\n  const browserHistory = window.history;\r\n  const { forceRefresh = false, getUserConfirmation = getDefaultConfirmation } = options;\r\n\r\n  const basename = options.basename ? normalizeSlash(options.basename) : '';\r\n\r\n  const initLocation = getLocation(getHistoryState());\r\n\r\n  const recordOperator = createMemoryRecord<string, Location<S>>(initLocation, l => l.key);\r\n\r\n  const transitionManager = new TransitionManager<S>();\r\n\r\n  const { go, goBack, goForward, listen, block, getUpdateStateFunc } = getBaseHistory<S>(\r\n    transitionManager,\r\n    setListener,\r\n    browserHistory,\r\n  );\r\n\r\n  const history: History<S> = {\r\n    action: Action.pop,\r\n    length: browserHistory.length,\r\n    location: initLocation,\r\n    go,\r\n    goBack,\r\n    goForward,\r\n    listen,\r\n    block,\r\n    push,\r\n    replace,\r\n    createHref,\r\n  };\r\n\r\n  const updateState = getUpdateStateFunc(history);\r\n\r\n  function getHistoryState() {\r\n    return supportHistory ? window.history.state : {};\r\n  }\r\n\r\n  function getLocation(historyState: Partial<HistoryState<S>>) {\r\n    const { search, hash } = window.location;\r\n    const { key, state } = historyState || {};\r\n    let pathname = window.location.pathname;\r\n    pathname = basename ? stripBasename(pathname, basename) : pathname;\r\n\r\n    return createLocation<S>('', { pathname, search, hash }, state, key);\r\n  }\r\n\r\n  // 拦截页面POP事件后，防止返回到的页面被重复拦截\r\n  let forceJump = false;\r\n\r\n  function handlePopState(location: Location<S>) {\r\n    if (forceJump) {\r\n      forceJump = false;\r\n      updateState(undefined);\r\n    } else {\r\n      const action = Action.pop;\r\n\r\n      const callback = (isJump: boolean) => {\r\n        if (isJump) {\r\n          // 执行跳转行为\r\n          updateState({ action: action, location: location });\r\n        } else {\r\n          revertPopState(location, history.location);\r\n        }\r\n      };\r\n\r\n      transitionManager.confirmJumpTo(location, action, getUserConfirmation, callback);\r\n    }\r\n  }\r\n\r\n  function popStateListener(event: PopStateEvent) {\r\n    handlePopState(getLocation(event.state));\r\n  }\r\n\r\n  function hashChangeListener() {\r\n    const location = getLocation(getHistoryState());\r\n    handlePopState(location);\r\n  }\r\n\r\n  let listenerCount = 0;\r\n\r\n  function setListener(count: number) {\r\n    listenerCount += count;\r\n    if (listenerCount === 1 && count === 1) {\r\n      window.addEventListener(EventType.PopState, popStateListener);\r\n      if (!isSupportPopState) {\r\n        window.addEventListener(EventType.HashChange, hashChangeListener);\r\n      }\r\n    } else if (listenerCount === 0) {\r\n      window.removeEventListener(EventType.PopState, popStateListener);\r\n      if (!isSupportPopState) {\r\n        window.removeEventListener(EventType.HashChange, hashChangeListener);\r\n      }\r\n    }\r\n  }\r\n\r\n  // 取消页面跳转并恢复到跳转前的页面\r\n  function revertPopState(form: Location<S>, to: Location<S>) {\r\n    const delta = recordOperator.getDelta(to, form);\r\n    if (delta !== 0) {\r\n      go(delta);\r\n      forceJump = true;\r\n    }\r\n  }\r\n\r\n  function createHref(path: Partial<Path>) {\r\n    return basename + createPath(path);\r\n  }\r\n\r\n  function push(to: To, state?: S) {\r\n    const action = Action.push;\r\n    const location = createLocation<S>(history.location, to, state, undefined);\r\n\r\n    transitionManager.confirmJumpTo(location, action, getUserConfirmation, isJump => {\r\n      if (!isJump) {\r\n        return;\r\n      }\r\n      const href = createHref(location);\r\n      const { key, state } = location;\r\n\r\n      if (supportHistory) {\r\n        if (forceRefresh) {\r\n          window.location.href = href;\r\n        } else {\r\n          browserHistory.pushState({ key: key, state: state }, '', href);\r\n          recordOperator.addRecord(history.location, location, action);\r\n          updateState({ action, location });\r\n        }\r\n      } else {\r\n        warning(state !== undefined, 'Browser history cannot push state in browsers that do not support HTML5 history');\r\n        window.location.href = href;\r\n      }\r\n    });\r\n  }\r\n\r\n  function replace(to: To, state?: S) {\r\n    const action = Action.replace;\r\n    const location = createLocation<S>(history.location, to, state, undefined);\r\n\r\n    transitionManager.confirmJumpTo(location, action, getUserConfirmation, isJump => {\r\n      if (!isJump) {\r\n        return;\r\n      }\r\n      const href = createHref(location);\r\n      const { key, state } = location;\r\n      if (supportHistory) {\r\n        if (forceRefresh) {\r\n          window.location.replace(href);\r\n        } else {\r\n          browserHistory.replaceState({ key: key, state: state }, '', href);\r\n          recordOperator.addRecord(history.location, location, action);\r\n          updateState({ action, location });\r\n        }\r\n      } else {\r\n        warning(state !== undefined, 'Browser history cannot push state in browsers that do not support HTML5 history');\r\n        window.location.replace(href);\r\n      }\r\n    });\r\n  }\r\n\r\n  return history;\r\n}\r\n","import { Action, BaseOption, DefaultStateType, EventType, History, Location, To } from './types';\r\nimport {\r\n  addHeadSlash,\r\n  normalizeSlash,\r\n  createMemoryRecord,\r\n  createPath,\r\n  createLocation,\r\n  isLocationEqual,\r\n  stripBasename,\r\n  stripHeadSlash,\r\n} from './utils';\r\nimport { getDefaultConfirmation } from './dom';\r\nimport TransitionManager from './transitionManager';\r\n\r\nimport warning from './waring';\r\nimport { getBaseHistory } from './baseHistory';\r\n\r\nexport type urlHashType = 'slash' | 'noslash';\r\n\r\ntype HashHistoryOption = {\r\n  hashType?: urlHashType;\r\n} & BaseOption;\r\n\r\n// 获取#前的内容\r\nfunction stripHash(path: string): string {\r\n  const idx = path.indexOf('#');\r\n  return idx === -1 ? path : path.substring(0, idx);\r\n}\r\n\r\n// 获取#后的内容\r\nfunction getHashContent(path: string): string {\r\n  const idx = path.indexOf('#');\r\n  return idx === -1 ? '' : path.substring(idx + 1);\r\n}\r\n\r\nexport function createHashHistory<S = DefaultStateType>(option: HashHistoryOption = {}): History<S> {\r\n  const browserHistory = window.history;\r\n  const { hashType = 'slash', getUserConfirmation = getDefaultConfirmation } = option;\r\n\r\n  const basename = option.basename ? normalizeSlash(option.basename) : '';\r\n\r\n  const pathDecoder = addHeadSlash;\r\n  const pathEncoder = hashType === 'slash' ? addHeadSlash : stripHeadSlash;\r\n\r\n  function getLocation() {\r\n    let hashPath = pathDecoder(getHashContent(window.location.hash));\r\n    if (basename) {\r\n      hashPath = stripBasename(hashPath, basename);\r\n    }\r\n\r\n    return createLocation<S>('', hashPath, undefined, 'default');\r\n  }\r\n\r\n  const initLocation = getLocation();\r\n\r\n  const memRecords = createMemoryRecord<string, Location<S>>(initLocation, createPath);\r\n\r\n  const transitionManager = new TransitionManager<S>();\r\n\r\n  function createHref(location: Location<S>) {\r\n    const tag = document.querySelector('base');\r\n    const base = tag && tag.getAttribute('href') ? stripHash(window.location.href) : '';\r\n    return base + '#' + pathEncoder(basename + createPath(location));\r\n  }\r\n\r\n  let forceNextPop = false;\r\n  let ignorePath: null | string = null;\r\n\r\n  const { go, goBack, goForward, listen, block, getUpdateStateFunc } = getBaseHistory(\r\n    transitionManager,\r\n    setListener,\r\n    browserHistory,\r\n  );\r\n\r\n  const history: History<S> = {\r\n    action: Action.pop,\r\n    length: browserHistory.length,\r\n    location: initLocation,\r\n    go,\r\n    goBack,\r\n    goForward,\r\n    push,\r\n    replace,\r\n    listen,\r\n    block,\r\n    createHref,\r\n  };\r\n\r\n  const updateState = getUpdateStateFunc(history);\r\n\r\n  function push(to: To, state?: S) {\r\n    warning(state !== undefined, 'Hash history does not support state, it will be ignored');\r\n\r\n    const action = Action.push;\r\n    const location = createLocation<S>(history.location, to, undefined, '');\r\n\r\n    transitionManager.confirmJumpTo(location, action, getUserConfirmation, isJump => {\r\n      if (!isJump) {\r\n        return;\r\n      }\r\n      const path = createPath(location);\r\n      const encodedPath = pathEncoder(basename + path);\r\n      // 前后hash不一样才进行跳转\r\n      if (getHashContent(window.location.href) !== encodedPath) {\r\n        ignorePath = encodedPath;\r\n        window.location.hash = encodedPath;\r\n\r\n        memRecords.addRecord(history.location, location, action);\r\n\r\n        updateState({ action, location });\r\n      } else {\r\n        updateState(undefined);\r\n      }\r\n    });\r\n  }\r\n\r\n  function replace(to: To, state?: S) {\r\n    warning(state !== undefined, 'Hash history does not support state, it will be ignored');\r\n    const action = Action.replace;\r\n    const location = createLocation<S>(history.location, to, undefined, '');\r\n\r\n    transitionManager.confirmJumpTo(location, action, getUserConfirmation, isJump => {\r\n      if (!isJump) {\r\n        return;\r\n      }\r\n      const path = createPath(location);\r\n      const encodedPath = pathEncoder(basename + path);\r\n      if (getHashContent(window.location.href) !== encodedPath) {\r\n        ignorePath = path;\r\n        window.location.replace(stripHash(window.location.href) + '#' + encodedPath);\r\n      }\r\n      memRecords.addRecord(history.location, location, action);\r\n      updateState({ action, location });\r\n    });\r\n  }\r\n\r\n  function handleHashChange() {\r\n    const hashPath = getHashContent(window.location.href);\r\n    const encodedPath = pathEncoder(hashPath);\r\n    if (hashPath !== encodedPath) {\r\n      window.location.replace(stripHash(window.location.href) + '#' + encodedPath);\r\n    } else {\r\n      const location = getLocation();\r\n      const prevLocation = history.location;\r\n      if (!forceNextPop && isLocationEqual(location, prevLocation)) {\r\n        return;\r\n      }\r\n      if (ignorePath === createPath(location)) {\r\n        return;\r\n      }\r\n      ignorePath = null;\r\n      handlePopState(location);\r\n    }\r\n  }\r\n\r\n  function handlePopState(location: Location<S>) {\r\n    if (forceNextPop) {\r\n      forceNextPop = false;\r\n      updateState(undefined);\r\n    } else {\r\n      const action = Action.pop;\r\n\r\n      const callback = (isJump: boolean) => {\r\n        if (isJump) {\r\n          updateState({ action: action, location: location });\r\n        } else {\r\n          revertPopState(location);\r\n        }\r\n      };\r\n\r\n      transitionManager.confirmJumpTo(location, action, getUserConfirmation, callback);\r\n    }\r\n  }\r\n\r\n  // 在跳转行为被Block后，用History.go()跳转回之前的页面\r\n  function revertPopState(form: Location<S>) {\r\n    const to = history.location;\r\n    const delta = memRecords.getDelta(to, form);\r\n    if (delta !== 0) {\r\n      go(delta);\r\n      forceNextPop = true;\r\n    }\r\n  }\r\n\r\n  let listenerCount = 0;\r\n\r\n  function setListener(delta: number) {\r\n    listenerCount += delta;\r\n    if (listenerCount === 1 && delta === 1) {\r\n      window.addEventListener(EventType.HashChange, handleHashChange);\r\n    } else if (listenerCount === 0) {\r\n      window.removeEventListener(EventType.HashChange, handleHashChange);\r\n    }\r\n  }\r\n\r\n  return history;\r\n}\r\n","import { createContext } from 'react';\r\nimport { History, Location } from './index';\r\nimport { Matched } from './matcher/parser';\r\n\r\nfunction createNamedContext<T>(name: string, defaultValue: T) {\r\n  const context = createContext<T>(defaultValue);\r\n  context.displayName = name;\r\n  return context;\r\n}\r\n\r\nexport type RouterContextValue = {\r\n  history: History;\r\n  location: Location;\r\n  match: Matched | null;\r\n};\r\n\r\nconst RouterContext = createNamedContext<RouterContextValue>('Router', {} as any);\r\n\r\nexport default RouterContext;","import { Matched, Params } from './parser';\r\n\r\nexport type Token = {\r\n  type: TokenType;\r\n  value: string;\r\n};\r\n\r\nexport enum TokenType {\r\n  Delimiter = 'delimiter',\r\n  Static = 'static',\r\n  Param = 'param',\r\n  WildCard = 'wildcard',\r\n  LBracket = '(',\r\n  RBracket = ')',\r\n  Pattern = 'pattern',\r\n}\r\n\r\nexport interface Parser<P> {\r\n  regexp: RegExp;\r\n\r\n  keys: string[];\r\n\r\n  parse(url: string): Matched<P> | null;\r\n\r\n  compile(params: Params<P>): string;\r\n}\r\n\r\nexport type ParserOption = {\r\n  // 是否大小写敏感\r\n  caseSensitive?: boolean;\r\n  // 是否启用严格模式\r\n  strictMode?: boolean;\r\n  // 精准匹配 兼容 React-RouterV5\r\n  exact?: boolean;\r\n};\r\n\r\ntype ClearLeading<U extends string> = U extends `/${infer R}` ? ClearLeading<R> : U;\r\ntype ClearTailing<U extends string> = U extends `${infer L}/` ? ClearTailing<L> : U;\r\n\r\ntype ParseParam<Param extends string> = Param extends `:${infer R}`\r\n  ? {\r\n    [K in R]: string;\r\n  }\r\n  : {};\r\n\r\ntype MergeParams<OneParam extends Record<string, any>, OtherParam extends Record<string, any>> = {\r\n  readonly [Key in keyof OneParam | keyof OtherParam]?: string;\r\n};\r\n\r\ntype ParseURLString<Str extends string> = Str extends `${infer Param}/${infer Rest}`\r\n  ? MergeParams<ParseParam<Param>, ParseURLString<ClearLeading<Rest>>>\r\n  : ParseParam<Str>;\r\n\r\n// 解析URL中的动态参数，以实现TypeScript提示功能\r\nexport type GetURLParams<U extends string> = ParseURLString<ClearLeading<ClearTailing<U>>>;\r\n","/**\r\n * @description 将url中的//转换为/\r\n */\r\nexport function cleanPath(path: string): string {\r\n  return path.replace(/\\/+/g, '/');\r\n}\r\n\r\nexport function scoreCompare(score1: number[], score2: number[]): number {\r\n  const score1Length = score1.length;\r\n  const score2Length = score2.length;\r\n  const end = Math.min(score1Length, score2Length);\r\n  for (let i = 0; i < end; i++) {\r\n    const delta = score2[i] - score1[i];\r\n    if (delta !== 0) {\r\n      return delta;\r\n    }\r\n  }\r\n  if (score1Length === score2Length) {\r\n    return 0;\r\n  }\r\n  return score1Length > score2Length ? -1 : 1;\r\n}\r\n\r\n// 把正则表达式的特殊符号加两个反斜杠进行转义\r\nexport function escapeStr(str: string) {\r\n  return str.replace(/([.+*?=^!:${}()[\\]|/\\\\])/g, '\\\\$1');\r\n}\r\n","import { Token, TokenType } from './types';\r\nimport { cleanPath } from './utils';\r\n\r\nconst validChar = /[^/:*()]/;\r\n\r\n// 对Url模板进行词法解析，解析结果为Tokens\r\nexport function lexer(path: string): Token[] {\r\n  const tokens: Token[] = [];\r\n\r\n  if (!path) {\r\n    return tokens;\r\n  }\r\n\r\n  let urlPath = cleanPath(path);\r\n  if (urlPath !== '*' && !urlPath.startsWith('/')) {\r\n    throw new Error(`Url must start with \"/\".`);\r\n  }\r\n\r\n  const getLiteral = () => {\r\n    let name = '';\r\n    while (i < urlPath.length && validChar.test(urlPath[i])) {\r\n      name += urlPath[i];\r\n      skipChar(1);\r\n    }\r\n    return name;\r\n  };\r\n\r\n  const skipChar = (step: number) => {\r\n    i += step;\r\n  };\r\n\r\n  let i = 0;\r\n  while (i < urlPath.length) {\r\n    const curChar = urlPath[i];\r\n    const prevChar = urlPath[i - 1];\r\n\r\n    if (curChar === '/') {\r\n      tokens.push({ type: TokenType.Delimiter, value: urlPath[i] });\r\n      skipChar(1);\r\n      continue;\r\n    }\r\n    // dynamic params (/:a)\r\n    if (prevChar === '/' && curChar === ':') {\r\n      skipChar(1);\r\n      tokens.push({ type: TokenType.Param, value: getLiteral() });\r\n      continue;\r\n    }\r\n    // wildCard params (/:*)\r\n    if ((prevChar === '/' || prevChar === undefined) && curChar === '*') {\r\n      tokens.push({ type: TokenType.WildCard, value: urlPath[i] });\r\n      skipChar(1);\r\n      continue;\r\n    }\r\n    // static params\r\n    if (prevChar === '/' && validChar.test(curChar)) {\r\n      tokens.push({ type: TokenType.Static, value: getLiteral() });\r\n      continue;\r\n    }\r\n    if (curChar === '(') {\r\n      tokens.push({ type: TokenType.LBracket, value: '(' });\r\n      skipChar(1);\r\n      continue;\r\n    }\r\n    if (curChar === ')') {\r\n      tokens.push({ type: TokenType.RBracket, value: ')' });\r\n      skipChar(1);\r\n      continue;\r\n    }\r\n    if (validChar.test(curChar)) {\r\n      tokens.push({ type: TokenType.Pattern, value: getLiteral() });\r\n      continue;\r\n    }\r\n    // 跳过非法字符\r\n    skipChar(1);\r\n  }\r\n\r\n  return tokens;\r\n}\r\n","import { GetURLParams, Parser, ParserOption, TokenType } from './types';\r\nimport { lexer } from './lexer';\r\nimport { escapeStr, scoreCompare } from './utils';\r\n\r\n// 不同类型参数的匹配得分\r\nenum MatchScore {\r\n  // 固定参数\r\n  static = 10,\r\n  // 动态参数\r\n  param = 6,\r\n  // 通配符参数\r\n  wildcard = 3,\r\n  placeholder = -1,\r\n}\r\n\r\nexport type Params<P> = { [K in keyof P]?: P[K] };\r\n\r\n// 兼容 react v5 matched类型\r\nexport type Matched<P = any> = {\r\n  score: number[];\r\n  params: Params<P>;\r\n  path: string;\r\n  url: string;\r\n  isExact: boolean;\r\n};\r\n\r\nconst defaultOption: Required<ParserOption> = {\r\n  // url匹配时是否大小写敏感\r\n  caseSensitive: true,\r\n  // 是否严格匹配url结尾的/\r\n  strictMode: false,\r\n  // 是否完全精确匹配\r\n  exact: false,\r\n};\r\n// 正则表达式中需要转义的字符\r\nconst REGEX_CHARS_RE = /[.+*?^${}()[\\]/\\\\]/g;\r\n// 用于匹配两个//中的的值\r\nconst BASE_PARAM_PATTERN = '[^/]+';\r\n\r\nconst DefaultDelimiter = '/#?';\r\n\r\nexport function createPathParser<Str extends string>(pathname: Str, option?: ParserOption): Parser<GetURLParams<Str>>;\r\nexport function createPathParser<P = unknown>(pathname: string, option?: ParserOption): Parser<P>;\r\nexport function createPathParser<P = unknown>(pathname: string, option: ParserOption = defaultOption): Parser<P> {\r\n  const {\r\n    caseSensitive = defaultOption.caseSensitive,\r\n    strictMode = defaultOption.strictMode,\r\n    exact = defaultOption.exact,\r\n  } = option;\r\n  /**\r\n   * URL匹配整体流程\r\n   * 1.词法解析，将URL模板解析为Token\r\n   * 2.使用Token生成正则表达式\r\n   * 3.利用正则表达式解析URL中参数或填充URL模板\r\n   */\r\n  let pattern = '^';\r\n  const keys: string[] = [];\r\n  const scores: number[] = [];\r\n\r\n  const tokens = lexer(pathname);\r\n  const onlyHasWildCard = tokens.length === 1 && tokens[0].type === TokenType.WildCard;\r\n  const tokenCount = tokens.length;\r\n  const lastToken = tokens[tokenCount - 1];\r\n\r\n  for (let tokenIdx = 0; tokenIdx < tokenCount; tokenIdx++) {\r\n    const token = tokens[tokenIdx];\r\n    const nextToken = tokens[tokenIdx + 1];\r\n    switch (token.type) {\r\n      case TokenType.Delimiter:\r\n        pattern += '/';\r\n        break;\r\n      case TokenType.Static:\r\n        pattern += token.value.replace(REGEX_CHARS_RE, '\\\\$&');\r\n        scores.push(MatchScore.static);\r\n        break;\r\n      case TokenType.Param:\r\n        let paramRegexp = '';\r\n        if (nextToken && nextToken.type === TokenType.LBracket) {\r\n          // 跳过当前Token和左括号\r\n          tokenIdx += 2;\r\n          while (tokens[tokenIdx].type !== TokenType.RBracket) {\r\n            paramRegexp += tokens[tokenIdx].value;\r\n            tokenIdx++;\r\n          }\r\n        }\r\n        pattern += paramRegexp ? `((?:${paramRegexp}))` : `(${BASE_PARAM_PATTERN})`;\r\n        keys.push(token.value);\r\n        scores.push(MatchScore.param);\r\n        break;\r\n      case TokenType.WildCard:\r\n        keys.push(token.value);\r\n        pattern += `((?:${BASE_PARAM_PATTERN})${onlyHasWildCard ? '?' : ''}(?:/(?:${BASE_PARAM_PATTERN}))*)`;\r\n        scores.push(onlyHasWildCard ? MatchScore.wildcard : MatchScore.placeholder);\r\n        break;\r\n    }\r\n  }\r\n  const isWildCard = lastToken.type === TokenType.WildCard;\r\n\r\n  if (!isWildCard && !exact) {\r\n    if (!strictMode) {\r\n      pattern += `(?:[${escapeStr(DefaultDelimiter)}](?=$))?`;\r\n    }\r\n    if (lastToken.type !== TokenType.Delimiter) {\r\n      pattern += `(?=[${escapeStr(DefaultDelimiter)}]|$)`;\r\n    }\r\n  } else {\r\n    pattern += strictMode ? '$' : `[${escapeStr(DefaultDelimiter)}]?$`;\r\n  }\r\n\r\n  const flag = caseSensitive ? '' : 'i';\r\n  const regexp = new RegExp(pattern, flag);\r\n\r\n  /**\r\n   * @description 根据给定Pattern解析path\r\n   */\r\n  function parse(path: string): Matched<P> | null {\r\n    const reMatch = path.match(regexp);\r\n\r\n    if (!reMatch) {\r\n      return null;\r\n    }\r\n    const matchedPath = reMatch[0];\r\n    let params: Params<P> = {};\r\n    let parseScore: number[] = Array.from(scores);\r\n    for (let i = 1; i < reMatch.length; i++) {\r\n      let param = reMatch[i];\r\n      let key = keys[i - 1];\r\n      if (key === '*' && param) {\r\n        let value = param.split('/');\r\n        if (!Array.isArray(params['*'])) {\r\n          params['*'] = value;\r\n        } else {\r\n          params['*'].push(...value);\r\n        }\r\n        // 完成通配符参数解析后将placeholder替换为wildcard参数的分值\r\n        parseScore.splice(\r\n          scores.indexOf(MatchScore.placeholder),\r\n          1,\r\n          ...new Array(value.length).fill(MatchScore.wildcard),\r\n        );\r\n      } else {\r\n        params[key] = param ? param : [];\r\n      }\r\n    }\r\n\r\n    const isExact = path === matchedPath;\r\n    const url = path === '/' && matchedPath === '' ? '/' : matchedPath;\r\n    return { isExact: isExact, path: pathname, url: url, score: parseScore, params: params };\r\n  }\r\n\r\n  /**\r\n   * @description 使用给定参数填充pattern，得到目标URL\r\n   */\r\n  function compile(params: Params<P>): string {\r\n    let path = '';\r\n    for (const token of tokens) {\r\n      switch (token.type) {\r\n        case TokenType.Static:\r\n          path += token.value;\r\n          break;\r\n        case TokenType.Param:\r\n          if (!params[token.value]) {\r\n            throw new Error('Param is invalid.');\r\n          }\r\n          path += params[token.value];\r\n          break;\r\n        case TokenType.WildCard:\r\n          let wildCard = params['*'];\r\n          if (wildCard instanceof Array) {\r\n            path += wildCard.join('/');\r\n          } else {\r\n            path += wildCard;\r\n          }\r\n          break;\r\n        case TokenType.Delimiter:\r\n          path += token.value;\r\n          break;\r\n      }\r\n    }\r\n    return path;\r\n  }\r\n\r\n  return {\r\n    get regexp() {\r\n      return regexp;\r\n    },\r\n    get keys() {\r\n      return keys;\r\n    },\r\n    compile,\r\n    parse,\r\n  };\r\n}\r\n\r\n/**\r\n * @description 依次使用pathname与pattern进行匹配，根据匹配分数取得分数最高结果\r\n */\r\nexport function matchPath<P = any>(\r\n  pathname: string,\r\n  pattern: string | string[],\r\n  option?: ParserOption,\r\n): Matched<P> | null {\r\n  const patterns = Array.isArray(pattern) ? [...pattern] : [pattern];\r\n  const matchedResults: Matched<P>[] = [];\r\n  for (const item of patterns) {\r\n    const parser = createPathParser(item, option);\r\n    const matched = parser.parse(pathname);\r\n    if (matched) {\r\n      matchedResults.push(matched);\r\n    }\r\n  }\r\n  return !matchedResults.length ? null : matchedResults.sort((a, b) => scoreCompare(a.score, b.score))[0];\r\n}\r\n\r\nexport function generatePath<P = any>(path: string, params: Params<P>) {\r\n  const parser = createPathParser(path);\r\n  return parser.compile(params);\r\n}","import { useContext } from 'react';\r\nimport RouterContext from './context';\r\nimport { Matched, matchPath, Params } from './matcher/parser';\r\nimport { History } from '../history/types';\r\nimport { Location } from './index';\r\n\r\nfunction useHistory<S>(): History<S>;\r\nfunction useHistory() {\r\n  return useContext(RouterContext).history;\r\n}\r\n\r\nfunction useLocation<S>(): Location<S>;\r\nfunction useLocation() {\r\n  return useContext(RouterContext).location;\r\n}\r\n\r\nfunction useParams<P>(): Params<P> | {};\r\nfunction useParams() {\r\n  const match = useContext(RouterContext).match;\r\n  return match ? match.params : {};\r\n}\r\n\r\nfunction useRouteMatch<P>(path?: string): Matched<P> | null;\r\nfunction useRouteMatch(path?: string) {\r\n  const pathname = useLocation().pathname;\r\n  const match = useContext(RouterContext).match;\r\n  if (path) {\r\n    return matchPath(pathname, path);\r\n  }\r\n  return match;\r\n}\r\n\r\nexport { useHistory, useLocation, useParams, useRouteMatch };\r\n","import * as React from 'react';\r\nimport { History, Location } from './index';\r\nimport { Matched, matchPath } from './matcher/parser';\r\nimport { useContext, Children, createElement } from 'react';\r\nimport RouterContext from './context';\r\nimport { GetURLParams } from './matcher/types';\r\n\r\nexport type RouteComponentProps<P extends Record<string, any> = {}, S = unknown> = RouteChildrenProps<P, S>;\r\n\r\nexport type RouteChildrenProps<P extends Record<string, any> = {}, S = unknown> = {\r\n  history: History<S>;\r\n  location: Location<S>;\r\n  match: Matched<P> | null\r\n}\r\n\r\nexport type RouteProps<P extends Record<string, any> = {}, Path extends string = string> = {\r\n  location?: Location;\r\n  component?: React.ComponentType<RouteComponentProps<P>> | React.ComponentType<any> | undefined;\r\n  children?: ((props: RouteChildrenProps<P>) => React.ReactNode) | React.ReactNode;\r\n  render?: (props: RouteComponentProps<P>) => React.ReactNode;\r\n  path?: Path | Path[];\r\n  exact?: boolean;\r\n  sensitive?: boolean;\r\n  strict?: boolean;\r\n  computed?: Matched<P>;\r\n};\r\n\r\nfunction Route<Path extends string, P extends Record<string, any> = GetURLParams<Path>>(props: RouteProps<P, Path>) {\r\n  const context = useContext(RouterContext);\r\n\r\n  const { computed, location, path } = props;\r\n  let { children, component, render } = props;\r\n  let match: Matched<P> | null;\r\n\r\n  const routeLocation = location || context.location;\r\n  if (computed) {\r\n    match = computed;\r\n  } else if (path) {\r\n    match = matchPath<P>(routeLocation.pathname, path);\r\n  } else {\r\n    match = context.match;\r\n  }\r\n  const newProps = { ...context, location: routeLocation, match: match };\r\n\r\n  if (Array.isArray(children) && Children.count(children) === 0) {\r\n    children = null;\r\n  }\r\n\r\n  /**\r\n   * 按顺序获取需要渲染的组件\r\n   * 1.children\r\n   * 2.component\r\n   * 3.render\r\n   * 都没有匹配到返回Null\r\n   */\r\n  const getChildren = (): React.ReactNode | null => {\r\n    // 如果 match 存在\r\n    if (newProps.match) {\r\n      if (children) {\r\n        if (typeof children === 'function') {\r\n          return children(newProps);\r\n        }\r\n        return children;\r\n      }\r\n\r\n      if (component) {\r\n        return createElement(component, newProps);\r\n      } else if (render) {\r\n        return render(newProps);\r\n      } else {\r\n        return null;\r\n      }\r\n    } else {\r\n      // match为null\r\n      if (typeof children === 'function') {\r\n        return children(newProps);\r\n      }\r\n      return null;\r\n    }\r\n  };\r\n\r\n  return <RouterContext.Provider value={newProps}>{getChildren()}</RouterContext.Provider>;\r\n}\r\n\r\nexport default Route;\r\n","import * as React from 'react';\r\nimport { useLayoutEffect, useMemo, useRef, useState } from 'react';\r\n\r\nimport { History, Location } from '../history/types';\r\n\r\nimport RouterContext, { RouterContextValue } from './context';\r\n\r\nexport type RouterProps = {\r\n  history: History;\r\n  children?: React.ReactNode;\r\n};\r\n\r\nfunction Router<P extends RouterProps>(props: P) {\r\n  const { history, children = null } = props;\r\n  const [location, setLocation] = useState(props.history.location);\r\n  const pendingLocation = useRef<Location | null>(null);\r\n\r\n  // 在Router加载时就监听history地址变化，以保证在始渲染时重定向能正确触发\r\n  let unListen: null | (() => void) = history.listen(arg => {\r\n    pendingLocation.current = arg.location;\r\n  });\r\n\r\n  // 模拟componentDidMount和componentWillUnmount\r\n  useLayoutEffect(() => {\r\n    if (unListen) {\r\n      unListen();\r\n    }\r\n    // 监听history中的位置变化\r\n    unListen = history.listen(arg => {\r\n      setLocation(arg.location);\r\n    });\r\n\r\n    if (pendingLocation.current) {\r\n      setLocation(pendingLocation.current);\r\n    }\r\n\r\n    return () => {\r\n      if (unListen) {\r\n        unListen();\r\n        unListen = null;\r\n        pendingLocation.current = null;\r\n      }\r\n    };\r\n  }, []);\r\n\r\n  const initContextValue: RouterContextValue = useMemo(\r\n    () => ({\r\n      history: history,\r\n      location: location,\r\n      match: { isExact: location.pathname === '/', params: {}, path: '/', score: [], url: '/' },\r\n    }),\r\n    [location],\r\n  );\r\n\r\n  return <RouterContext.Provider value={initContextValue} children={children} />;\r\n}\r\n\r\nexport default Router;\r\n","export default function _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n  return target;\n}","import { useLayoutEffect, useRef } from 'react';\r\n\r\nexport type LifeCycleProps = {\r\n  onMount?: () => void;\r\n  onUpdate?: (prevProps?: LifeCycleProps) => void;\r\n  onUnmount?: () => void;\r\n  data?: any;\r\n};\r\n\r\nexport function LifeCycle(props: LifeCycleProps) {\r\n  // 使用ref保存上一次的props，防止重新渲染\r\n  const prevProps = useRef<LifeCycleProps | null>(null);\r\n  const isMount = useRef(false);\r\n\r\n  const { onMount, onUpdate, onUnmount } = props;\r\n\r\n  useLayoutEffect(() => {\r\n    // 首次挂载 模拟componentDidMount\r\n    if (!isMount.current) {\r\n      isMount.current = true;\r\n      if (onMount) {\r\n        onMount();\r\n      }\r\n    } else {\r\n      // 不是首次渲染 模拟componentDidUpdate\r\n      if (onUpdate) {\r\n        prevProps.current ? onUpdate(prevProps.current) : onUpdate();\r\n      }\r\n    }\r\n    prevProps.current = props;\r\n  });\r\n\r\n  // 模拟componentWillUnmount\r\n  useLayoutEffect(() => {\r\n    return () => {\r\n      if (onUnmount) {\r\n        onUnmount();\r\n      }\r\n    };\r\n  }, []);\r\n\r\n  return null;\r\n}\r\n","import * as React from 'react';\r\nimport { useContext } from 'react';\r\nimport RouterContext from './context';\r\nimport { LifeCycle, LifeCycleProps } from './lifeCycleHook';\r\nimport { Matched, createPathParser } from './matcher/parser';\r\nimport { addHeadSlash, isLocationEqual, parsePath } from '../history/utils';\r\nimport { Location } from './index';\r\n\r\nexport type RedirectProps = {\r\n  to: string | Partial<Location>;\r\n  push?: boolean;\r\n  path?: string;\r\n  from?: string;\r\n  exact?: boolean;\r\n  strict?: boolean;\r\n\r\n  // 由Switch计算得到\r\n  readonly computed?: Matched | null;\r\n};\r\n\r\nfunction Redirect<P extends RedirectProps>(props: P) {\r\n  const { to, push = false, computed } = props;\r\n\r\n  const context = useContext(RouterContext);\r\n  const { history } = context;\r\n\r\n  const calcLocation = (): Partial<Location> => {\r\n    if (computed) {\r\n      if (typeof to === 'string') {\r\n        const parser = createPathParser(to);\r\n        const target = parser.compile(computed.params);\r\n        return parsePath(target);\r\n      } else {\r\n        const pathname = to.pathname ? addHeadSlash(to.pathname) : '/';\r\n        const parser = createPathParser(pathname);\r\n        const target = parser.compile(computed.params);\r\n        return { ...to, pathname: target };\r\n      }\r\n    }\r\n    return typeof to === 'string' ? parsePath(to) : to;\r\n  };\r\n\r\n  const navigate = push ? history.push : history.replace;\r\n  const { state, ...path } = calcLocation();\r\n\r\n  const onMountFunc = () => {\r\n    navigate(path, state);\r\n  };\r\n\r\n  const onUpdateFunc = (prevProps?: LifeCycleProps) => {\r\n    // 如果当前页面与重定向前页面不一致，执行跳转\r\n    const prevPath = prevProps?.data as Location;\r\n    if (!isLocationEqual(prevPath, path)) {\r\n      navigate(path, state);\r\n    }\r\n  };\r\n\r\n  return <LifeCycle onMount={onMountFunc} onUpdate={onUpdateFunc} data={path} />;\r\n}\r\n\r\nexport default Redirect;\r\n","import * as React from 'react';\r\nimport { useContext, Children, isValidElement, cloneElement } from 'react';\r\n\r\nimport { Location } from './index';\r\nimport RouterContext from './context';\r\nimport { Matched, matchPath } from './matcher/parser';\r\nimport Route, { RouteProps } from './Route';\r\nimport Redirect, { RedirectProps } from './Redirect';\r\n\r\nexport type SwitchProps = {\r\n  location?: Location;\r\n  children?: React.ReactNode;\r\n};\r\n\r\nfunction Switch<P extends SwitchProps>(props: P): React.ReactElement | null {\r\n  const context = useContext(RouterContext);\r\n  const location = props.location || context.location;\r\n\r\n  let element: React.ReactElement | null = null;\r\n  let match: Matched | null = null;\r\n\r\n  // 使用forEach不会给React.ReactNode增加key属性,防止重新渲染\r\n  Children.forEach(props.children, node => {\r\n    if (match === null && isValidElement(node)) {\r\n      element = node;\r\n\r\n      let strict: boolean | undefined;\r\n      let sensitive: boolean | undefined;\r\n      let path: string | string[] | undefined;\r\n      let from: string | undefined;\r\n\r\n      // node可能是Route和Redirect\r\n      if (node.type === Route) {\r\n        const props = node.props as RouteProps;\r\n        strict = props.strict;\r\n        sensitive = props.sensitive;\r\n        path = props.path;\r\n      } else if (node.type === Redirect) {\r\n        const props = node.props as RedirectProps;\r\n        path = props.path;\r\n        strict = props.strict;\r\n        from = props.from;\r\n      }\r\n\r\n      const exact = node.props.exact;\r\n      const target = path || from;\r\n\r\n      // 更新匹配状态，一旦匹配到停止遍历\r\n      if (target) {\r\n        match = matchPath(location.pathname, target, {\r\n          strictMode: strict,\r\n          caseSensitive: sensitive,\r\n          exact: exact,\r\n        });\r\n      } else {\r\n        match = context.match;\r\n      }\r\n    }\r\n  });\r\n\r\n  if (match && element) {\r\n    // 使用cloneElement复制已有组件并更新其Props\r\n    return cloneElement(element, { location: location, computed: match });\r\n  }\r\n  return null;\r\n}\r\n\r\nexport default Switch;\r\n","import * as React from 'react';\r\nimport { useContext } from 'react';\r\nimport { LifeCycle, LifeCycleProps } from './lifeCycleHook';\r\nimport { Location } from './index';\r\nimport { Action } from '../history/types';\r\nimport RouterContext from './context';\r\n\r\ntype PromptProps = {\r\n  message?: string | ((location: Partial<Location>, action: Action) => void);\r\n  when?: boolean | ((location: Partial<Location>) => boolean);\r\n};\r\n\r\nfunction Prompt<P extends PromptProps>(props: P) {\r\n  const context = useContext(RouterContext);\r\n\r\n  const { message, when = true } = props;\r\n\r\n  if ((typeof when === 'function' && when(context.location) === false) || !when) {\r\n    return null;\r\n  }\r\n\r\n  const navigate = context.history.block;\r\n\r\n  let release: (() => void) | null = null;\r\n\r\n  const onMountFunc = () => {\r\n    release = message ? navigate(message) : null;\r\n  };\r\n\r\n  const onUpdateFunc = (prevProps?: LifeCycleProps) => {\r\n    if (prevProps && prevProps.data !== message) {\r\n      if (release) {\r\n        release();\r\n      }\r\n      release = message ? navigate(message) : null;\r\n    }\r\n  };\r\n\r\n  const onUnmountFunc = () => {\r\n    if (release) {\r\n      release();\r\n    }\r\n    release = null;\r\n  };\r\n\r\n  return <LifeCycle onMount={onMountFunc} onUpdate={onUpdateFunc} onUnmount={onUnmountFunc} data={message} />;\r\n}\r\n\r\nexport default Prompt;\r\n","import * as React from 'react';\r\nimport { useContext } from 'react';\r\nimport RouterContext from './context';\r\n\r\nfunction withRouter<C extends React.ComponentType>(Component: C) {\r\n\r\n  function ComponentWithRouterProp(props: any) {\r\n    const { history, location, match } = useContext(RouterContext);\r\n    const routeProps = { history: history, location: location, match: match };\r\n\r\n    return <Component {...props} {...routeProps} />;\r\n  }\r\n\r\n  return ComponentWithRouterProp;\r\n}\r\n\r\nexport default withRouter;","import * as React from 'react';\r\nimport { useRef } from 'react';\r\nimport { History } from '../history/types';\r\nimport { BaseRouterProps } from './BrowserRouter';\r\nimport { createHashHistory, urlHashType } from '../history/hashHistory';\r\nimport Router from './Router';\r\n\r\nexport type HashRouterProps = BaseRouterProps & {\r\n  hashType: urlHashType;\r\n};\r\n\r\nfunction HashRouter<P extends Partial<HashRouterProps>>(props: P) {\r\n  let historyRef = useRef<History>();\r\n  if (historyRef.current === null || historyRef.current === undefined) {\r\n    historyRef.current = createHashHistory({\r\n      basename: props.basename,\r\n      getUserConfirmation: props.getUserConfirmation,\r\n      hashType: props.hashType,\r\n    });\r\n  }\r\n\r\n  return <Router history={historyRef.current}>{props.children}</Router>;\r\n}\r\n\r\nexport default HashRouter;","import * as React from 'react';\r\nimport { useRef, ReactNode } from 'react';\r\nimport Router from './Router';\r\nimport { createBrowserHistory } from '../history/browerHistory';\r\nimport { ConfirmationFunc, History } from '../history/types';\r\n\r\nexport type BaseRouterProps = {\r\n  basename: string;\r\n  getUserConfirmation: ConfirmationFunc;\r\n  children?: ReactNode;\r\n};\r\n\r\nexport type BrowserRouterProps = BaseRouterProps & {\r\n  forceRefresh: boolean;\r\n};\r\n\r\nfunction BrowserRouter<P extends Partial<BrowserRouterProps>>(props: P) {\r\n  // 使用Ref持有History对象，防止重复渲染\r\n  let historyRef = useRef<History>();\r\n\r\n  if (historyRef.current === null || historyRef.current === undefined) {\r\n    historyRef.current = createBrowserHistory({\r\n      basename: props.basename,\r\n      forceRefresh: props.forceRefresh,\r\n      getUserConfirmation: props.getUserConfirmation,\r\n    });\r\n  }\r\n\r\n  return <Router history={historyRef.current}>{props.children}</Router>;\r\n}\r\n\r\nexport default BrowserRouter;","import * as React from 'react';\r\nimport { useContext } from 'react';\r\nimport RouterContext from './context';\r\nimport { Location } from './index';\r\nimport { createPath, parsePath } from '../history/utils';\r\nimport { Path } from '../history/types';\r\n\r\nexport type LinkProps = {\r\n  component?: React.ComponentType<any>;\r\n  to: Partial<Location> | string | ((location: Location) => string | Partial<Location>);\r\n  replace?: boolean;\r\n  tag?: string;\r\n  /**\r\n   * @deprecated\r\n   * React16以后不再需要该属性\r\n   **/\r\n  innerRef?: React.Ref<HTMLAnchorElement>;\r\n} & React.AnchorHTMLAttributes<HTMLAnchorElement>;\r\n\r\nconst isModifiedEvent = (event: React.MouseEvent) => {\r\n  return event.metaKey || event.altKey || event.ctrlKey || event.shiftKey;\r\n};\r\n\r\nconst checkTarget = (target?: React.HTMLAttributeAnchorTarget) => {\r\n  return !target || target === '_self';\r\n};\r\n\r\n\r\nfunction Link<P extends LinkProps>(props: P) {\r\n  const { to, replace, component, onClick, target, ...other } = props;\r\n\r\n  const tag = props.tag || 'a';\r\n\r\n  const context = useContext(RouterContext);\r\n  const history = context.history;\r\n\r\n  let location = typeof to === 'function' ? to(context.location) : to;\r\n\r\n  let state: any;\r\n  let path: Partial<Path>;\r\n  if (typeof location === 'string') {\r\n    path = parsePath(location);\r\n  } else {\r\n    const { pathname, hash, search } = location;\r\n    path = { pathname, hash, search };\r\n    state = location.state;\r\n  }\r\n  const href = history.createHref(path);\r\n\r\n  const linkClickEvent = (event: React.MouseEvent<HTMLAnchorElement>) => {\r\n    try {\r\n      if (onClick) {\r\n        onClick(event);\r\n      }\r\n    } catch (e) {\r\n      event.preventDefault();\r\n      throw e;\r\n    }\r\n\r\n    if (!event.defaultPrevented && event.button === 0 && checkTarget(target) && !isModifiedEvent(event)) {\r\n      // 不是相同的路径执行push操作，是相同的路径执行replace\r\n      const isSamePath = createPath(context.location) === createPath(path);\r\n      const navigate = replace || isSamePath ? history.replace : history.push;\r\n      event.preventDefault();\r\n      navigate(path, state);\r\n    }\r\n  };\r\n\r\n  const linkProps = { href: href, onClick: linkClickEvent, ...other };\r\n  return React.createElement(tag, linkProps);\r\n}\r\n\r\nexport default Link;","import * as React from 'react';\r\nimport { useContext } from 'react';\r\nimport type { LinkProps } from './Link';\r\nimport Link from './Link';\r\nimport { Location, matchPath } from './index';\r\nimport { Matched } from './matcher/parser';\r\nimport Context from './context';\r\nimport { parsePath } from '../history/utils';\r\nimport { escapeStr } from './matcher/utils';\r\n\r\ntype NavLinkProps = {\r\n  to: Partial<Location> | string | ((location: Location) => string | Partial<Location>);\r\n  isActive?: (match: Matched | null, location: Location) => boolean;\r\n  // compat react-router NavLink props type\r\n  [key: string]: any;\r\n} & LinkProps;\r\n\r\ntype Page = 'page';\r\n\r\nfunction NavLink<P extends NavLinkProps>(props: P) {\r\n  const { to, isActive, ...rest } = props;\r\n  const context = useContext(Context);\r\n\r\n  const toLocation = typeof to === 'function' ? to(context.location) : to;\r\n\r\n  const { pathname: path } = typeof toLocation === 'string' ? parsePath(toLocation) : toLocation;\r\n  // 把正则表达式的特殊符号加两个反斜杠进行转义\r\n  const escapedPath = path ? escapeStr(path) : '';\r\n  const match = escapedPath ? matchPath(context.location.pathname, escapedPath) : null;\r\n\r\n  const isLinkActive = match && isActive ? isActive(match, context.location) : false;\r\n\r\n  const page: Page = 'page';\r\n  const otherProps = {\r\n    'aria-current': isLinkActive ? page : false,\r\n    ...rest,\r\n  };\r\n\r\n  return <Link to={to} {...otherProps} />;\r\n}\r\n\r\nexport default NavLink;\r\n"],"names":["isBrowser","window","document","createElement","getDefaultConfirmation","message","callBack","confirm","isSupportHistory","history","isSupportsPopState","navigator","userAgent","indexOf","Action","EventType","_extends","Object","assign","bind","target","i","arguments","length","source","key","prototype","hasOwnProperty","call","apply","createPath","path","search","hash","pathname","startsWith","parsePath","url","parsedPath","hashIdx","substring","searchIdx","createLocation","current","to","state","urlObj","getRandKey","genRandomKey","location","isLocationEqual","p1","p2","addHeadSlash","stripHeadSlash","normalizeSlash","tempPath","hasBasename","prefix","toLowerCase","includes","charAt","stripBasename","createMemoryRecord","initVal","fn","visitedRecord","getDelta","form","toIdx","lastIndexOf","fromIdx","addRecord","newRecord","action","curVal","NewVal","push","prevIdx","newVisitedRecord","slice","replace","end","Math","random","toString","_classCallCheck","instance","Constructor","TypeError","_typeof","obj","Symbol","iterator","constructor","_toPrimitive","input","hint","prim","toPrimitive","undefined","res","String","Number","_toPropertyKey","arg","_defineProperties","props","descriptor","enumerable","configurable","writable","defineProperty","toPropertyKey","_createClass","protoProps","staticProps","TransitionManager","prompt","listeners","value","setPrompt","_this","addListener","func","_this2","isActive","listener","args","filter","item","notifyListeners","_iterator","_createForOfIteratorHelper","_step","s","n","done","err","e","f","confirmJumpTo","userConfirmationFunc","result","warning","condition","console","warn","getBaseHistory","transitionManager","setListener","browserHistory","go","step","goBack","goForward","listen","cancel","isBlocked","block","unblock","getUpdateStateFunc","historyProps","nextState","createBrowserHistory","options","supportHistory","isSupportPopState","_options$forceRefresh","forceRefresh","_options$getUserConfi","getUserConfirmation","basename","initLocation","getLocation","getHistoryState","recordOperator","l","_getBaseHistory","pop","createHref","updateState","historyState","_window$location","_ref","forceJump","handlePopState","callback","isJump","revertPopState","popStateListener","event","hashChangeListener","listenerCount","count","addEventListener","PopState","HashChange","removeEventListener","delta","href","pushState","replaceState","stripHash","idx","getHashContent","createHashHistory","option","_option$hashType","hashType","_option$getUserConfir","pathDecoder","pathEncoder","hashPath","memRecords","tag","querySelector","base","getAttribute","forceNextPop","ignorePath","encodedPath","handleHashChange","prevLocation","createNamedContext","name","defaultValue","context","createContext","displayName","RouterContext","TokenType","cleanPath","scoreCompare","score1","score2","score1Length","score2Length","min","escapeStr","str","validChar","lexer","tokens","urlPath","Error","getLiteral","test","skipChar","curChar","prevChar","type","Delimiter","Param","WildCard","Static","LBracket","RBracket","Pattern","MatchScore","defaultOption","caseSensitive","strictMode","exact","REGEX_CHARS_RE","BASE_PARAM_PATTERN","DefaultDelimiter","createPathParser","_option$caseSensitive","_option$strictMode","_option$exact","pattern","keys","scores","onlyHasWildCard","tokenCount","lastToken","tokenIdx","token","nextToken","static","paramRegexp","param","wildcard","placeholder","isWildCard","flag","regexp","RegExp","parse","reMatch","match","matchedPath","params","parseScore","Array","from","split","isArray","_params$","splice","concat","fill","isExact","score","compile","wildCard","join","matchPath","patterns","matchedResults","_iterator2","_step2","parser","matched","sort","a","b","generatePath","useHistory","useContext","useLocation","useParams","useRouteMatch","Route","computed","children","component","render","routeLocation","newProps","Children","getChildren","React","Provider","Router","_props$children","_useState","useState","setLocation","pendingLocation","useRef","unListen","useLayoutEffect","initContextValue","useMemo","_objectWithoutPropertiesLoose","excluded","sourceKeys","LifeCycle","prevProps","isMount","onMount","onUpdate","onUnmount","Redirect","_props$push","calcLocation","navigate","_calcLocation","_excluded","onMountFunc","onUpdateFunc","prevPath","data","Switch","element","forEach","node","isValidElement","strict","sensitive","cloneElement","Prompt","_props$when","when","release","onUnmountFunc","withRouter","Component","ComponentWithRouterProp","_useContext","routeProps","HashRouter","historyRef","BrowserRouter","isModifiedEvent","metaKey","altKey","ctrlKey","shiftKey","checkTarget","Link","onClick","other","linkClickEvent","preventDefault","defaultPrevented","button","isSamePath","linkProps","NavLink","rest","Context","toLocation","escapedPath","isLinkActive","page","otherProps"],"mappings":"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"}
diff --git a/packages/horizon-router/src/configs/package.json b/packages/horizon-router/src/configs/package.json
new file mode 100644
index 00000000..0c8f9fe5
--- /dev/null
+++ b/packages/horizon-router/src/configs/package.json
@@ -0,0 +1,9 @@
+{
+  "module": "./esm/connectRouter.js",
+  "main": "./cjs/connectRouter.js",
+  "types": "./@types/router/index2.d.ts",
+  "peerDependencies": {
+    "react-redux": "^6.0.0 || ^7.1.0",
+    "redux": "^3.6.0 || ^4.0.0"
+  }
+}
diff --git a/packages/horizon-router/src/connect-router/actions.ts b/packages/horizon-router/src/connect-router/actions.ts
new file mode 100644
index 00000000..81a7396b
--- /dev/null
+++ b/packages/horizon-router/src/connect-router/actions.ts
@@ -0,0 +1,51 @@
+import { Action, Path } from '../history/types';
+
+type Location = Partial<Path>
+
+// 定义位置变化和history方法调用的Action type
+export enum ActionName {
+  LOCATION_CHANGE = '$horizon-router/LOCATION_CHANGE',
+  CALL_HISTORY_METHOD = '$horizon-router/CALL_HISTORY_METHOD'
+}
+
+// 定义Action的两种数据类型
+export type ActionMessage = {
+  type: ActionName.LOCATION_CHANGE
+  payload: {
+    location: Location,
+    action: Action
+    isFirstRendering: boolean
+  }
+} | {
+  type: ActionName.CALL_HISTORY_METHOD
+  payload: {
+    method: string,
+    args: any
+  }
+}
+
+
+export const onLocationChanged = (location: Location, action: Action, isFirstRendering = false): ActionMessage => {
+  return {
+    type: ActionName.LOCATION_CHANGE,
+    payload: {
+      location,
+      action,
+      isFirstRendering,
+    },
+  };
+};
+
+const updateLocation = (method: string): (...args: any) => ActionMessage => {
+  return (...args: any) => ({
+    type: ActionName.CALL_HISTORY_METHOD,
+    payload: {
+      method,
+      args,
+    },
+  });
+};
+
+export const push = updateLocation('push');
+export const replace = updateLocation('replace');
+export const go = updateLocation('go');
\ No newline at end of file
diff --git a/packages/horizon-router/src/connect-router/connectedRouter.tsx b/packages/horizon-router/src/connect-router/connectedRouter.tsx
new file mode 100644
index 00000000..83a47d9f
--- /dev/null
+++ b/packages/horizon-router/src/connect-router/connectedRouter.tsx
@@ -0,0 +1,128 @@
+import * as React from 'react';
+import { useLayoutEffect } from 'react';
+import { connect, ReactReduxContext } from 'react-redux';
+import { Store } from 'redux';
+import { reduxAdapter } from '@cloudsop/horizon';
+import { History, Location, Router } from '../router';
+import { Action, DefaultStateType, Navigation } from '../history/types';
+import { ActionMessage, onLocationChanged } from './actions';
+import stateReader from './reduxUtils';
+
+type StoreType = 'HorizonXCompat' | 'Redux';
+
+type ConnectedRouter<S> = {
+  store: Store;
+  history: History<S>;
+  basename: string;
+  children?: (() => React.ReactNode) | React.ReactNode;
+  onLocationChanged: (location: Location<S>, action: Action, isFirstRendering: boolean) => ActionMessage;
+  noInitialPop: boolean;
+  omitRouter: boolean;
+  storeType: StoreType;
+};
+
+const { connect: hConnect } = reduxAdapter;
+
+function ConnectedRouterWithoutMemo<S>(props: ConnectedRouter<S>) {
+  const { store, history, onLocationChanged, omitRouter, children, storeType } = props;
+  const { getLocation } = stateReader(storeType);
+
+  // 监听store变化
+  const unsubscribe = store.subscribe(() => {
+    // 获取redux State中的location信息
+    const {
+      pathname: pathnameInStore,
+      search: searchInStore,
+      hash: hashInStore,
+      state: stateInStore,
+    } = getLocation<S>(store.getState());
+
+    // 获取当前history对象中的location信息
+    const {
+      pathname: pathnameInHistory,
+      search: searchInHistory,
+      hash: hashInHistory,
+      state: stateInHistory,
+    } = history.location;
+
+    // 两个location不一致 执行跳转
+    if (
+      history.action === 'PUSH' &&
+      (pathnameInHistory !== pathnameInStore ||
+        searchInHistory !== searchInStore ||
+        hashInHistory !== hashInStore ||
+        stateInHistory !== stateInStore)
+    ) {
+      history.push(
+        {
+          pathname: pathnameInStore,
+          search: searchInStore,
+          hash: hashInStore,
+        },
+        stateInStore,
+      );
+    }
+  });
+
+  const handleLocationChange = (args: Navigation<S>, isFirstRendering: boolean = false) => {
+    const { location, action } = args;
+    onLocationChanged(location, action, isFirstRendering);
+  };
+
+  // 监听history更新
+  const unListen = () => history.listen(handleLocationChange);
+
+  useLayoutEffect(() => {
+    return () => {
+      unListen();
+      unsubscribe();
+    };
+  }, []);
+
+  if (!props.noInitialPop) {
+    // 传递初始时位置信息，isFirstRendering设为true防止重复渲染
+    handleLocationChange({ location: history.location, action: history.action }, true);
+  }
+
+  if (omitRouter) {
+    return <>{children}</>;
+  }
+  let childrenNode: React.ReactNode;
+  if (typeof children === 'function') {
+    childrenNode = children();
+  } else {
+    childrenNode = children;
+  }
+
+  return <Router history={history}>{childrenNode}</Router>;
+}
+
+function getConnectedRouter<S = DefaultStateType>(type: StoreType) {
+  const mapDispatchToProps = (dispatch: any) => ({
+    onLocationChanged: (location: Location, action: Action, isFirstRendering: boolean) =>
+      dispatch(onLocationChanged(location, action, isFirstRendering)),
+  });
+  const ConnectedRouter = React.memo(ConnectedRouterWithoutMemo<S>);
+
+  const ConnectedRouterWithContext = (props: any) => {
+    const Context = props.context || ReactReduxContext;
+
+    return (
+      <Context.Consumer>
+        {({ store }: any) => <ConnectedRouter store={store} storeType={type} {...props} />}
+      </Context.Consumer>
+    );
+  };
+
+  // 针对不同的Store类型，使用对应的connect函数
+  if (type === 'HorizonXCompat') {
+    return hConnect(null, mapDispatchToProps)(ConnectedRouterWithContext);
+  }
+  if (type === 'Redux') {
+    return connect(null, mapDispatchToProps)(ConnectedRouterWithContext);
+  } else {
+    throw new Error('Invalid store type');
+  }
+}
+
+export { getConnectedRouter };
diff --git a/packages/horizon-router/src/connect-router/dispatch.ts b/packages/horizon-router/src/connect-router/dispatch.ts
new file mode 100644
index 00000000..042609fb
--- /dev/null
+++ b/packages/horizon-router/src/connect-router/dispatch.ts
@@ -0,0 +1,19 @@
+import { ActionMessage, ActionName } from './actions';
+import { History } from '../history/types';
+
+// 定义connect-router对应的redux dispatch函数
+export function routerMiddleware(history: History) {
+  return function(_: any) {
+    return function(next: any) {
+      return function(action: ActionMessage) {
+        if (action.type !== ActionName.CALL_HISTORY_METHOD) {
+          return next(action);
+        }
+        const { payload: { method, args } } = action;
+        if (method in history) {
+          (history as any)[method](...args);
+        }
+      };
+    };
+  };
+}
diff --git a/packages/horizon-router/src/connect-router/index.ts b/packages/horizon-router/src/connect-router/index.ts
new file mode 100644
index 00000000..52f64271
--- /dev/null
+++ b/packages/horizon-router/src/connect-router/index.ts
@@ -0,0 +1,5 @@
+import { createConnectRouter } from './reducer';
+
+export { getConnectedRouter } from './connectedRouter';
+export const connectRouter = createConnectRouter();
+export { routerMiddleware } from './dispatch';
diff --git a/packages/horizon-router/src/connect-router/reducer.ts b/packages/horizon-router/src/connect-router/reducer.ts
new file mode 100644
index 00000000..7f50c8e7
--- /dev/null
+++ b/packages/horizon-router/src/connect-router/reducer.ts
@@ -0,0 +1,62 @@
+import { ActionName } from './actions';
+import { Action, History } from '../history/types';
+import { Location } from '../router';
+
+type LocationWithQuery = Partial<Location> & { query?: Record<string, any> };
+
+// 解析location对象，将其中的query参数解析并注入
+function injectQueryParams(location?: LocationWithQuery): LocationWithQuery {
+  if (location && location.query) {
+    return location;
+  }
+
+  const queryString = location && location.search;
+
+  if (!queryString) {
+    return {
+      ...location,
+      query: {},
+    };
+  }
+  const queryObject: Record<string, any> = {};
+
+  const params = new URLSearchParams(queryString);
+  params.forEach((value, key) => (queryObject[key] = value));
+
+  return {
+    ...location,
+    query: queryObject,
+  };
+}
+
+type InitRouterState = {
+  location: LocationWithQuery;
+  action: Action;
+};
+
+type Payload = {
+  type?: ActionName;
+  payload?: any;
+};
+
+export function createConnectRouter() {
+  // 初始化redux State
+  return (history: History) => {
+    const initRouterState = {
+      location: injectQueryParams(history.location),
+      action: history.action,
+    };
+
+    // 定义connect-router对应的redux reducer函数
+    return (state: InitRouterState = initRouterState, { type, payload }: Payload = {}): any => {
+      if (type === ActionName.LOCATION_CHANGE) {
+        const { location, action, isFirstRendering } = payload;
+        if (isFirstRendering) {
+          return state;
+        }
+        return { ...state, location: injectQueryParams(location), action: action };
+      }
+      return state;
+    };
+  };
+}
diff --git a/packages/horizon-router/src/connect-router/reduxUtils.ts b/packages/horizon-router/src/connect-router/reduxUtils.ts
new file mode 100644
index 00000000..80c23da4
--- /dev/null
+++ b/packages/horizon-router/src/connect-router/reduxUtils.ts
@@ -0,0 +1,48 @@
+import { Location } from '../router';
+import { Action } from '../history/types';
+
+// 获取redux state中的值
+export function getIn(state: Record<string, any>, path: string[]): any {
+  if (!state) {
+    return state;
+  }
+  const length = path.length;
+  if (!length) {
+    return undefined;
+  }
+  let res = state;
+  for (let i = 0; i < length && !!res; ++i) {
+    res = res[path[i]];
+  }
+  return res;
+}
+
+// 从store的state中获取Router、Location、Action、Hash等信息
+const stateReader = (storeType: string) => {
+  const isRouter = (value: unknown) => {
+    return value !== null && typeof value === 'object' && !!getIn(value, ['location']) && !!getIn(value, ['action']);
+  };
+
+  const getRouter = (state: any) => {
+    const router = getIn(state, ['router']);
+    if (!isRouter(router)) {
+      throw new Error(`Could not find router reducer in ${storeType} store, it must be mounted under "router"`);
+    }
+    return router!;
+  };
+
+  const getLocation = <S>(state: any): Partial<Location<S>> => getIn(getRouter(state), ['location']);
+  const getAction = (state: any): Action => getIn(getRouter(state), ['action']);
+  const getSearch = (state: any): string => getIn(getRouter(state), ['location', 'search']);
+  const getHash = (state: any): string => getIn(getRouter(state), ['location', 'hash']);
+
+  return {
+    getHash,
+    getAction,
+    getSearch,
+    getRouter,
+    getLocation,
+  };
+};
+
+export default stateReader
\ No newline at end of file
diff --git a/packages/horizon-router/src/history/__tests__/history.test.ts b/packages/horizon-router/src/history/__tests__/history.test.ts
new file mode 100644
index 00000000..0653b6f7
--- /dev/null
+++ b/packages/horizon-router/src/history/__tests__/history.test.ts
@@ -0,0 +1,61 @@
+import { createPath } from '../utils';
+
+describe('createPath', () => {
+  describe('given only a pathname', () => {
+    it('returns the pathname unchanged', () => {
+      let path = createPath({ pathname: 'https://google.com' });
+      expect(path).toBe('https://google.com');
+    });
+  });
+
+  describe('given a pathname and a search param', () => {
+    it('returns the constructed pathname', () => {
+      let path = createPath({
+        pathname: 'https://google.com',
+        search: '?something=cool',
+      });
+      expect(path).toBe('https://google.com?something=cool');
+    });
+  });
+
+  describe('given a pathname and a search param without ?', () => {
+    it('returns the constructed pathname', () => {
+      let path = createPath({
+        pathname: 'https://google.com',
+        search: 'something=cool',
+      });
+      expect(path).toBe('https://google.com?something=cool');
+    });
+  });
+
+  describe('given a pathname and a hash param', () => {
+    it('returns the constructed pathname', () => {
+      let path = createPath({
+        pathname: 'https://google.com',
+        hash: '#section-1',
+      });
+      expect(path).toBe('https://google.com#section-1');
+    });
+  });
+
+  describe('given a pathname and a hash param without #', () => {
+    it('returns the constructed pathname', () => {
+      let path = createPath({
+        pathname: 'https://google.com',
+        hash: 'section-1',
+      });
+      expect(path).toBe('https://google.com#section-1');
+    });
+  });
+
+  describe('given a full location object', () => {
+    it('returns the constructed pathname', () => {
+      let path = createPath({
+        pathname: 'https://google.com',
+        search: 'something=cool',
+        hash: '#section-1',
+      });
+      expect(path).toBe('https://google.com?something=cool#section-1');
+    });
+  });
+});
diff --git a/packages/horizon-router/src/history/baseHistory.ts b/packages/horizon-router/src/history/baseHistory.ts
new file mode 100644
index 00000000..e534f3ce
--- /dev/null
+++ b/packages/horizon-router/src/history/baseHistory.ts
@@ -0,0 +1,60 @@
+import { HistoryProps, Listener, Navigation, Prompt } from './types';
+import transitionManager from './transitionManager';
+
+// 抽取BrowserHistory和HashHistory中相同的方法
+export function getBaseHistory<S>(
+  transitionManager: transitionManager<S>,
+  setListener: (delta: number) => void,
+  browserHistory: History,
+) {
+  function go(step: number) {
+    browserHistory.go(step);
+  }
+
+  function goBack() {
+    browserHistory.go(-1);
+  }
+
+  function goForward() {
+    browserHistory.go(1);
+  }
+
+  function listen(listener: Listener<S>): () => void {
+    const cancel = transitionManager.addListener(listener);
+    setListener(1);
+    return () => {
+      setListener(-1);
+      cancel();
+    };
+  }
+
+  let isBlocked = false;
+
+  function block(prompt: Prompt<S> = false): () => void {
+    const unblock = transitionManager.setPrompt(prompt);
+    if (!isBlocked) {
+      setListener(1);
+      isBlocked = true;
+    }
+    return () => {
+      if (isBlocked) {
+        isBlocked = false;
+        setListener(-1);
+      }
+      unblock();
+    };
+  }
+
+  function getUpdateStateFunc(historyProps: HistoryProps<S>) {
+    return function (nextState: Navigation<S> | undefined) {
+      if (nextState) {
+        Object.assign(historyProps, nextState);
+      }
+      historyProps.length = browserHistory.length;
+      const args = { location: historyProps.location, action: historyProps.action };
+      transitionManager.notifyListeners(args);
+    };
+  }
+
+  return { go, goBack, goForward, listen, block, getUpdateStateFunc };
+}
diff --git a/packages/horizon-router/src/history/browerHistory.ts b/packages/horizon-router/src/history/browerHistory.ts
new file mode 100644
index 00000000..0c8abb06
--- /dev/null
+++ b/packages/horizon-router/src/history/browerHistory.ts
@@ -0,0 +1,179 @@
+import { getDefaultConfirmation, isSupportHistory, isSupportsPopState } from './dom';
+import { Action, BaseOption, DefaultStateType, EventType, History, HistoryState, Location, Path, To } from './types';
+import { normalizeSlash, createMemoryRecord, createPath, createLocation, stripBasename } from './utils';
+import TransitionManager from './transitionManager';
+
+import warning from './waring';
+import { getBaseHistory } from './baseHistory';
+
+export type BrowserHistoryOption = {
+  /**
+   * forceRefresh为True时跳转时会强制刷新页面
+   */
+  forceRefresh?: boolean;
+} & BaseOption;
+
+export function createBrowserHistory<S = DefaultStateType>(options: BrowserHistoryOption = {}): History<S> {
+  const supportHistory = isSupportHistory();
+  const isSupportPopState = isSupportsPopState();
+  const browserHistory = window.history;
+  const { forceRefresh = false, getUserConfirmation = getDefaultConfirmation } = options;
+
+  const basename = options.basename ? normalizeSlash(options.basename) : '';
+
+  const initLocation = getLocation(getHistoryState());
+
+  const recordOperator = createMemoryRecord<string, Location<S>>(initLocation, l => l.key);
+
+  const transitionManager = new TransitionManager<S>();
+
+  const { go, goBack, goForward, listen, block, getUpdateStateFunc } = getBaseHistory<S>(
+    transitionManager,
+    setListener,
+    browserHistory,
+  );
+
+  const history: History<S> = {
+    action: Action.pop,
+    length: browserHistory.length,
+    location: initLocation,
+    go,
+    goBack,
+    goForward,
+    listen,
+    block,
+    push,
+    replace,
+    createHref,
+  };
+
+  const updateState = getUpdateStateFunc(history);
+
+  function getHistoryState() {
+    return supportHistory ? window.history.state : {};
+  }
+
+  function getLocation(historyState: Partial<HistoryState<S>>) {
+    const { search, hash } = window.location;
+    const { key, state } = historyState || {};
+    let pathname = window.location.pathname;
+    pathname = basename ? stripBasename(pathname, basename) : pathname;
+
+    return createLocation<S>('', { pathname, search, hash }, state, key);
+  }
+
+  // 拦截页面POP事件后，防止返回到的页面被重复拦截
+  let forceJump = false;
+
+  function handlePopState(location: Location<S>) {
+    if (forceJump) {
+      forceJump = false;
+      updateState(undefined);
+    } else {
+      const action = Action.pop;
+
+      const callback = (isJump: boolean) => {
+        if (isJump) {
+          // 执行跳转行为
+          updateState({ action: action, location: location });
+        } else {
+          revertPopState(location, history.location);
+        }
+      };
+
+      transitionManager.confirmJumpTo(location, action, getUserConfirmation, callback);
+    }
+  }
+
+  function popStateListener(event: PopStateEvent) {
+    handlePopState(getLocation(event.state));
+  }
+
+  function hashChangeListener() {
+    const location = getLocation(getHistoryState());
+    handlePopState(location);
+  }
+
+  let listenerCount = 0;
+
+  function setListener(count: number) {
+    listenerCount += count;
+    if (listenerCount === 1 && count === 1) {
+      window.addEventListener(EventType.PopState, popStateListener);
+      if (!isSupportPopState) {
+        window.addEventListener(EventType.HashChange, hashChangeListener);
+      }
+    } else if (listenerCount === 0) {
+      window.removeEventListener(EventType.PopState, popStateListener);
+      if (!isSupportPopState) {
+        window.removeEventListener(EventType.HashChange, hashChangeListener);
+      }
+    }
+  }
+
+  // 取消页面跳转并恢复到跳转前的页面
+  function revertPopState(form: Location<S>, to: Location<S>) {
+    const delta = recordOperator.getDelta(to, form);
+    if (delta !== 0) {
+      go(delta);
+      forceJump = true;
+    }
+  }
+
+  function createHref(path: Partial<Path>) {
+    return basename + createPath(path);
+  }
+
+  function push(to: To, state?: S) {
+    const action = Action.push;
+    const location = createLocation<S>(history.location, to, state, undefined);
+
+    transitionManager.confirmJumpTo(location, action, getUserConfirmation, isJump => {
+      if (!isJump) {
+        return;
+      }
+      const href = createHref(location);
+      const { key, state } = location;
+
+      if (supportHistory) {
+        if (forceRefresh) {
+          window.location.href = href;
+        } else {
+          browserHistory.pushState({ key: key, state: state }, '', href);
+          recordOperator.addRecord(history.location, location, action);
+          updateState({ action, location });
+        }
+      } else {
+        warning(state !== undefined, 'Browser history cannot push state in browsers that do not support HTML5 history');
+        window.location.href = href;
+      }
+    });
+  }
+
+  function replace(to: To, state?: S) {
+    const action = Action.replace;
+    const location = createLocation<S>(history.location, to, state, undefined);
+
+    transitionManager.confirmJumpTo(location, action, getUserConfirmation, isJump => {
+      if (!isJump) {
+        return;
+      }
+      const href = createHref(location);
+      const { key, state } = location;
+      if (supportHistory) {
+        if (forceRefresh) {
+          window.location.replace(href);
+        } else {
+          browserHistory.replaceState({ key: key, state: state }, '', href);
+          recordOperator.addRecord(history.location, location, action);
+          updateState({ action, location });
+        }
+      } else {
+        warning(state !== undefined, 'Browser history cannot push state in browsers that do not support HTML5 history');
+        window.location.replace(href);
+      }
+    });
+  }
+
+  return history;
+}
diff --git a/packages/horizon-router/src/history/dom.ts b/packages/horizon-router/src/history/dom.ts
new file mode 100644
index 00000000..0db079a2
--- /dev/null
+++ b/packages/horizon-router/src/history/dom.ts
@@ -0,0 +1,17 @@
+export function isBrowser(): boolean {
+  return typeof window !== 'undefined' && window.document && typeof window.document.createElement === 'function';
+}
+
+export function getDefaultConfirmation(message: string, callBack: (result: boolean) => void) {
+  callBack(window.confirm(message));
+}
+
+// 判断浏览器是否支持pushState方法，pushState是browserHistory实现的基础
+export function isSupportHistory(): boolean {
+  return isBrowser() && window.history && 'pushState' in window.history;
+}
+
+// 判断浏览器是否支持PopState事件
+export function isSupportsPopState(): boolean {
+  return window.navigator.userAgent.indexOf('Trident') === -1;
+}
diff --git a/packages/horizon-router/src/history/hashHistory.ts b/packages/horizon-router/src/history/hashHistory.ts
new file mode 100644
index 00000000..f755ff1f
--- /dev/null
+++ b/packages/horizon-router/src/history/hashHistory.ts
@@ -0,0 +1,197 @@
+import { Action, BaseOption, DefaultStateType, EventType, History, Location, To } from './types';
+import {
+  addHeadSlash,
+  normalizeSlash,
+  createMemoryRecord,
+  createPath,
+  createLocation,
+  isLocationEqual,
+  stripBasename,
+  stripHeadSlash,
+} from './utils';
+import { getDefaultConfirmation } from './dom';
+import TransitionManager from './transitionManager';
+
+import warning from './waring';
+import { getBaseHistory } from './baseHistory';
+
+export type urlHashType = 'slash' | 'noslash';
+
+type HashHistoryOption = {
+  hashType?: urlHashType;
+} & BaseOption;
+
+// 获取#前的内容
+function stripHash(path: string): string {
+  const idx = path.indexOf('#');
+  return idx === -1 ? path : path.substring(0, idx);
+}
+
+// 获取#后的内容
+function getHashContent(path: string): string {
+  const idx = path.indexOf('#');
+  return idx === -1 ? '' : path.substring(idx + 1);
+}
+
+export function createHashHistory<S = DefaultStateType>(option: HashHistoryOption = {}): History<S> {
+  const browserHistory = window.history;
+  const { hashType = 'slash', getUserConfirmation = getDefaultConfirmation } = option;
+
+  const basename = option.basename ? normalizeSlash(option.basename) : '';
+
+  const pathDecoder = addHeadSlash;
+  const pathEncoder = hashType === 'slash' ? addHeadSlash : stripHeadSlash;
+
+  function getLocation() {
+    let hashPath = pathDecoder(getHashContent(window.location.hash));
+    if (basename) {
+      hashPath = stripBasename(hashPath, basename);
+    }
+
+    return createLocation<S>('', hashPath, undefined, 'default');
+  }
+
+  const initLocation = getLocation();
+
+  const memRecords = createMemoryRecord<string, Location<S>>(initLocation, createPath);
+
+  const transitionManager = new TransitionManager<S>();
+
+  function createHref(location: Location<S>) {
+    const tag = document.querySelector('base');
+    const base = tag && tag.getAttribute('href') ? stripHash(window.location.href) : '';
+    return base + '#' + pathEncoder(basename + createPath(location));
+  }
+
+  let forceNextPop = false;
+  let ignorePath: null | string = null;
+
+  const { go, goBack, goForward, listen, block, getUpdateStateFunc } = getBaseHistory(
+    transitionManager,
+    setListener,
+    browserHistory,
+  );
+
+  const history: History<S> = {
+    action: Action.pop,
+    length: browserHistory.length,
+    location: initLocation,
+    go,
+    goBack,
+    goForward,
+    push,
+    replace,
+    listen,
+    block,
+    createHref,
+  };
+
+  const updateState = getUpdateStateFunc(history);
+
+  function push(to: To, state?: S) {
+    warning(state !== undefined, 'Hash history does not support state, it will be ignored');
+
+    const action = Action.push;
+    const location = createLocation<S>(history.location, to, undefined, '');
+
+    transitionManager.confirmJumpTo(location, action, getUserConfirmation, isJump => {
+      if (!isJump) {
+        return;
+      }
+      const path = createPath(location);
+      const encodedPath = pathEncoder(basename + path);
+      // 前后hash不一样才进行跳转
+      if (getHashContent(window.location.href) !== encodedPath) {
+        ignorePath = encodedPath;
+        window.location.hash = encodedPath;
+
+        memRecords.addRecord(history.location, location, action);
+
+        updateState({ action, location });
+      } else {
+        updateState(undefined);
+      }
+    });
+  }
+
+  function replace(to: To, state?: S) {
+    warning(state !== undefined, 'Hash history does not support state, it will be ignored');
+    const action = Action.replace;
+    const location = createLocation<S>(history.location, to, undefined, '');
+
+    transitionManager.confirmJumpTo(location, action, getUserConfirmation, isJump => {
+      if (!isJump) {
+        return;
+      }
+      const path = createPath(location);
+      const encodedPath = pathEncoder(basename + path);
+      if (getHashContent(window.location.href) !== encodedPath) {
+        ignorePath = path;
+        window.location.replace(stripHash(window.location.href) + '#' + encodedPath);
+      }
+      memRecords.addRecord(history.location, location, action);
+      updateState({ action, location });
+    });
+  }
+
+  function handleHashChange() {
+    const hashPath = getHashContent(window.location.href);
+    const encodedPath = pathEncoder(hashPath);
+    if (hashPath !== encodedPath) {
+      window.location.replace(stripHash(window.location.href) + '#' + encodedPath);
+    } else {
+      const location = getLocation();
+      const prevLocation = history.location;
+      if (!forceNextPop && isLocationEqual(location, prevLocation)) {
+        return;
+      }
+      if (ignorePath === createPath(location)) {
+        return;
+      }
+      ignorePath = null;
+      handlePopState(location);
+    }
+  }
+
+  function handlePopState(location: Location<S>) {
+    if (forceNextPop) {
+      forceNextPop = false;
+      updateState(undefined);
+    } else {
+      const action = Action.pop;
+
+      const callback = (isJump: boolean) => {
+        if (isJump) {
+          updateState({ action: action, location: location });
+        } else {
+          revertPopState(location);
+        }
+      };
+
+      transitionManager.confirmJumpTo(location, action, getUserConfirmation, callback);
+    }
+  }
+
+  // 在跳转行为被Block后，用History.go()跳转回之前的页面
+  function revertPopState(form: Location<S>) {
+    const to = history.location;
+    const delta = memRecords.getDelta(to, form);
+    if (delta !== 0) {
+      go(delta);
+      forceNextPop = true;
+    }
+  }
+
+  let listenerCount = 0;
+
+  function setListener(delta: number) {
+    listenerCount += delta;
+    if (listenerCount === 1 && delta === 1) {
+      window.addEventListener(EventType.HashChange, handleHashChange);
+    } else if (listenerCount === 0) {
+      window.removeEventListener(EventType.HashChange, handleHashChange);
+    }
+  }
+
+  return history;
+}
diff --git a/packages/horizon-router/src/history/transitionManager.ts b/packages/horizon-router/src/history/transitionManager.ts
new file mode 100644
index 00000000..a36f2ade
--- /dev/null
+++ b/packages/horizon-router/src/history/transitionManager.ts
@@ -0,0 +1,64 @@
+import { Action, CallBackFunc, ConfirmationFunc, Listener, Location, Navigation, Prompt, TManager } from './types';
+
+class TransitionManager<S> implements TManager<S> {
+  private prompt: Prompt<S>;
+  private listeners: Listener<S>[];
+
+  constructor() {
+    this.prompt = null;
+    this.listeners = [];
+  }
+
+  public setPrompt(prompt: Prompt<S>): () => void {
+    this.prompt = prompt;
+
+    // 清除Prompt
+    return () => {
+      if (this.prompt === prompt) {
+        this.prompt = null;
+      }
+    };
+  }
+
+  // 使用发布订阅模式管理history的监听者
+  public addListener(func: Listener<S>): () => void {
+    let isActive = true;
+    const listener = (args: Navigation<S>) => {
+      if (isActive) {
+        func(args);
+      }
+    };
+    this.listeners.push(listener);
+    return () => {
+      isActive = false;
+      // 移除对应的监听者
+      this.listeners = this.listeners.filter(item => item !== listener);
+    };
+  }
+
+  public notifyListeners(args: Navigation<S>) {
+    for (const listener of this.listeners) {
+      listener(args);
+    }
+  }
+
+  public confirmJumpTo(
+    location: Location<S>,
+    action: Action,
+    userConfirmationFunc: ConfirmationFunc,
+    callBack: CallBackFunc
+  ) {
+    if (this.prompt !== null) {
+      const result = typeof this.prompt === 'function' ? this.prompt(location, action) : this.prompt;
+      if (typeof result === 'string') {
+        typeof userConfirmationFunc === 'function' ? userConfirmationFunc(result, callBack) : callBack(true);
+      } else {
+        callBack(result !== false);
+      }
+    } else {
+      callBack(true);
+    }
+  }
+}
+
+export default TransitionManager;
diff --git a/packages/horizon-router/src/history/types.ts b/packages/horizon-router/src/history/types.ts
new file mode 100644
index 00000000..5c116da7
--- /dev/null
+++ b/packages/horizon-router/src/history/types.ts
@@ -0,0 +1,92 @@
+export type BaseOption = {
+  basename?: string;
+  getUserConfirmation?: ConfirmationFunc;
+};
+
+export interface HistoryProps<T = unknown> {
+  readonly action: Action;
+
+  readonly location: Location<T>;
+
+  length: number;
+}
+
+export interface History<T = unknown> extends HistoryProps<T> {
+  createHref(path: Partial<Path>): string;
+
+  push(to: To, state?: T): void;
+
+  replace(to: To, state?: T): void;
+
+  listen(listener: Listener<T>): () => void;
+
+  block(prompt: Prompt<T>): () => void;
+
+  go(index: number): void;
+
+  goBack(): void;
+
+  goForward(): void;
+}
+
+export enum Action {
+  pop = 'POP',
+  push = 'PUSH',
+  replace = 'REPLACE',
+}
+
+export enum EventType {
+  PopState = 'popstate',
+  HashChange = 'hashchange',
+}
+
+export type Path = {
+  pathname: string;
+
+  search: string;
+
+  hash: string;
+};
+
+export type HistoryState<T> = {
+  state?: T;
+
+  key: string;
+};
+
+export type DefaultStateType = unknown;
+
+export type Location<T = unknown> = Path & HistoryState<T>;
+
+export type To = string | Partial<Path>;
+
+export interface Listener<T = unknown> {
+  (navigation: Navigation<T>): void;
+}
+
+export interface Navigation<T = unknown> {
+  action: Action;
+
+  location: Location<T>;
+}
+
+export type Prompt<S> = string | boolean | null | ((location: Location<S>, action: Action) => void);
+
+export type CallBackFunc = (isJump: boolean) => void;
+
+export type ConfirmationFunc = (message: string, callBack: CallBackFunc) => void;
+
+export interface TManager<S> {
+  setPrompt(next: Prompt<S>): () => void;
+
+  addListener(func: (navigation: Navigation<S>) => void): () => void;
+
+  notifyListeners(args: Navigation<S>): void;
+
+  confirmJumpTo(
+    location: Location<S>,
+    action: Action,
+    userConfirmationFunc: ConfirmationFunc,
+    callBack: CallBackFunc,
+  ): void;
+}
diff --git a/packages/horizon-router/src/history/utils.ts b/packages/horizon-router/src/history/utils.ts
new file mode 100644
index 00000000..d2bc7306
--- /dev/null
+++ b/packages/horizon-router/src/history/utils.ts
@@ -0,0 +1,134 @@
+import { Action, Location, Path, To } from './types';
+
+export function createPath(path: Partial<Path>): string {
+  const { search, hash } = path;
+  let pathname = path.pathname || '/';
+  if (search && search !== '?') {
+    pathname += search.startsWith('?') ? search : '?' + search;
+  }
+  if (hash && hash !== '#') {
+    pathname += hash.startsWith('#') ? hash : '#' + hash;
+  }
+  return pathname;
+}
+
+export function parsePath(url: string): Partial<Path> {
+  if (!url) {
+    return {};
+  }
+  let parsedPath: Partial<Path> = {};
+
+  let hashIdx = url.indexOf('#');
+  if (hashIdx > -1) {
+    parsedPath.hash = url.substring(hashIdx);
+    url = url.substring(0, hashIdx);
+  }
+
+  let searchIdx = url.indexOf('?');
+  if (searchIdx > -1) {
+    parsedPath.search = url.substring(searchIdx);
+    url = url.substring(0, searchIdx);
+  }
+  if (url) {
+    parsedPath.pathname = url;
+  }
+  return parsedPath;
+}
+
+export function createLocation<S>(current: string | Location, to: To, state?: S, key?: string): Readonly<Location<S>> {
+  let pathname = typeof current === 'string' ? current : current.pathname;
+  let urlObj = typeof to === 'string' ? parsePath(to) : to;
+  // 随机key长度取6
+  const getRandKey = genRandomKey(6);
+  const location = {
+    pathname: pathname,
+    search: '',
+    hash: '',
+    state: state,
+    key: typeof key === 'string' ? key : getRandKey(),
+    ...urlObj,
+  };
+  if (!location.pathname) {
+    location.pathname = '/';
+  }
+  return location;
+}
+
+export function isLocationEqual(p1: Partial<Path>, p2: Partial<Path>) {
+  return p1.pathname === p2.pathname && p1.search === p2.search && p1.hash === p2.hash;
+}
+
+export function addHeadSlash(path: string): string {
+  if (path[0] === '/') {
+    return path;
+  }
+  return '/' + path;
+}
+
+export function stripHeadSlash(path: string): string {
+  if (path[0] === '/') {
+    return path.substring(1);
+  }
+  return path;
+}
+
+export function normalizeSlash(path: string): string {
+  const tempPath = addHeadSlash(path);
+  if (tempPath[tempPath.length - 1] === '/') {
+    return tempPath.substring(0, tempPath.length - 1);
+  }
+  return tempPath;
+}
+
+export function hasBasename(path: string, prefix: string): Boolean {
+  return (
+    path.toLowerCase().indexOf(prefix.toLowerCase()) === 0 && ['/', '?', '#', ''].includes(path.charAt(prefix.length))
+  );
+}
+
+export function stripBasename(path: string, prefix: string): string {
+  return hasBasename(path, prefix) ? path.substring(prefix.length) : path;
+}
+
+// 使用随机生成的Key记录被访问过的URL，当Block被被触发时利用delta值跳转到之前的页面
+export function createMemoryRecord<T, S>(initVal: S, fn: (arg: S) => T) {
+  let visitedRecord: T[] = [fn(initVal)];
+
+  function getDelta(to: S, form: S): number {
+    let toIdx = visitedRecord.lastIndexOf(fn(to));
+    if (toIdx === -1) {
+      toIdx = 0;
+    }
+    let fromIdx = visitedRecord.lastIndexOf(fn(form));
+    if (fromIdx === -1) {
+      fromIdx = 0;
+    }
+    return toIdx - fromIdx;
+  }
+
+  function addRecord(current: S, newRecord: S, action: Action) {
+    const curVal = fn(current);
+    const NewVal = fn(newRecord);
+    if (action === Action.push) {
+      const prevIdx = visitedRecord.lastIndexOf(curVal);
+      const newVisitedRecord = visitedRecord.slice(0, prevIdx + 1);
+      newVisitedRecord.push(NewVal);
+      visitedRecord = newVisitedRecord;
+    }
+    if (action === Action.replace) {
+      const prevIdx = visitedRecord.lastIndexOf(curVal);
+      if (prevIdx !== -1) {
+        visitedRecord[prevIdx] = NewVal;
+      }
+    }
+  }
+
+  return { getDelta, addRecord };
+}
+
+function genRandomKey(length: number): () => string {
+  const end = length + 2;
+  return () => {
+    return Math.random().toString(18).substring(2, end);
+  };
+}
diff --git a/packages/horizon-router/src/history/waring.ts b/packages/horizon-router/src/history/waring.ts
new file mode 100644
index 00000000..74ec8ed6
--- /dev/null
+++ b/packages/horizon-router/src/history/waring.ts
@@ -0,0 +1,9 @@
+function warning(condition: any, message: string) {
+  if (condition) {
+    if (console && typeof console.warn === 'function') {
+      console.warn(message);
+    }
+  }
+}
+
+export default warning;
\ No newline at end of file
diff --git a/packages/horizon-router/src/router/BrowserRouter.tsx b/packages/horizon-router/src/router/BrowserRouter.tsx
new file mode 100644
index 00000000..d398488e
--- /dev/null
+++ b/packages/horizon-router/src/router/BrowserRouter.tsx
@@ -0,0 +1,32 @@
+import * as React from 'react';
+import { useRef, ReactNode } from 'react';
+import Router from './Router';
+import { createBrowserHistory } from '../history/browerHistory';
+import { ConfirmationFunc, History } from '../history/types';
+
+export type BaseRouterProps = {
+  basename: string;
+  getUserConfirmation: ConfirmationFunc;
+  children?: ReactNode;
+};
+
+export type BrowserRouterProps = BaseRouterProps & {
+  forceRefresh: boolean;
+};
+
+function BrowserRouter<P extends Partial<BrowserRouterProps>>(props: P) {
+  // 使用Ref持有History对象，防止重复渲染
+  let historyRef = useRef<History>();
+
+  if (historyRef.current === null || historyRef.current === undefined) {
+    historyRef.current = createBrowserHistory({
+      basename: props.basename,
+      forceRefresh: props.forceRefresh,
+      getUserConfirmation: props.getUserConfirmation,
+    });
+  }
+
+  return <Router history={historyRef.current}>{props.children}</Router>;
+}
+
+export default BrowserRouter;
\ No newline at end of file
diff --git a/packages/horizon-router/src/router/HashRouter.tsx b/packages/horizon-router/src/router/HashRouter.tsx
new file mode 100644
index 00000000..097625c9
--- /dev/null
+++ b/packages/horizon-router/src/router/HashRouter.tsx
@@ -0,0 +1,25 @@
+import * as React from 'react';
+import { useRef } from 'react';
+import { History } from '../history/types';
+import { BaseRouterProps } from './BrowserRouter';
+import { createHashHistory, urlHashType } from '../history/hashHistory';
+import Router from './Router';
+
+export type HashRouterProps = BaseRouterProps & {
+  hashType: urlHashType;
+};
+
+function HashRouter<P extends Partial<HashRouterProps>>(props: P) {
+  let historyRef = useRef<History>();
+  if (historyRef.current === null || historyRef.current === undefined) {
+    historyRef.current = createHashHistory({
+      basename: props.basename,
+      getUserConfirmation: props.getUserConfirmation,
+      hashType: props.hashType,
+    });
+  }
+
+  return <Router history={historyRef.current}>{props.children}</Router>;
+}
+
+export default HashRouter;
\ No newline at end of file
diff --git a/packages/horizon-router/src/router/Link.tsx b/packages/horizon-router/src/router/Link.tsx
new file mode 100644
index 00000000..a8a8b779
--- /dev/null
+++ b/packages/horizon-router/src/router/Link.tsx
@@ -0,0 +1,73 @@
+import * as React from 'react';
+import { useContext } from 'react';
+import RouterContext from './context';
+import { Location } from './index';
+import { createPath, parsePath } from '../history/utils';
+import { Path } from '../history/types';
+
+export type LinkProps = {
+  component?: React.ComponentType<any>;
+  to: Partial<Location> | string | ((location: Location) => string | Partial<Location>);
+  replace?: boolean;
+  tag?: string;
+  /**
+   * @deprecated
+   * React16以后不再需要该属性
+   **/
+  innerRef?: React.Ref<HTMLAnchorElement>;
+} & React.AnchorHTMLAttributes<HTMLAnchorElement>;
+
+const isModifiedEvent = (event: React.MouseEvent) => {
+  return event.metaKey || event.altKey || event.ctrlKey || event.shiftKey;
+};
+
+const checkTarget = (target?: React.HTMLAttributeAnchorTarget) => {
+  return !target || target === '_self';
+};
+
+
+function Link<P extends LinkProps>(props: P) {
+  const { to, replace, component, onClick, target, ...other } = props;
+
+  const tag = props.tag || 'a';
+
+  const context = useContext(RouterContext);
+  const history = context.history;
+
+  let location = typeof to === 'function' ? to(context.location) : to;
+
+  let state: any;
+  let path: Partial<Path>;
+  if (typeof location === 'string') {
+    path = parsePath(location);
+  } else {
+    const { pathname, hash, search } = location;
+    path = { pathname, hash, search };
+    state = location.state;
+  }
+  const href = history.createHref(path);
+
+  const linkClickEvent = (event: React.MouseEvent<HTMLAnchorElement>) => {
+    try {
+      if (onClick) {
+        onClick(event);
+      }
+    } catch (e) {
+      event.preventDefault();
+      throw e;
+    }
+
+    if (!event.defaultPrevented && event.button === 0 && checkTarget(target) && !isModifiedEvent(event)) {
+      // 不是相同的路径执行push操作，是相同的路径执行replace
+      const isSamePath = createPath(context.location) === createPath(path);
+      const navigate = replace || isSamePath ? history.replace : history.push;
+      event.preventDefault();
+      navigate(path, state);
+    }
+  };
+
+  const linkProps = { href: href, onClick: linkClickEvent, ...other };
+  return React.createElement(tag, linkProps);
+}
+
+export default Link;
\ No newline at end of file
diff --git a/packages/horizon-router/src/router/NavLink.tsx b/packages/horizon-router/src/router/NavLink.tsx
new file mode 100644
index 00000000..1c187d3d
--- /dev/null
+++ b/packages/horizon-router/src/router/NavLink.tsx
@@ -0,0 +1,42 @@
+import * as React from 'react';
+import { useContext } from 'react';
+import type { LinkProps } from './Link';
+import Link from './Link';
+import { Location, matchPath } from './index';
+import { Matched } from './matcher/parser';
+import Context from './context';
+import { parsePath } from '../history/utils';
+import { escapeStr } from './matcher/utils';
+
+type NavLinkProps = {
+  to: Partial<Location> | string | ((location: Location) => string | Partial<Location>);
+  isActive?: (match: Matched | null, location: Location) => boolean;
+  // compat react-router NavLink props type
+  [key: string]: any;
+} & LinkProps;
+
+type Page = 'page';
+
+function NavLink<P extends NavLinkProps>(props: P) {
+  const { to, isActive, ...rest } = props;
+  const context = useContext(Context);
+
+  const toLocation = typeof to === 'function' ? to(context.location) : to;
+
+  const { pathname: path } = typeof toLocation === 'string' ? parsePath(toLocation) : toLocation;
+  // 把正则表达式的特殊符号加两个反斜杠进行转义
+  const escapedPath = path ? escapeStr(path) : '';
+  const match = escapedPath ? matchPath(context.location.pathname, escapedPath) : null;
+
+  const isLinkActive = match && isActive ? isActive(match, context.location) : false;
+
+  const page: Page = 'page';
+  const otherProps = {
+    'aria-current': isLinkActive ? page : false,
+    ...rest,
+  };
+
+  return <Link to={to} {...otherProps} />;
+}
+
+export default NavLink;
diff --git a/packages/horizon-router/src/router/Prompt.tsx b/packages/horizon-router/src/router/Prompt.tsx
new file mode 100644
index 00000000..208f1471
--- /dev/null
+++ b/packages/horizon-router/src/router/Prompt.tsx
@@ -0,0 +1,49 @@
+import * as React from 'react';
+import { useContext } from 'react';
+import { LifeCycle, LifeCycleProps } from './lifeCycleHook';
+import { Location } from './index';
+import { Action } from '../history/types';
+import RouterContext from './context';
+
+type PromptProps = {
+  message?: string | ((location: Partial<Location>, action: Action) => void);
+  when?: boolean | ((location: Partial<Location>) => boolean);
+};
+
+function Prompt<P extends PromptProps>(props: P) {
+  const context = useContext(RouterContext);
+
+  const { message, when = true } = props;
+
+  if ((typeof when === 'function' && when(context.location) === false) || !when) {
+    return null;
+  }
+
+  const navigate = context.history.block;
+
+  let release: (() => void) | null = null;
+
+  const onMountFunc = () => {
+    release = message ? navigate(message) : null;
+  };
+
+  const onUpdateFunc = (prevProps?: LifeCycleProps) => {
+    if (prevProps && prevProps.data !== message) {
+      if (release) {
+        release();
+      }
+      release = message ? navigate(message) : null;
+    }
+  };
+
+  const onUnmountFunc = () => {
+    if (release) {
+      release();
+    }
+    release = null;
+  };
+
+  return <LifeCycle onMount={onMountFunc} onUpdate={onUpdateFunc} onUnmount={onUnmountFunc} data={message} />;
+}
+
+export default Prompt;
diff --git a/packages/horizon-router/src/router/Redirect.tsx b/packages/horizon-router/src/router/Redirect.tsx
new file mode 100644
index 00000000..66278d28
--- /dev/null
+++ b/packages/horizon-router/src/router/Redirect.tsx
@@ -0,0 +1,61 @@
+import * as React from 'react';
+import { useContext } from 'react';
+import RouterContext from './context';
+import { LifeCycle, LifeCycleProps } from './lifeCycleHook';
+import { Matched, createPathParser } from './matcher/parser';
+import { addHeadSlash, isLocationEqual, parsePath } from '../history/utils';
+import { Location } from './index';
+
+export type RedirectProps = {
+  to: string | Partial<Location>;
+  push?: boolean;
+  path?: string;
+  from?: string;
+  exact?: boolean;
+  strict?: boolean;
+
+  // 由Switch计算得到
+  readonly computed?: Matched | null;
+};
+
+function Redirect<P extends RedirectProps>(props: P) {
+  const { to, push = false, computed } = props;
+
+  const context = useContext(RouterContext);
+  const { history } = context;
+
+  const calcLocation = (): Partial<Location> => {
+    if (computed) {
+      if (typeof to === 'string') {
+        const parser = createPathParser(to);
+        const target = parser.compile(computed.params);
+        return parsePath(target);
+      } else {
+        const pathname = to.pathname ? addHeadSlash(to.pathname) : '/';
+        const parser = createPathParser(pathname);
+        const target = parser.compile(computed.params);
+        return { ...to, pathname: target };
+      }
+    }
+    return typeof to === 'string' ? parsePath(to) : to;
+  };
+
+  const navigate = push ? history.push : history.replace;
+  const { state, ...path } = calcLocation();
+
+  const onMountFunc = () => {
+    navigate(path, state);
+  };
+
+  const onUpdateFunc = (prevProps?: LifeCycleProps) => {
+    // 如果当前页面与重定向前页面不一致，执行跳转
+    const prevPath = prevProps?.data as Location;
+    if (!isLocationEqual(prevPath, path)) {
+      navigate(path, state);
+    }
+  };
+
+  return <LifeCycle onMount={onMountFunc} onUpdate={onUpdateFunc} data={path} />;
+}
+
+export default Redirect;
diff --git a/packages/horizon-router/src/router/Route.tsx b/packages/horizon-router/src/router/Route.tsx
new file mode 100644
index 00000000..431f2445
--- /dev/null
+++ b/packages/horizon-router/src/router/Route.tsx
@@ -0,0 +1,85 @@
+import * as React from 'react';
+import { History, Location } from './index';
+import { Matched, matchPath } from './matcher/parser';
+import { useContext, Children, createElement } from 'react';
+import RouterContext from './context';
+import { GetURLParams } from './matcher/types';
+
+export type RouteComponentProps<P extends Record<string, any> = {}, S = unknown> = RouteChildrenProps<P, S>;
+
+export type RouteChildrenProps<P extends Record<string, any> = {}, S = unknown> = {
+  history: History<S>;
+  location: Location<S>;
+  match: Matched<P> | null
+}
+
+export type RouteProps<P extends Record<string, any> = {}, Path extends string = string> = {
+  location?: Location;
+  component?: React.ComponentType<RouteComponentProps<P>> | React.ComponentType<any> | undefined;
+  children?: ((props: RouteChildrenProps<P>) => React.ReactNode) | React.ReactNode;
+  render?: (props: RouteComponentProps<P>) => React.ReactNode;
+  path?: Path | Path[];
+  exact?: boolean;
+  sensitive?: boolean;
+  strict?: boolean;
+  computed?: Matched<P>;
+};
+
+function Route<Path extends string, P extends Record<string, any> = GetURLParams<Path>>(props: RouteProps<P, Path>) {
+  const context = useContext(RouterContext);
+
+  const { computed, location, path } = props;
+  let { children, component, render } = props;
+  let match: Matched<P> | null;
+
+  const routeLocation = location || context.location;
+  if (computed) {
+    match = computed;
+  } else if (path) {
+    match = matchPath<P>(routeLocation.pathname, path);
+  } else {
+    match = context.match;
+  }
+  const newProps = { ...context, location: routeLocation, match: match };
+
+  if (Array.isArray(children) && Children.count(children) === 0) {
+    children = null;
+  }
+
+  /**
+   * 按顺序获取需要渲染的组件
+   * 1.children
+   * 2.component
+   * 3.render
+   * 都没有匹配到返回Null
+   */
+  const getChildren = (): React.ReactNode | null => {
+    // 如果 match 存在
+    if (newProps.match) {
+      if (children) {
+        if (typeof children === 'function') {
+          return children(newProps);
+        }
+        return children;
+      }
+
+      if (component) {
+        return createElement(component, newProps);
+      } else if (render) {
+        return render(newProps);
+      } else {
+        return null;
+      }
+    } else {
+      // match为null
+      if (typeof children === 'function') {
+        return children(newProps);
+      }
+      return null;
+    }
+  };
+
+  return <RouterContext.Provider value={newProps}>{getChildren()}</RouterContext.Provider>;
+}
+
+export default Route;
diff --git a/packages/horizon-router/src/router/Router.tsx b/packages/horizon-router/src/router/Router.tsx
new file mode 100644
index 00000000..b64f2266
--- /dev/null
+++ b/packages/horizon-router/src/router/Router.tsx
@@ -0,0 +1,58 @@
+import * as React from 'react';
+import { useLayoutEffect, useMemo, useRef, useState } from 'react';
+
+import { History, Location } from '../history/types';
+
+import RouterContext, { RouterContextValue } from './context';
+
+export type RouterProps = {
+  history: History;
+  children?: React.ReactNode;
+};
+
+function Router<P extends RouterProps>(props: P) {
+  const { history, children = null } = props;
+  const [location, setLocation] = useState(props.history.location);
+  const pendingLocation = useRef<Location | null>(null);
+
+  // 在Router加载时就监听history地址变化，以保证在始渲染时重定向能正确触发
+  let unListen: null | (() => void) = history.listen(arg => {
+    pendingLocation.current = arg.location;
+  });
+
+  // 模拟componentDidMount和componentWillUnmount
+  useLayoutEffect(() => {
+    if (unListen) {
+      unListen();
+    }
+    // 监听history中的位置变化
+    unListen = history.listen(arg => {
+      setLocation(arg.location);
+    });
+
+    if (pendingLocation.current) {
+      setLocation(pendingLocation.current);
+    }
+
+    return () => {
+      if (unListen) {
+        unListen();
+        unListen = null;
+        pendingLocation.current = null;
+      }
+    };
+  }, []);
+
+  const initContextValue: RouterContextValue = useMemo(
+    () => ({
+      history: history,
+      location: location,
+      match: { isExact: location.pathname === '/', params: {}, path: '/', score: [], url: '/' },
+    }),
+    [location],
+  );
+
+  return <RouterContext.Provider value={initContextValue} children={children} />;
+}
+
+export default Router;
diff --git a/packages/horizon-router/src/router/Switch.tsx b/packages/horizon-router/src/router/Switch.tsx
new file mode 100644
index 00000000..4f1cf783
--- /dev/null
+++ b/packages/horizon-router/src/router/Switch.tsx
@@ -0,0 +1,68 @@
+import * as React from 'react';
+import { useContext, Children, isValidElement, cloneElement } from 'react';
+
+import { Location } from './index';
+import RouterContext from './context';
+import { Matched, matchPath } from './matcher/parser';
+import Route, { RouteProps } from './Route';
+import Redirect, { RedirectProps } from './Redirect';
+
+export type SwitchProps = {
+  location?: Location;
+  children?: React.ReactNode;
+};
+
+function Switch<P extends SwitchProps>(props: P): React.ReactElement | null {
+  const context = useContext(RouterContext);
+  const location = props.location || context.location;
+
+  let element: React.ReactElement | null = null;
+  let match: Matched | null = null;
+
+  // 使用forEach不会给React.ReactNode增加key属性,防止重新渲染
+  Children.forEach(props.children, node => {
+    if (match === null && isValidElement(node)) {
+      element = node;
+
+      let strict: boolean | undefined;
+      let sensitive: boolean | undefined;
+      let path: string | string[] | undefined;
+      let from: string | undefined;
+
+      // node可能是Route和Redirect
+      if (node.type === Route) {
+        const props = node.props as RouteProps;
+        strict = props.strict;
+        sensitive = props.sensitive;
+        path = props.path;
+      } else if (node.type === Redirect) {
+        const props = node.props as RedirectProps;
+        path = props.path;
+        strict = props.strict;
+        from = props.from;
+      }
+
+      const exact = node.props.exact;
+      const target = path || from;
+
+      // 更新匹配状态，一旦匹配到停止遍历
+      if (target) {
+        match = matchPath(location.pathname, target, {
+          strictMode: strict,
+          caseSensitive: sensitive,
+          exact: exact,
+        });
+      } else {
+        match = context.match;
+      }
+    }
+  });
+
+  if (match && element) {
+    // 使用cloneElement复制已有组件并更新其Props
+    return cloneElement(element, { location: location, computed: match });
+  }
+  return null;
+}
+
+export default Switch;
diff --git a/packages/horizon-router/src/router/__tests__/router.test.tsx b/packages/horizon-router/src/router/__tests__/router.test.tsx
new file mode 100644
index 00000000..3a673249
--- /dev/null
+++ b/packages/horizon-router/src/router/__tests__/router.test.tsx
@@ -0,0 +1,163 @@
+import * as React from 'react';
+import { historyHook, locationHook, Test_Demo, Test_Demo2, Test_Demo3, Test_Demo4 } from './test_app';
+import { createBrowserHistory, createHashHistory, Router } from '../index';
+import { act, render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import '@testing-library/jest-dom';
+
+describe('Horizon-router Test', () => {
+
+  it('Render app and Jump use <Link>', async () => {
+    const history = createBrowserHistory();
+    render(
+      <Router history={history}>
+        <Test_Demo />
+      </Router>,
+    );
+    const user = userEvent.setup();
+    expect(locationHook.pathname).toEqual('/');
+    expect(screen.getByText(/you are home/i)).toBeInTheDocument();
+
+    await user.click(screen.getByText(/about/i));
+    expect(locationHook.pathname).toEqual('/about');
+    expect(screen.getByText(/you are on the about page/i)).toBeInTheDocument();
+
+    await user.click(screen.getByText(/user/i));
+    expect(locationHook.pathname).toEqual('/user');
+    expect(screen.getByText(/You are at User Index/i)).toBeInTheDocument();
+  });
+
+  it('Test hooks and use hook to jump to page', async () => {
+    const history = createBrowserHistory();
+    render(
+      <Router history={history}>
+        <Test_Demo />
+      </Router>,
+    );
+
+    act(() => {
+      historyHook.push('/');
+    });
+
+    expect(locationHook.pathname).toEqual('/');
+    act(() => {
+      historyHook.push('/about');
+    });
+
+    expect(screen.getByText(/you are on the about page/i)).toBeInTheDocument();
+
+    act(() => {
+      historyHook.push('/user');
+    });
+    expect(locationHook.pathname).toEqual('/user');
+    expect(screen.getByText(/You are at User Index/i)).toBeInTheDocument();
+
+    act(() => {
+      historyHook.push('/test');
+    });
+    expect(locationHook.pathname).toEqual('/test');
+    expect(screen.getByText(/No match/i)).toBeInTheDocument();
+
+  });
+
+  it('Test Redirect', async () => {
+    const history = createBrowserHistory();
+    render(
+      <Router history={history}>
+        <Test_Demo />
+      </Router>,
+    );
+
+    act(() => {
+      historyHook.push('/default');
+    });
+    expect(screen.getByText(/No match/i)).toBeInTheDocument();
+
+    act(() => {
+      historyHook.push('/test2');
+    });
+    // '/test2'会重定向至'/redirect'
+    expect(locationHook.pathname).toEqual('/redirect');
+    expect(screen.getByText(/No match/i)).toBeInTheDocument();
+  });
+
+  it('Test useParams Hook', async () => {
+    const history = createBrowserHistory();
+    render(
+      <Router history={history}>
+        <Test_Demo />
+      </Router>,
+    );
+
+    act(() => {
+      historyHook.push('/profile/123');
+    });
+    expect(locationHook.pathname).toEqual('/profile/123');
+
+    expect(screen.getByText(/Param is 123/i)).toBeInTheDocument();
+
+  });
+
+  it('Test WithRouter', async () => {
+    const history = createBrowserHistory();
+    render(
+      <Router history={history}>
+        <Test_Demo />
+      </Router>,
+    );
+
+    act(() => {
+      historyHook.push('/testr');
+    });
+
+    expect(locationHook.pathname).toEqual('/testr');
+
+    // 测试WithRouter是否正确注入Props
+    expect(screen.getByText('withRoute Test, pathname--/testr')).toBeInTheDocument();
+
+  });
+
+  it('Test Prompt', async () => {
+    const history = createBrowserHistory();
+    render(
+      <Router history={history}>
+        <Test_Demo2 />
+      </Router>,
+    );
+
+    const user = userEvent.setup();
+    await user.click(screen.getByText(/about/i));
+    // 查找结果为Null说明Prompt组件已成功拦截前往/about的跳转行为
+    expect(screen.queryByText(/you are on the about page/i)).toBeNull();
+
+    await user.click(screen.getByText(/user/i));
+    expect(screen.queryByText(/You are at User Index/i)).not.toBeNull();
+  });
+
+  it('Test Init Render Redirect', () => {
+    const history = createBrowserHistory();
+    render(
+      <Router history={history}>
+        <Test_Demo3 />
+      </Router>,
+    );
+    // 初次渲染重定向至User Index
+    expect(screen.queryByText(/you are home/i)).toBeNull();
+
+    expect(screen.queryByText(/You are at User Index/i)).not.toBeNull();
+  });
+
+  it('<Redirect/> support props path and wildcard', () => {
+    const history = createHashHistory();
+    render(
+      <Router history={history}>
+        <Test_Demo4 />
+      </Router>,
+    );
+    // 初次渲染重定向至User Index
+    expect(screen.queryByText(/you are home/i)).toBeNull();
+    expect(screen.queryByText(/You are on the about page/i)).toBeNull();
+
+    expect(screen.queryByText(/You are at User Index/i)).not.toBeNull();
+  });
+});
diff --git a/packages/horizon-router/src/router/__tests__/test_app.tsx b/packages/horizon-router/src/router/__tests__/test_app.tsx
new file mode 100644
index 00000000..5dfa2ef0
--- /dev/null
+++ b/packages/horizon-router/src/router/__tests__/test_app.tsx
@@ -0,0 +1,119 @@
+import React from 'react';
+import {
+  History,
+  Link,
+  Location,
+  Prompt,
+  Redirect,
+  Route,
+  Switch,
+  useHistory,
+  useLocation,
+  useParams,
+  withRouter,
+} from '../index';
+
+export let historyHook: History;
+export let locationHook: Location;
+const About = () => <div>You are on the about page</div>;
+const Home = () => <div>You are home</div>;
+const User = () => <div>You are at User Index</div>;
+const Profile = () => {
+  const params = useParams();
+  return <div>Param is {(params as any).id}</div>;
+};
+
+function WithRouterTest(props) {
+  return <h1>withRoute Test, pathname--{props.location.pathname}</h1>;
+}
+
+export const LocationDisplay = () => {
+  locationHook = useLocation();
+  historyHook = useHistory();
+  return <div>current Location: {locationHook.pathname}</div>;
+};
+
+export const Test_Demo = () => {
+  const comp = withRouter(WithRouterTest);
+
+  return (
+    <div>
+      <Link to='/'>Home</Link>
+
+      <Link to='/about'>About</Link>
+
+      <Link to='/user'>User</Link>
+
+      <Switch>
+        <Redirect to='/redirect' from='/test2' />
+
+        <Route exact path='/' component={Home} />
+
+        <Route path='/about' component={About} />
+
+        <Route path='/user' component={User} />
+
+        <Route path='/testr' component={comp} />
+
+        <Route path='/profile/:id' component={Profile} />
+
+        <Route component={() => <div>No match</div>} />
+      </Switch>
+      <LocationDisplay />
+    </div>
+  );
+};
+
+export const Test_Demo2 = () => {
+  return (
+    <div>
+      <Link to='/'>Home</Link>
+
+      <Link to='/about'>About</Link>
+
+      <Link to='/user'>User</Link>
+
+      <Prompt
+        when={true}
+        message={(location, _) => {
+          // location.pathname为about时拦截跳转
+          return location.pathname !== '/about';
+        }}
+      />
+
+      <Switch>
+        <Route exact path='/' component={Home} />
+
+        <Route path='/about' component={About} />
+
+        <Route path='/user' component={User} />
+      </Switch>
+    </div>
+  );
+};
+
+// 初始渲染直接重定向
+export const Test_Demo3 = () => {
+  return (
+    <div>
+      <Switch>
+        <Route path='/about' component={About} />
+        <Route path='/user' component={User} />
+        <Redirect to='/user' path='/' />
+      </Switch>
+    </div>
+  );
+};
+
+// <Redirect/>支持path设置通配符*
+export const Test_Demo4 = () => {
+  return (
+    <div>
+      <Switch>
+        <Route path='/about' component={About} />
+        <Route path='/user' component={User} />
+        <Redirect to='/user' path='*' />
+      </Switch>
+    </div>
+  );
+};
diff --git a/packages/horizon-router/src/router/context.tsx b/packages/horizon-router/src/router/context.tsx
new file mode 100644
index 00000000..aed3afe3
--- /dev/null
+++ b/packages/horizon-router/src/router/context.tsx
@@ -0,0 +1,19 @@
+import { createContext } from 'react';
+import { History, Location } from './index';
+import { Matched } from './matcher/parser';
+
+function createNamedContext<T>(name: string, defaultValue: T) {
+  const context = createContext<T>(defaultValue);
+  context.displayName = name;
+  return context;
+}
+
+export type RouterContextValue = {
+  history: History;
+  location: Location;
+  match: Matched | null;
+};
+
+const RouterContext = createNamedContext<RouterContextValue>('Router', {} as any);
+
+export default RouterContext;
\ No newline at end of file
diff --git a/packages/horizon-router/src/router/hooks.ts b/packages/horizon-router/src/router/hooks.ts
new file mode 100644
index 00000000..70ebf9ad
--- /dev/null
+++ b/packages/horizon-router/src/router/hooks.ts
@@ -0,0 +1,33 @@
+import { useContext } from 'react';
+import RouterContext from './context';
+import { Matched, matchPath, Params } from './matcher/parser';
+import { History } from '../history/types';
+import { Location } from './index';
+
+function useHistory<S>(): History<S>;
+function useHistory() {
+  return useContext(RouterContext).history;
+}
+
+function useLocation<S>(): Location<S>;
+function useLocation() {
+  return useContext(RouterContext).location;
+}
+
+function useParams<P>(): Params<P> | {};
+function useParams() {
+  const match = useContext(RouterContext).match;
+  return match ? match.params : {};
+}
+
+function useRouteMatch<P>(path?: string): Matched<P> | null;
+function useRouteMatch(path?: string) {
+  const pathname = useLocation().pathname;
+  const match = useContext(RouterContext).match;
+  if (path) {
+    return matchPath(pathname, path);
+  }
+  return match;
+}
+
+export { useHistory, useLocation, useParams, useRouteMatch };
diff --git a/packages/horizon-router/src/router/index.ts b/packages/horizon-router/src/router/index.ts
new file mode 100644
index 00000000..ce8b8bb0
--- /dev/null
+++ b/packages/horizon-router/src/router/index.ts
@@ -0,0 +1,38 @@
+import { Location as HLocation } from '../history/types';
+
+type Location<S = unknown> = Omit<HLocation<S>, 'key'>;
+
+// ============================ history ============================
+
+export { Location };
+export type { History } from '../history/types';
+
+export { createBrowserHistory } from '../history/browerHistory';
+export { createHashHistory } from '../history/hashHistory';
+
+export { default as __RouterContext } from './context';
+
+// ============================ URL parser ============================
+
+export { matchPath, generatePath } from './matcher/parser';
+
+// ============================ Router Hooks ============================
+
+export { useHistory, useLocation, useParams, useRouteMatch } from './hooks';
+
+// ============================ Router function component ============================
+
+export { default as Route } from './Route';
+export { default as Router } from './Router';
+export { default as Switch } from './Switch';
+export { default as Redirect } from './Redirect';
+export { default as Prompt } from './Prompt';
+export { default as withRouter } from './withRouter';
+export { default as HashRouter } from './HashRouter';
+export { default as BrowserRouter } from './BrowserRouter';
+export { default as Link } from './Link';
+export { default as NavLink } from './NavLink';
+
+// ============================ Router Types ============================
+
+export type { RouteComponentProps, RouteChildrenProps, RouteProps } from './Route';
diff --git a/packages/horizon-router/src/router/index2.ts b/packages/horizon-router/src/router/index2.ts
new file mode 100644
index 00000000..19542b64
--- /dev/null
+++ b/packages/horizon-router/src/router/index2.ts
@@ -0,0 +1,45 @@
+import { Location as HLocation } from '../history/types';
+import { getConnectedRouter } from '../connect-router';
+
+type Location<S = unknown> = Omit<HLocation<S>, 'key'>;
+
+// ============================ history ============================
+
+export { Location };
+export type { History } from '../history/types';
+
+export { createBrowserHistory } from '../history/browerHistory';
+export { createHashHistory } from '../history/hashHistory';
+
+export { default as __RouterContext } from './context';
+
+// ============================ URL parser ============================
+
+export { matchPath, generatePath } from './matcher/parser';
+
+// ============================ Router Hooks ============================
+
+export { useHistory, useLocation, useParams, useRouteMatch } from './hooks';
+
+// ============================ Router function component ============================
+
+export { default as Route } from './Route';
+export { default as Router } from './Router';
+export { default as Switch } from './Switch';
+export { default as Redirect } from './Redirect';
+export { default as Prompt } from './Prompt';
+export { default as withRouter } from './withRouter';
+export { default as HashRouter } from './HashRouter';
+export { default as BrowserRouter } from './BrowserRouter';
+export { default as Link } from './Link';
+export { default as NavLink } from './NavLink';
+
+// ============================ Router Types ============================
+
+export type { RouteComponentProps, RouteChildrenProps, RouteProps } from './Route';
+
+// ============================ Connect-router ============================
+
+export { connectRouter, routerMiddleware } from '../connect-router';
+export const ConnectedRouter = getConnectedRouter('Redux');
+export const ConnectedHRouter = getConnectedRouter('HorizonXCompat');
\ No newline at end of file
diff --git a/packages/horizon-router/src/router/lifeCycleHook.ts b/packages/horizon-router/src/router/lifeCycleHook.ts
new file mode 100644
index 00000000..b603d919
--- /dev/null
+++ b/packages/horizon-router/src/router/lifeCycleHook.ts
@@ -0,0 +1,43 @@
+import { useLayoutEffect, useRef } from 'react';
+
+export type LifeCycleProps = {
+  onMount?: () => void;
+  onUpdate?: (prevProps?: LifeCycleProps) => void;
+  onUnmount?: () => void;
+  data?: any;
+};
+
+export function LifeCycle(props: LifeCycleProps) {
+  // 使用ref保存上一次的props，防止重新渲染
+  const prevProps = useRef<LifeCycleProps | null>(null);
+  const isMount = useRef(false);
+
+  const { onMount, onUpdate, onUnmount } = props;
+
+  useLayoutEffect(() => {
+    // 首次挂载 模拟componentDidMount
+    if (!isMount.current) {
+      isMount.current = true;
+      if (onMount) {
+        onMount();
+      }
+    } else {
+      // 不是首次渲染 模拟componentDidUpdate
+      if (onUpdate) {
+        prevProps.current ? onUpdate(prevProps.current) : onUpdate();
+      }
+    }
+    prevProps.current = props;
+  });
+
+  // 模拟componentWillUnmount
+  useLayoutEffect(() => {
+    return () => {
+      if (onUnmount) {
+        onUnmount();
+      }
+    };
+  }, []);
+
+  return null;
+}
diff --git a/packages/horizon-router/src/router/matcher/__tests__/lexer.test.ts b/packages/horizon-router/src/router/matcher/__tests__/lexer.test.ts
new file mode 100644
index 00000000..ed87385c
--- /dev/null
+++ b/packages/horizon-router/src/router/matcher/__tests__/lexer.test.ts
@@ -0,0 +1,65 @@
+import { lexer } from '../lexer';
+
+describe('path lexer Test', () => {
+  it('basic lexer test', () => {
+    const tokens = lexer('/www.a.com/b/c');
+    expect(tokens).toStrictEqual([
+      { type: 'delimiter', value: '/' },
+      { type: 'static', value: 'www.a.com' },
+      { type: 'delimiter', value: '/' },
+      { type: 'static', value: 'b' },
+      { type: 'delimiter', value: '/' },
+      { type: 'static', value: 'c' },
+    ]);
+  });
+
+  it('null tokens', () => {
+    const tokens = lexer('');
+    expect(tokens).toStrictEqual([]);
+  });
+
+  it('a slash test', () => {
+    const tokens = lexer('/');
+    expect(tokens).toStrictEqual([{ type: 'delimiter', value: '/' }]);
+  });
+
+  it(`don't start with a slash`, () => {
+    const func = () => lexer('abc.com');
+    expect(func).toThrow(Error(`Url must start with "/".`));
+  });
+
+  it('dynamic params test', () => {
+    const tokens = lexer('/www.a.com/:b');
+    expect(tokens).toStrictEqual([
+      { type: 'delimiter', value: '/' },
+      { type: 'static', value: 'www.a.com' },
+      { type: 'delimiter', value: '/' },
+      { type: 'param', value: 'b' },
+    ]);
+  });
+
+  it('dynamic params with pattern', () => {
+    const tokens = lexer('/www.a.com/:b(a)/*');
+    expect(tokens).toStrictEqual([
+      { type: 'delimiter', value: '/' },
+      { type: 'static', value: 'www.a.com' },
+      { type: 'delimiter', value: '/' },
+      { type: 'param', value: 'b' },
+      { type: '(', value: '(' },
+      { type: 'pattern', value: 'a' },
+      { type: ')', value: ')' },
+      { type: 'delimiter', value: '/' },
+      { type: 'wildcard', value: '*' },
+    ]);
+  });
+
+  it('wildcard params test', () => {
+    const tokens = lexer('/www.a.com/:b');
+    expect(tokens).toStrictEqual([
+      { type: 'delimiter', value: '/' },
+      { type: 'static', value: 'www.a.com' },
+      { type: 'delimiter', value: '/' },
+      { type: 'param', value: 'b' },
+    ]);
+  });
+});
diff --git a/packages/horizon-router/src/router/matcher/__tests__/parser.test.ts b/packages/horizon-router/src/router/matcher/__tests__/parser.test.ts
new file mode 100644
index 00000000..70372f7f
--- /dev/null
+++ b/packages/horizon-router/src/router/matcher/__tests__/parser.test.ts
@@ -0,0 +1,248 @@
+import { matchPath, generatePath, createPathParser } from '../parser';
+
+describe('parser test', () => {
+  it('parse param test', function () {
+    const parser = createPathParser('/www.a.com/:b/:c/', { strictMode: true });
+    const res = parser.parse('/www.a.com/bbb/ccc/');
+    expect(res!.params).toStrictEqual({ b: 'bbb', c: 'ccc' });
+    expect(res!.score).toStrictEqual([10, 6, 6]);
+  });
+
+  it('parse param test2', function () {
+    const parser = createPathParser('/www.a.com/:b/:c', { exact: false });
+    const res = parser.parse('/www.a.com/bbb/ccc');
+    expect(res!.params).toStrictEqual({ b: 'bbb', c: 'ccc' });
+    expect(res!.score).toStrictEqual([10, 6, 6]);
+  });
+
+  it('compile test1', function () {
+    const url = generatePath('/www.a.com/a/:b', { b: 'xyz' });
+    expect(url).toBe('/www.a.com/a/xyz');
+  });
+
+  it('compile test2', function () {
+    const url = generatePath('/www.a.com/a/:b/c', { b: 'xyz' });
+    expect(url).toBe('/www.a.com/a/xyz/c');
+  });
+
+  it('compile test3', function () {
+    const action = () => generatePath('/www.a.com/a/:b/:c', { b: 'xyz' });
+    expect(action).toThrow(new Error('Param is invalid.'));
+  });
+
+  it('parse wildcard', function () {
+    const parser = createPathParser('/www.a.com/a/*', { exact: true });
+    const params = parser.parse('/www.a.com/a/b1/c1/d1');
+    const params1 = parser.parse('/www.a.com/a/b1/c1/');
+    expect(params!.params).toStrictEqual({ '*': ['b1', 'c1', 'd1'] });
+    expect(params!.score).toStrictEqual([10, 10, 3, 3, 3]);
+    expect(params1!.params).toStrictEqual({ '*': ['b1', 'c1'] });
+    expect(params1!.score).toStrictEqual([10, 10, 3, 3]);
+  });
+
+  it('compile wildcard', function () {
+    const url = generatePath('/www.a.com/:b/*', { b: 'abc', '*': ['x', 'y', 'z'] });
+    expect(url).toEqual('/www.a.com/abc/x/y/z');
+  });
+
+  it('wildcard all', function () {
+    const parser = createPathParser('/www.a.com/*', { exact: true });
+    const matched = parser.parse('/www.a.com/x2/yy3/zzz4');
+    expect(matched!.params).toStrictEqual({ '*': ['x2', 'yy3', 'zzz4'] });
+    expect(matched!.score).toStrictEqual([10, 3, 3, 3]);
+  });
+
+  it('enable strict mode', function () {
+    const matched = matchPath('/www.a.com/xx/yy', '/www.a.com/:x/:y/', { strictMode: true });
+    expect(matched).toBeNull();
+  });
+
+  it('multiple matched priority test1', function () {
+    const matched = matchPath('/www.a.com/aa/bb', ['/www.a.com/:x/:y', '/www.a.com/aa/:x']);
+    expect(matched?.params).toStrictEqual({ x: 'bb' });
+  });
+
+  it('multiple matched priority test2', function () {
+    const matched = matchPath('/www.a.com/abc/bcd', ['/www.a.com/:x/:y', '/www.a.com/abc/bcd', '/www.a.com/a/:x']);
+    expect(matched?.params).toEqual({});
+  });
+
+  it('multiple matched priority test3', function () {
+    const matched = matchPath('/www.a.com/abc/bcd', ['/www.a.com/:x/:y', '/www.a.com/a/b', '/www.a.com/a/:x']);
+    expect(matched?.params).toEqual({ x: 'abc', y: 'bcd' });
+  });
+
+  it('not match', function () {
+    const matched = matchPath('/www.b.com/a', '/www.a.com/a');
+    expect(matched).toBeNull();
+  });
+
+  it('wildcard match', () => {
+    const matched = matchPath('/www.a.com', '/*');
+    expect(matched).not.toBeNull();
+  });
+
+  it('wildcard match without slash', () => {
+    const matched = matchPath('/www.a.com', '*');
+    expect(matched).not.toBeNull();
+  });
+
+  it('wildcard match a slash', () => {
+    const matched = matchPath('/', '*');
+    expect(matched).not.toBeNull();
+    expect(matched?.isExact).toEqual(true);
+  });
+
+  it('partial matching', function () {
+    const parser = createPathParser('/www.a.com/a/*');
+    const matched = parser.parse('/www.a.com/a/bbb');
+    expect(matched !== null).toStrictEqual(true);
+    expect(matched!.params).toEqual({ '*': ['bbb'] });
+  });
+
+  it('url without end slash match wildcard', function () {
+    const parser = createPathParser('/about/', { strictMode: false });
+    const matched = parser.parse('/about');
+    expect(matched).toBeNull();
+  });
+
+  it('url without end slash match wildcard (strictMode)', function () {
+    const parser = createPathParser('/about/', { strictMode: true });
+    const matched = parser.parse('/about');
+    expect(matched).toBeNull();
+  });
+
+  it('exact match false', function () {
+    const parser = createPathParser('/about/', { strictMode: false, exact: false });
+    const matched = parser.parse('/about/abc');
+    expect(matched).not.toBeNull();
+  });
+
+  it('exact match true', function () {
+    const parser = createPathParser('/about/', { strictMode: false, exact: true });
+    const matched = parser.parse('/about/abc');
+    expect(matched).toBeNull();
+  });
+
+  it('exact false match', function () {
+    const parser = createPathParser('/about/', { strictMode: true, exact: false });
+    const matched = parser.parse('/about');
+    expect(matched).toBeNull();
+  });
+
+  it('exact false match2', function () {
+    const res = matchPath('/about1/aaa', '/about1/:a', { strictMode: true, exact: false });
+    expect(res).toEqual({
+      path: '/about1/:a',
+      url: '/about1/aaa',
+      isExact: true,
+      params: { a: 'aaa' },
+      score: [10, 6],
+    });
+  });
+
+  it('exact false match3', function () {
+    const res = matchPath('/about1/aaa/111', '/about1/:a', { strictMode: true, exact: false });
+    expect(res).toEqual({
+      path: '/about1/:a',
+      url: '/about1/aaa',
+      isExact: false,
+      params: { a: 'aaa' },
+      score: [10, 6],
+    });
+  });
+
+  it('exact false match4', function () {
+    const res = matchPath('/aaa111', '/aaa', { strictMode: true, exact: false });
+    expect(res).toBeNull();
+  });
+
+  it('exact false match5', function () {
+    const res = matchPath('/about/1111', '/about/', { strictMode: false, exact: false });
+    expect(res).toEqual({
+      path: '/about/',
+      url: '/about/',
+      isExact: false,
+      params: {},
+      score: [10],
+    });
+  });
+
+  it('matchPath special symbol', function () {
+    const res = matchPath('/about-home/1111', '/about-home/', { strictMode: false, exact: false });
+    expect(res).toEqual({
+      path: '/about-home/',
+      url: '/about-home/',
+      isExact: false,
+      params: {},
+      score: [10],
+    });
+  });
+
+  it('dynamic param with pattern', () => {
+    const parser = createPathParser('/detail/:action(info)');
+    const res = parser.parse('/detail/info/123');
+    expect(res).toEqual({
+      isExact: false,
+      path: '/detail/:action(info)',
+      url: '/detail/info',
+      score: [10, 6],
+      params: { action: 'info' },
+    });
+  });
+
+  it('dynamic param with regexp pattern', () => {
+    const parser = createPathParser('/detail/:action(\\d+)');
+    console.log(parser.regexp);
+    const res = parser.parse('/detail/123');
+    expect(res).toEqual({
+      isExact: true,
+      path: '/detail/:action(\\d+)',
+      url: '/detail/123',
+      score: [10, 6],
+      params: { action: '123' },
+    });
+  });
+
+  it('dynamic param with regexp pattern not exact', () => {
+    const parser = createPathParser('/detail/:action(\\d+)/pages', { exact: true });
+    const res = parser.parse('/detail/123/pages');
+    expect(res).toEqual({
+      isExact: true,
+      path: '/detail/:action(\\d+)/pages',
+      url: '/detail/123/pages',
+      score: [10, 6, 10],
+      params: { action: '123' },
+    });
+
+    const res1 = parser.parse('/detail/123/page');
+    expect(res1).toBeNull();
+  });
+
+  it('dynamic param with complex regexp pattern', () => {
+    const parser = createPathParser('/detail/:action([\\da-z]+)', { exact: true });
+    const res = parser.parse('/detail/a123');
+    expect(res).toEqual({
+      isExact: true,
+      path: '/detail/:action([\\da-z]+)',
+      url: '/detail/a123',
+      score: [10, 6],
+      params: { action: 'a123' },
+    });
+
+    const res1 = parser.parse('/detail/b123');
+    expect(res1).not.toBeNull();
+
+    const res2 = parser.parse('/detail/A123');
+    expect(res2).toBeNull();
+  });
+
+  it('wildcard param in centre', function () {
+    const parser = createPathParser('/a/b/*/:c/c');
+    const res = parser.parse('/a/b/d/x/yy/zzz/abc/c');
+    expect(res!.params).toEqual({
+      '*': ['d', 'x', 'yy', 'zzz'],
+      c: 'abc',
+    });
+  });
+});
diff --git a/packages/horizon-router/src/router/matcher/__tests__/utils.test.ts b/packages/horizon-router/src/router/matcher/__tests__/utils.test.ts
new file mode 100644
index 00000000..f837cd70
--- /dev/null
+++ b/packages/horizon-router/src/router/matcher/__tests__/utils.test.ts
@@ -0,0 +1,19 @@
+import { cleanPath, scoreCompare } from '../utils';
+
+describe('test for utils', () => {
+  it('cleanPath func test', () => {
+    const pattern = '/www.a.com//b//c';
+    const generated = cleanPath(pattern);
+    expect(generated).toBe('/www.a.com/b/c');
+  });
+
+  it('parse score compare1', function() {
+    const res = [[5], [10], [10, 5]].sort((a, b) => scoreCompare(a, b));
+    expect(res).toStrictEqual([[10, 5], [10], [5]]);
+  });
+
+  it('parse score compare2', function() {
+    const res = [[10], [10], [10, 5]].sort((a, b) => scoreCompare(a, b));
+    expect(res).toStrictEqual([[10, 5], [10], [10]]);
+  });
+});
diff --git a/packages/horizon-router/src/router/matcher/lexer.ts b/packages/horizon-router/src/router/matcher/lexer.ts
new file mode 100644
index 00000000..a31a2563
--- /dev/null
+++ b/packages/horizon-router/src/router/matcher/lexer.ts
@@ -0,0 +1,78 @@
+import { Token, TokenType } from './types';
+import { cleanPath } from './utils';
+
+const validChar = /[^/:*()]/;
+
+// 对Url模板进行词法解析，解析结果为Tokens
+export function lexer(path: string): Token[] {
+  const tokens: Token[] = [];
+
+  if (!path) {
+    return tokens;
+  }
+
+  let urlPath = cleanPath(path);
+  if (urlPath !== '*' && !urlPath.startsWith('/')) {
+    throw new Error(`Url must start with "/".`);
+  }
+
+  const getLiteral = () => {
+    let name = '';
+    while (i < urlPath.length && validChar.test(urlPath[i])) {
+      name += urlPath[i];
+      skipChar(1);
+    }
+    return name;
+  };
+
+  const skipChar = (step: number) => {
+    i += step;
+  };
+
+  let i = 0;
+  while (i < urlPath.length) {
+    const curChar = urlPath[i];
+    const prevChar = urlPath[i - 1];
+
+    if (curChar === '/') {
+      tokens.push({ type: TokenType.Delimiter, value: urlPath[i] });
+      skipChar(1);
+      continue;
+    }
+    // dynamic params (/:a)
+    if (prevChar === '/' && curChar === ':') {
+      skipChar(1);
+      tokens.push({ type: TokenType.Param, value: getLiteral() });
+      continue;
+    }
+    // wildCard params (/:*)
+    if ((prevChar === '/' || prevChar === undefined) && curChar === '*') {
+      tokens.push({ type: TokenType.WildCard, value: urlPath[i] });
+      skipChar(1);
+      continue;
+    }
+    // static params
+    if (prevChar === '/' && validChar.test(curChar)) {
+      tokens.push({ type: TokenType.Static, value: getLiteral() });
+      continue;
+    }
+    if (curChar === '(') {
+      tokens.push({ type: TokenType.LBracket, value: '(' });
+      skipChar(1);
+      continue;
+    }
+    if (curChar === ')') {
+      tokens.push({ type: TokenType.RBracket, value: ')' });
+      skipChar(1);
+      continue;
+    }
+    if (validChar.test(curChar)) {
+      tokens.push({ type: TokenType.Pattern, value: getLiteral() });
+      continue;
+    }
+    // 跳过非法字符
+    skipChar(1);
+  }
+
+  return tokens;
+}
diff --git a/packages/horizon-router/src/router/matcher/parser.ts b/packages/horizon-router/src/router/matcher/parser.ts
new file mode 100644
index 00000000..c1be4f99
--- /dev/null
+++ b/packages/horizon-router/src/router/matcher/parser.ts
@@ -0,0 +1,218 @@
+import { GetURLParams, Parser, ParserOption, TokenType } from './types';
+import { lexer } from './lexer';
+import { escapeStr, scoreCompare } from './utils';
+
+// 不同类型参数的匹配得分
+enum MatchScore {
+  // 固定参数
+  static = 10,
+  // 动态参数
+  param = 6,
+  // 通配符参数
+  wildcard = 3,
+  placeholder = -1,
+}
+
+export type Params<P> = { [K in keyof P]?: P[K] };
+
+// 兼容 react v5 matched类型
+export type Matched<P = any> = {
+  score: number[];
+  params: Params<P>;
+  path: string;
+  url: string;
+  isExact: boolean;
+};
+
+const defaultOption: Required<ParserOption> = {
+  // url匹配时是否大小写敏感
+  caseSensitive: true,
+  // 是否严格匹配url结尾的/
+  strictMode: false,
+  // 是否完全精确匹配
+  exact: false,
+};
+// 正则表达式中需要转义的字符
+const REGEX_CHARS_RE = /[.+*?^${}()[\]/\\]/g;
+// 用于匹配两个//中的的值
+const BASE_PARAM_PATTERN = '[^/]+';
+
+const DefaultDelimiter = '/#?';
+
+export function createPathParser<Str extends string>(pathname: Str, option?: ParserOption): Parser<GetURLParams<Str>>;
+export function createPathParser<P = unknown>(pathname: string, option?: ParserOption): Parser<P>;
+export function createPathParser<P = unknown>(pathname: string, option: ParserOption = defaultOption): Parser<P> {
+  const {
+    caseSensitive = defaultOption.caseSensitive,
+    strictMode = defaultOption.strictMode,
+    exact = defaultOption.exact,
+  } = option;
+  /**
+   * URL匹配整体流程
+   * 1.词法解析，将URL模板解析为Token
+   * 2.使用Token生成正则表达式
+   * 3.利用正则表达式解析URL中参数或填充URL模板
+   */
+  let pattern = '^';
+  const keys: string[] = [];
+  const scores: number[] = [];
+
+  const tokens = lexer(pathname);
+  const onlyHasWildCard = tokens.length === 1 && tokens[0].type === TokenType.WildCard;
+  const tokenCount = tokens.length;
+  const lastToken = tokens[tokenCount - 1];
+
+  for (let tokenIdx = 0; tokenIdx < tokenCount; tokenIdx++) {
+    const token = tokens[tokenIdx];
+    const nextToken = tokens[tokenIdx + 1];
+    switch (token.type) {
+      case TokenType.Delimiter:
+        pattern += '/';
+        break;
+      case TokenType.Static:
+        pattern += token.value.replace(REGEX_CHARS_RE, '\\$&');
+        scores.push(MatchScore.static);
+        break;
+      case TokenType.Param:
+        let paramRegexp = '';
+        if (nextToken && nextToken.type === TokenType.LBracket) {
+          // 跳过当前Token和左括号
+          tokenIdx += 2;
+          while (tokens[tokenIdx].type !== TokenType.RBracket) {
+            paramRegexp += tokens[tokenIdx].value;
+            tokenIdx++;
+          }
+        }
+        pattern += paramRegexp ? `((?:${paramRegexp}))` : `(${BASE_PARAM_PATTERN})`;
+        keys.push(token.value);
+        scores.push(MatchScore.param);
+        break;
+      case TokenType.WildCard:
+        keys.push(token.value);
+        pattern += `((?:${BASE_PARAM_PATTERN})${onlyHasWildCard ? '?' : ''}(?:/(?:${BASE_PARAM_PATTERN}))*)`;
+        scores.push(onlyHasWildCard ? MatchScore.wildcard : MatchScore.placeholder);
+        break;
+    }
+  }
+  const isWildCard = lastToken.type === TokenType.WildCard;
+
+  if (!isWildCard && !exact) {
+    if (!strictMode) {
+      pattern += `(?:[${escapeStr(DefaultDelimiter)}](?=$))?`;
+    }
+    if (lastToken.type !== TokenType.Delimiter) {
+      pattern += `(?=[${escapeStr(DefaultDelimiter)}]|$)`;
+    }
+  } else {
+    pattern += strictMode ? '$' : `[${escapeStr(DefaultDelimiter)}]?$`;
+  }
+
+  const flag = caseSensitive ? '' : 'i';
+  const regexp = new RegExp(pattern, flag);
+
+  /**
+   * @description 根据给定Pattern解析path
+   */
+  function parse(path: string): Matched<P> | null {
+    const reMatch = path.match(regexp);
+
+    if (!reMatch) {
+      return null;
+    }
+    const matchedPath = reMatch[0];
+    let params: Params<P> = {};
+    let parseScore: number[] = Array.from(scores);
+    for (let i = 1; i < reMatch.length; i++) {
+      let param = reMatch[i];
+      let key = keys[i - 1];
+      if (key === '*' && param) {
+        let value = param.split('/');
+        if (!Array.isArray(params['*'])) {
+          params['*'] = value;
+        } else {
+          params['*'].push(...value);
+        }
+        // 完成通配符参数解析后将placeholder替换为wildcard参数的分值
+        parseScore.splice(
+          scores.indexOf(MatchScore.placeholder),
+          1,
+          ...new Array(value.length).fill(MatchScore.wildcard),
+        );
+      } else {
+        params[key] = param ? param : [];
+      }
+    }
+
+    const isExact = path === matchedPath;
+    const url = path === '/' && matchedPath === '' ? '/' : matchedPath;
+    return { isExact: isExact, path: pathname, url: url, score: parseScore, params: params };
+  }
+
+  /**
+   * @description 使用给定参数填充pattern，得到目标URL
+   */
+  function compile(params: Params<P>): string {
+    let path = '';
+    for (const token of tokens) {
+      switch (token.type) {
+        case TokenType.Static:
+          path += token.value;
+          break;
+        case TokenType.Param:
+          if (!params[token.value]) {
+            throw new Error('Param is invalid.');
+          }
+          path += params[token.value];
+          break;
+        case TokenType.WildCard:
+          let wildCard = params['*'];
+          if (wildCard instanceof Array) {
+            path += wildCard.join('/');
+          } else {
+            path += wildCard;
+          }
+          break;
+        case TokenType.Delimiter:
+          path += token.value;
+          break;
+      }
+    }
+    return path;
+  }
+
+  return {
+    get regexp() {
+      return regexp;
+    },
+    get keys() {
+      return keys;
+    },
+    compile,
+    parse,
+  };
+}
+
+/**
+ * @description 依次使用pathname与pattern进行匹配，根据匹配分数取得分数最高结果
+ */
+export function matchPath<P = any>(
+  pathname: string,
+  pattern: string | string[],
+  option?: ParserOption,
+): Matched<P> | null {
+  const patterns = Array.isArray(pattern) ? [...pattern] : [pattern];
+  const matchedResults: Matched<P>[] = [];
+  for (const item of patterns) {
+    const parser = createPathParser(item, option);
+    const matched = parser.parse(pathname);
+    if (matched) {
+      matchedResults.push(matched);
+    }
+  }
+  return !matchedResults.length ? null : matchedResults.sort((a, b) => scoreCompare(a.score, b.score))[0];
+}
+
+export function generatePath<P = any>(path: string, params: Params<P>) {
+  const parser = createPathParser(path);
+  return parser.compile(params);
+}
\ No newline at end of file
diff --git a/packages/horizon-router/src/router/matcher/types.ts b/packages/horizon-router/src/router/matcher/types.ts
new file mode 100644
index 00000000..5367fd6c
--- /dev/null
+++ b/packages/horizon-router/src/router/matcher/types.ts
@@ -0,0 +1,55 @@
+import { Matched, Params } from './parser';
+
+export type Token = {
+  type: TokenType;
+  value: string;
+};
+
+export enum TokenType {
+  Delimiter = 'delimiter',
+  Static = 'static',
+  Param = 'param',
+  WildCard = 'wildcard',
+  LBracket = '(',
+  RBracket = ')',
+  Pattern = 'pattern',
+}
+
+export interface Parser<P> {
+  regexp: RegExp;
+
+  keys: string[];
+
+  parse(url: string): Matched<P> | null;
+
+  compile(params: Params<P>): string;
+}
+
+export type ParserOption = {
+  // 是否大小写敏感
+  caseSensitive?: boolean;
+  // 是否启用严格模式
+  strictMode?: boolean;
+  // 精准匹配 兼容 React-RouterV5
+  exact?: boolean;
+};
+
+type ClearLeading<U extends string> = U extends `/${infer R}` ? ClearLeading<R> : U;
+type ClearTailing<U extends string> = U extends `${infer L}/` ? ClearTailing<L> : U;
+
+type ParseParam<Param extends string> = Param extends `:${infer R}`
+  ? {
+    [K in R]: string;
+  }
+  : {};
+
+type MergeParams<OneParam extends Record<string, any>, OtherParam extends Record<string, any>> = {
+  readonly [Key in keyof OneParam | keyof OtherParam]?: string;
+};
+
+type ParseURLString<Str extends string> = Str extends `${infer Param}/${infer Rest}`
+  ? MergeParams<ParseParam<Param>, ParseURLString<ClearLeading<Rest>>>
+  : ParseParam<Str>;
+
+// 解析URL中的动态参数，以实现TypeScript提示功能
+export type GetURLParams<U extends string> = ParseURLString<ClearLeading<ClearTailing<U>>>;
diff --git a/packages/horizon-router/src/router/matcher/utils.ts b/packages/horizon-router/src/router/matcher/utils.ts
new file mode 100644
index 00000000..14cc6179
--- /dev/null
+++ b/packages/horizon-router/src/router/matcher/utils.ts
@@ -0,0 +1,27 @@
+/**
+ * @description 将url中的//转换为/
+ */
+export function cleanPath(path: string): string {
+  return path.replace(/\/+/g, '/');
+}
+
+export function scoreCompare(score1: number[], score2: number[]): number {
+  const score1Length = score1.length;
+  const score2Length = score2.length;
+  const end = Math.min(score1Length, score2Length);
+  for (let i = 0; i < end; i++) {
+    const delta = score2[i] - score1[i];
+    if (delta !== 0) {
+      return delta;
+    }
+  }
+  if (score1Length === score2Length) {
+    return 0;
+  }
+  return score1Length > score2Length ? -1 : 1;
+}
+
+// 把正则表达式的特殊符号加两个反斜杠进行转义
+export function escapeStr(str: string) {
+  return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, '\\$1');
+}
diff --git a/packages/horizon-router/src/router/withRouter.tsx b/packages/horizon-router/src/router/withRouter.tsx
new file mode 100644
index 00000000..824ffbc7
--- /dev/null
+++ b/packages/horizon-router/src/router/withRouter.tsx
@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { useContext } from 'react';
+import RouterContext from './context';
+
+function withRouter<C extends React.ComponentType>(Component: C) {
+
+  function ComponentWithRouterProp(props: any) {
+    const { history, location, match } = useContext(RouterContext);
+    const routeProps = { history: history, location: location, match: match };
+
+    return <Component {...props} {...routeProps} />;
+  }
+
+  return ComponentWithRouterProp;
+}
+
+export default withRouter;
\ No newline at end of file
diff --git a/packages/horizon-router/tsconfig.json b/packages/horizon-router/tsconfig.json
new file mode 100644
index 00000000..46985632
--- /dev/null
+++ b/packages/horizon-router/tsconfig.json
@@ -0,0 +1,38 @@
+{
+  "compilerOptions": {
+    "outDir": "./build",
+    "incremental": false,
+    "sourceMap": true,
+    "allowJs": true, // allowJs=true => tsc compile js as module, no type check
+    "checkJs": false, // Disable ts error checking in js
+    "strict": true, // js-ts mixed setting
+    "noImplicitReturns": true,
+    "noUnusedLocals": false,  // 等大部分js代码改成ts之后再启用.
+    "noUnusedParameters": false,
+    "noImplicitAny": false,
+    "noImplicitThis": true,
+    "module": "CommonJS",
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node",
+    "target": "es5",
+    "jsx": "react",
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true,
+    "allowUnreachableCode": true,
+    "alwaysStrict": true,
+    "esModuleInterop": true,
+    "declaration": true,
+    "experimentalDecorators": true,
+    "downlevelIteration": true,
+    "types": ["jest"], // 赋值为空数组使@types/node不会起作用
+    "lib": ["dom", "esnext", "ES2015", "ES2016", "ES2017", "ES2018", "ES2019", "ES2020"],
+    "baseUrl": ".",
+    "rootDir": "./src",
+    "strictNullChecks": true
+  },
+  "include": [
+    "./src/*/*.ts",
+  ],
+  "exclude": ["node_modules", "**/*.spec.ts", "dev"],
+}