新增vuex,router

node_modules/uni-read-pages/README.md

@@ -0,0 +1,108 @@
+# uni-read-pages
+
+![coverage](https://img.shields.io/badge/coverage%20-98%25-green) ![npm](https://img.shields.io/badge/npm%20-v2.6.11-blue) ![license](https://img.shields.io/badge/license-MIT-red) ![size](https://img.shields.io/badge/size-1.48%20kb-yellowgreen)
+
+通过 [vue.config.js](https://cli.vuejs.org/zh/config/) 配合此库，可以随心所欲的读取 `pages.json` 下的所有配置
+
+## 安装
+
+您可以使用 `Yarn` 或 `npm` 安装该软件包（选择一个）：
+
+##### Yarn
+
+```sh
+yarn add uni-read-pages
+```
+##### npm
+
+```sh
+npm install uni-read-pages
+```
+## 开始
+配置 `vue.config.js` 通过 `webpack` 注入全局变量 [查看文档](https://www.webpackjs.com/plugins/define-plugin/)
+
+#### 配置 `vue.config.js`
+```js
+//vue.config.js
+const TransformPages = require('uni-read-pages')
+const tfPages = new TransformPages()
+module.exports = {
+    configureWebpack: {
+        plugins: [
+            new tfPages.webpack.DefinePlugin({
+                ROUTES: JSON.stringify(tfPages.routes)
+            })
+        ]
+    }
+}
+```
+借助`webpack.DefinePlugin` 轻松注入全局变量。`ROUTES` 及可全局使用
+
+#### 使用
+```js
+// xxx.vue
+<script>
+export default {
+    data() {
+        return {
+            title: 'Hello'
+        }
+    },
+    onLoad() {
+        console.log(ROUTES)
+    },
+}
+</script>
+```
+## API
+#### options
+```js
+//默认值
+const CONFIG={
+    cli:false,      //当前是否为脚手架初始化的项目
+    includes:['path','aliasPath','name']	    //需要获取包涵的字段
+}
+```
+
+#### Instance method
+
+* **getPagesRoutes**
+    * 通过读取 `pages.json` 文件 生成直接可用的routes
+
+* **parsePages(pageCallback, subPageCallback)**
+    * 单条page对象解析
+
+* **resolvePath(dir)**
+    * 解析绝对路径
+
+#### Instance attr
+
+* **CONFIG**
+    * 当前配置项
+
+* **webpack**
+    * 当前工程下需要用到 `webpack`
+
+* **uniPagesJSON**
+    * 当前 `uni-app` 内置对象，可以通过此属性调用一些内置方法
+
+* **routes**
+    * 通过 **includes** 解析后得到的路由表 **可直接使用**
+
+#### getter
+
+* **pagesJson**
+    * 获取所有 `pages.json` 下的内容 返回 `json`
+
+
+#### uniPagesJSON method
+
+* getMainEntry()
+* getNVueMainEntry()
+* parsePages (pagesJson, pageCallback, subPageCallback)
+* parseEntry (pagesJson)
+* getPagesJson()
+* parsePagesJson (content, loader)
+
+#### uniPagesJSON attr
+* pagesJsonJsFileName //默认值 pages.js

node_modules/uni-read-pages/index.js

@@ -0,0 +1,83 @@
+const path = require('path')
+const CONFIG = {
+	includes: ['path', 'aliasPath', 'name']
+}
+const rootPath = path.resolve(process.cwd(), 'node_modules');
+
+/** 解析绝对路径
+ * @param {Object} dir 
+ */
+function resolvePath(dir) {
+	return path.resolve(rootPath, dir);
+}
+
+class TransformPages {
+	constructor(config) {
+		config = {
+			...CONFIG,
+			...config
+		};
+		this.CONFIG = config;
+		this.webpack = require(resolvePath('webpack'));
+		this.uniPagesJSON = require(resolvePath('@dcloudio/uni-cli-shared/lib/pages.js'));
+		this.routes = this.getPagesRoutes().concat(this.getNotMpRoutes());
+	}
+	/**
+	 * 获取所有pages.json下的内容 返回json
+	 */
+	get pagesJson() {
+		return this.uniPagesJSON.getPagesJson();
+	}
+	/**
+	 * 通过读取pages.json文件 生成直接可用的routes
+	 */
+	getPagesRoutes(pages = this.pagesJson.pages, rootPath = null) {
+		const routes = [];
+		for (let i = 0; i < pages.length; i++) {
+			const item = pages[i];
+			const route = {};
+			for (let j = 0; j < this.CONFIG.includes.length; j++) {
+				const key = this.CONFIG.includes[j];
+				let value = item[key];
+				if (key === 'path') {
+					value = rootPath ? `/${rootPath}/${value}` : `/${value}`
+				}
+				if (key === 'aliasPath' && i == 0 && rootPath == null) {
+					route[key] = route[key] || '/'
+				} else if (value !== undefined) {
+					route[key] = value;
+				}
+			}
+			routes.push(route);
+		}
+		return routes;
+	}
+	/**
+	 * 解析小程序分包路径
+	 */
+	getNotMpRoutes() {
+		const {
+			subPackages
+		} = this.pagesJson;
+		let routes = [];
+		if (subPackages == null || subPackages.length == 0) {
+			return [];
+		}
+		for (let i = 0; i < subPackages.length; i++) {
+			const subPages = subPackages[i].pages;
+			const root = subPackages[i].root;
+			const subRoutes = this.getPagesRoutes(subPages, root);
+			routes = routes.concat(subRoutes)
+		}
+		return routes
+	}
+	/**
+	 * 单条page对象解析
+	 * @param {Object} pageCallback 
+	 * @param {Object} subPageCallback
+	 */
+	parsePages(pageCallback, subPageCallback) {
+		this.uniPagesJSON.parsePages(this.pagesJson, pageCallback, subPageCallback)
+	}
+}
+module.exports = TransformPages

node_modules/uni-read-pages/package.json

@@ -0,0 +1,51 @@
+{
+  "_from": "uni-read-pages",
+  "_id": "uni-read-pages@1.0.5",
+  "_inBundle": false,
+  "_integrity": "sha512-GkrrZ0LX0vn9R5k6RKEi0Ez3Q3e2vUpjXQ8Z6/K/d28KudI9ajqgt8WEjQFlG5EPm1K6uTArN8LlqmZTEixDUA==",
+  "_location": "/uni-read-pages",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "tag",
+    "registry": true,
+    "raw": "uni-read-pages",
+    "name": "uni-read-pages",
+    "escapedName": "uni-read-pages",
+    "rawSpec": "",
+    "saveSpec": null,
+    "fetchSpec": "latest"
+  },
+  "_requiredBy": [
+    "#USER",
+    "/"
+  ],
+  "_resolved": "https://registry.npmjs.org/uni-read-pages/-/uni-read-pages-1.0.5.tgz",
+  "_shasum": "452c8dcaa8977bbaef600909be926c8d9704387c",
+  "_spec": "uni-read-pages",
+  "_where": "/Users/WebTmm/Desktop/ZhHealth",
+  "author": "",
+  "bugs": {
+    "url": "https://github.com/SilurianYang/uni-read-pages/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "read `pages.json` file to generate the routes table",
+  "directories": {
+    "example": "examples"
+  },
+  "homepage": "https://github.com/SilurianYang/uni-read-pages#readme",
+  "keywords": [],
+  "license": "ISC",
+  "main": "index.js",
+  "name": "uni-read-pages",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SilurianYang/uni-read-pages.git"
+  },
+  "scripts": {
+    "build": "webpack --progress --config webpack/webpack.prod.js",
+    "dev": "webpack --watch  --progress --config webpack/webpack.dev.js",
+    "postinstall": "node -e \"console.log('\\x1b[91m','\\n\\n uni-simple-router 垫脚片，欢迎下载！\\n \\n 开源不易，需要鼓励。去给 uni-read-pages 项目 点个 star 吧 \\n\\n')\""
+  },
+  "version": "1.0.5"
+}

node_modules/uni-simple-router/.eslintignore

@@ -0,0 +1,6 @@
+dist
+/node_modules
+/webpack
+/src/global.d.ts
+/test
+/jest.config.js

node_modules/uni-simple-router/.eslintrc.js

@@ -0,0 +1,257 @@
+module.exports = {
+    root: true,
+    env: {
+        browser: true,
+        node: true,
+        es6: true
+    },
+    globals: {
+        uni: true,
+        plus: true,
+        getCurrentPages: true,
+        getApp: true,
+        __uniConfig: true,
+        __uniRoutes: true,
+        $npm_package_name: true
+    },
+    parser: '@typescript-eslint/parser',
+    extends: ['eslint:recommended'],
+    plugins: ['@typescript-eslint'],
+    rules: {
+        '@typescript-eslint/consistent-type-definitions': [
+            'error',
+            'interface'
+        ],
+        'accessor-pairs': 2,
+        'arrow-spacing': [
+            2,
+            {
+                before: true,
+                after: true
+            }
+        ],
+        'block-spacing': [2, 'always'],
+        'brace-style': [
+            2,
+            '1tbs',
+            {
+                allowSingleLine: true
+            }
+        ],
+        camelcase: [
+            0,
+            {
+                properties: 'always'
+            }
+        ],
+        'comma-dangle': [2, 'never'],
+        'comma-spacing': [
+            2,
+            {
+                before: false,
+                after: true
+            }
+        ],
+        'comma-style': [2, 'last'],
+        'constructor-super': 2,
+        curly: [2, 'multi-line'],
+        'dot-location': [2, 'property'],
+        'eol-last': 2,
+        eqeqeq: ['error', 'always', {null: 'ignore'}],
+        'generator-star-spacing': [
+            2,
+            {
+                before: true,
+                after: true
+            }
+        ],
+        'handle-callback-err': [2, '^(err|error)$'],
+        indent: ['error', 4],
+        'jsx-quotes': [2, 'prefer-single'],
+        'key-spacing': [
+            2,
+            {
+                beforeColon: false,
+                afterColon: true
+            }
+        ],
+        'keyword-spacing': [
+            2,
+            {
+                before: true,
+                after: true
+            }
+        ],
+        'new-cap': [
+            2,
+            {
+                newIsCap: true,
+                capIsNew: false
+            }
+        ],
+        'new-parens': 2,
+        'no-array-constructor': 2,
+        'no-caller': 2,
+        'no-console': 'off',
+        'no-class-assign': 2,
+        'no-cond-assign': 2,
+        'no-const-assign': 2,
+        'no-control-regex': 0,
+        'no-delete-var': 2,
+        'no-dupe-args': 2,
+        'no-dupe-class-members': 2,
+        'no-dupe-keys': 2,
+        'no-duplicate-case': 2,
+        'no-empty-character-class': 2,
+        'no-empty-pattern': 2,
+        'no-eval': 2,
+        'no-ex-assign': 2,
+        'no-extend-native': 2,
+        'no-extra-bind': 2,
+        'no-extra-boolean-cast': 2,
+        'no-extra-parens': [2, 'functions'],
+        'no-fallthrough': 2,
+        'no-floating-decimal': 2,
+        'no-func-assign': 2,
+        'no-implied-eval': 2,
+        'no-inner-declarations': [2, 'functions'],
+        'no-invalid-regexp': 2,
+        'no-irregular-whitespace': 2,
+        'no-iterator': 2,
+        'no-label-var': 2,
+        'no-labels': [
+            2,
+            {
+                allowLoop: false,
+                allowSwitch: false
+            }
+        ],
+        'no-lone-blocks': 2,
+        'no-mixed-spaces-and-tabs': 2,
+        'no-multi-spaces': 2,
+        'no-multi-str': 2,
+        'no-multiple-empty-lines': [
+            2,
+            {
+                max: 1
+            }
+        ],
+        'no-native-reassign': 2,
+        'no-negated-in-lhs': 2,
+        'no-new-object': 2,
+        'no-new-require': 2,
+        'no-new-symbol': 2,
+        'no-new-wrappers': 2,
+        'no-obj-calls': 2,
+        'no-octal': 2,
+        'no-octal-escape': 2,
+        'no-path-concat': 2,
+        'no-proto': 2,
+        'no-redeclare': 2,
+        'no-regex-spaces': 2,
+        'no-return-assign': [2, 'except-parens'],
+        'no-self-assign': 2,
+        'no-self-compare': 2,
+        'no-sequences': 2,
+        'no-shadow-restricted-names': 2,
+        'no-spaced-func': 2,
+        'no-sparse-arrays': 2,
+        'no-this-before-super': 2,
+        'no-throw-literal': 2,
+        'no-trailing-spaces': 2,
+        'no-undef': 2,
+        'no-undef-init': 2,
+        'no-unexpected-multiline': 2,
+        'no-unmodified-loop-condition': 2,
+        'no-unneeded-ternary': [
+            2,
+            {
+                defaultAssignment: false
+            }
+        ],
+        'no-unreachable': 2,
+        'no-unsafe-finally': 2,
+        'no-unused-vars': [
+            2,
+            {
+                vars: 'all',
+                args: 'none'
+            }
+        ],
+        'no-useless-call': 2,
+        'no-useless-computed-key': 2,
+        'no-useless-constructor': 2,
+        'no-useless-escape': 0,
+        'no-whitespace-before-property': 2,
+        'no-with': 2,
+        'one-var': [
+            2,
+            {
+                initialized: 'never'
+            }
+        ],
+        'operator-linebreak': [
+            2,
+            'after',
+            {
+                overrides: {
+                    '?': 'before',
+                    ':': 'before'
+                }
+            }
+        ],
+        'padded-blocks': [2, 'never'],
+        quotes: [
+            2,
+            'single',
+            {
+                avoidEscape: true,
+                allowTemplateLiterals: true
+            }
+        ],
+        semi: 'off',
+        'semi-spacing': [
+            2,
+            {
+                before: false,
+                after: true
+            }
+        ],
+        'space-before-blocks': [2, 'always'],
+        'space-before-function-paren': [2, 'never'],
+        'space-in-parens': [2, 'never'],
+        'space-infix-ops': 2,
+        'space-unary-ops': [
+            2,
+            {
+                words: true,
+                nonwords: false
+            }
+        ],
+        'spaced-comment': [
+            2,
+            'always',
+            {
+                markers: [
+                    'global',
+                    'globals',
+                    'eslint',
+                    'eslint-disable',
+                    '*package',
+                    '!',
+                    ','
+                ]
+            }
+        ],
+        'template-curly-spacing': [2, 'never'],
+        'use-isnan': 2,
+        'valid-typeof': 2,
+        'wrap-iife': [2, 'any'],
+        'yield-star-spacing': [2, 'both'],
+        yoda: [2, 'never'],
+        'prefer-const': 2,
+        'no-debugger': process.env.NODE_ENV === 'production' ? 2 : 0,
+        'object-curly-spacing': 'off',
+        'array-bracket-spacing': [2, 'never']
+    }
+};

node_modules/uni-simple-router/.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,39 @@
+---
+name: 报告问题（Bug report）
+about: 详细描述你遇到的问题并寻求社区帮助
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**问题描述**
+[问题描述：尽可能简洁清晰地把问题描述清楚]
+
+**复现步骤**
+[复现问题的步骤]
+1. 启动 '...'
+2. 点击  '....'
+3. 查看
+
+[或者可以直接贴源代码]
+
+**预期结果**
+[使用简洁清晰的语言描述你希望生效的预期结果]
+
+**实际结果**
+[这里请贴上你的报错截图或文字]
+
+
+**系统信息:**
+ - 发行平台: [如 微信小程序、H5平台、5+ App等]
+ - 操作系统 [如 iOS 12.1.2、Android 7.0]
+ - HBuilderX版本 [如使用HBuilderX，则需提供 HBuilderX 版本号]
+ - 项目创建方法 [如使用Vue-cli创建/HBuilderX]
+ - 设备信息 [如 iPhone8 Plus]
+ - uni-simple-router版本 [如 v1.5.4]
+
+
+**补充信息**
+[可选]
+[根据你的分析，出现这个问题的原因可能在哪里？]

node_modules/uni-simple-router/.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,21 @@
+---
+name: 建议新功能（Feature Request）
+about: 对 uni-simple-router 提出改善建议
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**新功能描述**
+简洁描述你希望补充完善的增强功能
+
+**现状及问题**
+[当前现状及由此导致的不便]
+
+**尝试方案**
+[如果你有尝试绕开或其它解决方案，在这里描述你的建议方案]
+
+**补充信息**
+[其它你认为有参考价值的信息]
+

node_modules/uni-simple-router/CODE_OF_CONDUCT.md

@@ -0,0 +1,76 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+ advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+ address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+ professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at 1606726660@qq.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq

node_modules/uni-simple-router/LICENSE

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

node_modules/uni-simple-router/README.md

@@ -0,0 +1,49 @@
+# uni-simple-router
+
+> 一个更为简洁的[Vue-router](https://router.vuejs.org/zh/)，专为 [uni-app](https://uniapp.dcloud.io/) 量身打造
+
+## 介绍
+
+`uni-simple-router` 是专为 [uni-app](https://uniapp.dcloud.io/) 打造的路由器。它与 [uni-app](https://uniapp.dcloud.io/) 核心深度集成，使使用 [uni-app](https://uniapp.dcloud.io/) 轻松构建单页应用程序变得轻而易举。功能包括：
+
+* `H5端` 能完全使用 `vue-router` 进行开发。
+
+* 模块化，基于组件的路由器配置。
+
+* 路由参数，查询，通配符。
+
+* `H5端` 查看由 `uni-simple-router` 过渡系统提供动力的过渡效果。
+
+* 更细粒度的导航控制。
+
+* `H端`自动控制活动的CSS类链接。
+
+* 通配小程序端、APP端、H5端。
+
+
+开始使用 [查看文档](http://hhyang.cn)，或 [使用示例](https://github.com/SilurianYang/uni-simple-router/tree/master/examples)（请参见下面的示例）。
+
+## 问题
+在提交问题的之前，请确保阅读 [“问题报告清单”](https://github.com/SilurianYang/uni-simple-router/issues/new?assignees=&labels=&template=bug_report.md&title=) 。不符合准则的问题可能会立即被解决。
+
+## 贡献
+提出拉取请求之前，请务必先阅读 [查看文档](http://hhyang.cn)（请参见下面的示例）。。
+
+## 变更日志
+[发行说明](https://github.com/SilurianYang/uni-simple-router/releases) 中记录了每个发行版的详细信息更改。
+
+## 特别感谢
+
+特别感谢 [markrgba](https://github.com/markrgba) 一直以来对文档和相关测试的维护。
+
+## 技术交流
+
+<a target="_blank" href="//shang.qq.com/wpa/qunwpa?idkey=0f4d7f38e5d15dd49bf7c3032c80ed3f54ecfa3dd800053d6ae145c869f9eb47"><img border="0" src="http://pub.idqqimg.com/wpa/images/group.png" alt="uni-app  插件" title="uni-app  插件"></a>
+
+
+## 成品预览
+
+<div style="display: -webkit-box;display: flex; flex-direction: column;align-items: center;">
+    <p style="color: #3eaf7c;font-size:18px">uni-simple-router@2.0+ts+uni-app</p>
+    <img src="https://hhyang.cn/images/ad1.jpg" width="200" height="200">
+</div>

node_modules/uni-simple-router/RFC.md

@@ -0,0 +1,38 @@
+```flow
+
+st=>start: 开始跳转
+e=>end: 跳转结束
+platform=>operation: 平台选择
+H5=>condition: H5
+APP=>condition: APP
+applets=>condition: 小程序
+routerBeforeEach=>operation: routerBeforeEach
+lock=>condition: 跳转加锁
+
+runH5=>operation: H5
+runAPP=>parallel: APP
+runapplets=>parallel: 小程序
+
+beforeRouteLeave=>condition: beforeRouteLeave
+beforeEach=>condition: beforeEach 
+beforeEnter=>condition: beforeEnter
+afterEach=>operation: afterEach
+runJump=>condition: 执行跳转成功或者失败
+stopJump=>operation: next(false) 停止跳转
+errorJump=>operation: 跳转失败
+routerErrorEach=>operation: routerErrorEach
+routerAfterEach=>operation: routerAfterEach
+
+st->platform(right)->applets(yes)->routerBeforeEach
+applets(no)->APP(yes)->routerBeforeEach
+APP(no)->H5(yes)->routerBeforeEach
+routerBeforeEach->lock(yes)->runAPP(path1)->runapplets(path1)->beforeRouteLeave
+lock(no)->runH5->beforeRouteLeave(no)->stopJump->routerErrorEach
+beforeRouteLeave(yes)->beforeEach(no)->stopJump->routerErrorEach
+beforeEach(yes)->beforeEnter(no)->stopJump->routerErrorEach
+beforeEnter(yes)->runJump(no)->errorJump->routerErrorEach
+runJump(yes)->afterEach->routerAfterEach
+routerAfterEach->e
+routerErrorEach->e
+
+```

node_modules/uni-simple-router/api-extractor.json

@@ -0,0 +1,50 @@
+// this the shared base config for all packages.
+{
+    "$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
+  
+    "mainEntryPointFilePath": "./dist/src/index.d.ts",
+  
+    "apiReport": {
+      "enabled": true,
+      "reportFolder": "./temp/"
+    },
+  
+    "docModel": {
+      "enabled": true
+    },
+  
+    "dtsRollup": {
+      "enabled": true,
+      "untrimmedFilePath": "./dist/<unscopedPackageName>.d.ts"
+    },
+  
+    "tsdocMetadata": {
+      "enabled": false
+    },
+  
+    "messages": {
+      "compilerMessageReporting": {
+        "default": {
+          "logLevel": "warning"
+        }
+      },
+  
+      "extractorMessageReporting": {
+        "default": {
+          "logLevel": "warning",
+          "addToApiReportFile": true
+        },
+  
+        "ae-missing-release-tag": {
+          "logLevel": "none"
+        }
+      },
+  
+      "tsdocMessageReporting": {
+        "default": {
+          "logLevel": "warning"
+        }
+      }
+    }
+  }
+  

node_modules/uni-simple-router/dist/link.vue

@@ -0,0 +1,79 @@
+<template>
+    <view @click="gotoPage()"><slot></slot></view>
+</template>
+
+<script>
+const navType = {
+    push: 'push',
+    replace: 'replace',
+    replaceAll: 'replaceAll',
+    pushTab: 'pushTab',
+    back:'back'
+};
+export default {
+    props: {
+        to: {
+            type: [String, Object],
+            required: true
+        },
+        stopNavto: {
+            type: Boolean,
+            default: false,
+        },
+        navType: {
+            type: String,
+            default: 'push',
+        },
+        level: {
+            type: Number,
+            default: 1,
+        },
+        append: {
+            type: Boolean,
+            default: false,
+        },
+    },
+    methods: {
+        formatNav(text) {
+            if (text != null && text.constructor === String) {
+                text = text.replace(/\'/g, '');
+                text = text.replace(/(\w+)(?=:)/g, function (val) {
+                    return `"${val}"`;
+                });
+                text = text.replace(/:\s*([^,{}\s"]+)/g, function (val) {
+                    const arr = val.split(':');
+                    return `:"${arr[1].trim()}"`;
+                });
+                try {
+                    text = JSON.parse(text);
+                } catch (e) {}
+            }
+            if (this.append) {
+                let pathArr = this.$Route.path.split('/');
+                pathArr.splice(pathArr.length - this.level, this.level);
+                pathArr = pathArr.join('/');
+                if (text.constructor === Object) {
+                    if (text.path) {
+                        text.path = pathArr + text.path;
+                    }
+                } else {
+                    text = pathArr + text;
+                }
+            }
+            return text;
+        },
+        gotoPage() {
+            if (this.stopNavto) {
+                return true;
+            }
+            const type = navType[this.navType];
+            if (type == null) {
+                return console.error(` "navType" unknown type \n\n value：${Object.values(navType).join('、')}`);
+            }
+            const navInfo = this.formatNav(this.to);
+
+            this.$Router[type](navInfo);
+        },
+    },
+};
+</script>

node_modules/uni-simple-router/dist/uni-simple-router.d.ts

@@ -0,0 +1,312 @@
+
+export declare interface AppConfig {
+    registerLoadingPage?: boolean;
+    loadingPageStyle?: () => object;
+    loadingPageHook?: (view: any) => void;
+    launchedHook?: () => void;
+    animation?: startAnimationRule;
+}
+
+export declare interface appletConfig {
+    animationDuration?: number;
+}
+
+export declare type backTypeRule = 'backbutton' | 'navigateBack';
+
+export declare function createRouter(params: InstantiateConfig): Router;
+
+export declare interface debuggerArrayConfig {
+    error?: boolean;
+    warn?: boolean;
+    log?: boolean;
+}
+
+export declare type debuggerConfig = boolean | debuggerArrayConfig;
+
+export declare interface endAnimationRule {
+    animationType?: endAnimationType;
+    animationDuration?: number;
+}
+
+export declare type endAnimationType = 'slide-out-right' | 'slide-out-left' | 'slide-out-top' | 'slide-out-bottom' | 'pop-out' | 'fade-out' | 'zoom-in' | 'zoom-fade-in' | 'none';
+
+export declare type guardHookRule = (to: totalNextRoute, from: totalNextRoute, next: (rule?: navtoRule | false) => void) => void;
+
+export declare interface H5Config {
+    paramsToQuery?: boolean;
+    vueRouterDev?: boolean;
+    vueNext?: boolean;
+    mode?: string;
+    base?: string;
+    linkActiveClass?: string;
+    linkExactActiveClass?: string;
+    scrollBehavior?: Function;
+    fallback?: boolean;
+}
+
+export declare interface h5NextRule {
+    fullPath?: string | undefined;
+    hash?: string | undefined;
+    matched?: Array<object>;
+    meta?: object;
+    name?: undefined | string;
+    type?: undefined | string;
+}
+
+export declare type hookListRule = Array<(router: Router, to: totalNextRoute, from: totalNextRoute, toRoute: RoutesRule, next: Function) => void>;
+
+export declare interface hookObjectRule {
+    options: Array<any>;
+    hook: Function;
+}
+
+export declare enum hookToggle {
+    'beforeHooks' = "beforeEach",
+    'afterHooks' = "afterEach",
+    'enterHooks' = "beforeEnter"
+}
+
+export declare interface InstantiateConfig {
+    [key: string]: any;
+    keepUniOriginNav?: boolean;
+    platform: platformRule;
+    h5?: H5Config;
+    APP?: AppConfig;
+    applet?: appletConfig;
+    debugger?: debuggerConfig;
+    routerBeforeEach?: (to: navtoRule, from: navtoRule, next: (rule?: navtoRule | false) => void) => void;
+    routerAfterEach?: (to: navtoRule, from: navtoRule, next?: Function) => void;
+    routerErrorEach?: (error: navErrorRule, router: Router) => void;
+    resolveQuery?: (jsonQuery: objectAny) => objectAny;
+    parseQuery?: (jsonQuery: objectAny) => objectAny;
+    detectBeforeLock?: (router: Router, to: string | number | totalNextRoute | navRoute, navType: NAVTYPE) => void;
+    routes: RoutesRule[];
+}
+
+export declare interface LifeCycleConfig {
+    beforeHooks: hookListRule;
+    afterHooks: hookListRule;
+    routerBeforeHooks: hookListRule;
+    routerAfterHooks: hookListRule;
+    routerErrorHooks: Array<(error: navErrorRule, router: Router) => void>;
+}
+
+export declare interface navErrorRule {
+    type: navRuleStatus;
+    msg: string;
+    to?: totalNextRoute;
+    from?: totalNextRoute;
+    nextTo?: any;
+    [propName: string]: any;
+}
+
+export declare type navMethodRule = Promise<void | undefined | navRuleStatus>;
+
+export declare interface navRoute extends h5NextRule, navtoRule {
+}
+
+export declare type navRuleStatus = 0 | 1 | 2 | 3;
+
+export declare interface navtoRule {
+    NAVTYPE?: NAVTYPE;
+    path?: string;
+    name?: string | undefined;
+    query?: objectAny;
+    params?: objectAny;
+    animationType?: startAnimationType | endAnimationType;
+    animationDuration?: number;
+    events?: objectAny;
+    success?: Function;
+    fail?: Function;
+    complete?: Function;
+}
+
+export declare type NAVTYPE = 'push' | 'replace' | 'replaceAll' | 'pushTab' | 'back';
+
+export declare enum navtypeToggle {
+    'push' = "navigateTo",
+    'replace' = "redirectTo",
+    'replaceAll' = "reLaunch",
+    'pushTab' = "switchTab",
+    'back' = "navigateBack"
+}
+
+export declare type objectAny = {
+    [propName: string]: any;
+};
+
+export declare interface originMixins extends uniNavApiRule {
+    BACKTYPE: '' | backTypeRule;
+}
+
+export declare type pageTypeRule = 'app' | 'page' | 'component';
+
+export declare type platformRule = 'h5' | 'app-plus' | 'app-lets' | 'mp-weixin' | 'mp-baidu' | 'mp-alipay' | 'mp-toutiao' | 'mp-qq' | 'mp-360';
+
+export declare type PromiseResolve = (value?: void | PromiseLike<void> | undefined) => void;
+
+export declare type proxyDepsRule = {
+    resetIndex: Array<number>;
+    hooks: {
+        [key: number]: {
+            proxyHook: () => void;
+            callHook: (enterPath: string) => void;
+            resetHook: () => void;
+        };
+    };
+    options: {
+        [key: number]: Array<any>;
+    };
+};
+
+export declare type proxyHookName = 'beforeHooks' | 'afterHooks';
+
+export declare type reloadNavRule = totalNextRoute | false | undefined | string;
+
+export declare type reNavMethodRule = 'navigateTo' | 'redirectTo' | 'reLaunch' | 'switchTab';
+
+export declare type reNotNavMethodRule = 'navigateBack';
+
+export declare enum rewriteMethodToggle {
+    'navigateTo' = "push",
+    'navigate' = "push",
+    'redirectTo' = "replace",
+    'reLaunch' = "replaceAll",
+    'switchTab' = "pushTab",
+    'navigateBack' = "back"
+}
+
+export declare interface Router {
+    [key: string]: any;
+    readonly lifeCycle: LifeCycleConfig;
+    readonly options: InstantiateConfig;
+    $lockStatus: boolean;
+    $route: object | null;
+    enterPath: string;
+    Vue: any;
+    appMain: {
+        NAVTYPE: reNavMethodRule | reNotNavMethodRule;
+        path: string;
+    } | {};
+    proxyHookDeps: proxyDepsRule;
+    routesMap: routesMapRule | {};
+    mount: Array<{
+        app: any;
+        el: string;
+    }>;
+    install(Vue: any): void;
+    push(to: totalNextRoute | navRoute | string, from?: totalNextRoute): void;
+    replace(to: totalNextRoute | navRoute | string, from?: totalNextRoute): void;
+    replaceAll(to: totalNextRoute | navRoute | string, from?: totalNextRoute): void;
+    pushTab(to: totalNextRoute | navRoute | string, from?: totalNextRoute): void;
+    back(level: number | undefined, origin?: uniBackRule | uniBackApiRule): void;
+    forceGuardEach(navType: NAVTYPE | undefined, forceNav: boolean): void;
+    beforeEach(userGuard: guardHookRule): void;
+    afterEach(userGuard: (to: totalNextRoute, from: totalNextRoute) => void): void;
+}
+
+export declare function RouterMount(Vim: any, router: Router, el?: string | undefined): void | never;
+
+export declare interface routeRule {
+    name: string | undefined;
+    meta: objectAny;
+    path: string;
+    query: objectAny;
+    params: objectAny;
+    fullPath: string;
+    NAVTYPE: NAVTYPE | '';
+    BACKTYPE?: backTypeRule | '';
+    [propName: string]: any;
+}
+
+export declare type routesMapKeysRule = 'finallyPathList' | 'finallyPathMap' | 'aliasPathMap' | 'pathMap' | 'nameMap' | 'vueRouteMap';
+
+export declare interface routesMapRule {
+    [key: string]: any;
+    finallyPathList: Array<string>;
+    finallyPathMap: RoutesRule;
+    aliasPathMap: RoutesRule;
+    pathMap: RoutesRule;
+    nameMap: RoutesRule;
+    vueRouteMap: objectAny;
+}
+
+export declare interface RoutesRule {
+    path: string;
+    component?: object;
+    name?: string;
+    components?: object;
+    redirect?: string | Function;
+    props?: boolean | object | Function;
+    aliasPath?: string;
+    alias?: string | Array<string>;
+    children?: Array<RoutesRule>;
+    beforeEnter?: guardHookRule;
+    meta?: any;
+    [propName: string]: any;
+}
+
+export declare function runtimeQuit(title?: string | undefined): void;
+
+export declare interface startAnimationRule {
+    animationType?: startAnimationType;
+    animationDuration?: number;
+}
+
+export declare type startAnimationType = 'slide-in-right' | 'slide-in-left' | 'slide-in-top' | 'slide-in-bottom' | 'pop-in' | 'fade-in' | 'zoom-out' | 'zoom-fade-out' | 'none';
+
+export declare interface totalNextRoute extends h5NextRule, navtoRule {
+    path: string;
+    delta?: number;
+    [propName: string]: any;
+}
+
+export declare interface uniBackApiRule {
+    delta?: number;
+    animationDuration?: number;
+    animationType?: endAnimationType;
+}
+
+export declare interface uniBackRule {
+    from: backTypeRule;
+}
+
+export declare interface uniNavApiRule {
+    url: string;
+    openType?: 'appLaunch';
+    query?: objectAny;
+    path?: string;
+    delta?: number;
+    detail?: {
+        [propName: string]: any;
+    };
+    animationType?: startAnimationType;
+    animationDuration?: number;
+    events?: {
+        [propName: string]: any;
+    };
+    success?: Function;
+    fail?: Function;
+    complete?: Function;
+    animation?: {
+        animationType?: startAnimationType;
+        animationDuration?: number;
+    };
+}
+
+export declare type vueHookNameRule = 'onLaunch' | 'onShow' | 'onHide' | 'onError' | 'onInit' | 'onLoad' | 'onReady' | 'onUnload' | 'onResize' | 'created' | 'beforeMount' | 'mounted' | 'beforeDestroy' | 'destroyed';
+
+export declare type vueOptionRule = {
+    [propName in vueHookNameRule]: Array<Function> | undefined;
+};
+
+export { }
+
+// @ts-ignore
+declare module 'vue/types/vue' {
+    interface Vue {
+        $Router: Router;
+        $Route: routeRule;
+    }
+}
+    

node_modules/uni-simple-router/github.sh

@@ -0,0 +1,107 @@
+#!/bin/bash
+
+# author hhyang 
+# home  https://github.com/SilurianYang
+
+ printf "\n -------------- Ctrl+D可以退出程序 --------------- \n\n"
+
+select name in "auto" "status" "add" "commit" "push" "pull" "branch" "checkout" "*"; do
+        case "$name" in 
+            # 自动同步文件
+            "auto")
+                cp -avx ./examples/node_modules/uni-simple-router/* ./npm-package
+                rm -rf ./npm-package/package-lock.json
+                cp -avx ./README.md ./npm-package
+                cp -avx ./package.json ./npm-package
+                cp -avx ./npm-package/* ./src
+                rm -rf ./src/README.md
+                rm -rf ./src/package.json
+
+                printf "\n -------------- 自动化构建目录完毕 --------------- \n\n"
+            ;;
+
+            # 查询status
+            "status")
+                git status
+                printf "\n -------------- 查询完毕 --------------- \n\n"
+            ;; 
+
+            # 添加文件 .或* 全部文件 可自定义文件路径
+            "add")
+                while read -p "请输入更多提交命令 【默认全部.】 ：" add; do
+                        if [[ "$add" == "" ]]; then
+                            eval "git add ."
+                        else 
+                            eval "git add ${add}"
+                        fi
+                        printf "\n -------------- 添加完成 --------------- \n\n"
+                        break
+                done 
+            ;;
+
+            # 提交文件
+            "commit")
+                while read -p "请输入提交信息：" readme; do
+                        if [[ "$readme" != "" ]]; then
+                            eval "git commit -m '${readme}'"
+                            printf "\n -------------- 提交本地完成 --------------- \n\n"
+                            break
+                        else
+                            printf "\n警告====> 提交信息不能为空！  \n \n"
+                        fi
+                done 
+            ;; 
+
+            # 推送到服务端
+            "push")
+                read -p "请输入提交的分支(不输入默认主分支 [master] )：" branch
+                printf "\n\n -------------- 正在推送github,请稍后.... --------------- \n\n"
+                    if [[ "$branch" == "" ]]; then
+                        git push
+                    else
+                        eval "git push origin ${branch}"
+                    fi
+                printf "\n -------------- 推送github完成 --------------- \n\n"
+            ;;
+
+            # 拉取最新代码
+            "pull")
+                printf "\n\n -------------- 正在拉取,请稍后.... --------------- \n\n"
+                    git pull
+                printf "\n -------------- 正在拉取完成 --------------- \n\n"
+            ;;
+
+            # 切换分支操作
+            "branch")
+                read -p "请输入添加更多指令 【分支】 ：" branchs
+                    if [[ "$branchs" == "" ]]; then
+                    printf "\n分支列表如下：\n\n"
+                        git branch
+                    else
+                        eval "git branch ${branchs}"
+                    fi
+                printf "\n -------------- 分支操作完毕 --------------- \n\n"
+            ;;
+            # 
+            "checkout")
+                read -p "请输入添加更多指令 【默认切换到master】 ：" out
+                if [[ "$out" == "" ]]; then
+                    git checkout master
+                else
+                    eval "git checkout ${out}"
+                fi
+                printf "\n -------------- 执行完毕 --------------- \n\n"
+            ;;
+            # 自定义指令
+            *)
+            while read -p "请输入自定义命令 【输入:q退出】：" code; do
+                if [[ "$code" == ":q" ]];then
+                    printf "\n"
+                    break
+                fi
+                printf "\n\n -------------- 正在执行,请稍后.... --------------- \n\n"
+                    eval "$code"
+                printf "\n -------------- 执行完毕 --------------- \n\n"
+            done
+        esac
+done

node_modules/uni-simple-router/jest.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  moduleDirectories:['node_modules','src']
+};

node_modules/uni-simple-router/package.json

@@ -0,0 +1,62 @@
+{
+  "_from": "uni-simple-router@2.0.7",
+  "_id": "uni-simple-router@2.0.7",
+  "_inBundle": false,
+  "_integrity": "sha512-8FKv5dw7Eoonm0gkO8udprrxzin0fNUI0+AvIphFkFRH5ZmP5ZWJ2pvnWzb2NiiqQSECTSU5VSB7HhvOSwD5eA==",
+  "_location": "/uni-simple-router",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "uni-simple-router@2.0.7",
+    "name": "uni-simple-router",
+    "escapedName": "uni-simple-router",
+    "rawSpec": "2.0.7",
+    "saveSpec": null,
+    "fetchSpec": "2.0.7"
+  },
+  "_requiredBy": [
+    "#USER",
+    "/"
+  ],
+  "_resolved": "https://registry.npmjs.org/uni-simple-router/-/uni-simple-router-2.0.7.tgz",
+  "_shasum": "04e0b5be6cd733a1ecb9d35a3dbe82f27f48204e",
+  "_spec": "uni-simple-router@2.0.7",
+  "_where": "/Users/WebTmm/Desktop/ZhHealth",
+  "author": {
+    "name": "hhyang"
+  },
+  "bugs": {
+    "url": "https://github.com/SilurianYang/uni-simple-router/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "> 一个更为简洁的[Vue-router](https://router.vuejs.org/zh/)，专为 [uni-app](https://uniapp.dcloud.io/) 量身打造",
+  "homepage": "https://github.com/SilurianYang/uni-simple-router#readme",
+  "keywords": [
+    "router",
+    "uni-app-router",
+    "interceptor",
+    "uni-app",
+    "uniapp"
+  ],
+  "license": "MIT",
+  "main": "dist/uni-simple-router.js",
+  "name": "uni-simple-router",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SilurianYang/uni-simple-router.git"
+  },
+  "scripts": {
+    "build": "node ./publish/build.js",
+    "dev": "webpack --watch  --progress --config webpack/webpack.dev.js",
+    "dist": "webpack --progress --config webpack/webpack.prod.js",
+    "dist:dts": "api-extractor run --local --verbose",
+    "lint": "eslint --ext .js,.ts src",
+    "lintFix": "eslint --ext .js,.ts src --fix",
+    "publish": "node ./publish/index.js",
+    "test": "jest test/query-toggle.spec.ts"
+  },
+  "types": "dist/uni-simple-router.d.ts",
+  "version": "2.0.7"
+}

node_modules/uni-simple-router/progress.md

@@ -0,0 +1,16 @@
+## Fixes bug
+* `小程序` 端 `onLoad`、`onShow` 执行不标准的BUG。(#206,#224,#291)
+* `小程序` 端 启动页必须写 `onLoad` 才会执行的BUG。
+* `APP` 端 tab 拦截后无法自动还原选中区域现在已修复。
+* H5端设置 `aliasPath` 后，无法使用 `aliasPath` 跨端跳转 (#302)
+* 重写代理生命周期逻辑、保证执行各端执行顺序 (#312)
+
+## Revise
+* 参数可以直接传递 `null`。但是需要注意：**在非深度对象传参的情况下，小程序会将 `null` 解析为字符串`undefined`** 
+* 多端情况下自定义启动参数不仅限制于 `query` 传递深度参数，任何组合都可以 (#307,#301)
+* 去除 `keyword` 白名单字段
+* 调整小程序启动页面生命周期的执行，让在小程序下的生命周期能更贴近App、H5
+* `routerErrorEach` 新增回调参数、包括：`NAVTYPE`、`uniActualData`、`level`
+
+## Known Issues
+* `APP` 端启动页为tab时，拦截到其他页面后底部tabbar 还依然存在，请避免把原生 `tabbar` 页设置成启动页。你可以在 `beforeEach` 中使用 next 到tabbar页效果一致

node_modules/uni-simple-router/src/H5/buildRouter.ts

@@ -0,0 +1,76 @@
+import {RoutesRule, Router, routesMapRule, totalNextRoute, hookToggle, navtoRule} from '../options/base';
+import {H5Config} from '../options/config';
+import {warn} from '../helpers/warn'
+import {getDataType, getRoutePath} from '../helpers/utils'
+import { onTriggerEachHook } from '../public/hooks';
+
+export function buildVueRoutes(router: Router, vueRouteMap:RoutesRule):RoutesRule {
+    const {pathMap, finallyPathList} = (router.routesMap as routesMapRule);
+    const vueRoutePathList:Array<string> = Object.keys(vueRouteMap);
+    for (let i = 0; i < vueRoutePathList.length; i++) {
+        const path = vueRoutePathList[i];
+        const myRoute:RoutesRule = pathMap[path];
+        const vueRoute:RoutesRule = vueRouteMap[path];
+        if (!myRoute) {
+            warn(`${path} 路由地址在路由表中未找到，确定是否传递漏啦`, router, true);
+        } else {
+            const {finallyPath} = getRoutePath(myRoute, router);
+            if (finallyPath instanceof Array) {
+                throw new Error(`非 vueRouterDev 模式下，alias、aliasPath、path 无法提供数组类型！ ${JSON.stringify(myRoute)}`);
+            }
+            if (myRoute.name != null) {
+                vueRoute.name = myRoute.name;
+            }
+            const vuePath = vueRoute['path'];
+            const vueAlias = vueRoute['alias'];
+            delete vueRoute['alias'];
+            vueRoute['path'] = (finallyPath as string);
+            if (vuePath === '/' && vueAlias != null) {
+                vueRoute['alias'] = vueAlias;
+                vueRoute['path'] = vuePath;
+            }
+            const beforeEnter = myRoute.beforeEnter;
+            if (beforeEnter) {
+                vueRoute['beforeEnter'] = function(
+                    to:totalNextRoute,
+                    from: totalNextRoute,
+                    next:(rule?: navtoRule|false)=>void,
+                ):void{
+                    onTriggerEachHook(to, from, router, hookToggle['enterHooks'], next)
+                };
+            }
+        }
+    }
+    if (finallyPathList.includes('*')) {
+        vueRouteMap['*'] = pathMap['*']
+    }
+    return vueRouteMap
+}
+
+export function buildVueRouter(router:Router, vueRouter:any, vueRouteMap:RoutesRule|RoutesRule[]) :void |never {
+    let routes:RoutesRule[] = [];
+    if (getDataType<RoutesRule|RoutesRule[]>(vueRouteMap) === '[object Array]') {
+        routes = (vueRouteMap as RoutesRule[]);
+    } else {
+        routes = Object.values(vueRouteMap);
+    }
+    const {scrollBehavior, fallback} = router.options.h5 as H5Config;
+    const oldScrollBehavior = vueRouter.options.scrollBehavior;
+    vueRouter.options.scrollBehavior = function proxyScrollBehavior(
+        to:totalNextRoute,
+        from:totalNextRoute,
+        savedPosition:any
+    ) {
+        oldScrollBehavior && oldScrollBehavior(to, from, savedPosition);
+        return (scrollBehavior as Function)(to, from, savedPosition)
+    }
+    vueRouter.fallback = fallback;
+    // Detail see: https://github.com/vuejs/vue-router/issues/1234#issuecomment-357941465
+    const newVueRouter:any = new vueRouter.constructor({
+        ...router.options.h5,
+        base: vueRouter.options.base,
+        mode: vueRouter.options.mode,
+        routes
+    });
+    vueRouter.matcher = newVueRouter.matcher;
+}

node_modules/uni-simple-router/src/H5/proxyHook.ts

@@ -0,0 +1,71 @@
+import {Router, proxyHookName, totalNextRoute, navtoRule} from '../options/base';
+
+export class MyArray extends Array {
+    constructor(
+        private router:Router,
+        private vueEachArray:Array<Function>,
+        private myEachHook:Function,
+        private hookName:'beforeHooks'| 'afterHooks',
+    ) {
+        super();
+        Object.setPrototypeOf(this, MyArray.prototype)
+    }
+    push(v:any):any {
+        this.vueEachArray.push(v);
+        const index = this.length;
+        this[this.length] = (to: totalNextRoute, from: totalNextRoute, next:(rule?: navtoRule|false)=>void) => {
+            if (index > 0) {
+                this.vueEachArray[index](to, from, () => {
+                    next && next()
+                });
+            } else {
+                this.myEachHook(to, from, (nextTo?:navtoRule|false) => {
+                    // Fixe https://github.com/SilurianYang/uni-simple-router/issues/241 2021年3月6日22:15:27
+                    // 目前不调用uni-app的守卫函数，因为会丢失页面栈信息
+                    if (nextTo === false) {
+                        next(false);
+                    } else {
+                        this.vueEachArray[index](to, from, (uniNextTo?:navtoRule|false) => {
+                            next(nextTo);
+                        })
+                    }
+                }, this.router, true);
+            }
+        };
+    }
+}
+
+export function proxyEachHook(router:Router, vueRouter:any):void {
+    const hookList:Array<'beforeHooks'| 'afterHooks'> = ['beforeHooks', 'afterHooks'];
+    for (let i = 0; i < hookList.length; i++) {
+        const hookName = hookList[i];
+        const myEachHook = router.lifeCycle[(hookName as proxyHookName)][0];
+        if (myEachHook) {
+            const vueEachArray:Array<Function> = vueRouter[hookName];
+            vueRouter[hookName] = new MyArray(router, vueEachArray, myEachHook, hookName);
+        }
+    }
+}
+export function proxyH5Mount(router:Router):void {
+    if (router.mount.length === 0) {
+        if (router.options.h5?.vueRouterDev) {
+            return
+        }
+        const uAgent = navigator.userAgent;
+        const isIos = !!uAgent.match(/\(i[^;]+;( U;)? CPU.+Mac OS X/)
+        if (isIos) {
+            // 【Fixe】 https://github.com/SilurianYang/uni-simple-router/issues/109
+            setTimeout(() => {
+                const element = document.getElementsByTagName('uni-page');
+                if (element.length > 0) {
+                    return false
+                }
+                window.location.reload();
+            }, 0);
+        }
+    } else {
+        const [{app}] = router.mount;
+        app.$mount();
+        router.mount = [];
+    }
+}

node_modules/uni-simple-router/src/app/appPatch.ts

@@ -0,0 +1,75 @@
+import { objectAny, Router, totalNextRoute } from '../options/base';
+import { AppConfig } from '../options/config';
+
+let quitBefore:number|null = null;
+let TABBAR:objectAny|null = null;
+
+export function registerLoddingPage(
+    router:Router,
+):void{
+    if (router.options.registerLoadingPage) {
+        const { loadingPageHook, loadingPageStyle } = router.options.APP as AppConfig;	// 获取app所有配置
+        const view = new plus.nativeObj.View('router-loadding', {
+            top: '0px',
+            left: '0px',
+            height: '100%',
+            width: '100%',
+            ...(loadingPageStyle as Function)()
+        });
+        (loadingPageHook as Function)(view);	// 触发等待页面生命周期
+    }
+}
+
+export function runtimeQuit(
+    title:string|undefined = '再按一次退出应用'
+):void{
+    const nowTime = +new Date();
+    if (!quitBefore) {
+        quitBefore = nowTime;
+        uni.showToast({
+            title,
+            icon: 'none',
+            position: 'bottom',
+            duration: 1000
+        });
+        setTimeout(() => { quitBefore = null }, 1000);
+    } else {
+        if (nowTime - quitBefore < 1000) {
+            plus.runtime.quit();
+        }
+    }
+}
+
+export function tabIndexSelect(
+    to:totalNextRoute,
+    from:totalNextRoute
+):boolean {
+    if (!(__uniConfig.tabBar && Array.isArray(__uniConfig.tabBar.list))) {
+        return false
+    }
+    const tabBarList = __uniConfig.tabBar.list;
+    const routes:Array<totalNextRoute> = [];
+    let activeIndex:number = 0;
+    for (let i = 0; i < tabBarList.length; i++) {
+        const route:totalNextRoute = tabBarList[i];
+        if ('/' + route.pagePath === to.path || '/' + route.pagePath === from.path) {
+            if (route.pagePath === from.path) {
+                activeIndex = i;
+            }
+            routes.push(route);
+        }
+        if (routes.length === 2) {
+            break
+        }
+    }
+    if (routes.length !== 2) {
+        return false
+    }
+    if (TABBAR == null) {
+        TABBAR = uni.requireNativePlugin('uni-tabview')
+    }
+    (TABBAR as objectAny).switchSelect({
+        index: activeIndex
+    })
+    return true
+}

node_modules/uni-simple-router/src/applets/appletPatch.ts

@@ -0,0 +1,18 @@
+import { Router} from '../options/base';
+
+export function getEnterPath(
+    vueVim:any,
+    router:Router,
+) :string {
+    switch (router.options.platform) {
+    case 'mp-alipay':
+    case 'mp-weixin':
+    case 'mp-toutiao':
+    case 'mp-qq':
+        return vueVim.$options.mpInstance.route;
+    case 'mp-baidu':
+        // 【Fixe】 https://github.com/SilurianYang/uni-simple-router/issues/251
+        return vueVim.$options.mpInstance.is || vueVim.$options.mpInstance.pageinstance.route;
+    }
+    return vueVim.$options.mpInstance.route; // 这是暂时的 因为除了以上的小程序 其他没测试 先这样写
+}

node_modules/uni-simple-router/src/component/link.vue

@@ -0,0 +1,79 @@
+<template>
+    <view @click="gotoPage()"><slot></slot></view>
+</template>
+
+<script>
+const navType = {
+    push: 'push',
+    replace: 'replace',
+    replaceAll: 'replaceAll',
+    pushTab: 'pushTab',
+    back:'back'
+};
+export default {
+    props: {
+        to: {
+            type: [String, Object],
+            required: true
+        },
+        stopNavto: {
+            type: Boolean,
+            default: false,
+        },
+        navType: {
+            type: String,
+            default: 'push',
+        },
+        level: {
+            type: Number,
+            default: 1,
+        },
+        append: {
+            type: Boolean,
+            default: false,
+        },
+    },
+    methods: {
+        formatNav(text) {
+            if (text != null && text.constructor === String) {
+                text = text.replace(/\'/g, '');
+                text = text.replace(/(\w+)(?=:)/g, function (val) {
+                    return `"${val}"`;
+                });
+                text = text.replace(/:\s*([^,{}\s"]+)/g, function (val) {
+                    const arr = val.split(':');
+                    return `:"${arr[1].trim()}"`;
+                });
+                try {
+                    text = JSON.parse(text);
+                } catch (e) {}
+            }
+            if (this.append) {
+                let pathArr = this.$Route.path.split('/');
+                pathArr.splice(pathArr.length - this.level, this.level);
+                pathArr = pathArr.join('/');
+                if (text.constructor === Object) {
+                    if (text.path) {
+                        text.path = pathArr + text.path;
+                    }
+                } else {
+                    text = pathArr + text;
+                }
+            }
+            return text;
+        },
+        gotoPage() {
+            if (this.stopNavto) {
+                return true;
+            }
+            const type = navType[this.navType];
+            if (type == null) {
+                return console.error(` "navType" unknown type \n\n value：${Object.values(navType).join('、')}`);
+            }
+            const navInfo = this.formatNav(this.to);
+
+            this.$Router[type](navInfo);
+        },
+    },
+};
+</script>

node_modules/uni-simple-router/src/global.d.ts

@@ -0,0 +1,7 @@
+declare var uni:any;
+declare var plus:any;
+declare var __uniConfig:any;
+declare var __uniRoutes:any;
+declare function getCurrentPages(isAll:boolean|undefined=false):any;
+declare function getApp(args?:{allowDefault: true}):any;
+declare var $npm_package_name:string;

node_modules/uni-simple-router/src/helpers/config.ts

@@ -0,0 +1,78 @@
+import {err} from './warn'
+import { InstantiateConfig, LifeCycleConfig} from '../options/config'
+import { vueHookNameRule, proxyDepsRule } from '../options/base';
+
+export const mpPlatformReg = '(^mp-weixin$)|(^mp-baidu$)|(^mp-alipay$)|(^mp-toutiao$)|(^mp-qq$)|(^mp-360$)' // 小程序下不能直接导出正则 需要重新组装成正则 不然bug一推 诡异
+
+export const baseConfig:InstantiateConfig = {
+    h5: {
+        paramsToQuery: false,
+        vueRouterDev: false,
+        vueNext: false,
+        mode: 'hash',
+        base: '/',
+        linkActiveClass: 'router-link-active',
+        linkExactActiveClass: 'router-link-exact-active',
+        scrollBehavior: (to:any, from:any, savedPostion:Function) => ({ x: 0, y: 0 }),
+        fallback: true
+    },
+    APP: {
+        registerLoadingPage: true,
+        loadingPageStyle: () => JSON.parse('{"backgroundColor":"#FFF"}'),
+        loadingPageHook: (view:any) => { view.show(); },
+        launchedHook: () => { plus.navigator.closeSplashscreen(); },
+        animation: {}
+    },
+    applet: {
+        animationDuration: 300
+    },
+    platform: 'h5',
+    keepUniOriginNav: false,
+    debugger: false,
+    routerBeforeEach: (to, from, next) => { next() },
+    routerAfterEach: (to, from) => {},
+    routerErrorEach: (error, router) => { router.$lockStatus = false; err(error, router, true); },
+    detectBeforeLock: (router, to, navType) => {},
+    routes: [
+        {
+            path: '/choose-location'
+        },
+        {
+            path: '/open-location'
+        },
+        {
+            path: '/preview-image'
+        }
+    ]
+}
+
+export const lifeCycle:LifeCycleConfig = {
+    beforeHooks: [],
+    afterHooks: [],
+    routerBeforeHooks: [],
+    routerAfterHooks: [],
+    routerErrorHooks: []
+};
+
+export const proxyHookDeps:proxyDepsRule = {
+    resetIndex: [], // 还原时执行的生命周期的索引
+    hooks: {},
+    options: {}
+}
+
+export const proxyHookName:Array<vueHookNameRule> = [
+    'onLaunch',
+    'onShow',
+    'onHide',
+    'onError',
+    'onInit',
+    'onLoad',
+    'onReady',
+    'onUnload',
+    'onResize',
+    'created',
+    'beforeMount',
+    'mounted',
+    'beforeDestroy',
+    'destroyed'
+]

node_modules/uni-simple-router/src/helpers/createRouteMap.ts

@@ -0,0 +1,47 @@
+import {RoutesRule, Router, routesMapRule} from '../options/base';
+import {H5Config} from '../options/config';
+import {warn} from './warn'
+import {getRoutePath} from './utils'
+
+export function createRouteMap(
+    router: Router,
+    routes: RoutesRule[],
+): routesMapRule|never {
+    const routesMap:routesMapRule = {
+        finallyPathList: [],
+        finallyPathMap: Object.create(null),
+        aliasPathMap: Object.create(null),
+        pathMap: Object.create(null),
+        vueRouteMap: Object.create(null),
+        nameMap: Object.create(null)
+    }
+    routes.forEach(route => {
+        const { finallyPath, aliasPath, path} = getRoutePath(route, router);
+        if (path == null) {
+            throw new Error(`请提供一个完整的路由对象，包括以绝对路径开始的 ‘path’ 字符串 ${JSON.stringify(route)}`);
+        }
+        if (finallyPath instanceof Array) {
+            if (!(router.options.h5 as H5Config).vueRouterDev && router.options.platform === 'h5') {
+                throw new Error(`非 vueRouterDev 模式下，route.alias 目前无法提供数组类型！ ${JSON.stringify(route)}`);
+            }
+        }
+        const strFinallyPath = (finallyPath as string);
+        const strAliasPath = (aliasPath as string);
+        if (router.options.platform !== 'h5') {
+            if (strFinallyPath.indexOf('/') !== 0 && path !== '*') {
+                warn(`当前路由对象下，route：${JSON.stringify(route)} 是否缺少了前缀 ‘/’`, router, true);
+            }
+        }
+        if (!routesMap.finallyPathMap[strFinallyPath]) {
+            routesMap.finallyPathMap[strFinallyPath] = route;
+            routesMap.aliasPathMap[strAliasPath] = route;
+            routesMap.pathMap[path] = route;
+            routesMap.finallyPathList.push(strFinallyPath);
+            if (route.name != null) {
+                routesMap.nameMap[route.name] = route;
+            }
+        }
+    })
+
+    return routesMap;
+}

node_modules/uni-simple-router/src/helpers/lifeCycle.ts

@@ -0,0 +1,36 @@
+import { navtoRule, navErrorRule, Router, proxyHookName, guardHookRule, totalNextRoute, hookToggle} from '../options/base';
+import { LifeCycleConfig, InstantiateConfig} from '../options/config';
+import {onTriggerEachHook} from '../public/hooks'
+
+export function registerHook(list:Array<Function>, fn:Function):void {
+    list[0] = fn;
+}
+
+export function registerRouterHooks<T extends LifeCycleConfig>(cycleHooks:T, options:InstantiateConfig):T {
+    registerHook(cycleHooks.routerBeforeHooks, function(to:totalNextRoute, from: totalNextRoute, next:(rule?: navtoRule|false)=>void):void {
+        (options.routerBeforeEach as Function)(to, from, next);
+    })
+    registerHook(cycleHooks.routerAfterHooks, function(to:totalNextRoute, from: totalNextRoute):void {
+        (options.routerAfterEach as Function)(to, from);
+    })
+    registerHook(cycleHooks.routerErrorHooks, function(error:navErrorRule, router:Router):void {
+        (options.routerErrorEach as Function)(error, router);
+    })
+    return cycleHooks;
+}
+
+export function registerEachHooks(router:Router, hookType:proxyHookName, userGuard:guardHookRule) {
+    registerHook(router.lifeCycle[hookType], function(
+        to:totalNextRoute,
+        from: totalNextRoute,
+        next:(rule?: navtoRule|false)=>void,
+        router:Router,
+        auto:boolean,
+    ):void {
+        if (auto) { // h5端 vue-router自动触发 非自己调用触发
+            onTriggerEachHook(to, from, router, hookToggle[hookType], next)
+        } else {
+            userGuard(to, from, next)
+        }
+    })
+}

node_modules/uni-simple-router/src/helpers/mixins.ts

@@ -0,0 +1,109 @@
+import { Router, routesMapRule, RoutesRule, pageTypeRule} from '../options/base';
+import {createRouteMap} from '../helpers/createRouteMap'
+import {buildVueRoutes, buildVueRouter} from '../H5/buildRouter'
+import {proxyEachHook} from '../H5/proxyHook'
+import {registerLoddingPage} from '../app/appPatch';
+import { proxyPageHook } from '../public/page';
+import { forceGuardEach } from '../public/methods';
+import { assertParentChild, voidFun } from './utils';
+import { getEnterPath } from '../applets/appletPatch';
+import { mpPlatformReg } from './config';
+
+let registerRouter:boolean = false;
+let onloadProxyOk:boolean = false;
+
+const appletProxy:{
+    app:boolean;
+    page:string;
+} = {
+    app: false,
+    page: ''
+}
+
+export function getMixins(Vue:any, router: Router):{
+    beforeCreate(this: any): void;
+} | {
+    beforeCreate(): void;
+} | {
+    onLaunch(): void;
+} {
+    let platform = router.options.platform;
+    if (new RegExp(mpPlatformReg, 'g').test(platform)) {
+        platform = 'app-lets';
+    }
+    const toggleHooks = {
+        h5: {
+            beforeCreate(this: any): void {
+                if (this.$options.router) {
+                    router.$route = this.$options.router; // 挂载vue-router到路由对象下
+                    let vueRouteMap:RoutesRule[]|RoutesRule = [];
+                    if (router.options.h5?.vueRouterDev) {
+                        vueRouteMap = router.options.routes;
+                    } else {
+                        vueRouteMap = createRouteMap(router, this.$options.router.options.routes).finallyPathMap;
+                        (router.routesMap as routesMapRule).vueRouteMap = vueRouteMap;
+                        buildVueRoutes(router, vueRouteMap);
+                    }
+                    buildVueRouter(router, this.$options.router, vueRouteMap);
+                    proxyEachHook(router, this.$options.router);
+                }
+            }
+        },
+        'app-plus': {
+            beforeCreate(this: any): void {
+                if (!registerRouter) {
+                    registerRouter = true;
+                    proxyPageHook(this, router, 'app');
+                    registerLoddingPage(router);
+                }
+            }
+        },
+        'app-lets': {
+            beforeCreate(this: any): void {
+                // 保证这个函数不会被重写
+                const pluginMark = $npm_package_name;
+                voidFun(pluginMark);
+
+                let isProxy:boolean = true;
+                const pageType:pageTypeRule = this.$options.mpType;
+
+                if (onloadProxyOk) {
+                    return
+                }
+
+                if (pageType === 'component') {
+                    isProxy = assertParentChild(appletProxy['page'], this);
+                } else {
+                    if (pageType === 'page') {
+                        appletProxy[pageType] = getEnterPath(this, router);
+                        router.enterPath = appletProxy[pageType]; // 我不确定在不同端是否都是同样的变现？可能有的为非绝对路径？
+                    } else {
+                        appletProxy[pageType] = true;
+                    }
+                }
+                if (isProxy) {
+                    proxyPageHook(this, router, pageType);
+                }
+            },
+            onLoad(this: any):void{
+                // 保证这个函数不会被重写，否则必须在启动页写onLoad
+                const pluginMark = $npm_package_name;
+                voidFun(pluginMark);
+
+                if (!onloadProxyOk && assertParentChild(appletProxy['page'], this)) {
+                    onloadProxyOk = true;
+                    forceGuardEach(router);
+                }
+            }
+        }
+    };
+    return toggleHooks[(platform as 'h5'|'app-plus'|'app-lets')];
+}
+export function initMixins(Vue: any, router: Router) {
+    const routesMap = createRouteMap(router, router.options.routes);
+    router.routesMap = routesMap; // 挂载自身路由表到路由对象下
+    // Vue.util.defineReactive(router, '_Route', createRoute(router, 19970806))
+    Vue.mixin({
+        ...getMixins(Vue, router)
+    });
+}

node_modules/uni-simple-router/src/helpers/utils.ts

@@ -0,0 +1,452 @@
+import {H5Config, InstantiateConfig} from '../options/config';
+import {RoutesRule, routesMapRule, routesMapKeysRule, Router, totalNextRoute, objectAny, navErrorRule, NAVTYPE, navRoute, uniBackApiRule, uniBackRule} from '../options/base';
+import {baseConfig} from '../helpers/config';
+import {ERRORHOOK} from '../public/hooks'
+import {warnLock} from '../helpers/warn'
+import { createRoute, navjump } from '../public/methods';
+const Regexp = require('path-to-regexp');
+
+export function voidFun(...args:any):void{}
+
+export function def(
+    defObject:objectAny,
+    key:string,
+    getValue:Function
+) {
+    Object.defineProperty(defObject, key, {
+        get() {
+            return getValue();
+        }
+    })
+}
+
+export function timeOut(time:number):Promise<void> {
+    return new Promise(resolve => {
+        setTimeout(() => {
+            resolve();
+        }, time)
+    })
+}
+
+export function mergeConfig<T extends InstantiateConfig>(baseConfig: T, userConfig: T): T {
+    const config: {[key: string]: any} = Object.create(null);
+    const baseConfigKeys: Array<string> = Object.keys(baseConfig).concat(['resolveQuery', 'parseQuery']);
+    for (let i = 0; i < baseConfigKeys.length; i += 1) {
+        const key = baseConfigKeys[i];
+        if (userConfig[key] != null) {
+            if (userConfig[key].constructor === Object) {
+                config[key] = {
+                    ...baseConfig[key],
+                    ...userConfig[key]
+                };
+            } else if (key === 'routes') {
+                config[key] = [
+                    ...baseConfig[key],
+                    ...userConfig[key]
+                ];
+            } else {
+                config[key] = userConfig[key];
+            }
+        } else {
+            config[key] = baseConfig[key];
+        }
+    }
+    return config as T;
+}
+
+export function notDeepClearNull<T>(object:T):T {
+    for (const key in object) {
+        if (object[key] == null) {
+            delete object[key];
+        }
+    }
+    return object;
+}
+
+export function getRoutePath(route: RoutesRule, router:Router): {
+    finallyPath: string | string[];
+    aliasPath: string;
+    path: string;
+    alias: string | string[] | undefined;
+} {
+    let finallyPath = route.aliasPath || route.alias || route.path;
+    if (router.options.platform !== 'h5') {
+        finallyPath = route.path
+    }
+    return {
+        finallyPath,
+        aliasPath: route.aliasPath || route.path,
+        path: route.path,
+        alias: route.alias
+    }
+}
+
+export function assertNewOptions<T extends InstantiateConfig>(
+    options: T
+): T | never {
+    const {platform, routes} = options;
+    if (platform == null) {
+        throw new Error(`你在实例化路由时必须传递 'platform'`);
+    }
+    if (routes == null || routes.length === 0) {
+        throw new Error(`你在实例化路由时必须传递 routes 为空，这是无意义的。`);
+    }
+    if (options.platform === 'h5') {
+        if (options.h5?.vueRouterDev) {
+            baseConfig.routes = [];
+        }
+    }
+    const mergeOptions = mergeConfig<T>(baseConfig as T, options);
+    return mergeOptions;
+}
+
+export function getWildcardRule(
+    router:Router,
+    msg?:navErrorRule
+):RoutesRule|never {
+    const routesMap = (router.routesMap as routesMapRule);
+    const route = routesMap.finallyPathMap['*'];
+    if (route) { // 有写通配符
+        return route
+    }
+    if (msg) {
+        ERRORHOOK[0](msg, router);
+    }
+    throw new Error(`当前路由表匹配规则已全部匹配完成，未找到满足的匹配规则。你可以使用 '*' 通配符捕捉最后的异常`);
+}
+
+export function notRouteTo404(
+    router:Router,
+    toRoute:RoutesRule|{
+        redirect:any;
+        path:string
+    },
+    parseToRule:totalNextRoute,
+    navType:NAVTYPE
+):RoutesRule|totalNextRoute|never {
+    if (toRoute.path !== '*') { // 不是通配符  正常匹配成功
+        return (toRoute as RoutesRule);
+    }
+
+    const redirect = toRoute.redirect;
+
+    if (typeof redirect === 'undefined') {
+        throw new Error(` *  通配符必须配合 redirect 使用。redirect: string | Location | Function`);
+    }
+
+    let newRoute = redirect;
+    if (typeof newRoute === 'function') {
+        newRoute = newRoute(parseToRule) as totalNextRoute;
+    }
+    const redirectRule = navjump(newRoute as totalNextRoute, router, navType, undefined, undefined, undefined, false);
+    return (redirectRule as totalNextRoute);
+}
+
+export function routesForMapRoute(
+    router: Router,
+    path: string,
+    mapArrayKey:Array<routesMapKeysRule>,
+    deepFind:boolean|undefined = false
+):RoutesRule|never {
+    if (router.options.h5?.vueRouterDev) {
+        return {path}
+    }
+    // 【Fixe】 https://github.com/SilurianYang/uni-simple-router/issues/252
+    const startPath = path.split('?')[0];
+    let wildcard = '';
+    const routesMap = (router.routesMap as routesMapRule);
+    for (let i = 0; i < mapArrayKey.length; i++) {
+        const mapKey = mapArrayKey[i];
+        const mapList = routesMap[mapKey];
+        for (const [key, value] of Object.entries(mapList)) {
+            if (key === '*') {
+                if (wildcard === '') {
+                    wildcard = '*'
+                }
+                continue;
+            }
+            const route:string|RoutesRule = value;
+            let rule:string = key;
+            if (getDataType<Array<string>|objectAny>(mapList) === '[object Array]') {
+                rule = (route as string);
+            }
+            const pathRule:RegExp = Regexp(rule);
+            const result = pathRule.exec(startPath);
+            if (result != null) {
+                if (getDataType<string|RoutesRule>(route) === '[object String]') {
+                    return routesMap.finallyPathMap[(route as string)];
+                }
+                return (route as RoutesRule);
+            }
+        }
+    }
+    // 【Fixe】 https://github.com/SilurianYang/uni-simple-router/issues/302    2021-8-4 16:38:44
+    if (deepFind) {
+        return ({} as RoutesRule);
+    }
+    if (routesMap['aliasPathMap']) {
+        const results = routesForMapRoute(router, path, ['aliasPathMap'], true);
+        if (Object.keys(results).length > 0) {
+            return results;
+        }
+    }
+    if (wildcard !== '') {
+        return getWildcardRule(router);
+    }
+    throw new Error(`${path} 路径无法在路由表中找到！检查跳转路径及路由表`);
+}
+
+export function getDataType<T>(data:T):string {
+    return Object.prototype.toString.call(data)
+}
+
+export function copyData<T>(object:T): T {
+    return JSON.parse(JSON.stringify(object))
+}
+
+export function getUniCachePage<T extends objectAny>(pageIndex?:number):T|[] {
+    const pages:T = getCurrentPages();
+    if (pageIndex == null) {
+        return pages
+    }
+    if (pages.length === 0) {
+        return pages;
+    }
+    const page = pages.reverse()[pageIndex];
+    if (page == null) {
+        return []
+    }
+    return page;
+}
+
+export function urlToJson(url :string):{
+    path:string;
+    query:objectAny
+} {
+    const query:objectAny = {};
+    const [path, params] = url.split('?');
+    if (params != null) {
+        const parr = params.split('&');
+        for (const i of parr) {
+            const arr = i.split('=');
+            query[arr[0]] = arr[1];
+        }
+    }
+    return {
+        path,
+        query
+    }
+}
+
+export function forMatNextToFrom<T extends totalNextRoute>(
+    router:Router,
+    to:T,
+    from:T
+):{
+    matTo:T;
+    matFrom: T;
+} {
+    let [matTo, matFrom] = [to, from];
+    if (router.options.platform === 'h5') {
+        const {vueNext, vueRouterDev} = (router.options.h5 as H5Config);
+        if (!vueNext && !vueRouterDev) {
+            matTo = createRoute(router, undefined, matTo) as T;
+            matFrom = createRoute(router, undefined, matFrom) as T;
+        }
+    } else {
+        matTo = createRoute(router, undefined, deepClone<T>(matTo)) as T;
+        matFrom = createRoute(router, undefined, deepClone<T>(matFrom)) as T;
+    }
+    return {
+        matTo: matTo,
+        matFrom: matFrom
+    }
+}
+
+export function paramsToQuery(
+    router:Router,
+    toRule:totalNextRoute|string
+):totalNextRoute|string {
+    if (router.options.platform === 'h5' && !router.options.h5?.paramsToQuery) {
+        return toRule;
+    }
+    if (getDataType<totalNextRoute|string>(toRule) === '[object Object]') {
+        const {name, params, ...moreToRule} = (toRule as totalNextRoute);
+        let paramsQuery = params;
+        if (router.options.platform !== 'h5' && paramsQuery == null) {
+            paramsQuery = {};
+        }
+        if (name != null && paramsQuery != null) {
+            let route = (router.routesMap as routesMapRule).nameMap[name];
+            if (route == null) {
+                route = getWildcardRule(router, { type: 2, msg: `命名路由为：${name} 的路由，无法在路由表中找到！`, toRule});
+            }
+            const {finallyPath} = getRoutePath(route, router);
+            if (finallyPath.includes(':')) { // 动态路由无法使用 paramsToQuery
+                ERRORHOOK[0]({ type: 2, msg: `动态路由：${finallyPath} 无法使用 paramsToQuery！`, toRule}, router);
+            } else {
+                return {
+                    ...moreToRule,
+                    path: finallyPath as string,
+                    query: paramsQuery
+                }
+            }
+        }
+    }
+    return toRule
+}
+
+export function assertDeepObject(object:objectAny):boolean {
+    let arrMark = null;
+    try {
+        arrMark = JSON.stringify(object).match(/\{|\[|\}|\]/g);
+    } catch (error) {
+        warnLock(`传递的参数解析对象失败。` + error)
+    }
+    if (arrMark == null) {
+        return false
+    }
+    if (arrMark.length > 3) {
+        return true;
+    }
+    return false
+}
+
+export function baseClone<
+T extends {
+    [key:string]:any
+}, K extends keyof T
+>(
+    source:T,
+    target:Array<any>|objectAny
+):Array<any>|objectAny|null {
+    // 【Fixe】 https://github.com/SilurianYang/uni-simple-router/issues/292
+    // 小程序会将null解析为字符串 undefined 建议不要在参数中传递 null
+    if (source == null) {
+        target = source;
+    } else {
+        for (const key of Object.keys(source)) {
+            const dyKey = key as T[K];
+            if (source[key] === source) continue
+            if (typeof source[key] === 'object') {
+                target[dyKey] = getDataType<T>(source[key]) === '[object Array]' ? ([] as Array<any>) : ({} as objectAny)
+                target[dyKey] = baseClone(source[key], target[dyKey])
+            } else {
+                target[dyKey] = source[key]
+            }
+        }
+    }
+    return target;
+}
+
+export function deepClone<T>(source:T):T {
+    const __ob__ = getDataType<T>(source) === '[object Array]' ? ([] as Array<any>) : ({} as objectAny);
+    baseClone(source, __ob__)
+    return __ob__ as T
+}
+
+export function lockDetectWarn(
+    router:Router,
+    to:string|number|totalNextRoute|navRoute,
+    navType:NAVTYPE,
+    next:Function,
+    uniActualData:uniBackApiRule|uniBackRule|undefined = {},
+    passiveType?:'beforeHooks'| 'afterHooks'
+):void{
+    if (passiveType === 'afterHooks') {
+        next();
+    } else {
+        const {detectBeforeLock} = router.options;
+        detectBeforeLock && detectBeforeLock(router, to, navType);
+        if (router.$lockStatus) {
+            (router.options.routerErrorEach as (error: navErrorRule, router:Router) => void)({
+                type: 2,
+                msg: '当前页面正在处于跳转状态，请稍后再进行跳转....',
+                NAVTYPE: navType,
+                uniActualData
+            }, router);
+        } else {
+            next();
+        }
+    }
+}
+
+export function assertParentChild(
+    parentPath:string,
+    vueVim:any,
+):boolean {
+    while (vueVim.$parent != null) {
+        const mpPage = vueVim.$parent.$mp;
+        if (mpPage.page && mpPage.page.is === parentPath) {
+            return true;
+        }
+        vueVim = vueVim.$parent;
+    }
+    try {
+        if (vueVim.$mp.page.is === parentPath || vueVim.$mp.page.route === parentPath) {
+            return true
+        }
+    } catch (error) {
+        return false
+    }
+    return false
+}
+
+export function resolveAbsolutePath(
+    path:string,
+    router:Router
+):string|never {
+    const reg = /^\/?([^\?\s]+)(\?.+)?$/;
+    const trimPath = path.trim();
+    if (!reg.test(trimPath)) {
+        throw new Error(`【${path}】 路径错误，请提供完整的路径(10001)。`);
+    }
+    const paramsArray = trimPath.match(reg);
+    if (paramsArray == null) {
+        throw new Error(`【${path}】 路径错误，请提供完整的路径(10002)。`);
+    }
+    const query:string = paramsArray[2] || '';
+    if (/^\.\/[^\.]+/.test(trimPath)) { // 当前路径下
+        const navPath:string = router.currentRoute.path + path;
+        return navPath.replace(/[^\/]+\.\//, '');
+    }
+    const relative = paramsArray[1].replace(/\//g, `\\/`).replace(/\.\./g, `[^\\/]+`).replace(/\./g, '\\.');
+    const relativeReg = new RegExp(`^\\/${relative}$`);
+    const route = router.options.routes.filter(it => relativeReg.test(it.path));
+    if (route.length !== 1) {
+        throw new Error(`【${path}】 路径错误，尝试转成绝对路径失败，请手动转成绝对路径(10003)。`);
+    }
+    return route[0].path + query;
+}
+
+export function deepDecodeQuery(
+    query:objectAny
+):objectAny {
+    const formatQuery:objectAny = getDataType<objectAny>(query) === '[object Array]' ? [] : {};
+    const keys = Object.keys(query);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const it = query[key];
+        if (typeof it === 'string') {
+            try {
+                let json = JSON.parse(decodeURIComponent(it));
+                if (typeof json !== 'object') {
+                    json = it;
+                }
+                formatQuery[key] = json;
+            } catch (error) {
+                try {
+                    formatQuery[key] = decodeURIComponent(it)
+                } catch (error) {
+                    formatQuery[key] = it
+                }
+            }
+        } else if (typeof it === 'object') {
+            const childQuery = deepDecodeQuery(it);
+            formatQuery[key] = childQuery
+        } else {
+            formatQuery[key] = it
+        }
+    }
+    return formatQuery
+}

node_modules/uni-simple-router/src/helpers/warn.ts

@@ -0,0 +1,37 @@
+
+import {debuggerConfig, debuggerArrayConfig} from '../options/config'
+import {Router} from '../options/base'
+
+type callType='error'|'warn'|'log';
+
+export function isLog(type:callType, dev:debuggerConfig, errText:any, enforce:boolean = false):boolean {
+    if (!enforce) {
+        const isObject = dev.toString() === '[object Object]';
+        if (dev === false) {
+            return false
+        } else if (isObject) {
+            if ((dev as debuggerArrayConfig)[type] === false) {
+                return false;
+            }
+        }
+    }
+    console[type](errText);
+    return true;
+}
+export function err(errText:any, router:Router, enforce?:boolean):void {
+    const dev = (router.options.debugger as debuggerConfig);
+    isLog('error', dev, errText, enforce);
+}
+
+export function warn(errText:any, router:Router, enforce?:boolean):void {
+    const dev = (router.options.debugger as debuggerConfig);
+    isLog('warn', dev, errText, enforce);
+}
+
+export function log(errText:any, router:Router, enforce?:boolean):void {
+    const dev = (router.options.debugger as debuggerConfig);
+    isLog('log', dev, errText, enforce);
+}
+export function warnLock(errText:any):void {
+    console.warn(errText);
+}

node_modules/uni-simple-router/src/index.ts

@@ -0,0 +1,11 @@
+export * from './options/base'
+export * from './options/config'
+
+export {
+    runtimeQuit
+} from './app/appPatch'
+
+export {
+    RouterMount,
+    createRouter
+} from './public/router'

node_modules/uni-simple-router/src/options/base.ts

@@ -0,0 +1,245 @@
+import {InstantiateConfig, LifeCycleConfig} from '../options/config';
+
+export enum hookToggle{
+    'beforeHooks'='beforeEach',
+    'afterHooks'='afterEach',
+    'enterHooks'='beforeEnter'
+}
+export enum navtypeToggle{
+    'push'='navigateTo',
+    'replace'='redirectTo',
+    'replaceAll'='reLaunch',
+    'pushTab'='switchTab',
+    'back'='navigateBack'
+}
+export enum rewriteMethodToggle{
+    'navigateTo'='push',
+    'navigate'='push',
+    'redirectTo'='replace',
+    'reLaunch'='replaceAll',
+    'switchTab'='pushTab',
+    'navigateBack'='back',
+}
+export type proxyDepsRule={
+    resetIndex:Array<number>;
+    hooks: {
+        [key: number]:{
+            proxyHook:()=>void;
+            callHook:(enterPath:string)=>void;
+            resetHook: ()=>void
+        }
+    };
+    options: {[key: number]: Array<any>;};
+};
+export type backTypeRule='backbutton'|'navigateBack'
+export type pageTypeRule='app'|'page'|'component';
+export type vueHookNameRule='onLaunch'|'onShow'|'onHide'|'onError'|'onInit'|'onLoad'|'onReady'|'onUnload'|'onResize'|'created'|'beforeMount'|'mounted'|'beforeDestroy'|'destroyed'
+export type reNavMethodRule='navigateTo'|'redirectTo'|'reLaunch'|'switchTab';
+export type reNotNavMethodRule='navigateBack';
+export type reloadNavRule=totalNextRoute | false | undefined|string;
+export type hookListRule=Array<(router:Router, to:totalNextRoute, from: totalNextRoute, toRoute:RoutesRule,next:Function)=>void>
+export type guardHookRule=(to: totalNextRoute, from: totalNextRoute, next:(rule?: navtoRule|false)=>void)=>void;
+export type navRuleStatus=	0|1|2|3;  //0: next(false) 1:next(unknownType) 2:加锁状态，禁止跳转  3:在获取页面栈的时候，页面栈不够level获取
+export type proxyHookName='beforeHooks'|'afterHooks';
+export type navMethodRule = Promise<void | undefined | navRuleStatus>;
+export type objectAny={[propName: string]: any;};
+export type NAVTYPE = 'push' | 'replace' | 'replaceAll' | 'pushTab'|'back';
+export type startAnimationType =
+	| 'slide-in-right'
+	| 'slide-in-left'
+	| 'slide-in-top'
+	| 'slide-in-bottom'
+	| 'pop-in'
+	| 'fade-in'
+	| 'zoom-out'
+	| 'zoom-fade-out'
+	| 'none';
+export type endAnimationType =
+	| 'slide-out-right'
+	| 'slide-out-left'
+	| 'slide-out-top'
+	| 'slide-out-bottom'
+	| 'pop-out'
+	| 'fade-out'
+	| 'zoom-in'
+	| 'zoom-fade-in'
+	| 'none';
+
+export type vueOptionRule = {
+    [propName in vueHookNameRule]: Array<Function> | undefined;
+};
+
+// 跳转api时，传递的跳转规则
+export interface navtoRule {
+	NAVTYPE?: NAVTYPE; // 跳转类型 v1.1.0+
+	path?: string; // 跳转路径 绝对路径
+	name?: string | undefined; // 跳转路径名称
+	query?: objectAny; // 跳转使用path时 query包含需要传递的参数
+	params?: objectAny; // 跳转使用name时 params包含需要传递的参数
+	animationType?: startAnimationType|endAnimationType;
+	animationDuration?: number;
+	events?: objectAny;
+	success?: Function;
+	fail?: Function;
+	complete?: Function;
+}
+// h5 next管道函数中传递的from及to对象
+export interface h5NextRule {
+	fullPath?: string | undefined;
+	hash?: string | undefined;
+	matched?: Array<object>;
+	meta?: object;
+	name?: undefined | string;
+	type?: undefined | string;
+}
+
+export interface totalNextRoute extends h5NextRule, navtoRule {
+    path:string;
+    delta?:number;
+    [propName: string]: any;
+}
+export interface navRoute extends h5NextRule, navtoRule {
+
+}
+
+// 开始切换窗口动画 app端可用
+export interface startAnimationRule {
+	animationType?: startAnimationType; // 窗口关闭的动画效果
+	animationDuration?: number; // 窗口关闭动画的持续时间
+}
+// 关闭窗口时的动画 app端可用
+export interface endAnimationRule {
+	animationType?: endAnimationType; // 窗口关闭的动画效果
+	animationDuration?: number; // 窗口关闭动画的持续时间
+}
+export interface hookObjectRule {
+    options:Array<any>;
+    hook:Function;
+}
+
+// 执行路由跳转失败或者 next(false) 时走的规则
+export interface navErrorRule {
+	type: navRuleStatus;
+    msg: string;
+    to?:totalNextRoute;
+    from?:totalNextRoute;
+    nextTo?:any;
+    [propName:string]:any;
+}
+// uni原生api跳转时的规则
+export interface uniNavApiRule {
+    url: string;
+    openType?:'appLaunch',
+    query?:objectAny;
+    path?:string;
+    delta?:number;
+    detail?:{[propName:string]:any};
+    animationType?:startAnimationType;
+    animationDuration?:number;
+    events?:{[propName:string]:any};
+    success?:Function;
+    fail?:Function;
+    complete?:Function;
+    animation?:{
+        animationType?:startAnimationType;
+        animationDuration?:number;
+    }
+}
+
+export interface originMixins extends uniNavApiRule{
+    BACKTYPE:''|backTypeRule
+}
+
+// uni-app 原始返回api 回调参数
+export interface uniBackRule{
+    from:backTypeRule;
+}
+
+export interface uniBackApiRule{
+    delta?: number;
+    animationDuration?: number;
+    animationType?:endAnimationType;
+}
+
+export type routesMapKeysRule=
+    'finallyPathList'|
+    'finallyPathMap'|
+    'aliasPathMap'|
+    'pathMap'|
+    'nameMap'|
+    'vueRouteMap';
+
+export interface routesMapRule{
+    [key:string]:any;
+    finallyPathList: Array<string>;
+    finallyPathMap:RoutesRule;
+    aliasPathMap: RoutesRule;
+    pathMap: RoutesRule;
+    nameMap:RoutesRule,
+    vueRouteMap:objectAny
+}
+
+export interface routeRule{
+    name:string|undefined;
+    meta:objectAny;
+    path:string;
+    query:objectAny;
+    params:objectAny;
+    fullPath:string;
+    NAVTYPE:NAVTYPE|'';
+    BACKTYPE?:backTypeRule|'';    // v2.0.5 +
+    [propName: string]: any;
+}
+
+
+export interface RoutesRule {
+	path: string; // pages.json中的path 必须加上 '/' 开头
+	component?: object; // H5端可用
+	name?: string; // 命名路由
+	components?: object; // 命名视图组件，H5端可用
+	redirect?: string | Function; // H5端可用
+	props?: boolean | object | Function; // H5端可用
+	aliasPath?: string; // h5端 设置一个别名路径来替换 uni-app的默认路径
+	alias?: string | Array<string>; // H5端可用
+	children?: Array<RoutesRule>; // 嵌套路由，H5端可用
+	beforeEnter?:guardHookRule; // 路由元守卫
+	meta?: any; // 其他格外参数
+	[propName: string]: any;
+}
+
+export interface Router {
+    [key:string]:any;
+	readonly lifeCycle: LifeCycleConfig;
+    readonly options: InstantiateConfig;
+    $lockStatus:boolean;
+    $route: object | null;
+    enterPath:string;
+    Vue:any;
+    appMain:{
+        NAVTYPE:reNavMethodRule|reNotNavMethodRule,
+        path:string
+    }|{};
+    proxyHookDeps: proxyDepsRule;
+	routesMap: routesMapRule|{};
+	mount: Array<{app: any; el: string}>;
+	install(Vue: any): void;
+	push(to: totalNextRoute|navRoute | string,from?:totalNextRoute): void; // 动态的导航到一个新 URL 保留浏览历史
+	replace(to: totalNextRoute|navRoute | string,from?:totalNextRoute): void; // 动态的导航到一个新 URL 关闭当前页面，跳转到的某个页面。
+	replaceAll(to: totalNextRoute|navRoute | string,from?:totalNextRoute): void; // 动态的导航到一个新 URL 关闭所有页面，打开到应用内的某个页面
+	pushTab(to: totalNextRoute|navRoute | string,from?:totalNextRoute): void; // 动态的导航到一个新 url 关闭所有页面，打开到应用内的某个tab
+    back(level:number|undefined,origin?:uniBackRule|uniBackApiRule):void;
+    forceGuardEach(navType:NAVTYPE|undefined,forceNav:boolean):void;      //强制触发当前守卫
+    beforeEach(userGuard:guardHookRule): void; // 添加全局前置路由守卫
+    afterEach(userGuard:(to: totalNextRoute, from: totalNextRoute)=>void): void; // 添加全局后置路由守卫
+}
+
+
+export type PromiseResolve=(value?: void | PromiseLike<void> | undefined) => void;
+
+// @ts-ignore
+declare module 'vue/types/vue' {
+	interface Vue {
+		$Router: Router;
+		$Route: routeRule;
+	}
+}

node_modules/uni-simple-router/src/options/config.ts

@@ -0,0 +1,57 @@
+import {startAnimationRule, hookListRule, RoutesRule, navtoRule, navErrorRule, Router, objectAny, NAVTYPE, totalNextRoute, navRoute} from './base';
+
+export type debuggerConfig=boolean|debuggerArrayConfig;
+export type platformRule='h5'|'app-plus'|'app-lets'|'mp-weixin'|'mp-baidu'|'mp-alipay'|'mp-toutiao'|'mp-qq'|'mp-360';
+
+export interface H5Config {
+	paramsToQuery?: boolean; // h5端上通过params传参时规则是vue-router 刷新会丢失 开启此开关将变成?连接的方式
+	vueRouterDev?: boolean; // 完全使用采用vue-router的开发模式
+	vueNext?: boolean; // 在next管道函数中是否获取vueRouter next的原本参数
+	mode?: string;
+	base?: string;
+	linkActiveClass?: string;
+	linkExactActiveClass?: string;
+	scrollBehavior?: Function;
+	fallback?: boolean;
+}
+export interface AppConfig {
+    registerLoadingPage?:boolean; // 是否注册过渡加载页  +v2.0.6
+	loadingPageStyle?: () => object; // 当前等待页面的样式 必须返回一个json
+    loadingPageHook?: (view:any)=>void; // 刚刚打开页面处于等待状态,会触发此函数
+    launchedHook?:()=>void; // 首次启动app完成
+    animation?: startAnimationRule; // 页面切换动画
+}
+export interface appletConfig {
+    animationDuration?:number; // 页面切换时间，有助于路由锁精准解锁
+}
+
+export interface debuggerArrayConfig{
+    error?:boolean;
+    warn?:boolean;
+    log?:boolean;
+}
+
+export interface InstantiateConfig {
+    [key:string]:any;
+    keepUniOriginNav?:boolean; // 重写uni-app的跳转方法；关闭后使用uni-app的原始方法跳转和插件api跳转等同
+    platform:platformRule; // 当前运行平台
+    h5?: H5Config;
+	APP?: AppConfig;
+    applet?:appletConfig;
+	debugger?: debuggerConfig; // 是否处于开发阶段 设置为true则打印日志
+	routerBeforeEach?: (to:navtoRule, from:navtoRule, next:(rule?: navtoRule|false)=>void) => void; // router 前置路由函数 每次触发跳转前先会触发此函数
+	routerAfterEach?: (to:navtoRule, from:navtoRule, next?: Function) => void; // router 后置路由函数 每次触发跳转后会触发此函数
+    routerErrorEach?: (error: navErrorRule, router:Router) => void;
+    resolveQuery?:(jsonQuery:objectAny)=>objectAny; // 跳转之前把参数传递给此函数、返回最终的数据！有此函数不走默认方法
+    parseQuery?:(jsonQuery:objectAny)=>objectAny; // 读取值之前把参数传递给此函数，返回最终的数据！有此函数不走默认方法
+    detectBeforeLock?:(router:Router, to:string|number|totalNextRoute|navRoute, navType:NAVTYPE)=>void; // 在检测路由锁之前触发的函数
+    routes: RoutesRule[];
+}
+export interface LifeCycleConfig{
+    beforeHooks: hookListRule;
+    afterHooks: hookListRule;
+    routerBeforeHooks: hookListRule;
+    routerAfterHooks: hookListRule;
+    routerErrorHooks: Array<(error:navErrorRule, router:Router)=>void>;
+}
+

node_modules/uni-simple-router/src/public/hooks.ts

@@ -0,0 +1,177 @@
+import {
+    Router,
+    hookListRule,
+    navtoRule,
+    reloadNavRule,
+    totalNextRoute,
+    hookToggle,
+    NAVTYPE,
+    navErrorRule,
+    objectAny
+} from '../options/base';
+import {
+    routesForMapRoute,
+    getDataType,
+    forMatNextToFrom,
+    getUniCachePage,
+    voidFun
+} from '../helpers/utils'
+import { navjump } from './methods';
+import { proxyH5Mount } from '../H5/proxyHook';
+import { tabIndexSelect } from '../app/appPatch';
+
+export const ERRORHOOK:Array<(error:navErrorRule, router:Router)=>void> = [
+    (error, router) => router.lifeCycle.routerErrorHooks[0](error, router)
+]
+export const HOOKLIST: hookListRule = [
+    (router, to, from, toRoute, next) => callHook(router.lifeCycle.routerBeforeHooks[0], to, from, router, next),
+    (router, to, from, toRoute, next) => callBeforeRouteLeave(router, to, from, next),
+    (router, to, from, toRoute, next) => callHook(router.lifeCycle.beforeHooks[0], to, from, router, next),
+    (router, to, from, toRoute, next) => callHook(toRoute.beforeEnter, to, from, router, next),
+    (router, to, from, toRoute, next) => callHook(router.lifeCycle.afterHooks[0], to, from, router, next, false),
+    (router, to, from, toRoute, next) => {
+        router.$lockStatus = false;
+        if (router.options.platform === 'h5') {
+            proxyH5Mount(router);
+        }
+        return callHook(router.lifeCycle.routerAfterHooks[0], to, from, router, next, false)
+    }
+];
+
+export function callBeforeRouteLeave(
+    router:Router,
+    to:totalNextRoute,
+    from:totalNextRoute,
+    resolve:Function
+):void {
+    const page = getUniCachePage<objectAny>(0);
+    let beforeRouteLeave;
+    if (Object.keys(page).length > 0) {
+        let leaveHooks:Array<Function>|undefined|Function;
+        if (router.options.platform === 'h5') {
+            leaveHooks = (page as objectAny).$options.beforeRouteLeave;
+        } else {
+            if ((page as objectAny).$vm != null) {
+                leaveHooks = (page as objectAny).$vm.$options.beforeRouteLeave;
+            }
+        }
+        switch (getDataType<Array<Function>>((leaveHooks as Array<Function>))) {
+        case '[object Array]': // h5端表现
+            beforeRouteLeave = (leaveHooks as Array<Function>)[0];
+            beforeRouteLeave = beforeRouteLeave.bind(page)
+            break;
+        case '[object Function]': // 目前app端表现
+            beforeRouteLeave = (leaveHooks as Function).bind((page as objectAny).$vm);
+            break
+        }
+    }
+    return callHook(beforeRouteLeave, to, from, router, resolve);
+}
+
+export function callHook(
+    hook:Function|undefined,
+    to:totalNextRoute,
+    from: totalNextRoute,
+    router:Router,
+    resolve:Function,
+    hookAwait:boolean|undefined = true
+):void {
+    if (hook != null && hook instanceof Function) {
+        if (hookAwait === true) {
+            hook(to, from, resolve, router, false);
+        } else {
+            hook(to, from, () => {}, router, false);
+            resolve();
+        }
+    } else {
+        resolve();
+    }
+}
+
+export function onTriggerEachHook(
+    to:totalNextRoute,
+    from: totalNextRoute,
+    router:Router,
+    hookType:hookToggle,
+    next:(rule?: navtoRule|false)=>void,
+):void {
+    let callHookList:hookListRule = [];
+    switch (hookType) {
+    case 'beforeEach':
+        callHookList = HOOKLIST.slice(0, 3);
+        break;
+    case 'afterEach':
+        callHookList = HOOKLIST.slice(4);
+        break
+    case 'beforeEnter':
+        callHookList = HOOKLIST.slice(3, 4);
+        break;
+    }
+    transitionTo(router, to, from, 'push', callHookList, next);
+}
+
+export function transitionTo(
+    router:Router,
+    to:totalNextRoute,
+    from: totalNextRoute,
+    navType:NAVTYPE,
+    callHookList:hookListRule,
+    hookCB:Function
+) :void{
+    const {matTo, matFrom} = forMatNextToFrom<totalNextRoute>(router, to, from);
+    if (router.options.platform === 'h5') {
+        loopCallHook(callHookList, 0, hookCB, router, matTo, matFrom, navType);
+    } else {
+        loopCallHook(callHookList.slice(0, 4), 0, () => {
+            hookCB(() => { // 非H5端等他跳转完才触发最后两个生命周期
+                loopCallHook(callHookList.slice(4), 0, voidFun, router, matTo, matFrom, navType);
+            });
+        }, router, matTo, matFrom, navType);
+    }
+}
+
+export function loopCallHook(
+    hooks:hookListRule,
+    index:number,
+    next:Function,
+    router:Router,
+    matTo:totalNextRoute,
+    matFrom: totalNextRoute,
+    navType:NAVTYPE,
+): void|Function {
+    const toRoute = routesForMapRoute(router, matTo.path, ['finallyPathMap', 'pathMap']);
+    if (hooks.length - 1 < index) {
+        return next();
+    }
+    const hook = hooks[index];
+    const errHook = ERRORHOOK[0];
+    hook(router, matTo, matFrom, toRoute, (nextTo:reloadNavRule) => {
+        if (router.options.platform === 'app-plus') {
+            if (nextTo === false || (typeof nextTo === 'string' || typeof nextTo === 'object')) {
+                tabIndexSelect(matTo, matFrom);
+            }
+        }
+        if (nextTo === false) {
+            if (router.options.platform === 'h5') {
+                next(false);
+            }
+            errHook({ type: 0, msg: '管道函数传递 false 导航被终止!', matTo, matFrom, nextTo }, router)
+        } else if (typeof nextTo === 'string' || typeof nextTo === 'object') {
+            let newNavType = navType;
+            let newNextTo = nextTo;
+            if (typeof nextTo === 'object') {
+                const {NAVTYPE: type, ...moreTo} = nextTo;
+                newNextTo = moreTo;
+                if (type != null) {
+                    newNavType = type;
+                }
+            }
+            navjump(newNextTo, router, newNavType, {from: matFrom, next})
+        } else if (nextTo == null) {
+            index++;
+            loopCallHook(hooks, index, next, router, matTo, matFrom, navType)
+        } else {
+            errHook({ type: 1, msg: '管道函数传递未知类型，无法被识别。导航被终止！', matTo, matFrom, nextTo }, router)
+        }
+    });
+}

node_modules/uni-simple-router/src/public/methods.ts

@@ -0,0 +1,258 @@
+import {
+    NAVTYPE,
+    Router,
+    totalNextRoute,
+    objectAny,
+    routeRule,
+    reNavMethodRule,
+    rewriteMethodToggle,
+    navtypeToggle,
+    navErrorRule,
+    uniBackApiRule,
+    uniBackRule,
+    navRoute
+} from '../options/base'
+import {
+    queryPageToMap,
+    resolveQuery,
+    parseQuery
+} from './query'
+import {
+    voidFun,
+    paramsToQuery,
+    getUniCachePage,
+    routesForMapRoute,
+    copyData,
+    lockDetectWarn,
+    getDataType,
+    notRouteTo404,
+    deepDecodeQuery
+} from '../helpers/utils'
+import { transitionTo } from './hooks';
+import {createFullPath, createToFrom} from '../public/page'
+import {HOOKLIST} from './hooks'
+
+export function lockNavjump(
+    to:string|totalNextRoute|navRoute,
+    router:Router,
+    navType:NAVTYPE,
+    forceNav?:boolean,
+    animation?:uniBackApiRule|uniBackRule
+):void{
+    lockDetectWarn(router, to, navType, () => {
+        if (router.options.platform !== 'h5') {
+            router.$lockStatus = true;
+        }
+        navjump(to as totalNextRoute, router, navType, undefined, forceNav, animation);
+    }, animation);
+}
+export function navjump(
+    to:string|totalNextRoute,
+    router:Router,
+    navType:NAVTYPE,
+    nextCall?:{
+        from:totalNextRoute;
+        next:Function;
+    },
+    forceNav?:boolean,
+    animation?:uniBackApiRule|uniBackRule,
+    callHook:boolean|undefined = true
+) :void|never|totalNextRoute {
+    if (navType === 'back') {
+        let level:number = 1;
+        if (typeof to === 'string') {
+            level = +to;
+        } else {
+            level = to.delta || 1;
+        }
+        if (router.options.platform === 'h5') {
+            (router.$route as any).go(-level);
+
+            // Fixe  https://github.com/SilurianYang/uni-simple-router/issues/266   2021年6月3日11:14:38
+            // @ts-ignore
+            const success = (animation || {success: voidFun}).success || voidFun;
+            // @ts-ignore
+            const complete = (animation || {complete: voidFun}).complete || voidFun;
+            success({errMsg: 'navigateBack:ok'});
+            complete({errMsg: 'navigateBack:ok'});
+            return;
+        } else {
+            to = backOptionsBuild(router, level, animation);
+        }
+    }
+    const {rule} = queryPageToMap(to, router);
+    rule.type = navtypeToggle[navType];
+    const toRule = paramsToQuery(router, rule);
+    let parseToRule = resolveQuery(toRule as totalNextRoute, router);
+    if (router.options.platform === 'h5') {
+        if (navType !== 'push') {
+            navType = 'replace';
+        }
+        if (nextCall != null) { // next 管道函数拦截时 直接next即可
+            nextCall.next({
+                replace: navType !== 'push',
+                ...parseToRule
+            })
+        } else {
+            // Fixe  https://github.com/SilurianYang/uni-simple-router/issues/240   2021年3月7日14:45:36
+            if (navType === 'push' && Reflect.has(parseToRule, 'events')) {
+                if (Reflect.has(parseToRule, 'name')) {
+                    throw new Error(`在h5端上使用 'push'、'navigateTo' 跳转时，如果包含 events 不允许使用 name 跳转，因为 name 实现了动态路由。请更换为 path 或者 url 跳转！`);
+                } else {
+                    uni['navigateTo'](parseToRule, true, voidFun, forceNav);
+                }
+            } else {
+                (router.$route as any)[navType](parseToRule, (parseToRule as totalNextRoute).success || voidFun, (parseToRule as totalNextRoute).fail || voidFun)
+            }
+        }
+    } else {
+        let from:totalNextRoute = {path: ''};
+        if (nextCall == null) {
+            let toRoute = routesForMapRoute(router, parseToRule.path, ['finallyPathMap', 'pathMap']);
+            toRoute = notRouteTo404(router, toRoute, parseToRule, navType);
+            parseToRule = { ...toRoute, ...{params: {}}, ...parseToRule, ...{path: toRoute.path} }
+            from = createToFrom(parseToRule, router);
+        } else {
+            from = nextCall.from;
+        }
+        createFullPath(parseToRule, from);
+        if (callHook === false) {
+            return parseToRule;
+        }
+        transitionTo(router, parseToRule, from, navType, HOOKLIST, function(
+            callOkCb:Function
+        ):void {
+            uni[navtypeToggle[navType]](parseToRule, true, callOkCb, forceNav);
+        })
+    }
+}
+
+export function backOptionsBuild(
+    router:Router,
+    level:number,
+    animation:uniBackApiRule|uniBackRule|undefined = {},
+):totalNextRoute {
+    const toRule = createRoute(router, level, undefined, {NAVTYPE: 'back', ...animation});
+    const navjumpRule:totalNextRoute = {
+        ...animation,
+        path: toRule.path,
+        query: toRule.query,
+        delta: level
+    }
+    if (getDataType<any>(animation) === '[object Object]') {
+        const {animationDuration, animationType} = (animation as uniBackApiRule)
+        if (animationDuration != null) {
+            navjumpRule.animationDuration = animationDuration;
+        }
+        if (animationType != null) {
+            navjumpRule.animationType = animationType;
+        }
+
+        const {from} = (animation as uniBackRule)
+        if (from != null) {
+            navjumpRule.BACKTYPE = from;
+        }
+    }
+    return navjumpRule;
+}
+
+export function forceGuardEach(
+    router:Router,
+    navType:NAVTYPE|undefined = 'replaceAll',
+    forceNav:undefined|boolean = false
+):void|never {
+    if (router.options.platform === 'h5') {
+        throw new Error(`在h5端上使用：forceGuardEach 是无意义的，目前 forceGuardEach 仅支持在非h5端上使用`);
+    }
+    const currentPage = getUniCachePage<objectAny>(0);
+    if (Object.keys(currentPage).length === 0) {
+        (router.options.routerErrorEach as (error: navErrorRule, router:Router) => void)({
+            type: 3,
+            NAVTYPE: navType,
+            uniActualData: {},
+            level: 0,
+            msg: `不存在的页面栈，请确保有足够的页面可用，当前 level:0`
+        }, router);
+    }
+    const {route, options} = currentPage as objectAny;
+    lockNavjump({
+        path: `/${route}`,
+        query: deepDecodeQuery(options || {})
+    }, router, navType, forceNav);
+}
+
+export function createRoute(
+    router:Router,
+    level:number|undefined = 0,
+    orignRule?:totalNextRoute,
+    uniActualData:objectAny|undefined = {},
+):routeRule|never {
+    const route:routeRule = {
+        name: '',
+        meta: {},
+        path: '',
+        fullPath: '',
+        NAVTYPE: '',
+        query: {},
+        params: {},
+        BACKTYPE: (orignRule || {BACKTYPE: ''}).BACKTYPE || '' // v2.0.5 +
+    };
+
+    if (level === 19970806) { // 首次构建响应式 页面不存在 直接返回
+        return route
+    }
+    if (router.options.platform === 'h5') {
+        let vueRoute:totalNextRoute = {path: ''};
+        if (orignRule != null) {
+            vueRoute = orignRule;
+        } else {
+            vueRoute = (router.$route as objectAny).currentRoute;
+        }
+        const matRouteParams = copyData(vueRoute.params as objectAny);
+        delete matRouteParams.__id__;
+        const toQuery = parseQuery({...matRouteParams, ...copyData(vueRoute.query as objectAny)}, router);
+        vueRoute = {...vueRoute, query: toQuery}
+        route.path = vueRoute.path;
+        route.fullPath = vueRoute.fullPath || '';
+        route.query = deepDecodeQuery(vueRoute.query || {});
+        route.NAVTYPE = rewriteMethodToggle[vueRoute.type as reNavMethodRule || 'reLaunch'];
+    } else {
+        let appPage:objectAny = {};
+        if (orignRule != null) {
+            appPage = {...orignRule, openType: orignRule.type};
+        } else {
+            const page = getUniCachePage<objectAny>(level);
+            if (Object.keys(page).length === 0) {
+                const {NAVTYPE: _NAVTYPE, ..._args} = uniActualData;
+                const errorMsg:string = `不存在的页面栈，请确保有足够的页面可用，当前 level:${level}`;
+                (router.options.routerErrorEach as (error: navErrorRule, router:Router) => void)({
+                    type: 3,
+                    msg: errorMsg,
+                    NAVTYPE: _NAVTYPE,
+                    level,
+                    uniActualData: _args
+                }, router);
+                throw new Error(errorMsg);
+            }
+            // Fixes: https://github.com/SilurianYang/uni-simple-router/issues/196
+            const pageOptions:objectAny = (page as objectAny).options || {};
+            appPage = {
+                ...(page as objectAny).$page || {},
+                query: deepDecodeQuery(pageOptions),
+                fullPath: decodeURIComponent(((page as objectAny).$page || {}).fullPath || '/' + (page as objectAny).route)
+            }
+            if (router.options.platform !== 'app-plus') {
+                appPage.path = `/${(page as objectAny).route}`
+            }
+        }
+        const openType:reNavMethodRule|'navigateBack' = appPage.openType;
+        route.query = appPage.query;
+        route.path = appPage.path;
+        route.fullPath = appPage.fullPath;
+        route.NAVTYPE = rewriteMethodToggle[openType || 'reLaunch'];
+    }
+    const tableRoute = routesForMapRoute(router, route.path, ['finallyPathMap', 'pathMap'])
+    const perfectRoute = { ...route, ...tableRoute};
+    perfectRoute.query = parseQuery(perfectRoute.query, router);
+    return perfectRoute;
+}

node_modules/uni-simple-router/src/public/page.ts

@@ -0,0 +1,103 @@
+import { proxyHookName } from '../helpers/config';
+import { getDataType, getUniCachePage, deepClone} from '../helpers/utils';
+import { objectAny, pageTypeRule, Router, totalNextRoute, vueOptionRule } from '../options/base';
+import {createRoute} from './methods'
+import { stringifyQuery } from './query';
+
+export function createToFrom(
+    to:totalNextRoute,
+    router:Router,
+):totalNextRoute {
+    let fromRoute:totalNextRoute = {path: ''};
+    const page = getUniCachePage<Array<any>|objectAny>(0);
+    if (getDataType<Array<any>|objectAny>(page) === '[object Array]') {
+        fromRoute = deepClone<totalNextRoute>(to)
+    } else {
+        fromRoute = createRoute(router) as totalNextRoute;
+    }
+    return fromRoute;
+}
+
+export function createFullPath(
+    to:totalNextRoute,
+    from:totalNextRoute
+):void{
+    if (to.fullPath == null) {
+        const strQuery = stringifyQuery(to.query as objectAny);
+        to.fullPath = to.path + strQuery;
+    }
+    if (from.fullPath == null) {
+        const strQuery = stringifyQuery(from.query as objectAny);
+        from.fullPath = from.path + strQuery;
+    }
+}
+
+export function proxyPageHook(
+    vueVim:any,
+    router:Router,
+    pageType:pageTypeRule
+):void {
+    const hookDeps = router.proxyHookDeps;
+    const pageHook:vueOptionRule = vueVim.$options;
+    for (let i = 0; i < proxyHookName.length; i++) {
+        const hookName = proxyHookName[i];
+        const hookList = pageHook[hookName];
+        if (hookList) {
+            for (let k = 0; k < hookList.length; k++) {
+                const originHook = hookList[k];
+                if (originHook.toString().includes($npm_package_name)) {
+                    continue
+                }
+                const resetIndex = Object.keys(hookDeps.hooks).length + 1
+                const proxyHook = (...args:Array<any>):void => {
+                    hookDeps.resetIndex.push(resetIndex);
+                    hookDeps.options[resetIndex] = args;
+                }
+                const [resetHook] = hookList.splice(k, 1, proxyHook);
+                hookDeps.hooks[resetIndex] = {
+                    proxyHook,
+                    callHook: (enterPath:string) :void => {
+                        if (router.enterPath.replace(/^\//, '') !== enterPath.replace(/^\//, '') && pageType !== 'app') {
+                            return;
+                        }
+                        const options = hookDeps.options[resetIndex];
+                        resetHook.apply(vueVim, options);
+                    },
+                    resetHook: () :void => {
+                        hookList.splice(k, 1, resetHook)
+                    }
+                };
+            }
+        }
+    }
+}
+export function resetAndCallPageHook(
+    router:Router,
+    enterPath:string,
+    reset:boolean|undefined = true
+):void{
+    // Fixe: https://github.com/SilurianYang/uni-simple-router/issues/206
+    const pathInfo = enterPath.trim().match(/^(\/?[^\?\s]+)(\?[\s\S]*$)?$/);
+    if (pathInfo == null) {
+        throw new Error(`还原hook失败。请检查 【${enterPath}】 路径是否正确。`);
+    }
+    enterPath = pathInfo[1];
+    const proxyHookDeps = router.proxyHookDeps;
+    const resetHooksArray = proxyHookDeps.resetIndex
+    for (let i = 0; i < resetHooksArray.length; i++) {
+        const index = resetHooksArray[i];
+        const {callHook} = proxyHookDeps.hooks[index];
+        callHook(enterPath);
+    }
+    if (reset) {
+        resetPageHook(router);
+    }
+}
+export function resetPageHook(
+    router:Router
+) {
+    const proxyHookDeps = router.proxyHookDeps;
+    for (const [, {resetHook}] of Object.entries(proxyHookDeps.hooks)) {
+        resetHook();
+    }
+}

node_modules/uni-simple-router/src/public/query.ts

@@ -0,0 +1,200 @@
+import {
+    objectAny,
+    Router,
+    routesMapRule,
+    RoutesRule,
+    totalNextRoute
+} from '../options/base';
+import {
+    getDataType,
+    urlToJson,
+    routesForMapRoute,
+    getRoutePath,
+    assertDeepObject,
+    copyData,
+    getWildcardRule,
+    deepDecodeQuery
+} from '../helpers/utils'
+import {ERRORHOOK} from './hooks'
+import {warn} from '../helpers/warn'
+
+const encodeReserveRE = /[!'()*]/g
+const encodeReserveReplacer = (c:string) => '%' + c.charCodeAt(0).toString(16)
+const commaRE = /%2C/g
+
+const encode = (str:string) =>
+    encodeURIComponent(str)
+        .replace(encodeReserveRE, encodeReserveReplacer)
+        .replace(commaRE, ',')
+
+export function queryPageToMap(
+    toRule:string|totalNextRoute,
+    router:Router
+) :{
+    rule:totalNextRoute;
+    route:RoutesRule,
+    query:objectAny
+} {
+    let query:objectAny = {};
+    let route:RoutesRule|string = '';
+    let successCb = (toRule as totalNextRoute).success;
+    let failCb = (toRule as totalNextRoute).fail;
+    if (getDataType<string|totalNextRoute>(toRule) === '[object Object]') {
+        const objNavRule = (toRule as totalNextRoute);
+        if (objNavRule.path != null) {
+            const {path, query: newQuery} = urlToJson(objNavRule.path);
+            route = routesForMapRoute(router, path, ['finallyPathList', 'pathMap']);
+            query = {...newQuery, ...((toRule as totalNextRoute).query || {})};
+            objNavRule.path = path;
+            objNavRule.query = query;
+            delete (toRule as totalNextRoute).params;
+        } else if (objNavRule.name != null) {
+            route = (router.routesMap as routesMapRule).nameMap[objNavRule.name];
+            if (route == null) {
+                route = getWildcardRule(router, { type: 2, msg: `命名路由为：${objNavRule.name} 的路由，无法在路由表中找到！`, toRule});
+            } else {
+                query = (toRule as totalNextRoute).params || {};
+                delete (toRule as totalNextRoute).query;
+            }
+        } else {
+            route = getWildcardRule(router, { type: 2, msg: `${toRule} 解析失败，请检测当前路由表下是否有包含。`, toRule});
+        }
+    } else {
+        toRule = urlToJson((toRule as string)) as totalNextRoute;
+        route = routesForMapRoute(router, toRule.path, ['finallyPathList', 'pathMap'])
+        query = toRule.query as objectAny;
+    }
+    if (router.options.platform === 'h5') {
+        const {finallyPath} = getRoutePath(route as RoutesRule, router);
+        if (finallyPath.includes(':') && (toRule as totalNextRoute).name == null) {
+            ERRORHOOK[0]({ type: 2, msg: `当有设置 alias或者aliasPath 为动态路由时，不允许使用 path 跳转。请使用 name 跳转！`, route}, router)
+        }
+        const completeCb = (toRule as totalNextRoute).complete;
+        const cacheSuccess = (toRule as totalNextRoute).success;
+        const cacheFail = (toRule as totalNextRoute).fail;
+        if (getDataType<Function|undefined>(completeCb) === '[object Function]') {
+            const publicCb = function(this:any, args:Array<any>, callHook:Function|undefined):void {
+                if (getDataType<Function|undefined>(callHook) === '[object Function]') {
+                    (callHook as Function).apply(this, args);
+                }
+                (completeCb as Function).apply(this, args);
+            }
+            successCb = function(this:any, ...args:any):void{
+                publicCb.call(this, args, cacheSuccess);
+            };
+            failCb = function(this:any, ...args:any):void{
+                publicCb.call(this, args, cacheFail);
+            };
+        }
+    }
+    const rule = (toRule as totalNextRoute);
+    if (getDataType<Function|undefined>(rule.success) === '[object Function]') {
+        rule.success = successCb;
+    }
+    if (getDataType<Function|undefined>(rule.fail) === '[object Function]') {
+        rule.fail = failCb;
+    }
+    return {
+        rule,
+        route: (route as RoutesRule),
+        query
+    }
+}
+
+export function resolveQuery(
+    toRule:totalNextRoute,
+    router:Router
+):totalNextRoute {
+    let queryKey:'params'|'query' = 'query';
+    if (toRule.params as objectAny != null) {
+        queryKey = 'params';
+    }
+    if (toRule.query as objectAny != null) {
+        queryKey = 'query';
+    }
+    const query = copyData(toRule[queryKey] || {});
+    const {resolveQuery: userResolveQuery} = router.options;
+    if (userResolveQuery) {
+        const jsonQuery = userResolveQuery(query);
+        if (getDataType<objectAny>(jsonQuery) !== '[object Object]') {
+            warn('请按格式返回参数： resolveQuery?:(jsonQuery:{[propName: string]: any;})=>{[propName: string]: any;}', router)
+        } else {
+            toRule[queryKey] = jsonQuery;
+        }
+    } else {
+        const deepObj = assertDeepObject(query as objectAny);
+        if (!deepObj) {
+            return toRule;
+        }
+        const encode = JSON.stringify(query);
+        toRule[queryKey] = {
+            query: encode
+        }
+    }
+    return toRule
+}
+
+export function parseQuery(
+    query:objectAny,
+    router:Router,
+):objectAny {
+    const {parseQuery: userParseQuery} = router.options;
+    if (userParseQuery) {
+        query = userParseQuery(copyData(query));
+        if (getDataType<objectAny>(query) !== '[object Object]') {
+            warn('请按格式返回参数： parseQuery?:(jsonQuery:{[propName: string]: any;})=>{[propName: string]: any;}', router)
+        }
+    } else {
+        if (Reflect.get(query, 'query')) { // 验证一下是不是深度对象
+            let deepQuery = Reflect.get(query, 'query');
+            if (typeof deepQuery === 'string') {
+                try {
+                    deepQuery = JSON.parse(deepQuery);
+                } catch (error) {
+                    warn('尝试解析深度对象失败，按原样输出。' + error, router)
+                }
+            }
+            if (typeof deepQuery === 'object') {
+                return deepDecodeQuery(deepQuery);
+            }
+        }
+    }
+    return query
+}
+
+export function stringifyQuery(obj:objectAny): string {
+    const res = obj
+        ? Object.keys(obj)
+            .map(key => {
+                const val = obj[key]
+
+                if (val === undefined) {
+                    return ''
+                }
+
+                if (val === null) {
+                    return encode(key)
+                }
+
+                if (Array.isArray(val)) {
+                    const result:Array<any> = []
+                    val.forEach(val2 => {
+                        if (val2 === undefined) {
+                            return
+                        }
+                        if (val2 === null) {
+                            result.push(encode(key))
+                        } else {
+                            result.push(encode(key) + '=' + encode(val2))
+                        }
+                    })
+                    return result.join('&')
+                }
+
+                return encode(key) + '=' + encode(val)
+            })
+            .filter(x => x.length > 0)
+            .join('&')
+        : null
+    return res ? `?${res}` : ''
+}

node_modules/uni-simple-router/src/public/rewrite.ts

@@ -0,0 +1,158 @@
+import {
+    uniNavApiRule,
+    reNavMethodRule,
+    reNotNavMethodRule,
+    Router,
+    rewriteMethodToggle,
+    uniBackRule,
+    uniBackApiRule,
+    navtoRule,
+    totalNextRoute,
+    originMixins,
+    objectAny
+} from '../options/base'
+
+import {
+    routesForMapRoute,
+    getRoutePath,
+    getDataType,
+    notDeepClearNull,
+    resolveAbsolutePath,
+    getUniCachePage,
+    timeOut
+} from '../helpers/utils'
+
+import {
+    warn
+} from '../helpers/warn'
+
+import {uniOriginJump} from './uniOrigin'
+
+const rewrite: Array<reNavMethodRule|reNotNavMethodRule> = [
+    'navigateTo',
+    'redirectTo',
+    'reLaunch',
+    'switchTab',
+    'navigateBack'
+];
+
+export function rewriteMethod(
+    router:Router
+): void {
+    if (router.options.keepUniOriginNav === false) {
+        rewrite.forEach(name => {
+            const oldMethod: Function = uni[name];
+            uni[name] = function(
+                params:originMixins|{from:string}|navtoRule,
+                originCall:boolean = false,
+                callOkCb?:Function,
+                forceNav?:boolean
+            ):void {
+                if (originCall) {
+                    uniOriginJump(router, oldMethod, name, params as originMixins, callOkCb, forceNav)
+                } else {
+                    if (router.options.platform === 'app-plus') {
+                        if (Object.keys(router.appMain).length === 0) {
+                            router.appMain = {
+                                NAVTYPE: name,
+                                path: (params as uniNavApiRule).url
+                            }
+                        }
+                    }
+                    callRouterMethod(params as uniNavApiRule, name, router);
+                }
+            };
+        })
+    }
+}
+function callRouterMethod(
+    option: uniNavApiRule|uniBackRule|uniBackApiRule,
+    funName:reNavMethodRule|reNotNavMethodRule,
+    router:Router
+): void {
+    if (router.options.platform === 'app-plus') {
+        let openType = null;
+        if (option) {
+            openType = (option as uniNavApiRule).openType;
+        }
+        if (openType != null && openType === 'appLaunch') {
+            funName = 'reLaunch'
+        }
+    }
+    if (funName === 'reLaunch' && JSON.stringify(option) === '{"url":"/"}') {
+        warn(
+            `uni-app 原生方法：reLaunch({url:'/'}) 默认被重写啦！你可以使用 this.$Router.replaceAll() 或者 uni.reLaunch({url:'/?xxx=xxx'})`,
+            router,
+            true
+        );
+        funName = 'navigateBack';
+        option = {
+            from: 'backbutton'
+        }
+    }
+    if (funName === 'navigateBack') {
+        let level:number = 1;
+        if (option == null) {
+            option = {delta: 1};
+        }
+        if (getDataType<number|undefined>((option as uniBackApiRule).delta) === '[object Number]') {
+            level = ((option as uniBackApiRule).delta as number);
+        }
+        router.back(level, (option as uniBackRule|uniBackApiRule));
+    } else {
+        const routerMethodName = rewriteMethodToggle[(funName as reNavMethodRule)]
+        let path = (option as uniNavApiRule).url;
+        if (!path.startsWith('/')) {
+            const absolutePath = resolveAbsolutePath(path, router);
+            path = absolutePath;
+            (option as uniNavApiRule).url = absolutePath;
+        }
+        if (funName === 'switchTab') {
+            const route = routesForMapRoute(router, path, ['pathMap', 'finallyPathList'])
+            const {finallyPath} = getRoutePath(route, router);
+            if (getDataType<string | string[]>(finallyPath) === '[object Array]') {
+                warn(
+                    `uni-app 原生方法跳转路径为：${path}。此路为是tab页面时，不允许设置 alias 为数组的情况，并且不能为动态路由！当然你可以通过通配符*解决！`,
+                    router,
+                    true
+                );
+            }
+            if ((finallyPath as string) === '*') {
+                warn(
+                    `uni-app 原生方法跳转路径为：${path}。在路由表中找不到相关路由表！当然你可以通过通配符*解决！`,
+                    router,
+                    true
+                );
+            }
+            // Fixe h5 端无法触发 onTabItemTap hook  2021年6月3日17:26:47
+            if (router.options.platform === 'h5') {
+                const {success: userSuccess} = option as uniNavApiRule;
+                (option as uniNavApiRule).success = (...args:Array<any>) => {
+                    userSuccess?.apply(null, args);
+                    timeOut(150).then(() => {
+                        const cbArgs = (option as uniNavApiRule).detail || {};
+                        if (Object.keys(cbArgs).length > 0 && Reflect.has(cbArgs, 'index')) {
+                            const cachePage = getUniCachePage(0);
+                            if (Object.keys(cachePage).length === 0) {
+                                return false
+                            }
+                            const page = cachePage as objectAny;
+                            const hooks = page.$options.onTabItemTap;
+                            if (hooks) {
+                                for (let j = 0; j < hooks.length; j++) {
+                                    hooks[j].call(page, cbArgs)
+                                }
+                            }
+                        }
+                    });
+                }
+            }
+            path = (finallyPath as string);
+        }
+        const {events, success, fail, complete, animationType, animationDuration} = option as uniNavApiRule;
+        const jumpOptions:totalNextRoute = {path, events, success, fail, complete, animationDuration, animationType};
+        router[routerMethodName](
+            notDeepClearNull<totalNextRoute>(jumpOptions)
+        )
+    }
+}

node_modules/uni-simple-router/src/public/router.ts

@@ -0,0 +1,129 @@
+import {PromiseResolve, Router, uniBackApiRule, uniBackRule} from '../options/base';
+import {InstantiateConfig, LifeCycleConfig} from '../options/config';
+import { lifeCycle, proxyHookDeps} from '../helpers/config';
+import {assertNewOptions, def, getDataType} from '../helpers/utils';
+import {registerRouterHooks, registerEachHooks} from '../helpers/lifeCycle';
+import {initMixins} from '../helpers/mixins'
+import {lockNavjump, forceGuardEach, createRoute} from '../public/methods'
+import {rewriteMethod} from '../public/rewrite'
+
+let AppReadyResolve:PromiseResolve = () => {};
+const AppReady:Promise<void> = new Promise(resolve => (AppReadyResolve = resolve));
+
+function createRouter(params: InstantiateConfig):Router {
+    const options = assertNewOptions<InstantiateConfig>(params);
+    const router:Router = {
+        options,
+        mount: [],
+        Vue: null,
+        proxyHookDeps: proxyHookDeps,
+        appMain: {},
+        enterPath: '',
+        $route: null,
+        $lockStatus: false,
+        routesMap: {},
+        lifeCycle: registerRouterHooks<LifeCycleConfig>(lifeCycle, options),
+        push(to) {
+            lockNavjump(to, router, 'push');
+        },
+        replace(to) {
+            lockNavjump(to, router, 'replace');
+        },
+        replaceAll(to) {
+            lockNavjump(to, router, 'replaceAll');
+        },
+        pushTab(to) {
+            lockNavjump(to, router, 'pushTab');
+        },
+        back(level = 1, animation) {
+            if (getDataType(animation) !== '[object Object]') {
+                const backRule:uniBackRule = {
+                    from: 'navigateBack'
+                }
+                animation = backRule;
+            } else {
+                if (!Reflect.has((animation as uniBackRule | uniBackApiRule), 'from')) {
+                    animation = {
+                        ...animation,
+                        from: 'navigateBack'
+                    };
+                }
+            }
+            lockNavjump(level + '', router, 'back', undefined, animation)
+        },
+        forceGuardEach(navType, forceNav) {
+            forceGuardEach(router, navType, forceNav)
+        },
+        beforeEach(userGuard):void {
+            registerEachHooks(router, 'beforeHooks', userGuard);
+        },
+        afterEach(userGuard):void {
+            registerEachHooks(router, 'afterHooks', userGuard);
+        },
+        install(Vue:any):void{
+            router.Vue = Vue;
+            rewriteMethod(this);
+            initMixins(Vue, this);
+            Object.defineProperty(Vue.prototype, '$Router', {
+                get() {
+                    const actualData = router;
+
+                    Object.defineProperty(this, '$Router', {
+                        value: actualData,
+                        writable: false,
+                        configurable: false,
+                        enumerable: false
+                    });
+
+                    return Object.seal(actualData);
+                }
+            });
+            Object.defineProperty(Vue.prototype, '$Route', {
+                get() {
+                    return createRoute(router);
+                }
+            });
+            // 【Fixe】  https://github.com/SilurianYang/uni-simple-router/issues/254
+            Object.defineProperty(Vue.prototype, '$AppReady', {
+                get() {
+                    if (router.options.platform === 'h5') {
+                        return Promise.resolve();
+                    }
+                    return AppReady;
+                },
+                set(value:boolean) {
+                    if (value === true) {
+                        AppReadyResolve();
+                    }
+                }
+            });
+        }
+    }
+    def(router, 'currentRoute', () => createRoute(router));
+
+    router.beforeEach((to, from, next) => next());
+    router.afterEach(() => {});
+    return router;
+}
+
+function RouterMount(Vim:any, router:Router, el:string | undefined = '#app') :void|never {
+    if (getDataType<Array<any>>(router.mount) === '[object Array]') {
+        router.mount.push({
+            app: Vim,
+            el
+        })
+    } else {
+        throw new Error(`挂载路由失败，router.app 应该为数组类型。当前类型：${typeof router.mount}`);
+    }
+    if (router.options.platform === 'h5') {
+        const vueRouter = (router.$route as any);
+        vueRouter.replace({
+            path: vueRouter.currentRoute.fullPath
+        });
+    } // 其他端目前不需要做啥
+}
+
+export {
+    RouterMount,
+    createRouter
+}

node_modules/uni-simple-router/src/public/uniOrigin.ts

@@ -0,0 +1,112 @@
+import { originMixins, reNavMethodRule, reNotNavMethodRule, Router, startAnimationRule, uniNavApiRule } from '../options/base';
+import { stringifyQuery } from './query';
+import {notDeepClearNull, timeOut} from '../helpers/utils'
+import { mpPlatformReg } from '../helpers/config';
+import { resetAndCallPageHook, resetPageHook } from './page';
+
+let routerNavCount:number = 0;
+let lastNavType:reNavMethodRule|reNotNavMethodRule = 'reLaunch'
+
+export function uniOriginJump(
+    router:Router,
+    originMethod:Function,
+    funName:reNavMethodRule|reNotNavMethodRule,
+    options: originMixins,
+    callOkCb?:Function,
+    forceNav?:boolean
+):void {
+    const {complete, ...originRule} = formatOriginURLQuery(router, options, funName);
+    const platform = router.options.platform;
+    if (forceNav != null && forceNav === false) {
+        if (routerNavCount === 0) {
+            routerNavCount++
+            if (platform !== 'h5') {
+                resetAndCallPageHook(router, originRule.url) // 还原及执行app.vue及首页下已经重写后的生命周期
+                // 【Fixe】  https://github.com/SilurianYang/uni-simple-router/issues/254
+                // 在小程序端  next 直接放行会执行这个
+                router.Vue.prototype.$AppReady = true;
+            }
+        }
+        complete && complete.apply(null, {msg: 'forceGuardEach强制触发并且不执行跳转'});
+        callOkCb && callOkCb.apply(null, {msg: 'forceGuardEach强制触发并且不执行跳转'})
+    } else {
+        if (routerNavCount === 0) {
+            if (platform === 'app-plus') {
+                resetAndCallPageHook(router, originRule.url) // 还原及执行app.vue下已经重写后的生命周期
+            } else {
+                if (new RegExp(mpPlatformReg, 'g').test(platform)) {
+                    // 其他就是在小程序下，首次启动发生跳转会走这里
+                    // 我们先将app.vue的生命周期执行
+                    resetAndCallPageHook(router, originRule.url, false)
+                }
+            }
+        }
+        originMethod({
+            ...originRule,
+            from: options.BACKTYPE,
+            complete: async function(...args:Array<any>) {
+                if (routerNavCount === 0) {
+                    routerNavCount++
+
+                    if (platform !== 'h5') {
+                        if (new RegExp(mpPlatformReg, 'g').test(platform)) { // 跳转完成后小程序下还原生命周期
+                            resetPageHook(router);
+                        }
+                        // 【Fixe】  https://github.com/SilurianYang/uni-simple-router/issues/254
+                        // 在小程序端 第一次 next 做跳转  会触发这个 、在app端首次必定会触发这个
+                        router.Vue.prototype.$AppReady = true;
+
+                        if (platform === 'app-plus') {
+                            const waitPage = plus.nativeObj.View.getViewById('router-loadding');
+                            waitPage && waitPage.close();
+                            const launchedHook = router.options.APP?.launchedHook;
+                            launchedHook && launchedHook();
+                        }
+                    }
+                }
+                let time:number = 0;
+                if (new RegExp(mpPlatformReg, 'g').test(platform)) {
+                    time = (router.options.applet?.animationDuration) as number
+                } else if (platform === 'app-plus') {
+                    if (funName === 'navigateBack' && lastNavType === 'navigateTo') {
+                        time = (router.options.APP?.animation?.animationDuration) as number
+                    }
+                }
+                if (funName === 'navigateTo' || funName === 'navigateBack') {
+                    if (time !== 0) {
+                        await timeOut(time);
+                    }
+                }
+                lastNavType = funName;
+                complete && complete.apply(null, args);
+                callOkCb && callOkCb.apply(null, args)
+            }
+        });
+    }
+}
+export function formatOriginURLQuery(
+    router:Router,
+    options:uniNavApiRule,
+    funName:reNavMethodRule|reNotNavMethodRule
+):uniNavApiRule {
+    const {url, path, query, animationType, animationDuration, events, success, fail, complete, delta, animation} = options;
+    const strQuery = stringifyQuery(query || {});
+    const queryURL = strQuery === '' ? (path || url) : (path || url) + strQuery;
+    let animationRule:startAnimationRule = {};
+    if (router.options.platform === 'app-plus') {
+        if (funName !== 'navigateBack') {
+            animationRule = router.options.APP?.animation || {};
+            animationRule = {...animationRule, ...animation || {}};
+        }
+    }
+    return notDeepClearNull<uniNavApiRule>({
+        delta,
+        url: queryURL,
+        animationType: animationType || animationRule.animationType,
+        animationDuration: animationDuration || animationRule.animationDuration,
+        events,
+        success,
+        fail,
+        complete
+    })
+}

node_modules/uni-simple-router/test/path-to-regexp.spec.ts

@@ -0,0 +1,70 @@
+import {createRouter, routesMapKeysRule} from '../src/index';
+
+import {routesForMapRoute} from '../src/helpers/utils';
+
+const routes = [
+	{path: '/pages/login/login', name: 'login', aliasPath: '/'},
+	{path: '/pages/page2/page2', name: 'page2', aliasPath: '/page2/:id'},
+	{path: '/pages/page3/page3', aliasPath: '/:name/page3/:id'},
+	{path: '/pages/animation/animation', aliasPath: '/an-(\\d+)-on'},
+    {path: '/static/1/1', aliasPath: '/static/(.*)'},
+    {path: '/dynamic/1/1', aliasPath: '/dynamic-*'},
+    {path: '/dynamic/3/3', aliasPath: '/dynamic3'},
+    {path: '*'}
+];
+
+const router = createRouter({
+	platform: 'app-plus',
+	keepUniOriginNav: true,
+	routes,
+});
+
+const Vue = function () {};
+Vue.mixin = () => {};
+
+router.install(Vue);
+
+const rules: routesMapKeysRule[] = ['finallyPathMap', 'pathMap'];
+
+it('别名路径匹配',()=>{
+    const toRoute1 = routesForMapRoute(router, '/dynamic3', rules);
+	expect(toRoute1).toEqual(routes[6]);
+
+    const toRoute2 = routesForMapRoute(router, '/dynamic/3/3', rules);
+	expect(toRoute2).toEqual(routes[6]);
+})
+
+it('全局匹配', () => {
+	const toRoute1 = routesForMapRoute(router, '/pages/login/login', rules);
+	expect(toRoute1).toEqual(routes[0]);
+
+	const toRoute2 = routesForMapRoute(router,'/pages/login/login?id=666',rules);
+	expect(toRoute2).toEqual(routes[0]);
+
+	const toRoute3 = routesForMapRoute(router, '/page2/6666', rules);
+	expect(toRoute3).toEqual(routes[1]);
+
+	const toRoute4 = routesForMapRoute(router, '/page2/6666?id=555', rules);
+	expect(toRoute4).toEqual(routes[1]);
+
+	const toRoute5 = routesForMapRoute(router, '/pages/page3/page3', rules);
+	expect(toRoute5).toEqual(routes[2]);
+
+	const toRoute6 = routesForMapRoute(router, '/test/page3/123', rules);
+	expect(toRoute6).toEqual(routes[2]);
+
+	const toRoute7 = routesForMapRoute(router, '/an-123-on', rules);
+	expect(toRoute7).toEqual(routes[3]);
+
+    const toRoute8 = routesForMapRoute(router, '/static/aaa/bbb?id=1444&name=999', rules);
+	expect(toRoute8).toEqual(routes[4]);
+
+    const toRoute9 = routesForMapRoute(router, '/dynamic-6666-5555', rules);
+	expect(toRoute9).toEqual(routes[5]);
+
+    const toRoute10 = routesForMapRoute(router, '/aaaaaa', rules);
+	expect(toRoute10).toEqual(routes[7]);
+
+    const toRoute11 = routesForMapRoute(router, '---48848--14545', rules);
+	expect(toRoute11).toEqual(routes[7]);
+});

node_modules/uni-simple-router/test/query-toggle.spec.ts

@@ -0,0 +1,83 @@
+import {deepDecodeQuery} from '../src/helpers/utils';
+
+
+it('编码回转',()=>{
+    const query={
+        str:'%E7%9A%84%E6%8C%A5%E6%B4%92U%E7%9B%BE%E5%A5%BD%E6%92%92%E7%AC%AC%E4%B8%89%E5%A4%A7%E5%8E%A6%E5%8F%91%E7%9A%84%E6%92%92321312%2a%EF%BC%88%EF%BF%A5%23%254'
+    }
+    const result = deepDecodeQuery(query);
+    expect(JSON.stringify(result)).toEqual(JSON.stringify({
+        str:'的挥洒U盾好撒第三大厦发的撒321312*（￥#%4'
+    }))
+})
+
+it('一些乱码字符',()=>{
+    const query={
+        str:`~!@#$%^&*()_+-,./|][]`
+    }
+    const result = deepDecodeQuery(query);
+    expect(JSON.stringify(result)).toEqual(JSON.stringify({
+        str:`~!@#$%^&*()_+-,./|][]`
+    }))
+})
+
+it('单个加密参数',()=>{
+    const query={
+        name:'%7B%22status%22%3Atrue%2C%22list%22%3A%5B%7B%22id%22%3A1%7D%5D%7D'
+    }
+    const result = deepDecodeQuery(query);
+    expect(JSON.stringify(result)).toEqual(JSON.stringify({
+        name:{
+            status:true,
+            list:[
+                {
+                    id:1
+                },
+            ]
+        }
+    }));
+})
+
+it('单个普通参数',()=>{
+    const query={
+        name:'hhyang',
+        ages:22,
+        open:true
+    }
+    const result = deepDecodeQuery(query);
+
+    expect(JSON.stringify(result)).toEqual(JSON.stringify(query));
+})
+
+it('深度参数加混乱',()=>{
+    const query={
+        list:[
+            1,'2',true,encodeURIComponent(JSON.stringify({name:111})),{
+                name:'hhyang',
+                strObj:encodeURIComponent(JSON.stringify({name:222}))
+            }
+        ],
+        obj:{
+            strObj2:encodeURIComponent(JSON.stringify({name:333})),
+            number:1,
+            boolean:false,
+        },
+        str4:encodeURIComponent(JSON.stringify({name:444}))
+    }
+    const result = deepDecodeQuery(query);
+
+    expect(JSON.stringify(result)).toEqual(JSON.stringify({
+        list:[
+            1,'2',true,{name:111},{
+                name:'hhyang',
+                strObj:{name:222}
+            }
+        ],
+        obj:{
+            strObj2:{name:333},
+            number:1,
+            boolean:false,
+        },
+        str4:{name:444}
+    }));
+})  

node_modules/uni-simple-router/tsconfig.json

@@ -0,0 +1,19 @@
+{
+	"compilerOptions": {
+		"target": "es5",
+		"module": "CommonJS",
+		"strict": true,
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"forceConsistentCasingInFileNames": true,
+		"lib": ["ES2015", "DOM"],
+		"outDir": "dist/src",
+		"declaration": true,
+		"declarationMap": false,
+		"rootDir": "./src",
+		"baseUrl": ".",
+		"paths": {}
+	},
+	"include": ["./src/global.d.ts", "./src/*"],
+	"exclude": ["node_modules", "**/*.spec.ts"]
+}

node_modules/uni-simple-router/webpack/webpack.common.js

@@ -0,0 +1,41 @@
+const {resolve} = require('path');
+const CopyPlugin = require('copy-webpack-plugin');
+const webpack =require('webpack');
+
+module.exports = {
+	entry: './src/index.ts',
+	output: {
+		library: 'Router',
+		libraryTarget: 'umd',
+	},
+	resolve: {
+		extensions: ['.tsx', '.ts', 'd.ts', '.js', '.json'],
+	},
+	module: {
+		rules: [
+			{
+				test: /\.tsx?$/,
+				use: [
+					{
+						loader: 'ts-loader',
+					},
+				],
+				exclude: /node_modules/,
+			},
+		],
+	},
+	plugins: [
+		new CopyPlugin([
+			{
+				force: true,
+				from: resolve(__dirname, '../src/component'),
+				to: resolve(__dirname, '../dist'),
+			},
+		]),
+        new webpack.DefinePlugin({
+            $npm_package_name: webpack.DefinePlugin.runtimeValue(() => {
+                return JSON.stringify(process.env.npm_package_name.toLocaleUpperCase())
+            }, true )
+        })
+	],
+};

node_modules/uni-simple-router/webpack/webpack.dev.js

@@ -0,0 +1,22 @@
+const {merge} = require("webpack-merge");
+const {resolve} = require('path');
+const common = require("./webpack.common.js");
+const CopyPlugin = require('copy-webpack-plugin');
+
+const output=resolve(__dirname, '../examples/uni-simple-router2.0/dist');
+
+module.exports = merge(common, {
+    mode: 'development',
+    devtool: 'source-map',
+    output: {
+		path:output ,
+		filename: 'uni-simple-router.js',
+    },
+    plugins: [
+        new CopyPlugin([{
+          force: true,
+          from: resolve(__dirname, '../src/component'),
+          to: output,
+        }]),
+      ]
+});

node_modules/uni-simple-router/webpack/webpack.prod.js

@@ -0,0 +1,19 @@
+const {resolve} = require('path');
+const {merge} = require("webpack-merge");
+const common = require("./webpack.common.js");
+const rimraf = require('rimraf');
+
+
+function resolvePath(dir) {
+    return resolve(__dirname, '../', dir)
+}
+
+rimraf('dist', () => {});
+
+module.exports = merge(common, {
+    mode: "production",
+    output: {
+		path: resolvePath('dist'),
+		filename: 'uni-simple-router.js',
+	},
+})

node_modules/vuex/CHANGELOG.md

@@ -0,0 +1,356 @@
+## [3.6.2](https://github.com/vuejs/vuex/compare/v3.6.1...v3.6.2) (2021-01-26)
+
+### Bug Fixes
+
+* **build:** fix wrong path name for the export module ([679313b](https://github.com/vuejs/vuex/commit/679313bf5e4de066f340a06ef9bfe08d1536fadd))
+
+## [3.6.1](https://github.com/vuejs/vuex/compare/v3.6.0...v3.6.1) (2021-01-26)
+
+### Bug Fixes
+
+* fix tree shaking notworking in webpack bundle ([#1906](https://github.com/vuejs/vuex/issues/1906)) ([1dc2d1f](https://github.com/vuejs/vuex/commit/1dc2d1f21de42138053ea3281dde05487642a76d))
+
+# [3.6.0](https://github.com/vuejs/vuex/compare/v3.5.1...v3.6.0) (2020-11-25)
+
+### Bug Fixes
+
+* stop throwing an error on `hasModule` when parent does not exists ([#1850](https://github.com/vuejs/vuex/issues/1850)) ([#1851](https://github.com/vuejs/vuex/issues/1851)) ([12aabe4](https://github.com/vuejs/vuex/commit/12aabe4cc470916d40691097dcb95badb8212f5c))
+
+### Features
+
+* **types:** adding logger type for logger plugin ([#1853](https://github.com/vuejs/vuex/issues/1853)) ([cb3198d](https://github.com/vuejs/vuex/commit/cb3198d5998bdb11ef05dfa5ef98d5c5fa873089))
+* **build:** enable named esm module import on node.js >= 14 ([#1872](https://github.com/vuejs/vuex/issues/1872)) ([acddab2](https://github.com/vuejs/vuex/commit/acddab20769d1bb6125f2da78ac47561c682fc98))
+
+## [3.5.1](https://github.com/vuejs/vuex/compare/v3.5.0...v3.5.1) (2020-06-29)
+
+
+### Bug Fixes
+
+* **types:** add missing `logger.d.ts` file to the package ([#1789](https://github.com/vuejs/vuex/issues/1789)) ([a477334](https://github.com/vuejs/vuex/commit/a477334b909913f6a92bdbedcf4a3016a62eab7a))
+* warn when unregistering non existing module ([#1786](https://github.com/vuejs/vuex/issues/1786)) ([7cec79d](https://github.com/vuejs/vuex/commit/7cec79d339b874ec41f35891c891dfd27460c1d3))
+
+
+
+# [3.5.0](https://github.com/vuejs/vuex/compare/v3.4.0...v3.5.0) (2020-06-29)
+
+
+### Features
+
+* include logger plugin to the core export ([#1783](https://github.com/vuejs/vuex/issues/1783)) ([04e2bd8](https://github.com/vuejs/vuex/commit/04e2bd8b3509c67398a6fe73a3d53660069feca8))
+
+
+
+# [3.4.0](https://github.com/vuejs/vuex/compare/v3.3.0...v3.4.0) (2020-05-11)
+
+
+### Features
+
+* Allow action subscribers to catch rejections. ([#1740](https://github.com/vuejs/vuex/issues/1740)) ([6ebbe64](https://github.com/vuejs/vuex/commit/6ebbe64c5821d19e55a41dc8b1d81cfce6cbd195)), closes [#1489](https://github.com/vuejs/vuex/issues/1489) [#1558](https://github.com/vuejs/vuex/issues/1558) [#1625](https://github.com/vuejs/vuex/issues/1625)
+
+
+
+# [3.3.0](https://github.com/vuejs/vuex/compare/v3.2.0...v3.3.0) (2020-04-25)
+
+
+### Bug Fixes
+
+* Prepend devtool handler ([#1358](https://github.com/vuejs/vuex/issues/1358)) ([a39d076](https://github.com/vuejs/vuex/commit/a39d0767e4041cdd5cf8050774106c01d39024e0)), closes [vuejs/vue-devtools#678](https://github.com/vuejs/vue-devtools/issues/678)
+* **types:** Add `devtools` to store options type ([#1478](https://github.com/vuejs/vuex/issues/1478)) ([38c11dc](https://github.com/vuejs/vuex/commit/38c11dcbaea7d7e661a1623cabb5aef7c6e47ba7))
+
+
+### Features
+
+* Add `prepend` option for `subscribe` and `subscribeAction` ([#1358](https://github.com/vuejs/vuex/issues/1358)) ([a39d076](https://github.com/vuejs/vuex/commit/a39d0767e4041cdd5cf8050774106c01d39024e0))
+* **logger:** `createLogger` can optionally log actions ([#987](https://github.com/vuejs/vuex/issues/987)) ([18be128](https://github.com/vuejs/vuex/commit/18be128ad933d1fca6da05c060f7664ce0c819ae))
+
+
+
+# [3.2.0](https://github.com/vuejs/vuex/compare/v3.1.3...v3.2.0) (2020-04-19)
+
+
+### Features
+
+* add Store#hasModule(path) API ([#834](https://github.com/vuejs/vuex/issues/834)) ([d65d142](https://github.com/vuejs/vuex/commit/d65d14276e87aca17cfbd3fbf4af9e8dbb808f24))
+
+
+
+## [3.1.3](https://github.com/vuejs/vuex/compare/v3.1.2...v3.1.3) (2020-03-09)
+
+
+### Bug Fixes
+
+* Prevent invalidating subscription iterator  ([#1438](https://github.com/vuejs/vuex/issues/1438)) ([e012653](https://github.com/vuejs/vuex/commit/e0126533301febf66072f1865cf9a77778cf2176))
+
+
+
+## [3.1.2](https://github.com/vuejs/vuex/compare/v3.1.1...v3.1.2) (2019-11-10)
+
+
+### Bug Fixes
+
+* tweak mapping helper warning message ([#1641](https://github.com/vuejs/vuex/issues/1641)) ([e60bc76](https://github.com/vuejs/vuex/commit/e60bc76154bb05c12b24342617b946d9a6e2f476))
+* **types:** avoid broadening vue instance type when using map helpers ([#1639](https://github.com/vuejs/vuex/issues/1639)) ([9a96720](https://github.com/vuejs/vuex/commit/9a9672050bcfee198c379069ec0e1b03ca6cb965))
+* add warnings when the different namespaced modules has the same names… ([#1554](https://github.com/vuejs/vuex/issues/1554)) ([91f3e69](https://github.com/vuejs/vuex/commit/91f3e69ed9e290cf91f8885c6d5ae2c97fa7ab81))
+* Should vuex mapState print error message [#1093](https://github.com/vuejs/vuex/issues/1093) ([#1297](https://github.com/vuejs/vuex/issues/1297)) ([e5ca2d5](https://github.com/vuejs/vuex/commit/e5ca2d52e89a126bd48bd8a6003be77379960ea9))
+* Warn about conflicts between state and module ([#1365](https://github.com/vuejs/vuex/issues/1365)) ([538ee58](https://github.com/vuejs/vuex/commit/538ee5803bbca2fc8077208fb30c8d56d8be5cae))
+* **docs:** Clearify state object type ([#1601](https://github.com/vuejs/vuex/issues/1601)) ([de06f76](https://github.com/vuejs/vuex/commit/de06f76380e7429489c0eb15acc8e0b34a383860))
+
+
+### Performance Improvements
+
+* Implementing a cache for the gettersProxy object creation ([#1546](https://github.com/vuejs/vuex/issues/1546)) ([4003382](https://github.com/vuejs/vuex/commit/40033825b7259c2e9b702bdf94e0b24ed4511d7c))
+
+
+
+## [3.1.1](https://github.com/vuejs/vuex/compare/v3.1.0...v3.1.1) (2019-05-08)
+
+
+### Bug Fixes
+
+* Memory leak happening while using registerModule/u… ([#1508](https://github.com/vuejs/vuex/issues/1508)) ([cb9986a](https://github.com/vuejs/vuex/commit/cb9986ae5a62e002a1d876e881ee5f31dd410888)), closes [issue#1507](https://github.com/issue/issues/1507)
+* **types:** Make mutation and action payload optional in definition file ([#1517](https://github.com/vuejs/vuex/issues/1517)) ([0e109e2](https://github.com/vuejs/vuex/commit/0e109e2a38dafdc0c2bd6bd3892bc66cfe252b16)), closes [#1491](https://github.com/vuejs/vuex/issues/1491)
+
+
+### Features
+
+* **devtool:** allow usage in non-browser environments ([#1404](https://github.com/vuejs/vuex/issues/1404)) ([665455f](https://github.com/vuejs/vuex/commit/665455f8daf8512e7adbf63c2842bc0b1e39efdb))
+* **esm build:** build ES modules for browser ([#1533](https://github.com/vuejs/vuex/issues/1533)) ([d7c7f98](https://github.com/vuejs/vuex/commit/d7c7f9844831f98c5c9aaca213746c4ccc5d6929))
+
+
+
+# [3.1.0](https://github.com/vuejs/vuex/compare/v3.0.1...v3.1.0) (2019-01-17)
+
+
+### Bug Fixes
+
+* **types:** add helpers to default export type declaration as in sources ([#1408](https://github.com/vuejs/vuex/issues/1408)) ([404d0de](https://github.com/vuejs/vuex/commit/404d0de9531322a1a462e53dfd858d20f0bd99af))
+* **types:** add type annotation for the context of actions ([#1322](https://github.com/vuejs/vuex/issues/1322)) ([d1b5c66](https://github.com/vuejs/vuex/commit/d1b5c66961ab53e0172cbc706ff616227bcb5c77))
+* **types:** allow a function type for root `state` option ([#1132](https://github.com/vuejs/vuex/issues/1132)) ([d39791b](https://github.com/vuejs/vuex/commit/d39791bd05830b1889705761ef5779449e35e97f))
+* Add key to v-for ([#1369](https://github.com/vuejs/vuex/issues/1369)) ([a9bd047](https://github.com/vuejs/vuex/commit/a9bd047ea147cacfcb4003946aeebccd2c5e1e4e))
+* avoid to call root state function twice ([#1034](https://github.com/vuejs/vuex/issues/1034)) ([86677eb](https://github.com/vuejs/vuex/commit/86677ebcbfaecf712f339b73a568150fc9fd5f5e))
+* fix [#1032](https://github.com/vuejs/vuex/issues/1032), relax vue typing in helpers ([#1044](https://github.com/vuejs/vuex/issues/1044)) ([7c7ed1d](https://github.com/vuejs/vuex/commit/7c7ed1d37ee8a5058082d763d80529e5fef86a0b))
+
+
+### Features
+
+* add ability to turn off devtools on vuex by passing an off options ([#1407](https://github.com/vuejs/vuex/issues/1407)) ([be75d41](https://github.com/vuejs/vuex/commit/be75d41cf54d50177a7db7e9218e8d1c820ae830))
+* ensure errors in action subscribers do not break actions ([acd7249](https://github.com/vuejs/vuex/commit/acd72492eaffff3661f75860a3d7ab37b73c3906))
+
+
+### Reverts
+
+* Revert "Update util find (#1205)" (fix #1286) ([273bf86](https://github.com/vuejs/vuex/commit/273bf86b330ee580a73176c300919996b7d9c2c3)), closes [#1286](https://github.com/vuejs/vuex/issues/1286)
+
+
+
+## [3.0.1](https://github.com/vuejs/vuex/compare/v3.0.0...v3.0.1) (2017-11-01)
+
+
+
+# [3.0.0](https://github.com/vuejs/vuex/compare/v2.5.0...v3.0.0) (2017-10-11)
+
+
+### Features
+
+* **typings:** adapt to the new Vue typings ([#909](https://github.com/vuejs/vuex/issues/909)) ([65dbfec](https://github.com/vuejs/vuex/commit/65dbfec40d5fe7aac05aab333c7b70768997ca7f))
+
+
+### BREAKING CHANGES
+
+* **typings:** It is no longer compatible with the old Vue typings
+
+* chore(package): bump typescript and vue core typings
+
+* chore: bump vue
+
+* Update package.json
+
+
+
+# [2.5.0](https://github.com/vuejs/vuex/compare/v2.4.1...v2.5.0) (2017-10-11)
+
+
+### Bug Fixes
+
+* initialize root state as an empty object if state function returns no value ([#927](https://github.com/vuejs/vuex/issues/927)) ([0e9756b](https://github.com/vuejs/vuex/commit/0e9756b93c5de8e03286d93f0b50af5f8dfd3bac))
+
+
+### Features
+
+* add logger plugin logger config support ([#771](https://github.com/vuejs/vuex/issues/771)) ([804c3bb](https://github.com/vuejs/vuex/commit/804c3bbd2e60f11412f5a7cb7694969f8f6c215c))
+* preserve state with registerModule ([#837](https://github.com/vuejs/vuex/issues/837)) ([4c1841e](https://github.com/vuejs/vuex/commit/4c1841e79e63ca0ca95d0cc1b218fde258f23c20))
+* root actions in namespaced modules ([#941](https://github.com/vuejs/vuex/issues/941)) ([73189eb](https://github.com/vuejs/vuex/commit/73189eb35509de7d49bd2b577900ad560d37dcb0))
+* subscribeAction ([#960](https://github.com/vuejs/vuex/issues/960)) ([a8326b1](https://github.com/vuejs/vuex/commit/a8326b1bd77158e7e5903eed4cc98b52599e3dbd))
+
+
+
+## [2.4.1](https://github.com/vuejs/vuex/compare/v2.4.0...v2.4.1) (2017-09-27)
+
+
+### Bug Fixes
+
+* allow installation on extended Vue copies ([c87b72f](https://github.com/vuejs/vuex/commit/c87b72f2ff7f65e708c4b59a752ef234d0f28d1f))
+* link to details of mutations in components ([#930](https://github.com/vuejs/vuex/issues/930)) ([e82782b](https://github.com/vuejs/vuex/commit/e82782ba81c398dd5b78a195257a9d1c3a6d85ef))
+* move auto installation code into the store constructor ([#914](https://github.com/vuejs/vuex/issues/914)) ([852ac43](https://github.com/vuejs/vuex/commit/852ac43ea4813ecaeb1e5106c4a29c74e57c2fd7))
+
+
+### Features
+
+* allow to passing functions in mapActions/mapMutations (fix [#750](https://github.com/vuejs/vuex/issues/750)) ([#924](https://github.com/vuejs/vuex/issues/924)) ([be15f32](https://github.com/vuejs/vuex/commit/be15f32c0077d8fe9bafa38c1b319b655cfd5f86))
+
+
+
+# [2.4.0](https://github.com/vuejs/vuex/compare/v2.3.0...v2.4.0) (2017-08-29)
+
+
+### Bug Fixes
+
+* **typings:** watch() returns an unwatch function ([#922](https://github.com/vuejs/vuex/issues/922)) ([a4bd081](https://github.com/vuejs/vuex/commit/a4bd0816838cc4a843d833363b9aa412c1256e5e))
+* add missing typings and docs of createNamespacedHelpers ([#910](https://github.com/vuejs/vuex/issues/910)) ([7ad573b](https://github.com/vuejs/vuex/commit/7ad573bba59d23dbd66e3a25e6614296aeb98d42))
+
+
+### Features
+
+* **store:** bind mutation and action handlers to store ([#872](https://github.com/vuejs/vuex/issues/872)) ([67da622](https://github.com/vuejs/vuex/commit/67da6225552e46266ed059c7f0d0128294cd08ed))
+
+
+### Performance Improvements
+
+* do not connect devtools if Vue.config.devtools == false ([#881](https://github.com/vuejs/vuex/issues/881)) ([dd7f817](https://github.com/vuejs/vuex/commit/dd7f8178d93e6121a447c410b9c652f40cd80937))
+
+
+
+# [2.3.0](https://github.com/vuejs/vuex/compare/v2.2.1...v2.3.0) (2017-04-13)
+
+
+* Add '-loader' suffix to webpack config (#722) ([84b4634](https://github.com/vuejs/vuex/commit/84b463438ea4133f7f326dc18212e3d4b7b5a177)), closes [#722](https://github.com/vuejs/vuex/issues/722)
+
+
+### BREAKING CHANGES
+
+* It's no longer allowed to omit the '-loader' suffix when using loaders. You need to specify 'babel-loader' instead of 'babel'.
+My version of webpack: 2.2.0-rc.3
+Adding the '-loader' suffix fixed the problem.
+Not sure though how safe it is to use 'babel-loader' instead of 'babel' with previous webpack versions...
+
+
+
+## [2.2.1](https://github.com/vuejs/vuex/compare/v2.2.0...v2.2.1) (2017-02-26)
+
+
+
+# [2.2.0](https://github.com/vuejs/vuex/compare/v2.1.2...v2.2.0) (2017-02-26)
+
+
+
+## [2.1.2](https://github.com/vuejs/vuex/compare/v2.1.1...v2.1.2) (2017-02-06)
+
+
+### Reverts
+
+* Revert "Update modules.md (#534)" ([5e145b3](https://github.com/vuejs/vuex/commit/5e145b3a2d45977b52cfff41b3b663f629d67e74)), closes [#534](https://github.com/vuejs/vuex/issues/534)
+
+
+
+## [2.1.1](https://github.com/vuejs/vuex/compare/v2.1.0...v2.1.1) (2016-12-17)
+
+
+
+# [2.1.0](https://github.com/vuejs/vuex/compare/v2.0.0...v2.1.0) (2016-12-16)
+
+
+
+# [2.0.0](https://github.com/vuejs/vuex/compare/v2.0.0-rc.6...v2.0.0) (2016-09-30)
+
+
+
+# [2.0.0-rc.6](https://github.com/vuejs/vuex/compare/v2.0.0-rc.5...v2.0.0-rc.6) (2016-09-24)
+
+
+
+# [2.0.0-rc.5](https://github.com/vuejs/vuex/compare/v2.0.0-rc.4...v2.0.0-rc.5) (2016-08-15)
+
+
+
+# [2.0.0-rc.4](https://github.com/vuejs/vuex/compare/v2.0.0-rc.3...v2.0.0-rc.4) (2016-08-05)
+
+
+
+# [2.0.0-rc.3](https://github.com/vuejs/vuex/compare/v2.0.0-rc.1...v2.0.0-rc.3) (2016-07-11)
+
+
+
+# [2.0.0-rc.1](https://github.com/vuejs/vuex/compare/v1.0.0-rc...v2.0.0-rc.1) (2016-07-05)
+
+
+
+# [1.0.0-rc](https://github.com/vuejs/vuex/compare/v0.8.2...v1.0.0-rc) (2016-07-01)
+
+
+
+## [0.8.2](https://github.com/vuejs/vuex/compare/v0.8.1...v0.8.2) (2016-06-28)
+
+
+
+## [0.8.1](https://github.com/vuejs/vuex/compare/v0.8.0...v0.8.1) (2016-06-28)
+
+
+
+# [0.8.0](https://github.com/vuejs/vuex/compare/v0.7.1...v0.8.0) (2016-06-23)
+
+
+
+## [0.7.1](https://github.com/vuejs/vuex/compare/v0.7.0...v0.7.1) (2016-06-22)
+
+
+
+# [0.7.0](https://github.com/vuejs/vuex/compare/v0.6.3...v0.7.0) (2016-06-21)
+
+
+
+## [0.6.3](https://github.com/vuejs/vuex/compare/v0.6.2...v0.6.3) (2016-04-23)
+
+
+
+## [0.6.2](https://github.com/vuejs/vuex/compare/v0.6.1...v0.6.2) (2016-03-08)
+
+
+
+## [0.6.1](https://github.com/vuejs/vuex/compare/v0.6.0...v0.6.1) (2016-03-07)
+
+
+
+# [0.6.0](https://github.com/vuejs/vuex/compare/v0.5.1...v0.6.0) (2016-03-07)
+
+
+
+## [0.5.1](https://github.com/vuejs/vuex/compare/v0.5.0...v0.5.1) (2016-03-04)
+
+
+
+# [0.5.0](https://github.com/vuejs/vuex/compare/v0.4.2...v0.5.0) (2016-03-04)
+
+
+
+## [0.4.2](https://github.com/vuejs/vuex/compare/v0.4.1...v0.4.2) (2016-03-02)
+
+
+
+## [0.4.1](https://github.com/vuejs/vuex/compare/v0.4.0...v0.4.1) (2016-03-01)
+
+
+
+# [0.4.0](https://github.com/vuejs/vuex/compare/v0.3.0...v0.4.0) (2016-03-01)
+
+
+
+# [0.3.0](https://github.com/vuejs/vuex/compare/4a22523b8cf4a1954ec95a0083ddef6c085f4905...v0.3.0) (2016-02-16)
+
+
+### Bug Fixes
+
+* **api:** fix typo ([4a22523](https://github.com/vuejs/vuex/commit/4a22523b8cf4a1954ec95a0083ddef6c085f4905))
+* **forms:** fix typo ([50094a6](https://github.com/vuejs/vuex/commit/50094a604f32d00ceb784a3fbf07c82c502faca2))
+
+
+

node_modules/vuex/LICENSE

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

node_modules/vuex/README.md

@@ -0,0 +1,59 @@
+# Vuex
+
+[![npm](https://img.shields.io/npm/v/vuex.svg)](https://npmjs.com/package/vuex)
+[![ci status](https://circleci.com/gh/vuejs/vuex/tree/dev.png?style=shield)](https://circleci.com/gh/vuejs/vuex)
+
+---
+
+:fire: **HEADS UP!** You're currently looking at Vuex 3 branch. If you're looking for Vuex 4, [please check out `4.0` branch](https://github.com/vuejs/vuex/tree/4.0).
+
+---
+
+Vuex is a state management pattern + library for Vue.js applications. It serves as a centralized store for all the components in an application, with rules ensuring that the state can only be mutated in a predictable fashion. It also integrates with Vue's official [devtools extension](https://github.com/vuejs/vue-devtools) to provide advanced features such as zero-config time-travel debugging and state snapshot export / import.
+
+Learn more about Vuex at "[What is Vuex?](https://vuex.vuejs.org/)", or get started by looking into [full documentation](http://vuex.vuejs.org/).
+
+## Documentation
+
+To check out docs, visit [vuex.vuejs.org](https://vuex.vuejs.org/).
+
+## Examples
+
+- [Counter](https://github.com/vuejs/vuex/tree/dev/examples/counter)
+- [Counter with Hot Reload](https://github.com/vuejs/vuex/tree/dev/examples/counter-hot)
+- [TodoMVC](https://github.com/vuejs/vuex/tree/dev/examples/todomvc)
+- [Flux Chat](https://github.com/vuejs/vuex/tree/dev/examples/chat)
+- [Shopping Cart](https://github.com/vuejs/vuex/tree/dev/examples/shopping-cart)
+
+Running the examples:
+
+```bash
+$ npm install
+$ npm run dev # serve examples at localhost:8080
+```
+
+## Questions
+
+For questions and support please use the [Discord chat server](https://chat.vuejs.org) or [the official forum](http://forum.vuejs.org). The issue list of this repo is **exclusively** for bug reports and feature requests.
+
+## Issues
+
+Please make sure to read the [Issue Reporting Checklist](https://github.com/vuejs/vuex/blob/dev/.github/contributing.md#issue-reporting-guidelines) before opening an issue. Issues not conforming to the guidelines may be closed immediately.
+
+## Changelog
+
+Detailed changes for each release are documented in the [release notes](https://github.com/vuejs/vuex/releases).
+
+## Stay In Touch
+
+For latest releases and announcements, follow on Twitter: [@vuejs](https://twitter.com/vuejs).
+
+## Contribution
+
+Please make sure to read the [Contributing Guide](https://github.com/vuejs/vuex/blob/dev/.github/contributing.md) before making a pull request.
+
+## License
+
+[MIT](http://opensource.org/licenses/MIT)
+
+Copyright (c) 2015-present Evan You

node_modules/vuex/dist/logger.js

@@ -0,0 +1,155 @@
+/*!
+ * vuex v3.6.2
+ * (c) 2021 Evan You
+ * @license MIT
+ */
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+  typeof define === 'function' && define.amd ? define(factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Vuex = factory());
+}(this, (function () { 'use strict';
+
+  /**
+   * Get the first item that pass the test
+   * by second argument function
+   *
+   * @param {Array} list
+   * @param {Function} f
+   * @return {*}
+   */
+  function find (list, f) {
+    return list.filter(f)[0]
+  }
+
+  /**
+   * Deep copy the given object considering circular structure.
+   * This function caches all nested objects and its copies.
+   * If it detects circular structure, use cached copy to avoid infinite loop.
+   *
+   * @param {*} obj
+   * @param {Array<Object>} cache
+   * @return {*}
+   */
+  function deepCopy (obj, cache) {
+    if ( cache === void 0 ) cache = [];
+
+    // just return if obj is immutable value
+    if (obj === null || typeof obj !== 'object') {
+      return obj
+    }
+
+    // if obj is hit, it is in circular structure
+    var hit = find(cache, function (c) { return c.original === obj; });
+    if (hit) {
+      return hit.copy
+    }
+
+    var copy = Array.isArray(obj) ? [] : {};
+    // put the copy into cache at first
+    // because we want to refer it in recursive deepCopy
+    cache.push({
+      original: obj,
+      copy: copy
+    });
+
+    Object.keys(obj).forEach(function (key) {
+      copy[key] = deepCopy(obj[key], cache);
+    });
+
+    return copy
+  }
+
+  // Credits: borrowed code from fcomb/redux-logger
+
+  function createLogger (ref) {
+    if ( ref === void 0 ) ref = {};
+    var collapsed = ref.collapsed; if ( collapsed === void 0 ) collapsed = true;
+    var filter = ref.filter; if ( filter === void 0 ) filter = function (mutation, stateBefore, stateAfter) { return true; };
+    var transformer = ref.transformer; if ( transformer === void 0 ) transformer = function (state) { return state; };
+    var mutationTransformer = ref.mutationTransformer; if ( mutationTransformer === void 0 ) mutationTransformer = function (mut) { return mut; };
+    var actionFilter = ref.actionFilter; if ( actionFilter === void 0 ) actionFilter = function (action, state) { return true; };
+    var actionTransformer = ref.actionTransformer; if ( actionTransformer === void 0 ) actionTransformer = function (act) { return act; };
+    var logMutations = ref.logMutations; if ( logMutations === void 0 ) logMutations = true;
+    var logActions = ref.logActions; if ( logActions === void 0 ) logActions = true;
+    var logger = ref.logger; if ( logger === void 0 ) logger = console;
+
+    return function (store) {
+      var prevState = deepCopy(store.state);
+
+      if (typeof logger === 'undefined') {
+        return
+      }
+
+      if (logMutations) {
+        store.subscribe(function (mutation, state) {
+          var nextState = deepCopy(state);
+
+          if (filter(mutation, prevState, nextState)) {
+            var formattedTime = getFormattedTime();
+            var formattedMutation = mutationTransformer(mutation);
+            var message = "mutation " + (mutation.type) + formattedTime;
+
+            startMessage(logger, message, collapsed);
+            logger.log('%c prev state', 'color: #9E9E9E; font-weight: bold', transformer(prevState));
+            logger.log('%c mutation', 'color: #03A9F4; font-weight: bold', formattedMutation);
+            logger.log('%c next state', 'color: #4CAF50; font-weight: bold', transformer(nextState));
+            endMessage(logger);
+          }
+
+          prevState = nextState;
+        });
+      }
+
+      if (logActions) {
+        store.subscribeAction(function (action, state) {
+          if (actionFilter(action, state)) {
+            var formattedTime = getFormattedTime();
+            var formattedAction = actionTransformer(action);
+            var message = "action " + (action.type) + formattedTime;
+
+            startMessage(logger, message, collapsed);
+            logger.log('%c action', 'color: #03A9F4; font-weight: bold', formattedAction);
+            endMessage(logger);
+          }
+        });
+      }
+    }
+  }
+
+  function startMessage (logger, message, collapsed) {
+    var startMessage = collapsed
+      ? logger.groupCollapsed
+      : logger.group;
+
+    // render
+    try {
+      startMessage.call(logger, message);
+    } catch (e) {
+      logger.log(message);
+    }
+  }
+
+  function endMessage (logger) {
+    try {
+      logger.groupEnd();
+    } catch (e) {
+      logger.log('—— log end ——');
+    }
+  }
+
+  function getFormattedTime () {
+    var time = new Date();
+    return (" @ " + (pad(time.getHours(), 2)) + ":" + (pad(time.getMinutes(), 2)) + ":" + (pad(time.getSeconds(), 2)) + "." + (pad(time.getMilliseconds(), 3)))
+  }
+
+  function repeat (str, times) {
+    return (new Array(times + 1)).join(str)
+  }
+
+  function pad (num, maxLength) {
+    return repeat('0', maxLength - num.toString().length) + num
+  }
+
+  return createLogger;
+
+})));

node_modules/vuex/dist/vuex.mjs

@@ -0,0 +1,26 @@
+import Vuex from '../dist/vuex.common.js'
+
+const {
+  Store,
+  install,
+  version,
+  mapState,
+  mapMutations,
+  mapGetters,
+  mapActions,
+  createNamespacedHelpers,
+  createLogger
+} = Vuex
+
+export {
+  Vuex as default,
+  Store,
+  install,
+  version,
+  mapState,
+  mapMutations,
+  mapGetters,
+  mapActions,
+  createNamespacedHelpers,
+  createLogger
+}

node_modules/vuex/package.json

@@ -0,0 +1,124 @@
+{
+  "_from": "vuex",
+  "_id": "vuex@3.6.2",
+  "_inBundle": false,
+  "_integrity": "sha512-ETW44IqCgBpVomy520DT5jf8n0zoCac+sxWnn+hMe/CzaSejb/eVw2YToiXYX+Ex/AuHHia28vWTq4goAexFbw==",
+  "_location": "/vuex",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "tag",
+    "registry": true,
+    "raw": "vuex",
+    "name": "vuex",
+    "escapedName": "vuex",
+    "rawSpec": "",
+    "saveSpec": null,
+    "fetchSpec": "latest"
+  },
+  "_requiredBy": [
+    "#USER",
+    "/"
+  ],
+  "_resolved": "https://registry.npmjs.org/vuex/-/vuex-3.6.2.tgz",
+  "_shasum": "236bc086a870c3ae79946f107f16de59d5895e71",
+  "_spec": "vuex",
+  "_where": "/Users/WebTmm/Desktop/ZhHealth",
+  "author": {
+    "name": "Evan You"
+  },
+  "bugs": {
+    "url": "https://github.com/vuejs/vuex/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "state management for Vue.js",
+  "devDependencies": {
+    "@babel/core": "^7.12.10",
+    "@babel/preset-env": "^7.12.11",
+    "@rollup/plugin-buble": "^0.21.3",
+    "@rollup/plugin-commonjs": "^11.1.0",
+    "@rollup/plugin-node-resolve": "^7.1.3",
+    "@rollup/plugin-replace": "^2.3.2",
+    "@types/node": "^13.13.5",
+    "@vuepress/theme-vue": "^1.8.0",
+    "babel-jest": "^26.6.3",
+    "babel-loader": "^8.2.2",
+    "brotli": "^1.3.2",
+    "chalk": "^4.0.0",
+    "conventional-changelog-cli": "^2.1.1",
+    "cross-env": "^5.2.0",
+    "css-loader": "^2.1.0",
+    "enquirer": "^2.3.5",
+    "eslint": "^6.8.0",
+    "eslint-plugin-vue-libs": "^4.0.0",
+    "execa": "^5.0.0",
+    "express": "^4.17.1",
+    "jest": "^26.6.3",
+    "puppeteer": "^4.0.0",
+    "regenerator-runtime": "^0.13.5",
+    "rollup": "^2.38.0",
+    "rollup-plugin-terser": "^5.3.0",
+    "semver": "^7.3.2",
+    "start-server-and-test": "^1.11.7",
+    "todomvc-app-css": "^2.3.0",
+    "typescript": "^3.8.3",
+    "vue": "2.5.22",
+    "vue-loader": "15.2.1",
+    "vue-server-renderer": "2.5.22",
+    "vue-template-compiler": "2.5.22",
+    "vuepress": "^1.8.0",
+    "webpack": "^4.43.0",
+    "webpack-dev-middleware": "^3.7.2",
+    "webpack-hot-middleware": "^2.25.0"
+  },
+  "exports": {
+    ".": {
+      "module": "./dist/vuex.esm.js",
+      "require": "./dist/vuex.common.js",
+      "import": "./dist/vuex.mjs"
+    },
+    "./": "./"
+  },
+  "files": [
+    "dist",
+    "types/index.d.ts",
+    "types/helpers.d.ts",
+    "types/logger.d.ts",
+    "types/vue.d.ts"
+  ],
+  "homepage": "https://github.com/vuejs/vuex#readme",
+  "jsdelivr": "dist/vuex.js",
+  "license": "MIT",
+  "main": "dist/vuex.common.js",
+  "module": "dist/vuex.esm.js",
+  "name": "vuex",
+  "peerDependencies": {
+    "vue": "^2.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vuejs/vuex.git"
+  },
+  "scripts": {
+    "build": "npm run build:main && npm run build:logger",
+    "build:logger": "node scripts/build-logger.js",
+    "build:main": "node scripts/build-main.js",
+    "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s",
+    "coverage": "jest --testPathIgnorePatterns test/e2e --coverage",
+    "dev": "node examples/server.js",
+    "docs": "vuepress dev docs",
+    "docs:build": "vuepress build docs",
+    "lint": "eslint src test",
+    "release": "node scripts/release.js",
+    "test": "npm run lint && npm run test:types && npm run test:unit && npm run test:ssr && npm run test:e2e && npm run test:esm",
+    "test:e2e": "start-server-and-test dev http://localhost:8080 \"jest --testPathIgnorePatterns test/unit\"",
+    "test:esm": "node test/esm/esm-test.js",
+    "test:ssr": "cross-env VUE_ENV=server jest --testPathIgnorePatterns test/e2e",
+    "test:types": "tsc -p types/test",
+    "test:unit": "jest --testPathIgnorePatterns test/e2e"
+  },
+  "sideEffects": false,
+  "typings": "types/index.d.ts",
+  "unpkg": "dist/vuex.js",
+  "version": "3.6.2"
+}

node_modules/vuex/types/helpers.d.ts

@@ -0,0 +1,86 @@
+import Vue from 'vue';
+import { Dispatch, Commit } from './index';
+
+type Computed = () => any;
+type InlineComputed<T extends Function> = T extends (...args: any[]) => infer R ? () => R : never
+type MutationMethod = (...args: any[]) => void;
+type ActionMethod = (...args: any[]) => Promise<any>;
+type InlineMethod<T extends (fn: any, ...args: any[]) => any> = T extends (fn: any, ...args: infer Args) => infer R ? (...args: Args) => R : never
+type CustomVue = Vue & Record<string, any>;
+
+interface Mapper<R> {
+  <Key extends string>(map: Key[]): { [K in Key]: R };
+  <Map extends Record<string, string>>(map: Map): { [K in keyof Map]: R };
+}
+
+interface MapperWithNamespace<R> {
+  <Key extends string>(namespace: string, map: Key[]): { [K in Key]: R };
+  <Map extends Record<string, string>>(namespace: string, map: Map): { [K in keyof Map]: R };
+}
+
+interface MapperForState {
+  <S, Map extends Record<string, (this: CustomVue, state: S, getters: any) => any> = {}>(
+    map: Map
+  ): { [K in keyof Map]: InlineComputed<Map[K]> };
+}
+
+interface MapperForStateWithNamespace {
+  <S, Map extends Record<string, (this: CustomVue, state: S, getters: any) => any> = {}>(
+    namespace: string,
+    map: Map
+  ): { [K in keyof Map]: InlineComputed<Map[K]> };
+}
+
+interface MapperForAction {
+  <Map extends Record<string, (this: CustomVue, dispatch: Dispatch, ...args: any[]) => any>>(
+    map: Map
+  ): { [K in keyof Map]: InlineMethod<Map[K]> };
+}
+
+interface MapperForActionWithNamespace {
+  <Map extends Record<string, (this: CustomVue, dispatch: Dispatch, ...args: any[]) => any>>(
+    namespace: string,
+    map: Map
+  ): { [K in keyof Map]: InlineMethod<Map[K]> };
+}
+
+interface MapperForMutation {
+  <Map extends Record<string, (this: CustomVue, commit: Commit, ...args: any[]) => any>>(
+    map: Map
+  ): { [K in keyof Map]: InlineMethod<Map[K]> };
+}
+
+interface MapperForMutationWithNamespace {
+  <Map extends Record<string, (this: CustomVue, commit: Commit, ...args: any[]) => any>>(
+    namespace: string,
+    map: Map
+  ): { [K in keyof Map]: InlineMethod<Map[K]> };
+}
+
+
+interface NamespacedMappers {
+  mapState: Mapper<Computed> & MapperForState;
+  mapMutations: Mapper<MutationMethod> & MapperForMutation;
+  mapGetters: Mapper<Computed>;
+  mapActions: Mapper<ActionMethod> & MapperForAction;
+}
+
+export declare const mapState: Mapper<Computed>
+  & MapperWithNamespace<Computed>
+  & MapperForState
+  & MapperForStateWithNamespace;
+
+export declare const mapMutations: Mapper<MutationMethod>
+  & MapperWithNamespace<MutationMethod>
+  & MapperForMutation
+  & MapperForMutationWithNamespace;
+
+export declare const mapGetters: Mapper<Computed>
+  & MapperWithNamespace<Computed>;
+
+export declare const mapActions: Mapper<ActionMethod>
+  & MapperWithNamespace<ActionMethod>
+  & MapperForAction
+  & MapperForActionWithNamespace;
+
+export declare function createNamespacedHelpers(namespace: string): NamespacedMappers;

node_modules/vuex/types/index.d.ts

@@ -0,0 +1,164 @@
+import _Vue, { WatchOptions } from "vue";
+
+// augment typings of Vue.js
+import "./vue";
+
+import { mapState, mapMutations, mapGetters, mapActions, createNamespacedHelpers } from "./helpers";
+import createLogger from "./logger";
+
+export * from "./helpers";
+export * from "./logger";
+
+export declare class Store<S> {
+  constructor(options: StoreOptions<S>);
+
+  readonly state: S;
+  readonly getters: any;
+
+  replaceState(state: S): void;
+
+  dispatch: Dispatch;
+  commit: Commit;
+
+  subscribe<P extends MutationPayload>(fn: (mutation: P, state: S) => any, options?: SubscribeOptions): () => void;
+  subscribeAction<P extends ActionPayload>(fn: SubscribeActionOptions<P, S>, options?: SubscribeOptions): () => void;
+  watch<T>(getter: (state: S, getters: any) => T, cb: (value: T, oldValue: T) => void, options?: WatchOptions): () => void;
+
+  registerModule<T>(path: string, module: Module<T, S>, options?: ModuleOptions): void;
+  registerModule<T>(path: string[], module: Module<T, S>, options?: ModuleOptions): void;
+
+  unregisterModule(path: string): void;
+  unregisterModule(path: string[]): void;
+
+  hasModule(path: string): boolean;
+  hasModule(path: string[]): boolean;
+
+  hotUpdate(options: {
+    actions?: ActionTree<S, S>;
+    mutations?: MutationTree<S>;
+    getters?: GetterTree<S, S>;
+    modules?: ModuleTree<S>;
+  }): void;
+}
+
+export declare function install(Vue: typeof _Vue): void;
+
+export interface Dispatch {
+  (type: string, payload?: any, options?: DispatchOptions): Promise<any>;
+  <P extends Payload>(payloadWithType: P, options?: DispatchOptions): Promise<any>;
+}
+
+export interface Commit {
+  (type: string, payload?: any, options?: CommitOptions): void;
+  <P extends Payload>(payloadWithType: P, options?: CommitOptions): void;
+}
+
+export interface ActionContext<S, R> {
+  dispatch: Dispatch;
+  commit: Commit;
+  state: S;
+  getters: any;
+  rootState: R;
+  rootGetters: any;
+}
+
+export interface Payload {
+  type: string;
+}
+
+export interface MutationPayload extends Payload {
+  payload: any;
+}
+
+export interface ActionPayload extends Payload {
+  payload: any;
+}
+
+export interface SubscribeOptions {
+  prepend?: boolean
+}
+
+export type ActionSubscriber<P, S> = (action: P, state: S) => any;
+export type ActionErrorSubscriber<P, S> = (action: P, state: S, error: Error) => any;
+
+export interface ActionSubscribersObject<P, S> {
+  before?: ActionSubscriber<P, S>;
+  after?: ActionSubscriber<P, S>;
+  error?: ActionErrorSubscriber<P, S>;
+}
+
+export type SubscribeActionOptions<P, S> = ActionSubscriber<P, S> | ActionSubscribersObject<P, S>;
+
+export interface DispatchOptions {
+  root?: boolean;
+}
+
+export interface CommitOptions {
+  silent?: boolean;
+  root?: boolean;
+}
+
+export interface StoreOptions<S> {
+  state?: S | (() => S);
+  getters?: GetterTree<S, S>;
+  actions?: ActionTree<S, S>;
+  mutations?: MutationTree<S>;
+  modules?: ModuleTree<S>;
+  plugins?: Plugin<S>[];
+  strict?: boolean;
+  devtools?: boolean;
+}
+
+export type ActionHandler<S, R> = (this: Store<R>, injectee: ActionContext<S, R>, payload?: any) => any;
+export interface ActionObject<S, R> {
+  root?: boolean;
+  handler: ActionHandler<S, R>;
+}
+
+export type Getter<S, R> = (state: S, getters: any, rootState: R, rootGetters: any) => any;
+export type Action<S, R> = ActionHandler<S, R> | ActionObject<S, R>;
+export type Mutation<S> = (state: S, payload?: any) => any;
+export type Plugin<S> = (store: Store<S>) => any;
+
+export interface Module<S, R> {
+  namespaced?: boolean;
+  state?: S | (() => S);
+  getters?: GetterTree<S, R>;
+  actions?: ActionTree<S, R>;
+  mutations?: MutationTree<S>;
+  modules?: ModuleTree<R>;
+}
+
+export interface ModuleOptions {
+  preserveState?: boolean;
+}
+
+export interface GetterTree<S, R> {
+  [key: string]: Getter<S, R>;
+}
+
+export interface ActionTree<S, R> {
+  [key: string]: Action<S, R>;
+}
+
+export interface MutationTree<S> {
+  [key: string]: Mutation<S>;
+}
+
+export interface ModuleTree<R> {
+  [key: string]: Module<any, R>;
+}
+
+export { createLogger }
+
+declare const _default: {
+  Store: typeof Store;
+  install: typeof install;
+  mapState: typeof mapState,
+  mapMutations: typeof mapMutations,
+  mapGetters: typeof mapGetters,
+  mapActions: typeof mapActions,
+  createNamespacedHelpers: typeof createNamespacedHelpers,
+  createLogger: typeof createLogger
+};
+export default _default;

node_modules/vuex/types/logger.d.ts

@@ -0,0 +1,20 @@
+import { Payload, Plugin } from "./index";
+
+interface Logger extends Partial<Pick<Console, 'groupCollapsed' | 'group' | 'groupEnd'>> {
+  log(message: string, color: string, payload: any): void;
+  log(message: string): void;
+}
+
+export interface LoggerOption<S> {
+  collapsed?: boolean;
+  filter?: <P extends Payload>(mutation: P, stateBefore: S, stateAfter: S) => boolean;
+  transformer?: (state: S) => any;
+  mutationTransformer?: <P extends Payload>(mutation: P) => any;
+  actionFilter?: <P extends Payload>(action: P, state: S) => boolean;
+  actionTransformer?: <P extends Payload>(action: P) => any;
+  logMutations?: boolean;
+  logActions?: boolean;
+  logger?: Logger;
+}
+
+export default function createLogger<S>(option?: LoggerOption<S>): Plugin<S>;

node_modules/vuex/types/vue.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Extends interfaces in Vue.js
+ */
+
+import Vue, { ComponentOptions } from "vue";
+import { Store } from "./index";
+
+declare module "vue/types/options" {
+  interface ComponentOptions<V extends Vue> {
+    store?: Store<any>;
+  }
+}
+
+declare module "vue/types/vue" {
+  interface Vue {
+    $store: Store<any>;
+  }
+}