From f8bf14d3e401f2787891ed260bcb92a4b66333ab Mon Sep 17 00:00:00 2001
From: SuperMonster003 <wu2du2mo2gu0@gmail.com>
Date: Thu, 1 Dec 2022 16:21:28 +0800
Subject: [PATCH] =?UTF-8?q?1.0.0=20-=20=E9=87=8D=E6=96=B0=E9=83=A8?=
 =?UTF-8?q?=E7=BD=B2=E6=96=87=E6=A1=A3=E7=BB=93=E6=9E=84/=E5=A2=9E?=
 =?UTF-8?q?=E5=8A=A0=E9=83=A8=E5=88=86=E7=AB=A0=E8=8A=82/=E7=BB=9F?=
 =?UTF-8?q?=E4=B8=80=E6=A0=B7=E5=BC=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 api/.gitignore                      |    3 +
 api/{_404.md => 404.md}             |    0
 api/_sidebar.md                     |   30 -
 api/_toc.md                         |   40 -
 api/activity.md                     |   10 +
 api/all.md                          |   45 +-
 api/apiLevel.md                     |   72 +
 api/app.md                          |  176 +-
 api/appType.md                      |  259 +
 api/arrayx.md                       |  407 ++
 api/autojs.md                       |    8 +
 api/automator.md                    |  534 ++
 api/base64.md                       |   10 +
 api/canvas.md                       |   77 +-
 api/changelog.md                    |   13 +
 api/color.md                        |  152 +
 api/console.md                      |   81 +-
 api/context.md                      |   14 +
 api/continuation.md                 |   10 +
 api/coordinatesBasedAutomation.md   |  260 -
 api/{_coverpage.md => coverpage.md} |    6 +-
 api/crypto.md                       |   21 +-
 api/dataTypes.md                    | 1472 ++++
 api/device.md                       |  135 +-
 api/dialogs.md                      |  157 +-
 api/documentation.md                |  443 +-
 api/e4x.md                          |   31 +
 api/engines.md                      |   93 +-
 api/events.md                       |  209 +-
 api/exceptions.md                   | 1071 +++
 api/files.md                        |  131 +-
 api/floaty.md                       |   87 +-
 api/global.md                       | 1023 +++
 api/globals.md                      |  223 -
 api/glossaries.md                   |  566 ++
 api/http.md                         |  105 +-
 api/i18n.md                         |   10 +
 api/image.md                        |  798 +++
 api/images.md                       |  941 ---
 api/index.html                      |   21 +-
 api/intentType.md                   |   52 +
 api/keys.md                         |   95 +-
 api/mathx.md                        |  673 ++
 api/media.md                        |   45 +-
 api/modules.md                      |   25 +-
 api/numberx.md                      |  301 +
 api/overview.md                     |   73 +-
 api/plugins.md                      |   10 +
 api/polyfill.md                     |   30 +
 api/progress.md                     |   69 +
 api/qa.md                           |   89 +-
 api/recorder.md                     |   66 +
 api/runtime.md                      |   52 +
 api/scriptingJava.md                |  262 +
 api/sensors.md                      |  159 +-
 api/shell.md                        |  347 +-
 api/sidebar.md                      |   76 +
 api/static/docsify-config.js        |   17 +
 api/static/docsify.js               | 9719 +++++++++++++++++++++++++++
 api/static/docsify.min.js           |    1 -
 api/static/search.js                |  555 ++
 api/static/search.min.js            |    1 -
 api/static/vue.css                  | 1251 +++-
 api/storages.md                     |   43 +-
 api/tasks.md                        |   10 +
 api/threads.md                      |  101 +-
 api/timers.md                       |   61 +-
 api/toc.md                          |   84 +
 api/ui.md                           |  439 +-
 api/uiObjectActionsType.md          | 1246 ++++
 api/uiObjectCollectionType.md       |  791 +++
 api/uiObjectType.md                 | 2189 ++++++
 api/uiSelectorType.md               | 6106 +++++++++++++++++
 api/util.md                         |   48 -
 api/web.md                          |   10 +
 api/widgetsBasedAutomation.md       | 1226 ----
 76 files changed, 31901 insertions(+), 4165 deletions(-)
 create mode 100644 api/.gitignore
 rename api/{_404.md => 404.md} (100%)
 delete mode 100644 api/_sidebar.md
 delete mode 100644 api/_toc.md
 create mode 100644 api/activity.md
 create mode 100644 api/apiLevel.md
 create mode 100644 api/appType.md
 create mode 100644 api/arrayx.md
 create mode 100644 api/autojs.md
 create mode 100644 api/automator.md
 create mode 100644 api/base64.md
 create mode 100644 api/changelog.md
 create mode 100644 api/color.md
 create mode 100644 api/context.md
 create mode 100644 api/continuation.md
 delete mode 100644 api/coordinatesBasedAutomation.md
 rename api/{_coverpage.md => coverpage.md} (60%)
 create mode 100644 api/dataTypes.md
 create mode 100644 api/e4x.md
 create mode 100644 api/exceptions.md
 create mode 100644 api/global.md
 delete mode 100644 api/globals.md
 create mode 100644 api/glossaries.md
 create mode 100644 api/i18n.md
 create mode 100644 api/image.md
 delete mode 100644 api/images.md
 create mode 100644 api/intentType.md
 create mode 100644 api/mathx.md
 create mode 100644 api/numberx.md
 create mode 100644 api/plugins.md
 create mode 100644 api/polyfill.md
 create mode 100644 api/progress.md
 create mode 100644 api/recorder.md
 create mode 100644 api/runtime.md
 create mode 100644 api/scriptingJava.md
 create mode 100644 api/sidebar.md
 create mode 100644 api/static/docsify-config.js
 create mode 100644 api/static/docsify.js
 delete mode 100644 api/static/docsify.min.js
 create mode 100644 api/static/search.js
 delete mode 100644 api/static/search.min.js
 create mode 100644 api/tasks.md
 create mode 100644 api/toc.md
 create mode 100644 api/uiObjectActionsType.md
 create mode 100644 api/uiObjectCollectionType.md
 create mode 100644 api/uiObjectType.md
 create mode 100644 api/uiSelectorType.md
 create mode 100644 api/web.md
 delete mode 100644 api/widgetsBasedAutomation.md

diff --git a/api/.gitignore b/api/.gitignore
new file mode 100644
index 0000000..de1a26b
--- /dev/null
+++ b/api/.gitignore
@@ -0,0 +1,3 @@
+.idea
+*.bak
+declarations
\ No newline at end of file
diff --git a/api/_404.md b/api/404.md
similarity index 100%
rename from api/_404.md
rename to api/404.md
diff --git a/api/_sidebar.md b/api/_sidebar.md
deleted file mode 100644
index 8ba6ba6..0000000
--- a/api/_sidebar.md
+++ /dev/null
@@ -1,30 +0,0 @@
-* [About - 关于文档](/documentation)
-* -------------
-* %MARKER%
-* -------------
-* [Q&A](/qa)
-* [Global - 全局对象](/globals)
-* [应用 - App](/app)
-* [控制台 - Console](/console)
-* [基于坐标的操作 - CoordinatesBasedAutomation](/coordinatesBasedAutomation)
-* [加解密与消息摘要 - Crypto](/crypto)
-* [设备 - Device](/device)
-* [对话框 - Dialogs](/dialogs)
-* [脚本引擎 - Engines](/engines)
-* [事件与监听 - Events](/events)
-* [悬浮窗 - Floaty](/floaty)
-* [文件系统 - Files](/files)
-* [HTTP - Http](/http)
-* [图片与颜色 - Images](/images)
-* [画布 - Canvas](/canvas)
-* [按键模拟 - Keys](/keys)
-* [多媒体 - Media](/media)
-* [模块 - Modules](/modules)
-* [基于控件的操作 - WidgetsBaseAutomation](/widgetsBasedAutomation)
-* [传感器 - Sensor](/sensors)
-* [Shell - Shell](/shell)
-* [本地储存 - Storages](/storages)
-* [多线程 - Threads](/threads)
-* [定时器 - Timers](/timers)
-* [用户界面 - UI](/ui)
-* [调用Java - Work with Java](https://developer.mozilla.org/zh-CN/docs/Mozilla/Projects/Rhino/Scripting_Java)
diff --git a/api/_toc.md b/api/_toc.md
deleted file mode 100644
index 273e093..0000000
--- a/api/_toc.md
+++ /dev/null
@@ -1,40 +0,0 @@
-@// NB(chrisdickinson): if you move this file, be sure to update tools/doc/html.js to
-@// point at the new location.
-
-* [关于本文档](documentation.html)
-* [W3CSchool - ECMAScript教程](http://www.w3school.com.cn/js/pro_js_syntax.asp)
-* [阮一峰 - ECMAScript 6教程](http://es6.ruanyifeng.com/#README)
-
-<div class="line"></div>
-
-* [Overview - 综述](overview.html)
-* [Q&A - 常见问题](qa.html)
-* [App - 应用](app.html)
-* [Canvas - 画布](canvas.html)
-* [Console - 控制台](console.html)
-* [CoordinatesBasedAutomation - 基于坐标的操作](coordinatesBasedAutomation.html)
-* [Crypto - 加解密与消息摘要](crypto.html)
-* [Device - 设备](device.html)
-* [Dialogs - 对话框](dialogs.html)
-* [Engines - 脚本引擎](engines.html)
-* [Events - 事件与监听](events.html)
-* [Floaty - 悬浮窗](floaty.html)
-* [Files - 文件系统](files.html)
-* [Globals - 一般全局函数](globals.html)
-* [Http - HTTP](http.html)
-* [Images - 图片与图色处理](images.html)
-* [Keys - 按键模拟](keys.html)
-* [Media - 多媒体](media.html)
-* [Modules - 模块](modules.html)
-* [Sensors - 传感器](sensors.html)
-* [Shell - Shell命令](shell.html)
-* [Storages - 本地存储](storages.html)
-* [Threads - 多线程](threads.html)
-* [Timers - 定时器](timers.html)
-* [UI - 用户界面](ui.html)
-* [WidgetsBasedAutomation - 基于控件的操作](widgetsBasedAutomation.html)
-* [Work with Java - 调用Java API](https://developer.mozilla.org/zh-CN/docs/Mozilla/Projects/Rhino/Scripting_Java)
-
-<div class="line"></div>
-
-* [GitHub项目 & Issue提交](https://github.com/SuperMonster003/AutoJs6)
diff --git a/api/activity.md b/api/activity.md
new file mode 100644
index 0000000..082c663
--- /dev/null
+++ b/api/activity.md
@@ -0,0 +1,10 @@
+# 活动 (Activity)
+
+---
+
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
+
+---
+
+
diff --git a/api/all.md b/api/all.md
index 7d25d7a..f1d7795 100644
--- a/api/all.md
+++ b/api/all.md
@@ -1,26 +1,37 @@
 @include overview
+@include documentation
 @include qa
+
+@include global
+@include automator
+@include autojs
 @include app
-@include canvas
-@include console
-@include coordinatesBasedAutomation
-@include crypto
+@include color
+@include image
+@include keys
 @include device
-@include dialogs
-@include engines
-@include events
-@include floaty
+@include storages
 @include files
-@include globals
-@include http
-@include images
-@include keys
-@include media
+@include engines
+@include tasks
 @include modules
-@include sensors
+@include plugins
+@include continuation
+@include console
 @include shell
-@include storages
-@include threads
+@include media
+@include sensors
+@include recorder
 @include timers
+@include threads
+@include events
+@include dialogs
+@include floaty
+@include canvas
 @include ui
-@include widgetsBasedAutomation
\ No newline at end of file
+@include web
+@include http
+@include base64
+@include crypto
+@include i18n
+@include e4x
\ No newline at end of file
diff --git a/api/apiLevel.md b/api/apiLevel.md
new file mode 100644
index 0000000..b0ae9d1
--- /dev/null
+++ b/api/apiLevel.md
@@ -0,0 +1,72 @@
+# 安卓 API 级别 (Android API Level)
+
+API 级别 (API Level) 是对 Android 平台版本 (SDK Platforms) 提供的框架 API 修订版进行唯一标识的整数值 (SDK INT).
+
+Android 平台提供一种框架 API, 应用可利用它与底层 Android 系统进行交互.
+每个 Android 平台版本恰好支持一个 API 级别, 但隐含对所有早期 API 级别的支持.  
+Android 平台初始版本提供的是 API 级别 1, 后续版本的 API 级别则依次增加.
+
+下表列出了各 Android 平台版本所支持的 API 级别:
+
+| API 级别 | 版本名称 (Version Name)        | 版本代号 (Version Code)    | 版本号 (Version Number) | 内部代号 (Internal Codename) | 发行日期               |
+|:-------|:---------------------------|:-----------------------|:---------------------|:-------------------------|:-------------------|
+| 34     | Android 14                 | ?                      | 14                   | Upside Down Cake         | Q3 2023            |
+| 33     | Android 13                 | TIRAMISU               | 13                   | Tiramisu                 | August 15, 2022    |
+| 32     | Android 12L                | S_V2                   | 12.1                 | Snow Cone v2             | March 7, 2022      |
+| 31     | Android 12                 | S                      | 12                   | Snow Cone                | October 4, 2021    |
+| 30     | Android 11                 | R                      | 11                   | Red Velvet Cake          | September 8, 2020  |
+| 29     | Android 10                 | Q                      | 10                   | Quince Tart              | September 3, 2019  |
+| 28     | Android Pie                | P                      | 9                    | Pistachio Ice Cream      | August 6, 2018     |
+| 27     | Android Oreo               | O_MR1                  | 8.1                  | Oatmeal Cookie           | December 5, 2017   |
+| 26     | Android Oreo               | O                      | 8.0                  | Oatmeal Cookie           | August 21, 2017    |
+| 25     | Android Nougat             | N_MR1                  | 7.1-7.1.2            | New York Cheesecake      | October 4, 2016    |
+| 24     | Android Nougat             | N                      | 7.0                  | New York Cheesecake      | August 22, 2016    |
+| 23     | Android Marshmallow        | M                      | 6.0-6.0.1            | Macadamia Nut Cookie     | October 2, 2015    |
+| 22     | Android Lollipop           | LOLLIPOP_MR1           | 5.1-5.1.1            | Lemon Meringue Pie       | March 2, 2015      |
+| 21     | Android Lollipop           | LOLLIPOP               | 5.0-5.0.2            | Lemon Meringue Pie       | November 4, 2014   |
+| 20     | Android KitKat             | KITKAT_WATCH           | 4.4W-4.4W.2          | Key Lime Pie             | June 25, 2014      |
+| 19     | Android KitKat             | KITKAT                 | 4.4-4.4.4            | Key Lime Pie             | October 31, 2013   |
+| 18     | Android Jelly Bean         | JELLY_BEAN_MR2         | 4.3-4.3.1            | Jelly Bean               | July 24, 2013      |
+| 17     | Android Jelly Bean         | JELLY_BEAN_MR1         | 4.2-4.2.2            | Jelly Bean               | November 13, 2012  |
+| 16     | Android Jelly Bean         | JELLY_BEAN             | 4.1-4.1.2            | Jelly Bean               | July 9, 2012       |
+| 15     | Android Ice Cream Sandwich | ICE_CREAM_SANDWICH_MR1 | 4.0.3-4.0.4          | Ice Cream Sandwich       | December 16, 2011  |
+| 14     | Android Ice Cream Sandwich | ICE_CREAM_SANDWICH     | 4.0-4.0.2            | Ice Cream Sandwich       | October 18, 2011   |
+| 13     | Android Honeycomb          | HONEYCOMB_MR2          | 3.2-3.2.6            | Honeycomb                | July 15, 2011      |
+| 12     | Android Honeycomb          | HONEYCOMB_MR1          | 3.1                  | Honeycomb                | May 10, 2011       |
+| 11     | Android Honeycomb          | HONEYCOMB              | 3.0                  | Honeycomb                | February 22, 2011  |
+| 10     | Android Gingerbread        | GINGERBREAD_MR1        | 2.3.3-2.3.7          | Gingerbread              | February 9, 2011   |
+| 9      | Android Gingerbread        | GINGERBREAD            | 2.3-2.3.2            | Gingerbread              | December 6, 2010   |
+| 8      | Android Froyo              | FROYO                  | 2.2-2.2.3            | Froyo                    | May 20, 2010       |
+| 7      | Android Eclair             | ECLAIR_MR1             | 2.1                  | Eclair                   | January 11, 2010   |
+| 6      | Android Eclair             | ECLAIR_0_1             | 2.0.1                | Eclair                   | December 3, 2009   |
+| 5      | Android Eclair             | ECLAIR                 | 2.0                  | Eclair                   | October 27, 2009   |
+| 4      | Android Donut              | DONUT                  | 1.6                  | Donut                    | September 15, 2009 |
+| 3      | Android Cupcake            | CUPCAKE                | 1.5                  | Cupcake                  | April 27, 2009     |
+| 2      | Android 1.1                | BASE_1_1               | 1.1                  | Petit Four               | February 9, 2009   |
+| 1      | Android 1.0                | BASE                   | 1.0                  | -                        | September 23, 2008 |
+
+文档通常使用以下格式之一表示 API 级别的信息:
+
+- 30 (11) [R]
+- API 30 (11) [R]
+- Android API 30 (11) [R]
+
+上述示例中,  
+`30` 表示 `API 级别`,  
+`11` 表示 `版本号 (Version Number)`,  
+`R` 表示 `版本代号 (Version Code)`.
+
+查询当前设备的 API 级别:
+
+```js
+console.log(device.sdkInt); /* e.g. 30 */
+```
+
+要求设备 API 级别不低于指定值:
+
+```js
+/* 在 API 级别低于 30 的设备上将抛出异常. */
+runtime.requiresApi(30);
+```
+
+> 注: AutoJs6 安装及使用需满足的最低 API 级别为 24.
\ No newline at end of file
diff --git a/api/app.md b/api/app.md
index 749cc1a..7e8e79a 100644
--- a/api/app.md
+++ b/api/app.md
@@ -1,16 +1,23 @@
-# App
+# 通用应用 (App)
 
-app模块提供一系列函数，用于使用其他应用、与其他应用交互。例如发送意图、打开文件、发送邮件等。
+---
 
-同时提供了方便的进阶函数startActivity和sendBroadcast，用他们可完成app模块没有内置的和其他应用的交互。
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
+
+---
+
+app模块提供一系列函数, 用于使用其他应用、与其他应用交互. 例如发送意图、打开文件、发送邮件等.
+
+同时提供了方便的进阶函数startActivity和sendBroadcast, 用他们可完成app模块没有内置的和其他应用的交互.
 
 ## app.versionCode
 
 * {number}
 
-当前软件版本号，整数值。例如160, 256等。
+当前软件版本号, 整数值. 例如160, 256等.
 
-如果在Auto.js中运行则为Auto.js的版本号；在打包的软件中则为打包软件的版本号。
+如果在Auto.js中运行则为Auto.js的版本号；在打包的软件中则为打包软件的版本号.
 
 ```
 toastLog(app.versionCode);
@@ -20,9 +27,9 @@ toastLog(app.versionCode);
 
 * {string}
 
-当前软件的版本名称，例如"3.0.0 Beta"。
+当前软件的版本名称, 例如"3.0.0 Beta".
 
-如果在Auto.js中运行则为Auto.js的版本名称；在打包的软件中则为打包软件的版本名称。
+如果在Auto.js中运行则为Auto.js的版本名称；在打包的软件中则为打包软件的版本名称.
 
 ```
 toastLog(app.verionName);
@@ -32,21 +39,21 @@ toastLog(app.verionName);
 
 * {number}
 
-Auto.js版本号，整数值。例如160, 256等。
+Auto.js版本号, 整数值. 例如160, 256等.
 
 ## app.autojs.versionName
 
 * {string}
 
-Auto.js版本名称，例如"3.0.0 Beta"。
+Auto.js版本名称, 例如"3.0.0 Beta".
 
 ## app.launchApp(appName)
 
 * `appName` {string} 应用名称
 
-通过应用名称启动应用。如果该名称对应的应用不存在，则返回false; 否则返回true。如果该名称对应多个应用，则只启动其中某一个。
+通过应用名称启动应用. 如果该名称对应的应用不存在, 则返回false; 否则返回true. 如果该名称对应多个应用, 则只启动其中某一个.
 
-该函数也可以作为全局函数使用。
+该函数也可以作为全局函数使用.
 
 ```
 launchApp("Auto.js");
@@ -56,9 +63,9 @@ launchApp("Auto.js");
 
 * `packageName` {string} 应用包名
 
-通过应用包名启动应用。如果该包名对应的应用不存在，则返回false；否则返回true。
+通过应用包名启动应用. 如果该包名对应的应用不存在, 则返回false；否则返回true.
 
-该函数也可以作为全局函数使用。
+该函数也可以作为全局函数使用.
 
 ```
 //启动微信
@@ -69,15 +76,15 @@ launch("com.tencent.mm");
 
 * `packageName` {string} 应用包名
 
-相当于`app.launch(packageName)`。
+相当于`app.launch(packageName)`.
 
 ## app.getPackageName(appName)
 
 * `appName` {string} 应用名称
 
-获取应用名称对应的已安装的应用的包名。如果该找不到该应用，返回null；如果该名称对应多个应用，则只返回其中某一个的包名。
+获取应用名称对应的已安装的应用的包名. 如果该找不到该应用, 返回null；如果该名称对应多个应用, 则只返回其中某一个的包名.
 
-该函数也可以作为全局函数使用。
+该函数也可以作为全局函数使用.
 
 ```
 var name = getPackageName("QQ"); //返回"com.tencent.mobileqq"
@@ -87,9 +94,9 @@ var name = getPackageName("QQ"); //返回"com.tencent.mobileqq"
 
 * `packageName` {string} 应用包名
 
-获取应用包名对应的已安装的应用的名称。如果该找不到该应用，返回null。
+获取应用包名对应的已安装的应用的名称. 如果该找不到该应用, 返回null.
 
-该函数也可以作为全局函数使用。
+该函数也可以作为全局函数使用.
 
 ```
 var name = getAppName("com.tencent.mobileqq"); //返回"QQ"
@@ -99,17 +106,17 @@ var name = getAppName("com.tencent.mobileqq"); //返回"QQ"
 
 * `packageName` {string} 应用包名
 
-打开应用的详情页(设置页)。如果找不到该应用，返回false; 否则返回true。
+打开应用的详情页(设置页). 如果找不到该应用, 返回false; 否则返回true.
 
-该函数也可以作为全局函数使用。
+该函数也可以作为全局函数使用.
 
 ## app.viewFile(path)
 
 * `path` {string} 文件路径
 
-用其他应用查看文件。文件不存在的情况由查看文件的应用处理。
+用其他应用查看文件. 文件不存在的情况由查看文件的应用处理.
 
-如果找不出可以查看该文件的应用，则抛出`ActivityNotException`。
+如果找不出可以查看该文件的应用, 则抛出`ActivityNotException`.
 
 ```
 //查看文本文件
@@ -120,9 +127,9 @@ app.viewFile("/sdcard/1.txt");
 
 * `path` {string} 文件路径
 
-用其他应用编辑文件。文件不存在的情况由编辑文件的应用处理。
+用其他应用编辑文件. 文件不存在的情况由编辑文件的应用处理.
 
-如果找不出可以编辑该文件的应用，则抛出`ActivityNotException`。
+如果找不出可以编辑该文件的应用, 则抛出`ActivityNotException`.
 
 ```
 //编辑文本文件
@@ -133,7 +140,7 @@ app.editFile("/sdcard/1.txt/);
 
 * `packageName` {string} 应用包名
 
-卸载应用。执行后会会弹出卸载应用的提示框。如果该包名的应用未安装，由应用卸载程序处理，可能弹出"未找到应用"的提示。
+卸载应用. 执行后会会弹出卸载应用的提示框. 如果该包名的应用未安装, 由应用卸载程序处理, 可能弹出"未找到应用"的提示.
 
 ```
 //卸载QQ
@@ -142,28 +149,28 @@ app.uninstall("com.tencent.mobileqq");
 
 ## app.openUrl(url)
 
-* `url` {string} 网站的Url，如果不以"http://"或"https://"开头则默认是"http://"。
+* `url` {string} 网站的Url, 如果不以"http://"或"https://"开头则默认是"http://".
 
-用浏览器打开网站url。
+用浏览器打开网站url.
 
-如果没有安装浏览器应用，则抛出`ActivityNotException`。
+如果没有安装浏览器应用, 则抛出`ActivityNotException`.
 
 ## app.sendEmail(options)
 
-* `options` {Object} 发送邮件的参数。包括:
-* `email` {string} | {Array} 收件人的邮件地址。如果有多个收件人，则用字符串数组表示
-* `cc` {string} | {Array} 抄送收件人的邮件地址。如果有多个抄送收件人，则用字符串数组表示
-* `bcc` {string} | {Array} 密送收件人的邮件地址。如果有多个密送收件人，则用字符串数组表示
+* `options` {Object} 发送邮件的参数. 包括:
+* `email` {string} | {Array} 收件人的邮件地址. 如果有多个收件人, 则用字符串数组表示
+* `cc` {string} | {Array} 抄送收件人的邮件地址. 如果有多个抄送收件人, 则用字符串数组表示
+* `bcc` {string} | {Array} 密送收件人的邮件地址. 如果有多个密送收件人, 则用字符串数组表示
 * `subject` {string} 邮件主题(标题)
 * `text` {string} 邮件正文
-* `attachment` {string} 附件的路径。
+* `attachment` {string} 附件的路径.
 
-根据选项options调用邮箱应用发送邮件。这些选项均是可选的。
+根据选项options调用邮箱应用发送邮件. 这些选项均是可选的.
 
-如果没有安装邮箱应用，则抛出`ActivityNotException`。
+如果没有安装邮箱应用, 则抛出`ActivityNotException`.
 
 ```
-//发送邮件给10086@qq.com和10001@qq.com。
+//发送邮件给10086@qq.com和10001@qq.com.
 app.sendEmail({
     email: ["10086@qq.com", "10001@qq.com"],
     subject: "这是一个邮件标题",
@@ -173,69 +180,42 @@ app.sendEmail({
 
 ## app.startActivity(name)
 
-* `name` {string} 活动名称，可选的值为:
+* `name` {string} 活动名称, 可选的值为:
     * `console` 日志界面
     * `settings` 设置界面
 
-启动Auto.js的特定界面。该函数在Auto.js内运行则会打开Auto.js内的界面，在打包应用中运行则会打开打包应用的相应界面。
+启动Auto.js的特定界面. 该函数在Auto.js内运行则会打开Auto.js内的界面, 在打包应用中运行则会打开打包应用的相应界面.
 
 ```
 app.startActivity("console");
 ```
 
-# 进阶: 意图Intent
-
-Intent(意图) 是一个消息传递对象，您可以使用它从其他应用组件请求操作。尽管 Intent 可以通过多种方式促进组件之间的通信，但其基本用例主要包括以下三个：
-
-* 启动活动(Activity)：
-  Activity 表示应用中的一个"屏幕"。例如应用主入口都是一个Activity，应用的功能通常也以Activity的形式独立，例如微信的主界面、朋友圈、聊天窗口都是不同的Activity。通过将 Intent 传递给 startActivity()，您可以启动新的 Activity 实例。Intent 描述了要启动的 Activity，并携带了任何必要的数据。
-
-* 启动服务(Service)：
-  Service 是一个不使用用户界面而在后台执行操作的组件。通过将 Intent 传递给 startService()，您可以启动服务执行一次性操作（例如，下载文件）。Intent 描述了要启动的服务，并携带了任何必要的数据。
-
-* 传递广播：
-  广播是任何应用均可接收的消息。系统将针对系统事件（例如：系统启动或设备开始充电时）传递各种广播。通过将 Intent 传递给 sendBroadcast()、sendOrderedBroadcast() 或 sendStickyBroadcast()，您可以将广播传递给其他应用。
-
-本模块提供了构建Intent的函数(`app.intent()`), 启动Activity的函数`app.startActivity()`, 发送广播的函数`app.sendBroadcast()`。
-
-使用这些方法可以用来方便的调用其他应用。例如直接打开某个QQ号的个人卡片页，打开某个QQ号的聊天窗口等。
-
-```
-var qq = "2732014414";
-app.startActivity({ 
-    action: "android.intent.action.VIEW", 
-    data:"mqq://im/chat?chat_type=wpa&version=1&src_type=web&uin=" + qq, 
-    packageName: "com.tencent.mobileqq", 
-});
-
-```
-
 ## app.intent(options)
 
-* `options` {Object} 选项，包括：
-    * `action` {string} 意图的Action，指意图要完成的动作，是一个字符串常量，比如"android.intent.action.SEND"。当action以"android.intent.action"开头时，可以省略前缀，直接用"SEND"代替。参见[Actions](https://developer.android.com/reference/android/content/Intent.html#standard-activity-actions)。
+* `options` {Object} 选项, 包括：
+    * `action` {string} 意图的Action, 指意图要完成的动作, 是一个字符串常量, 比如"android.intent.action.SEND". 当action以"android.intent.action"开头时, 可以省略前缀, 直接用"SEND"代替. 参见[Actions](https://developer.android.com/reference/android/content/Intent.html#standard-activity-actions/).
 
-    * `type` {string} 意图的MimeType，表示和该意图直接相关的数据的类型，表示比如"text/plain"为纯文本类型。
+    * `type` {string} 意图的MimeType, 表示和该意图直接相关的数据的类型, 表示比如"text/plain"为纯文本类型.
 
-    * `data` {string} 意图的Data，表示和该意图直接相关的数据，是一个Uri, 可以是文件路径或者Url等。例如要打开一个文件, action为"android.intent.action.VIEW", data为"file:///sdcard/1.txt"。
+    * `data` {string} 意图的Data, 表示和该意图直接相关的数据, 是一个Uri, 可以是文件路径或者Url等. 例如要打开一个文件, action为"android.intent.action.VIEW", data为"file:///sdcard/1.txt".
 
-    * `category` {Array} 意图的类别。比较少用。参见[Categories](https://developer.android.com/reference/android/content/Intent.html#standard-categories)。
+    * `category` {Array} 意图的类别. 比较少用. 参见[Categories](https://developer.android.com/reference/android/content/Intent.html#standard-categories/).
 
     * `packageName` {string} 目标包名
 
     * `className` {string} 目标Activity或Service等组件的名称
 
-    * `extras` {Object} 以键值对构成的这个Intent的Extras(额外信息)。提供该意图的其他信息，例如发送邮件时的邮件标题、邮件正文。参见[Extras](https://developer.android.com/reference/android/content/Intent.html#standard-extra-data)。
+    * `extras` {Object} 以键值对构成的这个Intent的Extras(额外信息). 提供该意图的其他信息, 例如发送邮件时的邮件标题、邮件正文. 参见[Extras](https://developer.android.com/reference/android/content/Intent.html#standard-extra-data/).
 
-    * `flags` {Array} intent的标识，字符串数组，例如`["activity_new_task", "grant_read_uri_permission"]`。参见[Flags](https://developer.android.com/reference/android/content/Intent.html#setFlags%28int%29)。
+    * `flags` {Array} intent的标识, 字符串数组, 例如`["activity_new_task", "grant_read_uri_permission"]`. 参见[Flags](https://developer.android.com/reference/android/content/Intent.html#setFlags%28int%29/).
 
       **[v4.1.0新增]**
 
-    * `root` {Boolea} 是否以root权限启动、发送该intent。使用该参数后，不能使用`context.startActivity()`等方法，而应该直接使用诸如`app.startActivity({...})`的方法。
+    * `root` {Boolea} 是否以root权限启动、发送该intent. 使用该参数后, 不能使用`context.startActivity()`等方法, 而应该直接使用诸如`app.startActivity({...})`的方法.
 
       **[v4.1.0新增]**
 
-根据选项，构造一个意图Intent对象。
+根据选项, 构造一个意图Intent对象.
 
 例如：
 
@@ -249,9 +229,9 @@ var i = app.intent({
 context.startActivity(i);
 ```
 
-需要注意的是，除非应用专门暴露Activity出来，否则在没有root权限的情况下使用intent是无法跳转到特定Activity、应用的特定界面的。例如我们能通过Intent跳转到QQ的分享界面，是因为QQ对外暴露了分享的Activity；而在没有root权限的情况下，我们无法通过intent跳转到QQ的设置界面，因为QQ并没有暴露这个Activity。
+需要注意的是, 除非应用专门暴露Activity出来, 否则在没有root权限的情况下使用intent是无法跳转到特定Activity、应用的特定界面的. 例如我们能通过Intent跳转到QQ的分享界面, 是因为QQ对外暴露了分享的Activity；而在没有root权限的情况下, 我们无法通过intent跳转到QQ的设置界面, 因为QQ并没有暴露这个Activity.
 
-但如果有root权限，则在intent的参数加上`"root": true`即可。例如使用root权限跳转到Auto.js的设置界面为：
+但如果有root权限, 则在intent的参数加上`"root": true`即可. 例如使用root权限跳转到Auto.js的设置界面为：
 
 ```
 app.startActivity({
@@ -261,15 +241,15 @@ app.startActivity({
 });
 ```
 
-另外，关于intent的参数如何获取的问题，一些intent是意外发现并且在网络中传播的（例如跳转QQ聊天窗口是因为QQ给网页提供了跳转到客服QQ的方法），如果要自己获取活动的intent的参数，可以通过例如"intent记录"，"隐式启动"等应用拦截内部intent或者查询暴露的intent。其中拦截内部intent需要XPosed框架，或者可以通过反编译等手段获取参数。总之，没有简单直接的方法。
+另外, 关于intent的参数如何获取的问题, 一些intent是意外发现并且在网络中传播的（例如跳转QQ聊天窗口是因为QQ给网页提供了跳转到客服QQ的方法）, 如果要自己获取活动的intent的参数, 可以通过例如"intent记录", "隐式启动"等应用拦截内部intent或者查询暴露的intent. 其中拦截内部intent需要XPosed框架, 或者可以通过反编译等手段获取参数. 总之, 没有简单直接的方法.
 
-更多信息，请百度[安卓Intent](https://www.baidu.com/s?wd=android%20Intent)或参考[Android指南: Intent](https://developer.android.com/guide/components/intents-filters.html#Types)。
+更多信息, 请百度[安卓Intent](https://www.baidu.com/s?wd=android%20Intent)或参考[Android指南: Intent](https://developer.android.com/guide/components/intents-filters.html#Types).
 
 ## app.startActivity(options)
 
 * `options` {Object} 选项
 
-根据选项构造一个Intent，并启动该Activity。
+根据选项构造一个Intent, 并启动该Activity.
 
 ```
 app.startActivity({
@@ -283,23 +263,23 @@ app.startActivity({
 
 * `options` {Object} 选项
 
-根据选项构造一个Intent，并发送该广播。
+根据选项构造一个Intent, 并发送该广播.
 
 ## app.startService(options)
 
 * `options` {Object} 选项
 
-根据选项构造一个Intent，并启动该服务。
+根据选项构造一个Intent, 并启动该服务.
 
 ## app.sendBroadcast(name)
 
 **[v4.1.0新增]**
 
-* `name` {string} 特定的广播名称，包括：
+* `name` {string} 特定的广播名称, 包括：
     * `inspect_layout_hierarchy` 布局层次分析
     * `inspect_layout_bounds` 布局范围
 
-发送以上特定名称的广播可以触发Auto.js的布局分析，方便脚本调试。这些广播在Auto.js发送才有效，在打包的脚本上运行将没有任何效果。
+发送以上特定名称的广播可以触发Auto.js的布局分析, 方便脚本调试. 这些广播在Auto.js发送才有效, 在打包的脚本上运行将没有任何效果.
 
 ```
 app.sendBroadcast("inspect_layout_bounds");
@@ -311,7 +291,7 @@ app.sendBroadcast("inspect_layout_bounds");
 
 * `options` {Object} 选项
 
-根据选项构造一个Intent，转换为对应的shell的intent命令的参数。
+根据选项构造一个Intent, 转换为对应的shell的intent命令的参数.
 
 例如:
 
@@ -322,33 +302,33 @@ shell("am start " + app.intentToShell({
 }), true);
 ```
 
-参见[intent参数的规范](https://developer.android.com/studio/command-line/adb#IntentSpec)。
+参见[intent参数的规范](https://developer.android.com/studio/command-line/adb#IntentSpec/).
 
 ## app.parseUri(uri)
 
 **[v4.1.0新增]**
 
-* `uri` {string} 一个代表Uri的字符串，例如"file:///sdcard/1.txt", "https://www.autojs.org"
-* 返回 {Uri} 一个代表Uri的对象，参见[android.net.Uri](https://developer.android.com/reference/android/net/Uri)。
+* `uri` {string} 一个代表Uri的字符串, 例如"file:///sdcard/1.txt", "https://www.autojs.org"
+* 返回 {Uri} 一个代表Uri的对象, 参见[android.net.Uri](https://developer.android.com/reference/android/net/Uri/).
 
-解析uri字符串并返回相应的Uri对象。即使Uri格式错误，该函数也会返回一个Uri对象，但之后如果访问该对象的scheme, path等值可能因解析失败而返回`null`。
+解析uri字符串并返回相应的Uri对象. 即使Uri格式错误, 该函数也会返回一个Uri对象, 但之后如果访问该对象的scheme, path等值可能因解析失败而返回`null`.
 
-需要注意的是，在高版本Android上，由于系统限制直接在Uri暴露文件的绝对路径，因此如果uri字符串是文件`file://...`，返回的Uri会是诸如`content://...`的形式。
+需要注意的是, 在高版本Android上, 由于系统限制直接在Uri暴露文件的绝对路径, 因此如果uri字符串是文件`file://...`, 返回的Uri会是诸如`content://...`的形式.
 
 ## app.getUriForFile(path)
 
 **[v4.1.0新增]**
 
-* `path` {string} 文件路径，例如"/sdcard/1.txt"
-* 返回 {Uri} 一个指向该文件的Uri的对象，参见[android.net.Uri](https://developer.android.com/reference/android/net/Uri)。
+* `path` {string} 文件路径, 例如"/sdcard/1.txt"
+* 返回 {Uri} 一个指向该文件的Uri的对象, 参见[android.net.Uri](https://developer.android.com/reference/android/net/Uri/).
 
-从一个文件路径创建一个uri对象。需要注意的是，在高版本Android上，由于系统限制直接在Uri暴露文件的绝对路径，因此返回的Uri会是诸如`content://...`的形式。
+从一个文件路径创建一个uri对象. 需要注意的是, 在高版本Android上, 由于系统限制直接在Uri暴露文件的绝对路径, 因此返回的Uri会是诸如`content://...`的形式.
 
 ## app.getInstalledApps([options])
 
-** [[Pro 8.0.0新增](https://pro.autojs.org/)] **
+** [[Pro 8.0.0新增](https://pro.autojs.org//)] **
 
-* `options` {Object} 选项，包括：
+* `options` {Object} 选项, 包括：
     * `get`: 指定返回的应用信息中包含的信息
         * `"activities"` 应用的Activity组件信息
         * `"configurations"` 应用的硬件配置
@@ -376,12 +356,12 @@ shell("am start " + app.intentToShell({
         * `"apex"` APEX应用
 * 返回 {Array\<ApplicationInfo\>}
 
-返回为当前用户安装的所有应用程序包的列表。如果设置了match选项 `uninstalled_packages`，则包括被删除但保留了数据的应用程序。
-获取安装的应用列表。
+返回为当前用户安装的所有应用程序包的列表. 如果设置了match选项 `uninstalled_packages`, 则包括被删除但保留了数据的应用程序.
+获取安装的应用列表.
 
-返回值是ApplicationInfo对象的数组。 如果没有安装任何应用，则返回一个空数组。
+返回值是ApplicationInfo对象的数组.  如果没有安装任何应用, 则返回一个空数组.
 
-选项options的match选项用于指定要返回哪些应用程序，get选项用于指定返回的应用程序携带哪些信息。
+选项options的match选项用于指定要返回哪些应用程序, get选项用于指定返回的应用程序携带哪些信息.
 
 ```
 let apps = $app.getInstalledApps({
diff --git a/api/appType.md b/api/appType.md
new file mode 100644
index 0000000..d447ca8
--- /dev/null
+++ b/api/appType.md
@@ -0,0 +1,259 @@
+# 应用枚举类 (App)
+
+为便于与其他应用交互, AutoJs6 内置了部分常见应用的信息, 如下表:
+
+| 枚举实例名            | 中文名            | 英文名               | 包名                                 | 别名               |
+|:-----------------|:---------------|:------------------|:-----------------------------------|:-----------------|
+| ACCUWEATHER      | AccuWeather    | ~                 | com.accuweather.android            | accuweather      |
+| ADM              | ADM            | ~                 | com.dv.adm                         | adm              |
+| ALIPAY           | 支付宝            | Alipay            | com.eg.android.AlipayGphone        | alipay           |
+| AMAP             | 高德地图           | Amap              | com.autonavi.minimap               | amap             |
+| APPOPS           | App Ops        | ~                 | rikka.appops                       | appops           |
+| AQUAMAIL         | Aqua Mail      | ~                 | org.kman.AquaMail                  | aquamail         |
+| AUTOJS           | Auto.js        | ~                 | org.autojs.autojs                  | autojs           |
+| AUTOJS6          | AutoJs6        | ~                 | org.autojs.autojs6                 | autojs6          |
+| AUTOJSPRO        | AutoJsPro      | ~                 | org.autojs.autojspro               | autojspro        |
+| BAIDUMAP         | 百度地图           | BaiduMap          | com.baidu.BaiduMap                 | baidumap         |
+| BILIBILI         | 哔哩哔哩           | bilibili          | tv.danmaku.bili                    | bilibili         |
+| BREVENT          | 黑阈             | Brevent           | mie.piebridge.brevent              | brevent          |
+| CALENDAR         | 日历             | Calendar          | com.google.android.calendar        | calendar         |
+| CHROME           | Chrome         | ~                 | com.android.chrome                 | chrome           |
+| COOLAPK          | 酷安             | CoolApk           | com.coolapk.market                 | coolapk          |
+| DIANPING         | 大众点评           | Dianping          | com.dianping.v1                    | dianping         |
+| DIGICAL          | DigiCal        | ~                 | com.digibites.calendar             | digical          |
+| DRIVE            | 云端硬盘           | Drive             | com.google.android.apps.docs       | drive            |
+| ES               | ES文件浏览器        | ES File Explorer  | com.estrongs.android.pop           | es               |
+| EUDIC            | 欧路词典           | Eudic             | com.qianyan.eudic                  | eudic            |
+| EXCEL            | Excel          | ~                 | com.microsoft.office.excel         | excel            |
+| FIREFOX          | Firefox        | ~                 | org.mozilla.firefox                | firefox          |
+| FX               | FX             | ~                 | nextapp.fx                         | fx               |
+| GEOMETRICWEATHER | 几何天气           | Geometric Weather | wangdaye.com.geometricweather      | geometricweather |
+| HTTPCANARY       | HttpCanary     | ~                 | com.guoshi.httpcanary.premium      | httpcanary       |
+| IDLEFISH         | 闲鱼             | ~                 | com.taobao.idlefish                | idlefish         |
+| IDMPLUS          | IDM+           | ~                 | idm.internet.download.manager.plus | idm+             |
+| JD               | 京东             | ~                 | com.jingdong.app.mall              | jd               |
+| KEEP             | Keep           | ~                 | com.gotokeep.keep                  | keep             |
+| KEEPNOTES        | Keep 记事        | Keep Notes        | com.google.android.keep            | keepnotes        |
+| MAGISK           | Magisk         | ~                 | com.topjohnwu.magisk               | magisk           |
+| MEITUAN          | 美团             | Meituan           | com.sankuai.meituan                | meituan          |
+| MT               | MT管理器          | MT Manager        | bin.mt.plus                        | mt               |
+| MXPRO            | MX 播放器专业版      | MX Player Pro     | com.mxtech.videoplayer.pro         | mxpro            |
+| ONEDRIVE         | OneDrive       | ~                 | com.microsoft.skydrive             | onedrive         |
+| PACKETCAPTURE    | Packet Capture | ~                 | app.greyshirts.sslcapture          | packetcapture    |
+| PARALLELSPACE    | 平行空间(原双开大师)    | Parallel Space    | com.lbe.parallel.intl              | parallelspace    |
+| POWERPOINT       | PowerPoint     | ~                 | com.microsoft.office.powerpoint    | powerpoint       |
+| PULSARPLUS       | Pulsar+        | ~                 | com.rhmsoft.pulsar.pro             | pulsarplus       |
+| PUREWEATHER      | Pure天气         | ~                 | hanjie.app.pureweather             | pureweather      |
+| QQ               | QQ             | ~                 | com.tencent.mobileqq               | qq               |
+| QQMUSIC          | QQ音乐           | QQMusic           | com.tencent.qqmusic                | qqmusic          |
+| SDMAID           | SD Maid        | ~                 | eu.thedarken.sdm                   | sdmaid           |
+| SHIZUKU          | Shizuku        | ~                 | moe.shizuku.privileged.api         | shizuku          |
+| STOPAPP          | 小黑屋            | ~                 | web1n.stopapp                      | stopapp          |
+| TAOBAO           | 淘宝             | ~                 | com.taobao.taobao                  | taobao           |
+| TRAINNOTE        | 训记             | ~                 | com.trainnote.rn                   | trainnote        |
+| TWITTER          | Twitter        | ~                 | com.twitter.android                | twitter          |
+| UNIONPAY         | 云闪付            | ~                 | com.unionpay                       | unionpay         |
+| VIA              | Via            | ~                 | mark.via.gp                        | via              |
+| VYSOR            | Vysor          | ~                 | com.koushikdutta.vysor             | vysor            |
+| WECHAT           | 微信             | WeChat            | com.tencent.mm                     | wechat           |
+| WORD             | Word           | ~                 | com.microsoft.office.word          | word             |
+| ZHIHU            | 知乎             | ~                 | com.zhihu.android                  | zhihu            |
+
+通常 "别名" 字段取自 "枚举实例名" 字段的名称小写形式.  
+表列 "英文名" 中波浪符号表示与 "中文名" 对应字段名称相同.
+
+> 注: 上述信息可能发生变更.  
+> 例如一些应用在某个时间点开始去除了 "英文名" 并统一使用 "中文名" 字段, 甚至部分应用会在每个版本均变更其应用名.  
+> 如果用户编写的脚本对应用名十分敏感, 建议使用 App#getAppName 或 app.getAppName 等方式获取设备中已安装应用的真实应用名.
+
+---
+
+<p style="font: bold 2em sans-serif; color: #FF7043">App</p>
+
+---
+
+## [@] App
+
+**`6.2.0`** **`Global`** **`Enum`**
+
+App 为枚举类, 因此可使用 Java 通用的枚举类方法:
+
+```js
+/* 打印所有枚举实例名. */
+console.log(App.values().map(o => o.name()));
+
+/* 获取一个枚举实例. */
+const tt = App.FIREFOX;
+
+/* 调用实例方法. */
+console.log(tt.getAppName());
+console.log(tt.getPackageName());
+console.log(tt.getAlias());
+
+```
+
+## [m#] getAppName
+
+获取枚举实例的应用名.
+
+### getAppName()
+
+- <ins>**returns**</ins> { [string](dataTypes#string) }
+
+优先获取设备中已安装应用的应用名, 若应用未安装, 则获取 App 枚举实例中预置的应用名.
+
+```js
+// "Firefox"
+console.log(App.FIREFOX.getAppName());
+```
+
+## [m#] getAppNameZh
+
+获取枚举实例中预置的中文应用名.
+
+### getAppNameZh()
+
+- <ins>**returns**</ins> { [string](dataTypes#string) }
+
+```js
+// "支付宝"
+console.log(App.ALIPAY.getAppNameZh());
+```
+
+## [m#] getAppNameEn
+
+获取枚举实例中预置的英文应用名.
+
+### getAppNameEn()
+
+- <ins>**returns**</ins> { [string](dataTypes#string) }
+
+```js
+// "Alipay"
+console.log(App.ALIPAY.getAppNameEn());
+```
+
+## [m#] getPackageName
+
+获取枚举实例中预置的应用包名.
+
+### getPackageName()
+
+- <ins>**returns**</ins> { [string](dataTypes#string) }
+
+```js
+// "com.eg.android.AlipayGphone"
+console.log(App.ALIPAY.getPackageName());
+```
+
+## [m#] getAlias
+
+获取枚举实例中预置的应用别名.
+
+### getAlias()
+
+- <ins>**returns**</ins> { [string](dataTypes#string) }
+
+```js
+// "alipay"
+console.log(App.ALIPAY.getAlias());
+```
+
+## [m#] isInstalled
+
+检查枚举实例是否在设备安装.
+
+### isInstalled()
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+```js
+/* e.g. true */
+console.log(App.ALIPAY.isInstalled());
+```
+
+## [m#] ensureInstalled
+
+确保枚举实例在设备安装, 否则抛出异常.
+
+### ensureInstalled()
+
+- <ins>**returns**</ins> { [void](dataTypes#void) }
+
+```js
+App.FIREFOX.ensureInstalled();
+```
+
+## [m#] uninstall
+
+卸载设备中存在的枚举实例应用.
+
+### uninstall()
+
+- <ins>**returns**</ins> { [void](dataTypes#void) }
+
+```js
+App.FIREFOX.uninstall();
+```
+
+## [m#] launch
+
+启动设备中的枚举实例应用.
+
+### launch()
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+若应用未安装或启动过程中出错, 将返回 false (而非抛出异常).
+
+```js
+/* e.g. true */
+console.log(App.FIREFOX.launch());
+```
+
+## [m#] openSettings
+
+跳转至枚举实例应用的应用详情页面.
+
+### openSettings()
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+若应用未安装或跳转页面过程中出错, 将返回 false (而非抛出异常).
+
+```js
+/* e.g. true */
+console.log(App.FIREFOX.openSettings());
+```
+
+## [m#] toString
+
+获取枚举实例自定义的实例信息字符串.
+
+### toString()
+
+- <ins>**returns**</ins> { [string](dataTypes#string) }
+
+```js
+/* e.g. {appName: "Firefox", packageName: "org.mozilla.firefox", alias: "firefox"} */
+console.log(App.FIREFOX.toString());
+console.log(App.FIREFOX); /* 同上. */
+```
+
+## [m] getAppByAlias
+
+通过应用别名获取对应的 App 实例.
+
+### getAppByAlias(alias)
+
+- **alias** { [string](dataTypes#string) } - 应用别名
+- <ins>**returns**</ins> { [App](appType) | [null](dataTypes#null) }
+
+应用别名对应的枚举实例不存在时将返回 null:
+
+```js
+let tt = App.getAppByAlias('twitter');
+if (tt !== null) {
+    console.log(tt.getPackageName());
+}
+```
\ No newline at end of file
diff --git a/api/arrayx.md b/api/arrayx.md
new file mode 100644
index 0000000..5abc97a
--- /dev/null
+++ b/api/arrayx.md
@@ -0,0 +1,407 @@
+# Arrayx (Array 扩展)
+
+Arrayx 用于扩展 JavaScript 标准内置对象 Array 的功能 (参阅 [内置对象扩展](glossaries#内置对象扩展)).
+
+Arrayx 全局可用:
+
+```js
+console.log(typeof Arrayx); // "object"
+console.log(typeof Arrayx.union); // "function"
+```
+
+当启用内置扩展后, Arrayx 将被应用在 Array 及其原型上:
+
+```js
+console.log(typeof Array.prototype.union); // "function"
+console.log(typeof [].union); // "function"
+```
+
+## 启用内置扩展
+
+内置扩展默认被禁用, 以下任一方式可启用内置扩展:
+
+- 在脚本中加入代码片段: `plugins.extendAll();` 或 `plugins.extend('Array');`
+- AutoJs6 应用设置 - 扩展性 - JavaScript 内置对象扩展 - [ 启用 ]
+
+当上述应用设置启用时, 所有脚本均默认启用内置扩展.  
+当上述应用设置禁用时, 只有加入上述代码片段的脚本才会启用内置扩展.  
+内置扩展往往是不安全的, 除非明确了解内置扩展的原理及风险, 否则不建议启用.
+
+## 排序稳定性
+
+Arrayx 的诸多排序方法, 如 [ sortBy / sortDescending / sortByDescending / sorted / sortedBy / sortedDescending / sortedByDescending ] 等, 其内部实现均调用了 JavaScript 的原生方法 [Array.prototype.sort](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/sort).
+
+自 ES10（ECMAScript 2019）起，[规范](https://tc39.es/ecma262/#sec-array.prototype.sort) 要求 Array.prototype.sort 为稳定排序, 因此 Arrayx 的排序方法也是稳定的.
+
+> 参阅: [MDN](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#%E6%8E%92%E5%BA%8F%E7%A8%B3%E5%AE%9A%E6%80%A7)
+
+## 排序方式
+
+Arrayx 排序方法中的 selector (条件选择器) 使用的 compareFn (比较函数) 与默认的稍有不同.  
+默认的比较函数按照转换为字符串的诸个字符的 Unicode 位点进行 **升序** 排序, 例如 80 会被排列到 9 之前.  
+而 Arrayx 排序方法的 selector 则采用简单的直接比较方法:
+
+```js
+/* Arrayx 使用的 compareFn. */
+(a, b) => a === b ? 0 : a > b ? 1 : -1;
+```
+
+因此对于 number 数组的排序会出现不同的结果:
+
+```js
+console.log([ 80, 70, 9 ].sort()); // [ 70, 80, 9 ]
+console.log(Arrayx.sorted([ 80, 70, 9 ])); // [ 9, 70, 80 ]
+```
+
+---
+
+<p style="font: bold 2em sans-serif; color: #FF7043">Arrayx</p>
+
+---
+
+## [m] ensureArray
+
+### ensureArray(...o)
+
+**`6.2.0`** **`xObject`**
+
+- **o** { [...](documentation#可变参数)[any](dataTypes#any)[[]](documentation#可变参数) } - 任意对象
+- <ins>**returns**</ins> { [void](dataTypes#void) }
+
+相当于严格类型检查, 当任意一个 o 不满足 `Array.isArray(o)` 时抛出异常.
+
+```js
+/* 确保每一个对象都是 Array. */
+
+console.log(Arrayx.ensureArray([])); /* 无异常. */
+console.log(Arrayx.ensureArray([], 9)); /* 抛出异常. */
+console.log(Arrayx.ensureArray([ 5 ], [ 2, 3 ])); /* 无异常. */
+
+/* 启用内置对象扩展后. */
+
+console.log(Array.ensureArray([])); /* 无异常. */
+console.log(Array.ensureArray([], 9)); /* 抛出异常. */
+console.log(Array.ensureArray([ 5 ], [ 2, 3 ])); /* 无异常. */
+```
+
+## [m] intersect
+
+### intersect(o, ...others)
+
+**`6.2.0`** **`xProto`**
+
+- **o** { [T](dataTypes#generic)[[]](dataTypes#array) } - 数组
+- **others** { [...](documentation#可变参数)[U](dataTypes#generic)[[]](dataTypes#array)[[]](documentation#可变参数) } - 待处理数组
+- <ins>**returns**</ins> { ([T](dataTypes#generic) & [U](dataTypes#generic))[[]](dataTypes#array) }
+
+返回多个数组的交集.
+
+```js
+let arrA = [ 1, 2, 3 ];
+let arrB = [ 2, 3, 4 ];
+console.log(Arrayx.intersect(arrA, arrB)); // [ 2, 3 ]
+
+/* 启用内置对象扩展后. */
+console.log(arrA.intersect(arrB)); /* 同上. */
+
+let arrC = [ 1, 1, 2 ];
+let arrD = [ 1, 1, 3 ];
+/* 返回的交集结果中不包含重复元素. */
+console.log(Arrayx.intersect(arrC, arrD)); // [ 1 ]
+
+/* 启用内置对象扩展后. */
+console.log(arrC.intersect(arrD)); /* 同上. */
+```
+
+## [m] union
+
+### union(o, ...others)
+
+**`6.2.0`** **`xProto`**
+
+- **o** { [T](dataTypes#generic)[[]](dataTypes#array) } - 数组
+- **others** { [...](documentation#可变参数)[U](dataTypes#generic)[[]](dataTypes#array)[[]](documentation#可变参数) } - 待处理数组
+- <ins>**returns**</ins> { ([T](dataTypes#generic) | [U](dataTypes#generic))[[]](dataTypes#array) }
+
+返回多个数组的并集.
+
+```js
+let arrA = [ 1, 2 ];
+let arrB = [ 3, 4 ];
+console.log(Arrayx.union(arrA, arrB)); // [ 1, 2, 3, 4 ]
+
+/* 启用内置对象扩展后. */
+console.log(arrA.union(arrB)); /* 同上. */
+
+let arrC = [ 7, 8, 9 ];
+let arrD = [ 7, 10 ];
+/* 返回的并集结果中不包含重复元素. */
+console.log(Arrayx.union(arrC, arrD)); // [ 7, 8, 9, 10 ]
+
+/* 启用内置对象扩展后. */
+console.log(arrC.union(arrD)); /* 同上. */
+```
+
+## [m] distinct
+
+### distinct(arr)
+
+**`6.2.0`** **`xProto`**
+
+- **o** { [T](dataTypes#generic)[[]](dataTypes#array) } - 待处理数组
+- <ins>**returns**</ins> { [T](dataTypes#generic)[[]](dataTypes#array) }
+
+返回去除重复元素后的新数组.
+
+```js
+let arr = [ 1, 2, 1, 3, 2, 2 ];
+console.log(Arrayx.distinct(arr)); // [ 1, 2, 3 ]
+
+/* 启用内置对象扩展后. */
+console.log(arr.distinct()); /* 同上. */
+```
+
+## [m] distinctBy
+
+### distinctBy(arr, selector)
+
+**`6.2.0`** **`xProto`**
+
+- **arr** { [T](dataTypes#generic)[[]](dataTypes#array) } - 待处理数组
+- **selector** { [(](dataTypes#function)e: [T](dataTypes#generic)[)](dataTypes#function) [=>](dataTypes#function) [U](dataTypes#generic) } - 条件选择器
+- <ins>**returns**</ins> { [T](dataTypes#generic)[[]](dataTypes#array) }
+
+返回按一定条件去除重复元素后的新数组.
+
+```js
+/* 按奇偶条件去重. */
+/* 即结果数组中的所有元素保证相互之间奇偶互异. */
+let arrA = [ 1, 2, 1, 3, 2, 2 ];
+console.log(Arrayx.distinctBy(arrA, e => e % 2)); // [ 1, 2 ]
+
+/* 启用内置对象扩展后. */
+console.log(arrA.distinctBy(e => e % 2)); // /* 同上. */
+
+/* 按字符串长度条件去重. */
+/* 即结果数组中的所有元素保证相互之间长度不同. */
+let arrB = [ 'a', 'ab', 'c', 'bc', 'abc', '123' ];
+console.log(Arrayx.distinctBy(arrB, e => e.length)); // [ 'a', 'ab', 'abc' ]
+
+/* 启用内置对象扩展后. */
+console.log(arrB.distinctBy(e => e.length)); /* 同上. */
+
+/* 按对象属性条件去重. */
+let arrC = [
+    { num: 1, count: 10 },
+    { num: 2, count: 10 },
+    { num: 3, count: 20 },
+    { num: 4, count: 10 },
+    { num: 5, count: 20 },
+];
+console.log(Arrayx.distinctBy(arrC, e => e.count)); // [ { num: 1, count: 10 }, { num: 3, count: 20 } ]
+
+/* 启用内置对象扩展后. */
+console.log(arrC.distinctBy(e => e.count)); /* 同上. */
+```
+
+## [m] sortBy
+
+### sortBy(arr, selector)
+
+**`6.2.0`** **`xProto`**
+
+- **arr** { [T](dataTypes#generic)[[]](dataTypes#array) } - 待处理数组
+- **selector** { [(](dataTypes#function)e: [T](dataTypes#generic)[)](dataTypes#function) [=>](dataTypes#function) [U](dataTypes#generic) } - 条件选择器
+- <ins>**returns**</ins> { [T](dataTypes#generic)[[]](dataTypes#array) }
+
+按一定条件原地排序, 并返回排序后的新数组.  
+方法调用后, 原数组将发生改变.
+
+```js
+/* 将字符串按 "数字化" 顺序排序. */
+let arrA = [ '10', '2', '30', '4', '50', '0x6' ];
+console.log(Arrayx.sortBy(arrA, Number)); // [ '2', '4', '0x6', '10', '30', '50' ]
+
+/* arrA 将发生改变. */
+console.log(arrA); // [ '2', '4', '0x6', '10', '30', '50' ]
+
+/* 启用内置对象扩展后的使用方式. */
+console.log(arrA.sortBy(Number)); /* 结果同上. */
+
+/* 按字符串长度条件排序. */
+let arrB = [ 'a', 'ab', 'c', 'bc', 'abc', '123' ];
+console.log(Arrayx.sortBy(arrB, e => e.length)); // [ 'a', 'c', 'ab', 'bc', 'abc', '123' ]
+
+/* 启用内置对象扩展后的使用方式. */
+console.log(arrB.sortBy(e => e.length)); /* 结果同上. */
+
+/* 按对象属性条件排序. */
+let arrC = [
+    { num: 1, count: 10 },
+    { num: 2, count: 30 },
+    { num: 3, count: 20 },
+    { num: 4, count: 10 },
+    { num: 5, count: 0 },
+];
+console.log(Arrayx.sortBy(arrC, e => e.count)); /* num 按照 5 - 1 - 4 - 3 - 2 排序. */
+
+/* 启用内置对象扩展后的使用方式. */
+console.log(arrC.sortBy(e => e.count)); /* 结果同上. */
+```
+
+## [m] sortDescending
+
+### sortDescending(arr)
+
+**`6.2.0`** **`xProto`**
+
+- **arr** { [T](dataTypes#generic)[[]](dataTypes#array) } - 待处理数组
+- <ins>**returns**</ins> { [T](dataTypes#generic)[[]](dataTypes#array) }
+
+按一定条件原地 **降序** 排序, 并返回排序后的新数组.  
+方法调用后, 原数组将发生改变.
+
+```js
+/* 将字符串按 "数字化" 顺序排序. */
+let arrA = [ '10', '2', '30', '4', '50', '0x6' ];
+
+// [ '2', '4', '0x6', '10', '30', '50' ]
+console.log(Arrayx.sortDescending(arrA, Number));
+
+/* arrA 将发生改变. */
+console.log(arrA[0]); // '2'
+
+/* 启用内置对象扩展后的使用方式. */
+console.log(arrA.sortDescending(Number)); /* 结果同上. */
+
+/* 按字符串长度条件排序. */
+let arrB = [ 'a', 'ab', 'c', 'bc', 'abc', '123' ];
+
+// [ 'a', 'c', 'ab', 'bc', 'abc', '123' ]
+console.log(Arrayx.sortDescending(arrB, e => e.length));
+
+/* 启用内置对象扩展后的使用方式. */
+console.log(arrB.sortDescending(e => e.length)); /* 结果同上. */
+
+/* 按对象属性条件排序. */
+let arrC = [
+    { num: 1, count: 10 },
+    { num: 2, count: 30 },
+    { num: 3, count: 20 },
+    { num: 4, count: 10 },
+    { num: 5, count: 0 },
+];
+
+/* 元素将按照 num 属性值以 5 - 1 - 4 - 3 - 2 排序. */
+console.log(Arrayx.sortDescending(arrC, e => e.count));
+
+/* 启用内置对象扩展后的使用方式. */
+console.log(arrC.sortDescending(e => e.count)); /* 结果同上. */
+```
+
+## [m] sortByDescending
+
+### sortByDescending(arr, selector)
+
+**`6.2.0`** **`xProto`**
+
+- **arr** { [T](dataTypes#generic)[[]](dataTypes#array) } - 待处理数组
+- **selector** { [(](dataTypes#function)e: [T](dataTypes#generic)[)](dataTypes#function) [=>](dataTypes#function) [U](dataTypes#generic) } - 条件选择器
+- <ins>**returns**</ins> { [T](dataTypes#generic)[[]](dataTypes#array) }
+
+按一定条件原地 **降序** 排序, 并返回排序后的新数组.  
+方法调用后, 原数组将发生改变.
+
+> 参阅: [sortBy](#m-sortby)
+
+## [m] sorted
+
+### sorted(arr)
+
+**`6.2.0`** **`xProto`**
+
+- **arr** { [T](dataTypes#generic)[[]](dataTypes#array) } - 待处理数组
+- <ins>**returns**</ins> { [T](dataTypes#generic)[[]](dataTypes#array) }
+
+按简单比较方式原地排序, 并返回排序后的新数组.  
+方法调用后, 原数组将 **不** 发生改变.
+
+```js
+let arr = [ 2, 3, 1, 20, 10 ];
+
+console.log(Arrayx.sorted(arr)); // [ 1, 2, 3, 10, 20 ] 
+
+/* 启用内置对象扩展后. */
+console.log(arr.sorted()); /* 同上. */
+
+/* arr 不发生改变. */
+console.log(arr); // [ 2, 3, 1, 20, 10 ]
+```
+
+## [m] sortedBy
+
+### sortedBy(arr, selector)
+
+**`6.2.0`** **`xProto`**
+
+- **arr** { [T](dataTypes#generic)[[]](dataTypes#array) } - 待处理数组
+- **selector** { [(](dataTypes#function)e: [T](dataTypes#generic)[)](dataTypes#function) [=>](dataTypes#function) [U](dataTypes#generic) } - 条件选择器
+- <ins>**returns**</ins> { [T](dataTypes#generic)[[]](dataTypes#array) }
+
+按一定条件原地排序, 并返回排序后的新数组.  
+方法调用后, 原数组将 **不** 发生改变.
+
+> 参阅: [sortBy](#m-sortby)
+
+## [m] sortedDescending
+
+### sortedDescending(arr)
+
+**`6.2.0`** **`xProto`**
+
+- **arr** { [T](dataTypes#generic)[[]](dataTypes#array) } - 待处理数组
+- <ins>**returns**</ins> { [T](dataTypes#generic)[[]](dataTypes#array) }
+
+按一定条件原地 **降序** 排序, 并返回排序后的新数组.  
+方法调用后, 原数组将 **不** 发生改变.
+
+> 参阅: [sortDescending](#m-sortdescending)
+
+## [m] sortedByDescending
+
+### sortedByDescending(arr, selector)
+
+**`6.2.0`** **`xProto`**
+
+- **arr** { [T](dataTypes#generic)[[]](dataTypes#array) } - 待处理数组
+- **selector** { [(](dataTypes#function)e: [T](dataTypes#generic)[)](dataTypes#function) [=>](dataTypes#function) [U](dataTypes#generic) } - 条件选择器
+- <ins>**returns**</ins> { [T](dataTypes#generic)[[]](dataTypes#array) }
+
+按一定条件原地 **降序** 排序, 并返回排序后的新数组.  
+方法调用后, 原数组将 **不** 发生改变.
+
+> 参阅: [sortByDescending](#m-sortbydescending)
+
+## [m] shuffle
+
+### shuffle(arr)
+
+**`6.2.0`** **`xProto`**
+
+- **arr** { [T](dataTypes#generic)[[]](dataTypes#array) } - 待处理数组
+- <ins>**returns**</ins> { [T](dataTypes#generic)[[]](dataTypes#array) }
+
+按随机乱序方式原地排序, 并返回排序后的新数组.  
+方法调用后, 原数组将发生改变.
+
+```js
+/* 将元素随机乱序排序. */
+let arrA = [ 1, 2, 3, 4, 5, 6 ];
+console.log(Arrayx.shuffle(arrA)); /* e.g. [ 2, 4, 5, 1, 6, 3 ] */
+
+/* arrA 将发生改变. */
+console.log(arrA); /* 很可能不再是 [ 1, 2, 3, 4, 5, 6 ]. */
+
+/* 启用内置对象扩展后的使用方式. */
+console.log(arrA.shuffle()); /* 另一个随机的结果. */
+```
\ No newline at end of file
diff --git a/api/autojs.md b/api/autojs.md
new file mode 100644
index 0000000..4cf88e8
--- /dev/null
+++ b/api/autojs.md
@@ -0,0 +1,8 @@
+# AutoJs6 本体应用
+
+---
+
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
+
+---
\ No newline at end of file
diff --git a/api/automator.md b/api/automator.md
new file mode 100644
index 0000000..f949b29
--- /dev/null
+++ b/api/automator.md
@@ -0,0 +1,534 @@
+# 自动化 (Automator)
+
+---
+
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
+
+---
+
+## 简易自动化 (SimpleActionAutomator)
+
+待补充...
+
+## 高权限自动化 (RootAutomator)
+
+待补充...
+
+## 自动化配置 (AutomatorConfiguration)
+
+待补充...
+
+## 选择器 (UiSelector)
+
+UiSelector (选择器), 亦可看作是 [控件节点](uiObjectType) 的条件筛选器, 用于通过附加不同的条件, 筛选出一个或一组活动窗口中的 `控件节点`, 并做进一步处理, 如 [ 执行 [控件行为](uiObjectActionsType) (点击, 长按, 设置文本等) / 判断位置 / 获取文本内容 / 获取控件特定状态 / 在 [控件层级](glossaries#控件层级) 中进行 [罗盘](uiObjectType.md#m-compass) 导航 ] 等.
+
+详情参阅 [选择器 (UiSelector)](uiSelectorType) 章节.
+
+## 控件节点 (UiObject)
+
+UiObject 通常被称为 [ 控件 / 节点 / 控件节点 ], 可看做是一个通过安卓无障碍服务包装的 [AccessibilityNodeInfo](https://developer.android.com/reference/android/view/accessibility/AccessibilityNodeInfo) 对象, 代表一个当前活动窗口中的节点, 通过此节点可收集控件信息或执行控件行为, 进而实现一系列自动化操作.
+
+详情参阅 [控件节点 (UiObject)](uiObjectType) 章节.
+
+## 控件集合 (UiObjectCollection)
+
+UiObjectCollection 代表 [控件节点 (UiObject)](uiObjectType) 的对象集合.
+
+详情参阅 [控件集合 (UiObjectCollection)](uiObjectCollectionType) 章节.
+
+## 控件节点行为 (UiObjectActions)
+
+UiObjectActions 是一个 Java 接口, 代表 [控件节点 (UiObject)](uiObjectType) 的行为集合.
+
+详情参阅 [控件节点行为 (UiObjectActions)](uiObjectActionsType) 章节.
+
+---
+
+# 基于坐标的触摸模拟
+
+本章节介绍了一些使用坐标进行点击、滑动的函数. 这些函数有的需要安卓7.0以上, 有的需要root权限.
+
+要获取要点击的位置的坐标, 可以在开发者选项中开启"指针位置".
+
+基于坐标的脚本通常会有分辨率的问题, 这时可以通过`setScreenMetrics()`函数来进行自动坐标放缩. 这个函数会影响本章节的所有点击、长按、滑动等函数. 通过设定脚本设计时的分辨率, 使得脚本在其他分辨率下自动放缩坐标.
+
+控件和坐标也可以相互结合. 一些控件是无法点击的(clickable为false), 无法通过`.click()`函数来点击, 这时如果安卓版本在7.0以上或者有root权限, 就可以通过以下方式来点击：
+
+```
+//获取这个控件
+var widget = id("xxx").findOne();
+//获取其中心位置并点击
+click(widget.bounds().centerX(), widget.bounds().centerY());
+//如果用root权限则用Tap
+```
+
+## setScreenMetrics(width, height)
+
+* width {number} 屏幕宽度, 单位像素
+* height {number} 屏幕高度, 单位像素
+
+设置脚本坐标点击所适合的屏幕宽高. 如果脚本运行时, 屏幕宽度不一致会自动放缩坐标.
+
+例如在1920*1080的设备中, 某个操作的代码为
+
+```
+setScreenMetrics(1080, 1920);
+click(800, 200);
+longClick(300, 500);
+```
+
+那么在其他设备上AutoJs会自动放缩坐标以便脚本仍然有效. 例如在540 * 960的屏幕中`click(800, 200)`实际上会点击位置(400, 100).
+
+# 安卓7.0以上的触摸和手势模拟
+
+**注意以下命令只有Android7.0及以上才有效**
+
+## click(x, y)
+
+* `x` {number} 要点击的坐标的x值
+* `y` {number} 要点击的坐标的y值
+
+模拟点击坐标(x, y), 并返回是否点击成功. 只有在点击执行完成后脚本才继续执行.
+
+一般而言, 只有点击过程(大约150毫秒)中被其他事件中断(例如用户自行点击)才会点击失败.
+
+使用该函数模拟连续点击时可能有点击速度过慢的问题, 这时可以用`press()`函数代替.
+
+## longClick(x, y)
+
+* `x` {number} 要长按的坐标的x值
+* `y` {number} 要长按的坐标的y值
+
+模拟长按坐标(x, y), 并返回是否成功. 只有在长按执行完成（大约600毫秒）时脚本才会继续执行.
+
+一般而言, 只有长按过程中被其他事件中断(例如用户自行点击)才会长按失败.
+
+## press(x, y, duration)
+
+* `x` {number} 要按住的坐标的x值
+* `y` {number} 要按住的坐标的y值
+* `duration` {number} 按住时长, 单位毫秒
+
+模拟按住坐标(x, y), 并返回是否成功. 只有按住操作执行完成时脚本才会继续执行.
+
+如果按住时间过短, 那么会被系统认为是点击；如果时长超过500毫秒, 则认为是长按.
+
+一般而言, 只有按住过程中被其他事件中断才会操作失败.
+
+一个连点器的例子如下：
+
+```
+//循环100次
+for(var i = 0; i < 100; i++){
+  //点击位置(500, 1000), 每次用时1毫秒
+  press(500, 1000, 1);
+}
+```
+
+## swipe(x1, y1, x2, y2, duration)
+
+* `x1` {number} 滑动的起始坐标的x值
+* `y1` {number} 滑动的起始坐标的y值
+* `x2` {number} 滑动的结束坐标的x值
+* `y2` {number} 滑动的结束坐标的y值
+* `duration` {number} 滑动时长, 单位毫秒
+
+模拟从坐标(x1, y1)滑动到坐标(x2, y2), 并返回是否成功. 只有滑动操作执行完成时脚本才会继续执行.
+
+一般而言, 只有滑动过程中被其他事件中断才会滑动失败.
+
+## gesture(duration, [x1, y1], [x2, y2], ...)
+
+* `duration` {number} 手势的时长
+* [x, y] ... 手势滑动路径的一系列坐标
+
+模拟手势操作. 例如`gesture(1000, [0, 0], [500, 500], [500, 1000])`为模拟一个从(0, 0)到(500, 500)到(500, 100)的手势操作, 时长为2秒.
+
+## gestures([delay1, duration1, [x1, y1], [x2, y2], ...], [delay2, duration2, [x3, y3], [x4, y4], ...], ...)
+
+同时模拟多个手势. 每个手势的参数为\[delay, duration, 坐标\], delay为延迟多久(毫秒)才执行该手势；duration为手势执行时长；坐标为手势经过的点的坐标. 其中delay参数可以省略, 默认为0.
+
+例如手指捏合：
+
+```
+gestures([0, 500, [800, 300], [500, 1000]],
+         [0, 500, [300, 1500], [500, 1000]]);
+```
+
+# RootAutomator
+
+RootAutomator是一个使用root权限来模拟触摸的对象, 用它可以完成触摸与多点触摸, 并且这些动作的执行没有延迟.
+
+一个脚本中最好只存在一个RootAutomator, 并且保证脚本结束退出他. 可以在exit事件中退出RootAutomator, 例如：
+
+```
+var ra = new RootAutomator();
+events.on('exit', function(){
+  ra.exit();
+});
+//执行一些点击操作
+...
+
+```
+
+**注意以下命令需要root权限**
+
+## RootAutomator.tap(x, y[, id])
+
+* `x` {number} 横坐标
+* `y` {number} 纵坐标
+* `id` {number} 多点触摸id, 可选, 默认为1, 可以通过setDefaultId指定.
+
+点击位置(x, y). 其中id是一个整数值, 用于区分多点触摸, 不同的id表示不同的"手指", 例如：
+
+```
+var ra = new RootAutomator();
+//让"手指1"点击位置(100, 100)
+ra.tap(100, 100, 1);
+//让"手指2"点击位置(200, 200);
+ra.tap(200, 200, 2);
+ra.exit();
+```
+
+如果不需要多点触摸, 则不需要id这个参数.
+多点触摸通常用于手势或游戏操作, 例如模拟双指捏合、双指上滑等.
+
+某些情况下可能存在tap点击无反应的情况, 这时可以用`RootAutomator.press()`函数代替.
+
+## RootAutomator.swipe(x1, x2, y1, y2[, duration, id])
+
+* `x1` {number} 滑动起点横坐标
+* `y1` {number} 滑动起点纵坐标
+* `x2` {number} 滑动终点横坐标
+* `y2` {number} 滑动终点纵坐标
+* `duration` {number} 滑动时长, 单位毫秒, 默认值为300
+* `id` {number} 多点触摸id, 可选, 默认为1
+
+模拟一次从(x1, y1)到(x2, y2)的时间为duration毫秒的滑动.
+
+## RootAutomator.press(x, y, duration[, id])
+
+* `x` {number} 横坐标
+* `y` {number} 纵坐标
+* `duration` {number} 按下时长
+* `id` {number} 多点触摸id, 可选, 默认为1
+
+模拟按下位置(x, y), 时长为duration毫秒.
+
+## RootAutomator.longPress(x, y[\, id\])
+
+* `x` {number} 横坐标
+* `y` {number} 纵坐标
+* `duration` {number} 按下时长
+* `id` {number} 多点触摸id, 可选, 默认为1
+
+模拟长按位置(x, y).
+
+以上为简单模拟触摸操作的函数. 如果要模拟一些复杂的手势, 需要更底层的函数.
+
+## RootAutomator.touchDown(x, y[, id])
+
+* `x` {number} 横坐标
+* `y` {number} 纵坐标
+* `id` {number} 多点触摸id, 可选, 默认为1
+
+模拟手指按下位置(x, y).
+
+## RootAutomator.touchMove(x, y[, id])
+
+* `x` {number} 横坐标
+* `y` {number} 纵坐标
+* `id` {number} 多点触摸id, 可选, 默认为1
+
+模拟移动手指到位置(x, y).
+
+## RootAutomator.touchUp([id])
+
+* `id` {number} 多点触摸id, 可选, 默认为1
+
+模拟手指弹起.
+
+# 使用root权限点击和滑动的简单命令
+
+注意：本章节的函数在后续版本很可能有改动！请勿过分依赖本章节函数的副作用. 推荐使用`RootAutomator`代替本章节的触摸函数.
+
+以下函数均需要root权限, 可以实现任意位置的点击、滑动等.
+
+* 这些函数通常首字母大写以表示其特殊的权限.
+* 这些函数均不返回任何值.
+* 并且, 这些函数的执行是异步的、非阻塞的, 在不同机型上所用的时间不同. 脚本不会等待动作执行完成才继续执行. 因此最好在每个函数之后加上适当的sleep来达到期望的效果.
+
+例如:
+
+```
+Tap(100, 100);
+sleep(500);
+```
+
+注意, 动作的执行可能无法被停止, 例如：
+
+```
+for(var i = 0; i < 100; i++){
+  Tap(100, 100);
+}
+```
+
+这段代码执行后可能会出现在任务管理中停止脚本后点击仍然继续的情况.
+因此, 强烈建议在每个动作后加上延时：
+
+```
+for(var i = 0; i < 100; i++){
+  Tap(100, 100);
+  sleep(500);
+}
+```
+
+## Tap(x, y)
+
+* x, y {number} 要点击的坐标.
+
+点击位置(x, y), 您可以通过"开发者选项"开启指针位置来确定点击坐标.
+
+## Swipe(x1, y1, x2, y2, \[duration\])
+
+* x1, y1 {number} 滑动起点的坐标
+* x2, y2 {number} 滑动终点的坐标
+* duration {number} 滑动动作所用的时间
+
+滑动. 从(x1, y1)位置滑动到(x2, y2)位置.
+
+# 基于控件的操作
+
+基于控件的操作指的是选择屏幕上的控件, 获取其信息或对其进行操作. 对于一般软件而言, 基于控件的操作对不同机型有很好的兼容性；但是对于游戏而言, 由于游戏界面并不是由控件构成, 无法采用本章节的方法, 也无法使用本章节的函数. 有关游戏脚本的编写, 请参考《基于坐标的操作》.
+
+基于控件的操作依赖于无障碍服务, 因此最好在脚本开头使用`auto()`函数来确保无障碍服务已经启用. 如果运行到某个需要权限的语句无障碍服务并没启动, 则会抛出异常并跳转到无障碍服务界面. 这样的用户体验并不好, 因为需要重新运行脚本, 后续会加入等待无障碍服务启动并让脚本继续运行的函数.
+
+您也可以在脚本开头使用`"auto";`表示这个脚本需要无障碍服务, 但是不推荐这种做法, 因为这个标记必须在脚本的最开头(前面不能有注释或其他语句、空格等), 我们推荐使用`auto()`函数来确保无障碍服务已启用.
+
+## auto([mode])
+
+* `mode` {string} 模式
+
+检查无障碍服务是否已经启用, 如果没有启用则抛出异常并跳转到无障碍服务启用界面；同时设置无障碍模式为mode. mode的可选值为：
+
+* `fast` 快速模式. 该模式下会启用控件缓存, 从而选择器获取屏幕控件更快. 对于需要快速的控件操作的脚本可以使用该模式, 一般脚本则没有必要使用该函数.
+* `normal` 正常模式, 默认.
+
+如果不加mode参数, 则为正常模式.
+
+建议使用`auto.waitFor()`和`auto.setMode()`代替该函数, 因为`auto()`函数如果无障碍服务未启动会停止脚本；而`auto.waitFor()`则会在在无障碍服务启动后继续运行.
+
+示例：
+
+```
+auto("fast");
+```
+
+示例2：
+
+```
+auto();
+```
+
+## auto.waitFor()
+
+检查无障碍服务是否已经启用, 如果没有启用则跳转到无障碍服务启用界面, 并等待无障碍服务启动；当无障碍服务启动后脚本会继续运行.
+
+因为该函数是阻塞的, 因此除非是有协程特性, 否则不能在ui模式下运行该函数, 建议在ui模式下使用`auto()`函数.
+
+## auto.setMode(mode)
+
+* `mode` {string} 模式
+
+设置无障碍模式为mode. mode的可选值为：
+
+* `fast` 快速模式. 该模式下会启用控件缓存, 从而选择器获取屏幕控件更快. 对于需要快速的控件查看和操作的脚本可以使用该模式, 一般脚本则没有必要使用该函数.
+* `normal` 正常模式, 默认.
+
+## auto.setFlags(flags)
+
+**[v4.1.0新增]**
+
+* `flags` {string} | {Array} 一些标志, 来启用和禁用某些特性, 包括：
+    * `findOnUiThread` 使用该特性后, 选择器搜索时会在主进程进行. 该特性用于解决线程安全问题导致的次生问题, 不过目前貌似已知问题并不是线程安全问题.
+    * `useUsageStats` 使用该特性后, 将会以"使用情况统计"服务的结果来检测当前正在运行的应用包名（需要授予"查看使用情况统计"权限). 如果觉得currentPackage()返回的结果不太准确, 可以尝试该特性.
+    * `useShell` 使用该特性后, 将使用shell命令获取当前正在运行的应用的包名、活动名称, 但是需要root权限.
+
+启用有关automator的一些特性. 例如：
+
+```
+auto.setFlags(["findOnUiThread", "useShell"]);
+```
+
+## auto.service
+
+**[v4.1.0新增]**
+
+* [AccessibilityService](https://developer.android.com/reference/android/accessibilityservice/AccessibilityService/)
+
+获取无障碍服务. 如果无障碍服务没有启动, 则返回`null`.
+
+参见[AccessibilityService](https://developer.android.com/reference/android/accessibilityservice/AccessibilityService/).
+
+## auto.windows
+
+**[v4.1.0新增]**
+
+* {Array}
+
+当前所有窗口([AccessibilityWindowInfo](https://developer.android.com/reference/android/view/accessibility/AccessibilityWindowInfo/))的数组, 可能包括状态栏、输入法、当前应用窗口, 弹出窗口、悬浮窗、分屏应用窗口等. 可以分别获取每个窗口的布局信息.
+
+该函数需要Android 5.0以上才能运行.
+
+## auto.root
+
+**[v4.1.0新增]**
+
+* {UiObject}
+
+当前窗口的布局根元素. 如果无障碍服务未启动或者WindowFilter均返回false, 则会返回`null`.
+
+如果不设置windowFilter, 则当前窗口即为活跃的窗口（获取到焦点、正在触摸的窗口）；如果设置了windowFilter, 则获取的是过滤的窗口中的第一个窗口.
+
+如果系统是Android5.0以下, 则始终返回当前活跃的窗口的布局根元素.
+
+## auto.rootInActiveWindow
+
+**[v4.1.0新增]**
+
+* {UiObject}
+
+当前活跃的窗口（获取到焦点、正在触摸的窗口）的布局根元素. 如果无障碍服务未启动则为`null`.
+
+## auto.setWindowFilter(filter)
+
+**[v4.1.0新增]**
+
+* `filter` {Function} 参数为窗口([AccessibilityWindowInfo](https://developer.android.com/reference/android/view/accessibility/AccessibilityWindowInfo/)), 返回值为Boolean的函数.
+
+设置窗口过滤器. 这个过滤器可以决定哪些窗口是目标窗口, 并影响选择器的搜索. 例如, 如果想要选择器在所有窗口（包括状态栏、输入法等）中搜索, 只需要使用以下代码：
+
+```
+auto.setWindowFilter(function(window){
+    //不管是如何窗口, 都返回true, 表示在该窗口中搜索
+    return true;
+});
+```
+
+又例如, 当前使用了分屏功能, 屏幕上有Auto.js和QQ两个应用, 但我们只想选择器对QQ界面进行搜索, 则：
+
+```
+auto.setWindowFilter(function(window){
+    // 对于应用窗口, 他的title属性就是应用的名称, 因此可以通过title属性来判断一个应用
+    return window.title == "QQ";
+});
+```
+
+选择器默认是在当前活跃的窗口中搜索, 不会搜索诸如悬浮窗、状态栏之类的, 使用WindowFilter则可以控制搜索的窗口.
+
+需要注意的是, 如果WindowFilter返回的结果均为false, 则选择器的搜索结果将为空.
+
+另外setWindowFilter函数也会影响`auto.windowRoots`的结果.
+
+该函数需要Android 5.0以上才有效.
+
+## auto.windowRoots
+
+**[v4.1.0新增]**
+
+* {Array}
+
+返回当前被WindowFilter过滤的窗口的布局根元素组成的数组.
+
+如果系统是Android5.0以下, 则始终返回当前活跃的窗口的布局根元素的数组.
+
+# SimpleActionAutomator
+
+SimpleActionAutomator提供了一些模拟简单操作的函数, 例如点击文字、模拟按键等. 这些函数可以直接作为全局函数使用.
+
+## click(text[, i])
+
+* `text` {string} 要点击的文本
+* `i` {number} 如果相同的文本在屏幕中出现多次, 则i表示要点击第几个文本, i从0开始计算
+
+返回是否点击成功. 当屏幕中并未包含该文本, 或者该文本所在区域不能点击时返回false, 否则返回true.
+
+该函数可以点击大部分包含文字的按钮. 例如微信主界面下方的"微信", "联系人", "发现", "我"的按钮.   
+通常与while同时使用以便点击按钮直至成功. 例如:
+
+```
+while(!click("扫一扫"));
+```
+
+当不指定参数i时则会尝试点击屏幕上出现的所有文字text并返回是否全部点击成功.
+
+i是从0开始计算的, 也就是, `click("啦啦啦", 0)`表示点击屏幕上第一个"啦啦啦", `click("啦啦啦", 1)`表示点击屏幕上第二个"啦啦啦".
+
+> 文本所在区域指的是, 从文本处向其父视图寻找, 直至发现一个可点击的部件为止.
+
+## click(left, top, bottom, right)
+
+* `left` {number} 要点击的长方形区域左边与屏幕左边的像素距离
+* `top` {number} 要点击的长方形区域上边与屏幕上边的像素距离
+* `bottom` {number} 要点击的长方形区域下边与屏幕下边的像素距离
+* `right` {number} 要点击的长方形区域右边与屏幕右边的像素距离
+
+**注意, 该函数一般只用于录制的脚本中使用, 在自己写的代码中使用该函数一般不要使用该函数. **
+
+点击在指定区域的控件. 当屏幕中并未包含与该区域严格匹配的区域, 或者该区域不能点击时返回false, 否则返回true.
+
+有些按钮或者部件是图标而不是文字（例如发送朋友圈的照相机图标以及QQ下方的消息、联系人、动态图标）, 这时不能通过`click(text, i)`来点击, 可以通过描述图标所在的区域来点击. left, bottom, top, right描述的就是点击的区域.
+
+至于要定位点击的区域, 可以在悬浮窗使用布局分析工具查看控件的bounds属性.
+
+通过无障碍服务录制脚本会生成该语句.
+
+## longClick(text[, i]))
+
+* `text` {string} 要长按的文本
+* `i` {number} 如果相同的文本在屏幕中出现多次, 则i表示要长按第几个文本, i从0开始计算
+
+返回是否点击成功. 当屏幕中并未包含该文本, 或者该文本所在区域不能点击时返回false, 否则返回true.
+
+当不指定参数i时则会尝试点击屏幕上出现的所有文字text并返回是否全部长按成功.
+
+## scrollUp([i])
+
+* `i` {number} 要滑动的控件序号
+
+找到第i+1个可滑动控件上滑或**左滑**. 返回是否操作成功. 屏幕上没有可滑动的控件时返回false.
+
+另外不加参数时`scrollUp()`会寻找面积最大的可滑动的控件上滑或左滑, 例如微信消息列表等.
+
+参数为一个整数i时会找到第i + 1个可滑动控件滑动. 例如`scrollUp(0)`为滑动第一个可滑动控件.
+
+## scrollDown([i])
+
+* `i` {number} 要滑动的控件序号
+
+找到第i+1个可滑动控件下滑或**右滑**. 返回是否操作成功. 屏幕上没有可滑动的控件时返回false.
+
+另外不加参数时`scrollUp()`会寻找面积最大的可滑动的控件下滑或右滑.
+
+参数为一个整数i时会找到第i + 1个可滑动控件滑动. 例如`scrollUp(0)`为滑动第一个可滑动控件.
+
+## setText([i, ]text)
+
+* i {number} 表示要输入的为第i + 1个输入框
+* text {string} 要输入的文本
+
+返回是否输入成功. 当找不到对应的文本框时返回false.
+
+不加参数i则会把所有输入框的文本都置为text. 例如`setText("测试")`.
+
+这里的输入文本的意思是, 把输入框的文本置为text, 而不是在原来的文本上追加.
+
+## input([i, ]text)
+
+* i {number} 表示要输入的为第i + 1个输入框
+* text {string} 要输入的文本
+
+返回是否输入成功. 当找不到对应的文本框时返回false.
+
+不加参数i则会把所有输入框的文本追加内容text. 例如`input("测试")`.
\ No newline at end of file
diff --git a/api/base64.md b/api/base64.md
new file mode 100644
index 0000000..ab9fd6f
--- /dev/null
+++ b/api/base64.md
@@ -0,0 +1,10 @@
+# Base64
+
+---
+
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
+
+---
+
+
diff --git a/api/canvas.md b/api/canvas.md
index 443a54b..601f4b8 100644
--- a/api/canvas.md
+++ b/api/canvas.md
@@ -1,18 +1,25 @@
-# Canvas
+# 画布 (Canvas)
 
-canvas提供了使用画布进行2D画图的支持，可用于简单的小游戏开发或者图片编辑。使用canvas可以轻松地在一张图片或一个界面上绘制各种线与图形。
+---
 
-canvas的坐标系为平面直角坐标系，以控件左上角为原点，控件上边沿为x轴正方向，控件左边沿为y轴正方向。例如分辨率为1920*1080的屏幕上，canvas控件覆盖全屏，画一条从屏幕左上角到屏幕右下角的线段为:
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
+
+---
+
+canvas提供了使用画布进行2D画图的支持, 可用于简单的小游戏开发或者图片编辑. 使用canvas可以轻松地在一张图片或一个界面上绘制各种线与图形.
+
+canvas的坐标系为平面直角坐标系, 以控件左上角为原点, 控件上边沿为x轴正方向, 控件左边沿为y轴正方向. 例如分辨率为1920*1080的屏幕上, canvas控件覆盖全屏, 画一条从屏幕左上角到屏幕右下角的线段为:
 
 ```
 canvas.drawLine(0, 0, 1080, 1920, paint);
 ```
 
-canvas的绘制依赖于画笔Paint, 通过设置画笔的粗细、颜色、填充等可以改变绘制出来的图形。例如绘制一个红色实心正方形为：
+canvas的绘制依赖于画笔Paint, 通过设置画笔的粗细、颜色、填充等可以改变绘制出来的图形. 例如绘制一个红色实心正方形为：
 
 ```
 var paint = new Paint();
-//设置画笔为填充，则绘制出来的图形都是实心的
+//设置画笔为填充, 则绘制出来的图形都是实心的
 paint.setStyle(Paint.STYLE.FILL);
 //设置画笔颜色为红色
 paint.setColor(colors.RED);
@@ -20,11 +27,11 @@ paint.setColor(colors.RED);
 canvas.drawRect(0, 0, 100, 100, paint);
 ```
 
-如果要绘制正方形的边框，则通过设置画笔的Style来实现：
+如果要绘制正方形的边框, 则通过设置画笔的Style来实现：
 
 ```
 var paint = new Paint();
-//设置画笔为描边，则绘制出来的图形都是轮廓
+//设置画笔为描边, 则绘制出来的图形都是轮廓
 paint.setStyle(Paint.STYLE.STROKE);
 //设置画笔颜色为红色
 paint.setColor(colors.RED);
@@ -32,19 +39,19 @@ paint.setColor(colors.RED);
 canvas.drawRect(0, 0, 100, 100, paint);
 ```
 
-结合画笔，canvas可以绘制基本图形、图片等。
+结合画笔, canvas可以绘制基本图形、图片等.
 
 ## canvas.getWidth()
 
 * 返回 {number}
 
-返回画布当前图层的宽度。
+返回画布当前图层的宽度.
 
 ## canvas.getHeight()
 
 * 返回 {number}
 
-返回画布当前图层的高度。
+返回画布当前图层的高度.
 
 ## canvas.drawRGB(r, int g, int b)
 
@@ -52,7 +59,7 @@ canvas.drawRect(0, 0, 100, 100, paint);
 * `g` {number} 绿色通道值
 * `b` {number} 蓝色通道值
 
-将整个可绘制区域填充为r、g、b指定的颜色。相当于 `canvas.drawColor(colors.rgb(r, g, b))`。
+将整个可绘制区域填充为r、g、b指定的颜色. 相当于 `canvas.drawColor(colors.rgb(r, g, b))`.
 
 ## canvas.drawARGB(a, r, g, b)
 
@@ -61,27 +68,27 @@ canvas.drawRect(0, 0, 100, 100, paint);
 * `g` {number} 绿色通道值
 * `b` {number} 蓝色通道值
 
-将整个可绘制区域填充为a、r、g、b指定的颜色。相当于 `canvas.drawColor(colors.argb(a, r, g, b))`。
+将整个可绘制区域填充为a、r、g、b指定的颜色. 相当于 `canvas.drawColor(colors.argb(a, r, g, b))`.
 
 ## canvas.drawColor(color)
 
 * `color` {number} 颜色值
 
-将整个可绘制区域填充为color指定的颜色。
+将整个可绘制区域填充为color指定的颜色.
 
 ## canvas.drawColor(color, mode)
 
 * `color` {number} 颜色值
 * `mode` {PorterDuff.Mode} Porter-Duff操作
 
-将整个可绘制区域填充为color指定的颜色。
+将整个可绘制区域填充为color指定的颜色.
 
 ## canvas.drawPaint(paint)
 
 * `paint` {Paint} 画笔
 
-将整个可绘制区域用paint指定的画笔填充。相当于绘制一个无限大的矩形，但是更快。
-通过该方法可以绘制一个指定的着色器的图案。
+将整个可绘制区域用paint指定的画笔填充. 相当于绘制一个无限大的矩形, 但是更快.
+通过该方法可以绘制一个指定的着色器的图案.
 
 ## canvas.drawPoint(x, y, paint)
 
@@ -89,19 +96,19 @@ canvas.drawRect(0, 0, 100, 100, paint);
 * `y` {number} y坐标
 * `paint` {Paint} 画笔
 
-在可绘制区域绘制由坐标(x, y)指定的点。
-点的形状由画笔的线帽决定（参见paint.setStrokeCap(cap)）。
-点的大小由画笔的宽度决定（参见paint.setStrokeWidth(width)）。
-> 如果画笔宽度为0，则也会绘制1个像素至4个（若抗锯齿启用）。
+在可绘制区域绘制由坐标(x, y)指定的点.
+点的形状由画笔的线帽决定（参见paint.setStrokeCap(cap)）.
+点的大小由画笔的宽度决定（参见paint.setStrokeWidth(width)）.
+> 如果画笔宽度为0, 则也会绘制1个像素至4个（若抗锯齿启用）.
 
-相当于 `canvas.drawPoints([x, y], paint)`。
+相当于 `canvas.drawPoints([x, y], paint)`.
 
 ## canvas.drawPoints(pts, paint)
 
 * `pts` {Array<number>} 点坐标数组 [x0, y0, x1, y1, x2, y2, ...]
 * `paint` {Paint} 画笔
 
-在可绘制区域绘制由坐标数组指定的多个点。
+在可绘制区域绘制由坐标数组指定的多个点.
 
 ## canvas.drawLine(startX, startY, stopX, stopY, paint)
 
@@ -111,17 +118,17 @@ canvas.drawRect(0, 0, 100, 100, paint);
 * `endY` {number} 终点y坐标
 * `paint` {Paint} 画笔
 
-在可绘制区域绘制由起点坐标(startX, startY)和终点坐标(endX, endY)指定的线。
-绘制时会忽略画笔的样式(Style)。也就是说，即使样式设为“仅填充(FILL)”也会绘制。
-退化为点的线（长度为0）不会被绘制。
+在可绘制区域绘制由起点坐标(startX, startY)和终点坐标(endX, endY)指定的线.
+绘制时会忽略画笔的样式(Style). 也就是说, 即使样式设为“仅填充(FILL)”也会绘制.
+退化为点的线（长度为0）不会被绘制.
 
 ## canvas.drawRect(r, paint)
 
 * `r` {Rect} 矩形边界
 * `paint` {Paint} 画笔
 
-在可绘制区域绘制由矩形边界r指定的矩形。
-绘制时画笔的样式(Style)决定了是否绘制矩形界线和填充矩形。
+在可绘制区域绘制由矩形边界r指定的矩形.
+绘制时画笔的样式(Style)决定了是否绘制矩形界线和填充矩形.
 
 ## canvas.drawRect(left, top, right, bottom, android.graphics.Paint paint)
 
@@ -131,8 +138,8 @@ canvas.drawRect(0, 0, 100, 100, paint);
 * `bottom` {number} 矩形下边界y坐标
 * `paint` {Paint} 画笔
 
-在可绘制区域绘制由矩形边界(left, top, right, bottom)指定的矩形。
-绘制时画笔的样式(Style)决定了是否绘制矩形界线和填充矩形。
+在可绘制区域绘制由矩形边界(left, top, right, bottom)指定的矩形.
+绘制时画笔的样式(Style)决定了是否绘制矩形界线和填充矩形.
 
 ## canvas.drawOval(android.graphics.RectF oval, android.graphics.Paint paint)
 
@@ -158,17 +165,17 @@ canvas.drawRect(0, 0, 100, 100, paint);
 
 ## canvas.translate(dx, dy)
 
-* `dx` {number} 向x轴正方向平移的距离，负数表示反方向平移
-* `dy` {number} 向y轴正方向平移的距离，负数表示反方向平移
+* `dx` {number} 向x轴正方向平移的距离, 负数表示反方向平移
+* `dy` {number} 向y轴正方向平移的距离, 负数表示反方向平移
 
-平移指定距离。
+平移指定距离.
 
 ## canvas.scale(sx, sy)
 
-* `sx` {number} 向x轴正方向平移的距离，负数表示反方向平移
-* `sy` {number} 向y轴正方向平移的距离，负数表示反方向平移
+* `sx` {number} 向x轴正方向平移的距离, 负数表示反方向平移
+* `sy` {number} 向y轴正方向平移的距离, 负数表示反方向平移
 
-以原点为中心，将坐标系平移缩放指定倍数。
+以原点为中心, 将坐标系平移缩放指定倍数.
 
 ## canvas.scale(float sx, float sy, float px, float py)
 
diff --git a/api/changelog.md b/api/changelog.md
new file mode 100644
index 0000000..562ba7e
--- /dev/null
+++ b/api/changelog.md
@@ -0,0 +1,13 @@
+# 更新日志 (Changelog)
+
+## 2022/12/01
+
+- `新增` 夜间模式主题适配
+- `新增` [E4X](e4x) / [术语](glossaries) / [异常](exceptions) / [数据类型](dataTypes) / [选择器](uiSelectorType) / [控件节点](uiObjectType) / [控件集合](uiObjectCollectionType) 等章节
+- `修复` 章节标题可能显示不全的问题
+- `修复` 代码区域滑动时导致页面滑动的问题
+- `修复` App 文档无法跳转到其他章节的问题
+- `优化` 重新部署文档结构并统一样式 (暂未全部完成)
+- `优化` 完善 [脚本化 Java](scriptingJava) 章节
+- `优化` 支持 Java 等语言的语法高亮 (有限支持)
+- `优化` 去除章节标题的锚点标记
diff --git a/api/color.md b/api/color.md
new file mode 100644
index 0000000..87e73fa
--- /dev/null
+++ b/api/color.md
@@ -0,0 +1,152 @@
+# 颜色 (Colors)
+
+---
+
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
+
+---
+
+在Auto.js有两种方式表示一个颜色.
+
+一种是使用一个字符串"#AARRGGBB"或"#RRGGBB", 其中 AA 是Alpha通道(透明度)的值, RR 是R通道(红色)的值, GG 是G通道(绿色)的值, BB是B通道(蓝色)的值. 例如"#ffffff"表示白色, "#7F000000"表示半透明的黑色.
+
+另一种是使用一个16进制的"32位整数" 0xAARRGGBB 来表示一个颜色, 例如 `0xFF112233`表示颜色"#112233", `0x11223344`表示颜色"#11223344".
+
+可以通过`colors.toString()`把颜色整数转换为字符串, 通过`colors.parseColor()`把颜色字符串解析为颜色整数.
+
+## colors.toString(color)
+
+* `color` {number} 整数RGB颜色值
+* 返回 {string}
+
+返回颜色值的字符串, 格式为 "#AARRGGBB".
+
+## colors.red(color)
+
+* `color` {number} | {string} 颜色值
+* 返回 {number}
+
+返回颜色color的R通道的值, 范围0~255.
+
+## colors.green(color)
+
+* `color` {number} | {string} 颜色值
+* 返回 {number}
+
+返回颜色color的G通道的值, 范围0~255.
+
+## colors.blue(color)
+
+* `color` {number} | {string} 颜色值
+* 返回 {number}
+
+返回颜色color的B通道的值, 范围0~255.
+
+## colors.alpha(color)
+
+* `color` {number} | {string} 颜色值
+* 返回 {number}
+
+返回颜色color的Alpha通道的值, 范围0~255.
+
+## colors.rgb(red, green, blue)
+
+* red {number} 颜色的R通道的值
+* blue {number} 颜色的G通道的值
+* green {number} 颜色的B通道的值
+* 返回 {number}
+
+返回这些颜色通道构成的整数颜色值. Alpha通道将是255（不透明）.
+
+## colors.argb(alpha, red, green, blue)
+
+* `alpha` {number} 颜色的Alpha通道的值
+* `red` {number} 颜色的R通道的值
+* `green` {number} 颜色的G通道的值
+* `blue` {number} 颜色的B通道的值
+* 返回 {number}
+
+返回这些颜色通道构成的整数颜色值.
+
+## colors.parseColor(colorStr)
+
+* `colorStr` {string} 表示颜色的字符串, 例如"#112233"
+* 返回 {number}
+
+返回颜色的整数值.
+
+## colors.isSimilar(color2, color2[, threshold, algorithm])
+
+* `color1` {number} | {string} 颜色值1
+* `color1` {number} | {string} 颜色值2
+* `threshold` {number} 颜色相似度临界值, 默认为4. 取值范围为0~255. 这个值越大表示允许的相似程度越小, 如果这个值为0, 则两个颜色相等时该函数才会返回true.
+* `algorithm` {string} 颜色匹配算法, 默认为"diff", 包括:
+    * "diff": 差值匹配. 与给定颜色的R、G、B差的绝对值之和小于threshold时匹配.
+    * "rgb": rgb欧拉距离相似度. 与给定颜色color的rgb欧拉距离小于等于threshold时匹配.
+    * "rgb+": 加权rgb欧拉距离匹配([LAB Delta E](https://en.wikipedia.org/wiki/Color_difference/)).
+    * "hs": hs欧拉距离匹配. hs为HSV空间的色调值.
+* 返回 {Boolean}
+
+返回两个颜色是否相似.
+
+## colors.equals(color1, color2)
+
+* `color1` {number} | {string} 颜色值1
+* `color1` {number} | {string} 颜色值2
+* 返回 {Boolean}
+
+返回两个颜色是否相等. **注意该函数会忽略Alpha通道的值进行比较*.
+
+```
+log(colors.equals("#112233", "#112234"));
+log(colors.equals(0xFF112233, 0xFF223344));
+```
+
+# colors.BLACK
+
+黑色, 颜色值 #FF000000
+
+# colors.DKGRAY
+
+深灰色, 颜色值 #FF444444
+
+# colors.GRAY
+
+灰色, 颜色值 #FF888888
+
+# colors.LTGRAY
+
+亮灰色, 颜色值 #FFCCCCCC
+
+# colors.WHITE
+
+白色, 颜色值 #FFFFFFFF
+
+# colors.RED
+
+红色, 颜色值 #FFFF0000
+
+# colors.GREEN
+
+绿色, 颜色值 #FF00FF00
+
+# colors.BLUE
+
+蓝色, 颜色值 #FF0000FF
+
+# colors.YELLOW
+
+黄色, 颜色值 #FFFFFF00
+
+# colors.CYAN
+
+青色, 颜色值 #FF00FFFF
+
+# colors.MAGENTA
+
+品红色, 颜色值 #FFFF00FF
+
+# colors.TRANSPARENT
+
+透明, 颜色值 #00000000
\ No newline at end of file
diff --git a/api/console.md b/api/console.md
index 7573b03..f88547c 100644
--- a/api/console.md
+++ b/api/console.md
@@ -1,28 +1,33 @@
-# Console
+# 控制台 (Console)
 
-> Stability: 2 - Stable
+---
 
-控制台模块提供了一个和Web浏览器中相似的用于调试的控制台。用于输出一些调试信息、中间结果等。
-console模块中的一些函数也可以直接作为全局函数使用，例如log, print等。
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
+
+---
+
+控制台模块提供了一个和Web浏览器中相似的用于调试的控制台. 用于输出一些调试信息、中间结果等.
+console模块中的一些函数也可以直接作为全局函数使用, 例如log, print等.
 
 ## console.show()
 
-显示控制台。这会显示一个控制台的悬浮窗(需要悬浮窗权限)。
+显示控制台. 这会显示一个控制台的悬浮窗(需要悬浮窗权限).
 
 ## console.hide()
 
-隐藏控制台悬浮窗。
+隐藏控制台悬浮窗.
 
 ## console.clear()
 
-清空控制台。
+清空控制台.
 
 ## console.log([data][, ...args])#
 
 * `data` {any}
 * `...args` {any}
 
-打印到控制台，并带上换行符。 可以传入多个参数，第一个参数作为主要信息，其他参数作为类似于 [printf(3)](http://man7.org/linux/man-pages/man3/printf.3.html) 中的代替值（参数都会传给 util.format()）。
+打印到控制台, 并带上换行符.  可以传入多个参数, 第一个参数作为主要信息, 其他参数作为类似于 [printf(3)](http://man7.org/linux/man-pages/man3/printf.3.html/) 中的代替值（参数都会传给 util.format(/)）.
 
 ```
 const count = 5;
@@ -32,44 +37,44 @@ console.log('count:', count);
 // 打印: count: 5 到 stdout
 ```
 
-详见 util.format()。
+详见 util.format().
 
-该函数也可以作为全局函数使用。
+该函数也可以作为全局函数使用.
 
 ## console.verbose([data][, ...args])
 
 * `data` {any}
 * `...args` {any}
 
-与console.log类似，但输出结果以灰色字体显示。输出优先级低于log，用于输出观察性质的信息。
+与console.log类似, 但输出结果以灰色字体显示. 输出优先级低于log, 用于输出观察性质的信息.
 
 ## console.info([data][, ...args])
 
 * `data` {any}
 * `...args` {any}
 
-与console.log类似，但输出结果以绿色字体显示。输出优先级高于log, 用于输出重要信息。
+与console.log类似, 但输出结果以绿色字体显示. 输出优先级高于log, 用于输出重要信息.
 
 ## console.warn([data][, ...args])
 
 * `data` {any}
 * `...args` {any}
 
-与console.log类似，但输出结果以蓝色字体显示。输出优先级高于info, 用于输出警告信息。
+与console.log类似, 但输出结果以蓝色字体显示. 输出优先级高于info, 用于输出警告信息.
 
 ## console.error([data][, ...args])
 
 * `data` {any}
 * `...args` {any}
 
-与console.log类似，但输出结果以红色字体显示。输出优先级高于warn, 用于输出错误信息。
+与console.log类似, 但输出结果以红色字体显示. 输出优先级高于warn, 用于输出错误信息.
 
 ## console.assert(value, message)
 
 * value {any} 要断言的布尔值
 * message {string} value为false时要输出的信息
 
-断言。如果value为false则输出错误信息message并停止脚本运行。
+断言. 如果value为false则输出错误信息message并停止脚本运行.
 
 ```
 var a = 1 + 1;
@@ -80,12 +85,12 @@ console.assert(a == 2, "加法出错啦");
 
 **[v4.1.0新增]**
 
-* `label` {String} 计时器标签，可省略
+* `label` {String} 计时器标签, 可省略
 
-启动一个定时器，用以计算一个操作的持续时间。
-定时器由一个唯一的 `label` 标识。
-当调用 `console.timeEnd()` 时，可以使用相同的 `label` 来停止定时器，并以毫秒为单位将持续时间输出到控制台。
-重复启动同一个标签的定时器会覆盖之前启动同一标签的定时器。
+启动一个定时器, 用以计算一个操作的持续时间.
+定时器由一个唯一的 `label` 标识.
+当调用 `console.timeEnd()` 时, 可以使用相同的 `label` 来停止定时器, 并以毫秒为单位将持续时间输出到控制台.
+重复启动同一个标签的定时器会覆盖之前启动同一标签的定时器.
 
 ## console.timeEnd(label)
 
@@ -93,8 +98,8 @@ console.assert(a == 2, "加法出错啦");
 
 * `label` {String} 计时器标签
 
-停止之前通过调用 `console.time()` 启动的定时器，并打印结果到控制台。
-调用 `console.timeEnd()` 后定时器会被删除。如果不存在标签指定的定时器则会打印 `NaNms`。
+停止之前通过调用 `console.time()` 启动的定时器, 并打印结果到控制台.
+调用 `console.timeEnd()` 后定时器会被删除. 如果不存在标签指定的定时器则会打印 `NaNms`.
 
 ```js
 console.time('求和');
@@ -113,7 +118,7 @@ console.timeEnd('求和');
 * `data` {any}
 * `...args` {any}
 
-与console.log类似，同时会打印出调用这个函数所在的调用栈信息（即当前运行的文件、行数等信息）。
+与console.log类似, 同时会打印出调用这个函数所在的调用栈信息（即当前运行的文件、行数等信息）.
 
 ```js
 console.trace('Show me');
@@ -127,9 +132,9 @@ console.trace('Show me');
 * `data` {any}
 * `...args` {any}
 
-与console.log一样输出信息，并在控制台显示输入框等待输入。按控制台的确认按钮后会将输入的字符串用eval计算后返回。
+与console.log一样输出信息, 并在控制台显示输入框等待输入. 按控制台的确认按钮后会将输入的字符串用eval计算后返回.
 
-**部分机型可能会有控制台不显示输入框的情况，属于bug。**
+**部分机型可能会有控制台不显示输入框的情况, 属于bug. **
 
 例如：
 
@@ -145,9 +150,9 @@ toast(n + 1);
 * `data` {any}
 * `...args` {any}
 
-与console.log一样输出信息，并在控制台显示输入框等待输入。按控制台的确认按钮后会将输入的字符串直接返回。
+与console.log一样输出信息, 并在控制台显示输入框等待输入. 按控制台的确认按钮后会将输入的字符串直接返回.
 
-部分机型可能会有控制台不显示输入框的情况，属于bug。
+部分机型可能会有控制台不显示输入框的情况, 属于bug.
 
 例如：
 
@@ -163,7 +168,7 @@ toast(n + 1);
 * `w` {number} 宽度
 * `h` {number} 高度
 
-设置控制台的大小，单位像素。
+设置控制台的大小, 单位像素.
 
 ```
 console.show();
@@ -176,7 +181,7 @@ console.setSize(device.width / 2, device.height / 2);
 * `x` {number} 横坐标
 * `y` {number} 纵坐标
 
-设置控制台的位置，单位像素。
+设置控制台的位置, 单位像素.
 
 ```
 console.show();
@@ -187,14 +192,14 @@ console.setPosition(100, 100);
 
 **[v4.1.0新增]**
 
-* `config` {Object} 日志配置，可选的项有：
-    * `file` {string} 日志文件路径，将会把日志写入该文件中
-    * `maxFileSize` {number} 最大文件大小，单位字节，默认为512 * 1024 (512KB)
-    * `rootLevel` {string} 写入的日志级别，默认为"ALL"（所有日志），可以为"OFF"(关闭), "DEBUG", "INFO", "WARN", "ERROR", "FATAL"等。
-    * `maxBackupSize` {number} 日志备份文件最大数量，默认为5
-    * `filePattern` {string} 日志写入格式，参见[PatternLayout](http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/PatternLayout.html)
+* `config` {Object} 日志配置, 可选的项有：
+    * `file` {string} 日志文件路径, 将会把日志写入该文件中
+    * `maxFileSize` {number} 最大文件大小, 单位字节, 默认为512 * 1024 (512KB)
+    * `rootLevel` {string} 写入的日志级别, 默认为"ALL"（所有日志）, 可以为"OFF"(关闭), "DEBUG", "INFO", "WARN", "ERROR", "FATAL"等.
+    * `maxBackupSize` {number} 日志备份文件最大数量, 默认为5
+    * `filePattern` {string} 日志写入格式, 参见[PatternLayout](http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/PatternLayout.html/)
 
-设置日志保存的路径和配置。例如把日志保存到"/sdcard/1.txt":
+设置日志保存的路径和配置. 例如把日志保存到"/sdcard/1.txt":
 
 ```
 console.setGlobalLogConfig({
@@ -202,12 +207,12 @@ console.setGlobalLogConfig({
 });
 ```
 
-注意该函数会影响所有脚本的日志记录。
+注意该函数会影响所有脚本的日志记录.
 
 ## print(text)
 
 * text {string} | {Object} 要打印到控制台的信息
 
-相当于`log(text)`。
+相当于`log(text)`.
 
 
diff --git a/api/context.md b/api/context.md
new file mode 100644
index 0000000..9e115d7
--- /dev/null
+++ b/api/context.md
@@ -0,0 +1,14 @@
+# 上下文 (Context)
+
+---
+
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
+
+---
+
+一个 android.content.Context 子类实例.
+
+该对象为 ApplicationContext, 因此不能用于创建 [ 界面 / 对话框 ] 等.
+
+[android.content.Context#getApplicationContext](https://developer.android.com/reference/android/content/Context#getApplicationContext())
\ No newline at end of file
diff --git a/api/continuation.md b/api/continuation.md
new file mode 100644
index 0000000..0dfec89
--- /dev/null
+++ b/api/continuation.md
@@ -0,0 +1,10 @@
+# 协程 (Continuation)
+
+---
+
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
+
+---
+
+
diff --git a/api/coordinatesBasedAutomation.md b/api/coordinatesBasedAutomation.md
deleted file mode 100644
index a09c9ef..0000000
--- a/api/coordinatesBasedAutomation.md
+++ /dev/null
@@ -1,260 +0,0 @@
-# 基于坐标的触摸模拟
-
-> Stability: 2 - Stable
-
-本章节介绍了一些使用坐标进行点击、滑动的函数。这些函数有的需要安卓7.0以上，有的需要root权限。
-
-要获取要点击的位置的坐标，可以在开发者选项中开启"指针位置"。
-
-基于坐标的脚本通常会有分辨率的问题，这时可以通过`setScreenMetrics()`函数来进行自动坐标放缩。这个函数会影响本章节的所有点击、长按、滑动等函数。通过设定脚本设计时的分辨率，使得脚本在其他分辨率下自动放缩坐标。
-
-控件和坐标也可以相互结合。一些控件是无法点击的(clickable为false), 无法通过`.click()`函数来点击，这时如果安卓版本在7.0以上或者有root权限，就可以通过以下方式来点击：
-
-```
-//获取这个控件
-var widget = id("xxx").findOne();
-//获取其中心位置并点击
-click(widget.bounds().centerX(), widget.bounds().centerY());
-//如果用root权限则用Tap
-```
-
-## setScreenMetrics(width, height)
-
-* width {number} 屏幕宽度，单位像素
-* height {number} 屏幕高度，单位像素
-
-设置脚本坐标点击所适合的屏幕宽高。如果脚本运行时，屏幕宽度不一致会自动放缩坐标。
-
-例如在1920*1080的设备中，某个操作的代码为
-
-```
-setScreenMetrics(1080, 1920);
-click(800, 200);
-longClick(300, 500);
-```
-
-那么在其他设备上AutoJs会自动放缩坐标以便脚本仍然有效。例如在540 * 960的屏幕中`click(800, 200)`实际上会点击位置(400, 100)。
-
-# 安卓7.0以上的触摸和手势模拟
-
-> Stability: 2 - Stable
-
-**注意以下命令只有Android7.0及以上才有效**
-
-## click(x, y)
-
-* `x` {number} 要点击的坐标的x值
-* `y` {number} 要点击的坐标的y值
-
-模拟点击坐标(x, y)，并返回是否点击成功。只有在点击执行完成后脚本才继续执行。
-
-一般而言，只有点击过程(大约150毫秒)中被其他事件中断(例如用户自行点击)才会点击失败。
-
-使用该函数模拟连续点击时可能有点击速度过慢的问题，这时可以用`press()`函数代替。
-
-## longClick(x, y)
-
-* `x` {number} 要长按的坐标的x值
-* `y` {number} 要长按的坐标的y值
-
-模拟长按坐标(x, y), 并返回是否成功。只有在长按执行完成（大约600毫秒）时脚本才会继续执行。
-
-一般而言，只有长按过程中被其他事件中断(例如用户自行点击)才会长按失败。
-
-## press(x, y, duration)
-
-* `x` {number} 要按住的坐标的x值
-* `y` {number} 要按住的坐标的y值
-* `duration` {number} 按住时长，单位毫秒
-
-模拟按住坐标(x, y), 并返回是否成功。只有按住操作执行完成时脚本才会继续执行。
-
-如果按住时间过短，那么会被系统认为是点击；如果时长超过500毫秒，则认为是长按。
-
-一般而言，只有按住过程中被其他事件中断才会操作失败。
-
-一个连点器的例子如下：
-
-```
-//循环100次
-for(var i = 0; i < 100; i++){
-  //点击位置(500, 1000), 每次用时1毫秒
-  press(500, 1000, 1);
-}
-```
-
-## swipe(x1, y1, x2, y2, duration)
-
-* `x1` {number} 滑动的起始坐标的x值
-* `y1` {number} 滑动的起始坐标的y值
-* `x2` {number} 滑动的结束坐标的x值
-* `y2` {number} 滑动的结束坐标的y值
-* `duration` {number} 滑动时长，单位毫秒
-
-模拟从坐标(x1, y1)滑动到坐标(x2, y2)，并返回是否成功。只有滑动操作执行完成时脚本才会继续执行。
-
-一般而言，只有滑动过程中被其他事件中断才会滑动失败。
-
-## gesture(duration, [x1, y1], [x2, y2], ...)
-
-* `duration` {number} 手势的时长
-* [x, y] ... 手势滑动路径的一系列坐标
-
-模拟手势操作。例如`gesture(1000, [0, 0], [500, 500], [500, 1000])`为模拟一个从(0, 0)到(500, 500)到(500, 100)的手势操作，时长为2秒。
-
-## gestures([delay1, duration1, [x1, y1], [x2, y2], ...], [delay2, duration2, [x3, y3], [x4, y4], ...], ...)
-
-同时模拟多个手势。每个手势的参数为\[delay, duration, 坐标\], delay为延迟多久(毫秒)才执行该手势；duration为手势执行时长；坐标为手势经过的点的坐标。其中delay参数可以省略，默认为0。
-
-例如手指捏合：
-
-```
-gestures([0, 500, [800, 300], [500, 1000]],
-         [0, 500, [300, 1500], [500, 1000]]);
-```
-
-# RootAutomator
-
-> Stability: 2 - Stable
-
-RootAutomator是一个使用root权限来模拟触摸的对象，用它可以完成触摸与多点触摸，并且这些动作的执行没有延迟。
-
-一个脚本中最好只存在一个RootAutomator，并且保证脚本结束退出他。可以在exit事件中退出RootAutomator，例如：
-
-```
-var ra = new RootAutomator();
-events.on('exit', function(){
-  ra.exit();
-});
-//执行一些点击操作
-...
-
-```
-
-**注意以下命令需要root权限**
-
-## RootAutomator.tap(x, y[, id])
-
-* `x` {number} 横坐标
-* `y` {number} 纵坐标
-* `id` {number} 多点触摸id，可选，默认为1，可以通过setDefaultId指定。
-
-点击位置(x, y)。其中id是一个整数值，用于区分多点触摸，不同的id表示不同的"手指"，例如：
-
-```
-var ra = new RootAutomator();
-//让"手指1"点击位置(100, 100)
-ra.tap(100, 100, 1);
-//让"手指2"点击位置(200, 200);
-ra.tap(200, 200, 2);
-ra.exit();
-```
-
-如果不需要多点触摸，则不需要id这个参数。
-多点触摸通常用于手势或游戏操作，例如模拟双指捏合、双指上滑等。
-
-某些情况下可能存在tap点击无反应的情况，这时可以用`RootAutomator.press()`函数代替。
-
-## RootAutomator.swipe(x1, x2, y1, y2[, duration, id])
-
-* `x1` {number} 滑动起点横坐标
-* `y1` {number} 滑动起点纵坐标
-* `x2` {number} 滑动终点横坐标
-* `y2` {number} 滑动终点纵坐标
-* `duration` {number} 滑动时长，单位毫秒，默认值为300
-* `id` {number} 多点触摸id，可选，默认为1
-
-模拟一次从(x1, y1)到(x2, y2)的时间为duration毫秒的滑动。
-
-## RootAutomator.press(x, y, duration[, id])
-
-* `x` {number} 横坐标
-* `y` {number} 纵坐标
-* `duration` {number} 按下时长
-* `id` {number} 多点触摸id，可选，默认为1
-
-模拟按下位置(x, y)，时长为duration毫秒。
-
-## RootAutomator.longPress(x, y[\, id\])
-
-* `x` {number} 横坐标
-* `y` {number} 纵坐标
-* `duration` {number} 按下时长
-* `id` {number} 多点触摸id，可选，默认为1
-
-模拟长按位置(x, y)。
-
-以上为简单模拟触摸操作的函数。如果要模拟一些复杂的手势，需要更底层的函数。
-
-## RootAutomator.touchDown(x, y[, id])
-
-* `x` {number} 横坐标
-* `y` {number} 纵坐标
-* `id` {number} 多点触摸id，可选，默认为1
-
-模拟手指按下位置(x, y)。
-
-## RootAutomator.touchMove(x, y[, id])
-
-* `x` {number} 横坐标
-* `y` {number} 纵坐标
-* `id` {number} 多点触摸id，可选，默认为1
-
-模拟移动手指到位置(x, y)。
-
-## RootAutomator.touchUp([id])
-
-* `id` {number} 多点触摸id，可选，默认为1
-
-模拟手指弹起。
-
-# 使用root权限点击和滑动的简单命令
-
-> Stability: 1 - Experimental
-
-注意：本章节的函数在后续版本很可能有改动！请勿过分依赖本章节函数的副作用。推荐使用`RootAutomator`代替本章节的触摸函数。
-
-以下函数均需要root权限，可以实现任意位置的点击、滑动等。
-
-* 这些函数通常首字母大写以表示其特殊的权限。
-* 这些函数均不返回任何值。
-* 并且，这些函数的执行是异步的、非阻塞的，在不同机型上所用的时间不同。脚本不会等待动作执行完成才继续执行。因此最好在每个函数之后加上适当的sleep来达到期望的效果。
-
-例如:
-
-```
-Tap(100, 100);
-sleep(500);
-```
-
-注意，动作的执行可能无法被停止，例如：
-
-```
-for(var i = 0; i < 100; i++){
-  Tap(100, 100);
-}
-```
-
-这段代码执行后可能会出现在任务管理中停止脚本后点击仍然继续的情况。
-因此，强烈建议在每个动作后加上延时：
-
-```
-for(var i = 0; i < 100; i++){
-  Tap(100, 100);
-  sleep(500);
-}
-```
-
-## Tap(x, y)
-
-* x, y {number} 要点击的坐标。
-
-点击位置(x, y), 您可以通过"开发者选项"开启指针位置来确定点击坐标。
-
-## Swipe(x1, y1, x2, y2, \[duration\])
-
-* x1, y1 {number} 滑动起点的坐标
-* x2, y2 {number} 滑动终点的坐标
-* duration {number} 滑动动作所用的时间
-
-滑动。从(x1, y1)位置滑动到(x2, y2)位置。
\ No newline at end of file
diff --git a/api/_coverpage.md b/api/coverpage.md
similarity index 60%
rename from api/_coverpage.md
rename to api/coverpage.md
index 2c77ae4..340c9d1 100644
--- a/api/_coverpage.md
+++ b/api/coverpage.md
@@ -1,8 +1,8 @@
 ![logo](images/logo.png)
 
-# [AutoJs6](https://github.com/SuperMonster003/AutoJs6)
+# [AutoJs6](https://github.com/SuperMonster003/AutoJs6/)
 
 安卓平台 JavaScript 自动化工具
 
-[下载应用](https://github.com/SuperMonster003/AutoJs6/releases)
-[阅读文档](#综述)
\ No newline at end of file
+[下载应用](https://github.com/SuperMonster003/AutoJs6/releases/)
+[阅读文档](/overview)
\ No newline at end of file
diff --git a/api/crypto.md b/api/crypto.md
index 66fd6b1..0f04023 100644
--- a/api/crypto.md
+++ b/api/crypto.md
@@ -1,13 +1,20 @@
-# Crypto
+# 密文 (Crypto)
+
+---
+
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
+
+---
 
 ** [[Pro 8.0.0新增](https://pro.autojs.org/)] **
 
-$crypto模块提供了对称加密(例如AES)、非对称加密(例如RSA)、消息摘要(例如MD5, SHA)等支持。
+$crypto模块提供了对称加密(例如AES)、非对称加密(例如RSA)、消息摘要(例如MD5, SHA)等支持.
 
 ## $crypto.digest(message, algorithm[, options])
 
 * `message` {any}
-* `algorithm` {string} 消息摘要算法，包括：
+* `algorithm` {string} 消息摘要算法, 包括：
     * MD5
     * SHA-1
     * SHA-256
@@ -15,9 +22,9 @@ $crypto模块提供了对称加密(例如AES)、非对称加密(例如RSA)、消
     * SHA-512
 * `options` {any}
 
-对信息message使用消息摘要算法`algorithm`进行摘要并返回结果，默认的输出格式为hex。
+对信息message使用消息摘要算法`algorithm`进行摘要并返回结果, 默认的输出格式为hex.
 
-参数message的类型默认为字符串，返回值默认为hex；可以通过options来指定参数message的类型和返回值的类型、格式，比如文件、base64、字节数组、hex等。参见《输入和输出的类型和格式》。
+参数message的类型默认为字符串, 返回值默认为hex；可以通过options来指定参数message的类型和返回值的类型、格式, 比如文件、base64、字节数组、hex等. 参见《输入和输出的类型和格式》.
 
 ```javascript
 // 计算字符串abc的md5
@@ -34,7 +41,7 @@ toastLog($crypto.digest("/sdcard/1.txt", "MD5", {
 
 * `data` {any} 明文消息
 * `key` {Key} 密钥
-* `algorithm` {string} 加密算法，包括：
+* `algorithm` {string} 加密算法, 包括：
     * AES
     * AES/ECB/NoPadding
     * AES/ECB/PKCS5Padding
@@ -49,7 +56,7 @@ toastLog($crypto.digest("/sdcard/1.txt", "MD5", {
     * RSA/ECB/PKCS1Padding
     * RSA/ECB/NoPadding
     * ...
-      具体可参阅 [javax.crypto.Cipher](https://developer.android.com/reference/javax/crypto/Cipher)
+      具体可参阅 [javax.crypto.Cipher](https://developer.android.com/reference/javax/crypto/Cipher/)
 
 * `options` {Object} 加密选项
 
diff --git a/api/dataTypes.md b/api/dataTypes.md
new file mode 100644
index 0000000..4068f15
--- /dev/null
+++ b/api/dataTypes.md
@@ -0,0 +1,1472 @@
+# 数据类型 (Data Types)
+
+---
+
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
+
+---
+
+数据类型是用来约束数据的解释.  
+本章节的数据类型包括 [ number / void / any / object / 泛型 / 交叉类型 ] 等.
+
+> 注: 此章节的类型概念 与 JavaScript 数据类型 (如 [基本类型](https://developer.mozilla.org/zh-CN/docs/Glossary/Primitive/)) 以及 TypeScript 数据类型 (如 [基础类型](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html)) 在概念上可能存在出入, 因此仅适用于对文档内容的辅助理解, 不适用于严格的概念参考.
+
+## Boolean
+
+布尔类型.
+
+**foo(bar)**
+
+- **bar** { [boolean](#boolean) }
+
+```js
+foo(true); /* 符合预期. */
+foo(false); /* 符合预期. */
+foo(3); /* 不符合预期. */
+```
+
+需留意 JavaScript 的短路特性:
+
+```js
+/* 符合预期, 相当于 foo(false). */
+foo(3 > 4);
+
+/* 不符合预期, 相当于 foo("hello"). */
+foo(3 > 4 || "hello");
+
+/* 符合预期, 相当于 foo(false). */
+foo(3 > 4 && "hello");
+
+/* 不符合预期, 相当于 foo("hello"). */
+foo(3 > 2 && "hello");
+```
+
+## Number
+
+数字类型.
+
+常用以下表示方法:
+
+- `3` - 整数
+- `+3` - 整数
+    - 结果与 3 相同, 通常仅用于强调正负性
+    - 这里的 "+" 并非符号, 而是一元运算符
+- `-3` - 负数
+- `3.1` - 小数
+    - JS 使用 IEEE 754 双精度版本存储数字
+    - 参阅: [0.1 + 0.2 !== 0.3](https://github.com/HXWfromDJTU/blog/issues/20)
+- `3.0` - 整数
+    - 结果与 3 相同, JS 没有 Double 等类型
+- `.1` - 小数, 省略前导 0, 相当于 0.1
+- `2e3` - 科学计数法, 相当于 2 × 10^3, 即 2000
+    - 符号 e 表示 10 的幂, e 前后的数字分别称为有效数和幂次
+    - 有效数可以为整数或小数字面量:
+        - `1e2`, `3.1e2`, `-9e2`, `0e2`, `.1e2` 均合法
+    - 幂次只能为整数字面量:
+        - `1e2`, `1e-2` 均合法
+    - e 的前后不能有变量或括号等符号:
+        - `let num = 3;`
+        - `nume2`, `(num)e2`, `(3)e(2)`, `3e(num)` 均不合法
+- `0x23` - 十六进制
+- `0b101` - 二进制
+- `0o307` - 八进制
+- `NaN` - 特殊数值
+    - 参阅: [NaN](glossaries#nan)
+- `Infinity` - 无穷大
+- `-Infinity` - 负无穷大
+- `Number.XXX` - Number 对象上的常量
+    - 如 [Number\.EPSILON](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Number/EPSILON), [Number.MAX_VALUE](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_VALUE) 等
+- `Math.XXX` - Math 对象上的常量
+    - 如 [Math.PI](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Math/PI), [Math.SQRT2](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Math/SQRT2), [Math.LN2](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Math/LN2) 等
+
+**foo(bar)**
+
+- **bar** { [number](#number) }
+
+```js
+foo(3); /* 符合预期. */
+foo(3.3); /* 符合预期. */
+foo(3e3); /* 符合预期. */
+foo(NaN); /* 符合预期. */
+```
+
+JavaScript 的所有数字都是浮点数, 因此 number 类型对 Double, Float, Long, Integer, Short 等均不作区分.
+
+```js
+3.0 === 3; // true
+typeof new java.lang.Double(5.23).doubleValue(); // "number"
+```
+
+> 注: 如需表示一个很大的数 (超过 `2^53 - 1`), 需要用 [BigInt](glossaries#bigint) 表示.  
+> 文档中通常不会出现 `bigint` 类型的数据, 包括 `number | bigint` 这样的 [联合类型](#联合类型) 数据.
+
+## String
+
+字符串类型.
+
+常用以下表示方法:
+
+- `"hello"` - 成对双引号 (`"`)
+- `'hello'` - 成对单引号 (`'`)
+- `&#96;hello&#96;` - 成对反引号 (`&#96;`)
+    - 参阅: [模板字符串](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Template_literals)
+- `转义字符`
+    - 如 `\n`, `\r`, `\uXXXX`, `\xXX` 等
+    - 参阅: [转义字符](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/String#%E8%BD%AC%E4%B9%89%E5%AD%97%E7%AC%A6)
+
+**foo(bar)**
+
+- **bar** { [string](#string) }
+
+```js
+foo("3"); /* 符合预期. */
+foo('3.3'); /* 符合预期. */
+foo(`3e3 equals to ${3000}`); /* 符合预期. */
+foo(NaN.toString()); /* 符合预期. */
+```
+
+## Array
+
+数组类型.
+
+后缀 "[]" 代表数组类型.  
+如 `number[]` 代表一个数组, 其中的元素全部为 [number](#number) 类型, 且元素数量不限 (包括 0, 即空数组).
+
+> 注: `number[]` 与 `[number]` 不同, 后者表示 [元组类型](#tuple).
+
+> 注: 使用 `Array<T>` 这样的 [泛型](#generic) 表示法也可代表数组类型, 但文档通常只采用后缀表示法.
+
+**foo(bar)**
+
+- **bar** { [string[]](#array) }
+
+```js
+foo([ "3" ]); /* 符合预期. */
+foo([ 3 ]); /* 不符合预期. */
+foo([ "3", 3 ]); /* 不符合预期. */
+foo([]); /* 符合预期. */
+```
+
+## Tuple
+
+元组类型.
+
+元组类型严格限制数组的对应类型及元素数量.  
+如 `[ number, number, string, number ]` 有如下限制:  
+&#45; &#45; 数组有且必有 4 个元素;  
+&#45; &#45; 元素类型依次为 number, number, string, number.
+
+> 注: 需额外注意元组类型与 JSDoc 表示数组方法的异同.  
+> 另外 JavaScript 中没有元组的概念.
+
+**foo(bar)**
+
+- **bar** { [&#91;](#tuple) [string](#string), [number](#number) [&#93;](#tuple) }
+
+```js
+foo([ "3" ]); /* 不符合预期. */
+foo([ 3 ]); /* 不符合预期. */
+foo([ "3", 3 ]); /* 符合预期. */
+foo([]); /* 不符合预期. */
+```
+
+## Function
+
+函数类型.
+
+文档采用 [箭头函数](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Functions/Arrow_functions) 表示一个函数参数.
+
+**foo(bar)**
+
+- **bar** { [() =>](#function) [number](#number) }
+
+上述 [方法签名](documentation#方法签名) 中, bar 为函数参数, 该函数是一个无参函数且返回值为 number 类型.
+
+```js
+foo(Math.random()); /* 不符合预期. */
+
+foo(function () {
+    return Math.random();
+}); /* 符合预期. */
+
+foo(function () {
+    return 'hello';
+}); /* 不符合预期. */
+```
+
+**foo(bar)**
+
+- **bar** { [(a: ](#function)[string](#string)[, b: ](#function)[any](#any)[) => ](#function)[string](#string) }
+
+上述 [方法签名](documentation#方法签名) 中, bar 为函数参数, 该函数包含两个参函数且返回值为 string 类型.
+
+```js
+/* 参数 a 为 string 类型, b 为 any 类型. */
+foo(function (a, b) {
+    return a + String(b); /* 字符串拼接. */
+}); /* 符合预期. */
+```
+
+## RegExp
+
+正则表达式类型.
+
+**foo(bar)**
+
+- **bar** { [RegExp](#regexp) }
+
+上述 [方法签名](documentation#方法签名) 中, bar 为正则表达式参数, 是 JavaScript 标准 RegExp 类型:
+
+1. 字面量
+
+   `foo(/hello.+world?/)`
+
+2. RegExp 构造器
+
+   `new RegExp('hello.+world?')`
+
+> 参阅: [MDN](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/RegExp)
+
+## Any
+
+任意类型.
+
+类型 any 能够兼容所有类型.
+
+**foo(bar)**
+
+- **bar** { [any](#any) }
+
+```js
+foo(3); /* 符合预期. */
+foo([]); /* 符合预期. */
+foo({}); /* 符合预期. */
+foo(null); /* 符合预期. */
+```
+
+尽管 any 可以兼容所有类型, 但仍需提供一个具体的类型, 不能省略:
+
+```js
+foo(); /* 不符合预期. */
+foo(undefined); /* 符合预期. */
+```
+
+## Void
+
+此类型用于表示一个函数没有返回值.
+
+### 作为函数体返回值
+
+**foo(bar)**
+
+- **bar** { [any](#any) }
+- <ins>**returns**</ins> { [void](#void) }
+
+Void 作为 foo 函数体的返回值类型, 表示 foo 函数没有返回值:
+
+```js
+function foo() {
+    console.log("hello");
+} /* 符合预期. */
+
+function foo() {
+    return "hello";
+} /* 不符合预期. */
+```
+
+### 作为参数返回值
+
+**foo(bar)**
+
+- **bar** { [() =>](#function) [void](#void) }
+
+上述 [方法签名](documentation#方法签名) 中, bar 为函数参数,  
+void 并非表示要求其返回值为 void,  
+它表示 bar 返回的所有值均被忽略 (即不被关心).
+
+```js
+let arr = [];
+foo(() => arr.push(Math.random())); /* 符合预期. */
+console.log(arr);
+```
+
+### Void 与 Undefined
+
+**foo(bar)**
+
+- **bar** { [string](#string) }
+- <ins>**returns**</ins> { [void](#void) }
+
+在 JavaScript 中, 没有 return 语句的函数将默认返回 [undefined](#undefined).  
+因此对于函数体, 返回值为 void 相当于 undefined:
+
+```js
+foo(() => {
+    return;
+}) /* 符合预期. */;
+
+foo(() => {
+    return undefined;
+}) /* 符合预期. */;
+
+foo(() => {
+    // Empty body.
+}) /* 符合预期. */;
+
+foo(() => {
+    return 3;
+}) /* 不符合预期. */;
+```
+
+**foo(bar, baz)**
+
+- **bar** { [() =>](#function) [void](#void) }
+- **baz** { [() =>](#function) [undefined](#undefined) }
+
+对于函数参数, 返回值 void 与 返回值 undefined 意义不同.  
+void 表示返回的所有值均被忽略 (参阅 [作为参数返回值](#作为参数返回值)),  
+而 undefined 表示返回值必须为 undefined 类型.
+
+```js
+foo(
+    /* bar = */ () => {
+        return;
+    }, /* 符合预期. */
+    /* baz = */ () => {
+        return;
+    }, /* 符合预期. */
+);
+
+foo(
+    /* bar = */ () => {
+        return undefined;
+    }, /* 符合预期. */
+    /* baz = */ () => {
+        return undefined;
+    }, /* 符合预期. */
+);
+
+foo(
+    /* bar = */ () => {
+        // Empty body.
+    }, /* 符合预期. */
+    /* baz = */ () => {
+        // Empty body.
+    }, /* 符合预期. */
+);
+
+foo(
+    /* bar = */ () => {
+        return 3;
+    }, /* 符合预期. */
+    /* baz = */ () => {
+        return 3;
+    }, /* 不符合预期. */
+);
+```
+
+> 注: 上述方法签名如果将 void 替换为 any, 就 bar 参数是否符合预期方面而言, 效果是相同的.  
+> 然而两者在语义上有明确不同, void 表示不关心 bar 的返回值, 而 any 表示任意返回值类型均可接受.  
+> 在设计自定义 API 或设计 TS 声明文件时, 上述区分将显得尤为重要.
+
+## Never
+
+## Object
+
+### 字面量对象类型
+
+{{ a: number }}
+
+## Generic
+
+## Null
+
+> 参阅: [MDN #术语](https://developer.mozilla.org/zh-CN/docs/Glossary/Null/) / [MDN #操作符](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/null/) / [MDN #Nullish](https://developer.mozilla.org/zh-CN/docs/Glossary/Nullish/)
+
+## Undefined
+
+```js
+// device.vibrate(text: string, delay?: number): void
+typeof device.vibrate("hello") === "undefined"; // true
+```
+
+> 参阅: [MDN #术语](https://developer.mozilla.org/zh-CN/docs/Glossary/undefined/) / [MDN #全局对象](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/undefined/)
+
+## RegExPattern
+
+正则表达式模式类型.
+
+通常只在 [操纵泛型](#pattern) 中使用.
+
+**foo(bar)**
+
+- **bar** { [Pattern](#pattern)[<](#generic)[/^\d+$/](#regexp)[>](#generic) }
+
+```js
+foo("1"); /* 符合预期. */
+foo("123"); /* 符合预期. */
+foo("hello"); /* 不符合预期. */
+foo("1e3"); /* 不符合预期. */
+foo("1.3"); /* 不符合预期. */
+```
+
+## 联合类型
+
+# 操作符
+
+## in
+
+## keyof
+
+## typeof
+
+## extends
+
+## index
+
+## condition
+
+## readonly
+
+# 操纵泛型
+
+例如 Array<T>
+
+## Uppercase
+
+**Uppercase&lt;T>: string**
+
+通常用于输出转换.  
+接受 string 类型并生成所有字母大写的同类型数据.
+
+## Lowercase
+
+**Lowercase&lt;T>: string**
+
+通常用于输出转换.  
+接受 string 类型并生成所有字母小写的同类型数据.
+
+## Capitalize
+
+**Capitalize&lt;T>: string**
+
+通常用于输出转换.  
+接受 string 类型并生成首字母大写的同类型数据.
+
+```js
+
+```
+
+## IgnoreCase
+
+**IgnoreCase&lt;T extends string>: T**
+
+通常用于输出转换.  
+接受 string 类型并生成忽略大小写的同类型数据.
+
+例如, 对于 IgnoreCase<"webUrl">, 以下数据均符合预期:
+
+```js
+[ "webUrl", "WEBURL", "WebUrl", "WEBurl" ];
+```
+
+但不能在字符串前后或内部插入其他字符,  
+如 [ "WEB_URL" / "web-url" / "#WebUrl" ] 等.
+
+## Pattern
+
+**Pattern&lt;[T](#generic) [extends](#extends) [RegExPattern](#regexpattern)>: [string](#string)**
+
+通常用于输入检查.  
+接受 [正则表达式字面量](glossaries#正则表达式) 并生成通过测试的 [string](#string) 类型数据.
+
+Pattern 的泛型通配符 T 在文档中也称作 [字符串模式](glossaries#字符串模式).
+
+**foo(bar)**
+
+- **bar** { [Pattern](#pattern)[<](#generic)[/^https?:/](#regexpattern)[>](#generic) }
+
+```js
+foo("http is an abbreviation."); /* 不符合预期. */
+foo("https://xxx"); /* 符合预期. */
+foo("ftp://xxx"); /* 不符合预期. */
+```
+
+支持 [标记参数](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Guide/Regular_Expressions#%E9%80%9A%E8%BF%87%E6%A0%87%E5%BF%97%E8%BF%9B%E8%A1%8C%E9%AB%98%E7%BA%A7%E6%90%9C%E7%B4%A2):
+
+**foo(bar)**
+
+- **bar** { [Pattern](#pattern)[<](#generic)[/^h...[oy]/i](#regexpattern)[>](#generic) }
+
+```js
+foo("Happy"); /* 符合预期. */
+foo("hello"); /* 符合预期. */
+foo("Halloween"); /* 符合预期. */
+foo("history"); /* 符合预期. */
+foo("heroes"); /* 不符合预期. */
+```
+
+为便于理解或重复引用, 有些 Pattern 类型会被重新定义为自定义类型, 如 [NumberString](dataTypes#numberstring).
+
+> 注: 目前 (2022/08) 在 JSDoc 及 TypeScript 中,  
+> 均不存在使用正则表达式字面量检查字符串的类型检查 (参阅 [StackOverflow](https://stackoverflow.com/questions/51445767/how-to-define-a-regex-matched-string-type-in-typescript)),  
+> 上述 Pattern 类型仅适用于对文档内容的辅助理解.
+
+## JavaArray
+
+Java Array (Java 数组).
+
+```js
+let javaArr = java.lang.reflect.Array
+    .newInstance(java.lang.Float.TYPE, 3);
+
+console.log(util.isJavaArray(javaArr)); // true
+console.log(Array.isArray(javaArr)); // false
+```
+
+Java 数组可使用 JavaScript 数组的属性及方法:
+
+```js
+let javaArr = java.lang.reflect.Array
+    .newInstance(java.lang.Float.TYPE, 3);
+
+console.log(javaArr.length); // 3
+
+console.log(javaArr.slice === Array.prototype.slice); // true
+Array.isArray(javaArr.slice(0)); // true
+```
+
+Java 数组一旦被初始化, 长度将不可改变, [ 改变长度 / 越界赋值 ] 均会失败且抛出异常:
+
+```js
+let javaArr = java.lang.reflect.Array
+    .newInstance(java.lang.Float.TYPE, 3);
+
+/* 静默失败. */
+javaArr.length = 20;
+console.log(javaArr.length); // 3
+
+/* push 或 unshift 导致越界抛出异常. */
+javaArr.push(9); /* Error. */
+javaArr.unshift(9); /* Error. */
+
+/* pop 或 shift 不抛出异常但不改变数组长度. */
+javaArr.pop();
+console.log(javaArr.length); // 3
+javaArr.shift();
+console.log(javaArr.length); // 3
+
+/* 越界访问不抛出异常, 会返回 undefined. */
+console.log(javaArr[9]); // undefined
+
+/* 越界赋值将抛出异常. */
+javaArr[9] = 10; /* Error. */
+```
+
+Java 数组中的元素将隐式转换为指定的类型, 同时此类型也会被转换为 JavaScript 类型, 如 Java 的 Integer 等均转换为 Number:
+
+```js
+let javaArr = java.lang.reflect.Array
+    .newInstance(java.lang.Integer.TYPE, 3);
+
+console.log(javaArr.join()); // '0,0,0'
+
+/* Number('1a') -> NaN */
+javaArr[0] = '1a';
+console.log(javaArr[0]); // NaN
+
+/* Number('2.2') -> 2.2 $ JS */
+/* java.lang.Integer(2.2 $ JS) -> 2 $ Java */
+/* Number(2 $ Java) -> 2 $ JS */
+javaArr[2] = '2.2';
+console.log(javaArr[0]); // 2
+
+/* 0xFF $ Hexadecimal == 255 $ Decimal / JS */
+/* java.lang.Integer(255 $ JS) -> 255 $ Java */
+/* Number(255 $ Java) -> 255 $ JS */
+javaArr[0] = 0xFF;
+console.log(javaArr[0]); // 255
+```
+
+> 参阅: [Oracle Docs](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/arrays.html)
+
+## JavaArrayList
+
+Java ArrayList (Java 数组列表).
+
+与 [Java Array](#javaarray) 不同的是, ArrayList 创建的数组可调整大小:
+
+```js
+let arrList = new java.util.ArrayList();
+
+arrList.add(10);
+arrList.add('20');
+arrList.add([ '30' ]);
+arrList.add(/40/g);
+
+console.log(arrList.length); // 4
+
+arrList.forEach((o) => {
+    // 10 (Number)
+    // 20 (String)
+    // 30 (Array)
+    // /40/g (RegExp)
+    console.log(`${o} (${species(o)})`);
+});
+
+arrList.addAll(arrList);
+console.log(arrList.length); // 8
+
+arrList.clear();
+console.log(arrList.length); // 0
+```
+
+> 参阅: [Oracle Docs](https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html)
+
+# 自定义类型
+
+## NumberString
+
+数字字符串.
+
+[字符串模式](glossaries#字符串模式): `/[+-]?(\d+(\.\d+)?(e\d+)?)/`.
+
+```js
+"12";
+"-5";
+"1.5";
+"1.5e3";
+```
+
+## ScreenMetricNumberX
+
+屏幕横向度量值.
+
+表示方式:
+
+- 数字 { X >= 1 或 X < -1 } - 横向屏幕宽度值
+- 数字 { X > -1 且 X < 1 } - 横向屏幕宽度值的百分比
+- 数字 { X == -1 } - 横向屏幕宽度值本身 (代指值)
+
+例如, 对于下面的参数:
+
+**bottom** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) }
+
+bottom 赋值为 50, 表示 X 坐标为 50.  
+bottom 赋值为 -80, 表示 X 坐标为 -80.  
+bottom 赋值为 0.5, 表示 X 坐标为 50% 横向屏幕宽度, 即 `0.5 * device.width`.  
+bottom 赋值为 -0.1, 表示 X 坐标为 -10% 横向屏幕宽度, 即 `-0.1 * device.width`.  
+bottom 赋值为 -1, 表示 X 坐标为横向屏幕宽度的代指值, 即 `device.width`.
+
+## ScreenMetricNumberY
+
+屏幕纵向度量值.
+
+表示方式:
+
+- 数字 { Y >= 1 或 Y < -1 } - 纵向屏幕高度值
+- 数字 { Y > -1 且 Y < 1 } - 纵向屏幕高度值的百分比
+- 数字 { Y == -1 } - 纵向屏幕高度值本身 (代指值)
+
+例如, 对于下面的参数:
+
+**top** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) }
+
+top 赋值为 50, 表示 Y 坐标为 50.  
+top 赋值为 -80, 表示 Y 坐标为 -80.  
+top 赋值为 0.5, 表示 Y 坐标为 50% 纵向屏幕高度, 即 `0.5 * device.height`.  
+top 赋值为 -0.1, 表示 Y 坐标为 -10% 纵向屏幕高度, 即 `-0.1 * device.height`.  
+top 赋值为 -1, 表示 Y 坐标为纵向屏幕高度的代指值, 即 `device.height`.
+
+---
+
+## OpencvPoint
+
+org.opencv.core.Point 别名.
+表示一个点, 作为控件信息时则表示点在屏幕的相对位置.
+
+```js
+let point = pickup(/.+/, '.');
+console.log(`${point.x}, ${point.y}`);
+```
+
+部分属性或方法:
+
+- `[p#]` [x](#p-x)
+- `[p#]` [y](#p-y)
+
+常见可以返回此类型的方法:
+
+- [UiSelector.pickup](uiSelectorType#m-pickup)
+
+> 参阅: [OpenCV Docs](https://docs.opencv.org/4.x/javadoc/org/opencv/core/Point.html)
+
+---
+
+<p style="font: bold 2em sans-serif; color: #FF7043">org.opencv.core.Point</p>
+
+---
+
+### [C] org.opencv.core.Point
+
+#### [c] (x, y)
+
+- **x** { [number](dataTypes#number) } - 点 X 坐标
+- **y** { [number](dataTypes#number) } - 点 Y 坐标
+- <ins>**returns**</ins> { [org.opencv.core.Point](#c-orgopencvcorepoint) }
+
+生成一个点.
+
+```js
+console.log(new org.opencv.core.Point(10, 20)); // {10.0, 20.0}
+```
+
+坐标不会被化为整型:
+
+```js
+console.log(new org.opencv.core.Point(10.8, 20.44)); // {10.8, 20.44}
+```
+
+#### [c] ()
+
+- <ins>**returns**</ins> { [org.opencv.core.Point](#c-orgopencvcorepoint) }
+
+生成一个点, 并初始化为 `{0, 0}` 坐标.
+
+```js
+console.log(new org.opencv.core.Point()); // {0.0, 0.0}
+```
+
+#### [c] (points)
+
+- **points** { [number](dataTypes#number)[[]](dataTypes#array) } - 点坐标数组
+- <ins>**returns**</ins> { [org.opencv.core.Point](#c-orgopencvcorepoint) }
+
+生成一个点, 并按指定参数初始化坐标.
+
+两个坐标:
+
+```js
+console.log(new org.opencv.core.Point([ 5, 23 ])); // {5.0, 23.0}
+```
+
+一个坐标, 此坐标作为 X 坐标, Y 坐标初始化为 0:
+
+```js
+console.log(new org.opencv.core.Point([ 5 ])); // {5.0, 0.0}
+```
+
+空数组, X 与 Y 坐标均为 0:
+
+```js
+console.log(new org.opencv.core.Point([])); // {0.0, 0.0}
+```
+
+超过两个坐标, 多余坐标将被忽略:
+
+```js
+console.log(new org.opencv.core.Point([ 5, 23, 7, 8, 9 ])); // {5.0, 23.0}
+```
+
+### [p#] x
+
+- { [number](dataTypes#number) }
+
+点 X 坐标.
+
+如: Point(**180**, 440) 表示点距屏幕左边缘 180 像素.
+
+### [p#] y
+
+- { [number](dataTypes#number) }
+
+点 Y 坐标.
+
+如: Point(180, **440**) 表示点距屏幕上边缘 440 像素.
+
+---
+
+## OpencvSize
+
+org.opencv.core.Size 别名.
+表示一个长宽尺寸对象, 作为控件信息时则表示控件矩形在屏幕的控件占用尺寸.
+
+```js
+let size = pickup(/.+/, 'size');
+console.log(`${size.width}x${size.height}`);
+```
+
+部分属性或方法:
+
+* `[p#]` [x](#p-width)
+* `[p#]` [y](#p-height)
+
+常见可以返回此类型的方法:
+
+- [UiObject.size](uiobjectType#m-size)
+
+> 参阅: [OpenCV Docs](https://docs.opencv.org/4.x/javadoc/org/opencv/core/Size.html)
+
+---
+
+<p style="font: bold 2em sans-serif; color: #FF7043">org.opencv.core.Size</p>
+
+---
+
+### [C] org.opencv.core.Size
+
+#### [c] (width, height)
+
+- **width** { [number](dataTypes#number) } - 宽度值
+- **height** { [number](dataTypes#number) } - 高度值
+- <ins>**returns**</ins> { [org.opencv.core.Size](#c-orgopencvcoresize) }
+
+生成一个尺寸对象.
+
+```js
+console.log(new org.opencv.core.Size(100, 200)); // 100x200
+```
+
+坐标不会被化为整型:
+
+```js
+/* 打印时, 数值会转换为整数. */
+console.log(new org.opencv.core.Size(1.8, 3.2)); // 1x3
+/* 但获取宽高值时, 依然保留原始值, 不会被化为整型. */
+console.log(new org.opencv.core.Size(1.8, 3.2).width); // 1.8
+console.log(new org.opencv.core.Size(1.8, 3.2).height); // 3.2
+```
+
+#### [c] ()
+
+- <ins>**returns**</ins> { [org.opencv.core.Size](#c-orgopencvcoresize) }
+
+生成一个尺寸对象, 并初始化为 `0x0` 宽高尺寸.
+
+```js
+console.log(new org.opencv.core.Size()); // 0x0
+```
+
+#### [c] (point)
+
+- **point** { [OpencvPoint](#opencvpoint) } - 用于表示尺寸的 "点"
+- <ins>**returns**</ins> { [org.opencv.core.Size](#c-orgopencvcoresize) }
+
+生成一个尺寸对象, 并按参数初始化宽高尺寸.
+
+```js
+const { Size, Point } = org.opencv.core;
+console.log(new Size(new Point(5, 23))); // 5x23
+```
+
+#### [c] (dimensions)
+
+- **dimensions** { [number](dataTypes#number)[[]](dataTypes#array) } - 尺寸值数组
+- <ins>**returns**</ins> { [org.opencv.core.Size](#c-orgopencvcoresize) }
+
+生成一个尺寸对象, 并按指定参数初始化宽高尺寸.
+
+两个尺寸值:
+
+```js
+console.log(new org.opencv.core.Size([ 5, 23 ])); // 5x23
+```
+
+一个尺寸值, 此尺寸值作为宽度值, 高度值初始化为 0:
+
+```js
+console.log(new org.opencv.core.Size([ 5 ])); // 5x0
+```
+
+空数组, 宽度尺寸值均为 0:
+
+```js
+console.log(new org.opencv.core.Size([])); // 0x0
+```
+
+超过两个尺寸值, 多余尺寸值将被忽略:
+
+```js
+console.log(new org.opencv.core.Size([ 5, 23, 7, 8, 9 ])); // 5x23
+```
+
+### [p#] width
+
+- { [number](dataTypes#number) }
+
+尺寸宽度值.
+
+### [p#] height
+
+- { [number](dataTypes#number) }
+
+尺寸高度值.
+
+---
+
+## AndroidRect
+
+android.graphics.Rect 别名.  
+表示一个矩形, 作为控件信息时则用于表示控件在屏幕的相对位置及空间范围, 又称 **控件矩形**.
+
+```js
+let bounds = pickup(/.+/, 'bounds');
+console.log(`${bounds.centerX()}, ${bounds.centerY()}`);
+```
+
+部分属性或方法:
+
+- `[p#]` [left](#p-left)
+- `[p#]` [top](#p-top)
+- `[p#]` [right](#p-right)
+- `[p#]` [bottom](#p-bottom)
+- `[m#]` [width()](#m-width)
+- `[m#]` [height()](#m-height)
+- `[m#]` [centerX()](#m-centerx)
+- `[m#]` [centerY()](#m-centery)
+- `[m#]` [exactCenterX()](#m-exactcenterx)
+- `[m#]` [exactCenterY()](#m-exactcentery)
+- `[m#]` [contains()](#m-contains)
+- `[m#]` [intersect()](#m-intersect)
+- `[m#]` [intersects()](#m-intersects)
+
+常见可以返回此类型的方法:
+
+- [UiObject#bounds](uiObjectType#m-bounds)
+- [UiSelector.pickup](uiSelectorType#m-pickup)
+
+> 参阅: [Android Docs](https://developer.android.com/reference/android/graphics/Rect)
+
+---
+
+<p style="font: bold 2em sans-serif; color: #FF7043">android.graphics.Rect</p>
+
+---
+
+### [C] android.graphics.Rect
+
+#### [c] (left, top, right, bottom)
+
+- **left** { [number](dataTypes#number) } - 矩形左边界 X 坐标
+- **top** { [number](dataTypes#number) } - 矩形上边界 Y 坐标
+- **right** { [number](dataTypes#number) } - 矩形右边界 X 坐标
+- **bottom** { [number](dataTypes#number) } - 矩形下边界 Y 坐标
+- <ins>**returns**</ins> { [android.graphics.Rect](#c-androidgraphicsrect) }
+
+生成一个矩形.
+
+```js
+let rect = new android.graphics.Rect(10, 20, 80, 90);
+console.log(rect); // Rect(10, 20 - 80, 90)
+```
+
+如果坐标值为浮点数, 将做向下取整处理:
+
+```js
+let rect = new android.graphics.Rect(10.2, 20.7, 80.1, 90.92);
+console.log(rect); // Rect(10, 20 - 80, 90)
+```
+
+坐标值可以为 0 或负数:
+
+```js
+let rect = new android.graphics.Rect(0, 0, -80, -90);
+console.log(rect); // Rect(0, 0 - -80, -90)
+```
+
+#### [c] ()
+
+- <ins>**returns**</ins> { [android.graphics.Rect](#c-androidgraphicsrect) }
+
+生成一个空矩形.
+
+```js
+let rect = new android.graphics.Rect();
+console.log(rect); // Rect(0, 0 - 0, 0)
+```
+
+#### [c] (rect)
+
+- **rect** { [android.graphics.Rect](#c-androidgraphicsrect) } - 参照矩形
+- <ins>**returns**</ins> { [android.graphics.Rect](#c-androidgraphicsrect) }
+
+生成一个新矩形, 并按照参照矩形的参数初始化.
+
+```js
+let rectA = new android.graphics.Rect(10, 20, 80, 90);
+let rectB = new android.graphics.Rect(rectA);
+console.log(rectB); // Rect(10, 20 - 80, 90)
+rectB.top = 1;
+rectB.bottom = 0;
+console.log(rectB); // Rect(10, 1 - 80, 0)
+console.log(rectA); // Rect(10, 20 - 80, 90)
+```
+
+### [p#] left
+
+- { [number](dataTypes#number) }
+
+矩形左边界 X 坐标.
+
+如: Rect(**180**, 440, 750, 1200) 表示矩形左边界距屏幕左边缘 180 像素.
+
+### [p#] top
+
+- { [number](dataTypes#number) }
+
+矩形上边界 Y 坐标.
+
+如: Rect(180, **440**, 750, 1200) 表示矩形上边界距屏幕上边缘 440 像素.
+
+### [p#] right
+
+- { [number](dataTypes#number) }
+
+矩形右边界 X 坐标.
+
+如: Rect(180, 440, **750**, 1200) 表示矩形右边界距屏幕左边缘 750 像素.
+
+### [p#] bottom
+
+- { [number](dataTypes#number) }
+
+矩形下边界 Y 坐标.
+
+如: Rect(180, 440, 750, **1200**) 表示矩形下边界距屏幕上边缘 1200 像素.
+
+### [m#] width
+
+#### width()
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+矩形宽度.
+
+```js
+let rect = new android.graphics.Rect(180, 440, 750, 1200);
+console.log(rect.width()); // 570
+```
+
+宽度可能为 0 或负数:
+
+```js
+let rectA = new android.graphics.Rect(0, 440, 0, 1200);
+console.log(rectA.width()); // 0
+let rectB = new android.graphics.Rect(30, 440, 10, 1200);
+console.log(rectB.width()); // -20
+```
+
+### [m#] height
+
+#### height()
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+矩形高度.
+
+```js
+let rect = new android.graphics.Rect(180, 440, 750, 1200);
+console.log(rect.height()); // 760
+```
+
+高度可能为 0 或负数:
+
+```js
+let rectA = new android.graphics.Rect(180, 1200, 750, 1200);
+console.log(rectA.height()); // 0
+let rectB = new android.graphics.Rect(180, 40, 750, 10);
+console.log(rectB.height()); // -30
+```
+
+### [m#] centerX
+
+#### centerX()
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+矩形中点 X 坐标 (向下取整).
+
+```js
+let rectA = new android.graphics.Rect(180, 440, 750, 1200);
+console.log(rectA.centerX()); // 465
+
+let rectB = new android.graphics.Rect(100, 200, 101, 201);
+console.log(rectB.centerX()); // 100
+```
+
+### [m#] centerY
+
+#### centerY()
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+矩形中点 Y 坐标 (向下取整).
+
+```js
+let rectA = new android.graphics.Rect(180, 440, 750, 1200);
+console.log(rectA.centerY()); // 820
+
+let rectB = new android.graphics.Rect(100, 200, 101, 201);
+console.log(rectB.centerY()); // 200
+```
+
+### [m#] exactCenterX
+
+#### exactCenterX()
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+矩形中点 X 坐标 (浮点数).
+
+```js
+let rectA = new android.graphics.Rect(180, 440, 750, 1200);
+console.log(rectA.exactCenterX()); // 465
+
+let rectB = new android.graphics.Rect(100, 200, 101, 201);
+console.log(rectB.exactCenterX()); // 100.5
+```
+
+### [m#] exactCenterY
+
+#### exactCenterY()
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+矩形中点 Y 坐标 (浮点数).
+
+```js
+let rectA = new android.graphics.Rect(180, 440, 750, 1200);
+console.log(rectA.exactCenterY()); // 820
+
+let rectB = new android.graphics.Rect(100, 200, 101, 201);
+console.log(rectB.exactCenterY()); // 200.5
+```
+
+### [m#] contains
+
+#### contains(rect)
+
+- **rect** { [android.graphics.Rect](#c-androidgraphicsrect) } - 参照矩形
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+返回是否包含另一个矩形.  
+参照矩形的所有边均在当前矩形内 (包含边重叠情况) 则满足包含条件.  
+空矩形与任何矩形不存在包含关系.
+
+```js
+let rectThis = new android.graphics.Rect(180, 440, 750, 1200);
+
+let rectRefA = new android.graphics.Rect(rectThis);
+console.log(rectThis.contains(rectRefA)); // true
+
+let rectRefB = new android.graphics.Rect(200, 440, 750, 1200);
+console.log(rectThis.contains(rectRefB)); // true
+
+let rectRefC = new android.graphics.Rect(); /* 空矩形. */
+console.log(rectThis.contains(rectRefC)); // false
+```
+
+### [m#] intersect
+
+#### intersect(rect)
+
+- **rect** { [android.graphics.Rect](#c-androidgraphicsrect) } - 参照矩形
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+返回是否与参展矩形相交 (不包括边界或点重叠的情况).  
+如果相交, 则返回 true, **且当前矩形被设置为相交部分的矩形**.
+
+```js
+let rectThis = new android.graphics.Rect(0, 0, 600, 600);
+let rectRef = new android.graphics.Rect(200, 0, 800, 800);
+
+console.log(rectThis.intersect(rectRef)); // true
+
+/* rectThis 被修改. */
+console.log(rectThis); // Rect(200, 0 - 600, 600) 
+```
+
+如果不相交, 则返回 false, 当前矩形不会被修改:
+
+```js
+let rectThis = new android.graphics.Rect(0, 0, 100, 100);
+let rectRef = new android.graphics.Rect(100, 0, 800, 800);
+
+console.log(rectThis.intersect(rectRef)); // false
+
+/* rectThis 保持原来的值. */
+console.log(rectThis); // Rect(0, 0 - 100, 100)
+```
+
+空矩形与任意矩形不相交:
+
+```js
+let rectThis = new android.graphics.Rect(0, 0, 100, 100);
+let rectRef = new android.graphics.Rect();
+console.log(rectThis.intersect(rectRef)); // false
+```
+
+### [m] intersects
+
+#### intersects(rectA, rectB)
+
+- **rect** { [android.graphics.Rect](#c-androidgraphicsrect) } - 参照矩形
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+返回是否和另一个长方形相交.
+
+此方法近判断是否相交, 不改变任何矩形:
+
+```js
+let rectA = new android.graphics.Rect(0, 0, 600, 600);
+let rectB = new android.graphics.Rect(200, 0, 800, 800);
+
+console.log(android.graphics.Rect.intersects(rectA, rectB)); // true
+
+/* rectA 和 refB 均保持原来的值. */
+console.log(rectA); // Rect(0, 0 - 600, 600)
+console.log(rectB); // Rect(200, 0 - 800, 800)
+```
+
+需额外留意 [intersects](#m-intersects) 与 [intersect](#m-intersect) 的区别:
+
+- `[m#] intersect` 为实例方法, `rectA.intersect(rectB)` 需传入一个参数, 当相交时 `rectA` 会被改变, 返回结果为 "是否相交".
+
+- `[m] intersects` 为静态方法, `Rect.intersects(rectA, rectB)` 需传入两个参数, 且不改变任何矩形, 仅返回 "是否相交" 结果.
+
+## AndroidBundle
+
+android.os.Bundle 别名.  
+表示一个会被打包成捆的容器, 容器内可存储 `键值对 (Key-Value Pair)` 形式的数据.
+
+```js
+let bundleA = new android.os.Bundle();
+bundleA.putInt("num_key", 23);
+console.log(bundleA.getInt("num_key") === 23); // true
+
+let bundleB = new android.os.Bundle();
+let arrList = new java.util.ArrayList(2);
+arrList.add("A");
+arrList.add("B");
+bundleB.putStringArrayList("arr_list_key", arrList);
+console.log(bundleB.getStringArrayList("arr_list_key").get(0) === "A"); // true
+console.log(bundleB.getStringArrayList("arr_list_key").get(1) === "B"); // true
+```
+
+> 参阅: [Android Docs](https://developer.android.com/reference/android/os/Bundle)
+
+## DetectCompass
+
+用于传递给 [控件罗盘](uiObjectType#m-compass) 的参数类型, 又称 `罗盘参数`.
+
+罗盘参数是 [字符串](dataTypes#string) 类型, 支持单独或组合使用.
+
+下面列举了部分罗盘参数示例:
+
+- `p` - 父控件
+- `p2` - 二级父控件
+- `c0` - 索引 0 (首个) 子控件
+- `c2` - 索引 2 子控件
+- `c-1` - 末尾子控件
+- `s5` - 索引 5 兄弟控件
+- `s-2` - 倒数第 2 兄弟控件
+- `s<1` - 相邻左侧兄弟节点
+- `s>1` - 相邻右侧兄弟节点
+- `k2` - 向上寻找可点击控件 (最多 2 级)
+- `p4c0>1>1>0s0` - 组合使用
+
+[控件罗盘 (UiObject.compass)](uiObjectType#m-compass) 是 [控件探测 (UiObject.detect)](uiObjectType#m-detect) 的衍生方法, 因此类型命名采用了 `DetectCompass`.
+
+## DetectResult
+
+[控件探测 (UiObject.detect)](uiObjectType#m-detect) 的结果参数类型, 又称 `探测结果`, 此过程也称为 `结果筛选`.
+
+- `# / w / widget` - [控件](uiObjectType)
+- `$ / txt / content` - [文本内容](uiObjectType#m-content)
+- `. / pt / point` - [点](uiObjectType#m-point)
+- `UiObjectInvokable` - [控件可调用类型](#uiobjectinvokable)
+
+```js
+/* 控件. */
+detect(w, '#');
+detect(w, 'w'); /* 同上. */
+detect(w, 'widget'); /* 同上. */
+
+/* 文本内容. */
+detect(w, '$');
+detect(w, 'txt'); /* 同上. */
+detect(w, 'content'); /* 同上. */
+
+/* 点. */
+detect(w, '.');
+detect(w, 'pt'); /* 同上. */
+detect(w, 'point'); /* 同上. */
+
+/* UiObjectInvokable (控件可调用类型). */
+detect(w, 'click'); /* i.e. w.click() */
+detect(w, [ 'setText', 'hello' ]); /* i.e. w.setText('hello') */
+```
+
+不同于 [PickupResult (拾取结果)](#pickupresult), `探测结果` 的种类相对较少.
+
+## DetectCallback
+
+探测回调.
+
+探测回调用于处理 [控件探测 (UiObject.detect)](uiObjectType#m-detect) 的结果.
+
+`回调结果` 将影响 `探测结果`, 当 `回调结果` 返回 `undefined` 时, 将直接返回 `探测结果`, 否则返回 `回调结果`:
+
+```ts
+function detect<T extends UiObject, R>(w: T, callback: (w: T) => R): T | R {
+    let callbackResult: R = callback(w);
+    return callbackResult == undefined ? w : callbackResult;
+}
+```
+
+示例:
+
+```js
+let w = pickup(/.+/);
+
+/* 返回 w.content() 的结果. */
+detect(w, (w) => w.content());
+
+/* 返回 w 的结果. */
+detect(w, (w) => {
+    console.log(w.content());
+});
+```
+
+## PickupSelector
+
+[拾取选择器](uiSelectorType#m-pickup) 的 `选择器参数`.
+
+`选择器参数` 的类型分为 [单一型选择器](#单一型选择器) 和 [混合型选择器](#混合型选择器).
+
+### 单一型选择器
+
+单一型选择器包含 [ [经典选择器](#经典选择器) / [内容选择器](#内容选择器) / [对象选择器](#对象选择器) ].
+
+#### 经典选择器
+
+`text('abc')` 或串联形式 `text('abc').clickable().centerX(0.5)`.
+
+#### 内容选择器
+
+字符串 `'abc'` 或正则表达式 `/abc/`.  
+相当于 `content('abc')` 及 `contentMatch(/abc/)`.
+
+#### 对象选择器
+
+将选择器名称作为 `键 (key)`, 选择器参数作为 `值 (value)`.  
+若参数多于 1 个, 使用数组包含所有参数; 若无参数, 使用 `[]` (空数组) 或 `null`, 或默认值 (如 `true`).  
+虽然一个参数也可使用数组, 但通常无必要.
+
+```js
+/* 经典选择器. */
+let selClassic = text('abc').clickable().centerX(0.5).boundsInside(0.2, 0.05, -1, -1).action('CLICK', 'SET_TEXT', 'LONG_CLICK');
+
+/* 对象选择器. */
+let selObject = {
+    text: 'abc',
+    clickable: [], /* 或 clickable: true . */
+    centerX: 0.5,
+    boundsInside: [ 0.2, 0.05, -1, -1 ],
+    action: [ 'CLICK', 'SET_TEXT', 'LONG_CLICK' ],
+};
+```
+
+### 混合型选择器
+
+混合型选择器由多个单一型选择器组成.
+
+用数组表示一个混合型选择器, 其中的元素为单一型选择器:
+
+```js
+pickup([ /he.+/, clickable(true).boundsInside(0.2, 0.05, -1, -1) ]);
+```
+
+上述示例的选择器参数使用了混合型选择器, 它包含两个单一型选择器, 分别为 [内容选择器](#内容选择器) 和 [经典选择器](#经典选择器).
+
+上述示例可以转换为单一型选择器:
+
+```js
+/* 对象选择器. */
+pickup({
+    contentMatch: /he.+/,
+    clickable: true,
+    boundsInside: [ 0.2, 0.05, -1, -1 ],
+});
+
+/* 经典选择器. */
+pickup(contentMatch(/he.+/).clickable(true).boundsInside(0.2, 0.05, -1, -1));
+```
+
+## PickupResult
+
+[拾取选择器 (UiSelector#pickup)](uiSelectorType#m-pickup) 的结果参数类型, 又称 `拾取结果`, 此过程也称为 `结果筛选`.
+
+- `# / w / widget` - [控件 (UiObject)](uiObjectType)
+- `{} / #{} / {#} / w{} / {w} / wc / collection / list` -> [控件集合 (UiObjectCollection)](uiObjectCollectionType)
+- `[] / #[] / [#] / w[] / [w] / ws / widgets` -> [控件 (UiObject)](uiObjectType) 数组
+- `$ / txt / content` - [文本内容 (UiObject#content)](uiObjectType#m-content)
+- `$[] / [$] / txt[] / [txt] / content[] / [content] / contents` -> [文本内容 (UiObject#content)](uiObjectType#m-content) 数组
+- `. / pt / point` - [点 (UiObject#point)](uiObjectType#m-point)
+- `.[] / [.] / point[] / [point] / pt[] / [pt] / points / pts` -> [点 (UiObject#point)](uiObjectType#m-point) 数组
+- `@ / selector / sel` -> [选择器 (UiSelector)](uiSelectorType)
+- `? / exists` -> [存在判断 (UiSelector#exists)](uiSelectorType#m-exists)
+- `UiObjectInvokable` - [控件可调用类型](#uiobjectinvokable)
+
+```js
+/* 控件. */
+pickup(sel, '#');
+pickup(sel, 'w'); /* 同上. */
+pickup(sel, 'widget'); /* 同上. */
+
+/* 文本内容. */
+pickup(sel, '$');
+pickup(sel, 'txt'); /* 同上. */
+pickup(sel, 'content'); /* 同上. */
+
+/* 文本内容数组. */
+pickup(sel, '$[]');
+pickup(sel, 'txt[]'); /* 同上. */
+pickup(sel, '[content]'); /* 同上. */
+pickup(sel, 'contents'); /* 同上. */
+
+/* 点. */
+pickup(sel, '.');
+pickup(sel, 'pt'); /* 同上. */
+pickup(sel, 'point'); /* 同上. */
+
+/* 点数组. */
+pickup(sel, '.[]');
+pickup(sel, '[.]'); /* 同上. */
+pickup(sel, '[point]'); /* 同上. */
+pickup(sel, 'points'); /* 同上. */
+
+/* UiObjectInvokable (控件可调用类型). */
+pickup(sel, 'click'); /* i.e. sel.findOnce().click() */
+pickup(sel, [ 'setText', 'hello' ]); /* i.e. sel.findOnce().setText('hello') */
+```
+
+与 [DetectResult (探测结果)](#detectresult) 相比, `拾取结果` 的种类更加丰富.
+
+## UiObjectInvokable
+
+控件可调用类型, 用于使用参数形式实现方法调用, 又称 `参化调用`.
+
+支持所有 [UiObject](uiObjectType) 的实例方法, 如果方法需要传递参数, 需要将参数连同方法名称放入数组后再传递.
+
+```js
+/* 无参方法. */
+detect(w, 'click'); /* i.e. w.click() */
+detect(w, 'imeEnter'); /* i.e. w.imeEnter() */
+
+/* 含参方法. */
+detect(w, [ 'child', 0 ]); /* i.e. w.child(0) */
+detect(w, [ 'setText', 'hello' ]); /* i.e. w.setText('hello') */
+detect(w, [ 'setSelection', 2, 3 ]); /* i.e. w.setSelection(2, 3) */
+```
\ No newline at end of file
diff --git a/api/device.md b/api/device.md
index f445011..893ed76 100644
--- a/api/device.md
+++ b/api/device.md
@@ -1,22 +1,27 @@
-# Device
+# 设备 (Device)
 
-> Stability: 2 - Stable
+---
 
-device模块提供了与设备有关的信息与操作，例如获取设备宽高，内存使用率，IMEI，调整设备亮度、音量等。
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
 
-此模块的部分函数，例如调整音量，需要"修改系统设置"的权限。如果没有该权限，会抛出`SecurityException`并跳转到权限设置界面。
+---
+
+device模块提供了与设备有关的信息与操作, 例如获取设备宽高, 内存使用率, IMEI, 调整设备亮度、音量等.
+
+此模块的部分函数, 例如调整音量, 需要"修改系统设置"的权限. 如果没有该权限, 会抛出`SecurityException`并跳转到权限设置界面.
 
 ## device.width
 
 * {number}
 
-设备屏幕分辨率宽度。例如1080。
+设备屏幕分辨率宽度. 例如1080.
 
 ## device.height
 
 * {number}
 
-设备屏幕分辨率高度。例如1920。
+设备屏幕分辨率高度. 例如1920.
 
 ## device.buildId
 
@@ -24,7 +29,7 @@ device模块提供了与设备有关的信息与操作，例如获取设备宽
 
 Either a changelist number, or a label like "M4-rc20".
 
-修订版本号，或者诸如"M4-rc20"的标识。
+修订版本号, 或者诸如"M4-rc20"的标识.
 
 ## device.broad
 
@@ -32,7 +37,7 @@ Either a changelist number, or a label like "M4-rc20".
 
 The name of the underlying board, like "goldfish".
 
-设备的主板(?)型号。
+设备的主板(?)型号.
 
 ## device.brand
 
@@ -40,7 +45,7 @@ The name of the underlying board, like "goldfish".
 
 The consumer-visible brand with which the product/hardware will be associated, if any.
 
-与产品或硬件相关的厂商品牌，如"Xiaomi", "Huawei"等。
+与产品或硬件相关的厂商品牌, 如"Xiaomi", "Huawei"等.
 
 ## device.device
 
@@ -48,7 +53,7 @@ The consumer-visible brand with which the product/hardware will be associated, i
 
 The name of the industrial design.
 
-设备在工业设计中的名称。
+设备在工业设计中的名称.
 
 ## device.model
 
@@ -56,7 +61,7 @@ The name of the industrial design.
 
 The end-user-visible name for the end product.
 
-设备型号。
+设备型号.
 
 ## device.product
 
@@ -64,7 +69,7 @@ The end-user-visible name for the end product.
 
 The name of the overall product.
 
-整个产品的名称。
+整个产品的名称.
 
 ## device.bootloader
 
@@ -72,7 +77,7 @@ The name of the overall product.
 
 The system bootloader version number.
 
-设备Bootloader的版本。
+设备Bootloader的版本.
 
 ## device.hardware
 
@@ -80,7 +85,7 @@ The system bootloader version number.
 
 The name of the hardware (from the kernel command line or /proc).
 
-设备的硬件名称(来自内核命令行或者/proc)。
+设备的硬件名称(来自内核命令行或者/proc).
 
 ## device.fingerprint
 
@@ -88,7 +93,7 @@ The name of the hardware (from the kernel command line or /proc).
 
 A string that uniquely identifies this build. Do not attempt to parse this value.
 
-构建(build)的唯一标识码。
+构建(build)的唯一标识码.
 
 ## device.serial
 
@@ -96,7 +101,7 @@ A string that uniquely identifies this build. Do not attempt to parse this value
 
 A hardware serial number, if available. Alphanumeric only, case-insensitive.
 
-硬件序列号。
+硬件序列号.
 
 ## device.sdkInt
 
@@ -104,7 +109,7 @@ A hardware serial number, if available. Alphanumeric only, case-insensitive.
 
 The user-visible SDK version of the framework; its possible values are defined in Build.VERSION_CODES.
 
-安卓系统API版本。例如安卓4.4的sdkInt为19。
+安卓系统API版本. 例如安卓4.4的sdkInt为19.
 
 ## device.incremental
 
@@ -118,7 +123,7 @@ The internal value used by the underlying source control to represent this build
 
 The user-visible version string. E.g., "1.0" or "3.4b5".
 
-Android系统版本号。例如"5.0", "7.1.1"。
+Android系统版本号. 例如"5.0", "7.1.1".
 
 ## device.baseOS
 
@@ -132,7 +137,7 @@ The base OS build the product is based on.
 
 The user-visible security patch level.
 
-安全补丁程序级别。
+安全补丁程序级别.
 
 ## device.codename
 
@@ -140,7 +145,7 @@ The user-visible security patch level.
 
 The current development codename, or the string "REL" if this is a release build.
 
-开发代号，例如发行版是"REL"。
+开发代号, 例如发行版是"REL".
 
 ## device.getIMEI()
 
@@ -152,157 +157,157 @@ The current development codename, or the string "REL" if this is a release build
 
 * {string}
 
-返回设备的Android ID。
+返回设备的Android ID.
 
-Android ID为一个用16进制字符串表示的64位整数，在设备第一次使用时随机生成，之后不会更改，除非恢复出厂设置。
+Android ID为一个用16进制字符串表示的64位整数, 在设备第一次使用时随机生成, 之后不会更改, 除非恢复出厂设置.
 
 ## device.getMacAddress()
 
 * {string}
 
-返回设备的Mac地址。该函数需要在有WLAN连接的情况下才能获取，否则会返回null。
+返回设备的Mac地址. 该函数需要在有WLAN连接的情况下才能获取, 否则会返回null.
 
-**可能的后续修改**：未来可能增加有root权限的情况下通过root权限获取，从而在没有WLAN连接的情况下也能返回正确的Mac地址，因此请勿使用此函数判断WLAN连接。
+**可能的后续修改**：未来可能增加有root权限的情况下通过root权限获取, 从而在没有WLAN连接的情况下也能返回正确的Mac地址, 因此请勿使用此函数判断WLAN连接.
 
 ## device.getBrightness()
 
 * {number}
 
-返回当前的(手动)亮度。范围为0~255。
+返回当前的(手动)亮度. 范围为0~255.
 
 ## device.getBrightnessMode()
 
 * {number}
 
-返回当前亮度模式，0为手动亮度，1为自动亮度。
+返回当前亮度模式, 0为手动亮度, 1为自动亮度.
 
 ## device.setBrightness(b)
 
-* `b` {number} 亮度，范围0~255
+* `b` {number} 亮度, 范围0~255
 
-设置当前手动亮度。如果当前是自动亮度模式，该函数不会影响屏幕的亮度。
+设置当前手动亮度. 如果当前是自动亮度模式, 该函数不会影响屏幕的亮度.
 
-此函数需要"修改系统设置"的权限。如果没有该权限，会抛出SecurityException并跳转到权限设置界面。
+此函数需要"修改系统设置"的权限. 如果没有该权限, 会抛出SecurityException并跳转到权限设置界面.
 
 ## device.setBrightnessMode(mode)
 
-* `mode` {number} 亮度模式，0为手动亮度，1为自动亮度
+* `mode` {number} 亮度模式, 0为手动亮度, 1为自动亮度
 
-设置当前亮度模式。
+设置当前亮度模式.
 
-此函数需要"修改系统设置"的权限。如果没有该权限，会抛出SecurityException并跳转到权限设置界面。
+此函数需要"修改系统设置"的权限. 如果没有该权限, 会抛出SecurityException并跳转到权限设置界面.
 
 ## device.getMusicVolume()
 
 * {number} 整数值
 
-返回当前媒体音量。
+返回当前媒体音量.
 
 ## device.getNotificationVolume()
 
 * {number} 整数值
 
-返回当前通知音量。
+返回当前通知音量.
 
 ## device.getAlarmVolume()
 
 * {number} 整数值
 
-返回当前闹钟音量。
+返回当前闹钟音量.
 
 ## device.getMusicMaxVolume()
 
 * {number} 整数值
 
-返回媒体音量的最大值。
+返回媒体音量的最大值.
 
 ## device.getNotificationMaxVolume()
 
 * {number} 整数值
 
-返回通知音量的最大值。
+返回通知音量的最大值.
 
 ## device.getAlarmMaxVolume()
 
 * {number} 整数值
 
-返回闹钟音量的最大值。
+返回闹钟音量的最大值.
 
 ## device.setMusicVolume(volume)
 
 * `volume` {number} 音量
 
-设置当前媒体音量。
+设置当前媒体音量.
 
-此函数需要"修改系统设置"的权限。如果没有该权限，会抛出SecurityException并跳转到权限设置界面。
+此函数需要"修改系统设置"的权限. 如果没有该权限, 会抛出SecurityException并跳转到权限设置界面.
 
 ## device.setNotificationVolume(volume)
 
 * `volume` {number} 音量
 
-设置当前通知音量。
+设置当前通知音量.
 
-此函数需要"修改系统设置"的权限。如果没有该权限，会抛出SecurityException并跳转到权限设置界面。
+此函数需要"修改系统设置"的权限. 如果没有该权限, 会抛出SecurityException并跳转到权限设置界面.
 
 ## device.setAlarmVolume(volume)
 
 * `volume` {number} 音量
 
-设置当前闹钟音量。
+设置当前闹钟音量.
 
-此函数需要"修改系统设置"的权限。如果没有该权限，会抛出SecurityException并跳转到权限设置界面。
+此函数需要"修改系统设置"的权限. 如果没有该权限, 会抛出SecurityException并跳转到权限设置界面.
 
 ## device.getBattery()
 
 * {number} 0.0~100.0的浮点数
 
-返回当前电量百分比。
+返回当前电量百分比.
 
 ## device.isCharging()
 
 * {boolean}
 
-返回设备是否正在充电。
+返回设备是否正在充电.
 
 ## device.getTotalMem()
 
 * {number}
 
-返回设备内存总量，单位字节(B)。1MB = 1024 * 1024B。
+返回设备内存总量, 单位字节(B). 1MB = 1024 * 1024B.
 
 ## device.getAvailMem()
 
 * {number}
 
-返回设备当前可用的内存，单位字节(B)。
+返回设备当前可用的内存, 单位字节(B).
 
 ## device.isScreenOn()
 
 * 返回 {boolean}
 
-返回设备屏幕是否是亮着的。如果屏幕亮着，返回`true`; 否则返回`false`。
+返回设备屏幕是否是亮着的. 如果屏幕亮着, 返回`true`; 否则返回`false`.
 
-需要注意的是，类似于vivo xplay系列的息屏时钟不属于"屏幕亮着"的情况，虽然屏幕确实亮着但只能显示时钟而且不可交互，此时`isScreenOn()`也会返回`false`。
+需要注意的是, 类似于vivo xplay系列的息屏时钟不属于"屏幕亮着"的情况, 虽然屏幕确实亮着但只能显示时钟而且不可交互, 此时`isScreenOn()`也会返回`false`.
 
 ## device.wakeUp()
 
-唤醒设备。包括唤醒设备CPU、屏幕等。可以用来点亮屏幕。
+唤醒设备. 包括唤醒设备CPU、屏幕等. 可以用来点亮屏幕.
 
 ## device.wakeUpIfNeeded()
 
-如果屏幕没有点亮，则唤醒设备。
+如果屏幕没有点亮, 则唤醒设备.
 
 ## device.keepScreenOn([timeout])
 
-* `timeout` {number} 屏幕保持常亮的时间, 单位毫秒。如果不加此参数，则一直保持屏幕常亮。
+* `timeout` {number} 屏幕保持常亮的时间, 单位毫秒. 如果不加此参数, 则一直保持屏幕常亮.
 
-保持屏幕常亮。
+保持屏幕常亮.
 
-此函数无法阻止用户使用锁屏键等正常关闭屏幕，只能使得设备在无人操作的情况下保持屏幕常亮；同时，如果此函数调用时屏幕没有点亮，则会唤醒屏幕。
+此函数无法阻止用户使用锁屏键等正常关闭屏幕, 只能使得设备在无人操作的情况下保持屏幕常亮；同时, 如果此函数调用时屏幕没有点亮, 则会唤醒屏幕.
 
-在某些设备上，如果不加参数timeout，只能在Auto.js的界面保持屏幕常亮，在其他界面会自动失效，这是因为设备的省电策略造成的。因此，建议使用比较长的时长来代替"一直保持屏幕常亮"的功能，例如`device.keepScreenOn(3600 * 1000)`。
+在某些设备上, 如果不加参数timeout, 只能在Auto.js的界面保持屏幕常亮, 在其他界面会自动失效, 这是因为设备的省电策略造成的. 因此, 建议使用比较长的时长来代替"一直保持屏幕常亮"的功能, 例如`device.keepScreenOn(3600 * 1000)`.
 
-可以使用`device.cancelKeepingAwake()`来取消屏幕常亮。
+可以使用`device.cancelKeepingAwake()`来取消屏幕常亮.
 
 ```
 //一直保持屏幕常亮
@@ -311,23 +316,23 @@ device.keepScreenOn()
 
 ## device.keepScreenDim([timeout])
 
-* `timeout` {number} 屏幕保持常亮的时间, 单位毫秒。如果不加此参数，则一直保持屏幕常亮。
+* `timeout` {number} 屏幕保持常亮的时间, 单位毫秒. 如果不加此参数, 则一直保持屏幕常亮.
 
-保持屏幕常亮，但允许屏幕变暗来节省电量。此函数可以用于定时脚本唤醒屏幕操作，不需要用户观看屏幕，可以让屏幕变暗来节省电量。
+保持屏幕常亮, 但允许屏幕变暗来节省电量. 此函数可以用于定时脚本唤醒屏幕操作, 不需要用户观看屏幕, 可以让屏幕变暗来节省电量.
 
-此函数无法阻止用户使用锁屏键等正常关闭屏幕，只能使得设备在无人操作的情况下保持屏幕常亮；同时，如果此函数调用时屏幕没有点亮，则会唤醒屏幕。
+此函数无法阻止用户使用锁屏键等正常关闭屏幕, 只能使得设备在无人操作的情况下保持屏幕常亮；同时, 如果此函数调用时屏幕没有点亮, 则会唤醒屏幕.
 
-可以使用`device.cancelKeepingAwake()`来取消屏幕常亮。
+可以使用`device.cancelKeepingAwake()`来取消屏幕常亮.
 
 ## device.cancelKeepingAwake()
 
-取消设备保持唤醒状态。用于取消`device.keepScreenOn()`, `device.keepScreenDim()`等函数设置的屏幕常亮。
+取消设备保持唤醒状态. 用于取消`device.keepScreenOn()`, `device.keepScreenDim()`等函数设置的屏幕常亮.
 
 ## device.vibrate(millis)
 
-* `millis` {number} 震动时间，单位毫秒
+* `millis` {number} 震动时间, 单位毫秒
 
-使设备震动一段时间。
+使设备震动一段时间.
 
 ```
 //震动两秒
@@ -336,4 +341,4 @@ device.vibrate(2000);
 
 ## device.cancelVibration()
 
-如果设备处于震动状态，则取消震动。
+如果设备处于震动状态, 则取消震动.
diff --git a/api/dialogs.md b/api/dialogs.md
index acf3735..ad285ac 100644
--- a/api/dialogs.md
+++ b/api/dialogs.md
@@ -1,14 +1,19 @@
-# Dialogs
+# 对话框 (Dialogs)
 
-> Stability: 2 - Stable
+---
 
-dialogs 模块提供了简单的对话框支持，可以通过对话框和用户进行交互。最简单的例子如下：
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
+
+---
+
+dialogs 模块提供了简单的对话框支持, 可以通过对话框和用户进行交互. 最简单的例子如下：
 
 ```
 alert("您好");
 ```
 
-这段代码会弹出一个消息提示框显示"您好"，并在用户点击"确定"后继续运行。稍微复杂一点的例子如下：
+这段代码会弹出一个消息提示框显示"您好", 并在用户点击"确定"后继续运行. 稍微复杂一点的例子如下：
 
 ```
 var clear = confirm("要清除所有缓存吗?");
@@ -17,9 +22,9 @@ if(clear){
 }
 ```
 
-`confirm()`会弹出一个对话框并让用户选择"是"或"否"，如果选择"是"则返回true。
+`confirm()`会弹出一个对话框并让用户选择"是"或"否", 如果选择"是"则返回true.
 
-需要特别注意的是，对话框在ui模式下不能像通常那样使用，应该使用回调函数或者[Promise](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Promise)的形式。理解这一点可能稍有困难。举个例子:
+需要特别注意的是, 对话框在ui模式下不能像通常那样使用, 应该使用回调函数或者[Promise](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Promise/)的形式. 理解这一点可能稍有困难. 举个例子:
 
 ```
 "ui";
@@ -40,19 +45,19 @@ confirm("要清除所有缓存吗?")
 
 ## dialogs.alert(title[, content, callback])
 
-* `title` {string} 对话框的标题。
-* `content` {string} 可选，对话框的内容。默认为空。
-* `callback` {Function} 回调函数，可选。当用户点击确定时被调用,一般用于ui模式。
+* `title` {string} 对话框的标题.
+* `content` {string} 可选, 对话框的内容. 默认为空.
+* `callback` {Function} 回调函数, 可选. 当用户点击确定时被调用,一般用于ui模式.
 
-显示一个只包含“确定”按钮的提示对话框。直至用户点击确定脚本才继续运行。
+显示一个只包含“确定”按钮的提示对话框. 直至用户点击确定脚本才继续运行.
 
-该函数也可以作为全局函数使用。
+该函数也可以作为全局函数使用.
 
 ```
-alert("出现错误~", "出现未知错误，请联系脚本作者”);
+alert("出现错误~", "出现未知错误, 请联系脚本作者”);
 ```
 
-在ui模式下该函数返回一个`Promise`。例如:
+在ui模式下该函数返回一个`Promise`. 例如:
 
 ```
 "ui";
@@ -63,15 +68,15 @@ alert("嘿嘿嘿").then(()=>{
 
 ## dialogs.confirm(title[, content, callback])
 
-* `title` {string} 对话框的标题。
-* `content` {string} 可选，对话框的内容。默认为空。
-* `callback` {Function} 回调函数，可选。当用户点击确定时被调用,一般用于ui模式。
+* `title` {string} 对话框的标题.
+* `content` {string} 可选, 对话框的内容. 默认为空.
+* `callback` {Function} 回调函数, 可选. 当用户点击确定时被调用,一般用于ui模式.
 
-显示一个包含“确定”和“取消”按钮的提示对话框。如果用户点击“确定”则返回 `true` ，否则返回 `false` 。
+显示一个包含“确定”和“取消”按钮的提示对话框. 如果用户点击“确定”则返回 `true` , 否则返回 `false` .
 
-该函数也可以作为全局函数使用。
+该函数也可以作为全局函数使用.
 
-在ui模式下该函数返回一个`Promise`。例如:
+在ui模式下该函数返回一个`Promise`. 例如:
 
 ```
 "ui";
@@ -82,20 +87,20 @@ confirm("确定吗").then(value=>{
 
 ## dialogs.rawInput(title[, prefill, callback])
 
-* `title` {string} 对话框的标题。
-* `prefill` {string} 输入框的初始内容，可选，默认为空。
-* `callback` {Function} 回调函数，可选。当用户点击确定时被调用,一般用于ui模式。
+* `title` {string} 对话框的标题.
+* `prefill` {string} 输入框的初始内容, 可选, 默认为空.
+* `callback` {Function} 回调函数, 可选. 当用户点击确定时被调用,一般用于ui模式.
 
-显示一个包含输入框的对话框，等待用户输入内容，并在用户点击确定时将输入的字符串返回。如果用户取消了输入，返回null。
+显示一个包含输入框的对话框, 等待用户输入内容, 并在用户点击确定时将输入的字符串返回. 如果用户取消了输入, 返回null.
 
-该函数也可以作为全局函数使用。
+该函数也可以作为全局函数使用.
 
 ```
 var name = rawInput("请输入您的名字", "小明");
 alert("您的名字是" + name);
 ```
 
-在ui模式下该函数返回一个`Promise`。例如:
+在ui模式下该函数返回一个`Promise`. 例如:
 
 ```
 "ui";
@@ -104,7 +109,7 @@ rawInput("请输入您的名字", "小明").then(name => {
 });
 ```
 
-当然也可以使用回调函数，例如:
+当然也可以使用回调函数, 例如:
 
 ```
 rawInput("请输入您的名字", "小明", name => {
@@ -114,9 +119,9 @@ rawInput("请输入您的名字", "小明", name => {
 
 ## dialogs.input(title[, prefill, callback])
 
-等效于 `eval(dialogs.rawInput(title, prefill, callback))`, 该函数和rawInput的区别在于，会把输入的字符串用eval计算一遍再返回，返回的可能不是字符串。
+等效于 `eval(dialogs.rawInput(title, prefill, callback))`, 该函数和rawInput的区别在于, 会把输入的字符串用eval计算一遍再返回, 返回的可能不是字符串.
 
-可以用该函数输入数字、数组等。例如：
+可以用该函数输入数字、数组等. 例如：
 
 ```
 var age = dialogs.input("请输入您的年龄", "18");
@@ -125,7 +130,7 @@ var year = new Date().getYear() + 1900 - age;
 alert("您的出生年份是" + year);
 ```
 
-在ui模式下该函数返回一个`Promise`。例如:
+在ui模式下该函数返回一个`Promise`. 例如:
 
 ```
 "ui";
@@ -141,11 +146,11 @@ dialogs.input("请输入您的年龄", "18").then(age => {
 
 ## dialogs.select(title, items, callback)
 
-* `title` {string} 对话框的标题。
-* `items` {Array} 对话框的选项列表，是一个字符串数组。
-* `callback` {Function} 回调函数，可选。当用户点击确定时被调用,一般用于ui模式。
+* `title` {string} 对话框的标题.
+* `items` {Array} 对话框的选项列表, 是一个字符串数组.
+* `callback` {Function} 回调函数, 可选. 当用户点击确定时被调用,一般用于ui模式.
 
-显示一个带有选项列表的对话框，等待用户选择，返回用户选择的选项索引(0 ~ item.length - 1)。如果用户取消了选择，返回-1。
+显示一个带有选项列表的对话框, 等待用户选择, 返回用户选择的选项索引(0 ~ item.length - 1). 如果用户取消了选择, 返回-1.
 
 ```
 var options = ["选项A", "选项B", "选项C", "选项D"]
@@ -157,7 +162,7 @@ if(i >= 0){
 }
 ```
 
-在ui模式下该函数返回一个`Promise`。例如:
+在ui模式下该函数返回一个`Promise`. 例如:
 
 ```
 "ui";
@@ -169,32 +174,32 @@ dialogs.select("请选择一个选项", ["选项A", "选项B", "选项C", "选
 
 ## dialogs.singleChoice(title, items[, index, callback])
 
-* `title` {string} 对话框的标题。
-* `items` {Array} 对话框的选项列表，是一个字符串数组。
-* `index` {number} 对话框的初始选项的位置，默认为0。
-* `callback` {Function} 回调函数，可选。当用户点击确定时被调用,一般用于ui模式。
+* `title` {string} 对话框的标题.
+* `items` {Array} 对话框的选项列表, 是一个字符串数组.
+* `index` {number} 对话框的初始选项的位置, 默认为0.
+* `callback` {Function} 回调函数, 可选. 当用户点击确定时被调用,一般用于ui模式.
 
-显示一个单选列表对话框，等待用户选择，返回用户选择的选项索引(0 ~ item.length - 1)。如果用户取消了选择，返回-1。
+显示一个单选列表对话框, 等待用户选择, 返回用户选择的选项索引(0 ~ item.length - 1). 如果用户取消了选择, 返回-1.
 
-在ui模式下该函数返回一个`Promise`。
+在ui模式下该函数返回一个`Promise`.
 
 ## dialogs.multiChoice(title, items[, indices, callback])
 
-* `title` {string} 对话框的标题。
-* `items` {Array} 对话框的选项列表，是一个字符串数组。
-* `indices` {Array} 选项列表中初始选中的项目索引的数组，默认为空数组。
-* `callback` {Function} 回调函数，可选。当用户点击确定时被调用,一般用于ui模式。
+* `title` {string} 对话框的标题.
+* `items` {Array} 对话框的选项列表, 是一个字符串数组.
+* `indices` {Array} 选项列表中初始选中的项目索引的数组, 默认为空数组.
+* `callback` {Function} 回调函数, 可选. 当用户点击确定时被调用,一般用于ui模式.
 
-显示一个多选列表对话框，等待用户选择，返回用户选择的选项索引的数组。如果用户取消了选择，返回`[]`。
+显示一个多选列表对话框, 等待用户选择, 返回用户选择的选项索引的数组. 如果用户取消了选择, 返回`[]`.
 
-在ui模式下该函数返回一个`Promise`。
+在ui模式下该函数返回一个`Promise`.
 
 ## dialogs.build(properties)
 
-* `properties` {Object} 对话框属性，用于配置对话框。
+* `properties` {Object} 对话框属性, 用于配置对话框.
 * 返回 {Dialog}
 
-创建一个可自定义的对话框，例如：
+创建一个可自定义的对话框, 例如：
 
 ```
 dialogs.build({
@@ -227,17 +232,17 @@ dialogs.build({
 * `title` {string} 对话框标题
 * `titleColor` {string} | {number} 对话框标题的颜色
 * `buttonRippleColor` {string} | {number} 对话框按钮的波纹效果颜色
-* `icon` {string} | {Image} 对话框的图标，是一个URL或者图片对象
+* `icon` {string} | {Image} 对话框的图标, 是一个URL或者图片对象
 * `content` {string} 对话框文字内容
 * `contentColor`{string} | {number} 对话框文字内容的颜色
-* `contentLineSpacing`{number} 对话框文字内容的行高倍数，1.0为一倍行高
+* `contentLineSpacing`{number} 对话框文字内容的行高倍数, 1.0为一倍行高
 * `items` {Array} 对话框列表的选项
 * `itemsColor` {string} | {number} 对话框列表的选项的文字颜色
-* `itemsSelectMode` {string} 对话框列表的选项选择模式，可以为:
+* `itemsSelectMode` {string} 对话框列表的选项选择模式, 可以为:
     * `select` 普通选择模式
     * `single` 单选模式
     * `multi` 多选模式
-* `itemsSelectedIndex` {number} | {Array} 对话框列表中预先选中的项目索引，如果是单选模式为一个索引；多选模式则为数组
+* `itemsSelectedIndex` {number} | {Array} 对话框列表中预先选中的项目索引, 如果是单选模式为一个索引；多选模式则为数组
 * `positive` {string} 对话框确定按钮的文字内容(最右边按钮)
 * `positiveColor` {string} | {number} 对话框确定按钮的文字颜色(最右边按钮)
 * `neutral` {string} 对话框中立按钮的文字内容(最左边按钮)
@@ -247,15 +252,15 @@ dialogs.build({
 * `checkBoxPrompt` {string} 勾选框文字内容
 * `checkBoxChecked` {boolean} 勾选框是否勾选
 * `progress` {Object} 配置对话框进度条的对象：
-    * `max` {number} 进度条的最大值，如果为-1则为无限循环的进度条
+    * `max` {number} 进度条的最大值, 如果为-1则为无限循环的进度条
     * `horizontal` {boolean} 如果为true, 则对话框无限循环的进度条为水平进度条
     * `showMinMax` {boolean} 是否显示进度条的最大值和最小值
-* `cancelable` {boolean} 对话框是否可取消，如果为false，则对话框只能用代码手动取消
-* `canceledOnTouchOutside` {boolean} 对话框是否在点击对话框以外区域时自动取消，默认为true
+* `cancelable` {boolean} 对话框是否可取消, 如果为false, 则对话框只能用代码手动取消
+* `canceledOnTouchOutside` {boolean} 对话框是否在点击对话框以外区域时自动取消, 默认为true
 * `inputHint` {string} 对话框的输入框的输入提示
 * `inputPrefill` {string} 对话框输入框的默认输入内容
 
-通过这些选项可以自定义一个对话框，并通过监听返回的Dialog对象的按键、输入事件来实现交互。下面是一些例子。
+通过这些选项可以自定义一个对话框, 并通过监听返回的Dialog对象的按键、输入事件来实现交互. 下面是一些例子.
 
 模拟alert对话框：
 
@@ -323,7 +328,7 @@ dialogs.build({
 }).show();
 ```
 
-使用这个函数来构造对话框，一个明显的不同是需要使用回调函数而不能像dialogs其他函数一样同步地返回结果；但也可以通过threads模块的方法来实现。例如显示一个输入框并获取输入结果为：
+使用这个函数来构造对话框, 一个明显的不同是需要使用回调函数而不能像dialogs其他函数一样同步地返回结果；但也可以通过threads模块的方法来实现. 例如显示一个输入框并获取输入结果为：
 
 ```
 var input = threads.disposable();
@@ -339,13 +344,13 @@ tosatLog(age);
 
 # Dialog
 
-`dialogs.build()`返回的对话框对象，内置一些事件用于响应用户的交互，也可以获取对话框的状态和信息。
+`dialogs.build()`返回的对话框对象, 内置一些事件用于响应用户的交互, 也可以获取对话框的状态和信息.
 
 ## 事件: `show`
 
 * `dialog` {Dialog} 对话框
 
-对话框显示时会触发的事件。例如：
+对话框显示时会触发的事件. 例如：
 
 ```
 dialogs.build({
@@ -359,7 +364,7 @@ dialogs.build({
 
 * `dialog` {Dialog} 对话框
 
-对话框被取消时会触发的事件。一个对话框可能按取消按钮、返回键取消或者点击对话框以外区域取消。例如：
+对话框被取消时会触发的事件. 一个对话框可能按取消按钮、返回键取消或者点击对话框以外区域取消. 例如：
 
 ```
 dialogs.build({
@@ -375,7 +380,7 @@ dialogs.build({
 
 * `dialog` {Dialog} 对话框
 
-对话框消失时会触发的事件。对话框被取消或者手动调用`dialog.dismiss()`函数都会触发该事件。例如：
+对话框消失时会触发的事件. 对话框被取消或者手动调用`dialog.dismiss()`函数都会触发该事件. 例如：
 
 ```
 var d = dialogs.build({
@@ -395,7 +400,7 @@ setTimeout(()=>{
 
 * `dialog` {Dialog} 对话框
 
-确定按钮按下时触发的事件。例如：
+确定按钮按下时触发的事件. 例如：
 
 ```
 var d = dialogs.build({
@@ -411,7 +416,7 @@ var d = dialogs.build({
 
 * `dialog` {Dialog} 对话框
 
-取消按钮按下时触发的事件。例如：
+取消按钮按下时触发的事件. 例如：
 
 ```
 var d = dialogs.build({
@@ -427,7 +432,7 @@ var d = dialogs.build({
 
 * `dialog` {Dialog} 对话框
 
-中性按钮按下时触发的事件。例如：
+中性按钮按下时触发的事件. 例如：
 
 ```
 var d = dialogs.build({
@@ -443,12 +448,12 @@ var d = dialogs.build({
 ## 事件: `any`
 
 * `dialog` {Dialog} 对话框
-* `action` {string} 被点击的按钮，可能的值为:
+* `action` {string} 被点击的按钮, 可能的值为:
     * `positive` 确定按钮
     * `negative` 取消按钮
     * `neutral` 中性按钮
 
-任意按钮按下时触发的事件。例如:
+任意按钮按下时触发的事件. 例如:
 
 ```
 var d = dialogs.build({
@@ -467,11 +472,11 @@ var d = dialogs.build({
 
 ## 事件: `item_select`
 
-* `index` {number} 被选中的项目索引，从0开始
+* `index` {number} 被选中的项目索引, 从0开始
 * `item` {Object} 被选中的项目
 * `dialog` {Dialog} 对话框
 
-对话框列表(itemsSelectMode为"select")的项目被点击选中时触发的事件。例如：
+对话框列表(itemsSelectMode为"select")的项目被点击选中时触发的事件. 例如：
 
 ```
 var d = dialogs.build({
@@ -487,11 +492,11 @@ var d = dialogs.build({
 
 ## 事件: `single_choice`
 
-* `index` {number} 被选中的项目索引，从0开始
+* `index` {number} 被选中的项目索引, 从0开始
 * `item` {Object} 被选中的项目
 * `dialog` {Dialog} 对话框
 
-对话框单选列表(itemsSelectMode为"singleChoice")的项目被选中并点击确定时触发的事件。例如：
+对话框单选列表(itemsSelectMode为"singleChoice")的项目被选中并点击确定时触发的事件. 例如：
 
 ```
 var d = dialogs.build({
@@ -511,7 +516,7 @@ var d = dialogs.build({
 * `items` {Array} 被选中的项目的数组
 * `dialog` {Dialog} 对话框
 
-对话框多选列表(itemsSelectMode为"multiChoice")的项目被选中并点击确定时触发的事件。例如：
+对话框多选列表(itemsSelectMode为"multiChoice")的项目被选中并点击确定时触发的事件. 例如：
 
 ```
 var d = dialogs.build({
@@ -530,7 +535,7 @@ var d = dialogs.build({
 * `text` {string} 输入框的内容
 * `dialog` {Dialog} 对话框
 
-带有输入框的对话框当点击确定时会触发的事件。例如：
+带有输入框的对话框当点击确定时会触发的事件. 例如：
 
 ```
 dialogs.build({
@@ -548,7 +553,7 @@ dialogs.build({
 * `text` {string} 输入框的内容
 * `dialog` {Dialog} 对话框
 
-对话框的输入框的文本发生变化时会触发的事件。例如：
+对话框的输入框的文本发生变化时会触发的事件. 例如：
 
 ```
 dialogs.build({
@@ -565,17 +570,17 @@ dialogs.build({
 
 * 返回 {number}
 
-获取当前进度条的进度值，是一个整数
+获取当前进度条的进度值, 是一个整数
 
 ## dialog.getMaxProgress()
 
 * 返回 {number}
 
-获取当前进度条的最大进度值，是一个整数
+获取当前进度条的最大进度值, 是一个整数
 
 ## dialog.getActionButton(action)
 
-* `action` {string} 动作，包括:
+* `action` {string} 动作, 包括:
     * `positive`
     * `negative`
     * `neutral`
diff --git a/api/documentation.md b/api/documentation.md
index b0eafcb..75fb926 100644
--- a/api/documentation.md
+++ b/api/documentation.md
@@ -1,70 +1,433 @@
-# 关于本文档
+# 关于文档 (About)
 
 <!-- type=misc -->
 
-本文档为Auto.js的文档，解释了Auto.js各个模块的API的使用方法、作用和例子。
+AutoJs6 文档, 包含模块 API 使用方法及用例.  
+项目复刻 (Fork) 自 [hyb1996/AutoJs-Docs](https://github.com/hyb1996/AutoJs-Docs/) (GitHub).  
+项目地址: [SuperMonster003/AutoJs6-Documentation](https://github.com/SuperMonster003/AutoJs6-Documentation/) (GitHub).
 
-文档借助Node.js的文档构建工具生成，并在github上开源(https://github.com/hyb1996/AutoJs-Docs )，目前由开发者维护。
+---
 
-## API稳定性
+## 文档阅读示例
 
-由于Auto.js处于活跃的更新和开发状态，API可能随时有变动，我们用Stability来标记模块、函数的稳定性。这些标记包括：
+### 基础
 
-```txt
-Stability: 0 - Deprecated
+#### device.height
 
-弃用的函数、模块或特性，在未来的更新中将很快会被移除或更改。应该在脚本中移除对这些函数的使用，以免后续出现意料之外的问题。
+device 表示全局对象 (这里同时也是一个模块).  
+".height" 表示访问 device 对象的 height 成员变量.  
+如 console.log(device.height) 表示在控制台打印当前设备的高度数值.
+
+#### colors.rgb(red, green, blue)
+
+colors 与 device 类似, 表示全局对象.  
+"rgb" 表示方法名称, ".rgb()" 表示调用 colors 的 rgb 方法, 括号内的 red 等表示方法参数.  
+如 console.log(colors.rgb(255, 128, 64)) 表示在控制台打印一个 RGB 分别为 255, 128 和 64 的颜色数值.
+
+> 注: 绝大多数情况, 文档不对 "[函数](https://developer.mozilla.org/zh-CN/docs/Glossary/Function/)" 与 "[方法](https://developer.mozilla.org/zh-CN/docs/Glossary/Method/)" 做明确区分.
+
+### 临时作用域对象
+
+通常每个章节都以某个对象作为主题.
+
+例如上述 `colors.rgb(red, green, blue)` 位于 [Color - 颜色](color) 这个章节.  
+其中 colors 称为此章节的 "临时作用域对象",  
+它可能是一个对象, 函数, 甚至 "类", 在文档中使用 __`橙色粗体`__ 表示.
+
+列举其后续的相关方法及属性时, 将不再重复书写对象本身:
+
+<p style="font: bold 1em sans-serif; color: #FF7043">colors</p>
+
+[m] rgb
+
+rgb(red, green, blue)
+
+... ...
+
+上述 `rgb` 表示 `colors.rgb`.
+
+### 参数类型
+
+#### colors.rgb(red, green, blue)
+
+- **red** { [number](dataTypes#number) }
+- **green** { [number](dataTypes#number) }
+- **blue** { [number](dataTypes#number) }
+
+参数后的 "{}" 内包含其类型.  
+上述示例表示需要传入三个 [number](dataTypes#number) 类型的参数.  
+如 colors.rgb(255, 128, 64) 合法, 而 colors.rgb("abc", 128, 64) 将可能导致非预期结果或出现异常.
+
+> 注: 点击类型对应的超链接 (如有) 可跳转至类型详情页面.
+
+### 返回值类型
+
+#### colors.rgb(red, green, blue)
+
+- **red** { [number](dataTypes#number) }
+- **green** { [number](dataTypes#number) }
+- **blue** { [number](dataTypes#number) }
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+returns 后的 "{}" 内包含返回值类型.  
+上述示例表示 colors.rgb 方法调用后将返回 [number](dataTypes#number) 类型数据.
+
+### 属性类型
+
+#### colors.RED
+
+- { [number](dataTypes#number) }
+
+属性类型包裹在一对花括号中.  
+上述示例表示 colors 的 RED 属性是 [number](dataTypes#number) 类型数据.
+
+对象字面量形式的类型则用一对双花括号表示:
+
+- {{ name: [string](dataTypes#string); age: [number](dataTypes#number) }}
+
+多行形式:
+
+- {{
+- -- name: [string](dataTypes#string);
+- -- age: [number](dataTypes#number);
+- }}
+
+一个符合上述示例期望的变量:
+
+```js
+let o = { name: "David", age: 13 };
+```
+
+可存取的属性在读取时如果有非 undefined 默认值, 则以一对方括号表示:
+
+- [ 1200 ] { [number](dataTypes#number) }
+
+上述示例表示一个默认值为 1200 的可存取属性.
+
+以一对双方括号表示常量:
+
+- [[ 0.5 ]] { [number](dataTypes#number) }
+
+上述示例表示一个值为 0.5 的常量属性.
+
+### 方法签名
+
+形如上述 [返回值类型](#返回值类型) 小节的示例,  
+包含 [ 方法名称 + 参数类型 + 返回值类型 ] 的标志符, 称为 "方法签名".
+
+> 注: 上述 "方法签名" 定义只用于辅助读者对文档的理解, 并不保证名词解释的合理性.
+
+### 方法描述
+
+#### colors.rgb(red, green, blue)
+
+- __red__ - R (红色) 通道数值  [ A ]
+- __green__ - G (绿色) 通道数值  [ A ]
+- __blue__ - B (蓝色) 通道数值  [ A ]
+- __@return__ - 颜色数值  [ B ]
+
+获取 R/G/B 通道组合后的颜色数值. [ C ]
+
+```js
+[ D ]
+colors.rgb(255, 128, 64); // -32704
+colors.rgb(255, 128, 64) === 0xFFFF8040 - Math.pow(2, 32); // true
+colors.rgb(255, 128, 64) === colors.toInt("#FFFF8040"); // true
+colors.rgb(255, 128, 64) === colors.toInt("#FF8040"); // true
+```
+
+上述示例包含的字母标注含义:
+
+- [ A ] - 参数描述
+- [ B ] - 方法返回值描述
+- [ C ] - 方法描述
+- [ D ] - 方法使用示例
+
+### 可变参数
+
+#### files.join(parent, ...child)
+
+上述示例的 child 参数是 "可变参数", 也称为 "可变长参数" 或 "变长参数".  
+可变参数可传入任意个 (包括 0 个) 参数:
+
+```js
+let p = files.getSdcardPath();
+files.join(p); /* 0 个可变参数 */
+files.join(p, 'a'); /* 1 个可变参数 */
+files.join(p, 'a', 'b', 'c', 'd'); /* 4 个可变参数 */
 ```
 
-```txt
-Stability: 1 - Experimental
+文档采用 JSDoc 标准标注可变参数, 需额外注意 JSDoc 的尾数组标识代表容器, 用于容纳展开后的参数:
 
-实验性的函数、模块或特性，在未来的更新中可能会更改或移除。应该谨慎使用这些函数或模块，或者仅用作临时或试验用途。
+```js
+/**
+ * @param {number} x
+ * @param {number} y
+ * @param {...number[]} others
+ */
+function sum(x, y, others) {
+    /* ... */
+}
 ```
 
-```txt
-Stability: 2 - Stable
+上述示例 others 参数为可变参数, 其中 "...number[]" 代表 others 期望的参数类型为 number, 而非 number[], 最后的 "[]" 代表 "..." 的容器, "..." 与 "[]" 是配对出现的.
 
-稳定的函数、模块或特性，在未来的更新中这些模块已有的函数一般不会被更改，会保证后向兼容性。
+```js
+/**
+ * @param {number} x
+ * @param {number} y
+ * @param {...number[][]} others
+ */
+function sum(x, y, others) {
+    /* ... */
+}
 ```
 
-## 如何阅读本文档
+上述示例 others 期望的参数类型为 number[], 而非 number[][], 同样最后的 "[]" 代表 "..." 的容器.
 
-先看一个例子，下面是[基于控件的操作模拟](coordinates-based-automation.html)的章节中input函数的部分说明。
+```js
+/**
+ * @param {number} x
+ * @param {number} y
+ * @param {...number} others
+ */
+function sum(x, y, others) {
+    /* ... */
+}
+```
+
+上述示例 others 的参数类型标识方法 "...number" 也是合法的, 它其实是 "...number[]" 的省略形式.  
+文档为了避免歧义, 将全部采用完整写法.
 
-## input([i, ]text)
+作为强调, "...(SomeType)[]" 这样的可变参数表示方法, 需要把 "..." 和 "[]" 视为一个整体, 中间部分才是期望的参数类型.
 
-* `i` {number} 表示要输入的为第i + 1个输入框
-* `text` {string} 要输入的文本
+### 可选参数
 
-input表示函数名，括号内的`[i, ]text`为函数的参数。下面是参数列表，"number"表示参数i的类型为数值，"string"表示参数text的类型为字符串。
+#### device.vibrate(text, delay?)
 
-例如input(1, "啦啦啦")，执行这个语句会在屏幕上的第2个输入框处输入"啦啦啦"。
+上述示例的 delay 参数是可选的 (以 "?" 标注).  
+因此以下调用方式均被支持:
 
-方括号[ ]表示参数为可选参数。也就是说，可以省略i直接调用input。例如input("嘿嘿嘿")，按照文档，这个语句会在屏幕上所有输入框输入"嘿嘿嘿"。
+```js
+device.vibrate("hello", 2e3); /* 两秒钟延迟. */
+device.vibrate("hello"); /* 无延迟. */
+```
 
-调用有可选参数的函数时请不要写上方括号。
+可选参数描述时会以 "[]" 标注:
+
+- **[ delay ]** { [number](dataTypes#number) }
+
+如果可选参数包含默认值, 则会以 "=" 标注:
+
+- **[ delay = 0 ]** { [number](dataTypes#number) }
+
+详见下述 [参数默认值](#参数默认值)
+
+### 参数默认值
+
+#### device.vibrate(text, delay?)
+
+- **text** { [string](dataTypes#string) } - 需转换为摩斯码的文本
+- **[ delay = 0 ]** { [number](dataTypes#number) } - 震动延迟
+- <ins>**returns**</ins> { [void](dataTypes#void) }
+
+上述示例的 delay 参数是可选的 (以 "?" 标注) 且包含默认值 (以 "=" 标注).  
+因此以下两种调用方式等效:
+
+```js
+device.vibrate("hello");
+device.vibrate("hello", 0);
+```
+
+> 注: 上述示例的方法签名 (含默认值标注) 在 TypeScript 中并不合法, 此类签名仅限在文档中使用.
+>
+> 注: 以 "=" 标注的参数一定是可选的, 此时参数的 "?" 标注可能被省略, 尤其在重载签名拆写的情况下.  
+> 详情参阅下文的 "方法重载".
+
+### 方法重载
+
+__`Overload 1/17`__
+
+#### pickup(selector, compass, resultType)
+
+__`Overload 2/17`__
+
+#### pickup(selector, compass)
+
+__`Overload 3/17`__
+
+#### pickup(selector, resultType)
+
+... ...
+
+__`Overload 16/17`__
+
+#### pickup(root, selector)
+
+__`Overload 17/17`__
+
+#### pickup()
+
+包含 "Overload m/n" 标签的方法, 表示重载方法的序数及总量.  
+如 "Overload 2/3" 表示当前方法签名描述第 2 个重载方法, 总计 3 个,  
+而 "Overload 5-6/17" 表示当前方法签名涵盖第 5 及 第 6 个重载方法, 总计 17 个.
+
+重载方法可被简化:
+
+```text
+/* 拆写. */
+device.vibrate(text)
+device.vibrate(text, delay)
+
+/* 合写 (简化). */
+device.vibrate(text, delay?)
+
+/* 可选参数通常会标注默认值. */
+device.vibrate(text, delay?)
+· [ delay = 0 ] { number }
+
+/* 即使没有 "?" 标注 (针对拆写). */
+device.vibrate(text, delay)
+· [ delay = 0 ] { number }
+```
+
+多数情况下, 文档采用拆写的方式描述重载方法.
+
+### 方法全局化
+
+__`Global`__
+
+#### images.requestScreenCapture(landscape)
+
+包含 "Global" 标签的方法, 表示支持全局化使用, 可省略模块对象调用.  
+因此以下两种调用方式等效:
+
+```js
+images.requestScreenCapture(false);
+requestScreenCapture(false);
+```
+
+### 方法标签
+
+用于简便表示方法的特性:
+
+- `Global`: [方法全局化](#方法全局化) (可省略模块对象直接调用).
+- `Overload 2/3`: [方法重载](#方法重载) [ 第 2 个, 共 3 个 ].
+- `Non-UI`: 方法不能在 UI 模式下调用.
+- `6.2.0`: 方法对 AutoJs6 的版本要求 [ 不低于 6.2.0 ].
+- `[6.2.0]`: 与原同名方法相比, 方法的功能, 结果, 签名或使用方式发生变更的起始版本.
+- `API>=29`: 方法对 [API 级别](apiLevel) 的要求 [ 不低于 29 ], 当不满足时不抛出异常.
+- `API>=29!`: 方法对 [API 级别](apiLevel) 的要求 [ 不低于 29 ], 当不满足时将抛出异常.
+- `A11Y`: 方法依赖无障碍服务.
+- `A11Y?`: 方法可能会依赖无障碍服务.
+- `Async`: 异步执行的方法.
+- `Async?`: 可能异步执行的方法 (通过参数控制).
+- `Enum`: 枚举类.
+- `CONSTANT`: 常量.
+- `DEPRECATED`: 已弃用的属性或方法.
+- `xProto`: 针对原型的内置对象扩展.
+- `xObject`: 针对对象的内置对象扩展.
+- `xAlias`: 内置对象扩展时使用不同的方法或属性名称 (别名).
+
+### 对象标签
+
+用于简便表示对象的属性:
+
+- \[m]: 普通对象方法或类静态成员方法.
+    - 例如在 `images` 作为 [临时作用域对象](#临时作用域对象) 时:
+    - `[m] captureScreen` 代表 `images.captureScreen` 方法.
+- \[m+]: 具有扩展属性的对象方法.
+    - 如 auto 本身是一个方法 (或称函数), waitFor 是 auto 的一个扩展方法.
+    - 以下两种调用方式均可用: `auto()` 及 `auto.waitFor()`.
+- \[p]: 属性.
+    - 例如在 `device` 作为 [临时作用域对象](#临时作用域对象) 时:
+    - `[p] height` 代表 `device.height` 属性, 而非方法.
+    - 此标签对 [ Getter / Setter / "类" 属性 / 对象属性 / 方法扩展属性 ] 等不作区分.
+- \[I]: Java 接口.
+- \[C]: Java 类或 JavaScript 构造函数.
+- \[c]: Java 类的构造方法.
+- \[m!]: 抽象方法 (针对接口及抽象类).
+- \[m=]: 包含默认实现的抽象方法 (针对接口).
+- \[m#]: 类的实例成员方法.
+    - 类的静态成员方法用 [m] 标签标记.
+    - 例如对于类 `B`, 它有一个实例 `b` (可能通过 `new B()` 等方式获得),
+    - `[m#] foo` 和 `[m] bar` 的调用方式分别为
+    - `b.foo()` 和 `B.bar()`.
+- \[p#]: 类的实例成员属性.
+    - 类的静态成员属性依然用 [p] 标签标记.
+    - 例如对于类 `F`, 它有一个实例 `f` (可能通过 `new F()` 等方式获得),
+    - `[p#] foo` 和 `[p] bar` 的调用方式分别为
+    - `f.foo` 和 `F.bar`.
+- \[@]: 代表 [临时作用域对象](#临时作用域对象) 自身.
+    - 例如在同一个章节中
+        - `[@] apple` [1]
+        - `apple(c)` [2]
+        - `[m] getColor` [3]
+        - `getColor()` [4]
+        - `[@] banana` [5]
+        - `[m] banana` [6]
+        - `banana(x)` [7]
+        - `banana(x, y)` [8]
+    - 这个章节有两个 [临时作用域对象](#临时作用域对象), apple 和 banana, 对应 `[1]` 和 `[5]`.
+    - `[2]` 代表 apple 自身可被调用, 且调用方式为 `apple(c)`, 其中 "c" 为参数.
+    - `[3]` 代表 apple 的一个方法, 名称为 "getColor",
+    - 由 `[4]` 得知, 其调用方式为 `apple.getColor()`.
+    - 注意 `[6]` 与 `[2]` 不同:
+    - [`6`] 代表 banana 的一个方法, 名称为 "banana",
+    - 由 `[7]` 和 `[8]` 得知, 其调用方式有两种,
+    - `banana.banana(x)` 和 `banana.banana(x, y)`.
+
+### 成员访问
+
+成员访问用 "." 表示调用关系, 包括 "类" 静态成员访问, 对象成员访问等.  
+而实例成员访问则需要 "类" 的实例才能访问, 用 "#" 表示调用关系.  
+例如 JavaScript 的 Number 本身是一个 "类", 可用的成员访问方式如下:
+
+```js
+Number(2); /* 作为普通函数使用, 无成员访问. */
+Number.EPSILON; /* "类" 静态成员访问, 用 "Number.EPSILON" 标识, 标签为 "[p]". */
+new Number(2); /* 创建 "类" 实例, 无成员访问. */
+new Number(2).toFixed(0); /* 实例成员访问, 用 "Number#toFixed(number)" 标识, 标签为 "[m#]". */
+```
+
+实例成员访问示例:
+
+<p style="font: bold 1em sans-serif; color: #FF7043">UiObject</p>
+
+[m#] bounds()
+
+```js
+/* 正确访问示例 */
+
+let w = pickup(/.+/); /* w 是 UiObject 的实例. */
+if (w !== null) {
+    console.log(w.bounds()); /* 访问 UiObject 实例的 bounds 方法. */
+}
+
+/* 错误访问示例 */
+
+importClass(org.autojs.autojs.core.automator.UiObject);
+console.log(UiObject.bounds()); /* 访问的是类 UiObject 的静态方法 bounds. */
+```
 
-我们再看第二个例子。图片和图色处理中detectsColor函数的部分说明。
+### 模板参数
 
-## images.detectsColor(image, color, x, y[, threshold = 16, algorithm = "diff"])
+#### foo.bar(a, b)
 
-* `image` {Image} 图片
-* `color` {number} | {string} 要检测的颜色
-* `x` {number} 要检测的位置横坐标
-* `y` {number} 要检测的位置纵坐标
-* `threshold` {number} 颜色相似度临界值，默认为16。取值范围为0~255。
-* `algorithm` {string} 颜色匹配算法，包括:
-    * "equal": 相等匹配，只有与给定颜色color完全相等时才匹配。
-    * "diff": 差值匹配。与给定颜色的R、G、B差的绝对值之和小于threshold时匹配。
-    * "rgb": rgb欧拉距离相似度。与给定颜色color的rgb欧拉距离小于等于threshold时匹配。
+- **a** { [T](dataTypes#generic) }
+- **b** { [number](dataTypes#number) }
+- <ins>**returns**</ins> { [T](dataTypes#generic) }
+- <ins>**template**</ins> { [T](dataTypes#generic) }
 
-    * "rgb+": 加权rgb欧拉距离匹配([LAB Delta E](https://en.wikipedia.org/wiki/Color_difference))。
-    * "hs": hs欧拉距离匹配。hs为HSV空间的色调值。
+returns 后的 "{}" 内包含返回值类型.  
+上述示例表示 colors.rgb 方法调用后将返回 [number](dataTypes#number) 类型数据.
 
-同样地，`[, threshold = 16, algorithm = "rgb"]`为可选参数，并且，等于号=后面的值为参数的默认值。也就是如果不指定该参数，则该参数将会为这个值。
+> 参阅: [泛型](dataTypes#generic)
 
-例如 `images.detectsColor(captureScreen(), "#112233", 100, 200)` 相当于 `images.detectsColor(captureScreen(), "#112233", 100, 200, 16, "rgb")`，
-而`images.detectsColor(captureScreen(), "#112233", 100, 200, 64)` 相当于`images.detectsColor(captureScreen(), "#112233", 100, 200, 64, "rgb")`。
+## 声明
 
-调用有可选参数及默认值的函数时请不要写上方括号和等于号。
\ No newline at end of file
+当前项目 (文档) 及 [AutoJs6](https://github.com/SuperMonster003/AutoJs6/) (App) 均为二次开发.  
+相对于 [原始 App](https://github.com/hyb1996/Auto.js/), 二次开发的 App 中会增加或修改部分模块功能.  
+相对于 [原始文档](https://github.com/hyb1996/AutoJs-Docs/), 二次开发的文档将进行部分增删或重新编写.  
+开发者无法保证对 API 的完全理解及文档的无纰漏撰写.  
+如有任何不当之处, 欢迎提交 [Issue](https://github.com/SuperMonster003/AutoJs6-Documentation/issues/) 或 [PR](https://github.com/SuperMonster003/AutoJs6-Documentation/pulls/).  
\ No newline at end of file
diff --git a/api/e4x.md b/api/e4x.md
new file mode 100644
index 0000000..b7e6bc4
--- /dev/null
+++ b/api/e4x.md
@@ -0,0 +1,31 @@
+# E4X
+
+> 注: E4X __已弃用__.
+>
+> 尽管少数浏览器依然支持, 但随着件更新正逐步被废除, 应尽量避免使用.  
+> AutoJs6 使用 Rhino 引擎, 因此依然保持对 E4X 的支持.
+>
+> 本章节仅用于技术概念的归档及溯源, 不建议用于脚本编写.
+
+ECMAScript for XML (E4X) 是对 ECMAScript 的扩展, 增加对 XML 的内在支持.  
+其目标是在访问 XML 文档时, 提供一种更直观且语法更简洁的的 DOM 接口, 成为处理 XML 文档的新方式.
+
+```e4x
+var sales = <sales vendor="John">
+    <item type="peas" price="4" quantity="6"/>
+    <item type="carrot" price="3" quantity="10"/>
+    <item type="chips" price="5" quantity="3"/>
+  </sales>;
+
+alert( sales.item.(@type == "carrot").@quantity );
+alert( sales.@vendor );
+for each( var price in sales..@price ) {
+  alert( price );
+}
+delete sales.item[0];
+sales.item += <item type="oranges" price="4"/>;
+sales.item.(@type == "oranges").@quantity = 4;
+```
+
+> 参阅: [Wikipedia (英)](https://en.wikipedia.org/wiki/ECMAScript_for_XML) / [Wikipedia (中)](https://zh.wikipedia.org/wiki/E4X)  
+> 替代: [DOMParser](https://developer.mozilla.org/zh-CN/docs/Web/API/DOMParser) / [DOMSerializer](https://www.npmjs.com/package/dom-serializer)
\ No newline at end of file
diff --git a/api/engines.md b/api/engines.md
index 5a5b515..995e12f 100644
--- a/api/engines.md
+++ b/api/engines.md
@@ -1,10 +1,15 @@
-# Engines
+# 引擎 (Engines)
 
-> Stability: 2 - Stable
+---
 
-engines模块包含了一些与脚本环境、脚本运行、脚本引擎有关的函数，包括运行其他脚本，关闭脚本等。
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
 
-例如，获取脚本所在目录：
+---
+
+engines模块包含了一些与脚本环境、脚本运行、脚本引擎有关的函数, 包括运行其他脚本, 关闭脚本等.
+
+例如, 获取脚本所在目录：
 
 ```
 toast(engines.myEngine().cwd());
@@ -12,17 +17,17 @@ toast(engines.myEngine().cwd());
 
 ## engines.execScript(name, script[, config])
 
-* `name` {string} 要运行的脚本名称。这个名称和文件名称无关，只是在任务管理中显示的名称。
-* `script` {string} 要运行的脚本内容。
+* `name` {string} 要运行的脚本名称. 这个名称和文件名称无关, 只是在任务管理中显示的名称.
+* `script` {string} 要运行的脚本内容.
 * `config` {Object} 运行配置项
-    * `delay` {number} 延迟执行的毫秒数，默认为0
-    * `loopTimes` {number} 循环运行次数，默认为1。0为无限循环。
-    * `interval` {number} 循环运行时两次运行之间的时间间隔，默认为0
-    * `path` {Array} | {string} 指定脚本运行的目录。这些路径会用于require时寻找模块文件。
+    * `delay` {number} 延迟执行的毫秒数, 默认为0
+    * `loopTimes` {number} 循环运行次数, 默认为1. 0为无限循环.
+    * `interval` {number} 循环运行时两次运行之间的时间间隔, 默认为0
+    * `path` {Array} | {string} 指定脚本运行的目录. 这些路径会用于require时寻找模块文件.
 
-在新的脚本环境中运行脚本script。返回一个[ScriptExectuion](#engines_scriptexecution)对象。
+在新的脚本环境中运行脚本script. 返回一个[ScriptExectuion](#engines_scriptexecution)对象.
 
-所谓新的脚本环境，指定是，脚本中的变量和原脚本的变量是不共享的，并且，脚本会在新的线程中运行。
+所谓新的脚本环境, 指定是, 脚本中的变量和原脚本的变量是不共享的, 并且, 脚本会在新的线程中运行.
 
 最简单的例子如下：
 
@@ -30,27 +35,27 @@ toast(engines.myEngine().cwd());
 engines.execScript("hello world", "toast('hello world')");
 ```
 
-如果要循环运行，则：
+如果要循环运行, 则：
 
 ```
-//每隔3秒运行一次脚本，循环10次
+//每隔3秒运行一次脚本, 循环10次
 engines.execScript("hello world", "toast('hello world')", {
     loopTimes: 10,
     interval: 3000
 });
 ```
 
-用字符串来编写脚本非常不方便，可以结合 `Function.toString()`的方法来执行特定函数:
+用字符串来编写脚本非常不方便, 可以结合 `Function.toString()`的方法来执行特定函数:
 
 ```
 function helloWorld(){
-    //注意，这里的变量和脚本主体的变量并不共享
+    //注意, 这里的变量和脚本主体的变量并不共享
     toast("hello world");
 }
 engines.execScript("hello world", "helloWorld();\n" + helloWorld.toString());
 ```
 
-如果要传递变量，则可以把这些封装成一个函数：
+如果要传递变量, 则可以把这些封装成一个函数：
 
 ```
 function exec(action, args){
@@ -58,7 +63,7 @@ function exec(action, args){
     engines.execScript(action.name, action.name + "(" + JSON.stringify(args) + ");\n" + action.toString());
 }
 
-//要执行的函数，是一个简单的加法
+//要执行的函数, 是一个简单的加法
 function add(args){
     toast(args.a + args.b);
 }
@@ -69,14 +74,14 @@ exec(add, {a: 1, b:2});
 
 ## engines.execScriptFile(path[, config])
 
-* `path` {string} 要运行的脚本路径。
+* `path` {string} 要运行的脚本路径.
 * `config` {Object} 运行配置项
-    * `delay` {number} 延迟执行的毫秒数，默认为0
-    * `loopTimes` {number} 循环运行次数，默认为1。0为无限循环。
-    * `interval` {number} 循环运行时两次运行之间的时间间隔，默认为0
-    * `path` {Array} | {string} 指定脚本运行的目录。这些路径会用于require时寻找模块文件。
+    * `delay` {number} 延迟执行的毫秒数, 默认为0
+    * `loopTimes` {number} 循环运行次数, 默认为1. 0为无限循环.
+    * `interval` {number} 循环运行时两次运行之间的时间间隔, 默认为0
+    * `path` {Array} | {string} 指定脚本运行的目录. 这些路径会用于require时寻找模块文件.
 
-在新的脚本环境中运行脚本文件path。返回一个[ScriptExecution](#ScriptExecution)对象。
+在新的脚本环境中运行脚本文件path. 返回一个[ScriptExecution](#ScriptExecution)对象.
 
 ```
 engines.execScriptFile("/sdcard/脚本/1.js");
@@ -84,14 +89,14 @@ engines.execScriptFile("/sdcard/脚本/1.js");
 
 ## engines.execAutoFile(path[, config])
 
-* `path` {string} 要运行的录制文件路径。
+* `path` {string} 要运行的录制文件路径.
 * `config` {Object} 运行配置项
-    * `delay` {number} 延迟执行的毫秒数，默认为0
-    * `loopTimes` {number} 循环运行次数，默认为1。0为无限循环。
-    * `interval` {number} 循环运行时两次运行之间的时间间隔，默认为0
-    * `path` {Array} | {string} 指定脚本运行的目录。这些路径会用于require时寻找模块文件。
+    * `delay` {number} 延迟执行的毫秒数, 默认为0
+    * `loopTimes` {number} 循环运行次数, 默认为1. 0为无限循环.
+    * `interval` {number} 循环运行时两次运行之间的时间间隔, 默认为0
+    * `path` {Array} | {string} 指定脚本运行的目录. 这些路径会用于require时寻找模块文件.
 
-在新的脚本环境中运行录制文件path。返回一个[ScriptExecution](#ScriptExecution)对象。
+在新的脚本环境中运行录制文件path. 返回一个[ScriptExecution](#ScriptExecution)对象.
 
 ```
 engines.execAutoFile("/sdcard/脚本/1.auto");
@@ -99,30 +104,30 @@ engines.execAutoFile("/sdcard/脚本/1.auto");
 
 ## engines.stopAll()
 
-停止所有正在运行的脚本。包括当前脚本自身。
+停止所有正在运行的脚本. 包括当前脚本自身.
 
 ## engines.stopAllAndToast()
 
-停止所有正在运行的脚本并显示停止的脚本数量。包括当前脚本自身。
+停止所有正在运行的脚本并显示停止的脚本数量. 包括当前脚本自身.
 
 ## engines.myEngine()
 
 返回当前脚本的脚本引擎对象([ScriptEngine](#engines_scriptengine))
 
 **[v4.1.0新增]**
-特别的，该对象可以通过`execArgv`来获取他的运行参数，包括外部参数、intent等。例如：
+特别的, 该对象可以通过`execArgv`来获取他的运行参数, 包括外部参数、intent等. 例如：
 
 ```
 log(engines.myEngine().execArgv);
 ```
 
-普通脚本的运行参数通常为空，通过定时任务的广播启动的则可以获取到启动的intent。
+普通脚本的运行参数通常为空, 通过定时任务的广播启动的则可以获取到启动的intent.
 
 ## engines.all()
 
 * 返回 {Array}
 
-返回当前所有正在运行的脚本的脚本引擎[ScriptEngine](#engines_scriptengine)的数组。
+返回当前所有正在运行的脚本的脚本引擎[ScriptEngine](#engines_scriptengine)的数组.
 
 ```
 log(engines.all());
@@ -130,9 +135,9 @@ log(engines.all());
 
 # ScriptExecution
 
-执行脚本时返回的对象，可以通过他获取执行的引擎、配置等，也可以停止这个执行。
+执行脚本时返回的对象, 可以通过他获取执行的引擎、配置等, 也可以停止这个执行.
 
-要停止这个脚本的执行，使用`exectuion.getEngine().forceStop()`.
+要停止这个脚本的执行, 使用`exectuion.getEngine().forceStop()`.
 
 ## ScriptExecution.getEngine()
 
@@ -144,23 +149,23 @@ log(engines.all());
 
 # ScriptEngine
 
-脚本引擎对象。
+脚本引擎对象.
 
 ## ScriptEngine.forceStop()
 
-停止脚本引擎的执行。
+停止脚本引擎的执行.
 
 ## ScriptEngine.cwd()
 
 * 返回 {string}
 
-返回脚本执行的路径。对于一个脚本文件而言为这个脚本所在的文件夹；对于其他脚本，例如字符串脚本，则为`null`或者执行时的设置值。
+返回脚本执行的路径. 对于一个脚本文件而言为这个脚本所在的文件夹；对于其他脚本, 例如字符串脚本, 则为`null`或者执行时的设置值.
 
 ## ScriptEngine.getSource()
 
 * 返回 [ScriptSource](#engines_scriptsource)
 
-返回当前脚本引擎正在执行的脚本对象。
+返回当前脚本引擎正在执行的脚本对象.
 
 ```
 log(engines.myEngine().getSource());
@@ -171,7 +176,7 @@ log(engines.myEngine().getSource());
 * `eventName` {string} 事件名称
 * `...args` {any} 事件参数
 
-向该脚本引擎发送一个事件，该事件可以在该脚本引擎对应的脚本的events模块监听到并在脚本主线程执行事件处理。
+向该脚本引擎发送一个事件, 该事件可以在该脚本引擎对应的脚本的events模块监听到并在脚本主线程执行事件处理.
 
 例如脚本receiver.js的内容如下：
 
@@ -197,7 +202,7 @@ e.getEngine().emit("say", "你好");
 
 # ScriptConfig
 
-脚本执行时的配置。
+脚本执行时的配置.
 
 ## delay
 
@@ -221,7 +226,7 @@ e.getEngine().emit("say", "你好");
 
 * 返回 {Array}
 
-返回一个字符串数组表示脚本运行时模块寻找的路径。
+返回一个字符串数组表示脚本运行时模块寻找的路径.
 
 
 
diff --git a/api/events.md b/api/events.md
index 1fef8f8..a35aceb 100644
--- a/api/events.md
+++ b/api/events.md
@@ -1,12 +1,17 @@
-# Events
+# 事件监听 (Events)
 
-> Stability: 2 - Stable
+---
 
-events模块提供了监听手机通知、按键、触摸的接口。您可以用他配合自动操作函数完成自动化工作。
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
 
-events本身是一个[EventEmiiter](#events_eventemitter), 但内置了一些事件、包括按键事件、通知事件、Toast事件等。
+---
 
-需要注意的是，事件的处理是单线程的，并且仍然在原线程执行，如果脚本主体或者其他事件处理中有耗时操作、轮询等，则事件将无法得到及时处理（会进入事件队列等待脚本主体或其他事件处理完成才执行）。例如:
+events模块提供了监听手机通知、按键、触摸的接口. 您可以用他配合自动操作函数完成自动化工作.
+
+events本身是一个[EventEmiiter](#events_eventemitter), 但内置了一些事件、包括按键事件、通知事件、Toast事件等.
+
+需要注意的是, 事件的处理是单线程的, 并且仍然在原线程执行, 如果脚本主体或者其他事件处理中有耗时操作、轮询等, 则事件将无法得到及时处理（会进入事件队列等待脚本主体或其他事件处理完成才执行）. 例如:
 
 ```
 auto();
@@ -22,22 +27,22 @@ while(true){
 
 ## events.emitter()
 
-返回一个新的[EventEmitter](#events_eventemitter)。这个EventEmitter没有内置任何事件。
+返回一个新的[EventEmitter](#events_eventemitter). 这个EventEmitter没有内置任何事件.
 
 ## events.observeKey()
 
-启用按键监听，例如音量键、Home键。按键监听使用无障碍服务实现，如果无障碍服务未启用会抛出异常并提示开启。
+启用按键监听, 例如音量键、Home键. 按键监听使用无障碍服务实现, 如果无障碍服务未启用会抛出异常并提示开启.
 
-只有这个函数成功执行后, `onKeyDown`, `onKeyUp`等按键事件的监听才有效。
+只有这个函数成功执行后, `onKeyDown`, `onKeyUp`等按键事件的监听才有效.
 
-该函数在安卓4.3以上才能使用。
+该函数在安卓4.3以上才能使用.
 
 ## events.onKeyDown(keyName, listener)
 
 * `keyName` {string} 要监听的按键名称
-* `listener` {Function} 按键监听器。参数为一个[KeyEvent](#events_keyevent)。
+* `listener` {Function} 按键监听器. 参数为一个[KeyEvent](#events_keyevent).
 
-注册一个按键监听函数，当有keyName对应的按键被按下会调用该函数。可用的按键名称参见[Keys](#events_keys)。
+注册一个按键监听函数, 当有keyName对应的按键被按下会调用该函数. 可用的按键名称参见[Keys](#events_keys).
 
 例如:
 
@@ -58,11 +63,11 @@ events.onKeyDown("menu", function(event){
 ## events.onKeyUp(keyName, listener)
 
 * `keyName` {string} 要监听的按键名称
-* `listener` {Function} 按键监听器。参数为一个[KeyEvent](#events_keyevent)。
+* `listener` {Function} 按键监听器. 参数为一个[KeyEvent](#events_keyevent).
 
-注册一个按键监听函数，当有keyName对应的按键弹起会调用该函数。可用的按键名称参见[Keys](#events_keys)。
+注册一个按键监听函数, 当有keyName对应的按键弹起会调用该函数. 可用的按键名称参见[Keys](#events_keys).
 
-一次完整的按键动作包括了按键按下和弹起。按下事件会在手指按下一个按键的"瞬间"触发, 弹起事件则在手指放开这个按键时触发。
+一次完整的按键动作包括了按键按下和弹起. 按下事件会在手指按下一个按键的"瞬间"触发, 弹起事件则在手指放开这个按键时触发.
 
 例如:
 
@@ -83,45 +88,45 @@ events.onKeyDown("home", function(event){
 ## events.onceKeyDown(keyName, listener)
 
 * `keyName` {string} 要监听的按键名称
-* `listener` {Function} 按键监听器。参数为一个[KeyEvent](#events_keyevent)
+* `listener` {Function} 按键监听器. 参数为一个[KeyEvent](#events_keyevent)
 
-注册一个按键监听函数，当有keyName对应的按键被按下时会调用该函数，之后会注销该按键监听器。
+注册一个按键监听函数, 当有keyName对应的按键被按下时会调用该函数, 之后会注销该按键监听器.
 
-也就是listener只有在onceKeyDown调用后的第一次按键事件被调用一次。
+也就是listener只有在onceKeyDown调用后的第一次按键事件被调用一次.
 
 ## events.onceKeyUp(keyName, listener)
 
 * `keyName` {string} 要监听的按键名称
-* `listener` {Function} 按键监听器。参数为一个[KeyEvent](#events_keyevent)
+* `listener` {Function} 按键监听器. 参数为一个[KeyEvent](#events_keyevent)
 
-注册一个按键监听函数，当有keyName对应的按键弹起时会调用该函数，之后会注销该按键监听器。
+注册一个按键监听函数, 当有keyName对应的按键弹起时会调用该函数, 之后会注销该按键监听器.
 
-也就是listener只有在onceKeyUp调用后的第一次按键事件被调用一次。
+也就是listener只有在onceKeyUp调用后的第一次按键事件被调用一次.
 
 ## events.removeAllKeyDownListeners(keyName)
 
 * `keyName` {string} 按键名称
 
-删除该按键的KeyDown(按下)事件的所有监听。
+删除该按键的KeyDown(按下)事件的所有监听.
 
 ## events.removeAllKeyUpListeners(keyName)
 
 * `keyName` {string} 按键名称
 
-删除该按键的KeyUp(弹起)事件的所有监听。
+删除该按键的KeyUp(弹起)事件的所有监听.
 
 ## events.setKeyInterceptionEnabled([key, ]enabled)
 
 * `enabled` {boolean}
 * `key` {string} 要屏蔽的按键
 
-设置按键屏蔽是否启用。所谓按键屏蔽指的是，屏蔽原有按键的功能，例如使得音量键不再能调节音量，但此时仍然能通过按键事件监听按键。
+设置按键屏蔽是否启用. 所谓按键屏蔽指的是, 屏蔽原有按键的功能, 例如使得音量键不再能调节音量, 但此时仍然能通过按键事件监听按键.
 
-如果不加参数key则会屏蔽所有按键。
+如果不加参数key则会屏蔽所有按键.
 
-例如，调用`events.setKeyInterceptionEnabled(true)`会使系统的音量、Home、返回等键不再具有调节音量、回到主页、返回的作用，但此时仍然能通过按键事件监听按键。
+例如, 调用`events.setKeyInterceptionEnabled(true)`会使系统的音量、Home、返回等键不再具有调节音量、回到主页、返回的作用, 但此时仍然能通过按键事件监听按键.
 
-该函数通常于按键监听结合，例如想监听音量键并使音量键按下时不弹出音量调节框则为：
+该函数通常于按键监听结合, 例如想监听音量键并使音量键按下时不弹出音量调节框则为：
 
 ```
 events.setKeyInterceptionEnabled("volume_up", true);
@@ -131,35 +136,35 @@ events.onKeyDown("volume_up", ()=>{
 });
 ```
 
-只要有一个脚本屏蔽了某个按键，该按键便会被屏蔽；当脚本退出时，会自动解除所有按键屏蔽。
+只要有一个脚本屏蔽了某个按键, 该按键便会被屏蔽；当脚本退出时, 会自动解除所有按键屏蔽.
 
 ## events.observeTouch()
 
-启用屏幕触摸监听。（需要root权限）
+启用屏幕触摸监听. （需要root权限）
 
-只有这个函数被成功执行后, 触摸事件的监听才有效。
+只有这个函数被成功执行后, 触摸事件的监听才有效.
 
-没有root权限调用该函数则什么也不会发生。
+没有root权限调用该函数则什么也不会发生.
 
 ## events.setTouchEventTimeout(timeout)
 
-* `timeout` {number} 两个触摸事件的最小间隔。单位毫秒。默认为10毫秒。如果number小于0，视为0处理。
+* `timeout` {number} 两个触摸事件的最小间隔. 单位毫秒. 默认为10毫秒. 如果number小于0, 视为0处理.
 
-设置两个触摸事件分发的最小时间间隔。
+设置两个触摸事件分发的最小时间间隔.
 
-例如间隔为10毫秒的话，前一个触摸事件发生并被注册的监听器处理后，至少要过10毫秒才能分发和处理下一个触摸事件，这10毫秒之间的触摸将会被忽略。
+例如间隔为10毫秒的话, 前一个触摸事件发生并被注册的监听器处理后, 至少要过10毫秒才能分发和处理下一个触摸事件, 这10毫秒之间的触摸将会被忽略.
 
-建议在满足需要的情况下尽量提高这个间隔。一个简单滑动动作可能会连续触发上百个触摸事件，如果timeout设置过低可能造成事件拥堵。强烈建议不要设置timeout为0。
+建议在满足需要的情况下尽量提高这个间隔. 一个简单滑动动作可能会连续触发上百个触摸事件, 如果timeout设置过低可能造成事件拥堵. 强烈建议不要设置timeout为0.
 
 ## events.getTouchEventTimeout()
 
-返回触摸事件的最小时间间隔。
+返回触摸事件的最小时间间隔.
 
 ## events.onTouch(listener)
 
-* `listener` {Function} 参数为[Point](images.html#images_point)的函数
+* `listener` {Function} 参数为[Point](images#images_point)的函数
 
-注册一个触摸监听函数。相当于`on("touch", listener)`。
+注册一个触摸监听函数. 相当于`on("touch", listener)`.
 
 例如:
 
@@ -175,14 +180,14 @@ events.onTouch(function(p){
 
 ## events.removeAllTouchListeners()
 
-删除所有事件监听函数。
+删除所有事件监听函数.
 
 ## 事件: 'key'
 
 * `keyCode` {number} 键值
 * `event` {KeyEvent} 事件
 
-当有按键被按下或弹起时会触发该事件。
+当有按键被按下或弹起时会触发该事件.
 例如：
 
 ```
@@ -218,7 +223,7 @@ events.on("key", function(keyCode, event){
 * `keyCode` {number} 键值
 * `event` {KeyEvent} 事件
 
-当有按键被按下时会触发该事件。
+当有按键被按下时会触发该事件.
 
 ```
 auto();
@@ -233,7 +238,7 @@ events.on("key_down", function(keyCode, event){
 * `keyCode` {number} 键值
 * `event` {KeyEvent} 事件
 
-当有按键弹起时会触发该事件。
+当有按键弹起时会触发该事件.
 
 ```
 auto();
@@ -245,10 +250,10 @@ events.on("key_up", function(keyCode, event){
 
 ## 事件: 'exit`
 
-当脚本正常或者异常退出时会触发该事件。事件处理中如果有异常抛出，则立即中止exit事件的处理（即使exit事件有多个处理函数）并在控制台和日志中打印该异常。
+当脚本正常或者异常退出时会触发该事件. 事件处理中如果有异常抛出, 则立即中止exit事件的处理（即使exit事件有多个处理函数）并在控制台和日志中打印该异常.
 
-一个脚本停止运行时，会关闭该脚本的所有悬浮窗，触发exit事件，之后再回收资源。如果exit事件的处理中有死循环，则后续资源无法得到及时回收。
-此时脚本会停留在任务列表，如果在任务列表中关闭，则会强制结束exit事件的处理并回收后续资源。
+一个脚本停止运行时, 会关闭该脚本的所有悬浮窗, 触发exit事件, 之后再回收资源. 如果exit事件的处理中有死循环, 则后续资源无法得到及时回收.
+此时脚本会停留在任务列表, 如果在任务列表中关闭, 则会强制结束exit事件的处理并回收后续资源.
 
 ```
 log("开始运行")
@@ -260,14 +265,14 @@ log("即将结束运行");
 
 ## events.observeNotification()
 
-开启通知监听。例如QQ消息、微信消息、推送等通知。
+开启通知监听. 例如QQ消息、微信消息、推送等通知.
 
-通知监听依赖于通知服务，如果通知服务没有运行，会抛出异常并跳转到通知权限开启界面。（有时即使通知权限已经开启通知服务也没有运行，这时需要关闭权限再重新开启一次）
+通知监听依赖于通知服务, 如果通知服务没有运行, 会抛出异常并跳转到通知权限开启界面. （有时即使通知权限已经开启通知服务也没有运行, 这时需要关闭权限再重新开启一次）
 
 例如：
 
 ```
-events.obverseNotification();
+events.observeNotification();
 events.onNotification(function(notification){
     log(notification.getText());
 });
@@ -275,9 +280,9 @@ events.onNotification(function(notification){
 
 ## events.observeToast()
 
-开启Toast监听。
+开启Toast监听.
 
-Toast监听依赖于无障碍服务，因此此函数会确保无障碍服务运行。
+Toast监听依赖于无障碍服务, 因此此函数会确保无障碍服务运行.
 
 ## 事件: 'toast'
 
@@ -285,9 +290,9 @@ Toast监听依赖于无障碍服务，因此此函数会确保无障碍服务运
     * `getText()` 获取Toast的文本内容
     * `getPackageName()` 获取发出Toast的应用包名
 
-当有应用发出toast(气泡消息)时会触发该事件。但Auto.js软件本身的toast除外。
+当有应用发出toast(气泡消息)时会触发该事件. 但Auto.js软件本身的toast除外.
 
-例如，要记录发出所有toast的应用：
+例如, 要记录发出所有toast的应用：
 
 ```
 events.observeToast();
@@ -300,7 +305,7 @@ events.onToast(function(toast){
 
 * `notification` [Notification](#events_notification) 通知对象
 
-当有应用发出通知时会触发该事件，参数为[Notification](#events_notification)。
+当有应用发出通知时会触发该事件, 参数为[Notification](#events_notification).
 
 例如：
 
@@ -313,19 +318,19 @@ events.on("notification", function(n){
 
 # Notification
 
-通知对象，可以获取通知详情，包括通知标题、内容、发出通知的包名、时间等，也可以对通知进行操作，比如点击、删除。
+通知对象, 可以获取通知详情, 包括通知标题、内容、发出通知的包名、时间等, 也可以对通知进行操作, 比如点击、删除.
 
 ## Notification.number
 
 * {number}
 
-通知数量。例如QQ连续收到两条消息时number为2。
+通知数量. 例如QQ连续收到两条消息时number为2.
 
 ## Notification.when
 
 * {number}
 
-通知发出时间的时间戳，可以用于构造`Date`对象。例如：
+通知发出时间的时间戳, 可以用于构造`Date`对象. 例如：
 
 ```
 events.observeNotification();
@@ -338,42 +343,40 @@ events.on("notification", function(n){
 
 * 返回 {string}
 
-获取发出通知的应用包名。
+获取发出通知的应用包名.
 
 ## Notification.getTitle()
 
 * 返回 {string}
 
-获取通知的标题。
+获取通知的标题.
 
 ## Notification.getText()
 
 * 返回 {string}
 
-获取通知的内容。
+获取通知的内容.
 
 ## Notification.click()
 
-点击该通知。例如对于一条QQ消息，点击会进入具体的聊天界面。
+点击该通知. 例如对于一条QQ消息, 点击会进入具体的聊天界面.
 
 ## Notification.delete()
 
-删除该通知。该通知将从通知栏中消失。
+删除该通知. 该通知将从通知栏中消失.
 
 # KeyEvent
 
-> Stability: 2 - Stable
-
 ## KeyEvent.getAction()
 
-返回事件的动作。包括：
+返回事件的动作. 包括：
 
 * `KeyEvent.ACTION_DOWN` 按下事件
 * `KeyEvent.ACTION_UP` 弹起事件
 
 ## KeyEvent.getKeyCode()
 
-返回按键的键值。包括：
+返回按键的键值. 包括：
 
 * `KeyEvent.KEYCODE_HOME` 主页键
 * `KeyEvent.KEYCODE_BACK` 返回键
@@ -385,20 +388,18 @@ events.on("notification", function(n){
 
 * 返回 {number}
 
-返回事件发生的时间戳。
+返回事件发生的时间戳.
 
 ## KeyEvent.getDownTime()
 
-返回最近一次按下事件的时间戳。如果本身是按下事件，则与`getEventTime()`相同。
+返回最近一次按下事件的时间戳. 如果本身是按下事件, 则与`getEventTime()`相同.
 
 ## KeyEvent.keyCodeToString(keyCode)
 
-把键值转换为字符串。例如KEYCODE_HOME转换为"KEYCODE_HOME"。
+把键值转换为字符串. 例如KEYCODE_HOME转换为"KEYCODE_HOME".
 
 # keys
 
-> Stability: 2 - Stable
-
 按键事件中所有可用的按键名称为：
 
 * `volume_up`  音量上键
@@ -409,15 +410,13 @@ events.on("notification", function(n){
 
 # EventEmitter
 
-> Stability: 2 - Stable
-
 ## EventEmitter.defaultMaxListeners
 
-每个事件默认可以注册最多 10 个监听器。 单个 EventEmitter 实例的限制可以使用 emitter.setMaxListeners(n) 方法改变。 所有 EventEmitter 实例的默认值可以使用 EventEmitter.defaultMaxListeners 属性改变。
+每个事件默认可以注册最多 10 个监听器.  单个 EventEmitter 实例的限制可以使用 emitter.setMaxListeners(n) 方法改变.  所有 EventEmitter 实例的默认值可以使用 EventEmitter.defaultMaxListeners 属性改变.
 
-设置 EventEmitter.defaultMaxListeners 要谨慎，因为会影响所有 EventEmitter 实例，包括之前创建的。 因而，调用 emitter.setMaxListeners(n) 优先于 EventEmitter.defaultMaxListeners。
+设置 EventEmitter.defaultMaxListeners 要谨慎, 因为会影响所有 EventEmitter 实例, 包括之前创建的.  因而, 调用 emitter.setMaxListeners(n) 优先于 EventEmitter.defaultMaxListeners.
 
-注意，与Node.js不同，**这是一个硬性限制**。 EventEmitter 实例不允许添加更多的监听器，监听器超过最大数量时会抛出TooManyListenersException。
+注意, 与Node.js不同, **这是一个硬性限制**.  EventEmitter 实例不允许添加更多的监听器, 监听器超过最大数量时会抛出TooManyListenersException.
 
 ```
 emitter.setMaxListeners(emitter.getMaxListeners() + 1);
@@ -432,20 +431,20 @@ emitter.once('event', () => {
 * `eventName` {any}
 * `listener` {Function}
 
-emitter.on(eventName, listener) 的别名。
+emitter.on(eventName, listener) 的别名.
 
 ## EventEmitter.emit(eventName[, ...args])
 
 * `eventName` {any}
 * `args` {any}
 
-按监听器的注册顺序，同步地调用每个注册到名为 eventName 事件的监听器，并传入提供的参数。
+按监听器的注册顺序, 同步地调用每个注册到名为 eventName 事件的监听器, 并传入提供的参数.
 
-如果事件有监听器，则返回 true ，否则返回 false。
+如果事件有监听器, 则返回 true , 否则返回 false.
 
 ## EventEmitter.eventNames()
 
-返回一个列出触发器已注册监听器的事件的数组。 数组中的值为字符串或符号。
+返回一个列出触发器已注册监听器的事件的数组.  数组中的值为字符串或符号.
 
 ```
 const myEE = events.emitter();
@@ -461,19 +460,19 @@ console.log(myEE.eventNames());
 
 ## EventEmitter.getMaxListeners()
 
-返回 EventEmitter 当前的最大监听器限制值，该值可以通过 emitter.setMaxListeners(n) 设置或默认为 EventEmitter.defaultMaxListeners。
+返回 EventEmitter 当前的最大监听器限制值, 该值可以通过 emitter.setMaxListeners(n) 设置或默认为 EventEmitter.defaultMaxListeners.
 
 ## EventEmitter.listenerCount(eventName)
 
 * `eventName` {string} 正在被监听的事件名
 
-返回正在监听名为 eventName 的事件的监听器的数量。
+返回正在监听名为 eventName 的事件的监听器的数量.
 
 ## EventEmitter.listeners(eventName)
 
 * `eventName` {string}
 
-返回名为 eventName 的事件的监听器数组的副本。
+返回名为 eventName 的事件的监听器数组的副本.
 
 ```
 server.on('connection', (stream) => {
@@ -488,7 +487,7 @@ console.log(util.inspect(server.listeners('connection')));
 * `eventName` {any} 事件名
 * `listener` {Function} 回调函数
 
-添加 listener 函数到名为 eventName 的事件的监听器数组的末尾。 不会检查 listener 是否已被添加。 多次调用并传入相同的 eventName 和 listener 会导致 listener 被添加与调用多次。
+添加 listener 函数到名为 eventName 的事件的监听器数组的末尾.  不会检查 listener 是否已被添加.  多次调用并传入相同的 eventName 和 listener 会导致 listener 被添加与调用多次.
 
 ```
 server.on('connection', (stream) => {
@@ -496,9 +495,9 @@ server.on('connection', (stream) => {
 });
 ```
 
-返回一个 EventEmitter 引用，可以链式调用。
+返回一个 EventEmitter 引用, 可以链式调用.
 
-默认情况下，事件监听器会按照添加的顺序依次调用。 emitter.prependListener() 方法可用于将事件监听器添加到监听器数组的开头。
+默认情况下, 事件监听器会按照添加的顺序依次调用.  emitter.prependListener() 方法可用于将事件监听器添加到监听器数组的开头.
 
 ```
 const myEE = events.emitter();
@@ -515,7 +514,7 @@ myEE.emit('foo');
 * `eventName` {any} 事件名
 * `listener` {Function} 回调函数
 
-添加一个单次 listener 函数到名为 eventName 的事件。 下次触发 eventName 事件时，监听器会被移除，然后调用。
+添加一个单次 listener 函数到名为 eventName 的事件.  下次触发 eventName 事件时, 监听器会被移除, 然后调用.
 
 ```
 server.once('connection', (stream) => {
@@ -523,9 +522,9 @@ server.once('connection', (stream) => {
 });
 ```
 
-返回一个 EventEmitter 引用，可以链式调用。
+返回一个 EventEmitter 引用, 可以链式调用.
 
-默认情况下，事件监听器会按照添加的顺序依次调用。 emitter.prependOnceListener() 方法可用于将事件监听器添加到监听器数组的开头。
+默认情况下, 事件监听器会按照添加的顺序依次调用.  emitter.prependOnceListener() 方法可用于将事件监听器添加到监听器数组的开头.
 
 ```
 const myEE = events.emitter();
@@ -542,7 +541,7 @@ myEE.emit('foo');
 * `eventName` {any} 事件名
 * `listener` {Function} 回调函数
 
-添加 listener 函数到名为 eventName 的事件的监听器数组的开头。 不会检查 listener 是否已被添加。 多次调用并传入相同的 eventName 和 listener 会导致 listener 被添加与调用多次。
+添加 listener 函数到名为 eventName 的事件的监听器数组的开头.  不会检查 listener 是否已被添加.  多次调用并传入相同的 eventName 和 listener 会导致 listener 被添加与调用多次.
 
 ```
 server.prependListener('connection', (stream) => {
@@ -550,14 +549,14 @@ server.prependListener('connection', (stream) => {
 });
 ```
 
-返回一个 EventEmitter 引用，可以链式调用。
+返回一个 EventEmitter 引用, 可以链式调用.
 
 ## EventEmitter.prependOnceListener(eventName, listener)
 
 * `eventName` {any} 事件名
 * `listener` {Function} 回调函数
 
-添加一个单次 listener 函数到名为 eventName 的事件的监听器数组的开头。 下次触发 eventName 事件时，监听器会被移除，然后调用。
+添加一个单次 listener 函数到名为 eventName 的事件的监听器数组的开头.  下次触发 eventName 事件时, 监听器会被移除, 然后调用.
 
 ```
 server.prependOnceListener('connection', (stream) => {
@@ -565,24 +564,24 @@ server.prependOnceListener('connection', (stream) => {
 });
 ```
 
-返回一个 EventEmitter 引用，可以链式调用。
+返回一个 EventEmitter 引用, 可以链式调用.
 
 ## EventEmitter.removeAllListeners(\[eventName\])
 
 * `eventName` {any}
 
-移除全部或指定 eventName 的监听器。
+移除全部或指定 eventName 的监听器.
 
-注意，在代码中移除其他地方添加的监听器是一个不好的做法，尤其是当 EventEmitter 实例是其他组件或模块创建的。
+注意, 在代码中移除其他地方添加的监听器是一个不好的做法, 尤其是当 EventEmitter 实例是其他组件或模块创建的.
 
-返回一个 EventEmitter 引用，可以链式调用。
+返回一个 EventEmitter 引用, 可以链式调用.
 
 ## EventEmitter.removeListener(eventName, listener)
 
 * `eventName` {any}
 * `listener` {Function}
 
-从名为 eventName 的事件的监听器数组中移除指定的 listener。
+从名为 eventName 的事件的监听器数组中移除指定的 listener.
 
 ```
 const callback = (stream) => {
@@ -593,9 +592,9 @@ server.on('connection', callback);
 server.removeListener('connection', callback);
 ```
 
-removeListener 最多只会从监听器数组里移除一个监听器实例。 如果任何单一的监听器被多次添加到指定 eventName 的监听器数组中，则必须多次调用 removeListener 才能移除每个实例。
+removeListener 最多只会从监听器数组里移除一个监听器实例.  如果任何单一的监听器被多次添加到指定 eventName 的监听器数组中, 则必须多次调用 removeListener 才能移除每个实例.
 
-注意，一旦一个事件被触发，所有绑定到它的监听器都会按顺序依次触发。 这意味着，在事件触发后、最后一个监听器完成执行前，任何 removeListener() 或 removeAllListeners() 调用都不会从 emit() 中移除它们。 随后的事件会像预期的那样发生。
+注意, 一旦一个事件被触发, 所有绑定到它的监听器都会按顺序依次触发.  这意味着, 在事件触发后、最后一个监听器完成执行前, 任何 removeListener() 或 removeAllListeners() 调用都不会从 emit() 中移除它们.  随后的事件会像预期的那样发生.
 
 ```
 const myEmitter = events.emitter();
@@ -613,37 +612,37 @@ myEmitter.on('event', callbackA);
 
 myEmitter.on('event', callbackB);
 
-// callbackA 移除了监听器 callbackB，但它依然会被调用。
+// callbackA 移除了监听器 callbackB, 但它依然会被调用.
 // 触发是内部的监听器数组为 [callbackA, callbackB]
 myEmitter.emit('event');
 // 打印:
 //   A
 //   B
 
-// callbackB 被移除了。
+// callbackB 被移除了.
 // 内部监听器数组为 [callbackA]
 myEmitter.emit('event');
 // 打印:
 //   A
 ```
 
-因为监听器是使用内部数组进行管理的，所以调用它会改变在监听器被移除后注册的任何监听器的位置索引。 虽然这不会影响监听器的调用顺序，但意味着由 emitter.listeners() 方法返回的监听器数组副本需要被重新创建。
+因为监听器是使用内部数组进行管理的, 所以调用它会改变在监听器被移除后注册的任何监听器的位置索引.  虽然这不会影响监听器的调用顺序, 但意味着由 emitter.listeners() 方法返回的监听器数组副本需要被重新创建.
 
-返回一个 EventEmitter 引用，可以链式调用。
+返回一个 EventEmitter 引用, 可以链式调用.
 
 ## EventEmitter.setMaxListeners(n)
 
 * `n` {number}
 
-默认情况下，如果为特定事件添加了超过 10 个监听器，则 EventEmitter 会打印一个警告。 此限制有助于寻找内存泄露。 但是，并不是所有的事件都要被限为 10 个。 emitter.setMaxListeners() 方法允许修改指定的 EventEmitter 实例的限制。 值设为 Infinity（或 0）表明不限制监听器的数量。
+默认情况下, 如果为特定事件添加了超过 10 个监听器, 则 EventEmitter 会打印一个警告.  此限制有助于寻找内存泄露.  但是, 并不是所有的事件都要被限为 10 个.  emitter.setMaxListeners() 方法允许修改指定的 EventEmitter 实例的限制.  值设为 Infinity（或 0）表明不限制监听器的数量.
 
-返回一个 EventEmitter 引用，可以链式调用。
+返回一个 EventEmitter 引用, 可以链式调用.
 
 # events.broadcast: 脚本间广播
 
-脚本间通信除了使用engines模块提供的`ScriptEngine.emit()`方法以外，也可以使用events模块提供的broadcast广播。
+脚本间通信除了使用engines模块提供的`ScriptEngine.emit()`方法以外, 也可以使用events模块提供的broadcast广播.
 
-events.broadcast本身是一个EventEmitter，但它的事件是在脚本间共享的，所有脚本都能发送和监听这些事件；事件处理会在脚本主线程执行（后续可能加入函数`onThisThread(eventName, ...args)`来提供在其他线程执行的能力）。
+events.broadcast本身是一个EventEmitter, 但它的事件是在脚本间共享的, 所有脚本都能发送和监听这些事件；事件处理会在脚本主线程执行（后续可能加入函数`onThisThread(eventName, ...args)`来提供在其他线程执行的能力）.
 
 例如在一个脚本发送一个广播hello:
 
diff --git a/api/exceptions.md b/api/exceptions.md
new file mode 100644
index 0000000..79efe4b
--- /dev/null
+++ b/api/exceptions.md
@@ -0,0 +1,1071 @@
+# 异常 (Exceptions)
+
+当运行时发生错误, 新创建的 Error 对象会被抛出.  
+除通用的 Error 构造器外, JavaScript 还有其它类型的错误构造器, 详见下述 [JavaScript 错误类型](#javascript) 小节.
+
+> 注: Java 有 Error (错误) 和 Exception (异常) 之分, 它们都扩展自 Throwable 类.  
+> JavaScript 有 Error (错误) 全局对象, 以及一系列细分 Error 对象 (如 TypeError 等).  
+> 虽然 JavaScript 没有 Exception (异常) 对象, 但章节标题依然采用 "异常" (而非 "错误").
+
+用 `try...catch` 语句可以捕获并处理异常, 详见下述 [异常处理](#trycatch-语句) 小节.
+
+在 `catch {}` (即 `catch 块`) 中, `e` 对象可用于获取异常相关信息,  
+而 Rhino 引擎重新包装了 `e` 对象, 通过 [`e.javaException`](#p-javaexception) 和 [`e.rhinoException`](#p-rhinoexception) 可获取更多异常信息,  
+详见下述 [catch 块](#catch-块) 小节.
+
+# 错误类型
+
+## JavaScript
+
+以下内置错误类型在 Rhino 引擎中均得以实现, 在 AutoJs6 支持全局调用.  
+如需创建自定义错误类型, 参阅下述 [自定义错误类型](#自定义) 小节.
+
+### Error
+
+通用 Error 构造器.
+
+内置错误类型 TypeError, RangeError 等均扩展自 Error 构造器.  
+例如, 如果一个对象是 TypeError 的实例, 则也一定是 Error 的实例.
+
+Error 实例的属性及方法可参阅 [Error 对象](#Error-对象) 章节.
+
+```js
+try {
+    android();
+} catch (e) {
+    console.log(e instanceof TypeError); // true
+    console.log(e instanceof Error); // true
+}
+```
+
+### RangeError
+
+越界错误.
+
+RangeError 实例代表了当一个值不在其所允许的范围或者集合中的错误.
+
+```js
+/* 创建或应用. */
+
+const check = function (num) {
+    const MIN = 1;
+    const MAX = 500;
+    if (num < MIN || num > MAX) {
+        throw new RangeError(`Number ${num} must be between ${MIN} and ${MAX}.`);
+    }
+};
+
+try {
+    check(523);
+} catch (e) {
+    if (e instanceof RangeError) {
+        console.error("发生越界错误.");
+        throw e;
+    }
+}
+
+/* 复现 (Array 构造器参数不合法). */
+
+// RangeError: Inappropriate array length.
+let a = Array(-1);
+
+/* 复现 (Number 部分实例方法参数不合法). */
+
+// RangeError: Precision -1 out of range. 
+let n = (23).toExponential(-1);
+// RangeError: Precision -2 out of range. 
+let n = (23).toFixed(-2);
+// RangeError: Precision -3 out of range.
+let n = (23).toPrecision(-3);
+
+```
+
+### ReferenceError
+
+引用错误.
+
+ReferenceError 实例代表了当一个不存在或尚未初始化的变量被引用时发生的错误.
+
+```js
+/* 创建或应用. */
+
+const f = function (num, options) {
+    if (typeof options === 'undefined') {
+        throw new ReferenceError("Invalid options.");
+    }
+    /* Other code... */
+};
+f(23);
+
+/* 复现. */
+
+// ReferenceError: a is not defined.
+a;
+
+```
+
+### SyntaxError
+
+语法错误.
+
+SyntaxError 实例代表了当 Javascript 引擎发现 tokens 不合法或 token 顺序不合法时抛出的错误.
+
+```badjs
+/* 创建或应用. */
+
+try {
+    eval("...");
+} catch (e) {
+    if (e instanceof SyntaxError) {
+        console.error("发生语法错误, 位于 eval.");
+        throw e;
+    }
+}
+
+/* 复现. */
+
+// Firefox 103.0 - SyntaxError: expected expression, got '??'.
+// Node.js 17.3.0 - SyntaxError: Unexpected token '??'.
+// AutoJs6 - syntax error.
+??
+```
+
+> 注: Rhino 内置了 token 解析器,  
+> 因此多数语法错误会被重新解析后再抛出,  
+> 而其他多数 JavaScript 引擎则直接抛出 SyntaxError.
+
+> Rhino 相关类或文件:  
+> [org.mozilla.javascript.Parser](https://github.com/mozilla/rhino/blob/master/src/org/mozilla/javascript/Parser.java)  
+> [org.mozilla.javascript.TokenStream](https://github.com/mozilla/rhino/blob/master/src/org/mozilla/javascript/TokenStream.java)  
+> [Messages.properties](https://github.com/mozilla/rhino/blob/master/src/org/mozilla/javascript/resources/Messages.properties)
+
+### TypeError
+
+类型错误.
+
+TypeError 实例代表了当一个值的类型为非预期类型时发生的错误.
+
+```js
+/* 创建或应用. */
+
+try {
+    throw new TypeError('Hello', "someFile.js", 10);
+} catch (e) {
+    console.log(e instanceof TypeError); // true
+    console.log(e.message); // "Hello"
+    console.log(e.name); // "TypeError"
+    console.log(e.fileName); // "someFile.js"
+    console.log(e.lineNumber); // 10
+}
+
+/* 复现. */
+
+// TypeError: Cannot call method "f" of null.
+null.f();
+
+// TypeError: java is not a function, it is object.
+java();
+
+// TypeError: day is not a function, it is string.
+[].every("day");
+```
+
+### URIError
+
+URI 错误.
+
+URIError 实例代表了当以一种错误方式使用全局 URI 处理方法时产生的错误.
+
+```js
+/* 创建或应用. */
+
+try {
+    throw new URIError('Hello', 'someFile.js', 10);
+} catch (e) {
+    console.log(e instanceof URIError); // true
+    console.log(e.message); // "Hello"
+    console.log(e.name); // "URIError"
+    console.log(e.fileName); // "someFile.js"
+    console.log(e.lineNumber); // 10
+}
+
+/* 复现. */
+
+// URIError: Malformed URI sequence.
+decodeURIComponent('%');
+```
+
+### InternalError
+
+内部错误.
+
+InternalError 实例代表了出现在 JavaScript 引擎内部的错误.
+
+```js
+/* 创建或应用. */
+
+try {
+    console.log(App.HELLO);
+} catch (e) {
+    if (e instanceof InternalError) {
+        console.error("发生内部错误: 未知的预置 App.");
+        throw e;
+    }
+}
+
+/* 复现. */
+
+// InternalError: Java method "vibrate" cannot be assigned to.
+runtime.device.vibrate = 1;
+```
+
+### EvalError
+
+Eval 错误.
+
+EvalError 实例代表了一个关于 [eval](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/eval) 方法的错误.
+
+```js
+/* 创建或应用. */
+
+try {
+    throw new EvalError('Hello', 'someFile.js', 10);
+} catch (e) {
+    console.log(e instanceof EvalError); // true
+    console.log(e.message); // "Hello"
+    console.log(e.name); // "EvalError"
+    console.log(e.fileName); // "someFile.js"
+    console.log(e.lineNumber); // 10
+}
+
+/* 复现. */
+
+/* eval 抛出具体类型的错误, 而非 EvalError, 因此基本无法复现. */
+
+// ReferenceError: "hello" is not defined.
+eval("hello()");
+
+/* 除非像上述 "创建 EvalError" 示例一样抛出错误, */
+/* 或在 eval 中显式抛出 EvalError, */
+/* 但这样做通常没有意义. */
+
+// EvalError: test
+eval("throw EvalError('test')");
+```
+
+> 注: EvalError 不在当前 (2022/07) ECMAScript 规范中使用, 因此不会被运行时抛出.  
+> 但是对象本身仍然与规范的早期版本向后兼容.
+
+## DOM
+
+DOMException 接口代表访问 Web API 属性或执行 [DOM (文档对象模型)](https://developer.mozilla.org/zh-CN/docs/Web/API/Document_Object_Model/Introduction) 相关操作时发生的异常, 此异常通常是面对浏览器环境的.
+
+当一个操作不可执行时, 如试图创建一个无效的 DOM 或通过一个不存在的节点作为参数节点操作方法, 会抛出 DOMException 异常:
+
+```js
+let node = document.getElementsByTagName('h1').item(0);
+let refnode = node.nextSibling;
+let newnode = document.createTextNode('test');
+node.insertBefore(newnode, refnode); /* 抛出 DOMException 异常. */
+```
+
+DOMException 包含详细的名称分类, 如 [ "NotFoundError" / "InvalidStateError" / "NoModificationAllowedError" ] 等, 详情参阅 [Web IDL](https://webidl.spec.whatwg.org/#idl-DOMException-error-names).
+
+## Java
+
+Java 异常 (Exception) 类扩展自 Throwable 类, Exception 实例可使用 [throw 关键字](#throw-语句) 抛出.
+
+Exception 可以被 [try...catch 语句](#trycatch-语句) 捕获并处理.
+
+Error 类也扩展自 Throwable 类, 与 Exception 稍有不同, Error 往往是 Java 程序运行中不可预料且无法恢复的异常情况, 如 [ OutOfMemoryError / NoClassDefFoundError / StackOverflowError ] 等.
+
+由 Java 方法抛出的原始异常, 指向 catch 块中异常对象的 [javaException](#p-javaexception) 属性.
+
+常见的 Java 异常:
+
+```text
+Exception
+│
+├─ RuntimeException
+│  │
+│  ├─ NullPointerException
+│  │
+│  ├─ IndexOutOfBoundsException
+│  │
+│  ├─ SecurityException
+│  │
+│  └─ IllegalArgumentException
+│     │
+│     └─ NumberFormatException
+│
+├─ IOException
+│  │
+│  ├─ UnsupportedCharsetException
+│  │
+│  ├─ FileNotFoundException
+│  │
+│  └─ SocketException
+│
+├─ ParseException
+│
+├─ GeneralSecurityException
+│
+├─ SQLException
+│
+└─ TimeoutException
+```
+
+> 参阅: [廖雪峰](https://www.liaoxuefeng.com/wiki/1252599548343744/1264737765214592) / [GeeksForGeeks ](https://www.geeksforgeeks.org/errors-v-s-exceptions-in-java/)
+
+## Rhino
+
+Rhino 异常可以视为特殊的 [Java 异常](#java), 由 Rhino [运行时 (Runtime)](runtime) 包装为对象, 指向 catch 块中异常对象的 [rhinoException](#p-rhinoexception) 属性. 
+
+## 自定义
+
+本小节列举了几种自定义错误类型的方法.
+
+- 借助标准内置对象 Error:
+
+```js
+function InvalidFruitError(msg) {
+    Error.call(this);
+    this.message = `Name of "${msg}" must end with "Fruit"`;
+    this.name = this.constructor.name;
+}
+
+InvalidFruitError.prototype = Object.create(Error.prototype, {
+    constructor: { value: InvalidFruitError },
+});
+
+function ensureFruitName(name) {
+    if (!name.endsWith("Fruit")) {
+        throw new InvalidFruitError(name);
+    }
+}
+
+// InvalidFruitError: Name of "coconut" must end with "Fruit"...
+[ "appleFruit", "bananaFruit", "coconut" ].forEach(ensureFruitName);
+```
+
+- 模拟标准内置对象 Error 的行为:
+
+```js
+function InvalidFruitError(msg) {
+    this.message = `Name of "${msg}" must end with "Fruit"`;
+    this.name = this.constructor.name;
+    this.toString = () => `${this.name}: ${this.message}`;
+}
+
+function ensureFruitName(name) {
+    if (!name.endsWith("Fruit")) {
+        throw new InvalidFruitError(name);
+    }
+}
+
+// InvalidFruitError: Name of "coconut" must end with "Fruit"...
+[ "appleFruit", "bananaFruit", "coconut" ].forEach(ensureFruitName);
+```
+
+- 摘录自 [MDN](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Error) 的示例:
+
+```js
+function CustomError(foo, message, fileName, lineNumber) {
+    var instance = new Error(message, fileName, lineNumber);
+    instance.foo = foo;
+    Object.setPrototypeOf(instance, CustomError.prototype);
+    if (Error.captureStackTrace) {
+        Error.captureStackTrace(instance, CustomError);
+    }
+    return instance;
+}
+
+Object.setPrototypeOf(CustomError.prototype, Error.prototype);
+
+Object.setPrototypeOf(CustomError, Error);
+
+CustomError.prototype.name = 'CustomError';
+
+try {
+    throw new CustomError('baz', 'bazMessage');
+} catch (e) {
+    console.error(e.name); // CustomError
+    console.error(e.foo); // baz
+    console.error(e.message); // bazMessage
+}
+
+```
+
+# 异常处理
+
+## throw 语句
+
+使用 throw 语句抛出一个异常.  
+此异常可以是一个含有值的表达式, 包括 [ 数字 / 字符串 / 布尔 / 对象 ] 等多种类型.
+
+不同语言的语法存在差异:
+
+```java
+/* Java. */
+
+/* new 不可省略. */
+throw new Exception("foo");
+```
+
+```kotlin
+/* Kotlin. */
+
+/* Kotlin 语言无 new 关键字. */
+throw Exception("foo");
+``` 
+
+```js
+/* JavaScript. */
+
+/* Error 实例. */
+throw new Error("foo");
+
+/* Error 实例 (new 关键字省略). */
+throw Error("foo");
+
+/* 数字或字符串等表达式. */
+throw "foo"; /* 合法. */
+throw 23; /* 合法. */
+throw true; /* 合法. */
+
+/* 对象. */
+throw {
+    name: "CustomError",
+    message: "test",
+    __proto__: Error.prototype,
+};
+
+/* 自定义 "类" 的实例. */
+function TestError(msg) {
+    this.message = msg;
+    this.name = this.constructor.name;
+    this.toString = () => `${this.name}: ${this.message}`;
+}
+
+throw new TestError("foo"); /* new 关键字不可省略. */
+
+```
+
+## try...catch 语句
+
+try...catch 语句标记一块待尝试的语句, 若语句出现异常 (包括主动使用 throw 语句抛出的异常), 该异常会被 try...catch 语句捕获:
+
+```js
+try {
+    throw new java.lang.RuntimeException("hello");
+} catch (e) {
+    console.log(e.message); // "hello"
+}
+```
+
+try...catch 语句必须有 try 代码块, 最多 1 个 catch 代码块 (catch 代码块省略时, 则必须存在 finally 代码块).
+
+## catch 块
+
+又名 "捕捉块".
+
+使用 catch 块处理在 try 代码块中产生的异常.  
+catch 块中的语句只有 try 代码块中抛出异常时才会执行.
+
+```js
+try {
+    0 === 1;
+} catch (e) {
+    /* 不会执行, 因为 try 块中无异常. */
+    console.log(e.message);
+}
+```
+
+catch 块中的异常信息对象 (通常用 e 或 ex 表示) 包含了异常的基本信息, 如 [ message / name / javaException / stack ] 等, 详见 [Error 对象](#error 对象) 章节.
+
+Rhino 内置的 token 解析器可以解析像 Java 语言一样的多 catch 语句:
+
+```badjs
+function classForName(name) {
+    try {
+        return java.lang.Class.forName(name);
+    } catch (e if e.javaException instanceof java.lang.ClassNotFoundException) {
+        print(`Class ${name} not found`);
+    } catch (e if e.javaException instanceof java.lang.NullPointerException) {
+        print("Class name is null");
+    }
+}
+
+classForName("NonExistingClass"); // Class NonExistingClass not found
+classForName(null); // Class name is null
+```
+
+上述示例代码在 AutoJs6 可正常运行并返回预期结果, 但不符合 ECMAScript 语法, 且暂未发现任何可以解析此语法的 IDE, 使用后会造成 IDE 报错并在格式化代码时出现排版异常.
+
+使用传统的单 catch 块语句可能会是更好的选择:
+
+```js
+try {
+    return java.lang.Class.forName(name);
+} catch (e) {
+    if (e.javaException instanceof java.lang.ClassNotFoundException) {
+        print(`Class ${name} not found`);
+    } else if (e.javaException instanceof java.lang.NullPointerException) {
+        print("Class name is null");
+    }
+}
+```
+
+## finally 块
+
+finally 块中的语句无论 try 代码块是否抛出异常都会执行.
+
+```js
+try {
+    /* 打开并写入文件, 此处可能出现异常. */
+} catch (e) {
+    /* 处理异常. */
+} finally {
+    /* 关闭文件, 释放资源. */
+}
+```
+
+finally 块存在时, catch 块可省略:
+
+```js
+try {
+    /* 打开并写入文件, 此处可能出现异常. */
+} finally {
+    /* 关闭文件, 释放资源, 然后将异常重新抛出 (因为没有 catch 块捕获异常). */
+}
+```
+
+如果 finally 块有返回值, 该值会是整个 try...catch...finally 流程的返回值, 而不论在 try 和 catch 块中语句的返回值:
+
+```js
+function f() {
+    try {
+        console.log(0);
+        throw "error";
+    } catch (e) {
+        console.log(1);
+        return true; /* return 语句被暂时搁置, 直至 finally 块语句全部执行完成. */
+        console.log(2); /* 不可达. */
+    } finally {
+        console.log(3);
+        return false; /* 覆盖上一个 return 语句. */
+        console.log(4); /* 不可达. */
+    }
+    /* `return false` 已执行. */
+    console.log(5); /* 不可达. */
+}
+
+let res = f(); // 控制台打印 0, 1, 3
+console.log(res); // false
+```
+
+# Error 对象
+
+Error 对象是一个 JavaScript 构造函数, 它的实例通常由 [catch 块](#catch-块) 中的参数引用, 或通过 new 关键字产生相应的 Error 实例对象:
+
+```js
+try {
+    let err = new Error("test");
+    console.log(err instanceof Error); // true
+    throw err;
+} catch (e) {
+    console.log(e instanceof Error); // true
+}
+```
+
+对于 AutoJs6, catch 块中的引用对象 (通常用 e 或 ex 表示) 还由 Rhino 引擎额外封装了 [javaException](#p-javaexception) 和 [rhinoException](#p-rhinoexception) 两个对象.
+
+---
+
+<p style="font: bold 2em sans-serif; color: #FF7043">Error</p>
+
+---
+
+## [@] Error
+
+## [p#] name
+
+- { [string](dataTypes#string) }
+
+表示 Error 类型的名称, 初始值为 "Error".
+
+```js
+console.log(new SyntaxError('hello').name); // "SyntaxError"
+
+try {
+    throw TypeError('world');
+} catch (e) {
+    console.log(e.name); // "TypeError"
+}
+```
+
+## [p#] message
+
+- { [string](dataTypes#string) }
+
+错误相关信息的描述.
+
+```js
+console.log(new SyntaxError('hello').name); // "hello"
+
+try {
+    Math.random().toFixed(-1);
+} catch (e) {
+    console.log(e.message); // "精度 -1 超出范围."
+}
+```
+
+## [p#] stack
+
+- { [string](dataTypes#string) | [any](dataTypes#any) }
+
+stack 属性描述了 Error 对象的 [栈追踪 (Stack Trace)](https://zh.wikipedia.org/wiki/%E6%A0%88%E8%BF%BD%E8%B8%AA) 信息.
+
+栈追踪描述了程序运行过程中某个时间点上的活跃栈帧信息.  
+用户在日志中可以查看程序出错时的栈追踪信息, 用以自行排查代码异常或将栈追踪信息反馈给开发者.
+
+```js
+try {
+    !function test() {
+        throw Error('hello');
+    }();
+} catch (e) {
+    /* 打印栈追踪信息. */
+    console.log(e.stack);
+}
+```
+
+一个已格式化的栈追踪信息示例:
+
+```text
+ReferenceError: FAIL is not defined
+   at Constraint.execute (deltablue.js:525:2)
+   at Constraint.recalculate (deltablue.js:424:21)
+   at Planner.addPropagate (deltablue.js:701:6)
+   at Constraint.satisfy (deltablue.js:184:15)
+   at Planner.incrementalAdd (deltablue.js:591:21)
+   at Constraint.addConstraint (deltablue.js:162:10)
+   at Constraint.BinaryConstraint (deltablue.js:346:7)
+   at Constraint.EqualityConstraint (deltablue.js:515:38)
+   at chainTest (deltablue.js:807:6)
+   at deltaBlue (deltablue.js:879:2)
+```
+
+栈追踪的信息量由栈帧数量体现, 通过 [Error.stackTraceLimit](#p-stacktracelimit) 可设置栈帧数量.  
+栈追踪信息可通过 [Error.captureStackTrace](#m-capturestacktrace) 附加到一个 JavaScript 对象 (如 obj) 上, 通过访问 obj.stack 可随时查看栈追踪信息.  
+[Error.prepareStackTrace](#m-preparestacktrace) 还可以自定义栈追踪信息的输出格式.
+
+stack 属性默认返回 string 类型, 如果设置了 prepareStackTrace 格式函数, 则 stack 类型将与格式函数的返回值类型一致:
+
+```js
+Error.prepareStackTrace = function (e, frames) {
+    return frames.reduce((a, b) => a.concat([ b.getFunctionName() ]), []);
+};
+try {
+    !function test() {
+        throw Error('hello');
+    }();
+} catch (e) {
+    /* 此时 stack 是一个数组. */
+    console.log(Array.isArray(e.stack)); // true
+}
+```
+
+## [p#] lineNumber
+
+- { [number](dataTypes#number) }
+
+表示抛出异常的代码在源文件中的行号.
+
+```js
+try {
+    throw Error("hello");
+} catch (e) {
+    console.log(e.lineNumber); /* e.g. 5 */
+}
+```
+
+## [p#] fileName
+
+- { [string](dataTypes#string) }
+
+表示抛出异常的代码所在源文件的文件路径.
+
+```js
+try {
+    throw Error("hello");
+} catch (e) {
+    console.log(e.fileName); /* e.g. "/storage/emulated/0/Scripts/test.js" */
+}
+```
+
+## [p#] javaException
+
+- { [java.lang.Exception](#java) }
+
+由 Java 方法抛出的原始异常.
+
+```js
+try {
+    /* 一些其他代码, 可能会抛出异常. */
+    /* ... */
+
+    /* 启动一个不存在的 Activity. */
+    app.startActivity({});
+} catch (e) {
+    // '[JavaException: android.content.ActivityNotFoundException: No Activity found to handle Intent { flg=0x10000000 }]'
+    console.log(e);
+
+    console.log(e.javaException !== undefined); // true
+
+    /* 借助 e.javaException 类型处理不同的异常. */
+    if (e.javaException instanceof org.json.JSONException) {
+        console.error('JSON 解析错误');
+        throw (e);
+    }
+    if (e.javaException instanceof android.content.ActivityNotFoundException) {
+        console.error('指定的 Activity 不存在');
+        throw (e);
+    }
+    if (e.javaException instanceof ScriptInterruptedException) {
+        /* 忽略错误, 直接退出. */
+        exit();
+    }
+    if (e.javaException instanceof java.lang.RuntimeException) {
+        /* ... */
+        throw (e);
+    }
+    /* ... */
+}
+```
+
+## [p#] rhinoException
+
+- { [java.lang.Exception](#java) }
+
+由 Rhino 运行时 (Runtime) 包装的异常对象.
+
+```js
+try {
+    f();
+} catch (e) {
+    // '[ReferenceError: "f" is not defined.]'
+    console.log(e);
+
+    /* e 是 ReferenceError 类型. */
+    console.log(e instanceof ReferenceError); // true
+    /* 同时也是 Error 类型. */
+    console.log(e instanceof Error); // true
+
+    /* 对象 e 是 Error 类型, 为 JavaScript 异常. */
+    /* 但 e.rhinoException 是 java.lang.Exception 类型, 为 Java 异常. */
+    console.log(e.rhinoException instanceof java.lang.Exception); // true
+    console.log(e.rhinoException instanceof org.mozilla.javascript.EcmaError); // true
+    console.log(e.rhinoException instanceof Error); // false
+    
+    /* 因为 try 代码块没有触发 Java 异常, 因此 e.javaException 是 undefined. */
+    console.log(e.javaException); // undefined
+}
+```
+
+## [m#] toString
+
+### toString()
+
+- <ins>**returns**</ins> { [string](dataTypes#string) }
+
+返回一个表示指定 Error 对象的字符串.
+
+```js
+let errA = new Error('hello');
+console.log(errA.toString()); // "Error: hello"
+
+let errB = new TypeError('world');
+console.log(errB.toString()); // "TypeError: world"
+
+errB.name = 'Banana';
+console.log(errB.toString()); // "Banana: world"
+
+errB.message = "yellow";
+console.log(errB.toString()); // "Banana: yellow"
+```
+
+## [m#] toSource
+
+### toSource()
+
+- <ins>**returns**</ins> { [string](dataTypes#string) }
+
+返回表示 Error 对象源代码的字符串.
+
+```js
+let err = new Error('hello');
+console.log(err.toSource()); // (new Error("hello", ""))
+
+try {
+    Math.random().toFixed(-1);
+} catch (e) {
+    console.log(e.toSource()); // (new RangeError("\u7cbe\u5ea6 -1 \u8d85\u51fa\u8303\u56f4.", "\u8fdc\u7a0b$Untitled-52js", 3))
+    throw eval(e.toSource()); /* 可供 eval 作为参数接收. */
+}
+```
+
+## [p] stackTraceLimit
+
+- [ Infinity ] { [number](dataTypes#number) }
+
+设置或读取收集的栈追踪信息的栈帧数量.
+
+> 注: 该属性虽以 [数据描述符](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty#%E6%8F%8F%E8%BF%B0) 描述, 但通常以 [存取描述符](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty#%E6%8F%8F%E8%BF%B0) 方式使用, 且 setter 更具有实际意义.
+
+栈帧默认值为 Infinity, 即无数量限制:
+
+```js
+console.log(Error.stackTraceLimit); // Infinity
+```
+
+设置一个数量限制:
+
+```js
+Error.stackTraceLimit = 23;
+console.log(Error.stackTraceLimit); // 23
+```
+
+恢复默认的数量限制值 (Infinity) 有多种方式:
+
+```js
+/* 直接设置 Infinity. */
+Error.stackTraceLimit = Infinity;
+
+/* 设置 NaN. */
+Error.stackTraceLimit = NaN;
+
+/* 设置负数. */
+Error.stackTraceLimit = -1;
+
+/* 设置无法转换为非 NaN 的 number 类型. */
+Error.stackTraceLimit = "hello";
+```
+
+注意与 0 的区分, 将数量限制设置为 0 表示不显示栈追踪信息, 即禁用栈追踪收集.
+
+```js
+let infoA = {};
+let infoB = {};
+
+try {
+    throw Error("hello");
+} catch (e) {
+    Error.captureStackTrace(infoA);
+
+    Error.stackTraceLimit = 0;
+    Error.captureStackTrace(infoB);
+
+    console.log(infoA.stack); /* 打印栈追踪信息. */
+    console.log(infoB.stack); /* 打印空字符串. */
+
+    Error.stackTraceLimit = Infinity;
+    Error.captureStackTrace(infoB);
+    console.log(infoB.stack); /* 打印栈追踪信息. */
+}
+```
+
+> 参阅: [V8 Dev](https://v8.dev/docs/stack-trace-api)
+
+## [m] prepareStackTrace
+
+用于自定义栈追踪信息格式, 该属性以函数形式发挥作用, 因此文档称之为 "格式函数".
+
+> 注: 该属性虽以 [数据描述符](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty#%E6%8F%8F%E8%BF%B0) 描述, 但通常以 [存取描述符](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty#%E6%8F%8F%E8%BF%B0) 方式使用, 且 setter 更具有实际意义.
+
+格式函数默认值为 undefined, 即使用默认格式输出栈追踪信息:
+
+```js
+console.log(Error.prepareStackTrace); // undefined
+```
+
+设置自定义格式函数:
+
+```js
+Error.prepareStackTrace = function (e, frames) {
+    /* ... */
+};
+```
+
+恢复默认的格式函数:
+
+```js
+/* 直接设置 null 或 undefined. */
+Error.prepareStackTrace = undefined;
+
+/* 除函数, null 和 undefined 外, 赋值其他类型的操作将被忽略, 不会有任何效果. */
+Error.prepareStackTrace = "hello"; /* 无任何效果. */
+```
+
+> 参阅: [V8 Dev](https://v8.dev/docs/stack-trace-api)
+
+### prepareStackTrace(errorObj, stackTraces)
+
+- **errorObj** { [Error](#error 对象) } - 异常对象的引用
+- **stackTraces** { [NodeJS.CallSite](https://microsoft.github.io/PowerBI-JavaScript/interfaces/_node_modules__types_node_globals_d_.nodejs.callsite.html)[[]](dataTypes#array) } - 栈追踪数组 (栈帧组)
+- <ins>**returns**</ins> { [any](dataTypes#any) }
+
+设置或查看用于自定义栈追踪信息的格式函数.
+
+```js
+Error.prepareStackTrace = function (e, frames) {
+    /* ... */
+};
+```
+
+上述示例中的 frames (以及方法签名中的 stackTraces) 表示栈帧组, 每一个栈帧都是 [NodeJS.CallSite](https://microsoft.github.io/PowerBI-JavaScript/interfaces/_node_modules__types_node_globals_d_.nodejs.callsite.html) 类型.
+
+下面列出了部分栈帧可用的属性或方法:
+
+- `[m#]` getColumnNumber
+- `[m#]` getEvalOrigin
+- `[m#]` getFileName
+- `[m#]` getFunction
+- `[m#]` getFunctionName
+- `[m#]` getLineNumber
+- `[m#]` getMethodName
+- `[m#]` getThis
+- `[m#]` getTypeName
+- `[m#]` isConstructor
+- `[m#]` isEval
+- `[m#]` isNative
+- `[m#]` isToplevel
+
+格式函数的返回值决定了 stack 属性的类型值.
+
+```js
+/* 格式函数返回值为 string 类型. */
+Error.prepareStackTrace = function (e, frames) {
+    return frames.map(f => `${f.getFunctionName()}: ${f.getLineNumber()}`).join('\n');
+};
+try {
+    !function test() {
+        throw Error('hello');
+    }();
+} catch (e) {
+    /* 与格式函数返回值同为 string 类型. */
+    console.log(e.stack);
+}
+```
+
+## [m] captureStackTrace
+
+附加 stack 属性 (栈追踪信息) 到任意对象上.
+
+> 参阅: [V8 Dev](https://v8.dev/docs/stack-trace-api)
+
+### captureStackTrace(errorObj, constructorOpt)
+
+- **errorObj** { [object](dataTypes#object) } - 用于附加 stack 属性的任意对象
+- **constructorOpt** { [Function](dataTypes#function) } - 用于在栈追踪信息中触发隐藏的函数
+- <ins>**returns**</ins> { [void](dataTypes#void) }
+
+附加 stack 属性 (栈追踪信息) 到任意对象上, 并支持在栈追踪信息中隐藏以指定的调用函数为起点的栈帧信息.
+
+```js
+let info = {};
+try {
+    function a() {
+        Error.captureStackTrace(info);
+        return (0.5).toFixed(-1);
+    }
+
+    function b() {
+        a();
+    }
+
+    !function c() {
+        b();
+    }();
+} catch (e) {
+    /* info 对象被附加了 stack 属性. */
+    /* stack 信息中包含函数 a, b, c 的栈帧信息, 顺序为 a (栈顶) -> b -> c (栈底). */
+    console.log(info.stack);
+}
+```
+
+部分信息对于用户或开发者可能没有参考意义, 此时可使用 constructorOpt 参数隐藏部分栈帧信息:
+
+```js
+let info = {};
+try {
+    function a() {
+        /* b (含) 及其栈顶方向的所有函数调用均将隐藏. */
+        Error.captureStackTrace(info, b);
+        return (0.5).toFixed(-1);
+    }
+
+    function b() {
+        a();
+    }
+
+    !function c() {
+        b();
+    }();
+} catch (e) {
+    /* stack 信息中 b 和 a 被隐藏, 仅 c 被保留. */
+    console.log(info.stack);
+}
+```
+
+上述示例中的 `b` 如果替换为 `c`, 则所有栈帧全部被隐藏, `info.stack` 将返回 `undefined` (即 stack 没有被附加到 info 对象上):
+
+```js
+let info = {};
+try {
+    function a() {
+        /* 传入栈底方法 (c) 将不会触发 stack 属性的附加操作. */
+        Error.captureStackTrace(info, c);
+        return (0.5).toFixed(-1);
+    }
+
+    function b() {
+        a();
+    }
+
+    !function c() {
+        b();
+    }();
+} catch (e) {
+    /* stack 信息未被附加. */
+    console.log(info.stack); // undefined
+    console.log("stack" in info); // false
+}
+```
+
+如果传入一个栈帧中不存在的函数, 则 `info.stack` 将返回 `""` (空字符串):
+
+```js
+let info = {};
+try {
+    function irrelevant() {
+        // Empty body.
+    }
+
+    function a() {
+        /* 传入一个与所有栈帧无关的函数, 将导致 stack 属性值变为空字符串. */
+        Error.captureStackTrace(info, irrelevant);
+        return (0.5).toFixed(-1);
+    }
+
+    function b() {
+        a();
+    }
+
+    !function c() {
+        b();
+    }();
+} catch (e) {
+    console.log(info.stack); // ""
+}
+```
\ No newline at end of file
diff --git a/api/files.md b/api/files.md
index 754f3c8..a70daba 100644
--- a/api/files.md
+++ b/api/files.md
@@ -1,17 +1,22 @@
-# Files
+# 文件 (Files)
 
-> Stability: 2 - Stable
+---
 
-files模块提供了一些常见的文件处理，包括文件读写、移动、复制、删掉等。
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
 
-一次性的文件读写可以直接使用`files.read()`, `files.write()`, `files.append()`等方便的函数，但如果需要频繁读写或随机读写，则使用`open()`函数打开一个文件对象来操作文件，并在操作完毕后调用`close()`函数关闭文件。
+---
+
+files模块提供了一些常见的文件处理, 包括文件读写、移动、复制、删掉等.
+
+一次性的文件读写可以直接使用`files.read()`, `files.write()`, `files.append()`等方便的函数, 但如果需要频繁读写或随机读写, 则使用`open()`函数打开一个文件对象来操作文件, 并在操作完毕后调用`close()`函数关闭文件.
 
 ## files.isFile(path)
 
 * `path` {string} 路径
 * 返回 {boolean}
 
-返回路径path是否是文件。
+返回路径path是否是文件.
 
 ```
 log(files.isDir("/sdcard/文件夹/")); //返回false
@@ -23,7 +28,7 @@ log(files.isDir("/sdcard/文件.txt")); //返回true
 * `path` {string} 路径
 * 返回 {boolean}
 
-返回路径path是否是文件夹。
+返回路径path是否是文件夹.
 
 ```
 log(files.isDir("/sdcard/文件夹/")); //返回true
@@ -35,7 +40,7 @@ log(files.isDir("/sdcard/文件.txt")); //返回false
 * `path` {string} 路径
 * 返回 {boolean}
 
-返回文件夹path是否为空文件夹。如果该路径并非文件夹，则直接返回`false`。
+返回文件夹path是否为空文件夹. 如果该路径并非文件夹, 则直接返回`false`.
 
 ## files.join(parent, child)
 
@@ -43,14 +48,14 @@ log(files.isDir("/sdcard/文件.txt")); //返回false
 * `child` {string} 子路径
 * 返回 {string}
 
-连接两个路径并返回，例如`files.join("/sdcard/", "1.txt")`返回"/sdcard/1.txt"。
+连接两个路径并返回, 例如`files.join("/sdcard/", "1.txt")`返回"/sdcard/1.txt".
 
 ## files.create(path)
 
 * `path` {string} 路径
 * 返回 {boolean}
 
-创建一个文件或文件夹并返回是否创建成功。如果文件已经存在，则直接返回`false`。
+创建一个文件或文件夹并返回是否创建成功. 如果文件已经存在, 则直接返回`false`.
 
 ```
 files.create("/sdcard/新文件夹/");
@@ -61,7 +66,7 @@ files.create("/sdcard/新文件夹/");
 * `path` {string} 路径
 * 返回 {boolean}
 
-创建一个文件或文件夹并返回是否创建成功。如果文件所在文件夹不存在，则先创建他所在的一系列文件夹。如果文件已经存在，则直接返回`false`。
+创建一个文件或文件夹并返回是否创建成功. 如果文件所在文件夹不存在, 则先创建他所在的一系列文件夹. 如果文件已经存在, 则直接返回`false`.
 
 ```
 files.createWithDirs("/sdcard/新文件夹/新文件夹/新文件夹/1.txt");
@@ -72,23 +77,23 @@ files.createWithDirs("/sdcard/新文件夹/新文件夹/新文件夹/1.txt");
 * `path` {string} 路径
 * 返回 {boolean}
 
-返回在路径path处的文件是否存在。
+返回在路径path处的文件是否存在.
 
 ## files.ensureDir(path)
 
 * `path` {string} 路径
 
-确保路径path所在的文件夹存在。如果该路径所在文件夹不存在，则创建该文件夹。
+确保路径path所在的文件夹存在. 如果该路径所在文件夹不存在, 则创建该文件夹.
 
-例如对于路径"/sdcard/Download/ABC/1.txt"，如果/Download/文件夹不存在，则会先创建Download，再创建ABC文件夹。
+例如对于路径"/sdcard/Download/ABC/1.txt", 如果/Download/文件夹不存在, 则会先创建Download, 再创建ABC文件夹.
 
 ## files.read(path[, encoding = "utf-8"])
 
 * `path` {string} 路径
-* `encoding` {string} 字符编码，可选，默认为utf-8
+* `encoding` {string} 字符编码, 可选, 默认为utf-8
 * 返回 {string}
 
-读取文本文件path的所有内容并返回。如果文件不存在，则抛出`FileNotFoundException`。
+读取文本文件path的所有内容并返回. 如果文件不存在, 则抛出`FileNotFoundException`.
 
 ```
 log(files.read("/sdcard/1.txt"));
@@ -99,9 +104,9 @@ log(files.read("/sdcard/1.txt"));
 * `path` {string} 路径
 * 返回 {byte[]}
 
-读取文件path的所有内容并返回一个字节数组。如果文件不存在，则抛出`FileNotFoundException`。
+读取文件path的所有内容并返回一个字节数组. 如果文件不存在, 则抛出`FileNotFoundException`.
 
-注意，该数组是Java的数组，不具有JavaScript数组的forEach, slice等函数。
+注意, 该数组是Java的数组, 不具有JavaScript数组的forEach, slice等函数.
 
 一个以16进制形式打印文件的例子如下:
 
@@ -120,7 +125,7 @@ log(sb.toString());
 * `text` {string} 要写入的文本内容
 * `encoding` {string} 字符编码
 
-把text写入到文件path中。如果文件存在则覆盖，不存在则创建。
+把text写入到文件path中. 如果文件存在则覆盖, 不存在则创建.
 
 ```
 var text = "文件内容";
@@ -133,9 +138,9 @@ app.viewFile("/sdcard/1.txt");
 ## files.writeBytes(path, bytes)
 
 * `path` {string} 路径
-* `bytes` {byte[]} 字节数组，要写入的二进制数据
+* `bytes` {byte[]} 字节数组, 要写入的二进制数据
 
-把bytes写入到文件path中。如果文件存在则覆盖，不存在则创建。
+把bytes写入到文件path中. 如果文件存在则覆盖, 不存在则创建.
 
 ## files.append(path, text[, encoding = 'utf-8'])
 
@@ -143,7 +148,7 @@ app.viewFile("/sdcard/1.txt");
 * `text` {string} 要写入的文本内容
 * `encoding` {string} 字符编码
 
-把text追加到文件path的末尾。如果文件不存在则创建。
+把text追加到文件path的末尾. 如果文件不存在则创建.
 
 ```
 var text = "追加的文件内容";
@@ -156,9 +161,9 @@ app.viewFile("/sdcard/1.txt");
 ## files.appendBytes(path, text[, encoding = 'utf-8'])
 
 * `path` {string} 路径
-* `bytes` {byte[]} 字节数组，要写入的二进制数据
+* `bytes` {byte[]} 字节数组, 要写入的二进制数据
 
-把bytes追加到文件path的末尾。如果文件不存在则创建。
+把bytes追加到文件path的末尾. 如果文件不存在则创建.
 
 ## files.copy(fromPath, toPath)
 
@@ -166,7 +171,7 @@ app.viewFile("/sdcard/1.txt");
 * `toPath` {string} 复制到的文件路径
 * 返回 {boolean}
 
-复制文件，返回是否复制成功。例如`files.copy("/sdcard/1.txt", "/sdcard/Download/1.txt")`。
+复制文件, 返回是否复制成功. 例如`files.copy("/sdcard/1.txt", "/sdcard/Download/1.txt")`.
 
 ## files.move(fromPath, toPath)
 
@@ -174,7 +179,7 @@ app.viewFile("/sdcard/1.txt");
 * `toPath` {string} 移动到的文件路径
 * 返回 {boolean}
 
-移动文件，返回是否移动成功。例如`files.move("/sdcard/1.txt", "/sdcard/Download/1.txt")`会把1.txt文件从sd卡根目录移动到Download文件夹。
+移动文件, 返回是否移动成功. 例如`files.move("/sdcard/1.txt", "/sdcard/Download/1.txt")`会把1.txt文件从sd卡根目录移动到Download文件夹.
 
 ## files.rename(path, newName)
 
@@ -182,7 +187,7 @@ app.viewFile("/sdcard/1.txt");
 * `newName` {string} 要重命名的新文件名
 * 返回 {boolean}
 
-重命名文件，并返回是否重命名成功。例如`files.rename("/sdcard/1.txt", "2.txt")`。
+重命名文件, 并返回是否重命名成功. 例如`files.rename("/sdcard/1.txt", "2.txt")`.
 
 ## files.renameWithoutExtension(path, newName)
 
@@ -190,35 +195,35 @@ app.viewFile("/sdcard/1.txt");
 * `newName` {string} 要重命名的新文件名
 * 返回 {boolean}
 
-重命名文件，不包含拓展名，并返回是否重命名成功。例如`files.rename("/sdcard/1.txt", "2")`会把"1.txt"重命名为"2.txt"。
+重命名文件, 不包含拓展名, 并返回是否重命名成功. 例如`files.rename("/sdcard/1.txt", "2")`会把"1.txt"重命名为"2.txt".
 
 ## files.getName(path)
 
 * `path` {string} 路径
 * 返回 {string}
 
-返回文件的文件名。例如`files.getName("/sdcard/1.txt")`返回"1.txt"。
+返回文件的文件名. 例如`files.getName("/sdcard/1.txt")`返回"1.txt".
 
 ## files.getNameWithoutExtension(path)
 
 * `path` {string} 路径
 * 返回 {string}
 
-返回不含拓展名的文件的文件名。例如`files.getName("/sdcard/1.txt")`返回"1"。
+返回不含拓展名的文件的文件名. 例如`files.getName("/sdcard/1.txt")`返回"1".
 
 ## files.getExtension(path)
 
 * `path` {string} 路径
 * 返回 {string}
 
-返回文件的拓展名。例如`files.getExtension("/sdcard/1.txt")`返回"txt"。
+返回文件的拓展名. 例如`files.getExtension("/sdcard/1.txt")`返回"txt".
 
 ## files.remove(path)
 
 * `path` {string} 路径
 * 返回 {boolean}
 
-删除文件或**空文件夹**，返回是否删除成功。
+删除文件或**空文件夹**, 返回是否删除成功.
 
 ## files.removeDir(path)
 
@@ -226,35 +231,35 @@ app.viewFile("/sdcard/1.txt");
 * `path` {string} 路径
 * 返回 {boolean}
 
-删除文件夹，如果文件夹不为空，则删除该文件夹的所有内容再删除该文件夹，返回是否全部删除成功。
+删除文件夹, 如果文件夹不为空, 则删除该文件夹的所有内容再删除该文件夹, 返回是否全部删除成功.
 
 ## files.getSdcardPath()
 
 * 返回 {string}
 
-返回SD卡路径。所谓SD卡，即外部存储器。
+返回SD卡路径. 所谓SD卡, 即外部存储器.
 
 ## files.cwd()
 
 * 返回 {string}
 
-返回脚本的"当前工作文件夹路径"。该路径指的是，如果脚本本身为脚本文件，则返回这个脚本文件所在目录；否则返回`null`获取其他设定路径。
+返回脚本的"当前工作文件夹路径". 该路径指的是, 如果脚本本身为脚本文件, 则返回这个脚本文件所在目录；否则返回`null`获取其他设定路径.
 
-例如，对于脚本文件"/sdcard/脚本/1.js"运行`files.cwd()`返回"/sdcard/脚本/"。
+例如, 对于脚本文件"/sdcard/脚本/1.js"运行`files.cwd()`返回"/sdcard/脚本/".
 
 ## files.path(relativePath)
 
 * `relativePath` {string} 相对路径
 * 返回 {string}
 
-返回相对路径对应的绝对路径。例如`files.path("./1.png")`，如果运行这个语句的脚本位于文件夹"/sdcard/脚本/"中，则返回`"/sdcard/脚本/1.png"`。
+返回相对路径对应的绝对路径. 例如`files.path("./1.png")`, 如果运行这个语句的脚本位于文件夹"/sdcard/脚本/"中, 则返回`"/sdcard/脚本/1.png"`.
 
 ## files.listDir(path[, filter])
 
 * `path` {string} 路径
-* `filter` {Function} 过滤函数，可选。接收一个`string`参数（文件名），返回一个`boolean`值。
+* `filter` {Function} 过滤函数, 可选. 接收一个`string`参数（文件名）, 返回一个`boolean`值.
 
-列出文件夹path下的满足条件的文件和文件夹的名称的数组。如果不加filter参数，则返回所有文件和文件夹。
+列出文件夹path下的满足条件的文件和文件夹的名称的数组. 如果不加filter参数, 则返回所有文件和文件夹.
 
 列出sdcard目录下所有文件和文件夹为:
 
@@ -275,66 +280,66 @@ log(jsFiles);
 
 ## open(path[, mode = "r", encoding = "utf-8", bufferSize = 8192])
 
-* `path` {string} 文件路径，例如"/sdcard/1.txt"。
-* `mode` {string} 文件打开模式，包括:
-    * "r": 只读文本模式。该模式下只能对文件执行**文本**读取操作。
-    * "w": 只写文本模式。该模式下只能对文件执行**文本**覆盖写入操作。
-    * "a": 附加文本模式。该模式下将会把写入的文本附加到文件末尾。
-    * "rw": 随机读写文本模式。该模式下将会把写入的文本附加到文件末尾。  
-      目前暂不支持二进制模式，随机读写模式。
-* `encoding` {string} 字符编码。
-* `bufferSize` {number} 文件读写的缓冲区大小。
+* `path` {string} 文件路径, 例如"/sdcard/1.txt".
+* `mode` {string} 文件打开模式, 包括:
+    * "r": 只读文本模式. 该模式下只能对文件执行**文本**读取操作.
+    * "w": 只写文本模式. 该模式下只能对文件执行**文本**覆盖写入操作.
+    * "a": 附加文本模式. 该模式下将会把写入的文本附加到文件末尾.
+    * "rw": 随机读写文本模式. 该模式下将会把写入的文本附加到文件末尾.   
+      目前暂不支持二进制模式, 随机读写模式.
+* `encoding` {string} 字符编码.
+* `bufferSize` {number} 文件读写的缓冲区大小.
 
-打开一个文件。根据打开模式返回不同的文件对象。包括：
+打开一个文件. 根据打开模式返回不同的文件对象. 包括：
 
-* "r": 返回一个ReadableTextFile对象。
-* "w", "a": 返回一个WritableTextFile对象。
+* "r": 返回一个ReadableTextFile对象.
+* "w", "a": 返回一个WritableTextFile对象.
 
-对于"w"模式，如果文件并不存在，则会创建一个，已存在则会清空该文件内容；其他模式文件不存在会抛出FileNotFoundException。
+对于"w"模式, 如果文件并不存在, 则会创建一个, 已存在则会清空该文件内容；其他模式文件不存在会抛出FileNotFoundException.
 
 # ReadableTextFile
 
-可读文件对象。
+可读文件对象.
 
 ## ReadableTextFile.read()
 
-返回该文件剩余的所有内容的字符串。
+返回该文件剩余的所有内容的字符串.
 
 ## ReadableTextFile.read(maxCount)
 
 * `maxCount` {Number} 最大读取的字符数量
 
-读取该文件接下来最长为maxCount的字符串并返回。即使文件剩余内容不足maxCount也不会出错。
+读取该文件接下来最长为maxCount的字符串并返回. 即使文件剩余内容不足maxCount也不会出错.
 
 ## ReadableTextFile.readline()
 
-读取一行并返回（不包含换行符）。
+读取一行并返回（不包含换行符）.
 
 ## ReadableTextFile.readlines()
 
-读取剩余的所有行，并返回它们按顺序组成的字符串数组。
+读取剩余的所有行, 并返回它们按顺序组成的字符串数组.
 
 ## close()
 
-关闭该文件。
+关闭该文件.
 
 **打开一个文件不再使用时务必关闭**
 
 # PWritableTextFile
 
-可写文件对象。
+可写文件对象.
 
 ## PWritableTextFile.write(text)
 
 * `text` {string} 文本
 
-把文本内容text写入到文件中。
+把文本内容text写入到文件中.
 
 ## PWritableTextFile.writeline(line)
 
 * `text` {string} 文本
 
-把文本line写入到文件中并写入一个换行符。
+把文本line写入到文件中并写入一个换行符.
 
 ## PWritableTextFile.writelines(lines)
 
@@ -344,10 +349,10 @@ log(jsFiles);
 
 ## PWritableTextFile.flush()
 
-把缓冲区内容输出到文件中。
+把缓冲区内容输出到文件中.
 
 ## PWritableTextFile.close()
 
-关闭文件。同时会被缓冲区内容输出到文件。
+关闭文件. 同时会被缓冲区内容输出到文件.
 
-**打开一个文件写入后，不再使用时务必关闭，否则文件可能会丢失**
+**打开一个文件写入后, 不再使用时务必关闭, 否则文件可能会丢失**
diff --git a/api/floaty.md b/api/floaty.md
index 4e3bb8c..f4c67a7 100644
--- a/api/floaty.md
+++ b/api/floaty.md
@@ -1,8 +1,15 @@
-# Floaty
+# 悬浮窗 (Floaty)
 
-floaty模块提供了悬浮窗的相关函数，可以在屏幕上显示自定义悬浮窗，控制悬浮窗大小、位置等。
+---
 
-悬浮窗在脚本停止运行时会自动关闭，因此，要保持悬浮窗不被关闭，可以用一个空的setInterval来实现，例如：
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
+
+---
+
+floaty模块提供了悬浮窗的相关函数, 可以在屏幕上显示自定义悬浮窗, 控制悬浮窗大小、位置等.
+
+悬浮窗在脚本停止运行时会自动关闭, 因此, 要保持悬浮窗不被关闭, 可以用一个空的setInterval来实现, 例如：
 
 ```
 setInterval(()=>{}, 1000);
@@ -12,11 +19,11 @@ setInterval(()=>{}, 1000);
 
 * `layout` {xml} | {View} 悬浮窗界面的XML或者View
 
-指定悬浮窗的布局，创建并**显示**一个悬浮窗，返回一个`FloatyWindow`对象。
+指定悬浮窗的布局, 创建并**显示**一个悬浮窗, 返回一个`FloatyWindow`对象.
 
-该悬浮窗自带关闭、调整大小、调整位置按键，可根据需要调用`setAdjustEnabled()`函数来显示或隐藏。
+该悬浮窗自带关闭、调整大小、调整位置按键, 可根据需要调用`setAdjustEnabled()`函数来显示或隐藏.
 
-其中layout参数可以是xml布局或者一个View，更多信息参见ui模块的说明。
+其中layout参数可以是xml布局或者一个View, 更多信息参见ui模块的说明.
 
 例子：
 
@@ -31,9 +38,9 @@ setTimeout(()=>{
 }, 2000);
 ```
 
-这段代码运行后将会在屏幕上显示悬浮文字，并在两秒后消失。
+这段代码运行后将会在屏幕上显示悬浮文字, 并在两秒后消失.
 
-另外，因为脚本运行的线程不是UI线程，而所有对控件的修改操作需要在UI线程执行，此时需要用`ui.run`，例如:
+另外, 因为脚本运行的线程不是UI线程, 而所有对控件的修改操作需要在UI线程执行, 此时需要用`ui.run`, 例如:
 
 ```
 ui.run(function(){
@@ -41,17 +48,17 @@ ui.run(function(){
 });
 ```
 
-有关返回的`FloatyWindow`对象的说明，参见下面的`FloatyWindow`章节。
+有关返回的`FloatyWindow`对象的说明, 参见下面的`FloatyWindow`章节.
 
 ## floaty.rawWindow(layout)
 
 * `layout` {xml} | {View} 悬浮窗界面的XML或者View
 
-指定悬浮窗的布局，创建并**显示**一个原始悬浮窗，返回一个`FloatyRawWindow`对象。
+指定悬浮窗的布局, 创建并**显示**一个原始悬浮窗, 返回一个`FloatyRawWindow`对象.
 
-与`floaty.window()`函数不同的是，该悬浮窗不会增加任何额外设施（例如调整大小、位置按钮），您可以根据自己需要编写任何布局。
+与`floaty.window()`函数不同的是, 该悬浮窗不会增加任何额外设施（例如调整大小、位置按钮）, 您可以根据自己需要编写任何布局.
 
-而且，该悬浮窗支持完全全屏，可以覆盖状态栏，因此可以做护眼模式之类的应用。
+而且, 该悬浮窗支持完全全屏, 可以覆盖状态栏, 因此可以做护眼模式之类的应用.
 
 ```
 var w = floaty.rawWindow(
@@ -67,76 +74,76 @@ setTimeout(()=>{
 }, 2000);
 ```
 
-这段代码运行后将会在屏幕上显示悬浮文字，并在两秒后消失。
+这段代码运行后将会在屏幕上显示悬浮文字, 并在两秒后消失.
 
-有关返回的`FloatyRawWindow`对象的说明，参见下面的`FloatyRawWindow`章节。
+有关返回的`FloatyRawWindow`对象的说明, 参见下面的`FloatyRawWindow`章节.
 
 ## floaty.closeAll()
 
-关闭所有本脚本的悬浮窗。
+关闭所有本脚本的悬浮窗.
 
 # FloatyWindow
 
-悬浮窗对象，可通过`FloatyWindow.{id}`获取悬浮窗界面上的元素。例如, 悬浮窗window上一个控件的id为aaa, 那么`window.aaa`即可获取到该控件，类似于ui。
+悬浮窗对象, 可通过`FloatyWindow.{id}`获取悬浮窗界面上的元素. 例如, 悬浮窗window上一个控件的id为aaa, 那么`window.aaa`即可获取到该控件, 类似于ui.
 
 ## window.setAdjustEnabled(enabled)
 
 * `enabled` {boolean} 是否启用悬浮窗调整(大小、位置)
 
-如果enabled为true，则在悬浮窗左上角、右上角显示可供位置、大小调整的标示，就像控制台一样；
-如果enabled为false，则隐藏上述标示。
+如果enabled为true, 则在悬浮窗左上角、右上角显示可供位置、大小调整的标示, 就像控制台一样；
+如果enabled为false, 则隐藏上述标示.
 
 ## window.setPosition(x, y)
 
 * `x` {number} x
 * `x` {number} y
 
-设置悬浮窗位置。
+设置悬浮窗位置.
 
 ## window.getX()
 
-返回悬浮窗位置的X坐标。
+返回悬浮窗位置的X坐标.
 
 ## window.getY()
 
-返回悬浮窗位置的Y坐标。
+返回悬浮窗位置的Y坐标.
 
 ## window.setSize(width, height)
 
 * `width` {number} 宽度
 * `height` {number} 高度
 
-设置悬浮窗宽高。
+设置悬浮窗宽高.
 
 ## window.getWidht()
 
-返回悬浮窗宽度。
+返回悬浮窗宽度.
 
 ## window.getHeight()
 
-返回悬浮窗高度。
+返回悬浮窗高度.
 
 ## window.close()
 
-关闭悬浮窗。如果悬浮窗已经是关闭状态，则此函数将不执行任何操作。
+关闭悬浮窗. 如果悬浮窗已经是关闭状态, 则此函数将不执行任何操作.
 
-被关闭后的悬浮窗不能再显示。
+被关闭后的悬浮窗不能再显示.
 
 ## window.exitOnClose()
 
-使悬浮窗被关闭时自动结束脚本运行。
+使悬浮窗被关闭时自动结束脚本运行.
 
 # FloatyRawWindow
 
-原始悬浮窗对象，可通过`window.{id}`获取悬浮窗界面上的元素。例如, 悬浮窗window上一个控件的id为aaa, 那么`window.aaa`即可获取到该控件，类似于ui。
+原始悬浮窗对象, 可通过`window.{id}`获取悬浮窗界面上的元素. 例如, 悬浮窗window上一个控件的id为aaa, 那么`window.aaa`即可获取到该控件, 类似于ui.
 
 ## window.setTouchable(touchable)
 
 * `touchable` {Boolean} 是否可触摸
 
-设置悬浮窗是否可触摸，如果为true, 则悬浮窗将接收到触摸、点击等事件并且无法继续传递到悬浮窗下面；如果为false, 悬浮窗上的触摸、点击等事件将被直接传递到悬浮窗下面。处于安全考虑，被悬浮窗接收的触摸事情无法再继续传递到下层。
+设置悬浮窗是否可触摸, 如果为true, 则悬浮窗将接收到触摸、点击等事件并且无法继续传递到悬浮窗下面；如果为false, 悬浮窗上的触摸、点击等事件将被直接传递到悬浮窗下面. 处于安全考虑, 被悬浮窗接收的触摸事情无法再继续传递到下层.
 
-可以用此特性来制作护眼模式脚本。
+可以用此特性来制作护眼模式脚本.
 
 ```
 var w = floaty.rawWindow(
@@ -157,24 +164,24 @@ setTimeout(()=>{
 * `x` {number} x
 * `x` {number} y
 
-设置悬浮窗位置。
+设置悬浮窗位置.
 
 ## window.getX()
 
-返回悬浮窗位置的X坐标。
+返回悬浮窗位置的X坐标.
 
 ## window.getY()
 
-返回悬浮窗位置的Y坐标。
+返回悬浮窗位置的Y坐标.
 
 ## window.setSize(width, height)
 
 * `width` {number} 宽度
 * `height` {number} 高度
 
-设置悬浮窗宽高。
+设置悬浮窗宽高.
 
-特别地，如果设置为-1，则为占满全屏；设置为-2则为根据悬浮窗内容大小而定。例如：
+特别地, 如果设置为-1, 则为占满全屏；设置为-2则为根据悬浮窗内容大小而定. 例如：
 
 ```
 var w = floaty.rawWindow(
@@ -193,18 +200,18 @@ setTimeout(()=>{
 
 ## window.getWidht()
 
-返回悬浮窗宽度。
+返回悬浮窗宽度.
 
 ## window.getHeight()
 
-返回悬浮窗高度。
+返回悬浮窗高度.
 
 ## window.close()
 
-关闭悬浮窗。如果悬浮窗已经是关闭状态，则此函数将不执行任何操作。
+关闭悬浮窗. 如果悬浮窗已经是关闭状态, 则此函数将不执行任何操作.
 
-被关闭后的悬浮窗不能再显示。
+被关闭后的悬浮窗不能再显示.
 
 ## window.exitOnClose()
 
-使悬浮窗被关闭时自动结束脚本运行。
+使悬浮窗被关闭时自动结束脚本运行.
diff --git a/api/global.md b/api/global.md
new file mode 100644
index 0000000..ee89d4b
--- /dev/null
+++ b/api/global.md
@@ -0,0 +1,1023 @@
+# 全局对象 (Global)
+
+---
+
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Nov 20, 2022.</p>
+
+---
+
+在 JavaScript 中, [几乎一切都是对象](https://stackoverflow.com/questions/9108925/how-is-almost-everything-in-javascript-an-object/).  
+此处的全局 "对象" 包括 [ 变量 / 方法 / 构造器 ] 等.  
+全局对象随处可用, 包括 ECMA 标准内置对象 (如 [ Number / RegExp / String ] 等).
+
+AutoJs6 的内置模块均支持全局使用, 如 `app`, `images`, `device` 等.
+
+为便于使用, 一些 AutoJs6 模块中的方法也被全局化,  
+如 `images.captureScreen()`, `dialogs.alert()`, `app.launch()` 等.  
+全局化方法均以 `Global` 标签标注.
+
+脚本文件可直接运行使用, 也可作为模块被导入使用 (`require` 方法).  
+当作为模块使用时, `exports` 和 `module` 可作为全局对象使用.  
+另在 UI 模式下也有一些专属全局对象, 如 `activity`.
+
+## 覆写保护
+
+AutoJs6 对部分全局对象及内置模块增加了覆写保护.  
+以下全局声明或赋值将导致异常或非预期结果:
+
+```js
+/* 以全局对象 selector 为例. */
+
+/* 声明无效. */
+let selector = 1; /* 异常: 变量 selector 重复声明. */
+const selector = 1; /* 同上. */
+var selector = 1; /* 同上. */
+
+/* 覆写无效 (非严格模式). */
+selector = 1;
+typeof selector; // "function" - 静默失败, 覆写未生效.
+
+/* 覆写无效 (严格模式). */
+"use strict";
+selector = 1; /* 异常: 无法修改只读属性: selector. */
+```
+
+局部作用域不受上述情况影响:
+
+```js
+(function () {
+    let selector = 1;
+    return typeof selector;
+})(); // "number"
+```
+
+截至目前 (2022/10) 受覆写保护的对象有:
+
+```text
+selector
+continuation
+```
+
+---
+
+<p style="font: bold 2em sans-serif; color: #FF7043">global</p>
+
+---
+
+## [@] global
+
+global 为 AutoJs6 的默认顶级作用域对象, 可作为全局对象使用:
+
+```js
+typeof global; // "object"
+typeof global.sleep; // "function"
+```
+
+另, 访问顶级作用域对象也可通过以下代码:
+
+```js
+runtime.topLevelScope;
+```
+
+`runtime.topLevelScope` 本身有 `"global"` 属性, 因此全局对象 `global` 也一样拥有:
+
+```js
+typeof runtime.topLevelScope.global; // "object"
+
+global.global === global; // true
+global.global.global.global === global; // true
+```
+
+global 对象可以增加属性, 也可以覆写甚至删除属性 (部分被保护):
+
+```js
+global.hello = "hello";
+delete global.hello;
+```
+
+global 对象本身是可被覆写的:
+
+```js
+typeof global; // "object"
+global = 3;
+typeof global; // "number"
+```
+
+如果 global 对象被意外重写 (虽然概率很低),  
+可通过 `runtime.topLevelScope` 访问或还原:
+
+```js
+global = 3; /* 覆写 global 对象. */
+typeof global; // "number"
+typeof global.sleep; // "undefined"
+typeof runtime.topLevelScope.sleep; // "function"
+
+global = runtime.topLevelScope; /* 还原 global 对象. */
+typeof global; // "object"
+typeof global.sleep; // "function"
+```
+
+## [m] sleep
+
+### sleep(millis)
+
+**`Overload 1/3`** **`Non-UI`**
+
+- **millis** { [number](dataTypes#number) } - 休眠时间 (毫秒)
+- <ins>**returns**</ins> { [void](dataTypes#void) }
+
+使当前线程休眠一段时间.
+
+```js
+/* 休眠 9 秒钟. */
+sleep(9000);
+/* 休眠 9 秒钟 (使用科学计数法). */
+sleep(9e3);
+```
+
+### sleep(millisMin, millisMax)
+
+**`6.2.0`** **`Overload 2/3`** **`Non-UI`**
+
+- **millisMin** { [number](dataTypes#number) } - 休眠时间下限 (毫秒)
+- **millisMax** { [number](dataTypes#number) } - 休眠时间上限 (毫秒)
+- <ins>**returns**</ins> { [void](dataTypes#void) }
+
+使当前线程休眠一段时间, 该时间随机落在 millisMin 和 millisMax 之间.
+
+```js
+/* 随机休眠 3 - 5 秒钟. */
+sleep(3e3, 5e3);
+```
+
+### sleep(millis, bounds)
+
+**`6.2.0`** **`Overload 3/3`** **`Non-UI`**
+
+- **millis** { [number](dataTypes#number) } - 休眠时间 (毫秒)
+- **bounds** { [NumberString](dataTypes#NumberString) | [string](dataTypes#string) } - 浮动值
+- <ins>**returns**</ins> { [void](dataTypes#void) }
+
+使当前线程休眠一段时间, 该时间随机落在 millis ± bounds 之间.  
+bounds 参数为 [数字字符串](dataTypes#NumberString) 类型 (如 "12"), 或在字符串开头附加 "±" 明确参数含义 (如 "±12").
+
+```js
+/* 随机休眠 3 - 5 秒钟 (即 4 ± 1 秒钟). */
+sleep(4e3, "1e3");
+sleep(4e3, "±1e3"); /* 同上. */
+```
+
+---
+
+## [m] currentPackage
+
+### currentPackage()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [string](dataTypes#string) }
+
+获取最近一次监测到的应用包名, 并视为当前正在运行的应用包名.
+
+---
+
+## [m] currentActivity
+
+### currentActivity()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [string](dataTypes#string) }
+
+获取最近一次监测到的活动名称, 并视为当前正在运行的活动名称.
+
+---
+
+## [m] setClip
+
+### setClip(text)
+
+- **text** { [string](dataTypes#string) } - 剪贴板内容
+- <ins>**returns**</ins> { [void](dataTypes#void) }
+
+设置系统剪贴板内容.
+
+> 参阅: [getClip](#m-getclip) / [UiObject#paste](uiObjectType#m-paste)
+
+---
+
+## [m] getClip
+
+### getClip()
+
+- <ins>**returns**</ins> { [string](dataTypes#string) } - 系统剪贴板内容
+
+需额外留意, 自 [Android API 29 (10) [Q]](apiLevel) 起, 剪贴板数据的访问将受到限制:
+
+为更好地保护用户隐私权, 除默认输入法及当前获取焦点的前置应用外, 均无法访问剪贴板数据.
+
+```js
+setClip("test");
+
+/* 安卓 10 以下: 打印 "test". */
+/* 安卓 10 及以上: 若 AutoJs6 前置, 打印 "test", 否则打印空字符串. */
+console.log(getClip());
+```
+
+> 参阅: [setClip](#m-setclip) / [UiObject#paste](uiObjectType#m-paste)
+
+> 参阅: [Android Docs](https://developer.android.com/about/versions/10/privacy/changes#clipboard-data)
+
+---
+
+## [m+] toast
+
+### toast(text)
+
+**`Overload 1/4`** **`Async`**
+
+- **text** { [string](dataTypes#string) } - 消息内容
+- <ins>**returns**</ins> { [void](dataTypes#void) }
+
+显示一个 [消息浮动框](https://developer.android.com/guide/topics/ui/notifiers/toasts?hl=zh-cn).
+
+消息框的显示默认是依次进行的:
+
+```js
+/* 显示消息框 2 秒钟. */
+toast("hello");
+/* 显示消息框 2 秒钟, 且在前一个消息框消失后才显示. */
+toast("world");
+/* 显示消息框 2 秒钟, 且在前一个消息框消失后才显示. */
+toast("hello world");
+```
+
+### toast(text, isLong)
+
+**`Overload 2/4`** **`Async`**
+
+- **text** { [string](dataTypes#string) } - 消息内容
+- **isLong = false** { "long" | "l" | "short" | "s" | [boolean](dataTypes#boolean) } - 是否以较长时间显示
+- <ins>**returns**</ins> { [void](dataTypes#void) }
+
+控制单个消息框显示时长:
+
+```js
+toast("hello", 'long'); /* 显示消息框 3.5 秒钟. */
+toast("hello", true); /* 同上. */
+```
+
+> 注: 仅有 [ 长 / 短 ] 两种时长, 此时长由安卓系统决定.  
+> 通常, 短时为 2 秒, 长时为 3.5 秒.
+
+### toast(text, isLong, isForcible)
+
+**`Overload 3/4`** **`Async`**
+
+- **text** { [string](dataTypes#string) } - 消息内容
+- **isLong = false** { "long" | "l" | "short" | "s" | [boolean](dataTypes#boolean) } - 是否以较长时间显示
+- **isForcible = false** { "forcible" | "f" | [boolean](dataTypes#boolean) } - 是否强制覆盖显示
+- <ins>**returns**</ins> { [void](dataTypes#void) }
+
+使用 "强制覆盖显示" 参数可立即显示消息框:
+
+```js
+toast("hello");
+/* 显示消息框 2 秒钟, 且立即显示, 前一个消息框 "hello" 被 "覆盖". */
+toast("world", "short", "forcible");
+```
+
+> 注: 强制覆盖仅对当前脚本有效, 对其他脚本及应用程序无效.
+
+### toast(text, isForcible)
+
+**`Overload 4/4`** **`Async`**
+
+- **text** { [string](dataTypes#string) } - 消息内容
+- **isForcible** { "forcible" | "f" } - 强制覆盖显示 (字符标识)
+- <ins>**returns**</ins> { [void](dataTypes#void) }
+
+此方法相当于忽略 isLong 参数:
+
+```js
+toast("hello");
+/* 显示消息框 2 秒钟, 且立即显示, 前一个消息框 "hello" 被 "覆盖". */
+toast("world", "forcible");
+```
+
+> 注: 此方法的 isForcible 参数只能为具有明确意义的字符标识, 不能为 boolean 类型或其他类型, 否则 isForcible 将被视为 isLong.
+
+### toast.dismissAll()
+
+- <ins>**returns**</ins> { [void](dataTypes#void) }
+
+强制取消显示所有消息框.
+
+```js
+toast("hello");
+toast("world");
+toast("of");
+toast("JavaScript");
+
+sleep(1e3);
+
+/* "hello" 显示 1 秒后消失, "world" 及其他消息框均不再显示. */
+/* 若无 sleep 语句, 由于 toast 是异步的, 上述消息框均不会显示. */
+toast.dismissAll();
+
+/* dismissAll 仅对已在队列中的消息框有效, 因此下述消息框正常显示. */
+toast("forcibly dismissed");
+```
+
+> 注: 强制取消显示仅对当前脚本有效, 对其他脚本及应用程序无效.
+
+---
+
+## [m] toastLog
+
+显示消息浮动框并在控制台打印消息.  
+相当于以下代码组合:
+
+```js
+toast(text, ...args);
+console.log(text);
+```
+
+因此, 方法重载与 [toast](#m-toast) 完全一致.
+
+> 注: 虽然 toast 方法异步, 但 console.log 方法同步, 因此 toastLog 方法也为同步.
+
+### toastLog(text)
+
+**`Overload 1/4`**
+
+- **text** { [string](dataTypes#string) } - 消息内容
+- <ins>**returns**</ins> { [void](dataTypes#void) }
+
+> 参阅: [toast(text)](#toasttext)
+
+### toastLog(text, isLong)
+
+**`Overload 2/4`**
+
+- **text** { [string](dataTypes#string) } - 消息内容
+- **isLong = false** { "long" | "l" | "short" | "s" | [boolean](dataTypes#boolean) } - 是否以较长时间显示
+- <ins>**returns**</ins> { [void](dataTypes#void) }
+
+> 参阅: [toast(text, isLong)](#toasttext-islong)
+
+### toastLog(text, isLong, isForcible)
+
+**`Overload 3/4`**
+
+- **text** { [string](dataTypes#string) } - 消息内容
+- **isLong = false** { "long" | "l" | "short" | "s" | [boolean](dataTypes#boolean) } - 是否以较长时间显示
+- **isForcible = false** { "forcible" | "f" | [boolean](dataTypes#boolean) } - 是否强制覆盖显示
+- <ins>**returns**</ins> { [void](dataTypes#void) }
+
+> 参阅: [toast(text, isLong, isForcible)](#toasttext-islong-isforcible)
+
+### toastLog(text, isForcible)
+
+**`Overload 4/4`**
+
+- **text** { [string](dataTypes#string) } - 消息内容
+- **isForcible** { "forcible" | "f" } - 强制覆盖显示 (字符标识)
+- <ins>**returns**</ins> { [void](dataTypes#void) }
+
+> 参阅: [toast(text, isForcible)](#toasttext-isforcible)
+
+---
+
+## [m] wait
+
+### wait(condition)
+
+**`6.2.0`** **`Overload 1/6`** **`A11Y?`** **`Non-UI`**
+
+- **condition** { [(() => any)](dataTypes#function) | [PickupSelector](dataTypes#pickupselector) } - 结束等待条件
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+阻塞等待, 直到条件满足.  
+默认等待时间为 10 秒, 条件检查间隔为 200 毫秒.  
+若超时, 放弃等待, 并返回特定的条件超时结果 (如 false).  
+若超时之前条件得以满足, 结束等待, 并返回特定的条件满足结果 (如 true).
+
+> 注: 不同于 while 和 for 等循环语句的 "条件",  
+> 该方法的条件是结束等待条件, 只要不满足条件, 就一直等待.  
+> 而循环语句的条件, 是只要满足条件, 就一直循环.
+
+等待条件支持函数及选择器.
+
+函数示例, 等待设备屏幕关闭:
+
+```js
+wait(function () {
+    return device.isScreenOff();
+});
+
+/* 使用箭头函数. */
+wait(() => device.isScreenOff());
+
+/* 使用 bind. */
+wait(device.isScreenOff.bind(device));
+
+/* 对结果分支处理. */
+if (wait(() => device.isScreenOff())) {
+    console.log("等待屏幕关闭成功");
+} else {
+    console.log("等待屏幕关闭超时");
+}
+```
+
+选择器示例, 等待文本为 "立即开始" 的控件出现:
+
+```js
+/* 以下三种方式为 Pickup 选择器的不同格式, 效果相同. */
+wait("立即开始");
+wait(content("立即开始")); /* 同上. */
+wait({ content: "立即开始" }); /* 同上. */
+
+/* 对比上述函数方式. */
+wait(() => content("立即开始").exists());
+wait(() => pickup("立即开始", "?")); /* 同上. */
+```
+
+等待条件的满足与否, 与函数返回值有关.  
+例如当函数返回 true 时, 等待条件即满足.
+
+下面列出不满足条件的几种返回值:  
+[ [false](dataTypes#boolean) / [null](dataTypes#null) / [undefined](dataTypes#undefined) / [NaN](https://developer.mozilla.org/zh-CN/docs/Glossary/NaN/) ]  
+除此之外的返回值均视为满足条件 (包括空字符串和数字 0 等).
+
+一种常见的错误用例, 即函数条件缺少返回值:
+
+```js
+wait(() => {
+    if (device.isScreenOff()) {
+        console.log("屏幕已成功关闭");
+    }
+});
+```
+
+上述示例中, 等待条件永远无法满足, 因函数一直返回 undefined.
+
+添加合适的返回值即可修正:
+
+```js
+wait(() => {
+    if (device.isScreenOff()) {
+        console.log("屏幕已成功关闭");
+        return true;
+    }
+});
+```
+
+> 参阅: [pickup](uiSelectorType#m-pickup)
+
+### wait(condition, limit)
+
+**`6.2.0`** **`Overload 2/6`** **`A11Y?`** **`Non-UI`**
+
+- **condition** { [(() => any)](dataTypes#function) | [PickupSelector](uiSelectorType#m-pickup) } - 结束等待条件
+- **limit** { [number](dataTypes#number) } - 等待条件检测限制
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+[wait(condition)](#waitcondition) 增加条件检测限制.  
+达到限制后, 表示等待超时, 并放弃等待.  
+限制分为 "次数限制" (limit < 100) 和 "时间限制" (limit >= 100).
+
+```js
+/* 等待屏幕关闭, 最多检测屏幕状态 20 次. */
+wait(() => device.isScreenOff(), 20); /* limit < 100, 视为次数限制. */
+/* 等待屏幕关闭, 最多检测屏幕状态 5 秒钟. */
+wait(() => device.isScreenOff(), 5e3); /* limit >= 100, 视为时间限制. */
+```
+
+### wait(condition, limit, interval)
+
+**`6.2.0`** **`Overload 3/6`** **`A11Y?`** **`Non-UI`**
+
+- **condition** { [(() => any)](dataTypes#function) | [PickupSelector](uiSelectorType#m-pickup) } - 结束等待条件
+- **limit** { [number](dataTypes#number) } - 等待条件检测限制
+- **interval** { [number](dataTypes#number) } - 等待条件检测间隔
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+[wait(condition, limit)](#waitcondition-limit) 增加条件检测间隔.  
+只要条件不满足, wait() 方法会持续检测, 直到条件满足或达到检测限制.  
+interval 参数用于设置条件检测之间的间歇时长, 默认为 200 毫秒.
+
+```text
+检查条件 (不满足) - 间歇 - 检查条件 (不满足) - 间歇 - 检查条件...
+```
+
+```js
+/* 等待屏幕关闭, 最多检测屏幕状态 20 次, 每次检查间歇 3 秒钟. */
+wait(() => device.isScreenOff(), 20, 3e3);
+/* 等待屏幕关闭, 最多检测屏幕状态 20 次, 并采用不间断检测 (无间歇). */
+wait(() => device.isScreenOff(), 20, 0);
+```
+
+> 注: 在最后一次条件检查之后, 将不再发生间歇.  
+> 包括条件满足或达到检测限制.
+>
+> 例如在第三次检查时, 条件满足:  
+> 检查 (×) - 间歇 - 检查 (×) - 间歇 - 检查 (√) - 立即结束 wait()
+
+### wait(condition, callback)
+
+**`6.2.0`** **`Overload 4/6`** **`A11Y?`** **`Non-UI`**
+
+- **condition** { [(() => T)](dataTypes#function) | [PickupSelector](uiSelectorType#m-pickup) } - 结束等待条件
+- **callback** {{
+    - then?(result?: [T](dataTypes#generic)): [R](dataTypes#generic)
+    - else?(result?: [T](dataTypes#generic)): [R](dataTypes#generic)
+- }} - 等待结束回调对象
+- <ins>**returns**</ins> { [R](dataTypes#generic) extends [void](dataTypes#void) ? [boolean](dataTypes#boolean) : [R](dataTypes#generic) }
+- <ins>**template**</ins> [T](dataTypes#generic), [R](dataTypes#generic)
+
+[wait(condition)](#waitcondition) 增加回调对象.
+
+回调对象集合了两个方法, then 与 else 分别对应等待成功与等待失败的情况:
+
+```js
+wait(() => device.isScreenOff(), {
+    then: () => console.log("等待屏幕关闭成功"),
+    else: () => console.log("等待屏幕关闭超时"),
+});
+```
+
+两种方法都将最后一次检查结果作为实参, 可在方法体内直接使用:
+
+```js
+/* 等待一个落在 99.99 到 100 区间的随机数. */
+wait(() => {
+    let num = Math.random() * 100;
+    return num > 99.99 && num;
+}, {
+    then(o) {
+        console.log(`获取随机数成功, 数字是: ${o}`);
+    },
+    else() {
+        console.log("获取 99.99 到 100 的随机数超时");
+    },
+});
+```
+
+> 注: else 回调方法的参数只能是 [ [false](dataTypes#boolean) / [null](dataTypes#null) / [undefined](dataTypes#undefined) / [NaN](https://developer.mozilla.org/zh-CN/docs/Glossary/NaN/) ],  
+> 因此 else 的参数几乎不会用到.
+
+需特别注意, 回调方法的返回值具有穿透性.  
+在回调方法内使用 return 语句, 将直接影响 wait() 的返回值 (undefined 除外).
+
+上述示例中, then 和 else 回调都没有返回值, 因此 wait() 返回值是 boolean 类型, 表示等待条件是否满足.  
+下述示例在回调函数中增加了返回值 (非 undefined), 则 wait() 也将返回这个值.
+
+```js
+let result = wait(() => {
+    let num = Math.random() * 100;
+    return num > 99.99 && num;
+}, {
+    then(o) {
+        console.log(`获取随机数成功`);
+        return o;
+    },
+    else() {
+        console.log("获取 99.99 到 100 的随机数超时");
+        return NaN;
+    },
+});
+result; /* 一个数字 (如 99.99732126036437) 或 NaN. */
+```
+
+上述示例如果等待条件满足, 则返回 then 的返回值 (number 类型),  
+等待条件超时, 则返回 else 的返回值 (NaN, 也为 number 类型).
+
+如果去掉 else 的返回语句, 则等待条件超时后, wait() 将返回 false (boolean 类型).
+
+如需对 wait() 的返回值做进一步处理, 则建议两个回调方法的返回值类型一致:
+
+```js
+wait(() => {
+    let num = Math.random() * 100;
+    return num > 99.99 && num;
+}, {
+    then(o) {
+        return [ o - 1, o, o + 1 ];
+    },
+    else() {
+        /* 即使等待条件超时, 也可调用 forEach 方法. */
+        return [];
+    },
+}).forEach(x => console.log(x));
+```
+
+### wait(condition, limit, callback)
+
+**`6.2.0`** **`Overload 5/6`** **`A11Y?`** **`Non-UI`**
+
+- **condition** { [(() => T)](dataTypes#function) | [PickupSelector](uiSelectorType#m-pickup) } - 结束等待条件
+- **limit** { [number](dataTypes#number) } - 等待条件检测限制
+- **callback** {{
+    - then?(result?: [T](dataTypes#generic)): [R](dataTypes#generic)
+    - else?(result?: [T](dataTypes#generic)): [R](dataTypes#generic)
+- }} - 等待结束回调对象
+- <ins>**returns**</ins> { [R](dataTypes#generic) extends [void](dataTypes#void) ? [boolean](dataTypes#boolean) : [R](dataTypes#generic) }
+- <ins>**template**</ins> [T](dataTypes#generic), [R](dataTypes#generic)
+
+[wait(condition, callback)](#waitcondition-callback) 增加条件检测限制.
+
+> 参阅: [wait(condition, limit)](#waitcondition-limit)
+
+### wait(condition, limit, interval, callback)
+
+**`6.2.0`** **`Overload 6/6`** **`A11Y?`** **`Non-UI`**
+
+- **condition** { [(() => T)](dataTypes#function) | [PickupSelector](uiSelectorType#m-pickup) } - 结束等待条件
+- **limit** { [number](dataTypes#number) } - 等待条件检测限制
+- **interval** { [number](dataTypes#number) } - 等待条件检测间隔
+- **callback** {{
+    - then?(result?: [T](dataTypes#generic)): [R](dataTypes#generic)
+    - else?(result?: [T](dataTypes#generic)): [R](dataTypes#generic)
+- }} - 等待结束回调对象
+- <ins>**returns**</ins> { [R](dataTypes#generic) extends [void](dataTypes#void) ? [boolean](dataTypes#boolean) : [R](dataTypes#generic) }
+- <ins>**template**</ins> [T](dataTypes#generic), [R](dataTypes#generic)
+
+[wait(condition, limit, callback)](#waitcondition-callback) 增加条件检测间隔.
+
+> 参阅: [wait(condition, limit, interval)](#waitcondition-limit-interval)
+
+---
+
+## [m] waitForActivity
+
+等待指定名称的 Activity 出现 (前置).  
+此方法相当于 `wait(() => currentActivity() === activityName, ...args)`,  
+因此其所有重载方法的结构与 wait 一致.  
+为节约篇幅, 将仅列出方法签名等重要信息.
+
+### waitForActivity(activityName)
+
+**`6.2.0`** **`Overload 1/6`** **`A11Y?`** **`Non-UI`**
+
+- **activityName** { [string](dataTypes#string) } - 目标活动名称
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+> 参阅:[wait(condition)](#waitcondition)
+
+### waitForActivity(activityName, limit)
+
+**`6.2.0`** **`Overload 2/6`** **`A11Y?`** **`Non-UI`**
+
+- **activityName** { [string](dataTypes#string) } - 目标活动名称
+- **limit** { [number](dataTypes#number) } - 等待条件检测限制
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+> 参阅:[wait(condition, limit)](#waitcondition-limit)
+
+### waitForActivity(activityName, limit, interval)
+
+**`6.2.0`** **`Overload 3/6`** **`A11Y?`** **`Non-UI`**
+
+- **activityName** { [string](dataTypes#string) } - 目标活动名称
+- **limit** { [number](dataTypes#number) } - 等待条件检测限制
+- **interval** { [number](dataTypes#number) } - 等待条件检测间隔
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+> 参阅:[wait(condition, limit, interval)](#waitcondition-limit-interval)
+
+### waitForActivity(activityName, callback)
+
+**`6.2.0`** **`Overload 4/6`** **`A11Y?`** **`Non-UI`**
+
+- **activityName** { [string](dataTypes#string) } - 目标活动名称
+- **callback** {{
+    - then?(result?: [T](dataTypes#generic)): [R](dataTypes#generic)
+    - else?(result?: [T](dataTypes#generic)): [R](dataTypes#generic)
+- }} - 等待结束回调对象
+- <ins>**returns**</ins> { [R](dataTypes#generic) extends [void](dataTypes#void) ? [boolean](dataTypes#boolean) : [R](dataTypes#generic) }
+- <ins>**template**</ins> [T](dataTypes#generic), [R](dataTypes#generic)
+
+> 参阅: [wait(condition, callback)](#waitcondition-callback)
+
+### waitForActivity(activityName, limit, callback)
+
+**`6.2.0`** **`Overload 5/6`** **`A11Y?`** **`Non-UI`**
+
+- **activityName** { [string](dataTypes#string) } - 目标活动名称
+- **limit** { [number](dataTypes#number) } - 等待条件检测限制
+- **callback** {{
+    - then?(result?: [T](dataTypes#generic)): [R](dataTypes#generic)
+    - else?(result?: [T](dataTypes#generic)): [R](dataTypes#generic)
+- }} - 等待结束回调对象
+- <ins>**returns**</ins> { [R](dataTypes#generic) extends [void](dataTypes#void) ? [boolean](dataTypes#boolean) : [R](dataTypes#generic) }
+- <ins>**template**</ins> [T](dataTypes#generic), [R](dataTypes#generic)
+
+> 参阅: [wait(condition, limit, callback)](#waitcondition-limit-callback)
+
+### waitForActivity(activityName, limit, interval, callback)
+
+**`6.2.0`** **`Overload 6/6`** **`A11Y?`** **`Non-UI`**
+
+- **activityName** { [string](dataTypes#string) } - 目标活动名称
+- **limit** { [number](dataTypes#number) } - 等待条件检测限制
+- **interval** { [number](dataTypes#number) } - 等待条件检测间隔
+- **callback** {{
+    - then?(result?: [T](dataTypes#generic)): [R](dataTypes#generic)
+    - else?(result?: [T](dataTypes#generic)): [R](dataTypes#generic)
+- }} - 等待结束回调对象
+- <ins>**returns**</ins> { [R](dataTypes#generic) extends [void](dataTypes#void) ? [boolean](dataTypes#boolean) : [R](dataTypes#generic) }
+- <ins>**template**</ins> [T](dataTypes#generic), [R](dataTypes#generic)
+
+> 参阅: [wait(condition, limit, interval, callback)](#waitcondition-limit-interval-callback)
+
+---
+
+## [m] waitForPackage
+
+等待指定包名的应用出现 (前置).  
+此方法相当于 `wait(() => currentPackage() === packageName, ...args)`,  
+因此其所有重载方法的结构与 wait 一致.  
+为节约篇幅, 将仅列出方法签名等重要信息.
+
+### waitForPackage(packageName)
+
+**`6.2.0`** **`Overload 1/6`** **`A11Y?`** **`Non-UI`**
+
+- **packageName** { [string](dataTypes#string) } - 目标应用包名
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+> 参阅:[wait(condition)](#waitcondition)
+
+### waitForPackage(packageName, limit)
+
+**`6.2.0`** **`Overload 2/6`** **`A11Y?`** **`Non-UI`**
+
+- **packageName** { [string](dataTypes#string) } - 目标应用包名
+- **limit** { [number](dataTypes#number) } - 等待条件检测限制
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+> 参阅:[wait(condition, limit)](#waitcondition-limit)
+
+### waitForPackage(packageName, limit, interval)
+
+**`6.2.0`** **`Overload 3/6`** **`A11Y?`** **`Non-UI`**
+
+- **packageName** { [string](dataTypes#string) } - 目标应用包名
+- **limit** { [number](dataTypes#number) } - 等待条件检测限制
+- **interval** { [number](dataTypes#number) } - 等待条件检测间隔
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+> 参阅:[wait(condition, limit, interval)](#waitcondition-limit-interval)
+
+### waitForPackage(packageName, callback)
+
+**`6.2.0`** **`Overload 4/6`** **`A11Y?`** **`Non-UI`**
+
+- **packageName** { [string](dataTypes#string) } - 目标应用包名
+- **callback** {{
+    - then?(result?: [T](dataTypes#generic)): [R](dataTypes#generic)
+    - else?(result?: [T](dataTypes#generic)): [R](dataTypes#generic)
+- }} - 等待结束回调对象
+- <ins>**returns**</ins> { [R](dataTypes#generic) extends [void](dataTypes#void) ? [boolean](dataTypes#boolean) : [R](dataTypes#generic) }
+- <ins>**template**</ins> [T](dataTypes#generic), [R](dataTypes#generic)
+
+> 参阅: [wait(condition, callback)](#waitcondition-callback)
+
+### waitForPackage(packageName, limit, callback)
+
+**`6.2.0`** **`Overload 5/6`** **`A11Y?`** **`Non-UI`**
+
+- **packageName** { [string](dataTypes#string) } - 目标应用包名
+- **limit** { [number](dataTypes#number) } - 等待条件检测限制
+- **callback** {{
+    - then?(result?: [T](dataTypes#generic)): [R](dataTypes#generic)
+    - else?(result?: [T](dataTypes#generic)): [R](dataTypes#generic)
+- }} - 等待结束回调对象
+- <ins>**returns**</ins> { [R](dataTypes#generic) extends [void](dataTypes#void) ? [boolean](dataTypes#boolean) : [R](dataTypes#generic) }
+- <ins>**template**</ins> [T](dataTypes#generic), [R](dataTypes#generic)
+
+> 参阅: [wait(condition, limit, callback)](#waitcondition-limit-callback)
+
+### waitForPackage(packageName, limit, interval, callback)
+
+**`6.2.0`** **`Overload 6/6`** **`A11Y?`** **`Non-UI`**
+
+- **packageName** { [string](dataTypes#string) } - 目标应用包名
+- **limit** { [number](dataTypes#number) } - 等待条件检测限制
+- **interval** { [number](dataTypes#number) } - 等待条件检测间隔
+- **callback** {{
+    - then?(result?: [T](dataTypes#generic)): [R](dataTypes#generic)
+    - else?(result?: [T](dataTypes#generic)): [R](dataTypes#generic)
+- }} - 等待结束回调对象
+- <ins>**returns**</ins> { [R](dataTypes#generic) extends [void](dataTypes#void) ? [boolean](dataTypes#boolean) : [R](dataTypes#generic) }
+- <ins>**template**</ins> [T](dataTypes#generic), [R](dataTypes#generic)
+
+> 参阅: [wait(condition, limit, interval, callback)](#waitcondition-limit-interval-callback)
+
+---
+
+## [m] exit
+
+### exit()
+
+停止脚本运行.
+
+通过抛出 `ScriptInterruptedException` 异常实现脚本停止.  
+因此用 `try` 包裹 `exit()` 语句将会使脚本继续运行片刻:
+
+```js
+try {
+    log('exit now');
+    exit();
+    log("after"); /* 控制台不会打印 "after". */
+} catch (e) {
+    e.javaException instanceof ScriptInterruptedException; // true
+}
+while (true) log("hello"); /* 控制台将打印一定数量的 "hello". */
+```
+
+如果编写的脚本对 "是否停止" 的状态十分敏感,  
+即要求 exit() 之后的代码一定不被执行,  
+则可通过附加状态判断实现上述需求:
+
+```js
+if (!isStopped()) {
+    // 其他代码...
+}
+```
+
+因此上述示例如果加上状态判断, "hello" 将不会被打印:
+
+```js
+try {
+    log('exit now');
+    exit();
+} catch (_) {
+    // Ignored.
+}
+if (!isStopped()) {
+    while (true) log("hello"); /* 控制台不会打印 "hello". */
+}
+```
+
+除了 [isStopped](#isstopped), 还可通过 threads 或 engines 获取停止状态:
+
+```js
+/* threads. */
+if (!threads.currentThread().isInterrupted()) {
+    // 其他代码...
+}
+
+/* engines. */
+if (!engines.myEngine().isStopped()) {
+    // 其他代码...
+}
+```
+
+---
+
+## [m] random
+
+### random()
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+与 Math.random() 相同, 返回落在 [0, 1) 区间的随机数字.
+
+### random(min, max)
+
+- **min** { [number](dataTypes#number) } - 随机数下限
+- **max** { [number](dataTypes#number) } - 随机数上限
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回落在 [min, max] 区间的随机数字.
+
+> 注: random(min, max) 右边界闭合, 而 random() 右边界开放.
+
+---
+
+## [m] requiresApi
+
+### requiresApi(api)
+
+- **api** { [number](dataTypes#number) } - 安卓 API 级别
+
+脚本运行的最低 API 级别要求.
+
+例如要求脚本运行不低于 [Android API 30 (11) [R]](apiLevel):
+
+```js
+requiresApi(30);
+requiresApi(util.versionCodes.R.apiLevel); /* 同上. */
+requiresApi(android.os.Build.VERSION_CODES.R); /* 同上. */
+```
+
+若 API 级别不符合要求, 脚本抛出异常并停止继续执行.
+
+> 参阅:
+> - [Android API Level - 安卓 API 级别](apiLevel)
+> - [util.versionCodes](util#versioncodes)
+
+---
+
+## [m] requiresAutojsVersion
+
+### requiresAutojsVersion(versionName)
+
+- **versionName** { [string](dataTypes#string) } - AutoJs6 版本名称
+- <ins>**returns**</ins> { [void](dataTypes#void) }
+
+脚本运行的最低 AutoJs6 版本要求 (版本名称).
+
+```js
+requiresAutojsVersion("6.2.0");
+```
+
+可通过 `autojs.versionName` 查看 AutoJs6 版本名称.
+
+> 参阅: [autojs.versionName](autojs#versionname)
+
+### requiresAutojsVersion(versionCode)
+
+- **versionCode** { [number](dataTypes#number) } - AutoJs6 版本号
+- <ins>**returns**</ins> { [void](dataTypes#void) }
+
+脚本运行的最低 AutoJs6 版本要求 (版本号).
+
+```js
+requiresAutojsVersion(1024);
+```
+
+可通过 `autojs.versionCode` 查看 AutoJs6 版本号.
+
+> 参阅: [autojs.versionCode](autojs#versioncode)
+
+## [m] importPackage
+
+### importPackage(...pkg)
+
+- **pkg** { ...( [string](dataTypes#string) | [object](dataTypes#object) ) } - 需导入的 Java 包
+- <ins>**returns**</ins> { [void](dataTypes#void) }
+
+```js
+/* 导入一个 Java 包. */
+
+importPackage(java.lang);
+importPackage('java.lang'); /* 同上. */
+
+/* 导入多个 Java 包. */
+
+importPackage(java.io);
+importPackage(java.lang);
+importPackage(java.util);
+
+importPackage(java.io, java.lang, java.util); /* 同上. */
+``` 
+
+> 参阅: [访问 Java 包和类](scriptingJava#访问-Java-包和类)
+
+## [m] importClass
+
+### importClass(...cls)
+
+- **cls** { ...( [string](dataTypes#string) | [object](dataTypes#object) ) } - 需导入的 Java 类
+- <ins>**returns**</ins> { [void](dataTypes#void) }
+
+```js
+/* 导入一个 Java 类. */
+
+importClass(java.lang.Integer);
+importClass('java.lang.Integer'); /* 同上. */
+
+/* 导入多个 Java 类. */
+
+importClass(java.io.File);
+importClass(java.lang.Integer);
+importClass(java.util.HashMap);
+
+importClass(
+    java.io.File,
+    java.lang.Integer,
+    java.util.HashMap,
+); /* 同上. */
+``` 
+
+> 参阅: [访问 Java 包和类](scriptingJava#访问-Java-包和类)
+
+## [m] isStopped
+
+### isStopped()
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+检测脚本当前线程是否已停止.
+
+## [m] selector
+
+### selector()
+
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+构建一个 "空" [选择器](uiSelectorType).
\ No newline at end of file
diff --git a/api/globals.md b/api/globals.md
deleted file mode 100644
index 1ff0f40..0000000
--- a/api/globals.md
+++ /dev/null
@@ -1,223 +0,0 @@
-# 全局变量与函数
-
-全局变量和函数在所有模块中均可使用。 但以下变量的作用域只在模块内，详见 [module](modules)：
-
-* exports
-* module
-* require()
-  以下的对象是特定于 Auto.js 的。 有些内置对象是 JavaScript 语言本身的一部分，它们也是全局的。
-
-一些模块中的函数为了使用方便也可以直接全局使用，这些函数在此不再赘述。例如timers模块的setInterval, setTimeout等函数。
-
-## sleep(n)
-
-* `n` {number} 毫秒数
-
-暂停运行n**毫秒**的时间。1秒等于1000毫秒。
-
-```
-//暂停5秒
-sleep(5000);
-```
-
-## currentPackage()
-
-* 返回 {string}
-
-返回最近一次监测到的正在运行的应用的包名，一般可以认为就是当前正在运行的应用的包名。
-
-此函数依赖于无障碍服务，如果服务未启动，则抛出异常并提示用户启动。
-
-## currentActivity()
-
-* 返回 {string}
-
-返回最近一次监测到的正在运行的Activity的名称，一般可以认为就是当前正在运行的Activity的名称。
-
-此函数依赖于无障碍服务，如果服务未启动，则抛出异常并提示用户启动。
-
-## setClip(text)
-
-* `text` {string} 文本
-
-设置剪贴板内容。此剪贴板即系统剪贴板，在一般应用的输入框中"粘贴"既可使用。
-
-```
-setClip("剪贴板文本");
-```
-
-## getClip()
-
-* 返回 {string}
-
-返回系统剪贴板的内容。
-
-```
-toast("剪贴板内容为:" + getClip());
-```
-
-## toast(message)
-
-* message {string} 要显示的信息
-
-以气泡显示信息message几秒。(具体时间取决于安卓系统，一般都是2秒)
-
-注意，信息的显示是"异步"执行的，并且，不会等待信息消失程序才继续执行。如果在循环中执行该命令，可能出现脚本停止运行后仍然有不断的气泡信息出现的情况。
-例如:
-
-```
-for(var i = 0; i < 100; i++){
-  toast(i);
-}
-```
-
-运行这段程序以后，会很快执行完成，且不断弹出消息，在任务管理中关闭所有脚本也无法停止。
-要保证气泡消息才继续执行可以用：
-
-```
-for(var i = 0; i < 100; i++){
-  toast(i);
-  sleep(2000);
-}
-```
-
-或者修改toast函数：
-
-```
-var _toast_ = toast;
-toast = function(message){
-  _toast_(message);
-  sleep(2000);
-}
-for(var i = 0; i < 100; i++){
-  toast(i);
-}
-```
-
-## toastLog(message)
-
-* message {string} 要显示的信息
-
-相当于`toast(message);log(message)`。显示信息message并在控制台中输出。参见console.log。
-
-## waitForActivity(activity[, period = 200])
-
-* `activity` Activity名称
-* `period` 轮询等待间隔（毫秒）
-
-等待指定的Activity出现，period为检查Activity的间隔。
-
-## waitForPackage(package[, period = 200])
-
-* `package` 包名
-* `period` 轮询等待间隔（毫秒）
-
-等待指定的应用出现。例如`waitForPackage("com.tencent.mm")`为等待当前界面为微信。
-
-## exit()
-
-立即停止脚本运行。
-
-立即停止是通过抛出`ScriptInterrupttedException`来实现的，因此如果用`try...catch`把exit()函数的异常捕捉，则脚本不会立即停止，仍会运行几行后再停止。
-
-## random(min, max)
-
-* `min` {number} 随机数产生的区间下界
-* `max` {number} 随机数产生的区间上界
-* 返回 {number}
-
-返回一个在[min...max]之间的随机数。例如random(0, 2)可能产生0, 1, 2。
-
-## random()
-
-* 返回 {number}
-
-返回在[0, 1)的随机浮点数。
-
-## requiresApi(api)
-
-* `api` Android版本号
-
-表示此脚本需要Android API版本达到指定版本才能运行。例如`requiresApi(19)`表示脚本需要在Android 4.4以及以上运行。
-
-调用该函数时会判断运行脚本的设备系统的版本号，如果没有达到要求则抛出异常。
-
-可以参考以下Android API和版本的对照表:
-
-平台版本： API级别
-
-Android 7.0： 24
-
-Android 6.0： 23
-
-Android 5.1： 22
-
-Android 5.0： 21
-
-Android 4.4W： 20
-
-Android 4.4： 19
-
-Android 4.3： 18
-
-## requiresAutojsVersion(version)
-
-* `version` {string} | {number} Auto.js的版本或版本号
-
-表示此脚本需要Auto.js版本达到指定版本才能运行。例如`requiresAutojsVersion("3.0.0 Beta")`表示脚本需要在Auto.js 3.0.0 Beta以及以上运行。
-
-调用该函数时会判断运行脚本的Auto.js的版本号，如果没有达到要求则抛出异常。
-
-version参数可以是整数表示版本号，例如`requiresAutojsVersion(250)`；也可以是字符串格式表示的版本，例如"3.0.0 Beta", "3.1.0 Alpha4", "3.2.0"等。
-
-可以通过`app.autojs.versionCode`和`app.autojs.versionName`获取当前的Auto.js版本号和版本。
-
-## runtime.requestPermissions(permissions)
-
-* `permissions` {Array} 权限的字符串数组
-
-动态申请安卓的权限。例如：
-
-```
-//请求GPS权限
-runtime.requestPermissions(["access_fine_location"]);
-```
-
-尽管安卓有很多权限，但必须写入Manifest才能动态申请，为了防止权限的滥用，目前Auto.js只能额外申请两个权限：
-
-* `access_fine_location` GPS权限
-* `record_audio` 录音权限
-
-您可以通过APK编辑器来增加Auto.js以及Auto.js打包的应用的权限。
-
-安卓所有的权限列表参见[Permissions Overview](https://developer.android.com/guide/topics/permissions/overview)。（并没有用）
-
-## runtime.loadJar(path)
-
-* `path` {string} jar文件路径
-
-加载目标jar文件，加载成功后将可以使用该Jar文件的类。
-
-```
-// 加载jsoup.jar
-runtime.loadJar("./jsoup.jar");
-// 使用jsoup解析html
-importClass(org.jsoup.Jsoup);
-log(Jsoup.parse(files.read("./test.html")));
-```
-
-(jsoup是一个Java实现的解析Html DOM的库，可以在[Jsoup](https://jsoup.org/download)下载)
-
-## runtime.loadDex(path)
-
-* `path` {string} dex文件路径
-
-加载目标dex文件，加载成功后将可以使用该dex文件的类。
-
-因为加载jar实际上是把jar转换为dex再加载的，因此加载dex文件会比jar文件快得多。可以使用Android SDK的build tools的dx工具把jar转换为dex。
-
-## context
-
-全局变量。一个android.content.Context对象。
-
-注意该对象为ApplicationContext，因此不能用于界面、对话框等的创建。
\ No newline at end of file
diff --git a/api/glossaries.md b/api/glossaries.md
new file mode 100644
index 0000000..c560b45
--- /dev/null
+++ b/api/glossaries.md
@@ -0,0 +1,566 @@
+# 术语 (Glossaries)
+
+---
+
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
+
+---
+
+## 内置模块
+
+AutoJs6 内置模块指脚本可全局使用的 JavaScript 模块.  
+这些模块多数已在文档中列出, 如 `app`, `images`, `device` 等.
+
+### 查看内置模块源代码
+
+除 [直接查看开源代码](https://github.com/SuperMonster003/AutoJs6/tree/master/app/src/main/assets/modules) 外, 还可以将内置模块解压到本地存储后查看:  
+下载 [AutoJs6 APK](https://github.com/SuperMonster003/AutoJs6/releases/latest) 并使用压缩软件将 APK 内的 `\assets\modules` 文件夹解压到本地.  
+模块通常以 `__%name%__.js` 格式命名, 其中 `%name%` 对应模块名.  
+可使用文本编辑器等软件查看模块源代码.
+
+### 修改或增加内置模块
+
+> 注: 此小节内容可能需要用户具备一定的编程基础及开发经验.
+
+> 注: 此操作需要重新打包生成 `新的 AutoJs6 APK` (下文作 `新生 APK`).  
+> 因 `新生 APK` 包名发生变化, 需卸载已安装的 `开源 AutoJs6 APK` (下文作 `开源 APK`) 后再安装 `新生 APK`.  
+> 当 `开源 APK` 出现新版本时, 同样需卸载 `新生 APK` 才能安装新版本的 `开源 APK`.  
+> 此时, 修改或增加的内置模块将失效.  
+> 如欲将自己的代码整合到 `开源 APK` 中, 可向开源项目提交 [Pull Request (PR)](https://github.com/SuperMonster003/AutoJs6/pulls).
+
+克隆 (Clone) [AutoJs6 源码](https://github.com/SuperMonster003/AutoJs6).  
+使用 [Android Studio](https://developer.android.com/studio/archive) 打开并完成项目构建 (Build).  
+定位 `\app\src\main\assets\modules` 目录.
+
+#### 修改模块
+
+修改目录中的模块代码后直接打包生成新的 APK.
+
+#### 增加模块
+
+以增加一个 date 模块为例, 该模块有一个 `date.toFullTimeString()` 方法.
+
+在 `\app\src\main\assets\modules` 目录新建 `__date__.js` 文件, 此文件将作为增加的内置模块.
+
+供参考的文件内容:
+
+```js
+module.exports = function () {
+    return {
+        toFullTimeString() {
+            let now = new Date();
+            let pad = x => x.toString().padStart(2, '0');
+            return [ now.getHours(), now.getMinutes(), now.getSeconds() ].map(pad).join(':');
+        },
+    };
+};
+```
+
+打开 "初始化脚本", 即 `\app\src\main\assets\init.js`.  
+将 date 模块添加到 "初始化脚本" 中:
+
+```js
+/* ... */
+
+let $ = {
+    /* ... */
+    bindModules() {
+        _.bind([
+            /* ... */
+
+            [ 'date', 'RootAutomator', 'floaty', /* 其他模块... */ ],
+
+            /* ... */
+        ]);
+    },
+    /* ... */
+};
+
+/* ... */
+```
+
+添加完成后即可打包生成新的 APK.
+
+## 编译器
+
+语法编译器是一个能够逐行读取代码的程序.  
+它了解代码如何匹配编程语言所定义的语法, 以及代码应该做什么.
+
+## JavaScript 引擎
+
+JavaScript 引擎是一个计算机程序.  
+它接收 JavaScript 源代码并将其编译成 CPU 可以理解的二进制指令 (机器码).
+
+### 引擎与运行环境
+
+运行环境也称为运行时环境, 引擎需要在运行环境中
+
+JavaScript 引擎通常由浏览器供应商开发, 主流浏览器通常有自己开发的引擎:
+
+- Chrome - V8
+- Firefox - SpiderMonkey
+- IE - Chakra
+
+## 运行时
+
+即 `Runtime`.
+
+Runtime 是一个通用术语, 指代码运行所需的 [ 库 / 框架 / 平台 ].
+
+> 参阅: [runtime](runtime) (全局对象)
+
+## 上下文
+
+Context.
+
+> 参阅: [context](context) (全局对象)
+
+## 字符串模式
+
+表示需要匹配指定正则表达式的字符串.
+
+如字符串模式为 `/\d/`, 则要求给定的字符串 `str` 满足以下语句:
+
+```js
+/\d/.test(str) === true;
+```
+
+因此以下示例均满足要求:  
+`"1"`, `"1a"`, `"a1"`, `"hello 2011"`.
+
+字符串模式支持正则表达式的 [标记参数](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Guide/Regular_Expressions#%E9%80%9A%E8%BF%87%E6%A0%87%E5%BF%97%E8%BF%9B%E8%A1%8C%E9%AB%98%E7%BA%A7%E6%90%9C%E7%B4%A2), 如 `/hello/i`.
+
+## NaN
+
+NaN 表示 "不是一个数字", 即 **N**ot **A** **N**umber.
+
+NaN 是一个数值, 在 JavaScript 中可以使用 `isNaN` 或 `Number.isNaN` 检测:
+
+```js
+let n = 0 / 0;
+isNaN(n); // true
+Number.isNaN(n); // true
+
+let m = null;
+isNaN(m); // false
+Number.isNaN(m); // false
+
+let l = undefined;
+isNaN(l); // true
+Number.isNaN(l); // false
+```
+
+> 参阅: [MDN #术语](https://developer.mozilla.org/zh-CN/docs/Glossary/NaN/) / [MDN #全局对象](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/NaN/) / [isNaN](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/isNaN) / [Number.isNaN](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN)
+
+## 正则表达式
+
+也作 [ 正则 / Regular Expression / RegEx / REGEX / RegExp / REX (非正式) ] 等.
+
+正则表达式字面量在 JavaScript 中用一对 `/` 符号表示,  
+如 `/\d/`, `/^[0-9a-f]{6}$/`, `/[bc]+?(?=y{2,})/i` 等.
+
+> 参阅: [MDN #指南](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Guide/Regular_Expressions)
+
+## Truthy
+
+Truthy (真值) 指 `Boolean(truthy)` 返回 `true` 的值.  
+从另一个角度看, [Falsy (假值)](#falsy) 以外的任何值都为真值.
+
+> 参阅: [MDN #术语](https://developer.mozilla.org/zh-CN/docs/Glossary/Truthy/)
+
+## Falsy
+
+目前 (2022/08), JavaScript 共有 8 个 Falsy (假值):
+
+1. false ([boolean](dataTypes#boolean))
+2. 0 ([number](dataTypes#number))
+3. -0 ([number](dataTypes#number))
+4. 0n ([bigint](#bigint))
+5. [空字符串](#空字符串)
+6. [null](dataTypes#null)
+7. [undefined](dataTypes#undefined)
+8. [NaN](#nan)
+
+需留意 `0` 与 `-0` 是不同的值:
+
+```js
+0 === -0; // true
+Object.is(0, -0); // false
+Object.is(0n, -0n); // true
+
+let n = -0;
+n.toString(); // "0"
+Object.is(n, -0) ? `-${n}` : `${n}`; // "-0"
+```
+
+> 参阅: [MDN #术语](https://developer.mozilla.org/zh-CN/docs/Glossary/Falsy/) / [Object.is](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/is)
+
+## 空字符串
+
+通常用 `""` 表示空字符串, 它是一个长度为 0 的 string 类型数据.
+
+以下几种表示方式均可代表空字符串:
+
+```js
+[ "", '', ``, String() ];
+```
+
+## BigInt
+
+一种可以表示任意精度格式整数的数字类型.
+
+如 `3n`, `16777216n`, `-1n` 均合法.  
+如 `3.1n`, `2ne5`, `2e5n` 均不合法.
+
+> 参阅: [MDN #术语](https://developer.mozilla.org/zh-CN/docs/Glossary/BigInt) / [MDN #全局对象](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/BigInt)
+
+## 枚举
+
+枚举是组织收集有关联变量的一种方式, 许多程序语言如 [ C / C# / Java ] 等都有枚举数据类型.
+
+## 内置对象
+
+又称 [ 原生对象 / 标准内置对象 ], 内置对象与宿主无关, 是独立于宿主环境的 ECMAScript 实现提供的对象.  
+它们在 ECMAScript 程序开始执行前就存在, 本身就是实例化内置对象, 开发者无需再去实例化.  
+内置对象是原生对象的子集, 如常用的 [ Object / Function / Array / String / Boolean / Number / Date / RegExp / Error / Math / JSON ] 等都是内置对象.
+
+> 参阅: [MDN](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects)
+
+## 内置对象扩展
+
+对 [内置对象](#内置对象) 的扩展主要有两种类型, 属性扩展及原型扩展.
+
+属性扩展:
+
+```js
+Object.saySomething = function (content) {
+    console.log(content);
+};
+
+Math.sum = function (x, y) {
+    return +x + +y;
+};
+```
+
+调用时直接使用 `A.b` 形式:
+
+```js
+Object.saySomething("hello"); /* print "hello". */
+console.log(Math.sum(2, 3)); // 5
+```
+
+原型扩展:
+
+```js
+Array.prototype.sorted = function () {
+    return this.slice().sort();
+};
+Number.prototype.toFixedNum = function (fraction) {
+    return +this.toFixed(fraction);
+};
+```
+
+调用时可在相应对象实例上使用:
+
+```js
+let arr = [ 1, 2, 9, 3 ];
+console.log(arr.sorted()); // [ 1, 2, 3, 9 ]
+console.log(arr); // [ 1, 2, 9, 3 ]
+
+let num = 375.201;
+console.log(num.toFixed(2)); // "375.20"
+console.log(num.toFixedNum(2)); // 375.2
+```
+
+上述扩展均为自定义扩展, 它们实现了自定义的属性或方法, 往往是针对个人项目使用的.  
+而针对 ECMAScript 规范中的新功能的扩展, 则被称为 [填泥 (Polyfill)](#polyfill).
+
+> 注: 扩展内置对象往往是 **危险** 的.
+>
+> 扩展 JavaScript 原生对象意味着将属性或方法添加到其原型或内置对象上,  
+> 其潜在的危险包括但不限于以下几种情况:
+>
+> 1. 无意中修改或覆盖了 JavaScript 标准的内置方法
+> 2. 自定义扩展方法被定义者或合作开发者修改后需修改大量依赖代码甚至出错
+> 3. 导入库时可能存在与本地同名扩展方法冲突
+> 4. 导入多个库时可能存在库之间的同名扩展方法冲突
+> 5. 未来标准更新后可能与已有扩展方法冲突
+>
+> 因此建议使用模块化编程替代对象扩展.  
+> 如确实有对象扩展需求, 建议新建一个与原生对象名称相似但不同的对象进行扩展, 如下文示例.
+
+上述扩展方式均可采用更安全 (但使用起来可能相对复杂) 的方式实现:
+
+```js
+let Objectx = {};
+
+Objectx.saySomething = function (content) {
+    console.log(content);
+};
+
+Objectx.saySomething("hello"); /* print "hello". */
+
+let Mathx = {};
+
+Mathx.sum = function (x, y) {
+    return +x + +y;
+};
+
+console.log(Mathx.sum(2, 3)); // 5
+
+let Arrayx = {};
+
+Arrayx.sorted = function (arr) {
+    return arr.slice().sort();
+};
+
+let arr = [ 1, 2, 9, 3 ];
+console.log(Arrayx.sorted(arr)); // [ 1, 2, 3, 9 ]
+
+let Numberx = {};
+
+Numberx.toFixedNum = function (num, fraction) {
+    return +num.toFixed(fraction);
+};
+
+let num = 375.201;
+console.log(Numberx.toFixedNum(num, 2)); // 375.2
+```
+
+AutoJs6 默认提供了一些内置对象扩展, 如 [ [Arrayx](arrayx), [Numberx](numberx), [Mathx](mathx) ] 等.
+
+这些扩展默认是安全的, 统一为 `Ax.b` 的调用方式,  
+如 `Arrayx.intersect`, `Mathx.sum`, `Numberx.clamp`.
+
+```js
+console.log(Arrayx.intersect([ 1, 2, 3, 4 ], [ 1, 3, 5 ])); // [ 1, 3 ] 
+console.log(Numberx.clamp(Math.random(), [ 0.3, 0.5 ])); // e.g. 0.4251169347959409 
+```
+
+而另一种不安全的扩展, 即直接扩展内置对象, 可实现更为便捷的调用:
+
+```js
+console.log([ 1, 2, 3, 4 ].intersect([ 1, 3, 5 ])); // [ 1, 3 ]
+console.log(Math.random().clamp([ 0.3, 0.5 ])); // e.g. 0.4251169347959409
+```
+
+如需默认进行直接扩展, 可选择以下任一方式:
+
+- 在脚本中加入代码片段: `plugins.extendAll();`
+- AutoJs6 应用设置 - 扩展性 - JavaScript 内置对象扩展 - [ 启用 ]
+
+进行直接扩展后, 所有扩展属性和方法会按需附加到内置对象或其原型上, 详情参考每个扩展对象的小节内容.  
+直接扩展是不安全的, 需谨慎使用.
+
+> 参阅: [StackOverflow](https://stackoverflow.com/questions/14034180/why-is-extending-native-objects-a-bad-practice) / [lucybain.com](https://lucybain.com/blog/2014/js-extending-built-in-objects/)
+
+## Polyfill
+
+又称 [ 代码填泥 / 填泥 / 腻子 / 泥子 ], 是一个完整的代码块, 用于为不支持原生 ECMAScript 新功能的环境提供功能支持.  
+详见 [代码填泥](polyfill) 章节.
+
+## Shim
+
+又称 [ 代码垫片 / 垫片 / 填隙片 ], 是一种小型函数库, 可以用来截取 API 调用或修改传入参数, 最后自行处理对应操作或者将操作交由其它地方执行.  
+垫片可以在新环境中支持老 API, 也可以在老环境里支持新 API.  
+一些程序并没有针对某些平台开发, 也可以通过使用垫片来辅助运行.
+
+Shim 与 Polyfill 的不同, 可参阅 [代码填泥](polyfill) 章节.
+
+## 应用资源
+
+应用资源指代码使用的附加文件和静态内容, 如 [ 位图 / 布局定义 / 界面字符串 / 动画说明 ] 等.
+
+通常, 应用资源与代码是分离的, 以便于独立维护.  
+资源可进行分组并放入专门命名的资源目录中, 如 [ animator / color / drawable / layout / values / menu ] 等.  
+在运行时, Android 会根据当前配置使用合适的资源, 如根据屏幕尺寸提供不同的界面布局或根据语言设置提供不同的字符串.
+
+将应用资源分离之后, 可使用项目的 R 类中生成的 [资源 ID](#资源-ID) 对其进行访问.
+
+```js
+console.log(context.getString(R.string.text_app_name_powerpoint)); // PowerPoint
+console.log(R.id.explorer_item_list); /* e.g. 2131296535 */
+console.log(`0x${java.lang.Integer.toHexString(R.id.explorer_item_list)}`); /* e.g. 0x7f090117 */
+```
+
+> 参阅: [Android Docs](https://developer.android.com/guide/topics/resources/providing-resources?hl=zh-cn)
+
+## 资源 ID
+
+在代码中使用 R 类的子类中的静态整数可访问 [应用资源](#应用资源):
+
+```js
+/* 资源 ID 是一个整数. */
+console.log(R.string.text_app_name_autojspro); /* e.g. 2131887020 */
+```
+
+根据资源类型获取类型值 (string):
+
+```js
+console.log(context.getString(R.string.text_app_name_autojspro)); /* e.g. AutoJsPro */
+```
+
+根据资源类型获取类型值 (drawable):
+
+```js
+/* 绘制一个淡绿色的铃铛图标. */
+
+'ui';
+
+ui.layout(<vertical bg="#FFFFFF">
+    <img id="img" tint="#9CCC65"/>
+</vertical>);
+
+ui.img.setImageResource(R.drawable.ic_ali_notification);
+```
+
+在 XML 中也可访问 `资源 ID`:
+
+```js
+/* 绘制一个淡绿色的铃铛图标. */
+
+'ui';
+
+ui.layout(<vertical bg="#FFFFFF">
+    <img id="img" tint="#9CCC65" src="@drawable/ic_ali_notification"/>
+</vertical>);
+```
+
+将 `资源 ID` 的十六进制值与 `0x` 前缀组合, 可作为控件的 [idHex](uiObjectType#m-idhex) 信息:
+
+```js
+/* 直接对资源 ID 值组合. */
+console.log(`0x${java.lang.Integer.toHexString(R.id.explorer_item_list)}`); /* e.g. 0x7f090117 */
+
+/* 在 AutoJs6 主页找到对应控件并获取其 idHex 值. */
+console.log(idMatch(/explorer_item_list/).findOnce().idHex()); /* e.g. 0x7f090117 */
+```
+
+## 控件层级
+
+类似 HTML 的层级绘制, 安卓的视图 (View) 嵌套也会形成层级, 外部视图成为其内部视图的父控件 (Parent Node), 内部视图成为外部视图的子控件 (Child Node).
+
+在 AutoJs6 中, 控件由 [UiObject](uiObjectType) 表示.
+
+以下方式可获取当前窗口的控件层级:
+
+- 使用 AutoJs6 获取
+    - AutoJs6 主页侧拉抽屉 -> 悬浮窗 [开启] -> 悬浮图标 [点击]
+        - 方案 A: 蓝色按钮 [点击] -> (布局范围分析) -> 控件图示 [点击] -> 在布局层次中查看
+        - 方案 B: 蓝色按钮 [长按] -> 布局层次分析 [点击]
+
+- 使用 uiautomatorviewer 工具获取
+    - 位置 (以 Windows 为例): `"%ANDROID_HOME%\tools\bin\uiautomatorviewer.bat"`
+
+- 使用 Android Studio 的 Layout Inspector 工具获取
+    - Android Studio -> Tools -> Layout Inspector
+
+- 使用 ADB Shell 的 dumpsys 指令获取
+    - 使用 AutoJs6 执行代码 `console.log(shell('dumpsys activity top').result);`
+
+## 信息集控件
+
+信息集控件指拥有一个非 null 的 [无障碍节点信息集 (AccessibilityNodeInfo.CollectionInfo)](https://developer.android.com/reference/android/view/accessibility/AccessibilityNodeInfo.CollectionInfo) 实例的控件.
+
+```js
+let info = w.getCollectionInfo();
+console.log(info);
+```
+
+信息集控件包含一系列子控件, 它们类似 HTML 表格那样按行列方式分布.  
+例如垂直列表是一个信息集控件, 它有一列多行作为子控件; 表格也是一个信息集控件, 它有多列多行作为子控件.  
+这些子控件均拥有非 null 的 [无障碍节点子项信息集 (AccessibilityNodeInfo.CollectionItemInfo)](https://developer.android.com/reference/android/view/accessibility/AccessibilityNodeInfo.CollectionItemInfo):
+
+```js
+/* 通常, 在 AutoJs6 主页即可获取到至少一个信息集控件. */
+scrollable().find().some((w) => {
+    let info = w.getCollectionInfo();
+    if (info !== null) {
+
+        /* 展示常用的信息集实例属性或方法. */
+
+        console.log(`rowCount: ${info.getRowCount()}`); /* 对应 w.rowCount() 封装方法. */
+        console.log(`columnCount: ${info.getColumnCount()}`); /* 对应 w.columnCount() 封装方法. */
+
+        w.children().forEach((c) => {
+            let itemInfo = c.getCollectionItemInfo();
+            if (itemInfo !== null) {
+
+                /* 展示常用的子项信息集实例属性或方法. */
+
+                console.log(c.bounds());
+                console.log(`rowIndex: ${itemInfo.getRowIndex()}`); /* 对应 w.row() 封装方法. */
+                console.log(`columnIndex: ${itemInfo.getColumnIndex()}`); /* 对应 w.column() 封装方法. */
+                console.log(`rowSpan: ${itemInfo.getRowSpan()}`); /* 对应 w.rowSpan() 封装方法. */
+                console.log(`columnSpan: ${itemInfo.getColumnSpan()}`); /* 对应 w.columnSpan() 封装方法. */
+                console.log(`selected: ${itemInfo.isSelected()}`);
+                console.log(`rowTitle: ${itemInfo.getRowTitle()}`);
+                console.log(`columnTitle: ${itemInfo.getColumnTitle()}`);
+                console.log('-'.repeat(33));
+            }
+        });
+
+        return /* @some */ true;
+    }
+});
+```
+
+部分属性或方法:
+
+- `[m#]` getRowCount / `[p#]` rowCount
+- `[m#]` getColumnCount / `[p#]` columnCount
+
+常见与信息集存在关联的类:
+
+- android.widget.GridView
+- android.widget.ListView
+- android.widget.RadioGroup
+- com.android.systemui.qs.TileLayout
+- androidx.recyclerview.widget.RecyclerView
+
+## 子项信息集控件
+
+子项信息集控件指拥有 [无障碍节点子项信息集 (AccessibilityNodeInfo.CollectionItemInfo)](https://developer.android.com/reference/android/view/accessibility/AccessibilityNodeInfo.CollectionItemInfo) 实例的一组控件, 它们共同属于同一个 [信息集控件](#信息集控件).
+
+部分属性或方法:
+
+- `[m#]` getRowIndex / `[p#]` rowIndex
+- `[m#]` getColumnIndex / `[p#]` columnIndex
+- `[m#]` getRowSpan / `[p#]` rowSpan
+- `[m#]` getColumnSpan / `[p#]` columnSpan
+- `[m#]` isSelected / `[p#]` selected
+- `[m#]` getRowTitle / `[p#]` rowTitle
+- `[m#]` getColumnTitle / `[p#]` columnTitle
+
+## 控件矩形外展
+
+[控件矩形](dataTypes.md#androidrect) 边界为非整数时, 外展将对各个边界做如下取整操作:
+
+- left - 左边界左移, 即向下取整, 类似 JavaScript 语言的 Math.floor(left)
+- top - 上边界上移, 即向下取整, 类似 JavaScript 语言的 Math.floor(top)
+- right - 右边界右移, 即向上取整, 类似 JavaScript 语言的 Math.ceil(right)
+- bottom - 下边界下移, 即向上取整, 类似 JavaScript 语言的 Math.ceil(bottom)
+
+例如:  
+
+`Rect(10.9, 12.6 - 120.37, 1882.02)` 外展后得到  
+`Rect(10, 12, 121, 1883)`
+
+> 注: "外展" 源自健身术语
+
+## 控件矩形内收
+
+[控件矩形](dataTypes.md#androidrect) 边界为非整数时, 外展将对各个边界做如下取整操作:
+
+- left - 左边界右移, 即向上取整, 类似 JavaScript 语言的 Math.ceil(left)
+- top - 上边界下移, 即向上取整, 类似 JavaScript 语言的 Math.ceil(top)
+- right - 右边界左移, 即向下取整, 类似 JavaScript 语言的 Math.floor(right)
+- bottom - 下边界上移, 即向下取整, 类似 JavaScript 语言的 Math.floor(bottom)
+
+例如:
+
+`Rect(10.9, 12.6 - 120.37, 1882.02)` 内收后得到  
+`Rect(11, 13, 120, 1882)`
+
+> 注: "内收" 源自健身术语
\ No newline at end of file
diff --git a/api/http.md b/api/http.md
index d30ace6..c981dba 100644
--- a/api/http.md
+++ b/api/http.md
@@ -1,16 +1,21 @@
 # HTTP
 
-> Stability: 2 - Stable
+---
 
-http模块提供一些进行http请求的函数。
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
+
+---
+
+http模块提供一些进行http请求的函数.
 
 ## http.get(url[, options, callback])
 
-* `url` {string} 请求的URL地址，需要以"http://"或"https://"开头。如果url没有以"http://"开头，则默认为"http://"。
-* `options` {Object} 请求选项。参见[http.request()][]。
-* `callback` {Function} 回调函数，可选，其参数是一个[Response][]对象。如果不加回调函数，则该请求将阻塞、同步地执行。
+* `url` {string} 请求的URL地址, 需要以"http://"或"https://"开头. 如果url没有以"http://"开头, 则默认为"http://".
+* `options` {Object} 请求选项. 参见[http.request()][].
+* `callback` {Function} 回调函数, 可选, 其参数是一个[Response][]对象. 如果不加回调函数, 则该请求将阻塞、同步地执行.
 
-对地址url进行一次HTTP GET 请求。如果没有回调函数，则在请求完成或失败时返回此次请求的响应(参见[Response][])。
+对地址url进行一次HTTP GET 请求. 如果没有回调函数, 则在请求完成或失败时返回此次请求的响应(参见[Response][]).
 
 最简单GET请求如下:
 
@@ -35,7 +40,7 @@ http.get("www.baidu.com", {}, function(res, err){
 });
 ```
 
-如果要增加HTTP头部信息，则在options参数中添加，例如：
+如果要增加HTTP头部信息, 则在options参数中添加, 例如：
 
 ```
 console.show();
@@ -66,14 +71,14 @@ if(res.statusCode != 200){
 
 ## http.post(url, data[, options, callback])
 
-* `url` {string} 请求的URL地址，需要以"http://"或"https://"开头。如果url没有以"http://"开头，则默认为"http://"。
-* `data` {string} | {Object} POST数据。
-* `options` {Object} 请求选项。
-* `callback` {Function} 回调，其参数是一个[Response][]对象。如果不加回调参数，则该请求将阻塞、同步地执行。
+* `url` {string} 请求的URL地址, 需要以"http://"或"https://"开头. 如果url没有以"http://"开头, 则默认为"http://".
+* `data` {string} | {Object} POST数据.
+* `options` {Object} 请求选项.
+* `callback` {Function} 回调, 其参数是一个[Response][]对象. 如果不加回调参数, 则该请求将阻塞、同步地执行.
 
-对地址url进行一次HTTP POST 请求。如果没有回调函数，则在请求完成或失败时返回此次请求的响应(参见[Response][])。
+对地址url进行一次HTTP POST 请求. 如果没有回调函数, 则在请求完成或失败时返回此次请求的响应(参见[Response][]).
 
-其中POST数据可以是字符串或键值对。具体含义取决于options.contentType的值。默认为"application/x-www-form-urlencoded"(表单提交), 这种方式是JQuery的ajax函数的默认方式。
+其中POST数据可以是字符串或键值对. 具体含义取决于options.contentType的值. 默认为"application/x-www-form-urlencoded"(表单提交), 这种方式是JQuery的ajax函数的默认方式.
 
 一个模拟表单提交登录淘宝的例子如下:
 
@@ -95,14 +100,14 @@ if(html.contains("页面跳转中")){
 
 ## http.postJson(url[, data, options, callback])
 
-* `url` {string} 请求的URL地址，需要以"http://"或"https://"开头。如果url没有以"http://"开头，则默认为"http://"。
-* `data` {Object} POST数据。
-* `options` {Object} 请求选项。
-* `callback` {Function} 回调，其参数是一个[Response][]对象。如果不加回调参数，则该请求将阻塞、同步地执行。
+* `url` {string} 请求的URL地址, 需要以"http://"或"https://"开头. 如果url没有以"http://"开头, 则默认为"http://".
+* `data` {Object} POST数据.
+* `options` {Object} 请求选项.
+* `callback` {Function} 回调, 其参数是一个[Response][]对象. 如果不加回调参数, 则该请求将阻塞、同步地执行.
 
-以JSON格式向目标Url发起POST请求。如果没有回调函数，则在请求完成或失败时返回此次请求的响应(参见[Response][])。
+以JSON格式向目标Url发起POST请求. 如果没有回调函数, 则在请求完成或失败时返回此次请求的响应(参见[Response][]).
 
-JSON格式指的是，将会调用`JSON.stringify()`把data对象转换为JSON字符串，并在HTTP头部信息中把"Content-Type"属性置为"application/json"。这种方式是AngularJS的ajax函数的默认方式。
+JSON格式指的是, 将会调用`JSON.stringify()`把data对象转换为JSON字符串, 并在HTTP头部信息中把"Content-Type"属性置为"application/json". 这种方式是AngularJS的ajax函数的默认方式.
 
 一个调用图灵机器人接口的例子如下：
 
@@ -118,19 +123,19 @@ toastLog(r.body.string());
 
 ## http.postMultipart(url, files[, options, callback])
 
-* `url` {string} 请求的URL地址，需要以"http://"或"https://"开头。如果url没有以"http://"开头，则默认为"http://"。
-* `files` {Object} POST数据。
-* `options` {Object} 请求选项。
-* `callback` {Function} 回调，其参数是一个`Response`对象。如果不加回调参数，则该请求将阻塞、同步地执行。
+* `url` {string} 请求的URL地址, 需要以"http://"或"https://"开头. 如果url没有以"http://"开头, 则默认为"http://".
+* `files` {Object} POST数据.
+* `options` {Object} 请求选项.
+* `callback` {Function} 回调, 其参数是一个`Response`对象. 如果不加回调参数, 则该请求将阻塞、同步地执行.
 
-向目标地址发起类型为multipart/form-data的请求（通常用于文件上传等), 其中files参数是{name1: value1, name2: value2, ...}的键值对，value的格式可以是以下几种情况：
+向目标地址发起类型为multipart/form-data的请求（通常用于文件上传等), 其中files参数是{name1: value1, name2: value2, ...}的键值对, value的格式可以是以下几种情况：
 
 1. `string`
-2. 文件类型，即open()返回的类型
+2. 文件类型, 即open()返回的类型
 3. [fileName, filePath]
 4. [fileName, mimeType, filePath]
 
-其中1属于非文件参数，2、3、4为文件参数。举个例子，最简单的文件上传的请求为：
+其中1属于非文件参数, 2、3、4为文件参数. 举个例子, 最简单的文件上传的请求为：
 
 ```
 var res = http.postMultipart(url, {
@@ -139,7 +144,7 @@ var res = http.postMultipart(url, {
 log(res.body.string());
 ```
 
-如果使用格式2，则代码为
+如果使用格式2, 则代码为
 
 ```
 var res = http.postMultipart(url, {
@@ -148,7 +153,7 @@ var res = http.postMultipart(url, {
 log(res.body.string());
 ```
 
-如果使用格式3，则代码为
+如果使用格式3, 则代码为
 
 ```
 var res = http.postMultipart(url, {
@@ -157,7 +162,7 @@ var res = http.postMultipart(url, {
 log(res.body.string());
 ```
 
-如果使用格式2的同时要附带非文件参数"appId=abcdefghijk"，则为:
+如果使用格式2的同时要附带非文件参数"appId=abcdefghijk", 则为:
 
 ```
 var res = http.postMultipart(url, {
@@ -169,40 +174,40 @@ log(res.body.string());
 
 ## http.request(url[, options, callback])
 
-* `url` {string} 请求的URL地址，需要以"http://"或"https://"开头。如果url没有以"http://"开头，则默认为"http://"。
-* `options` {Object} 请求选项。参见[http.buildRequest()][]。
-* `callback` {Function} 回调，其参数是一个[Response][]对象。如果不加回调参数，则该请求将阻塞、同步地执行。
+* `url` {string} 请求的URL地址, 需要以"http://"或"https://"开头. 如果url没有以"http://"开头, 则默认为"http://".
+* `options` {Object} 请求选项. 参见[http.buildRequest()][].
+* `callback` {Function} 回调, 其参数是一个[Response][]对象. 如果不加回调参数, 则该请求将阻塞、同步地执行.
 
-对目标地址url发起一次HTTP请求。如果没有回调函数，则在请求完成或失败时返回此次请求的响应(参见[Response][])。
+对目标地址url发起一次HTTP请求. 如果没有回调函数, 则在请求完成或失败时返回此次请求的响应(参见[Response][]).
 
 选项options可以包含以下属性：
 
-* `headers` {Object} 键值对形式的HTTP头部信息。有关HTTP头部信息，参见[菜鸟教程：HTTP响应头信息](http://www.runoob.com/http/http-header-fields.html)。
-* `method` {string} HTTP请求方法。包括"GET", "POST", "PUT", "DELET", "PATCH"。
-* `contentType` {string} HTTP头部信息中的"Content-Type", 表示HTTP请求的内容类型。例如"text/plain", "application/json"。更多信息参见[菜鸟教程：HTTP contentType](http://www.runoob.com/http/http-content-type.html)。
-* `body` {string} | {Array} | {Function} HTTP请求的内容。可以是一个字符串，也可以是一个字节数组；或者是一个以[BufferedSink](https://github.com/square/okio/blob/master/okio/src/main/java/okio/BufferedSink.java)为参数的函数。
+* `headers` {Object} 键值对形式的HTTP头部信息. 有关HTTP头部信息, 参见[菜鸟教程：HTTP响应头信息](http://www.runoob.com/http/http-header-fields.html).
+* `method` {string} HTTP请求方法. 包括"GET", "POST", "PUT", "DELET", "PATCH".
+* `contentType` {string} HTTP头部信息中的"Content-Type", 表示HTTP请求的内容类型. 例如"text/plain", "application/json". 更多信息参见[菜鸟教程：HTTP contentType](http://www.runoob.com/http/http-content-type.html).
+* `body` {string} | {Array} | {Function} HTTP请求的内容. 可以是一个字符串, 也可以是一个字节数组；或者是一个以[BufferedSink](https://github.com/square/okio/blob/master/okio/src/main/java/okio/BufferedSink.java/)为参数的函数.
 
-该函数是get, post, postJson等函数的基础函数。因此除非是PUT, DELET等请求，或者需要更高定制的HTTP请求，否则直接使用get, post, postJson等函数会更加方便。
+该函数是get, post, postJson等函数的基础函数. 因此除非是PUT, DELET等请求, 或者需要更高定制的HTTP请求, 否则直接使用get, post, postJson等函数会更加方便.
 
 # Response
 
-HTTP请求的响应。
+HTTP请求的响应.
 
 ## Response.statusCode
 
 * {number}
 
-当前响应的HTTP状态码。例如200(OK), 404(Not Found)等。
+当前响应的HTTP状态码. 例如200(OK), 404(Not Found)等.
 
-有关HTTP状态码的信息，参见[菜鸟教程：HTTP状态码](http://www.runoob.com/http/http-status-codes.html)。
+有关HTTP状态码的信息, 参见[菜鸟教程：HTTP状态码](http://www.runoob.com/http/http-status-codes.html).
 
 ## Response.statusMessage
 
 * {string}
 
-当前响应的HTTP状态信息。例如"OK", "Bad Request", "Forbidden"。
+当前响应的HTTP状态信息. 例如"OK", "Bad Request", "Forbidden".
 
-有关HTTP状态码的信息，参见[菜鸟教程：HTTP状态码](http://www.runoob.com/http/http-status-codes.html)。
+有关HTTP状态码的信息, 参见[菜鸟教程：HTTP状态码](http://www.runoob.com/http/http-status-codes.html).
 
 例子：
 
@@ -221,9 +226,9 @@ if(res.statusCode >= 200 && res.statusCode < 300){
 
 * {Object}
 
-当前响应的HTTP头部信息。该对象的键是响应头名称，值是各自的响应头值。 所有响应头名称都是小写的(吗)。
+当前响应的HTTP头部信息. 该对象的键是响应头名称, 值是各自的响应头值.  所有响应头名称都是小写的(吗).
 
-有关HTTP头部信息，参见[菜鸟教程：HTTP响应头信息](http://www.runoob.com/http/http-header-fields.html)。
+有关HTTP头部信息, 参见[菜鸟教程：HTTP响应头信息](http://www.runoob.com/http/http-header-fields.html).
 
 例子:
 
@@ -240,24 +245,24 @@ for(var headerName in res.headers){
 
 * {Object}
 
-当前响应的内容。他有以下属性和函数：
+当前响应的内容. 他有以下属性和函数：
 
 * bytes() {Array} 以字节数组形式返回响应内容
 * string() {string} 以字符串形式返回响应内容
-* json() {Object} 把响应内容作为JSON格式的数据并调用JSON.parse，返回解析后的对象
+* json() {Object} 把响应内容作为JSON格式的数据并调用JSON.parse, 返回解析后的对象
 * contentType {string} 当前响应的内容类型
 
 ## Response.request
 
 * {Request}
-  当前响应所对应的请求。参见[Request][]。
+  当前响应所对应的请求. 参见[Request][].
 
 ## Response.url
 
 * {number}
-  当前响应所对应的请求URL。
+  当前响应所对应的请求URL.
 
 ## Response.method
 
 * {string}
-  当前响应所对应的HTTP请求的方法。例如"GET", "POST", "PUT"等。
+  当前响应所对应的HTTP请求的方法. 例如"GET", "POST", "PUT"等.
diff --git a/api/i18n.md b/api/i18n.md
new file mode 100644
index 0000000..47d679a
--- /dev/null
+++ b/api/i18n.md
@@ -0,0 +1,10 @@
+# 国际化 (Internationalization)
+
+---
+
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
+
+---
+
+
diff --git a/api/image.md b/api/image.md
new file mode 100644
index 0000000..18b74e5
--- /dev/null
+++ b/api/image.md
@@ -0,0 +1,798 @@
+# 图像 (Images)
+
+---
+
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
+
+---
+
+images模块提供了一些手机设备中常见的图片处理函数, 包括截图、读写图片、图片剪裁、旋转、二值化、找色找图等.
+
+该模块分为两个部分, 找图找色部分和图片处理部分.
+
+需要注意的是, image对象创建后尽量在不使用时进行回收, 同时避免循环创建大量图片. 因为图片是一种占用内存比较大的资源, 尽管Auto.js通过各种方式（比如图片缓存机制、垃圾回收时回收图片、脚本结束时回收所有图片）尽量降低图片资源的泄漏和内存占用, 但是糟糕的代码仍然可以占用大量内存.
+
+Image对象通过调用`recycle()`函数来回收. 例如：
+
+```
+// 读取图片
+var img = images.read("./1.png");
+//对图片进行操作
+... 
+// 回收图片
+img.recycle();
+```
+
+例外的是, `caputerScreen()`返回的图片不需要回收.
+
+## 图片处理
+
+## images.read(path)
+
+* `path` {string} 图片路径
+
+读取在路径path的图片文件并返回一个Image对象. 如果文件不存在或者文件无法解码则返回null.
+
+## images.load(url)
+
+* `url` {string} 图片URL地址
+
+加载在地址URL的网络图片并返回一个Image对象. 如果地址不存在或者图片无法解码则返回null.
+
+## images.copy(img)
+
+* `img` {Image} 图片
+* 返回 {Image}
+
+复制一张图片并返回新的副本. 该函数会完全复制img对象的数据.
+
+## images.save(image, path[, format = "png", quality = 100])
+
+* `image` {Image} 图片
+* `path` {string} 路径
+* `format` {string} 图片格式, 可选的值为:
+    * `png`
+    * `jpeg`/`jpg`
+    * `webp`
+* `quality` {number} 图片质量, 为0~100的整数值
+
+把图片image以PNG格式保存到path中. 如果文件不存在会被创建；文件存在会被覆盖.
+
+```
+//把图片压缩为原来的一半质量并保存
+var img = images.read("/sdcard/1.png");
+images.save(img, "/sdcard/1.jpg", "jpg", 50);
+app.viewFile("/sdcard/1.jpg");
+```
+
+## images.fromBase64(base64)
+
+* `base64` {string} 图片的Base64数据
+* 返回 {Image}
+
+解码Base64数据并返回解码后的图片Image对象. 如果base64无法解码则返回`null`.
+
+## images.toBase64(img[, format = "png", quality = 100])
+
+* `image` {image} 图片
+* `format` {string} 图片格式, 可选的值为:
+    * `png`
+    * `jpeg`/`jpg`
+    * `webp`
+* `quality` {number} 图片质量, 为0~100的整数值
+* 返回 {string}
+
+把图片编码为base64数据并返回.
+
+## images.fromBytes(bytes)
+
+* `bytes` {byte[]} 字节数组
+
+解码字节数组bytes并返回解码后的图片Image对象. 如果bytes无法解码则返回`null`.
+
+## images.toBytes(img[, format = "png", quality = 100])
+
+* `image` {image} 图片
+* `format` {string} 图片格式, 可选的值为:
+    * `png`
+    * `jpeg`/`jpg`
+    * `webp`
+* `quality` {number} 图片质量, 为0~100的整数值
+* 返回 {byte[]}
+
+把图片编码为字节数组并返回.
+
+## images.clip(img, x, y, w, h)
+
+* `img` {Image} 图片
+* `x` {number} 剪切区域的左上角横坐标
+* `y` {number} 剪切区域的左上角纵坐标
+* `w` {number} 剪切区域的宽度
+* `h` {number} 剪切区域的高度
+* 返回 {Image}
+
+从图片img的位置(x, y)处剪切大小为w * h的区域, 并返回该剪切区域的新图片.
+
+```
+var src = images.read("/sdcard/1.png");
+var clip = images.clip(src, 100, 100, 400, 400);
+images.save(clip, "/sdcard/clip.png");
+```
+
+## images.resize(img, size[, interpolation])
+
+**[v4.1.0新增]**
+
+* `img` {Image} 图片
+* `size` {Array} 两个元素的数组[w, h], 分别表示宽度和高度；如果只有一个元素, 则宽度和高度相等
+* `interpolation` {string} 插值方法, 可选, 默认为"LINEAR"（线性插值）, 可选的值有：
+    * `NEAREST` 最近邻插值
+    * `LINEAR` 线性插值（默认）
+    * `AREA` 区域插值
+    * `CUBIC` 三次样条插值
+    * `LANCZOS4` Lanczos插值
+      参见[InterpolationFlags](https://docs.opencv.org/3.4.4/da/d54/group__imgproc__transform.html#ga5bb5a1fea74ea38e1a5445ca803ff121/)
+
+* 返回 {Image}
+
+调整图片大小, 并返回调整后的图片. 例如把图片放缩为200*300：`images.resize(img, [200, 300])`.
+
+参见[Imgproc.resize](https://docs.opencv.org/3.4.4/da/d54/group__imgproc__transform.html#ga47a974309e9102f5f08231edc7e7529d/).
+
+## images.scale(img, fx, fy[, interpolation])
+
+**[v4.1.0新增]**
+
+* `img` {Image} 图片
+* `fx` {number} 宽度放缩倍数
+* `fy` {number} 高度放缩倍数
+* `interpolation` {string} 插值方法, 可选, 默认为"LINEAR"（线性插值）, 可选的值有：
+    * `NEAREST` 最近邻插值
+    * `LINEAR` 线性插值（默认）
+    * `AREA` 区域插值
+    * `CUBIC` 三次样条插值
+    * `LANCZOS4` Lanczos插值
+      参见[InterpolationFlags](https://docs.opencv.org/3.4.4/da/d54/group__imgproc__transform.html#ga5bb5a1fea74ea38e1a5445ca803ff121/)
+
+* 返回 {Image}
+
+放缩图片, 并返回放缩后的图片. 例如把图片变成原来的一半：`images.scale(img, 0.5, 0.5)`.
+
+参见[Imgproc.resize](https://docs.opencv.org/3.4.4/da/d54/group__imgproc__transform.html#ga47a974309e9102f5f08231edc7e7529d/).
+
+## images.rotate(img, degress[, x, y])
+
+**[v4.1.0新增]**
+
+* `img` {Image} 图片
+* `degress` {number} 旋转角度.
+* `x` {number} 旋转中心x坐标, 默认为图片中点
+* `y` {number} 旋转中心y坐标, 默认为图片中点
+* 返回 {Image}
+
+将图片逆时针旋转degress度, 返回旋转后的图片对象.
+
+例如逆时针旋转90度为`images.rotate(img, 90)`.
+
+## images.concat(img1, image2[, direction])
+
+**[v4.1.0新增]**
+
+* `img1` {Image} 图片1
+* `img2` {Image} 图片2
+* direction {string} 连接方向, 默认为"RIGHT", 可选的值有：
+    * `LEFT` 将图片2接到图片1左边
+    * `RIGHT` 将图片2接到图片1右边
+    * `TOP` 将图片2接到图片1上边
+    * `BOTTOM` 将图片2接到图片1下边
+* 返回 {Image}
+
+连接两张图片, 并返回连接后的图像. 如果两张图片大小不一致, 小的那张将适当居中.
+
+## images.grayscale(img)
+
+**[v4.1.0新增]**
+
+* `img` {Image} 图片
+* 返回 {Image}
+
+灰度化图片, 并返回灰度化后的图片.
+
+## image.threshold(img, threshold, maxVal[, type])
+
+**[v4.1.0新增]**
+
+* `img` {Image} 图片
+* `threshold` {number} 阈值
+* `maxVal` {number} 最大值
+* `type` {string} 阈值化类型, 默认为"BINARY", 参见[ThresholdTypes](https://docs.opencv.org/3.4.4/d7/d1b/group__imgproc__misc.html#gaa9e58d2860d4afa658ef70a9b1115576/), 可选的值:
+    * `BINARY`
+    * `BINARY_INV`
+    * `TRUNC`
+    * `TOZERO`
+    * `TOZERO_INV`
+    * `OTSU`
+    * `TRIANGLE`
+
+* 返回 {Image}
+
+将图片阈值化, 并返回处理后的图像. 可以用这个函数进行图片二值化. 例如：`images.threshold(img, 100, 255, "BINARY")`, 这个代码将图片中大于100的值全部变成255, 其余变成0, 从而达到二值化的效果. 如果img是一张灰度化图片, 这个代码将会得到一张黑白图片.
+
+可以参考有关博客（比如[threshold函数的使用](https://blog.csdn.net/u012566751/article/details/77046445/)）或者OpenCV文档[threshold](https://docs.opencv.org/3.4.4/d7/d1b/group__imgproc__misc.html#gae8a4a146d1ca78c626a53577199e9c57/).
+
+## images.adaptiveThreshold(img, maxValue, adaptiveMethod, thresholdType, blockSize, C)
+
+**[v4.1.0新增]**
+
+* `img` {Image} 图片
+* `maxValue` {number} 最大值
+* `adaptiveMethod` {string} 在一个邻域内计算阈值所采用的算法, 可选的值有：
+    * `MEAN_C` 计算出领域的平均值再减去参数C的值
+    * `GAUSSIAN_C` 计算出领域的高斯均值再减去参数C的值
+* `thresholdType` {string} 阈值化类型, 可选的值有：
+    * `BINARY`
+    * `BINARY_INV`
+* `blockSize` {number} 邻域块大小
+* `C` {number} 偏移值调整量
+* 返回 {Image}
+
+对图片进行自适应阈值化处理, 并返回处理后的图像.
+
+可以参考有关博客（比如[threshold与adaptiveThreshold](https://blog.csdn.net/guduruyu/article/details/68059450/)）或者OpenCV文档[adaptiveThreshold](https://docs.opencv.org/3.4.4/d7/d1b/group__imgproc__misc.html#ga72b913f352e4a1b1b397736707afcde3
+/).
+
+## images.cvtColor(img, code[, dstCn])
+
+**[v4.1.0新增]**
+
+* `img` {Image} 图片
+* `code` {string} 颜色空间转换的类型, 可选的值有一共有205个（参见[ColorConversionCodes](https://docs.opencv.org/3.4.4/d8/d01/group__imgproc__color__conversions.html#ga4e0972be5de079fed4e3a10e24ef5ef0/)）, 这里只列出几个：
+    * `BGR2GRAY` BGR转换为灰度
+    * `BGR2HSV ` BGR转换为HSV
+    * ``
+* `dstCn` {number} 目标图像的颜色通道数量, 如果不填写则根据其他参数自动决定.
+* 返回 {Image}
+
+对图像进行颜色空间转换, 并返回转换后的图像.
+
+可以参考有关博客（比如[颜色空间转换](https://blog.csdn.net/u011574296/article/details/70896811?locationNum=14&fps=1)）或者OpenCV文档[cvtColor](https://docs.opencv.org/3.4.4/d8/d01/group__imgproc__color__conversions.html#ga397ae87e1288a81d2363b61574eb8cab/).
+
+## images.inRange(img, lowerBound, upperBound)
+
+**[v4.1.0新增]**
+
+* `img` {Image} 图片
+* `lowerBound` {string} | {number} 颜色下界
+* `upperBound` {string} | {number} 颜色下界
+* 返回 {Image}
+
+将图片二值化, 在lowerBound~upperBound范围以外的颜色都变成0, 在范围以内的颜色都变成255.
+
+例如`images.inRange(img, "#000000", "#222222")`.
+
+## images.interval(img, color, interval)
+
+**[v4.1.0新增]**
+
+* `img` {Image} 图片
+* `color` {string} | {number} 颜色值
+* `interval` {number} 每个通道的范围间隔
+* 返回 {Image}
+
+将图片二值化, 在color-interval ~ color+interval范围以外的颜色都变成0, 在范围以内的颜色都变成255. 这里对color的加减是对每个通道而言的.
+
+例如`images.interval(img, "#888888", 16)`, 每个通道的颜色值均为0x88, 加减16后的范围是[0x78, 0x98], 因此这个代码将把#787878~#989898的颜色变成#FFFFFF, 而把这个范围以外的变成#000000.
+
+## images.blur(img, size[, anchor, type])
+
+**[v4.1.0新增]**
+
+* `img` {Image} 图片
+* `size` {Array} 定义滤波器的大小, 如[3, 3]
+* `anchor` {Array} 指定锚点位置(被平滑点), 默认为图像中心
+* `type` {string} 推断边缘像素类型, 默认为"DEFAULT", 可选的值有：
+    * `CONSTANT` iiiiii|abcdefgh|iiiiiii with some specified i
+    * `REPLICATE` aaaaaa|abcdefgh|hhhhhhh
+    * `REFLECT` fedcba|abcdefgh|hgfedcb
+    * `WRAP` cdefgh|abcdefgh|abcdefg
+    * `REFLECT_101` gfedcb|abcdefgh|gfedcba
+    * `TRANSPARENT` uvwxyz|abcdefgh|ijklmno
+    * `REFLECT101` same as BORDER_REFLECT_101
+    * `DEFAULT` same as BORDER_REFLECT_101
+    * `ISOLATED` do not look outside of ROI
+* 返回 {Image}
+
+对图像进行模糊（平滑处理）, 返回处理后的图像.
+
+可以参考有关博客（比如[实现图像平滑处理](https://www.cnblogs.com/denny402/p/3848316.html)）或者OpenCV文档[blur](https://docs.opencv.org/3.4.4/d4/d86/group__imgproc__filter.html#ga8c45db9afe636703801b0b2e440fce37/).
+
+## images.medianBlur(img, size)
+
+**[v4.1.0新增]**
+
+* `img` {Image} 图片
+* `size` {Array} 定义滤波器的大小, 如[3, 3]
+* 返回 {Image}
+
+对图像进行中值滤波, 返回处理后的图像.
+
+可以参考有关博客（比如[实现图像平滑处理](https://www.cnblogs.com/denny402/p/3848316.html)）或者OpenCV文档[blur](https://docs.opencv.org/3.4.4/d4/d86/group__imgproc__filter.html#ga564869aa33e58769b4469101aac458f9/).
+
+## images.gaussianBlur(img, size[, sigmaX, sigmaY, type])
+
+**[v4.1.0新增]**
+
+* `img` {Image} 图片
+* `size` {Array} 定义滤波器的大小, 如[3, 3]
+* `sigmaX` {number} x方向的标准方差, 不填写则自动计算
+* `sigmaY` {number} y方向的标准方差, 不填写则自动计算
+* `type` {string} 推断边缘像素类型, 默认为"DEFAULT", 参见`images.blur`
+* 返回 {Image}
+
+对图像进行高斯模糊, 返回处理后的图像.
+
+可以参考有关博客（比如[实现图像平滑处理](https://www.cnblogs.com/denny402/p/3848316.html)）或者OpenCV文档[GaussianBlur](https://docs.opencv.org/3.4.4/d4/d86/group__imgproc__filter.html#gaabe8c836e97159a9193fb0b11ac52cf1/).
+
+## images.matToImage(mat)
+
+**[v4.1.0新增]**
+
+* `mat` {Mat} OpenCV的Mat对象
+* 返回 {Image}
+
+把Mat对象转换为Image对象.
+
+## 找图找色
+
+## images.requestScreenCapture([landscape])
+
+* `landscape` {boolean} 布尔值,  表示将要执行的截屏是否为横屏. 如果landscape为false, 则表示竖屏截图; true为横屏截图.
+
+向系统申请屏幕截图权限, 返回是否请求成功.
+
+第一次使用该函数会弹出截图权限请求, 建议选择“总是允许”.
+
+这个函数只是申请截图权限, 并不会真正执行截图, 真正的截图函数是`captureScreen()`.
+
+该函数在截图脚本中只需执行一次, 而无需每次调用`captureScreen()`都调用一次.
+
+**如果不指定landscape值, 则截图方向由当前设备屏幕方向决定**, 因此务必注意执行该函数时的屏幕方向.
+
+建议在本软件界面运行该函数, 在其他软件界面运行时容易出现一闪而过的黑屏现象.
+
+示例:
+
+```
+//请求截图
+if(!requestScreenCapture()){
+    toast("请求截图失败");
+    exit();
+}
+//连续截图10张图片(间隔1秒)并保存到存储卡目录
+for(var i = 0; i < 10; i++){
+    captureScreen("/sdcard/screencapture" + i + ".png");
+    sleep(1000);
+}
+
+```
+
+该函数也可以作为全局函数使用.
+
+## images.captureScreen()
+
+截取当前屏幕并返回一个Image对象.
+
+没有截图权限时执行该函数会抛出SecurityException.
+
+该函数不会返回null, 两次调用可能返回相同的Image对象. 这是因为设备截图的更新需要一定的时间, 短时间内（一般来说是16ms）连续调用则会返回同一张截图.
+
+截图需要转换为Bitmap格式, 从而该函数执行需要一定的时间(0~20ms).
+
+另外在requestScreenCapture()执行成功后需要一定时间后才有截图可用, 因此如果立即调用captureScreen(), 会等待一定时间后(一般为几百ms)才返回截图.
+
+例子:
+
+```
+//请求横屏截图
+requestScreenCapture(true);
+//截图
+var img = captureScreen();
+//获取在点(100, 100)的颜色值
+var color = images.pixel(img, 100, 100);
+//显示该颜色值
+toast(colors.toString(color));
+```
+
+该函数也可以作为全局函数使用.
+
+## images.captureScreen(path)
+
+* `path` {string} 截图保存路径
+
+截取当前屏幕并以PNG格式保存到path中. 如果文件不存在会被创建；文件存在会被覆盖.
+
+该函数不会返回任何值. 该函数也可以作为全局函数使用.
+
+## images.pixel(image, x, y)
+
+* `image` {Image} 图片
+* `x` {number} 要获取的像素的横坐标.
+* `y` {number} 要获取的像素的纵坐标.
+
+返回图片image在点(x, y)处的像素的ARGB值.
+
+该值的格式为0xAARRGGBB, 是一个"32位整数"(虽然JavaScript中并不区分整数类型和其他数值类型).
+
+坐标系以图片左上角为原点. 以图片左侧边为y轴, 上侧边为x轴.
+
+## images.findColor(image, color, options)
+
+* `image` {Image} 图片
+* `color` {number} | {string} 要寻找的颜色的RGB值. 如果是一个整数, 则以0xRRGGBB的形式代表RGB值（A通道会被忽略）；如果是字符串, 则以"#RRGGBB"代表其RGB值.
+* `options` {Object} 选项
+
+在图片中寻找颜色color. 找到时返回找到的点Point, 找不到时返回null.
+
+选项包括：
+
+* `region` {Array} 找色区域. 是一个两个或四个元素的数组. (region[0], region[1])表示找色区域的左上角；region[2]*region[3]表示找色区域的宽高. 如果只有region只有两个元素, 则找色区域为(region[0], region[1])到屏幕右下角. 如果不指定region选项, 则找色区域为整张图片.
+* `threshold` {number} 找色时颜色相似度的临界值, 范围为0~255（越小越相似, 0为颜色相等, 255为任何颜色都能匹配）. 默认为4. threshold和浮点数相似度(0.0~1.0)的换算为 similarity = (255 - threshold) / 255.
+
+该函数也可以作为全局函数使用.
+
+一个循环找色的例子如下：
+
+```
+requestScreenCapture();
+
+//循环找色, 找到红色(#ff0000)时停止并报告坐标
+while(true){
+    var img = captureScreen();
+    var point = findColor(img, "#ff0000");
+    if(point){
+        toast("找到红色, 坐标为(" + point.x + ", " + point.y + ")");
+    }
+}
+
+```
+
+一个区域找色的例子如下：
+
+```
+//读取本地图片/sdcard/1.png
+var img = images.read("/sdcard/1.png");
+//判断图片是否加载成功
+if(!img){
+    toast("没有该图片");
+    exit();
+}
+//在该图片中找色, 指定找色区域为在位置(400, 500)的宽为300长为200的区域, 指定找色临界值为4
+var point = findColor(img, "#00ff00", {
+     region: [400, 500, 300, 200],
+     threshold: 4
+ });
+if(point){
+    toast("找到啦:" + point);
+}else{
+    toast("没找到");
+}
+```
+
+## images.findColorInRegion(img, color, x, y[, width, height, threshold])
+
+区域找色的简便方法.
+
+相当于
+
+```
+images.findColor(img, color, {
+     region: [x, y, width, height],
+     threshold: threshold
+});
+```
+
+该函数也可以作为全局函数使用.
+
+## images.findColorEquals(img, color[, x, y, width, height])
+
+* `img` {Image} 图片
+* `color` {number} | {string} 要寻找的颜色
+* `x` {number} 找色区域的左上角横坐标
+* `y` {number} 找色区域的左上角纵坐标
+* `width` {number} 找色区域的宽度
+* `height` {number} 找色区域的高度
+* 返回 {Point}
+
+在图片img指定区域中找到颜色和color完全相等的某个点, 并返回该点的左边；如果没有找到, 则返回`null`.
+
+找色区域通过`x`, `y`, `width`, `height`指定, 如果不指定找色区域, 则在整张图片中寻找.
+
+该函数也可以作为全局函数使用.
+
+示例：
+(通过找QQ红点的颜色来判断是否有未读消息)
+
+```
+requestScreenCapture();
+launchApp("QQ");
+sleep(1200);
+var p = findColorEquals(captureScreen(), "#f64d30");
+if(p){
+    toast("有未读消息");
+}else{
+    toast("没有未读消息");
+}
+```
+
+## images.findMultiColors(img, firstColor, colors[, options])
+
+* `img` {Image} 要找色的图片
+* `firstColor` {number} | {string} 第一个点的颜色
+* `colors` {Array} 表示剩下的点相对于第一个点的位置和颜色的数组, 数组的每个元素为[x, y, color]
+* `options` {Object} 选项, 包括：
+    * `region` {Array} 找色区域. 是一个两个或四个元素的数组. (region[0], region[1])表示找色区域的左上角；region[2]*region[3]表示找色区域的宽高. 如果只有region只有两个元素, 则找色区域为(region[0], region[1])到屏幕右下角. 如果不指定region选项, 则找色区域为整张图片.
+    * `threshold` {number} 找色时颜色相似度的临界值, 范围为0~255（越小越相似, 0为颜色相等, 255为任何颜色都能匹配）. 默认为4. threshold和浮点数相似度(0.0~1.0)的换算为 similarity = (255 - threshold) / 255.
+
+多点找色, 类似于按键精灵的多点找色, 其过程如下：
+
+1. 在图片img中找到颜色firstColor的位置(x0, y0)
+2. 对于数组colors的每个元素[x, y, color], 检查图片img在位置(x + x0, y + y0)上的像素是否是颜色color, 是的话返回(x0, y0), 否则继续寻找firstColor的位置, 重新执行第1步
+3. 整张图片都找不到时返回`null`
+
+例如, 对于代码`images.findMultiColors(img, "#123456", [[10, 20, "#ffffff"], [30, 40, "#000000"]])`, 假设图片在(100, 200)的位置的颜色为#123456, 这时如果(110, 220)的位置的颜色为#fffff且(130, 240)的位置的颜色为#000000, 则函数返回点(100, 200).
+
+如果要指定找色区域, 则在options中指定, 例如:
+
+```
+var p = images.findMultiColors(img, "#123456", [[10, 20, "#ffffff"], [30, 40, "#000000"]], {
+    region: [0, 960, 1080, 960]
+});
+```
+
+## images.detectsColor(image, color, x, y[, threshold = 16, algorithm = "diff"])
+
+* `image` {Image} 图片
+* `color` {number} | {string} 要检测的颜色
+* `x` {number} 要检测的位置横坐标
+* `y` {number} 要检测的位置纵坐标
+* `threshold` {number} 颜色相似度临界值, 默认为16. 取值范围为0~255.
+* `algorithm` {string} 颜色匹配算法, 包括:
+    * "equal": 相等匹配, 只有与给定颜色color完全相等时才匹配.
+    * "diff": 差值匹配. 与给定颜色的R、G、B差的绝对值之和小于threshold时匹配.
+    * "rgb": rgb欧拉距离相似度. 与给定颜色color的rgb欧拉距离小于等于threshold时匹配.
+
+    * "rgb+": 加权rgb欧拉距离匹配([LAB Delta E](https://en.wikipedia.org/wiki/Color_difference/)).
+    * "hs": hs欧拉距离匹配. hs为HSV空间的色调值.
+
+返回图片image在位置(x, y)处是否匹配到颜色color. 用于检测图片中某个位置是否是特定颜色.
+
+一个判断微博客户端的某个微博是否被点赞过的例子：
+
+```
+requestScreenCapture();
+//找到点赞控件
+var like = id("ly_feed_like_icon").findOne();
+//获取该控件中点坐标
+var x = like.bounds().centerX();
+var y = like.bounds().centerY();
+//截图
+var img = captureScreen();
+//判断在该坐标的颜色是否为橙红色
+if(images.detectsColor(img, "#fed9a8", x, y)){
+    //是的话则已经是点赞过的了, 不做任何动作
+}else{
+    //否则点击点赞按钮
+    like.click();
+}
+```
+
+## images.findImage(img, template[, options])
+
+* `img` {Image} 大图片
+* `template` {Image} 小图片（模板）
+* `options` {Object} 找图选项
+
+找图. 在大图片img中查找小图片template的位置（模块匹配）, 找到时返回位置坐标(Point), 找不到时返回null.
+
+选项包括：
+
+* `threshold` {number} 图片相似度. 取值范围为0~1的浮点数. 默认值为0.9.
+* `region` {Array} 找图区域. 参见findColor函数关于region的说明.
+* `level` {number} **一般而言不必修改此参数**. 不加此参数时该参数会根据图片大小自动调整. 找图算法是采用图像金字塔进行的, level参数表示金字塔的层次, level越大可能带来越高的找图效率, 但也可能造成找图失败（图片因过度缩小而无法分辨）或返回错误位置. 因此, 除非您清楚该参数的意义并需要进行性能调优, 否则不需要用到该参数.
+
+该函数也可以作为全局函数使用.
+
+一个最简单的找图例子如下：
+
+```
+var img = images.read("/sdcard/大图.png");
+var templ = images.read("/sdcard/小图.png");
+var p = findImage(img, templ);
+if(p){
+    toast("找到啦:" + p);
+}else{
+    toast("没找到");
+}
+```
+
+稍微复杂点的区域找图例子如下：
+
+```
+auto();
+requestScreenCapture();
+var wx = images.read("/sdcard/微信图标.png");
+//返回桌面
+home();
+//截图并找图
+var p = findImage(captureScreen(), wx, {
+    region: [0, 50],
+    threshold: 0.8
+});
+if(p){
+    toast("在桌面找到了微信图标啦: " + p);
+}else{
+    toast("在桌面没有找到微信图标");
+}
+```
+
+## images.findImageInRegion(img, template, x, y[, width, height, threshold])
+
+区域找图的简便方法. 相当于：
+
+```
+images.findImage(img, template, {
+    region: [x, y, width, height],
+    threshold: threshold
+})
+```
+
+该函数也可以作为全局函数使用.
+
+## images.matchTemplate(img, template, options)
+
+**[v4.1.0新增]**
+
+* `img` {Image} 大图片
+* `template` {Image} 小图片（模板）
+* `options` {Object} 找图选项：
+    * `threshold` {number} 图片相似度. 取值范围为0~1的浮点数. 默认值为0.9.
+    * `region` {Array} 找图区域. 参见findColor函数关于region的说明.
+    * `max` {number} 找图结果最大数量, 默认为5
+    * `level` {number} **一般而言不必修改此参数**. 不加此参数时该参数会根据图片大小自动调整. 找图算法是采用图像金字塔进行的, level参数表示金字塔的层次, level越大可能带来越高的找图效率, 但也可能造成找图失败（图片因过度缩小而无法分辨）或返回错误位置. 因此, 除非您清楚该参数的意义并需要进行性能调优, 否则不需要用到该参数.
+* 返回 {MatchingResult}
+
+在大图片中搜索小图片, 并返回搜索结果MatchingResult. 该函数可以用于找图时找出多个位置, 可以通过max参数控制最大的结果数量. 也可以对匹配结果进行排序、求最值等操作.
+
+# MatchingResult
+
+**[v4.1.0新增]**
+
+## matches
+
+* {Array} 匹配结果的数组.
+
+数组的元素是一个Match对象：
+
+* `point` {Point} 匹配位置
+* `similarity` {number} 相似度
+
+例如:
+
+```
+var result = images.matchTemplate(img, template, {
+    max: 100
+});
+result.matches.forEach(match => {
+    log("point = " + match.point + ", similarity = " + match.similarity);
+});
+```
+
+## points
+
+* {Array} 匹配位置的数组.
+
+## first()
+
+* 返回 {Match}
+
+第一个匹配结果. 如果没有任何匹配, 则返回`null`.
+
+## last()
+
+* 返回 {Match}
+
+最后一个匹配结果. 如果没有任何匹配, 则返回`null`.
+
+## leftmost()
+
+* 返回 {Match}
+
+位于大图片最左边的匹配结果. 如果没有任何匹配, 则返回`null`.
+
+## topmost()
+
+* 返回 {Match}
+
+位于大图片最上边的匹配结果. 如果没有任何匹配, 则返回`null`.
+
+## rightmost()
+
+* 返回 {Match}
+
+位于大图片最右边的匹配结果. 如果没有任何匹配, 则返回`null`.
+
+## bottommost()
+
+* 返回 {Match}
+
+位于大图片最下边的匹配结果. 如果没有任何匹配, 则返回`null`.
+
+## best()
+
+* 返回 {Match}
+
+相似度最高的匹配结果. 如果没有任何匹配, 则返回`null`.
+
+## worst()
+
+* 返回 {Match}
+
+相似度最低的匹配结果. 如果没有任何匹配, 则返回`null`.
+
+## sortBy(cmp)
+
+* cmp {Function}|{string} 比较函数, 或者是一个字符串表示排序方向. 例如"left"表示将匹配结果按匹配位置从左往右排序、"top"表示将匹配结果按匹配位置从上往下排序, "left-top"表示将匹配结果按匹配位置从左往右、从上往下排序. 方向包括`left`（左）, `top` （上）, `right` （右）, `bottom`（下）.
+* {MatchingResult}
+
+对匹配结果进行排序, 并返回排序后的结果.
+
+```
+var result = images.matchTemplate(img, template, {
+    max: 100
+});
+log(result.sortBy("top-right"));
+```
+
+# Image
+
+表示一张图片, 可以是截图的图片, 或者本地读取的图片, 或者从网络获取的图片.
+
+## Image.getWidth()
+
+返回以像素为单位图片宽度.
+
+## Image.getHeight()
+
+返回以像素为单位的图片高度.
+
+## Image.saveTo(path)
+
+* `path` {string} 路径
+
+把图片保存到路径path. （如果文件存在则覆盖）
+
+## Image.pixel(x, y)
+
+* `x` {number} 横坐标
+* `y` {number} 纵坐标
+
+返回图片image在点(x, y)处的像素的ARGB值.
+
+该值的格式为0xAARRGGBB, 是一个"32位整数"(虽然JavaScript中并不区分整数类型和其他数值类型).
+
+坐标系以图片左上角为原点. 以图片左侧边为y轴, 上侧边为x轴.
+
+##
+
+# Point
+
+findColor, findImage返回的对象. 表示一个点（坐标）.
+
+## Point.x
+
+横坐标.
+
+## Point.y
+
+纵坐标.
diff --git a/api/images.md b/api/images.md
deleted file mode 100644
index fa5b7ee..0000000
--- a/api/images.md
+++ /dev/null
@@ -1,941 +0,0 @@
-# colors
-
-> Stability: 2 - Stable
-
-在Auto.js有两种方式表示一个颜色。
-
-一种是使用一个字符串"#AARRGGBB"或"#RRGGBB"，其中 AA 是Alpha通道(透明度)的值，RR 是R通道(红色)的值，GG 是G通道(绿色)的值，BB是B通道(蓝色)的值。例如"#ffffff"表示白色, "#7F000000"表示半透明的黑色。
-
-另一种是使用一个16进制的"32位整数" 0xAARRGGBB 来表示一个颜色，例如 `0xFF112233`表示颜色"#112233", `0x11223344`表示颜色"#11223344"。
-
-可以通过`colors.toString()`把颜色整数转换为字符串，通过`colors.parseColor()`把颜色字符串解析为颜色整数。
-
-## colors.toString(color)
-
-* `color` {number} 整数RGB颜色值
-* 返回 {string}
-
-返回颜色值的字符串，格式为 "#AARRGGBB"。
-
-## colors.red(color)
-
-* `color` {number} | {string} 颜色值
-* 返回 {number}
-
-返回颜色color的R通道的值，范围0~255.
-
-## colors.green(color)
-
-* `color` {number} | {string} 颜色值
-* 返回 {number}
-
-返回颜色color的G通道的值，范围0~255.
-
-## colors.blue(color)
-
-* `color` {number} | {string} 颜色值
-* 返回 {number}
-
-返回颜色color的B通道的值，范围0~255.
-
-## colors.alpha(color)
-
-* `color` {number} | {string} 颜色值
-* 返回 {number}
-
-返回颜色color的Alpha通道的值，范围0~255.
-
-## colors.rgb(red, green, blue)
-
-* red {number} 颜色的R通道的值
-* blue {number} 颜色的G通道的值
-* green {number} 颜色的B通道的值
-* 返回 {number}
-
-返回这些颜色通道构成的整数颜色值。Alpha通道将是255（不透明）。
-
-## colors.argb(alpha, red, green, blue)
-
-* `alpha` {number} 颜色的Alpha通道的值
-* `red` {number} 颜色的R通道的值
-* `green` {number} 颜色的G通道的值
-* `blue` {number} 颜色的B通道的值
-* 返回 {number}
-
-返回这些颜色通道构成的整数颜色值。
-
-## colors.parseColor(colorStr)
-
-* `colorStr` {string} 表示颜色的字符串，例如"#112233"
-* 返回 {number}
-
-返回颜色的整数值。
-
-## colors.isSimilar(color2, color2[, threshold, algorithm])
-
-* `color1` {number} | {string} 颜色值1
-* `color1` {number} | {string} 颜色值2
-* `threshold` {number} 颜色相似度临界值，默认为4。取值范围为0~255。这个值越大表示允许的相似程度越小，如果这个值为0，则两个颜色相等时该函数才会返回true。
-* `algorithm` {string} 颜色匹配算法，默认为"diff", 包括:
-    * "diff": 差值匹配。与给定颜色的R、G、B差的绝对值之和小于threshold时匹配。
-    * "rgb": rgb欧拉距离相似度。与给定颜色color的rgb欧拉距离小于等于threshold时匹配。
-    * "rgb+": 加权rgb欧拉距离匹配([LAB Delta E](https://en.wikipedia.org/wiki/Color_difference))。
-    * "hs": hs欧拉距离匹配。hs为HSV空间的色调值。
-* 返回 {Boolean}
-
-返回两个颜色是否相似。
-
-## colors.equals(color1, color2)
-
-* `color1` {number} | {string} 颜色值1
-* `color1` {number} | {string} 颜色值2
-* 返回 {Boolean}
-
-返回两个颜色是否相等。**注意该函数会忽略Alpha通道的值进行比较*。
-
-```
-log(colors.equals("#112233", "#112234"));
-log(colors.equals(0xFF112233, 0xFF223344));
-```
-
-# colors.BLACK
-
-黑色，颜色值 #FF000000
-
-# colors.DKGRAY
-
-深灰色，颜色值 #FF444444
-
-# colors.GRAY
-
-灰色，颜色值 #FF888888
-
-# colors.LTGRAY
-
-亮灰色，颜色值 #FFCCCCCC
-
-# colors.WHITE
-
-白色，颜色值 #FFFFFFFF
-
-# colors.RED
-
-红色，颜色值 #FFFF0000
-
-# colors.GREEN
-
-绿色，颜色值 #FF00FF00
-
-# colors.BLUE
-
-蓝色，颜色值 #FF0000FF
-
-# colors.YELLOW
-
-黄色，颜色值 #FFFFFF00
-
-# colors.CYAN
-
-青色，颜色值 #FF00FFFF
-
-# colors.MAGENTA
-
-品红色，颜色值 #FFFF00FF
-
-# colors.TRANSPARENT
-
-透明，颜色值 #00000000
-
-# Images
-
-> Stability: 2 - Stable
-
-images模块提供了一些手机设备中常见的图片处理函数，包括截图、读写图片、图片剪裁、旋转、二值化、找色找图等。
-
-该模块分为两个部分，找图找色部分和图片处理部分。
-
-需要注意的是，image对象创建后尽量在不使用时进行回收，同时避免循环创建大量图片。因为图片是一种占用内存比较大的资源，尽管Auto.js通过各种方式（比如图片缓存机制、垃圾回收时回收图片、脚本结束时回收所有图片）尽量降低图片资源的泄漏和内存占用，但是糟糕的代码仍然可以占用大量内存。
-
-Image对象通过调用`recycle()`函数来回收。例如：
-
-```
-// 读取图片
-var img = images.read("./1.png");
-//对图片进行操作
-... 
-// 回收图片
-img.recycle();
-```
-
-例外的是，`caputerScreen()`返回的图片不需要回收。
-
-## 图片处理
-
-## images.read(path)
-
-* `path` {string} 图片路径
-
-读取在路径path的图片文件并返回一个Image对象。如果文件不存在或者文件无法解码则返回null。
-
-## images.load(url)
-
-* `url` {string} 图片URL地址
-
-加载在地址URL的网络图片并返回一个Image对象。如果地址不存在或者图片无法解码则返回null。
-
-## images.copy(img)
-
-* `img` {Image} 图片
-* 返回 {Image}
-
-复制一张图片并返回新的副本。该函数会完全复制img对象的数据。
-
-## images.save(image, path[, format = "png", quality = 100])
-
-* `image` {Image} 图片
-* `path` {string} 路径
-* `format` {string} 图片格式，可选的值为:
-    * `png`
-    * `jpeg`/`jpg`
-    * `webp`
-* `quality` {number} 图片质量，为0~100的整数值
-
-把图片image以PNG格式保存到path中。如果文件不存在会被创建；文件存在会被覆盖。
-
-```
-//把图片压缩为原来的一半质量并保存
-var img = images.read("/sdcard/1.png");
-images.save(img, "/sdcard/1.jpg", "jpg", 50);
-app.viewFile("/sdcard/1.jpg");
-```
-
-## images.fromBase64(base64)
-
-* `base64` {string} 图片的Base64数据
-* 返回 {Image}
-
-解码Base64数据并返回解码后的图片Image对象。如果base64无法解码则返回`null`。
-
-## images.toBase64(img[, format = "png", quality = 100])
-
-* `image` {image} 图片
-* `format` {string} 图片格式，可选的值为:
-    * `png`
-    * `jpeg`/`jpg`
-    * `webp`
-* `quality` {number} 图片质量，为0~100的整数值
-* 返回 {string}
-
-把图片编码为base64数据并返回。
-
-## images.fromBytes(bytes)
-
-* `bytes` {byte[]} 字节数组
-
-解码字节数组bytes并返回解码后的图片Image对象。如果bytes无法解码则返回`null`。
-
-## images.toBytes(img[, format = "png", quality = 100])
-
-* `image` {image} 图片
-* `format` {string} 图片格式，可选的值为:
-    * `png`
-    * `jpeg`/`jpg`
-    * `webp`
-* `quality` {number} 图片质量，为0~100的整数值
-* 返回 {byte[]}
-
-把图片编码为字节数组并返回。
-
-## images.clip(img, x, y, w, h)
-
-* `img` {Image} 图片
-* `x` {number} 剪切区域的左上角横坐标
-* `y` {number} 剪切区域的左上角纵坐标
-* `w` {number} 剪切区域的宽度
-* `h` {number} 剪切区域的高度
-* 返回 {Image}
-
-从图片img的位置(x, y)处剪切大小为w * h的区域，并返回该剪切区域的新图片。
-
-```
-var src = images.read("/sdcard/1.png");
-var clip = images.clip(src, 100, 100, 400, 400);
-images.save(clip, "/sdcard/clip.png");
-```
-
-## images.resize(img, size[, interpolation])
-
-**[v4.1.0新增]**
-
-* `img` {Image} 图片
-* `size` {Array} 两个元素的数组[w, h]，分别表示宽度和高度；如果只有一个元素，则宽度和高度相等
-* `interpolation` {string} 插值方法，可选，默认为"LINEAR"（线性插值），可选的值有：
-    * `NEAREST` 最近邻插值
-    * `LINEAR` 线性插值（默认）
-    * `AREA` 区域插值
-    * `CUBIC` 三次样条插值
-    * `LANCZOS4` Lanczos插值
-      参见[InterpolationFlags](https://docs.opencv.org/3.4.4/da/d54/group__imgproc__transform.html#ga5bb5a1fea74ea38e1a5445ca803ff121)
-
-* 返回 {Image}
-
-调整图片大小，并返回调整后的图片。例如把图片放缩为200*300：`images.resize(img, [200, 300])`。
-
-参见[Imgproc.resize](https://docs.opencv.org/3.4.4/da/d54/group__imgproc__transform.html#ga47a974309e9102f5f08231edc7e7529d)。
-
-## images.scale(img, fx, fy[, interpolation])
-
-**[v4.1.0新增]**
-
-* `img` {Image} 图片
-* `fx` {number} 宽度放缩倍数
-* `fy` {number} 高度放缩倍数
-* `interpolation` {string} 插值方法，可选，默认为"LINEAR"（线性插值），可选的值有：
-    * `NEAREST` 最近邻插值
-    * `LINEAR` 线性插值（默认）
-    * `AREA` 区域插值
-    * `CUBIC` 三次样条插值
-    * `LANCZOS4` Lanczos插值
-      参见[InterpolationFlags](https://docs.opencv.org/3.4.4/da/d54/group__imgproc__transform.html#ga5bb5a1fea74ea38e1a5445ca803ff121)
-
-* 返回 {Image}
-
-放缩图片，并返回放缩后的图片。例如把图片变成原来的一半：`images.scale(img, 0.5, 0.5)`。
-
-参见[Imgproc.resize](https://docs.opencv.org/3.4.4/da/d54/group__imgproc__transform.html#ga47a974309e9102f5f08231edc7e7529d)。
-
-## images.rotate(img, degress[, x, y])
-
-**[v4.1.0新增]**
-
-* `img` {Image} 图片
-* `degress` {number} 旋转角度。
-* `x` {number} 旋转中心x坐标，默认为图片中点
-* `y` {number} 旋转中心y坐标，默认为图片中点
-* 返回 {Image}
-
-将图片逆时针旋转degress度，返回旋转后的图片对象。
-
-例如逆时针旋转90度为`images.rotate(img, 90)`。
-
-## images.concat(img1, image2[, direction])
-
-**[v4.1.0新增]**
-
-* `img1` {Image} 图片1
-* `img2` {Image} 图片2
-* direction {string} 连接方向，默认为"RIGHT"，可选的值有：
-    * `LEFT` 将图片2接到图片1左边
-    * `RIGHT` 将图片2接到图片1右边
-    * `TOP` 将图片2接到图片1上边
-    * `BOTTOM` 将图片2接到图片1下边
-* 返回 {Image}
-
-连接两张图片，并返回连接后的图像。如果两张图片大小不一致，小的那张将适当居中。
-
-## images.grayscale(img)
-
-**[v4.1.0新增]**
-
-* `img` {Image} 图片
-* 返回 {Image}
-
-灰度化图片，并返回灰度化后的图片。
-
-## image.threshold(img, threshold, maxVal[, type])
-
-**[v4.1.0新增]**
-
-* `img` {Image} 图片
-* `threshold` {number} 阈值
-* `maxVal` {number} 最大值
-* `type` {string} 阈值化类型，默认为"BINARY"，参见[ThresholdTypes](https://docs.opencv.org/3.4.4/d7/d1b/group__imgproc__misc.html#gaa9e58d2860d4afa658ef70a9b1115576), 可选的值:
-    * `BINARY`
-    * `BINARY_INV`
-    * `TRUNC`
-    * `TOZERO`
-    * `TOZERO_INV`
-    * `OTSU`
-    * `TRIANGLE`
-
-* 返回 {Image}
-
-将图片阈值化，并返回处理后的图像。可以用这个函数进行图片二值化。例如：`images.threshold(img, 100, 255, "BINARY")`，这个代码将图片中大于100的值全部变成255，其余变成0，从而达到二值化的效果。如果img是一张灰度化图片，这个代码将会得到一张黑白图片。
-
-可以参考有关博客（比如[threshold函数的使用](https://blog.csdn.net/u012566751/article/details/77046445)）或者OpenCV文档[threshold](https://docs.opencv.org/3.4.4/d7/d1b/group__imgproc__misc.html#gae8a4a146d1ca78c626a53577199e9c57)。
-
-## images.adaptiveThreshold(img, maxValue, adaptiveMethod, thresholdType, blockSize, C)
-
-**[v4.1.0新增]**
-
-* `img` {Image} 图片
-* `maxValue` {number} 最大值
-* `adaptiveMethod` {string} 在一个邻域内计算阈值所采用的算法，可选的值有：
-    * `MEAN_C` 计算出领域的平均值再减去参数C的值
-    * `GAUSSIAN_C` 计算出领域的高斯均值再减去参数C的值
-* `thresholdType` {string} 阈值化类型，可选的值有：
-    * `BINARY`
-    * `BINARY_INV`
-* `blockSize` {number} 邻域块大小
-* `C` {number} 偏移值调整量
-* 返回 {Image}
-
-对图片进行自适应阈值化处理，并返回处理后的图像。
-
-可以参考有关博客（比如[threshold与adaptiveThreshold](https://blog.csdn.net/guduruyu/article/details/68059450)）或者OpenCV文档[adaptiveThreshold](https://docs.opencv.org/3.4.4/d7/d1b/group__imgproc__misc.html#ga72b913f352e4a1b1b397736707afcde3
-)。
-
-## images.cvtColor(img, code[, dstCn])
-
-**[v4.1.0新增]**
-
-* `img` {Image} 图片
-* `code` {string} 颜色空间转换的类型，可选的值有一共有205个（参见[ColorConversionCodes](https://docs.opencv.org/3.4.4/d8/d01/group__imgproc__color__conversions.html#ga4e0972be5de079fed4e3a10e24ef5ef0)），这里只列出几个：
-    * `BGR2GRAY` BGR转换为灰度
-    * `BGR2HSV ` BGR转换为HSV
-    * ``
-* `dstCn` {number} 目标图像的颜色通道数量，如果不填写则根据其他参数自动决定。
-* 返回 {Image}
-
-对图像进行颜色空间转换，并返回转换后的图像。
-
-可以参考有关博客（比如[颜色空间转换](https://blog.csdn.net/u011574296/article/details/70896811?locationNum=14&fps=1)）或者OpenCV文档[cvtColor](https://docs.opencv.org/3.4.4/d8/d01/group__imgproc__color__conversions.html#ga397ae87e1288a81d2363b61574eb8cab)。
-
-## images.inRange(img, lowerBound, upperBound)
-
-**[v4.1.0新增]**
-
-* `img` {Image} 图片
-* `lowerBound` {string} | {number} 颜色下界
-* `upperBound` {string} | {number} 颜色下界
-* 返回 {Image}
-
-将图片二值化，在lowerBound~upperBound范围以外的颜色都变成0，在范围以内的颜色都变成255。
-
-例如`images.inRange(img, "#000000", "#222222")`。
-
-## images.interval(img, color, interval)
-
-**[v4.1.0新增]**
-
-* `img` {Image} 图片
-* `color` {string} | {number} 颜色值
-* `interval` {number} 每个通道的范围间隔
-* 返回 {Image}
-
-将图片二值化，在color-interval ~ color+interval范围以外的颜色都变成0，在范围以内的颜色都变成255。这里对color的加减是对每个通道而言的。
-
-例如`images.interval(img, "#888888", 16)`，每个通道的颜色值均为0x88，加减16后的范围是[0x78, 0x98]，因此这个代码将把#787878~#989898的颜色变成#FFFFFF，而把这个范围以外的变成#000000。
-
-## images.blur(img, size[, anchor, type])
-
-**[v4.1.0新增]**
-
-* `img` {Image} 图片
-* `size` {Array} 定义滤波器的大小，如[3, 3]
-* `anchor` {Array} 指定锚点位置(被平滑点)，默认为图像中心
-* `type` {string} 推断边缘像素类型，默认为"DEFAULT"，可选的值有：
-    * `CONSTANT` iiiiii|abcdefgh|iiiiiii with some specified i
-    * `REPLICATE` aaaaaa|abcdefgh|hhhhhhh
-    * `REFLECT` fedcba|abcdefgh|hgfedcb
-    * `WRAP` cdefgh|abcdefgh|abcdefg
-    * `REFLECT_101` gfedcb|abcdefgh|gfedcba
-    * `TRANSPARENT` uvwxyz|abcdefgh|ijklmno
-    * `REFLECT101` same as BORDER_REFLECT_101
-    * `DEFAULT` same as BORDER_REFLECT_101
-    * `ISOLATED` do not look outside of ROI
-* 返回 {Image}
-
-对图像进行模糊（平滑处理），返回处理后的图像。
-
-可以参考有关博客（比如[实现图像平滑处理](https://www.cnblogs.com/denny402/p/3848316.html)）或者OpenCV文档[blur](https://docs.opencv.org/3.4.4/d4/d86/group__imgproc__filter.html#ga8c45db9afe636703801b0b2e440fce37)。
-
-## images.medianBlur(img, size)
-
-**[v4.1.0新增]**
-
-* `img` {Image} 图片
-* `size` {Array} 定义滤波器的大小，如[3, 3]
-* 返回 {Image}
-
-对图像进行中值滤波，返回处理后的图像。
-
-可以参考有关博客（比如[实现图像平滑处理](https://www.cnblogs.com/denny402/p/3848316.html)）或者OpenCV文档[blur](https://docs.opencv.org/3.4.4/d4/d86/group__imgproc__filter.html#ga564869aa33e58769b4469101aac458f9)。
-
-## images.gaussianBlur(img, size[, sigmaX, sigmaY, type])
-
-**[v4.1.0新增]**
-
-* `img` {Image} 图片
-* `size` {Array} 定义滤波器的大小，如[3, 3]
-* `sigmaX` {number} x方向的标准方差，不填写则自动计算
-* `sigmaY` {number} y方向的标准方差，不填写则自动计算
-* `type` {string} 推断边缘像素类型，默认为"DEFAULT"，参见`images.blur`
-* 返回 {Image}
-
-对图像进行高斯模糊，返回处理后的图像。
-
-可以参考有关博客（比如[实现图像平滑处理](https://www.cnblogs.com/denny402/p/3848316.html)）或者OpenCV文档[GaussianBlur](https://docs.opencv.org/3.4.4/d4/d86/group__imgproc__filter.html#gaabe8c836e97159a9193fb0b11ac52cf1)。
-
-## images.matToImage(mat)
-
-**[v4.1.0新增]**
-
-* `mat` {Mat} OpenCV的Mat对象
-* 返回 {Image}
-
-把Mat对象转换为Image对象。
-
-## 找图找色
-
-## images.requestScreenCapture([landscape])
-
-* `landscape` {boolean} 布尔值， 表示将要执行的截屏是否为横屏。如果landscape为false, 则表示竖屏截图; true为横屏截图。
-
-向系统申请屏幕截图权限，返回是否请求成功。
-
-第一次使用该函数会弹出截图权限请求，建议选择“总是允许”。
-
-这个函数只是申请截图权限，并不会真正执行截图，真正的截图函数是`captureScreen()`。
-
-该函数在截图脚本中只需执行一次，而无需每次调用`captureScreen()`都调用一次。
-
-**如果不指定landscape值，则截图方向由当前设备屏幕方向决定**，因此务必注意执行该函数时的屏幕方向。
-
-建议在本软件界面运行该函数，在其他软件界面运行时容易出现一闪而过的黑屏现象。
-
-示例:
-
-```
-//请求截图
-if(!requestScreenCapture()){
-    toast("请求截图失败");
-    exit();
-}
-//连续截图10张图片(间隔1秒)并保存到存储卡目录
-for(var i = 0; i < 10; i++){
-    captureScreen("/sdcard/screencapture" + i + ".png");
-    sleep(1000);
-}
-
-```
-
-该函数也可以作为全局函数使用。
-
-## images.captureScreen()
-
-截取当前屏幕并返回一个Image对象。
-
-没有截图权限时执行该函数会抛出SecurityException。
-
-该函数不会返回null，两次调用可能返回相同的Image对象。这是因为设备截图的更新需要一定的时间，短时间内（一般来说是16ms）连续调用则会返回同一张截图。
-
-截图需要转换为Bitmap格式，从而该函数执行需要一定的时间(0~20ms)。
-
-另外在requestScreenCapture()执行成功后需要一定时间后才有截图可用，因此如果立即调用captureScreen()，会等待一定时间后(一般为几百ms)才返回截图。
-
-例子:
-
-```
-//请求横屏截图
-requestScreenCapture(true);
-//截图
-var img = captureScreen();
-//获取在点(100, 100)的颜色值
-var color = images.pixel(img, 100, 100);
-//显示该颜色值
-toast(colors.toString(color));
-```
-
-该函数也可以作为全局函数使用。
-
-## images.captureScreen(path)
-
-* `path` {string} 截图保存路径
-
-截取当前屏幕并以PNG格式保存到path中。如果文件不存在会被创建；文件存在会被覆盖。
-
-该函数不会返回任何值。该函数也可以作为全局函数使用。
-
-## images.pixel(image, x, y)
-
-* `image` {Image} 图片
-* `x` {number} 要获取的像素的横坐标。
-* `y` {number} 要获取的像素的纵坐标。
-
-返回图片image在点(x, y)处的像素的ARGB值。
-
-该值的格式为0xAARRGGBB，是一个"32位整数"(虽然JavaScript中并不区分整数类型和其他数值类型)。
-
-坐标系以图片左上角为原点。以图片左侧边为y轴，上侧边为x轴。
-
-## images.findColor(image, color, options)
-
-* `image` {Image} 图片
-* `color` {number} | {string} 要寻找的颜色的RGB值。如果是一个整数，则以0xRRGGBB的形式代表RGB值（A通道会被忽略）；如果是字符串，则以"#RRGGBB"代表其RGB值。
-* `options` {Object} 选项
-
-在图片中寻找颜色color。找到时返回找到的点Point，找不到时返回null。
-
-选项包括：
-
-* `region` {Array} 找色区域。是一个两个或四个元素的数组。(region[0], region[1])表示找色区域的左上角；region[2]*region[3]表示找色区域的宽高。如果只有region只有两个元素，则找色区域为(region[0], region[1])到屏幕右下角。如果不指定region选项，则找色区域为整张图片。
-* `threshold` {number} 找色时颜色相似度的临界值，范围为0~255（越小越相似，0为颜色相等，255为任何颜色都能匹配）。默认为4。threshold和浮点数相似度(0.0~1.0)的换算为 similarity = (255 - threshold) / 255.
-
-该函数也可以作为全局函数使用。
-
-一个循环找色的例子如下：
-
-```
-requestScreenCapture();
-
-//循环找色，找到红色(#ff0000)时停止并报告坐标
-while(true){
-    var img = captureScreen();
-    var point = findColor(img, "#ff0000");
-    if(point){
-        toast("找到红色，坐标为(" + point.x + ", " + point.y + ")");
-    }
-}
-
-```
-
-一个区域找色的例子如下：
-
-```
-//读取本地图片/sdcard/1.png
-var img = images.read("/sdcard/1.png");
-//判断图片是否加载成功
-if(!img){
-    toast("没有该图片");
-    exit();
-}
-//在该图片中找色，指定找色区域为在位置(400, 500)的宽为300长为200的区域，指定找色临界值为4
-var point = findColor(img, "#00ff00", {
-     region: [400, 500, 300, 200],
-     threshold: 4
- });
-if(point){
-    toast("找到啦:" + point);
-}else{
-    toast("没找到");
-}
-```
-
-## images.findColorInRegion(img, color, x, y[, width, height, threshold])
-
-区域找色的简便方法。
-
-相当于
-
-```
-images.findColor(img, color, {
-     region: [x, y, width, height],
-     threshold: threshold
-});
-```
-
-该函数也可以作为全局函数使用。
-
-## images.findColorEquals(img, color[, x, y, width, height])
-
-* `img` {Image} 图片
-* `color` {number} | {string} 要寻找的颜色
-* `x` {number} 找色区域的左上角横坐标
-* `y` {number} 找色区域的左上角纵坐标
-* `width` {number} 找色区域的宽度
-* `height` {number} 找色区域的高度
-* 返回 {Point}
-
-在图片img指定区域中找到颜色和color完全相等的某个点，并返回该点的左边；如果没有找到，则返回`null`。
-
-找色区域通过`x`, `y`, `width`, `height`指定，如果不指定找色区域，则在整张图片中寻找。
-
-该函数也可以作为全局函数使用。
-
-示例：
-(通过找QQ红点的颜色来判断是否有未读消息)
-
-```
-requestScreenCapture();
-launchApp("QQ");
-sleep(1200);
-var p = findColorEquals(captureScreen(), "#f64d30");
-if(p){
-    toast("有未读消息");
-}else{
-    toast("没有未读消息");
-}
-```
-
-## images.findMultiColors(img, firstColor, colors[, options])
-
-* `img` {Image} 要找色的图片
-* `firstColor` {number} | {string} 第一个点的颜色
-* `colors` {Array} 表示剩下的点相对于第一个点的位置和颜色的数组，数组的每个元素为[x, y, color]
-* `options` {Object} 选项，包括：
-    * `region` {Array} 找色区域。是一个两个或四个元素的数组。(region[0], region[1])表示找色区域的左上角；region[2]*region[3]表示找色区域的宽高。如果只有region只有两个元素，则找色区域为(region[0], region[1])到屏幕右下角。如果不指定region选项，则找色区域为整张图片。
-    * `threshold` {number} 找色时颜色相似度的临界值，范围为0~255（越小越相似，0为颜色相等，255为任何颜色都能匹配）。默认为4。threshold和浮点数相似度(0.0~1.0)的换算为 similarity = (255 - threshold) / 255.
-
-多点找色，类似于按键精灵的多点找色，其过程如下：
-
-1. 在图片img中找到颜色firstColor的位置(x0, y0)
-2. 对于数组colors的每个元素[x, y, color]，检查图片img在位置(x + x0, y + y0)上的像素是否是颜色color，是的话返回(x0, y0)，否则继续寻找firstColor的位置，重新执行第1步
-3. 整张图片都找不到时返回`null`
-
-例如，对于代码`images.findMultiColors(img, "#123456", [[10, 20, "#ffffff"], [30, 40, "#000000"]])`，假设图片在(100, 200)的位置的颜色为#123456, 这时如果(110, 220)的位置的颜色为#fffff且(130, 240)的位置的颜色为#000000，则函数返回点(100, 200)。
-
-如果要指定找色区域，则在options中指定，例如:
-
-```
-var p = images.findMultiColors(img, "#123456", [[10, 20, "#ffffff"], [30, 40, "#000000"]], {
-    region: [0, 960, 1080, 960]
-});
-```
-
-## images.detectsColor(image, color, x, y[, threshold = 16, algorithm = "diff"])
-
-* `image` {Image} 图片
-* `color` {number} | {string} 要检测的颜色
-* `x` {number} 要检测的位置横坐标
-* `y` {number} 要检测的位置纵坐标
-* `threshold` {number} 颜色相似度临界值，默认为16。取值范围为0~255。
-* `algorithm` {string} 颜色匹配算法，包括:
-    * "equal": 相等匹配，只有与给定颜色color完全相等时才匹配。
-    * "diff": 差值匹配。与给定颜色的R、G、B差的绝对值之和小于threshold时匹配。
-    * "rgb": rgb欧拉距离相似度。与给定颜色color的rgb欧拉距离小于等于threshold时匹配。
-
-    * "rgb+": 加权rgb欧拉距离匹配([LAB Delta E](https://en.wikipedia.org/wiki/Color_difference))。
-    * "hs": hs欧拉距离匹配。hs为HSV空间的色调值。
-
-返回图片image在位置(x, y)处是否匹配到颜色color。用于检测图片中某个位置是否是特定颜色。
-
-一个判断微博客户端的某个微博是否被点赞过的例子：
-
-```
-requestScreenCapture();
-//找到点赞控件
-var like = id("ly_feed_like_icon").findOne();
-//获取该控件中点坐标
-var x = like.bounds().centerX();
-var y = like.bounds().centerY();
-//截图
-var img = captureScreen();
-//判断在该坐标的颜色是否为橙红色
-if(images.detectsColor(img, "#fed9a8", x, y)){
-    //是的话则已经是点赞过的了，不做任何动作
-}else{
-    //否则点击点赞按钮
-    like.click();
-}
-```
-
-## images.findImage(img, template[, options])
-
-* `img` {Image} 大图片
-* `template` {Image} 小图片（模板）
-* `options` {Object} 找图选项
-
-找图。在大图片img中查找小图片template的位置（模块匹配），找到时返回位置坐标(Point)，找不到时返回null。
-
-选项包括：
-
-* `threshold` {number} 图片相似度。取值范围为0~1的浮点数。默认值为0.9。
-* `region` {Array} 找图区域。参见findColor函数关于region的说明。
-* `level` {number} **一般而言不必修改此参数**。不加此参数时该参数会根据图片大小自动调整。找图算法是采用图像金字塔进行的, level参数表示金字塔的层次, level越大可能带来越高的找图效率，但也可能造成找图失败（图片因过度缩小而无法分辨）或返回错误位置。因此，除非您清楚该参数的意义并需要进行性能调优，否则不需要用到该参数。
-
-该函数也可以作为全局函数使用。
-
-一个最简单的找图例子如下：
-
-```
-var img = images.read("/sdcard/大图.png");
-var templ = images.read("/sdcard/小图.png");
-var p = findImage(img, templ);
-if(p){
-    toast("找到啦:" + p);
-}else{
-    toast("没找到");
-}
-```
-
-稍微复杂点的区域找图例子如下：
-
-```
-auto();
-requestScreenCapture();
-var wx = images.read("/sdcard/微信图标.png");
-//返回桌面
-home();
-//截图并找图
-var p = findImage(captureScreen(), wx, {
-    region: [0, 50],
-    threshold: 0.8
-});
-if(p){
-    toast("在桌面找到了微信图标啦: " + p);
-}else{
-    toast("在桌面没有找到微信图标");
-}
-```
-
-## images.findImageInRegion(img, template, x, y[, width, height, threshold])
-
-区域找图的简便方法。相当于：
-
-```
-images.findImage(img, template, {
-    region: [x, y, width, height],
-    threshold: threshold
-})
-```
-
-该函数也可以作为全局函数使用。
-
-## images.matchTemplate(img, template, options)
-
-**[v4.1.0新增]**
-
-* `img` {Image} 大图片
-* `template` {Image} 小图片（模板）
-* `options` {Object} 找图选项：
-    * `threshold` {number} 图片相似度。取值范围为0~1的浮点数。默认值为0.9。
-    * `region` {Array} 找图区域。参见findColor函数关于region的说明。
-    * `max` {number} 找图结果最大数量，默认为5
-    * `level` {number} **一般而言不必修改此参数**。不加此参数时该参数会根据图片大小自动调整。找图算法是采用图像金字塔进行的, level参数表示金字塔的层次, level越大可能带来越高的找图效率，但也可能造成找图失败（图片因过度缩小而无法分辨）或返回错误位置。因此，除非您清楚该参数的意义并需要进行性能调优，否则不需要用到该参数。
-* 返回 {MatchingResult}
-
-在大图片中搜索小图片，并返回搜索结果MatchingResult。该函数可以用于找图时找出多个位置，可以通过max参数控制最大的结果数量。也可以对匹配结果进行排序、求最值等操作。
-
-# MatchingResult
-
-**[v4.1.0新增]**
-
-## matches
-
-* {Array} 匹配结果的数组。
-
-数组的元素是一个Match对象：
-
-* `point` {Point} 匹配位置
-* `similarity` {number} 相似度
-
-例如:
-
-```
-var result = images.matchTemplate(img, template, {
-    max: 100
-});
-result.matches.forEach(match => {
-    log("point = " + match.point + ", similarity = " + match.similarity);
-});
-```
-
-## points
-
-* {Array} 匹配位置的数组。
-
-## first()
-
-* 返回 {Match}
-
-第一个匹配结果。如果没有任何匹配，则返回`null`。
-
-## last()
-
-* 返回 {Match}
-
-最后一个匹配结果。如果没有任何匹配，则返回`null`。
-
-## leftmost()
-
-* 返回 {Match}
-
-位于大图片最左边的匹配结果。如果没有任何匹配，则返回`null`。
-
-## topmost()
-
-* 返回 {Match}
-
-位于大图片最上边的匹配结果。如果没有任何匹配，则返回`null`。
-
-## rightmost()
-
-* 返回 {Match}
-
-位于大图片最右边的匹配结果。如果没有任何匹配，则返回`null`。
-
-## bottommost()
-
-* 返回 {Match}
-
-位于大图片最下边的匹配结果。如果没有任何匹配，则返回`null`。
-
-## best()
-
-* 返回 {Match}
-
-相似度最高的匹配结果。如果没有任何匹配，则返回`null`。
-
-## worst()
-
-* 返回 {Match}
-
-相似度最低的匹配结果。如果没有任何匹配，则返回`null`。
-
-## sortBy(cmp)
-
-* cmp {Function}|{string} 比较函数，或者是一个字符串表示排序方向。例如"left"表示将匹配结果按匹配位置从左往右排序、"top"表示将匹配结果按匹配位置从上往下排序，"left-top"表示将匹配结果按匹配位置从左往右、从上往下排序。方向包括`left`（左）, `top` （上）, `right` （右）, `bottom`（下）。
-* {MatchingResult}
-
-对匹配结果进行排序，并返回排序后的结果。
-
-```
-var result = images.matchTemplate(img, template, {
-    max: 100
-});
-log(result.sortBy("top-right"));
-```
-
-# Image
-
-表示一张图片，可以是截图的图片，或者本地读取的图片，或者从网络获取的图片。
-
-## Image.getWidth()
-
-返回以像素为单位图片宽度。
-
-## Image.getHeight()
-
-返回以像素为单位的图片高度。
-
-## Image.saveTo(path)
-
-* `path` {string} 路径
-
-把图片保存到路径path。（如果文件存在则覆盖）
-
-## Image.pixel(x, y)
-
-* `x` {number} 横坐标
-* `y` {number} 纵坐标
-
-返回图片image在点(x, y)处的像素的ARGB值。
-
-该值的格式为0xAARRGGBB，是一个"32位整数"(虽然JavaScript中并不区分整数类型和其他数值类型)。
-
-坐标系以图片左上角为原点。以图片左侧边为y轴，上侧边为x轴。
-
-##
-
-# Point
-
-findColor, findImage返回的对象。表示一个点（坐标）。
-
-## Point.x
-
-横坐标。
-
-## Point.y
-
-纵坐标。
diff --git a/api/index.html b/api/index.html
index 9c98749..ddb13b9 100644
--- a/api/index.html
+++ b/api/index.html
@@ -8,28 +8,15 @@
     <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1"/>
     <meta name="description" content="Description">
     <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
-    <link href="static/vue.css" rel="stylesheet">
+    <link rel="stylesheet" href="static/vue.css">
     <!-- <link rel="stylesheet" href="//unpkg.com/docsify/lib/themes/vue.css"> -->
         <style>
          .commit-tease,
          .user-profile-mini-avatar,
          .avatar,
          .vcard-details,
          .signup-prompt-bg {
            display: none !IMPORTANT;
          }
        </style>
         <script>
          document.addEventListener('DOMContentLoaded', function() {
            this.querySelectorAll('a').forEach(anchor => {
              anchor.addEventListener('click', e => {
                e.preventDefault();

                const redact = new URLSearchParams(window.location.search).get('redact');
                const hasExistingParams = anchor.href.includes('?');
                window.location.href = anchor.href + (hasExistingParams ? `&redact=${redact}` : `?redact=${redact}`);
              });
            });
          });
        </script>
 </head>
 
 <body>
 <div id="app"></div>
-<script>
-    window.$docsify = {
-        name: 'AutoJs6',
-        repo: 'SuperMonster003/AutoJs6-Documentation',
-        notFoundPage: true,
-        loadSidebar: true,
-        subMaxLevel: 2,
-        coverpage: true,
-        loadNavbar: true,
-        auto2top: true,
-        homepage: 'overview.md',
-        maxAge: 0,
-    };
-</script>
-<script src="static/docsify.min.js"></script>
-<script src="static/search.min.js"></script>
+<script src="static/docsify-config.js"></script>
+<script src="static/docsify.js"></script>
+<script src="static/search.js"></script>
 <!-- <script src="//unpkg.com/docsify"></script> -->
 <!-- <script src="//unpkg.com/docsify/lib/docsify.js"></script> -->
 <!-- <script src="//unpkg.com/docsify/lib/plugins/search.js"></script> -->
diff --git a/api/intentType.md b/api/intentType.md
new file mode 100644
index 0000000..39d2050
--- /dev/null
+++ b/api/intentType.md
@@ -0,0 +1,52 @@
+# 意图 (Intent)
+
+---
+
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Nov 18, 2022.</p>
+
+---
+
+作为概念, Intent (意图) 是一个消息传递对象.
+
+在 AutoJs6 中, Intent 作为全局对象, 支持全局调用:
+
+```js
+/* 仅用作示例展示. */
+app.startActivity(new Intent()
+    .setAction("x")
+    .setData('x')
+    .setClass('x')
+    .setFlags(0));
+
+/* app.intent 方法返回 Intent 类型数据. */
+console.log(app.intent({ data: 'protocol://data' }) instanceof Intent); // true
+
+/* Intent 是 android.conent.Intent 的别名. */
+console.log(Intent === android.content.Intent); // true
+```
+
+您可以使用它从其他应用组件请求操作. 尽管 Intent 可以通过多种方式促进组件之间的通信, 但其基本用例主要包括以下三个：
+
+* 启动活动(Activity)：
+  Activity 表示应用中的一个"屏幕". 例如应用主入口都是一个Activity, 应用的功能通常也以Activity的形式独立, 例如微信的主界面、朋友圈、聊天窗口都是不同的Activity. 通过将 Intent 传递给 startActivity(), 您可以启动新的 Activity 实例. Intent 描述了要启动的 Activity, 并携带了任何必要的数据.
+
+* 启动服务(Service)：
+  Service 是一个不使用用户界面而在后台执行操作的组件. 通过将 Intent 传递给 startService(), 您可以启动服务执行一次性操作（例如, 下载文件）. Intent 描述了要启动的服务, 并携带了任何必要的数据.
+
+* 传递广播：
+  广播是任何应用均可接收的消息. 系统将针对系统事件（例如：系统启动或设备开始充电时）传递各种广播. 通过将 Intent 传递给 sendBroadcast()、sendOrderedBroadcast() 或 sendStickyBroadcast(), 您可以将广播传递给其他应用.
+
+本模块提供了构建Intent的函数(`app.intent()`), 启动Activity的函数`app.startActivity()`, 发送广播的函数`app.sendBroadcast()`.
+
+使用这些方法可以用来方便的调用其他应用. 例如直接打开某个QQ号的个人卡片页, 打开某个QQ号的聊天窗口等.
+
+```js
+let qq = "2732014414";
+app.startActivity({
+    action: "android.intent.action.VIEW",
+    data: "mqq://im/chat?chat_type=wpa&version=1&src_type=web&uin=" + qq,
+    packageName: "com.tencent.mobileqq",
+});
+
+```
\ No newline at end of file
diff --git a/api/keys.md b/api/keys.md
index 7bc8d93..1300b34 100644
--- a/api/keys.md
+++ b/api/keys.md
@@ -1,126 +1,133 @@
-# Keys
+# 按键 (Keys)
 
-按键模拟部分提供了一些模拟物理按键的全局函数，包括Home、音量键、照相键等，有的函数依赖于无障碍服务，有的函数依赖于root权限。
+---
 
-一般来说，以大写字母开头的函数都依赖于root权限。执行此类函数时，如果没有root权限，则函数执行后没有效果，并会在控制台输出一个警告。
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
+
+---
+
+按键模拟部分提供了一些模拟物理按键的全局函数, 包括Home、音量键、照相键等, 有的函数依赖于无障碍服务, 有的函数依赖于root权限.
+
+一般来说, 以大写字母开头的函数都依赖于root权限. 执行此类函数时, 如果没有root权限, 则函数执行后没有效果, 并会在控制台输出一个警告.
 
 ## back()
 
 * 返回 {boolean}
 
-模拟按下返回键。返回是否执行成功。
-此函数依赖于无障碍服务。
+模拟按下返回键. 返回是否执行成功.
+此函数依赖于无障碍服务.
 
 ## home()
 
 * 返回 {boolean}
 
-模拟按下Home键。返回是否执行成功。
-此函数依赖于无障碍服务。
+模拟按下Home键. 返回是否执行成功.
+此函数依赖于无障碍服务.
 
 ## powerDialog()
 
 * 返回 {boolean}
 
-弹出电源键菜单。返回是否执行成功。
-此函数依赖于无障碍服务。
+弹出电源键菜单. 返回是否执行成功.
+此函数依赖于无障碍服务.
 
 ## notifications()
 
 * 返回 {boolean}
 
-拉出通知栏。返回是否执行成功。
-此函数依赖于无障碍服务。
+拉出通知栏. 返回是否执行成功.
+此函数依赖于无障碍服务.
 
 ## quickSettings()
 
 * 返回 {boolean}
 
-显示快速设置(下拉通知栏到底)。返回是否执行成功。
-此函数依赖于无障碍服务。
+显示快速设置(下拉通知栏到底). 返回是否执行成功.
+此函数依赖于无障碍服务.
 
 ## recents()
 
 * 返回 {boolean}
 
-显示最近任务。返回是否执行成功。
-此函数依赖于无障碍服务。
+显示最近任务. 返回是否执行成功.
+此函数依赖于无障碍服务.
 
 ## splitScreen()
 
 * 返回 {boolean}
 
-分屏。返回是否执行成功。
-此函数依赖于无障碍服务, 并且需要系统自身功能的支持。
+分屏. 返回是否执行成功.
+此函数依赖于无障碍服务, 并且需要系统自身功能的支持.
 
 ## Home()
 
-模拟按下Home键。
-此函数依赖于root权限。
+模拟按下Home键.
+此函数依赖于root权限.
 
 ## Back()
 
-模拟按下返回键。
-此函数依赖于root权限。
+模拟按下返回键.
+此函数依赖于root权限.
 
 ## Power()
 
-模拟按下电源键。
-此函数依赖于root权限。
+模拟按下电源键.
+此函数依赖于root权限.
 
 ## Menu()
 
-模拟按下菜单键。
-此函数依赖于root权限。
+模拟按下菜单键.
+此函数依赖于root权限.
 
 ## VolumeUp()
 
-按下音量上键。
-此函数依赖于root权限。
+按下音量上键.
+此函数依赖于root权限.
 
 ## VolumeDown()
 
-按键音量上键。
-此函数依赖于root权限。
+按键音量上键.
+此函数依赖于root权限.
 
 ## Camera()
 
-模拟按下照相键。
+模拟按下照相键.
 
 ## Up()
 
-模拟按下物理按键上。
-此函数依赖于root权限。
+模拟按下物理按键上.
+此函数依赖于root权限.
 
 ## Down()
 
-模拟按下物理按键下。
-此函数依赖于root权限。
+模拟按下物理按键下.
+此函数依赖于root权限.
 
 ## Left()
 
-模拟按下物理按键左。
-此函数依赖于root权限。
+模拟按下物理按键左.
+此函数依赖于root权限.
 
 ## Right()
 
-模拟按下物理按键右。
-此函数依赖于root权限。
+模拟按下物理按键右.
+此函数依赖于root权限.
 
 ## OK()
 
-模拟按下物理按键确定。
-此函数依赖于root权限。
+模拟按下物理按键确定.
+此函数依赖于root权限.
 
 ## Text(text)
 
-* text {string} 要输入的文字，只能为英文或英文符号
-  输入文字text。例如`Text("aaa");`
+* text {string} 要输入的文字, 只能为英文或英文符号
+  输入文字text. 例如`Text("aaa");`
 
 ## KeyCode(code)
 
-* code {number} | <String> 要按下的按键的数字代码或名称。参见下表。
-  模拟物理按键。例如`KeyCode(29)`和`KeyCode("KEYCODE_A")`是按下A键。
+* code {number} | <String> 要按下的按键的数字代码或名称. 参见下表.
+  模拟物理按键. 例如`KeyCode(29)`和`KeyCode("KEYCODE_A")`是按下A键.
 
 # 附录: KeyCode对照表
 
diff --git a/api/mathx.md b/api/mathx.md
new file mode 100644
index 0000000..b4e82a3
--- /dev/null
+++ b/api/mathx.md
@@ -0,0 +1,673 @@
+# Mathx (Math 扩展)
+
+Mathx 用于扩展 JavaScript 标准内置对象 Math 的功能 (参阅 [内置对象扩展](glossaries#内置对象扩展)).
+
+Mathx 全局可用:
+
+```js
+console.log(typeof Mathx); // "object"
+console.log(typeof Mathx.sum); // "function"
+```
+
+当启用内置扩展后, Mathx 将被应用在 Math 上:
+
+```js
+console.log(typeof Math.sum); // "function"
+```
+
+## 启用内置扩展
+
+内置扩展默认被禁用, 以下任一方式可启用内置扩展:
+
+- 在脚本中加入代码片段: `plugins.extendAll();` 或 `plugins.extend('Math');`
+- AutoJs6 应用设置 - 扩展性 - JavaScript 内置对象扩展 - [ 启用 ]
+
+当上述应用设置启用时, 所有脚本均默认启用内置扩展.  
+当上述应用设置禁用时, 只有加入上述代码片段的脚本才会启用内置扩展.  
+内置扩展往往是不安全的, 除非明确了解内置扩展的原理及风险, 否则不建议启用.
+
+> 注: 因 Mathx 所有属性及方法均为 "针对对象的内置对象扩展", 在启用内置对象扩展时, 使用方法仅仅是 Mathx 与 Math 的差别, 故示例代码中将不再赘述相关示例, 但别名方法例外 (如 min 的别名 mini, max 的别名 maxi 等).
+
+---
+
+<p style="font: bold 2em sans-serif; color: #FF7043">Mathx</p>
+
+---
+
+## [m] randInt
+
+randInt 用于返回一个指定范围内的随机整数.
+
+因 NaN 不属于整数范畴, 故 randInt 内部实现对范围数值中出现的 NaN 做了过滤处理, 进而使 NaN 失去了常见的传染性.
+
+```js
+/* NaN 不属于整数范畴. */
+console.log(Number.isInteger(NaN)); // false
+
+/* NaN 出现在范围数值中时将失去其传染性. */
+console.log(Number.isNaN(Mathx.randInt(1, NaN))); // false
+```
+
+若范围数值中出现非整数数值, 将范围中极小值作 `Math.ceil()` 处理, 极大值作 `Math.floor()` 处理.
+
+```js
+console.log(Mathx.randInt(1.8, 3.3)); /* 视为 randInt(2, 3). */
+console.log(Mathx.randInt(-9.7, -2.4)); /* 视为 randInt(-9, -3). */
+```
+
+### randInt(start, stop)
+
+**`6.2.0`** **`xObject`** **`Overload 1/5`**
+
+- **start** { [number](dataTypes#number) } - 范围起点 (含)
+- **stop** { [number](dataTypes#number) } - 范围止点 (含)
+- <ins>**returns**</ins> { [number](dataTypes#number) } - 范围内随机整数
+
+返回一个指定范围内的随机整数.
+
+```js
+/* 10 - 20 的随机整数. */
+console.log(Mathx.randInt(10, 20)); // e.g. 13
+
+/* start 和 stop 可自动交换. */
+console.log(Mathx.randInt(20, 10)); /* 与 randInt(10, 20) 效果相同. */
+
+/* start 与 stop 相等时返回唯一值. */
+console.log(Mathx.randInt(15, 15)); // 15
+```
+
+### randInt(stop)
+
+**`6.2.0`** **`xObject`** **`Overload 2/5`**
+
+- **stop** { [number](dataTypes#number) } - 范围止点 (含)
+- <ins>**returns**</ins> { [number](dataTypes#number) } - 范围内随机整数
+
+返回一个指定范围内的随机整数, stop 参数作为止点, 0 作为起点.  
+相当于 `randInt(0, stop)`.  
+当 stop 为负数时, 起止点将自动交换.
+
+```js
+/* 10 - 20 的随机整数. */
+console.log(Mathx.randInt(10, 20)); // e.g. 13
+
+/* start 和 stop 可自动交换. */
+console.log(Mathx.randInt(20, 10)); /* 与 randInt(10, 20) 效果相同. */
+
+/* start 与 stop 相等时返回唯一值. */
+console.log(Mathx.randInt(15, 15)); // 15
+```
+
+### randInt(range?)
+
+**`6.2.0`** **`xObject`** **`Overload [3-4]/5`**
+
+- **[ range = [ [MIN_SAFE_INTEGER](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Number/MIN_SAFE_INTEGER), [MAX_SAFE_INTEGER](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER) ] ]** { [number](dataTypes#number)[[]](dataTypes#array) } - 范围数组 (含两边界)
+- <ins>**returns**</ins> { [number](dataTypes#number) } - 范围内随机整数
+
+返回一个指定范围内的随机整数.
+
+```js
+/* 10 - 20 的随机整数. */
+console.log(Mathx.randInt([ 10, 20 ])); // e.g. 13
+
+/* 范围数组中的数字没有数量限制, 排序后将两个极值作为边界. */
+console.log(Mathx.randInt([ 20, 10, 13, 11, 15 ])); /* 与 randInt([ 10, 20 ]) 效果相同. */
+
+/* 范围数组中排序后极值相同时将直接返回此极值. */
+console.log(Mathx.randInt([ 15, 15, 15 ])); // 15
+
+/* 范围数组为空数组或省略参数时将返回任意 "安全" 整数. */
+console.log(Mathx.randInt([])); // e.g. -7217922776918875
+console.log(Mathx.randInt([ Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER ])); /* 效果同上. */
+console.log(Mathx.randInt()); /* 效果同上. */
+```
+
+### randInt(...numbers)
+
+**`6.2.0`** **`xObject`** **`Overload 5/5`**
+
+- **numbers** { [...](documentation#可变参数)[number](dataTypes#number)[[]](documentation#可变参数) } - 范围数组 (含两边界)
+- <ins>**returns**</ins> { [number](dataTypes#number) } - 范围内随机整数
+
+返回一个指定范围内的随机整数.
+
+```js
+/* 10 - 20 的随机整数. */
+console.log(Mathx.randInt(10, 20)); // e.g. 13
+
+/* 可变参数没有数量限制, 排序后将两个极值作为边界. */
+console.log(Mathx.randInt(20, 10, 13, 11, 15)); /* 与 randInt(10, 20) 效果相同. */
+
+/* 可变参数排序后极值相同时将直接返回此极值. */
+console.log(Mathx.randInt(15, 15, 15)); // 15
+```
+
+## [m] sum
+
+求和.
+
+### sum(...numbers)
+
+**`6.2.0`** **`xObject`** **`Overload 1/3`**
+
+- **numbers** { [...](documentation#可变参数)[number](dataTypes#number)[[]](documentation#可变参数) } - 待求和数字
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回所有数字的加和结果.
+
+```js
+/* 整数求和. */
+console.log(Mathx.sum(1, 2, 3)); // 6
+console.log(Mathx.sum(9)); // 9
+
+/* 浮点数求和. */
+console.log(Mathx.sum(0.1, 0.1)); // 0.2
+console.log(Mathx.sum(0.1, 0.2, 0.3)); // 0.6000000000000001
+
+/* NaN 保持其传染性. */
+console.log(Mathx.sum(7, 8, 9, NaN)); // NaN
+
+/* 无参将返回 NaN. */
+console.log(Mathx.sum()); // NaN
+
+/* 元素将被 Number 化. */
+console.log(Mathx.sum('1', '2', '3')); // 6
+console.log(Mathx.sum({ valueOf: () => 11 }, { valueOf: () => 12 })); // 23
+
+/* 嵌套将被展平. */
+console.log(Mathx.sum(1, [ 2, [ 3, [ 4 ] ], 5 ])); // 15
+```
+
+### sum(numbers, fraction?)
+
+**`6.2.0`** **`xObject`** **`Overload [2-3]/3`**
+
+- **numbers** { [number](dataTypes#number)[[]](dataTypes#array) } - 待求和数字数组
+- **[ fraction = undefined ]** { [number](dataTypes#number) } - 小数点后的数字个数
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回数组内数字的加和结果, 并根据 fraction 参数进行可能的四舍五入.
+
+```js
+console.log(Mathx.sum([ 1, 2, 3 ])); // 6
+console.log(Mathx.sum([ 1, 2, [ 3 ] ])); // 6
+console.log(Mathx.sum([ 0.1, 0.2, 0.309 ], 2)); // 0.61
+console.log(Mathx.sum([ 0.1, 0.2, 0.309 ], 10)); // 0.609
+console.log(Mathx.sum([ 0.1, 0.2, 0.309 ], 0)); // 1
+```
+
+## [m] avg
+
+算术平均数.
+
+### avg(...numbers)
+
+**`6.2.0`** **`xObject`** **`Overload 1/3`**
+
+- **numbers** { [...](documentation#可变参数)[number](dataTypes#number)[[]](documentation#可变参数) } - 待求算术平均值的数字
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回所有数字的算术平均值.
+
+```js
+/* 常规运算. */
+console.log(Mathx.avg(1, 2, 3)); // 2
+console.log(Mathx.avg(9)); // 9
+console.log(Mathx.avg(0.1, 0.1)); // 0.1
+console.log(Mathx.avg(0.1, 0.2, 0.3)); // 0.20000000000000004
+
+/* NaN 保持其传染性. */
+console.log(Mathx.avg(7, 8, 9, NaN)); // NaN
+
+/* 无参将返回 NaN. */
+console.log(Mathx.avg()); // NaN
+
+/* 元素将被 Number 化. */
+console.log(Mathx.avg('1', '2', '3')); // 2
+console.log(Mathx.avg({ valueOf: () => 11 }, { valueOf: () => 12 })); // 11.5
+
+/* 嵌套将被展平. */
+console.log(Mathx.avg(1, [ 2, [ 3, [ 4 ] ], 5 ])); // 3
+```
+
+### avg(numbers, fraction?)
+
+**`6.2.0`** **`xObject`** **`Overload [2-3]/3`**
+
+- **numbers** { [number](dataTypes#number)[[]](dataTypes#array) } - 待求算术平均值数字数组
+- **[ fraction = undefined ]** { [number](dataTypes#number) } - 小数点后的数字个数
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回数组内数字的算术平均值, 并根据 fraction 参数进行可能的四舍五入.
+
+```js
+console.log(Mathx.avg([ 1, 2, 3 ])); // 2
+console.log(Mathx.avg([ 1, 2, [ 3 ] ])); // 2
+console.log(Mathx.avg([ 0.1, 0.2, 0.309 ], 2)); // 0.2
+console.log(Mathx.avg([ 0.1, 0.2, 0.309 ], 10)); // 0.203
+console.log(Mathx.avg([ 0.1, 0.2, 0.309 ], 0)); // 0
+```
+
+## [m] median
+
+中位数.
+
+### median(...numbers)
+
+**`6.2.0`** **`xObject`** **`Overload 1/3`**
+
+- **numbers** { [...](documentation#可变参数)[number](dataTypes#number)[[]](documentation#可变参数) } - 待求中位数的数字
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回所有数字的中位数.
+
+```js
+/* 常规运算. */
+console.log(Mathx.median(1, 2, 3)); // 2
+console.log(Mathx.median(9)); // 9
+console.log(Mathx.median(0.1, 0.1)); // 0.1
+console.log(Mathx.median(0.1, 0.2, 0.3)); // 0.2
+
+/* NaN 保持其传染性. */
+console.log(Mathx.median(7, 8, 9, NaN)); // NaN
+
+/* 无参将返回 NaN. */
+console.log(Mathx.median()); // NaN
+
+/* 元素将被 Number 化. */
+console.log(Mathx.median('1', '2', '3')); // 2
+console.log(Mathx.median({ valueOf: () => 11 }, { valueOf: () => 12 })); // 11.5
+
+/* 嵌套将被展平. */
+console.log(Mathx.median(1, [ 2, [ 3, [ 4 ] ], 5 ])); // 3
+```
+
+### median(numbers, fraction?)
+
+**`6.2.0`** **`xObject`** **`Overload [2-3]/3`**
+
+- **numbers** { [number](dataTypes#number)[[]](dataTypes#array) } - 待求中位数数字数组
+- **[ fraction = undefined ]** { [number](dataTypes#number) } - 小数点后的数字个数
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回数组内数字的中位数, 并根据 fraction 参数进行可能的四舍五入.
+
+```js
+console.log(Mathx.median([ 1, 2, 3 ])); // 2
+console.log(Mathx.median([ 1, 2, [ 3 ] ])); // 2
+console.log(Mathx.median([ 0.1, 0.2, 0.309 ], 2)); // 0.2
+console.log(Mathx.median([ 0.1, 0.2, 0.309 ], 10)); // 0.203
+console.log(Mathx.median([ 0.1, 0.2, 0.309 ], 0)); // 0
+```
+
+## [m] var
+
+方差.
+
+### var(...numbers)
+
+**`6.2.0`** **`xObject`** **`Overload 1/3`**
+
+- **numbers** { [...](documentation#可变参数)[number](dataTypes#number)[[]](documentation#可变参数) } - 待求方差的数字
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回所有数字的方差.
+
+```js
+/* 常规运算. */
+console.log(Mathx.var(1, 2, 3)); // 0.6666666666666666
+console.log(Mathx.var(1, 2, 3, 4, 5)); // 2
+console.log(Mathx.var(9)); // 0
+console.log(Mathx.var(0.1, 0.1)); // 0
+console.log(Mathx.var(0.1, 0.2, 0.3)); // 0.006666666666666665
+
+/* NaN 保持其传染性. */
+console.log(Mathx.var(7, 8, 9, NaN)); // NaN
+
+/* 无参将返回 NaN. */
+console.log(Mathx.var()); // NaN
+
+/* 元素将被 Number 化. */
+console.log(Mathx.var('1', '2', '3')); // 0.6666666666666666
+console.log(Mathx.var({ valueOf: () => 11 }, { valueOf: () => 12 })); // 0.25
+
+/* 嵌套将被展平. */
+console.log(Mathx.var(1, [ 2, [ 3, [ 4 ] ], 5 ])); // 2
+```
+
+### var(numbers, fraction?)
+
+**`6.2.0`** **`xObject`** **`Overload [2-3]/3`**
+
+- **numbers** { [number](dataTypes#number)[[]](dataTypes#array) } - 待求方差数字数组
+- **[ fraction = undefined ]** { [number](dataTypes#number) } - 小数点后的数字个数
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回数组内数字的方差, 并根据 fraction 参数进行可能的四舍五入.
+
+```js
+console.log(Mathx.var([ 1, 2, 3 ])); // 0.6666666666666666
+console.log(Mathx.var([ 1, 2, [ 3 ] ])); // 0.6666666666666666
+console.log(Mathx.var([ 0.1, 0.2, 0.309 ], 2)); // 0.01
+console.log(Mathx.var([ 0.1, 0.2, 0.309 ], 10)); // 0.0072846667
+console.log(Mathx.var([ 0.1, 0.2, 0.309 ], 0)); // 0
+```
+
+## [m] std
+
+标准差 (均方差).
+
+### std(...numbers)
+
+**`6.2.0`** **`xObject`** **`Overload 1/3`**
+
+- **numbers** { [...](documentation#可变参数)[number](dataTypes#number)[[]](documentation#可变参数) } - 待求标准差的数字
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回所有数字的标准差.
+
+```js
+/* 常规运算. */
+console.log(Mathx.std(1, 2, 3)); // 0.816496580927726
+console.log(Mathx.std(1, 2, 3, 4, 5)); // 1.4142135623730951
+console.log(Mathx.std(9)); // 0
+console.log(Mathx.std(0.1, 0.1)); // 0
+console.log(Mathx.std(0.1, 0.2, 0.3)); // 0.0816496580927726
+
+/* NaN 保持其传染性. */
+console.log(Mathx.std(7, 8, 9, NaN)); // NaN
+
+/* 无参将返回 NaN. */
+console.log(Mathx.std()); // NaN
+
+/* 元素将被 Number 化. */
+console.log(Mathx.std('1', '2', '3')); // 0.0816496580927726
+console.log(Mathx.std({ valueOf: () => 11 }, { valueOf: () => 12 })); // 0.5
+
+/* 嵌套将被展平. */
+console.log(Mathx.std(1, [ 2, [ 3, [ 4 ] ], 5 ])); // 1.4142135623730951
+```
+
+### std(numbers, fraction?)
+
+**`6.2.0`** **`xObject`** **`Overload [2-3]/3`**
+
+- **numbers** { [number](dataTypes#number)[[]](dataTypes#array) } - 待求标准差数字数组
+- **[ fraction = undefined ]** { [number](dataTypes#number) } - 小数点后的数字个数
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回数组内数字的标准差, 并根据 fraction 参数进行可能的四舍五入.
+
+```js
+console.log(Mathx.std([ 1, 2, 3 ])); // 0.816496580927726
+console.log(Mathx.std([ 1, 2, [ 3 ] ])); // 0.816496580927726
+console.log(Mathx.std([ 0.1, 0.2, 0.309 ], 2)); // 0.09
+console.log(Mathx.std([ 0.1, 0.2, 0.309 ], 10)); // 0.0853502587
+console.log(Mathx.std([ 0.1, 0.2, 0.309 ], 0)); // 0
+```
+
+## [m] cv
+
+变异系数 (离散系数).
+
+### cv(...numbers)
+
+**`6.2.0`** **`xObject`** **`Overload 1/3`**
+
+- **numbers** { [...](documentation#可变参数)[number](dataTypes#number)[[]](documentation#可变参数) } - 待求变异系数的数字
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回所有数字的变异系数.
+
+```js
+/* 常规运算. */
+console.log(Mathx.cv(1, 2, 3)); // 0.5
+console.log(Mathx.cv(1, 2, 3, 4, 5)); // 0.5270462766947299
+console.log(Mathx.cv(9)); // NaN
+console.log(Mathx.cv(0.1, 0.1)); // 0
+console.log(Mathx.cv([ 0.1, 0.2, 0.3 ], 2)); // 0.5
+
+/* NaN 保持其传染性. */
+console.log(Mathx.cv(7, 8, 9, NaN)); // NaN
+
+/* 无参将返回 NaN. */
+console.log(Mathx.cv()); // NaN
+
+/* 元素将被 Number 化. */
+console.log(Mathx.cv('1', '2', '3')); // 0.5
+console.log(Mathx.cv({ valueOf: () => 11 }, { valueOf: () => 12 })); // 0.06148754619013457
+
+/* 嵌套将被展平. */
+console.log(Mathx.cv(1, [ 2, [ 3, [ 4 ] ], 5 ])); // 0.5270462766947299
+```
+
+### cv(numbers, fraction?)
+
+**`6.2.0`** **`xObject`** **`Overload [2-3]/3`**
+
+- **numbers** { [number](dataTypes#number)[[]](dataTypes#array) } - 待求变异系数数字数组
+- **[ fraction = undefined ]** { [number](dataTypes#number) } - 小数点后的数字个数
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回数组内数字的变异系数, 并根据 fraction 参数进行可能的四舍五入.
+
+```js
+console.log(Mathx.cv([ 1, 2, 3 ])); // 0.5
+console.log(Mathx.cv([ 1, 2, [ 3 ] ])); // 0.5
+console.log(Mathx.cv([ 0.1, 0.2, 0.309 ], 2)); // 0.51
+console.log(Mathx.cv([ 0.1, 0.2, 0.309 ], 10)); // 0.5149373973
+console.log(Mathx.cv([ 0.1, 0.2, 0.309 ], 0)); // 1
+```
+
+## [m] max
+
+最大值.
+
+内置扩展别名: maxi.
+
+```js
+console.log(Mathx.max([ 5, 23 ])); // 23
+
+/* 启用内置对象扩展后. */
+console.log(Math.maxi([ 5, 23 ])); // 23
+```
+
+需额外留意空数组作为参数及无参时的一些情况:
+
+```js
+console.log(Math.max()); // -Infinity
+console.log(Mathx.max()); // -Infinity
+
+console.log(Math.max([])); // 0
+console.log(Mathx.max([])); // -Infinity
+```
+
+### max(...numbers)
+
+**`6.2.0`** **`xObject`** **`xAlias`** **`Overload 1/3`**
+
+- **numbers** { [...](documentation#可变参数)[number](dataTypes#number)[[]](documentation#可变参数) } - 待求最大值的数字
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回所有参数中的最大数字.
+
+```js
+/* 常规运算. */
+console.log(Mathx.max(1, 2, 3)); // 3
+console.log(Mathx.max(9)); // 9
+console.log(Mathx.max(0.1, 0.1)); // 0.1
+
+/* NaN 保持其传染性. */
+console.log(Mathx.max(7, 8, 9, NaN)); // NaN
+
+/* 无参将返回与 Math.max() 相同的值. */
+console.log(Mathx.max()); // -Infinity
+
+/* 元素将被 Number 化. */
+console.log(Mathx.max('1', '2', '3')); // 3
+console.log(Mathx.max({ valueOf: () => 11 }, { valueOf: () => 12 })); // 12
+
+/* 嵌套将被展平. */
+console.log(Mathx.max(1, [ 2, [ 3, [ 4 ] ], 5 ])); // 5
+```
+
+### max(numbers, fraction?)
+
+**`6.2.0`** **`xObject`** **`xAlias`** **`Overload [2-3]/3`**
+
+- **numbers** { [number](dataTypes#number)[[]](dataTypes#array) } - 待求最大值的数字数组
+- **[ fraction = undefined ]** { [number](dataTypes#number) } - 小数点后的数字个数
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回数组内参数的最大数字, 并根据 fraction 参数进行可能的四舍五入.
+
+```js
+console.log(Mathx.max([ 1, 2, 3 ])); // 3
+console.log(Mathx.max([ 1, 2, [ 3 ] ])); // 3
+console.log(Mathx.max([ 0.1, 0.2, 0.309 ], 2)); // 0.31
+console.log(Mathx.max([ 0.1, 0.2, 0.309 ], 10)); // 0.309
+console.log(Mathx.max([ 0.1, 0.2, 0.309 ], 0)); // 0
+
+/* 相当于无参调用 Math.max(). */
+console.log(Mathx.max([])); // -Infinity
+```
+
+## [m] min
+
+最小值.
+
+内置扩展别名: mini.
+
+```js
+console.log(Mathx.min([ 5, 23 ])); // 5
+
+/* 启用内置对象扩展后. */
+console.log(Math.mini([ 5, 23 ])); // 5
+```
+
+需额外留意空数组作为参数及无参时的一些情况:
+
+```js
+console.log(Math.min()); // Infinity
+console.log(Mathx.min()); // Infinity
+
+console.log(Math.min([])); // 0
+console.log(Mathx.min([])); // Infinity
+```
+
+### min(...numbers)
+
+**`6.2.0`** **`xObject`** **`xAlias`** **`Overload 1/3`**
+
+- **numbers** { [...](documentation#可变参数)[number](dataTypes#number)[[]](documentation#可变参数) } - 待求最小值的数字
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回所有参数中的最小数字.
+
+```js
+/* 常规运算. */
+console.log(Mathx.min(1, 2, 3)); // 1
+console.log(Mathx.min(9)); // 9
+console.log(Mathx.min(0.1, 0.1)); // 0.1
+
+/* NaN 保持其传染性. */
+console.log(Mathx.min(7, 8, 9, NaN)); // NaN
+
+/* 无参将返回与 Math.min() 相同的值. */
+console.log(Mathx.min()); // Infinity
+
+/* 元素将被 Number 化. */
+console.log(Mathx.min('1', '2', '3')); // 1
+console.log(Mathx.min({ valueOf: () => 11 }, { valueOf: () => 12 })); // 11
+
+/* 嵌套将被展平. */
+console.log(Mathx.min(1, [ 2, [ 3, [ 4 ] ], 5 ])); // 1
+```
+
+### min(numbers, fraction?)
+
+**`6.2.0`** **`xObject`** **`xAlias`** **`Overload [2-3]/3`**
+
+- **numbers** { [number](dataTypes#number)[[]](dataTypes#array) } - 待求最小值的数字数组
+- **[ fraction = undefined ]** { [number](dataTypes#number) } - 小数点后的数字个数
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回数组内参数的最小数字, 并根据 fraction 参数进行可能的四舍五入.
+
+```js
+console.log(Mathx.min([ 1, 2, 3 ])); // 1
+console.log(Mathx.min([ 1, 2, [ 3 ] ])); // 1
+console.log(Mathx.min([ 0.1, 0.2, 0.309 ], 2)); // 0.1
+console.log(Mathx.min([ 0.1, 0.2, 0.309 ], 10)); // 0.1
+console.log(Mathx.min([ 0.1, 0.2, 0.309 ], 0)); // 0
+
+/* 相当于无参调用 Math.min(). */
+console.log(Mathx.min([])); // Infinity
+```
+
+## [m] dist
+
+两点间距离.
+
+上述 "距离" 指的是 [欧几里得距离 (Euclidean distance)](https://zh.wikipedia.org/wiki/%E6%AC%A7%E5%87%A0%E9%87%8C%E5%BE%97%E8%B7%9D%E7%A6%BB), 亦称作欧氏距离.
+
+### dist(pointA, pointB, fraction?)
+
+**`6.2.0`** **`xObject`** **`Overload [1-2]/4`**
+
+- **pointA** { [\[](dataTypes#tuple) [number](dataTypes#number), [number](dataTypes#number) [\]](dataTypes#tuple) | [{](dataTypes#object) x: [number](dataTypes#number), y: [number](dataTypes#number) [}](dataTypes#object) | [OpencvPoint](dataTypes#opencvpoint) | [AndroidRect](dataTypes#androidrect) }
+- **pointB** { [\[](dataTypes#tuple) [number](dataTypes#number), [number](dataTypes#number) [\]](dataTypes#tuple) | [{](dataTypes#object) x: [number](dataTypes#number), y: [number](dataTypes#number) [}](dataTypes#object) | [OpencvPoint](dataTypes#opencvpoint) | [AndroidRect](dataTypes#androidrect) }
+- **[ fraction = undefined ]** { [number](dataTypes#number) } - 小数点后的数字个数
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回两点间距离, 并根据 fraction 参数进行可能的四舍五入.
+
+```js
+const Point = org.opencv.core.Point;
+const Rect = android.graphics.Rect;
+
+/* 无参返回 NaN. */
+console.log(Mathx.dist()); // NaN
+
+/* 以数组作点. */
+console.log(Mathx.dist([ 0, 0 ], [ 3, 4 ])); // 5
+
+/* 以包含 x 及 y 属性的对象作点. */
+console.log(Mathx.dist({ x: 0, y: 0 }, { x: 3, y: 4 })); // 5
+
+/* 以 Point 作点. */
+console.log(Mathx.dist(new Point(6, 7), new Point(12, 15))); // 10
+
+/* 以 Rect 作点, 此时其中心点作为参照点. */
+console.log(Mathx.dist(new Rect(0, 0, 10, 10), new Rect(10, 10, 20, 20))); // 14.142135623730951
+console.log(Mathx.dist(new Rect(0, 0, 10, 10), new Rect(10, 10, 20, 20), 3)); // 14.142
+
+/* 两点类型可以不一致. */
+console.log(Mathx.dist([ 0, 0 ], new Point(3, 4))); // 5
+console.log(Mathx.dist([ 0, 0 ], new Rect(0, 0, 6, 8))); // 5
+
+/* 点可以用浮点数表示. */
+console.log(Mathx.dist(new Point(0, 0), new Point(0.5, 0.5))); // 0.7071067811865476
+
+/* Rect 的中心点也可以为浮点数. */
+console.log(Mathx.dist(new Point(0, 0), new Rect(0, 0, 1, 1))); // 0.7071067811865476
+```
+
+### dist(rect, fraction?)
+
+**`6.2.0`** **`xObject`** **`Overload [3-4]/4`**
+
+- **rect** { [AndroidRect](dataTypes#androidrect) } - 矩形
+- **[ fraction = undefined ]** { [number](dataTypes#number) } - 小数点后的数字个数
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回矩形的对角点间距, 并根据 fraction 参数进行可能的四舍五入.
+
+```js
+/* 长 6 (12 - 6) 宽 8 (15 - 7) 的矩形, 对角线长度为 10. */
+console.log(Mathx.dist(new Rect(6, 7, 12, 15))); // 10
+
+/* 边长为 1 的正方形, 对角线长度为 √2 (根号 2). 结果保留 3 位小数. */
+console.log(Mathx.dist(new Rect(0, 0, 1, 1), 3)); // 1.414
+```
diff --git a/api/media.md b/api/media.md
index cbc33c4..ef71eb8 100644
--- a/api/media.md
+++ b/api/media.md
@@ -1,10 +1,15 @@
-# Media
+# 多媒体 (Media)
 
-> Stability: 2 - Stable
+---
 
-media模块提供多媒体编程的支持。目前仅支持音乐播放和媒体文件扫描。后续会结合UI加入视频播放等功能。
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
 
-需要注意是，使用该模块播放音乐时是在后台异步播放的，在脚本结束后会自动结束播放，因此可能需要插入诸如`sleep()`的语句来使脚本保持运行。例如：
+---
+
+media模块提供多媒体编程的支持. 目前仅支持音乐播放和媒体文件扫描. 后续会结合UI加入视频播放等功能.
+
+需要注意是, 使用该模块播放音乐时是在后台异步播放的, 在脚本结束后会自动结束播放, 因此可能需要插入诸如`sleep()`的语句来使脚本保持运行. 例如：
 
 ```
 //播放音乐
@@ -17,9 +22,9 @@ sleep(media.getMusicDuration());
 
 * `path` {string} 媒体文件路径
 
-扫描路径path的媒体文件，将它加入媒体库中；或者如果该文件以及被删除，则通知媒体库移除该文件。
+扫描路径path的媒体文件, 将它加入媒体库中；或者如果该文件以及被删除, 则通知媒体库移除该文件.
 
-媒体库包括相册、音乐库等，因此该函数可以用于把某个图片文件加入相册。
+媒体库包括相册、音乐库等, 因此该函数可以用于把某个图片文件加入相册.
 
 ```
 //请求截图
@@ -36,10 +41,10 @@ media.scanFile(path);
 ## media.playMusic(path[, volume, looping])
 
 * `path` {string} 音乐文件路径
-* `volume` {number} 播放音量，为0~1的浮点数，默认为1
-* `looping` {boolean} 是否循环播放，如果looping为`true`则循环播放，默认为`false`
+* `volume` {number} 播放音量, 为0~1的浮点数, 默认为1
+* `looping` {boolean} 是否循环播放, 如果looping为`true`则循环播放, 默认为`false`
 
-播放音乐文件path。该函数不会显示任何音乐播放界面。如果文件不存在或者文件不是受支持的音乐格式，则抛出`UncheckedIOException`异常。
+播放音乐文件path. 该函数不会显示任何音乐播放界面. 如果文件不存在或者文件不是受支持的音乐格式, 则抛出`UncheckedIOException`异常.
 
 ```
 //播放音乐
@@ -48,7 +53,7 @@ media.playMusic("/sdcard/1.mp3");
 sleep(media.getMusicDuration());
 ```
 
-如果要循环播放音乐，则使用looping参数：
+如果要循环播放音乐, 则使用looping参数：
 
 ```
 ```
@@ -61,15 +66,15 @@ sleep(media.getMusicDuration() * 3);
 ```
 ```
 
-如果要使用音乐播放器播放音乐，调用`app.viewFile(path)`函数。
+如果要使用音乐播放器播放音乐, 调用`app.viewFile(path)`函数.
 
 ## media.musicSeekTo(msec)
 
-* `msec` {number} 毫秒数，表示音乐进度
+* `msec` {number} 毫秒数, 表示音乐进度
 
-把当前播放进度调整到时间msec的位置。如果当前没有在播放音乐，则调用函数没有任何效果。
+把当前播放进度调整到时间msec的位置. 如果当前没有在播放音乐, 则调用函数没有任何效果.
 
-例如，要把音乐调到1分钟的位置，为`media.musicSeekTo(60 * 1000)`。
+例如, 要把音乐调到1分钟的位置, 为`media.musicSeekTo(60 * 1000)`.
 
 ```
 //播放音乐
@@ -82,30 +87,30 @@ sleep(media.getMusicDuration() - 30 * 1000);
 
 ## media.pauseMusic()
 
-暂停音乐播放。如果当前没有在播放音乐，则调用函数没有任何效果。
+暂停音乐播放. 如果当前没有在播放音乐, 则调用函数没有任何效果.
 
 ## media.resumeMusic()
 
-继续音乐播放。如果当前没有播放过音乐，则调用该函数没有任何效果。
+继续音乐播放. 如果当前没有播放过音乐, 则调用该函数没有任何效果.
 
 ## media.stopMusic()
 
-停止音乐播放。如果当前没有在播放音乐，则调用函数没有任何效果。
+停止音乐播放. 如果当前没有在播放音乐, 则调用函数没有任何效果.
 
 ## media.isMusicPlaying()
 
 * 返回 {boolean}
 
-返回当前是否正在播放音乐。
+返回当前是否正在播放音乐.
 
 ## media.getMusicDuration()
 
 * 返回 {number}
 
-返回当前音乐的时长。单位毫秒。
+返回当前音乐的时长. 单位毫秒.
 
 ## media.getMusicCurrentPosition()
 
 * 返回 {number}
 
-返回当前音乐的播放进度(已经播放的时间)，单位毫秒。
\ No newline at end of file
+返回当前音乐的播放进度(已经播放的时间), 单位毫秒.
\ No newline at end of file
diff --git a/api/modules.md b/api/modules.md
index 164293c..e01c123 100644
--- a/api/modules.md
+++ b/api/modules.md
@@ -1,17 +1,22 @@
-# module (模块)
+# 模块 (Module)
 
-> Stability: 2 - Stable
+---
 
-Auto.js 有一个简单的模块加载系统。 在 Auto.js 中，文件和模块是一一对应的（每个文件被视为一个独立的模块）。
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
 
-例子，假设有一个名为 foo.js 的文件：
+---
+
+Auto.js 有一个简单的模块加载系统.  在 Auto.js 中, 文件和模块是一一对应的（每个文件被视为一个独立的模块）.
+
+例子, 假设有一个名为 foo.js 的文件：
 
 ```
 var circle = require('circle.js');
 console.log("半径为 4 的圆的面积是 %d", circle.area(4));
 ```
 
-在第一行中，foo.js 加载了同一目录下的 circle.js 模块。
+在第一行中, foo.js 加载了同一目录下的 circle.js 模块.
 
 circle.js 文件的内容为：
 
@@ -29,13 +34,13 @@ circle.circumference = (r) => 2 * PI * r;
 module.exports = circle;
 ```
 
-circle.js 模块导出了 area() 和 circumference() 两个函数。 通过在特殊的 exports 对象上指定额外的属性，函数和对象可以被添加到模块的根部。
+circle.js 模块导出了 area() 和 circumference() 两个函数.  通过在特殊的 exports 对象上指定额外的属性, 函数和对象可以被添加到模块的根部.
 
-模块内的本地变量是私有的。 在这个例子中，变量 PI 是 circle.js 私有的，不会影响到加载他的脚本的变量环境。
+模块内的本地变量是私有的.  在这个例子中, 变量 PI 是 circle.js 私有的, 不会影响到加载他的脚本的变量环境.
 
-module.exports属性可以被赋予一个新的值（例如函数或对象）。
+module.exports属性可以被赋予一个新的值（例如函数或对象）.
 
-如下，bar.js 会用到 square 模块，square 导出一个构造函数：
+如下, bar.js 会用到 square 模块, square 导出一个构造函数：
 
 ```
 const square = require('square.js');
@@ -43,7 +48,7 @@ const mySquare = square(2);
 console.log("正方形的面积是 %d", mySquare.area());
 square 模块定义在 square.js 中：
 
-// 赋值给 `exports` 不会修改模块，必须使用 `module.exports`
+// 赋值给 `exports` 不会修改模块, 必须使用 `module.exports`
 module.exports = function(width) {
   return {
     area: () => width ** 2
diff --git a/api/numberx.md b/api/numberx.md
new file mode 100644
index 0000000..35d4065
--- /dev/null
+++ b/api/numberx.md
@@ -0,0 +1,301 @@
+# Numberx (Number 扩展)
+
+Numberx 用于扩展 JavaScript 标准内置对象 Number 的功能 (参阅 [内置对象扩展](glossaries#内置对象扩展)).
+
+Numberx 全局可用:
+
+```js
+console.log(typeof Numberx); // "object"
+console.log(typeof Numberx.clamp); // "function"
+```
+
+当启用内置扩展后, Numberx 将被应用在 Number 及其原型上:
+
+```js
+console.log(typeof Number.prototype.clamp); // "function"
+console.log(typeof (123).clamp); // "function"
+```
+
+## 启用内置扩展
+
+内置扩展默认被禁用, 以下任一方式可启用内置扩展:
+
+- 在脚本中加入代码片段: `plugins.extendAll();` 或 `plugins.extend('Number');`
+- AutoJs6 应用设置 - 扩展性 - JavaScript 内置对象扩展 - [ 启用 ]
+
+当上述应用设置启用时, 所有脚本均默认启用内置扩展.  
+当上述应用设置禁用时, 只有加入上述代码片段的脚本才会启用内置扩展.  
+内置扩展往往是不安全的, 除非明确了解内置扩展的原理及风险, 否则不建议启用.
+
+---
+
+<p style="font: bold 2em sans-serif; color: #FF7043">Numberx</p>
+
+---
+
+## [p] ICU
+
+**`6.2.0`** **`xObject`** **`CONSTANT`**
+
+- [[ 996 ]] { [number](dataTypes#number) }
+
+996.ICU - Developers' lives matter (程序员生命健康值得呵护).
+
+常量值: 996
+
+```js
+/* 静态常量. */
+console.log(`${Numberx.ICU} is not only a number`);
+
+/* 启用内置对象扩展后. */
+console.log(`${Number.ICU} is not only a number`);
+```
+
+> 参阅: [Wikipedia](https://zh.wikipedia.org/wiki/996%E5%B7%A5%E4%BD%9C%E5%88%B6) / [GitHub](https://github.com/996icu/996.ICU)
+
+## [m] ensureNumber
+
+### ensureNumber(...o)
+
+**`6.2.0`** **`xObject`**
+
+- **o** { [...](documentation#可变参数)[any](dataTypes#any)[[]](documentation#可变参数) } - 任意对象
+- <ins>**returns**</ins> { [void](dataTypes#void) }
+
+相当于严格类型检查, 当任意一个 o 不满足 `typeof o === 'number'` 时抛出异常.
+
+```js
+/* 确保每一个对象都是 number 基本类型. */
+
+console.log(Numberx.ensureNumber(9)); /* 无异常. */
+console.log(Numberx.ensureNumber(null)); /* 抛出异常. */
+console.log(Numberx.ensureNumber(NaN, 0, Infinity)); /* 无异常. */
+
+/* 启用内置对象扩展后. */
+
+console.log(Number.ensureNumber(9)); /* 无异常. */
+console.log(Number.ensureNumber(null)); /* 抛出异常. */
+console.log(Number.ensureNumber(NaN, 0, Infinity)); /* 无异常. */
+```
+
+## [m] clamp
+
+### clamp(num, ...clamps)
+
+**`6.2.0`** **`xProto`**
+
+- **num** { [number](dataTypes#number) } - 待处理数字
+- **clamps** { [...](documentation#可变参数)([number](dataTypes#number) | [number](dataTypes#number)[[]](dataTypes#array))[[]](documentation#可变参数) } - 限制范围
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回限制在指定范围内的数字.  
+当给定数字不在限制范围内时, 则就近返回一个范围边界值.
+
+通常限制范围用两个大小不同的数字数组表示,  
+如范围 10 - 30 可用 `[ 10, 30 ]` 表示.  
+范围参数会根据给定参数排序后挑选出最大值与最小值作为限制上限及下限,  
+因此 `[ 30, 10 ]` 与 `[ 10, 30 ]` 效果相同,  
+而与 `[ 10, 11, 15, 22, 30 ]` 或 `[ 20, 30, 25, 10 ]` 等效果也相同:
+
+```js
+let num = Math.random() * 50;
+console.log(Numberx.clamp(num, [ 10, 30 ]));
+console.log(Numberx.clamp(num, [ 10, 12, 30, 22, 20 ])); /* 同上. */
+
+/* 启用内置对象扩展后. */
+
+console.log(num.clamp([ 10, 30 ])); /* 同上. */
+console.log(num.clamp([ 10, 12, 30, 22, 20 ])); /* 同上. */
+```
+
+因范围参数 clamps 是 [可变参数](documentation#可变参数), 因此以下两种调用方式效果相同:
+
+```js
+let num = Math.random() * 50;
+console.log(Numberx.clamp(num, [ 10, 30 ]));
+console.log(Numberx.clamp(num, 10, 30)); /* 同上. */
+
+/* 启用内置对象扩展后. */
+
+console.log(num.clamp([ 10, 30 ])); /* 同上. */
+console.log(num.clamp(10, 30)); /* 同上. */
+```
+
+当限制范围参数是 1 个数字时, 相当于 `[ x, x ]`, 则一定返回 x 本身;  
+当限制范围参数是 0 个数字时 (省略或空数组), 则返回 num 本身:
+
+```js
+let num = 307;
+console.log(Numberx.clamp(num, 523)); // 523
+console.log(Numberx.clamp(num)); // 307
+
+/* 启用内置对象扩展后. */
+
+console.log(num.clamp(523)); // 523
+console.log(num.clamp()); // 307
+```
+
+## [m] toFixedNum
+
+### toFixedNum(num, fraction?)
+
+**`6.2.0`** **`xProto`**
+
+- **num** { [number](dataTypes#number) } - 待处理数字
+- **[ fraction = 0 ]** { [number](dataTypes#number) } - 小数点后数字的个数
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+使用定点表示法来格式化一个数值, 然后返回其对应的 number 值.
+
+```js
+console.log(Numberx.toFixedNum(123.456, 2)); // 123.46
+console.log(Numberx.toFixedNum(3.004, 2)); // 3
+console.log(Numberx.toFixedNum(1.23456e3)); // 1235
+
+/* 启用内置对象扩展后. */
+
+console.log((123.456).toFixedNum(2)); // 123.46
+console.log((3.004).toFixedNum(2)); // 3
+console.log((1.23456e3).toFixedNum()); // 1235
+```
+
+## [m] padStart
+
+### padStart(num, targetLength, pad?)
+
+**`6.2.0`** **`xProto`**
+
+- **num** { [number](dataTypes#number) } - 待处理数字
+- **targetLength** { [number](dataTypes#number) } - 当前数字需要填充到的目标字符串长度. 如果此长度小于 num 参数的字符串长度, 则返回 num 参数的字符串本身.
+- **[ pad = '0' ]** { [string](dataTypes#string) | [number](dataTypes#number) } - 填充字符串. 如果字符串太长, 使填充后的字符串长度超过了目标长度, 则只保留最左侧部分, 其他部分会被截断. 此参数的默认值为 "0"（U+0030）。
+- <ins>**returns**</ins> { [string](dataTypes#string) }
+
+此方法用一个字符串填充当前数字 (如果需要的话则重复填充), 返回填充后达到指定长度的字符串.  
+填充从当前数字对应字符串的开头开始.
+
+```js
+console.log(Numberx.padStart(5, 2, 0)); // "05"
+console.log(Numberx.padStart(5, 2)); // "05"
+console.log(Numberx.padStart(3, 3)); // "003"
+console.log(Numberx.padStart(99, 5, "AB")); // "ABA99"
+
+/* 启用内置对象扩展后. */
+
+console.log((5).padStart(2, 0)); // "05"
+console.log((5).padStart(2)); // "05"
+console.log((3).padStart(3)); // "003"
+console.log((99).padStart(5, "AB")); // "ABA99"
+```
+
+格式化日期与时间:
+
+```js
+let pad = x => Numberx.padStart(x, 2, 0); /* 启用内置对象扩展后: `x.padStart(2, 0)`. */
+let now = new Date();
+let date = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`;
+let time = `${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}`;
+console.log(`${date} ${time}`); /* e.g. "2022-11-01 08:47:15" */
+```
+
+## [m] padEnd
+
+### padEnd(num, targetLength, pad?)
+
+**`6.2.0`** **`xProto`**
+
+- **num** { [number](dataTypes#number) } - 待处理数字
+- **targetLength** { [number](dataTypes#number) } - 当前数字需要填充到的目标字符串长度. 如果此长度小于 num 参数的字符串长度, 则返回 num 参数的字符串本身.
+- **[ pad = '0' ]** { [string](dataTypes#string) | [number](dataTypes#number) } - 填充字符串. 如果字符串太长, 使填充后的字符串长度超过了目标长度, 则只保留最左侧部分, 其他部分会被截断. 此参数的默认值为 "0"（U+0030）。
+- <ins>**returns**</ins> { [string](dataTypes#string) }
+
+此方法用一个字符串填充当前数字 (如果需要的话则重复填充), 返回填充后达到指定长度的字符串.  
+填充从当前数字对应字符串的末尾开始.
+
+```js
+console.log(Numberx.padEnd(5, 2, 0)); // "50"
+console.log(Numberx.padEnd(5, 2)); // "50"
+console.log(Numberx.padEnd(3, 3)); // "300"
+console.log(Numberx.padEnd(99.1, 5)); // "99.10"
+
+/* 启用内置对象扩展后. */
+
+console.log((5).padEnd(2, 0)); // "50"
+console.log((5).padEnd(2)); // "50"
+console.log((3).padEnd(3)); // "300"
+console.log((99.1).padEnd(5)); // "99.10"
+```
+
+## [m] parseFloat
+
+### parseFloat(string, radix)
+
+**`6.2.0`** **`xObject`**
+
+- **string** { [string](dataTypes#string) } - 待解析的字符串
+- **radix** { [number](dataTypes#number) } - 进制的基数
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+根据指定的进制基数, 解析字符串并返回一个数字.
+
+标准内置对象 Number 的 parseInt 支持进制基数 radix 参数, 即 parseInt(string, radix), 但 parseFloat 不支持 radix 参数.
+
+此扩展方法对上述 radix 参数提供了支持:
+
+```js
+console.log(Numberx.parseFloat("0.8", 16)); // 0.5
+console.log(Numberx.parseFloat("0.101", 2)); // 0.625
+
+/* 启用内置对象扩展后. */
+
+console.log(Number.parseFloat("0.8", 16)); // 0.5
+console.log(Number.parseFloat("0.101", 2)); // 0.625
+console.log(parseFloat("0.8", 16)); // 0.5
+console.log(parseFloat("0.101", 2)); // 0.625
+```
+
+## [m] parsePercent
+
+### parsePercent(percentage)
+
+**`6.2.0`** **`xObject`**
+
+- **percentage** { [string](dataTypes#string) | [number](dataTypes#number) } - 百分数字符串或任意数字
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+此方法用于解析一个百分数字符串 (如 `"5%"`) 并返回其代表的数值.  
+如果 percentage 是一个 number 基本类型值, 则直接返回.
+
+```js
+console.log(Numberx.parsePercent('1%')); // 0.01
+console.log(Numberx.parsePercent('50.00%')); // 0.5
+console.log(Numberx.parsePercent('2%%')); // 0.0002
+
+/* 启用内置对象扩展后. */
+
+console.log(Number.parsePercent('1%')); // 0.01
+console.log(Number.parsePercent('50.00%')); // 0.5
+console.log(Number.parsePercent('2%%')); // 0.0002
+```
+
+## [m] parseRatio
+
+### parseRatio(ratio)
+
+**`6.2.0`** **`xObject`**
+
+- **ratio** { [string](dataTypes#string) } - 比率字符串
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+此方法用于解析一个比率字符串 (如 `"5:23"`) 并返回其代表的数值.
+
+```js
+console.log(Numberx.parseRatio('3:2')); // 1.5
+console.log(Numberx.parseRatio('3:0.1')); // 30
+console.log(Numberx.parseRatio('0.1:0.01')); // 10
+
+/* 启用内置对象扩展后. */
+
+console.log(Number.parseRatio('3:2')); // 1.5
+console.log(Number.parseRatio('3:0.1')); // 30
+console.log(Number.parseRatio('0.1:0.01')); // 10
+```
diff --git a/api/overview.md b/api/overview.md
index cd91989..89a06b9 100644
--- a/api/overview.md
+++ b/api/overview.md
@@ -1,28 +1,45 @@
-# 综述
-
-Auto.js使用[JavaScript](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript)作为脚本语言，目前使用[Rhino 1.7.15-snapshot](https://developer.mozilla.org/zh-CN/docs/Mozilla/Projects/Rhino)作为脚本引擎，支持ES5与部分ES6特性。
-
-* 因为Auto.js是基于JavaScript的，学习Auto.js的API之前建议先学习JavaScript的基本语法和内置对象，可以使用教程前面的两个JavaScript教程链接来学习。
-* 如果您想要使用TypeScript来开发，目前已经有开发者公布了一个可以把使用TypeScript进行Auto.js开发的工具，参见[Auto.js DevTools](https://github.com/pboymt/autojs-dev)。
-* 如果想要在电脑而不是手机上开发Auto.js，可以使用VS Code以及相应的Auto.js插件使得在电脑上编辑的脚本能推送到手机运行，参见[Auto.js-VSCode-Extension](https://github.com/hyb1996/Auto.js-VSCode-Extension)，Auto.js Pro用户则需要使用[Auto.js-Pro-Ext](https://marketplace.visualstudio.com/items?itemName=hyb1996.auto-js-pro-ext)。
-* 支持Node.js已在计划中，预计2020年底在Auto.js Pro中支持
-
-本文档的章节大致上是以模块来分的，总体上可以分成"自动操作"类模块(控件操作、触摸模拟、按键模拟等)和其他类模块(设备、应用、界面等)。
-
-"自动操作"的部分又可以大致分为基于控件和基于坐标的操作。基于坐标的操作是传统按键精灵、触摸精灵等脚本软件采用的方式，通过屏幕坐标来点击、长按指定位置模拟操作，从而到达目的。例如`click(100, 200)`, `press(100, 200, 500)`等。这种方式在游戏类脚本中比较有可行性，结合找图找色、坐标放缩功能也能达到较好的兼容性。但是，这种方式对一般软件脚本却难以达到想要的效果，而且这种方式需要安卓7.0版本以上或者root权限才能执行。所以对于一般软件脚本(例如批量添加联系人、自动提取短信验证码等等)，我们采用基于控件的模拟操作方式，结合通知事情、按键事情等达成更好的工作流。这些部分的文档参见[基于控件的操作](widgets-based-automation.html)和[基于坐标的操作](coordinates-based-automation.html)。
-
-其他部分主要包括：
-
-* app: 应用。启动应用，卸载应用，使用应用查看、编辑文件、访问网页，发送应用间广播等。
-* console: 控制台。记录运行的日志、错误、信息等。
-* device: 设备。获取设备屏幕宽高、系统版本等信息，控制设备音量、亮度等。
-* engines: 脚本引擎。用于启动其他脚本。
-* events: 事件与监听。按键监听，通知监听，触摸监听等。
-* floaty: 悬浮窗。用于显示自定义的悬浮窗。
-* files: 文件系统。文件创建、获取信息、读写。
-* http: HTTP。发送HTTP请求，例如GET, POST等。
-* images, colors: 图片和图色处理。截图，剪切图片，找图找色，读取保存图片等。
-* keys: 按键模拟。比如音量键、Home键模拟等。
-* shell: Shell命令。
-* threads: 多线程支持。
-* ui: UI界面。用于显示自定义的UI界面，和用户交互。
\ No newline at end of file
+# 综述 (Overview)
+
+---
+
+AutoJs6: 安卓平台 JavaScript 自动化工具.
+
+- 脚本语言: [JavaScript](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/)  
+- 脚本引擎: [Rhino](https://github.com/mozilla/rhino/)  
+- 支持特性: [ES5](https://262.ecma-international.org/5.1/) (全部), [ES6](https://262.ecma-international.org/6.0/) (部分)
+
+---
+
+扩展阅读:
+
+- 了解 JavaScript
+  - [MDN - JavaScript 基础](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/)
+  - [JavaScript.info - JavaScript 教程](https://zh.javascript.info/)
+- 查看 Rhino 引擎兼容性列表
+  - [Rhino ES2015 Support](https://mozilla.github.io/rhino/compat/engines.html)
+- 使用 PC (个人计算机) 开发
+  - [AutoJs6 VSCode Extension](https://github.com/SuperMonster003/AutoJs6-VSCode-Extension/)
+- 使用 Node.js 开发
+  - [Auto.js Pro](https://pro.autojs.org/)
+- 使用 TypeScript 开发
+  - [Auto.js DevTools](https://github.com/pboymt/autojs-dev/)
+
+---
+
+阅读文档:
+
+- 宽屏设备网页阅读
+  - 点击左侧边栏条目 - 阅读相关章节
+- 移动设备网页阅读
+  - 点击左下方抽屉按钮 - 展开侧边栏并点击条目 - 阅读相关章节
+- AutoJs6 阅读
+  - 点击首页 "文档" 标签 - 点击条目 - 阅读相关章节
+  - 点击首页右上方 "搜索" 图标 - 在当前页面检索内容
+  - 文档页面左上方的导航链接可实现页面跳转:
+    - 点击 "索引" - 跳转至章节索引页面
+    - 点击 "查看全部" - 所有章节内容在同一页面列出
+  - 阅读文档时, "文档" 标签可作为快捷按钮使用:
+    - 点击 "文档" 标签 - 返回至当前页面顶部
+    - 长按 "文档" 标签 - 跳转至章节索引页面
+
+> 注: 初次阅读文档或首次使用 AutoJs6 建议从 [关于文档](documentation) 开始.
\ No newline at end of file
diff --git a/api/plugins.md b/api/plugins.md
new file mode 100644
index 0000000..3d52bcb
--- /dev/null
+++ b/api/plugins.md
@@ -0,0 +1,10 @@
+# 插件 (Plugins)
+
+---
+
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
+
+---
+
+
diff --git a/api/polyfill.md b/api/polyfill.md
new file mode 100644
index 0000000..9cf0c8b
--- /dev/null
+++ b/api/polyfill.md
@@ -0,0 +1,30 @@
+# 代码填泥 (Polyfill)
+
+## 定义
+
+代码填泥, 又称 [ 填泥 / 腻子 / 泥子 ], 是一个完整的代码块, 用于为不支持原生 ECMAScript 新功能的环境提供功能支持.  
+例如 Polyfill 可以让 AutoJs6 模拟 Array 原型上的 [at](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/at) 等新增方法.
+
+之所以被称为填泥, 是因为它主要用于 "抹平" 不同环境的功能支持差异.  
+换句话说, 它是当前环境中某个标准 API 缺失后的手动实现.  
+
+> 参阅: [MDN](https://developer.mozilla.org/zh-CN/docs/Glossary/Polyfill)
+
+## AutoJs6 实现
+
+截至 2022 年 10 月, AutoJs6 实现了以下代码填泥:
+
+- [Array.prototype.at](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/at)
+- [Array.prototype.flat](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/flat)
+- ~~[Object.getOwnPropertyDescriptors](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptors)~~ (Rhino 1.7.15-SNAPSHOT 已实现)
+
+## 区别于 Shim (代码垫片)
+
+Polyfill 与 Shim (代码垫片) 不同, Shim 针对的是环境, Polyfill 针对的是API.  
+
+Shim 作为 "垫片", 主要用于为旧环境提供 API 或提供新功能.  
+在使用 Shim 时, 通常不会在意旧环境是否已存在某 API, 它会直接改变或重新定义某些全局对象, 以实现在不同环境下功能的完整性和统一性.
+
+Polyfill 是腻子, 用于抹平不同环境下的 API 差异, 它会判断旧环境是否已经存在 API, 不存在时才会添加新API.
+
+> 参阅: [掘金](https://juejin.cn/post/6844904050882772999) / [StackOverflow](https://stackoverflow.com/questions/6599815/what-is-the-difference-between-a-shim-and-a-polyfill)
\ No newline at end of file
diff --git a/api/progress.md b/api/progress.md
new file mode 100644
index 0000000..a57b318
--- /dev/null
+++ b/api/progress.md
@@ -0,0 +1,69 @@
+# 部署进度 (Progress)
+
+本章节展示了 AutoJs6 文档各个章节的部署进度.  
+文档以 Auto.js 4.1.1 Alpha2 的原始文档为基础, 逐步完成部署及更新.
+
+---
+
+标记含义:
+
+- √ - 全部完成 (或具备基础完整度)
+- × - 暂未开始部署 (或暂时保留原始文档内容)
+- &lt; 10% - 预估部署进度, 小于指定百分比
+- &gt; 20% - 预估部署进度, 大于指定百分比
+
+---
+
+|                         章节                          |   部署进度   |
+|:---------------------------------------------------:|:--------:|
+|               [Global - 全局对象](global)               | &gt; 70% |
+|            [Automator - 自动化](automator)             | &gt; 60% |
+|              [AutoJs6 - 本体应用](autojs)               |    ×     |
+|                  [App - 通用应用](app)                  |    ×     |
+|                 [Color - 颜色](color)                 |    ×     |
+|                 [Image - 图像](image)                 |    ×     |
+|                  [Keys - 按键](keys)                  |    ×     |
+|                [Device - 设备](device)                |    ×     |
+|              [Storage - 储存](storages)               |    ×     |
+|                 [File - 文件](files)                  |    ×     |
+|               [Engine - 引擎](engines)                |    ×     |
+|                 [Task - 任务](tasks)                  |    ×     |
+|               [Module - 模块](modules)                |    ×     |
+|               [Plugins - 插件](plugins)               |    ×     |
+|              [Console - 控制台](console)               |    ×     |
+|                   [Shell](shell)                    |    ×     |
+|                [Media - 多媒体](media)                 |    ×     |
+|               [Sensor - 传感器](sensors)               |    ×     |
+|             [Recorder - 记录器](recorder)              |    ×     |
+|                [Timer - 定时器](timers)                |    ×     |
+|               [Thread - 线程](threads)                |    ×     |
+|          [Continuation - 协程](continuation)          |    ×     |
+|               [Event - 事件监听](events)                |    ×     |
+|               [Dialog - 对话框](dialogs)               |    ×     |
+|               [Floaty - 悬浮窗](floaty)                |    ×     |
+|                [Canvas - 画布](canvas)                |    ×     |
+|                   [UI - 用户界面](ui)                   |    ×     |
+|                  [Web - 万维网](web)                   |    ×     |
+|                    [HTTP](http)                     |    ×     |
+|                  [Base64](base64)                   |    ×     |
+|                [Crypto - 密文](crypto)                |    ×     |
+|         [Internationalization - 国际化](i18n)          |    ×     |
+|                     [E4X](e4x)                      |    √     |
+|            [Glossaries - 术语](glossaries)            |    √     |
+|            [Exceptions - 异常](exceptions)            |    √     |
+|              [Intent - 意图](intentType)              | &lt; 10% |
+|              [Runtime - 运行时](runtime)               |    ×     |
+|              [Context - 上下文](context)               |    ×     |
+|              [Activity - 活动](activity)              |    ×     |
+|           [Data Types - 数据类型](dataTypes)            | &gt; 70% |
+|         [UiSelector - 选择器](uiSelectorType)          |    √     |
+|           [UiObject - 控件节点](uiObjectType)           |    √     |
+| [UiObjectCollection - 控件集合](uiObjectCollectionType) |    √     |
+|   [UiObjectActions - 控件节点行为](uiObjectActionsType)   |    √     |
+|               [App - 应用枚举类](appType)                |    √     |
+|             [Polyfill - 代码填泥](polyfill)             |    √     |
+|             [Arrayx - Array 扩展](arrayx)             |    √     |
+|           [Numberx - Number 扩展](numberx)            |    √     |
+|              [Mathx - Math 扩展](mathx)               |    √     |
+|     [Scripting Java - 脚本化 Java](scriptingJava)      |    √     |
+|      [Android API Level - 安卓 API 级别](apiLevel)      |    √     |
\ No newline at end of file
diff --git a/api/qa.md b/api/qa.md
index 012894f..96cb64c 100644
--- a/api/qa.md
+++ b/api/qa.md
@@ -1,62 +1,81 @@
-# Q & A
+# 疑难解答 (Q & A)
 
-## 如何定时运行脚本nenenene
+---
 
-点击脚本右边的菜单按钮->更多->定时任务即可定时运行脚本，但是必须保持Auto.js后台运行(自启动白名单、电源管理白名单等)。同时，可以在脚本的开头使用`device.wakeUp()`来唤醒屏幕；但是，Auto.js没有解锁屏幕的功能，因此难以在有锁屏密码的设备上达到效果。
+## 图像
 
-## 定时任何如何获取外部参数
+### 区域截图
 
-如果一个脚本是用intent"启动"的，比如定时任务中的特定事件（网络状态变化等）触发而启动的，则可以通过`engines.myEngine().execArgv.intent`获取启动的intent，从而获取外部参数。
+AutoJs6 不支持区域截图.  
+只能通过 `images.captureScreen` 截取屏幕后使用 `images.clip` 等方式做进一步处理.
 
-## 如何把图片和脚本一起打包，或者打包多个脚本
+## 定时任务
 
-如果除了单脚本以外还有其他脚本、图片、音乐等资源一起打包，则需要使用项目功能。
+### 定时运行脚本
 
-点击Auto.js的"+"号，选择项目，填写项目名称、包名等信息以后，点击"√"即可新建一个项目。可以在项目中放多个脚本、模块、资源文件，点击项目工具栏的apk打包图标即可打包一个项目，点击工具栏可以重新配置项目。
+脚本右侧菜单 -> 定时任务, 即可定时运行脚本.  
+需保持 AutoJs6 后台运行, 包括 [ 自启动白名单 / 忽略电池优化 / 忽略后台活动限制 / 系统多任务保留 ] 等.  
+在设备关屏情况下, 可使用 `device.wakeUp()` 唤醒屏幕.  
+但 AutoJs6 暂未提供解锁功能, 因此可能需要根据设备自行设计解锁代码.
 
-例如，主脚本要读取同一文件夹下的图片1.png，再执行找图，则可以通过`images.read("./1.png")`来读取，其中"./1.png"表示同一目录1.png图片；ui中的图片控件要引用同一文件夹的2.png图片则为`<img src="file://2.png"/>`。Auto.js内置的函数和模块都支持相对路径，但是，其他情况则需要使用`files.path()`函数来把相对路径转换为绝对路径。
+### 定时任务获取外部参数
 
-## 如何使打包的应用不显示主界面
+若脚本由 intent (如网络状态变化等特定事件) 触发启动, 可通过 `engines.myEngine().execArgv.intent` 获取 intent, 进而获取外部参数.
 
-需要使用项目功能。新建项目后，修改项目下的`project.json`文件，增加以下条目：
+## 打包应用
 
-```
-"launchConfig": {
+### 图片等资源共同打包及多脚本打包
+
+上述需求需使用 "项目" 功能.
+
+点击 AutoJs6 主页面 "+" 图标, 选择项目, 填写信息后可新建一个项目.  
+项目支持存放多个 [ 脚本 / 模块 / 资源文件 ].  
+项目工具栏的 APK 打包图标, 点击可打包一个项目.
+
+例如:  
+脚本读取同目录 `1.png`: `images.read("./1.png")`.  
+UI 脚本图片控件引用同目录 `2.png`: `<img src="file://2.png"/>`.  
+AutoJs6 内置模块支持相对路径引用, 其他情况可能需借助 `files.path()` 转换为绝对路径.
+
+### 打包应用不显示主界面
+
+需使用 "项目" 功能.  
+新建项目后, 在项目目录 `project.json` 文件中增加以下条目:
+
+```json
+{
+  "launchConfig": {
     "hideLogs": true
+  }
 }
 ```
 
-例如：
+例如:
 
-```
+```json
 {
-  "name": "项目名称",
+  "name": "First-Project",
   "versionName": "1.0.0",
   "versionCode": 1,
-  "packageName": "org.autojs.example",
+  "packageName": "org.autojs.example.first",
   "main": "main.js",
   "launchConfig": {
-      "hideLogs": true
+    "hideLogs": true
   }
 }
 ```
 
-"launchConfig"表示启动配置，"hideLogs"表示隐藏日志。
+## 功能扩展
 
-参见项目与项目配置。
+AutoJs6 支持直接调用 [ Java / Android / 扩展库 ] 等 API.  
+对于 AutoJs6 没有内置的功能, 可进行 Java 脚本化, 即直接参照 Java (或 Kotlin 等) 源码, 转换为 JavaScript 代码.  
+例如:
 
-## Auto.js自带的模块和函数中没有的功能如何实现
-
-由于Auto.js支持直接调用Android的API，对于Auto.js没有内置的函数，可以直接通过修改Android代码为JavaScript代码实现。例如旋转图片的Android代码为：
-
-```
+```java
 import android.graphics.Bitmap;
 import android.graphics.Matrix;
 
-public static Bitmap rotate(final Bitmap src,
-                            final int degrees,
-                            final float px,
-                            final float py) {
+public static Bitmap rotate(Bitmap src, int degrees, float px, float py) {
     if (degrees == 0) return src;
     Matrix matrix = new Matrix();
     matrix.setRotate(degrees, px, py);
@@ -65,19 +84,19 @@ public static Bitmap rotate(final Bitmap src,
 }
 ```
 
-转换为JavaScript的代码后为：
+转换为 JavaScript 代码:
 
-```
+```js
 importClass(android.graphics.Bitmap);
 importClass(android.graphics.Matrix);
 
-function rotate(src, degrees, px, py){
+function rotate(src, degrees, px, py) {
     if (degrees == 0) return src;
-    var matrix = new Matrix();
+    let matrix = new Matrix();
     matrix.setRotate(degrees, px, py);
-    var ret = Bitmap.createBitmap(src, 0, 0, src.getWidth(), src.getHeight(), matrix, true);
+    let ret = Bitmap.createBitmap(src, 0, 0, src.getWidth(), src.getHeight(), matrix, true);
     return ret;
 }
 ```
 
-有关调用Android和Java的API的更多信息，参见[Work with Java](https://developer.mozilla.org/zh-CN/docs/Mozilla/Projects/Rhino/Scripting_Java)。
\ No newline at end of file
+关于脚本化 Java 的更多信息, 参阅 [Scripting Java - 脚本化 Java](scriptingJava) 章节.
\ No newline at end of file
diff --git a/api/recorder.md b/api/recorder.md
new file mode 100644
index 0000000..af7385e
--- /dev/null
+++ b/api/recorder.md
@@ -0,0 +1,66 @@
+# 记录器 (Recorder)
+
+---
+
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
+
+---
+
+记录器用于计时.
+
+> 注: 为避免与 Timers (定时器) 混淆, 本条目不采用 "计时器" 定义.
+
+---
+
+<p style="font: bold 2em sans-serif; color: #FF7043">recorder</p>
+
+---
+
+## [@] recorder
+
+### recorder()
+
+### recorder(key)
+
+### recorder(key, timestamp)
+
+### recorder(func)
+
+### recorder(func, thisType)
+
+## [m] save
+
+### save()
+
+### save(key)
+
+### save(key, timestamp)
+
+## [m] load
+
+### load()
+
+### load(key)
+
+### load(key, timestamp)
+
+## [m] isLessThan
+
+### isLessThan(key, compare)
+
+## [m] isGreaterThan
+
+### isGreaterThan(key, compare)
+
+## [m] has
+
+### has(key)
+
+## [m] remove
+
+### remove(key)
+
+## [m] clear
+
+### clear()
\ No newline at end of file
diff --git a/api/runtime.md b/api/runtime.md
new file mode 100644
index 0000000..50a413b
--- /dev/null
+++ b/api/runtime.md
@@ -0,0 +1,52 @@
+# 运行时 (Runtime)
+
+---
+
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 31, 2022.</p>
+
+---
+
+## runtime.requestPermissions(permissions)
+
+* `permissions` {Array} 权限的字符串数组
+
+动态申请安卓的权限. 例如：
+
+```
+//请求GPS权限
+runtime.requestPermissions(["access_fine_location"]);
+```
+
+尽管安卓有很多权限, 但必须写入Manifest才能动态申请, 为了防止权限的滥用, 目前Auto.js只能额外申请两个权限：
+
+* `access_fine_location` GPS权限
+* `record_audio` 录音权限
+
+您可以通过APK编辑器来增加Auto.js以及Auto.js打包的应用的权限.
+
+安卓所有的权限列表参见[Permissions Overview](https://developer.android.com/guide/topics/permissions/overview/). （并没有用）
+
+## runtime.loadJar(path)
+
+* `path` {string} jar文件路径
+
+加载目标jar文件, 加载成功后将可以使用该Jar文件的类.
+
+```
+// 加载jsoup.jar
+runtime.loadJar("./jsoup.jar");
+// 使用jsoup解析html
+importClass(org.jsoup.Jsoup);
+log(Jsoup.parse(files.read("./test.html")));
+```
+
+(jsoup是一个Java实现的解析Html DOM的库, 可以在[Jsoup](https://jsoup.org/download/)下载/)
+
+## runtime.loadDex(path)
+
+* `path` {string} dex文件路径
+
+加载目标dex文件, 加载成功后将可以使用该dex文件的类.
+
+因为加载jar实际上是把jar转换为dex再加载的, 因此加载dex文件会比jar文件快得多. 可以使用Android SDK的build tools的dx工具把jar转换为dex.
diff --git a/api/scriptingJava.md b/api/scriptingJava.md
new file mode 100644
index 0000000..607feb8
--- /dev/null
+++ b/api/scriptingJava.md
@@ -0,0 +1,262 @@
+# 脚本化 Java
+
+Rhino 引擎提供了脚本化 Java 的便捷性.
+
+> 注: 此章节参考并修改自 [Auto.js Pro](https://pro.autojs.org/) 及 [Scripting Java](http://udn.realityripple.com/docs/Mozilla/Projects/Rhino/Scripting_Java/).
+
+> 注: ECMA 标准并未包含与 Java 的交互, 本章节所有功能均作为扩展功能而非语言标准使用.
+
+## 访问 Java 包和类
+
+Rhino 定义了顶层变量 `Packages`, 可用于访问顶层 Java 包 (如 [ java / com ] 等).
+
+```js
+typeof Packages === 'object'; // true
+typeof Packages.java === 'object'; // true
+```
+
+为了便于访问, Rhino 提供了顶层包名前缀的快捷访问方式.
+
+```js
+Packages.java === java; // true
+```
+
+> 注: AutoJs6 顶层化的包名前缀包括 [ android / androidx / java / javax / org / com / net / de / ezy / kotlin / okhttp3 ].
+
+顶层方法 `importPackage` 及 `importClass` 可以像 `import` 语句一样导入包或类.
+
+```js
+importPackage(java.io);
+typeof File === 'object'; // true
+```
+
+上述示例相当于 Java 的导入声明语句 `import java.io.*;`
+
+```js
+importClass(java.io.File);
+typeof File === 'object'; // true
+```
+
+上述示例相当于 Java 的导入声明语句 `import java.io.File;`
+
+```js
+const File = java.io.File;
+typeof File === 'object'; // true
+```
+
+上述示例也可使用解构赋值方式导入 File 类: `const {File} = java.io;`
+
+> 注: 配合 TypeScript Declarations 的 IDE 可能对解构赋值变量无法进行类型识别和代码智能提示.  
+> 因此建议使用原始变量声明方式导入需要使用的类.  
+> 对于 importClass 和 importPackage, 目前还未能实现类型识别和代码智能提示 (截至 2022 年 7 月).
+
+## 访问扩展的包及类
+
+AutoJs6 的项目扩展库及项目依赖包均可直接访问.
+
+```js
+/* 依赖包: implementation("joda-time:joda-time:2.10.14") */
+typeof org.joda.time.LocalDateTime.now; // "function"
+
+/* 扩展库: implementation(project(":libs:org.opencv-4.5.5")) */
+typeof org.opencv.core.Point; // "function"
+```
+
+## 与 Java 协作
+
+Rhino 提供了在 JavaScript 代码中 [ 创建 Java 类 / 调用 Java 方法 / 访问变量 ] 等能力.
+
+### Java 类及方法
+
+```js
+let builder = new java.lang.StringBuilder();
+builder.append('foo');
+builder.append('bar');
+builder.toString(); // "foobar"
+```
+
+### Java 类的静态方法及字段
+
+```js
+java.lang.Math.PI; // 3.141592653589793
+java.lang.Math.cos(0); // 1
+```
+
+### Java 重载方法签名
+
+```js
+new java.io.File("foo").listFiles.toString();
+
+/* 代码结果 (共 5 行) */
+
+// function listFiles() {/*
+//     java.io.File[] listFiles(java.io.FileFilter)
+//     java.io.File[] listFiles(java.io.FilenameFilter)
+//     java.io.File[] listFiles()
+// */}
+```
+
+### JavaBean 属性
+
+读写方法符合以下命名规范的类称为 JavaBean:
+
+```java
+/* 读方法 */
+getXyz(): Type
+/* 写方法 */
+setXyz(Type value): void
+```
+
+以下 JavaBean 示例 (Student) 定义了 age 和 sex 属性:
+
+```java
+public class Student {
+
+    private int mAge;  
+    
+    public int getAge() { return mAge; }  
+    public void setAge(int anAge) { mAge = anAge; }
+      
+    public String getSex() { return "male"; }
+      
+};
+```
+
+其中 age 属性可读写, 而 sex 属性只读.
+
+在 JavaScript 代码中可通过实例成员访问属性及方法:
+
+```js
+let stu = new Student();
+stu.sex; // "male" - 相当于 stu.getSex();
+stu.age = 33; /* 相当于 stu.setAge(33); */
+stu.age; // 33
+stu.getAge(); // 33
+```
+
+同样地, 对于属性类型为 boolean 类型的 JavaBean:
+
+```java
+public class Student {
+
+    private boolean mMale;  
+    
+    public boolean isMale() { return mMale; }  
+    public String setMale(boolean value) { mMale = value; }
+      
+};
+```
+
+JavaScript 使用方式:
+
+```js
+let stu = new Student();
+stu.male; // false - 相当于 stu.isMale();
+stu.male = true; /* 相当于 stu.setMale(true); */
+stu.male; // true
+stu.isMale(); // true
+```
+
+## 实现 Java 接口
+
+### 函数转换
+
+```js
+"ui";
+
+ui.layout(
+    <frame>
+        <button id="btn" text="BUTTON"/>
+    </frame>
+);
+
+let listener = new android.view.View.OnClickListener(function (view) {
+    toastLog("clicked");
+});
+ui.btn.setOnClickListener(listener);
+```
+
+上述示例将 JavaScript 函数作为 Java 接口传入 `OnClickListener` 方法.  
+将函数作为接口使用的条件: 接口只有一个方法 (不可为 0 或多于 1 个) 且参数类型依次匹配.
+
+### 对象转换
+
+若 Java 接口有多个方法, 则可传入一个 JavaScript 对象:
+
+```java
+public interface OnAttachStateChangeListener {
+    public void onViewAttachedToWindow(View v);
+    public void onViewDetachedFromWindow(View v);
+}
+```
+
+JavaScript 代码实现:
+
+```js
+new android.view.View.OnAttachStateChangeListener({
+    onViewAttachedToWindow(view) {
+        toastLog('attached');
+    },
+    onViewDetachedFromWindow(view) {
+        toastLog('detached');
+    },
+});
+```
+
+## JavaAdapter 构造器
+
+### 实现 Java 接口
+
+```js
+new JavaAdapter(android.view.View.OnAttachStateChangeListener, {
+    onViewAttachedToWindow(view) {
+        toastLog('attached');
+    },
+    onViewDetachedFromWindow(view) {
+        toastLog('detached');
+    }
+});
+```
+
+### 实现多个 Java 接口
+
+```js
+/* 语法: new JavaAdapter(javaIntfOrClass, [javaIntf, ..., javaIntf,] javascriptObject) */
+
+new JavaAdapter(android.view.View.OnAttachStateChangeListener, java.lang.Runnable, {
+    onViewAttachedToWindow(view) {
+        toastLog('attached');
+    },
+    onViewDetachedFromWindow(view) {
+        toastLog('detached');
+    },
+    run() {
+        toastLog('run');
+    }
+});
+```
+
+### 继承 Java 类并重写方法
+
+```js
+"ui";
+
+ui.layout(
+    <vertical>
+        <frame id="container"/>
+    </vertical>
+);
+
+let paint = new Paint();
+/* android.view.View 构造器的参数. */
+let viewParam = activity;
+let view = new JavaAdapter(android.view.View, {
+    onDraw(canvas) {
+        /* 调用父类 View 的 onDraw 方法. */
+        this.super$onDraw(canvas);
+        canvas.drawRect(500, 500, 1000, 1000, paint);
+    },
+}, viewParam);
+
+ui.container.addView(view);
+```
diff --git a/api/sensors.md b/api/sensors.md
index 2a9d27c..8f28dfd 100644
--- a/api/sensors.md
+++ b/api/sensors.md
@@ -1,12 +1,17 @@
-# Sensors
+# 传感器 (Sensors)
 
-> Stability: 2 - Stable
+---
 
-sensors模块提供了获取手机上的传感器的信息的支持，这些传感器包括距离传感器、光线光感器、重力传感器、方向传感器等。需要指出的是，脚本只能获取传感器的数据，**不能模拟或伪造传感器的数据和事件**，因此诸如模拟摇一摇的功能是无法实现的。
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
 
-要监听一个传感器时，需要使用`sensors.register()`注册监听器，之后才能开始监听；不需要监听时则调用`sensors.unregister()`注销监听器。在脚本结束时会自动注销所有的监听器。同时，这种监听会使脚本保持运行状态，如果不注销监听器，脚本会一直保持运行状态。
+---
 
-例如，监听光线传感器的代码为：
+sensors模块提供了获取手机上的传感器的信息的支持, 这些传感器包括距离传感器、光线光感器、重力传感器、方向传感器等. 需要指出的是, 脚本只能获取传感器的数据, **不能模拟或伪造传感器的数据和事件**, 因此诸如模拟摇一摇的功能是无法实现的.
+
+要监听一个传感器时, 需要使用`sensors.register()`注册监听器, 之后才能开始监听；不需要监听时则调用`sensors.unregister()`注销监听器. 在脚本结束时会自动注销所有的监听器. 同时, 这种监听会使脚本保持运行状态, 如果不注销监听器, 脚本会一直保持运行状态.
+
+例如, 监听光线传感器的代码为：
 
 ```
 //光线传感器监听
@@ -15,80 +20,80 @@ sensors.register("light").on("change", (event, light)=>{
 });
 ```
 
-要注意的是，每个传感器的数据并不相同，所以对他们调用`on()`监听事件时的回调函数参数也不是相同，例如光线传感器参数为`(event, light)`，加速度传感器参数为`(event, ax, ay, az)`。甚至在某些设备上的传感器参数有所增加，例如华为手机的距离传感器为三个参数，一般手机只有一个参数。
+要注意的是, 每个传感器的数据并不相同, 所以对他们调用`on()`监听事件时的回调函数参数也不是相同, 例如光线传感器参数为`(event, light)`, 加速度传感器参数为`(event, ax, ay, az)`. 甚至在某些设备上的传感器参数有所增加, 例如华为手机的距离传感器为三个参数, 一般手机只有一个参数.
 
 常用的传感器及其事件参数如下表：
 
-* `accelerometer` 加速度传感器，参数`(event, ax, ay, az)`:
-    * `event` [SensorEvent](#sensors_sensorevent) 传感器事件，用于获取传感器数据变化时的所有信息
-    * `ax` {number} x轴上的加速度，单位m/s^2
-    * `ay` {number} y轴上的加速度，单位m/s^2
-    * `az` {number} z轴上的加速度，单位m/s^2
-      这里的x轴，y轴，z轴所属的坐标系统如下图(其中z轴垂直于设备屏幕表面):
+* `accelerometer` 加速度传感器, 参数`(event, ax, ay, az)`:
+    * `event` [SensorEvent](#sensors_sensorevent) 传感器事件, 用于获取传感器数据变化时的所有信息
+    * `ax` {number} x轴上的加速度, 单位m/s^2
+    * `ay` {number} y轴上的加速度, 单位m/s^2
+    * `az` {number} z轴上的加速度, 单位m/s^2
+      这里的x轴, y轴, z轴所属的坐标系统如下图(其中z轴垂直于设备屏幕表面):
 
   !![axis_device](#images/axis_device.png)
 
-* `orientation` 方向传感器，参数`(event, azimuth, pitch, roll)`:
-    * `event` [SensorEvent](#sensors_sensorevent) 传感器事件，用于获取传感器数据变化时的所有信息
-    * `azimuth` {number} 方位角，从地磁指北方向线起，依顺时针方向到y轴之间的水平夹角，单位角度，范围0~359
-    * `pitch` {number} 绕x轴旋转的角度，当设备水平放置时该值为0，当设备顶部翘起时该值为正数，当设备尾部翘起时该值为负数，单位角度，范围-180~180
-    * `roll` {number} 绕y轴顺时针旋转的角度，单位角度，范围-90~90
-
-* `gyroscope` 陀螺仪传感器，参数`(event, wx, wy, wz)`:
-    * `event` [SensorEvent](#sensors_sensorevent) 传感器事件，用于获取传感器数据变化时的所有信息
-    * `wx` {number} 绕x轴的角速度，单位弧度/s
-    * `wy` {number} 绕y轴的角速度，单位弧度/s
-    * `wz` {number} 绕z轴的角速度，单位弧度/s
-
-* `magnetic_field` 磁场传感器，参数`(event, bx, by, bz)`:
-    * `event` [SensorEvent](#sensors_sensorevent) 传感器事件，用于获取传感器数据变化时的所有信息
-    * `bx` {number} x轴上的磁场强度，单位uT
-    * `by` {number} y轴上的磁场强度，单位uT
-    * `bz` {number} z轴上的磁场强度，单位uT
-
-* `gravity` 重力传感器，参数`(event, gx, gy, gz)`:
-    * `event` [SensorEvent](#sensors_sensorevent) 传感器事件，用于获取传感器数据变化时的所有信息
-    * `gx` {number} x轴上的重力加速度，单位m/s^2
-    * `gy` {number} y轴上的重力加速度，单位m/s^2
-    * `gz` {number} z轴上的重力加速度，单位m/s^2
-
-* `linear_acceleration` 线性加速度传感器，参数`(event, ax, ay, az)`:
-    * `event` [SensorEvent](#sensors_sensorevent) 传感器事件，用于获取传感器数据变化时的所有信息
-    * `ax` {number} x轴上的线性加速度，单位m/s^2
-    * `ay` {number} y轴上的线性加速度，单位m/s^2
-    * `az` {number} z轴上的线性加速度，单位m/s^2
-
-* `ambient_temperature` 环境温度传感器，大部分设备并不支持，参数`(event, t)`:
-    * `event` [SensorEvent](#sensors_sensorevent) 传感器事件，用于获取传感器数据变化时的所有信息
-    * `t` {number} 环境温度，单位摄氏度。
-
-* `light` 光线传感器，参数`(event, light)`:
-    * `event` [SensorEvent](#sensors_sensorevent) 传感器事件，用于获取传感器数据变化时的所有信息
-    * `light` {number} 环境光强度，单位lux
-
-* `pressure` 压力传感器，参数`(event, p)`:
-    * `event` [SensorEvent](#sensors_sensorevent) 传感器事件，用于获取传感器数据变化时的所有信息
-    * `p` {number} 大气压，单位hPa
-
-* `proximity` 距离传感器，参数`(event, distance)`:
-    * `event` [SensorEvent](#sensors_sensorevent) 传感器事件，用于获取传感器数据变化时的所有信息
-    * `distance` {number} 一般指设备前置摄像头旁边的距离传感器到前方障碍物的距离，并且很多设备上这个值只有两种情况：当障碍物较近时该值为0，当障碍物较远或在范围内没有障碍物时该值为5
-
-* `relative_humidity` 湿度传感器，大部分设备并不支持，参数`(event, rh)`:
-    * `event` [SensorEvent](#sensors_sensorevent) 传感器事件，用于获取传感器数据变化时的所有信息
-    * `rh` {number} 相对湿度，范围为0~100（百分比）
+* `orientation` 方向传感器, 参数`(event, azimuth, pitch, roll)`:
+    * `event` [SensorEvent](#sensors_sensorevent) 传感器事件, 用于获取传感器数据变化时的所有信息
+    * `azimuth` {number} 方位角, 从地磁指北方向线起, 依顺时针方向到y轴之间的水平夹角, 单位角度, 范围0~359
+    * `pitch` {number} 绕x轴旋转的角度, 当设备水平放置时该值为0, 当设备顶部翘起时该值为正数, 当设备尾部翘起时该值为负数, 单位角度, 范围-180~180
+    * `roll` {number} 绕y轴顺时针旋转的角度, 单位角度, 范围-90~90
+
+* `gyroscope` 陀螺仪传感器, 参数`(event, wx, wy, wz)`:
+    * `event` [SensorEvent](#sensors_sensorevent) 传感器事件, 用于获取传感器数据变化时的所有信息
+    * `wx` {number} 绕x轴的角速度, 单位弧度/s
+    * `wy` {number} 绕y轴的角速度, 单位弧度/s
+    * `wz` {number} 绕z轴的角速度, 单位弧度/s
+
+* `magnetic_field` 磁场传感器, 参数`(event, bx, by, bz)`:
+    * `event` [SensorEvent](#sensors_sensorevent) 传感器事件, 用于获取传感器数据变化时的所有信息
+    * `bx` {number} x轴上的磁场强度, 单位uT
+    * `by` {number} y轴上的磁场强度, 单位uT
+    * `bz` {number} z轴上的磁场强度, 单位uT
+
+* `gravity` 重力传感器, 参数`(event, gx, gy, gz)`:
+    * `event` [SensorEvent](#sensors_sensorevent) 传感器事件, 用于获取传感器数据变化时的所有信息
+    * `gx` {number} x轴上的重力加速度, 单位m/s^2
+    * `gy` {number} y轴上的重力加速度, 单位m/s^2
+    * `gz` {number} z轴上的重力加速度, 单位m/s^2
+
+* `linear_acceleration` 线性加速度传感器, 参数`(event, ax, ay, az)`:
+    * `event` [SensorEvent](#sensors_sensorevent) 传感器事件, 用于获取传感器数据变化时的所有信息
+    * `ax` {number} x轴上的线性加速度, 单位m/s^2
+    * `ay` {number} y轴上的线性加速度, 单位m/s^2
+    * `az` {number} z轴上的线性加速度, 单位m/s^2
+
+* `ambient_temperature` 环境温度传感器, 大部分设备并不支持, 参数`(event, t)`:
+    * `event` [SensorEvent](#sensors_sensorevent) 传感器事件, 用于获取传感器数据变化时的所有信息
+    * `t` {number} 环境温度, 单位摄氏度.
+
+* `light` 光线传感器, 参数`(event, light)`:
+    * `event` [SensorEvent](#sensors_sensorevent) 传感器事件, 用于获取传感器数据变化时的所有信息
+    * `light` {number} 环境光强度, 单位lux
+
+* `pressure` 压力传感器, 参数`(event, p)`:
+    * `event` [SensorEvent](#sensors_sensorevent) 传感器事件, 用于获取传感器数据变化时的所有信息
+    * `p` {number} 大气压, 单位hPa
+
+* `proximity` 距离传感器, 参数`(event, distance)`:
+    * `event` [SensorEvent](#sensors_sensorevent) 传感器事件, 用于获取传感器数据变化时的所有信息
+    * `distance` {number} 一般指设备前置摄像头旁边的距离传感器到前方障碍物的距离, 并且很多设备上这个值只有两种情况：当障碍物较近时该值为0, 当障碍物较远或在范围内没有障碍物时该值为5
+
+* `relative_humidity` 湿度传感器, 大部分设备并不支持, 参数`(event, rh)`:
+    * `event` [SensorEvent](#sensors_sensorevent) 传感器事件, 用于获取传感器数据变化时的所有信息
+    * `rh` {number} 相对湿度, 范围为0~100（百分比）
 
 ## sensors.register(sensorName[, delay])
 
-* `sensorName` {string} 传感器名称，常用的传感器名称如上面所述
-* `delay` {number} 传感器数据更新频率，可选，默认为`sensors.delay.normal`。可用的值如下：
+* `sensorName` {string} 传感器名称, 常用的传感器名称如上面所述
+* `delay` {number} 传感器数据更新频率, 可选, 默认为`sensors.delay.normal`. 可用的值如下：
     * `sensors.delay.normal` 正常频率
     * `sensors.delay.ui` 适合于用户界面的更新频率
     * `sensors.delay.game` 适合于游戏的更新频率
     * `sensors.delay.fastest` 最快的更新频率】
 * 返回 [SensorEventEmiiter](#sensors_sensoreventemitter)
 
-注册一个传感器监听并返回[SensorEventEmitter](#sensors_sensoreventemitter)。
+注册一个传感器监听并返回[SensorEventEmitter](#sensors_sensoreventemitter).
 
 例如:
 
@@ -106,13 +111,13 @@ sensor.on("change", (gx, gy, gz)=>{
 });
 ```
 
-可以通过delay参数来指定传感器数据的更新频率，例如：
+可以通过delay参数来指定传感器数据的更新频率, 例如：
 
 ```
 var sensor = sensors.register("gravity", sensors.delay.game);
 ```
 
-另外，如果不支持`sensorName`所指定的传感器，那么该函数将返回`null`；但如果`sensors.ignoresUnsupportedSensor`的值被设置为`true`, 则该函数会返回一个不会分发任何传感器事件的[SensorEventEmitter](#sensors_sensoreventemitter)。
+另外, 如果不支持`sensorName`所指定的传感器, 那么该函数将返回`null`；但如果`sensors.ignoresUnsupportedSensor`的值被设置为`true`, 则该函数会返回一个不会分发任何传感器事件的[SensorEventEmitter](#sensors_sensoreventemitter).
 
 例如:
 
@@ -124,13 +129,13 @@ sensors.register("gravity").on("change", (gx, gy, gz)=>{
 });
 ```
 
-更多信息，参见[SensorEventEmitter](#sensors_sensoreventemitter)和[sensors.ignoresUnsupportedSensor](#sensors_sensors_ignoresUnsupportedSensor)。
+更多信息, 参见[SensorEventEmitter](#sensors_sensoreventemitter)和[sensors.ignoresUnsupportedSensor](#sensors_sensors_ignoresUnsupportedSensor).
 
 ## sensors.unregister(emitter)
 
 * `emiiter` [SensorEventEmitter](#sensors_sensoreventemitter)
 
-注销该传感器监听器。被注销的监听器将不再能监听传感器数据。
+注销该传感器监听器. 被注销的监听器将不再能监听传感器数据.
 
 ```
 //注册一个传感器监听器
@@ -146,13 +151,13 @@ setTimeout(()=> {
 
 ## sensors.unregisterAll()
 
-注销所有传感器监听器。
+注销所有传感器监听器.
 
 ## sensors.ignoresUnsupportedSensor
 
 * {boolean}
 
-表示是否忽略不支持的传感器。如果该值被设置为`true`，则函数`sensors.register()`即使对不支持的传感器也会返回一个无任何数据的虚拟传感器监听，也就是`sensors.register()`不会返回`null`从而避免非空判断，并且此时会触发`sensors`的"unsupported_sensor"事件。
+表示是否忽略不支持的传感器. 如果该值被设置为`true`, 则函数`sensors.register()`即使对不支持的传感器也会返回一个无任何数据的虚拟传感器监听, 也就是`sensors.register()`不会返回`null`从而避免非空判断, 并且此时会触发`sensors`的"unsupported_sensor"事件.
 
 ```
 //忽略不支持的传感器
@@ -161,7 +166,7 @@ sensors.ignoresUnsupportedSensor = true;
 sensors.on("unsupported_sensor", function(sensorName){
     toastLog("不支持的传感器: " + sensorName);
 });
-//随便注册一个不存在的传感器。
+//随便注册一个不存在的传感器.
 log(sensors.register("aaabbb"));
 ```
 
@@ -169,19 +174,19 @@ log(sensors.register("aaabbb"));
 
 * `sensorName` {string} 不支持的传感器名称
 
-当`sensors.ignoresUnsupportedSensor`被设置为`true`并且有不支持的传感器被注册时触发该事件。事件参数的传感器名称。
+当`sensors.ignoresUnsupportedSensor`被设置为`true`并且有不支持的传感器被注册时触发该事件. 事件参数的传感器名称.
 
 # SensorEventEmitter
 
-注册传感器返回的对象，其本身是一个EventEmmiter，用于监听传感器事件。
+注册传感器返回的对象, 其本身是一个EventEmmiter, 用于监听传感器事件.
 
 ## 事件: 'change'
 
 * `..args` {Any} 传感器参数
 
-当传感器数据改变时触发该事件；该事件触发的最高频繁由`sensors.register()`指定的delay参数决定。
+当传感器数据改变时触发该事件；该事件触发的最高频繁由`sensors.register()`指定的delay参数决定.
 
-事件参数根据传感器类型不同而不同，具体参见本章最前面的列表。
+事件参数根据传感器类型不同而不同, 具体参见本章最前面的列表.
 
 一个监听光线传感器和加速度传感器并且每0.5秒获取一个数据并最终写入一个csv表格文件的例子如下：
 
@@ -225,11 +230,11 @@ setTimeout(()=>{
 
 ## 事件: 'accuracy_change'
 
-* `accuracy` {number} 表示传感器精度。为以下值之一:
+* `accuracy` {number} 表示传感器精度. 为以下值之一:
     * -1 传感器未连接
     * 0 传感器不可读
     * 1 低精度
     * 2 中精度
     * 3 高精度
 
-当传感器精度改变时会触发的事件。比较少用。
+当传感器精度改变时会触发的事件. 比较少用.
diff --git a/api/shell.md b/api/shell.md
index b69e06d..e1678d6 100644
--- a/api/shell.md
+++ b/api/shell.md
@@ -1,26 +1,33 @@
-shell即Unix Shell，在类Unix系统提供与操作系统交互的一系列命令。
+# Shell
+
+---
+
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
+
+---
 
-很多程序可以用来执行shell命令，例如终端模拟器。
+shell即Unix Shell, 在类Unix系统提供与操作系统交互的一系列命令.
 
-在Auto.js大致等同于用adb执行命令"adb shell"。其实现包括两种方式：
+很多程序可以用来执行shell命令, 例如终端模拟器.
+
+在Auto.js大致等同于用adb执行命令"adb shell". 其实现包括两种方式：
 
 * 通过`java.lang.Runtime.exec`执行(shell, Tap, Home等函数)
 * 通过内嵌终端模拟器执行(RootAutomator, Shell等对象)
 
 # shell函数
 
-> Stability: 2 - Stable
-
 ## shell(cmd[, root])
 
 * cmd {string} 要执行的命令
-* root {Boolean} 是否以root权限运行，默认为false。
+* root {Boolean} 是否以root权限运行, 默认为false.
 
-一次性执行命令cmd, 并返回命令的执行结果。返回对象的其属性如下:
+一次性执行命令cmd, 并返回命令的执行结果. 返回对象的其属性如下:
 
-* code {number} 返回码。执行成功时为0，失败时为非0的数字。
+* code {number} 返回码. 执行成功时为0, 失败时为非0的数字.
 * result {string} 运行结果(stdout输出结果)
-* error {string} 运行的错误信息(stderr输出结果)。例如执行需要root权限的命令但没有授予root权限会返回错误信息"Permission denied"。
+* error {string} 运行的错误信息(stderr输出结果). 例如执行需要root权限的命令但没有授予root权限会返回错误信息"Permission denied".
 
 示例(强制停止微信) ：
 
@@ -37,15 +44,13 @@ if(result.code == 0){
 
 # Shell
 
-> Stability: 2 - Stable
-
-shell函数通过用来一次性执行单条命令并获取结果。如果有多条命令需要执行，用Shell对象的效率更高。这是因为，每次运行shell函数都会打开一个单独的shell进程并在运行结束后关闭他，这个过程需要一定的时间；而Shell对象自始至终使用同一个shell进程。
+shell函数通过用来一次性执行单条命令并获取结果. 如果有多条命令需要执行, 用Shell对象的效率更高. 这是因为, 每次运行shell函数都会打开一个单独的shell进程并在运行结束后关闭他, 这个过程需要一定的时间；而Shell对象自始至终使用同一个shell进程.
 
 ## new Shell(root)
 
-* root {Boolean} 是否以root权限运行一个shell进程，默认为false。这将会影响其后使用该Shell对象执行的命令的权限
+* root {Boolean} 是否以root权限运行一个shell进程, 默认为false. 这将会影响其后使用该Shell对象执行的命令的权限
 
-Shell对象的"构造函数"。
+Shell对象的"构造函数".
 
 ```
 var sh = new Shell(true);
@@ -58,30 +63,30 @@ sh.exit();
 
 * `cmd` {string} 要执行的命令
 
-执行命令cmd。该函数不会返回任何值。
+执行命令cmd. 该函数不会返回任何值.
 
-注意，命令执行是"异步"的、非阻塞的。也就是不会等待命令完成后才继续向下执行。
+注意, 命令执行是"异步"的、非阻塞的. 也就是不会等待命令完成后才继续向下执行.
 
-尽管这样的设计使用起来有很多不便之处，但受限于终端模拟器，暂时没有解决方式；如果后续能找到解决方案，则将提供`Shell.execAndWaitFor`函数。
+尽管这样的设计使用起来有很多不便之处, 但受限于终端模拟器, 暂时没有解决方式；如果后续能找到解决方案, 则将提供`Shell.execAndWaitFor`函数.
 
 ## Shell.exit()
 
-直接退出shell。正在执行的命令会被强制退出。
+直接退出shell. 正在执行的命令会被强制退出.
 
 ## Shell.exitAndWaitFor()
 
-执行"exit"命令并等待执行命令执行完成、退出shell。
+执行"exit"命令并等待执行命令执行完成、退出shell.
 
-此函数会执行exit命令来正常退出shell。
+此函数会执行exit命令来正常退出shell.
 
 ## Shell.setCallback(callback)
 
 * callback {Object} 回调函数
 
-设置该Shell的回调函数，以便监听Shell的输出。可以包括以下属性：
+设置该Shell的回调函数, 以便监听Shell的输出. 可以包括以下属性：
 
-* onOutput {Function} 每当shell有新的输出时便会调用该函数。其参数是一个字符串。
-* onNewLine {Function} 每当shell有新的一行输出时便会调用该函数。其参数是一个字符串(不包括最后的换行符)。
+* onOutput {Function} 每当shell有新的输出时便会调用该函数. 其参数是一个字符串.
+* onNewLine {Function} 每当shell有新的一行输出时便会调用该函数. 其参数是一个字符串(不包括最后的换行符).
 
 例如:
 
@@ -95,7 +100,7 @@ sh.setCallback({
 })
 while(true){
 	//循环输入命令
-	var cmd = dialogs.rawInput("请输入要执行的命令，输入exit退出");
+	var cmd = dialogs.rawInput("请输入要执行的命令, 输入exit退出");
 	if(cmd == "exit"){
 		break;
 	}
@@ -107,105 +112,105 @@ sh.exit();
 
 # 附录: shell命令简介
 
-以下关于shell命令的资料来自[AndroidStudio用户指南：Shell命令](https://developer.android.com/studio/command-line/adb.html#shellcommands)。
+以下关于shell命令的资料来自[AndroidStudio用户指南：Shell命令](https://developer.android.com/studio/command-line/adb.html#shellcommands/).
 
 ## am命令
 
-am命令即Activity Manager命令，用于管理应用程序活动、服务等。
+am命令即Activity Manager命令, 用于管理应用程序活动、服务等.
 
-**以下命令均以"am "开头，例如`shell('am start -p com.tencent.mm');`(启动微信)**
+**以下命令均以"am "开头, 例如`shell('am start -p com.tencent.mm');`(启动微信)**
 
 ### start [options] intent
 
-启动 intent 指定的 Activity(应用程序活动)。  
-请参阅 [intent 参数的规范](#shell_intent)。
+启动 intent 指定的 Activity(应用程序活动).   
+请参阅 [intent 参数的规范](#shell_intent).
 
 选项包括：
 
-* -D：启用调试。
-* -W：等待启动完成。
-* --start-profiler file：启动分析器并将结果发送到 file。
-* -P file：类似于 --start-profiler，但当应用进入空闲状态时分析停止。
-* -R count：重复 Activity 启动 count 次数。在每次重复前，将完成顶部 Activity。
-* -S：启动 Activity 前强行停止目标应用。
-* --opengl-trace：启用 OpenGL 函数的跟踪。
-* --user user_id | current：指定要作为哪个用户运行；如果未指定，则作为当前用户运行。
+* -D：启用调试.
+* -W：等待启动完成.
+* --start-profiler file：启动分析器并将结果发送到 file.
+* -P file：类似于 --start-profiler, 但当应用进入空闲状态时分析停止.
+* -R count：重复 Activity 启动 count 次数. 在每次重复前, 将完成顶部 Activity.
+* -S：启动 Activity 前强行停止目标应用.
+* --opengl-trace：启用 OpenGL 函数的跟踪.
+* --user user_id | current：指定要作为哪个用户运行；如果未指定, 则作为当前用户运行.
 
 ### startservice [options] intent
 
-启动 intent 指定的 Service(服务)。  
-请参阅 [intent 参数的规范](#shell_intent)。  
+启动 intent 指定的 Service(服务).   
+请参阅 [intent 参数的规范](#shell_intent).   
 选项包括：
 
-* --user user_id | current：指定要作为哪个用户运行；如果未指定，则作为当前用户运行。
+* --user user_id | current：指定要作为哪个用户运行；如果未指定, 则作为当前用户运行.
 
 ### force-stop package
 
-强行停止与 package（[应用包名](#应用包名)）关联的所有应用。
+强行停止与 package（[应用包名](#应用包名)）关联的所有应用.
 
 ### kill [options] package
 
-终止与 package（[应用包名](#应用包名)）关联的所有进程。此命令仅终止可安全终止且不会影响用户体验的进程。  
+终止与 package（[应用包名](#应用包名)）关联的所有进程. 此命令仅终止可安全终止且不会影响用户体验的进程.   
 选项包括：
 
-* --user user_id | all | current：指定将终止其进程的用户；如果未指定，则终止所有用户的进程。
+* --user user_id | all | current：指定将终止其进程的用户；如果未指定, 则终止所有用户的进程.
 
 ### kill-all
 
-终止所有后台进程。
+终止所有后台进程.
 
 ### broadcast [options] intent
 
-发出广播 intent。
-请参阅 [intent 参数的规范](#shell_intent)。
+发出广播 intent.
+请参阅 [intent 参数的规范](#shell_intent).
 
 选项包括：
 
-* [--user user_id | all | current]：指定要发送到的用户；如果未指定，则发送到所有用户。
+* [--user user_id | all | current]：指定要发送到的用户；如果未指定, 则发送到所有用户.
 
 ### instrument [options] component
 
-使用 Instrumentation 实例启动监控。通常，目标 component 是表单 test_package/runner_class。  
+使用 Instrumentation 实例启动监控. 通常, 目标 component 是表单 test_package/runner_class.   
 选项包括：
 
-* -r：输出原始结果（否则对 report_key_streamresult 进行解码）。与 [-e perf true] 结合使用以生成性能测量的原始输出。
-* -e name value：将参数 name 设为 value。对于测试运行器，通用表单为 -e testrunner_flag value[,value...]。
-* -p file：将分析数据写入 file。
-* -w：先等待仪器完成，然后再返回。测试运行器需要使用此选项。
-* --no-window-animation：运行时关闭窗口动画。
-* --user user_id | current：指定仪器在哪个用户中运行；如果未指定，则在当前用户中运行。
-* profile start process file 启动 process 的分析器，将结果写入 file。
-* profile stop process 停止 process 的分析器。
+* -r：输出原始结果（否则对 report_key_streamresult 进行解码）. 与 [-e perf true] 结合使用以生成性能测量的原始输出.
+* -e name value：将参数 name 设为 value. 对于测试运行器, 通用表单为 -e testrunner_flag value[,value...].
+* -p file：将分析数据写入 file.
+* -w：先等待仪器完成, 然后再返回. 测试运行器需要使用此选项.
+* --no-window-animation：运行时关闭窗口动画.
+* --user user_id | current：指定仪器在哪个用户中运行；如果未指定, 则在当前用户中运行.
+* profile start process file 启动 process 的分析器, 将结果写入 file.
+* profile stop process 停止 process 的分析器.
 
 ### dumpheap [options] process file
 
-转储 process 的堆，写入 file。
+转储 process 的堆, 写入 file.
 
 选项包括：
 
-* --user [user_id|current]：提供进程名称时，指定要转储的进程用户；如果未指定，则使用当前用户。
-* -n：转储原生堆，而非托管堆。
-* set-debug-app [options] package 将应用 package 设为调试。
+* --user [user_id|current]：提供进程名称时, 指定要转储的进程用户；如果未指定, 则使用当前用户.
+* -n：转储原生堆, 而非托管堆.
+* set-debug-app [options] package 将应用 package 设为调试.
 
 选项包括：
 
-* -w：应用启动时等待调试程序。
-* --persistent：保留此值。
-* clear-debug-app 使用 set-debug-app 清除以前针对调试用途设置的软件包。
+* -w：应用启动时等待调试程序.
+* --persistent：保留此值.
+* clear-debug-app 使用 set-debug-app 清除以前针对调试用途设置的软件包.
 
-### monitor [options]    启动对崩溃或 ANR 的监控。
+### monitor [options]    启动对崩溃或 ANR 的监控.
 
 选项包括：
 
-* --gdb：在崩溃/ANR 时在给定端口上启动 gdbserv。
+* --gdb：在崩溃/ANR 时在给定端口上启动 gdbserv.
 
 ### screen-compat {on|off} package
 
-控制 package 的屏幕兼容性模式。
+控制 package 的屏幕兼容性模式.
 
 ### display-size [reset|widthxheight]
 
-替换模拟器/设备显示尺寸。此命令对于在不同尺寸的屏幕上测试您的应用非常有用，它支持使用大屏设备模仿小屏幕分辨率（反之亦然）。  
+替换模拟器/设备显示尺寸. 此命令对于在不同尺寸的屏幕上测试您的应用非常有用, 它支持使用大屏设备模仿小屏幕分辨率（反之亦然）.   
 示例：
 
 ```
@@ -215,7 +220,7 @@ shell("am display-size 1280x800", true);
 
 ### display-density dpi
 
-替换模拟器/设备显示密度。此命令对于在不同密度的屏幕上测试您的应用非常有用，它支持使用低密度屏幕在高密度环境环境上进行测试（反之亦然）。  
+替换模拟器/设备显示密度. 此命令对于在不同密度的屏幕上测试您的应用非常有用, 它支持使用低密度屏幕在高密度环境环境上进行测试（反之亦然）.   
 示例：
 
 ```
@@ -224,256 +229,256 @@ shell("am display-density 480", true);
 
 ### to-uri intent
 
-将给定的 intent 规范以 URI 的形式输出。
-请参阅  [intent 参数的规范](#shell_intent)。
+将给定的 intent 规范以 URI 的形式输出.
+请参阅  [intent 参数的规范](#shell_intent).
 
 ### to-intent-uri intent
 
-将给定的 intent 规范以 intent:URI 的形式输出。
-请参阅 intent 参数的规范。
+将给定的 intent 规范以 intent:URI 的形式输出.
+请参阅 intent 参数的规范.
 
 ### intent参数的规范
 
-对于采用 intent 参数的 am 命令，您可以使用以下选项指定 intent：
+对于采用 intent 参数的 am 命令, 您可以使用以下选项指定 intent：
 
 * -a action  
-  指定 intent 操作，如“android.intent.action.VIEW”。此指定只能声明一次。
+  指定 intent 操作, 如“android.intent.action.VIEW”. 此指定只能声明一次.
 * -d data_uri  
-  指定 intent 数据 URI，如“content://contacts/people/1”。此指定只能声明一次。
+  指定 intent 数据 URI, 如“content://contacts/people/1”. 此指定只能声明一次.
 * -t mime_type  
-  指定 intent MIME 类型，如“image/png”。此指定只能声明一次。
+  指定 intent MIME 类型, 如“image/png”. 此指定只能声明一次.
 * -c category  
-  指定 intent 类别，如“android.intent.category.APP_CONTACTS”。
+  指定 intent 类别, 如“android.intent.category.APP_CONTACTS”.
 * -n component  
-  指定带有软件包名称前缀的组件名称以创建显式 intent，如“com.example.app/.ExampleActivity”。
+  指定带有软件包名称前缀的组件名称以创建显式 intent, 如“com.example.app/.ExampleActivity”.
 * -f flags  
-  将标志添加到 setFlags() 支持的 intent。
+  将标志添加到 setFlags() 支持的 intent.
 * --esn extra_key  
-  添加一个 null extra。URI intent 不支持此选项。
+  添加一个 null extra. URI intent 不支持此选项.
 * -e|--es extra_key extra_string_value  
-  添加字符串数据作为键值对。
+  添加字符串数据作为键值对.
 * --ez extra_key extra_boolean_value  
-  添加布尔型数据作为键值对。
+  添加布尔型数据作为键值对.
 * --ei extra_key extra_int_value  
-  添加整数型数据作为键值对。
+  添加整数型数据作为键值对.
 * --el extra_key extra_long_value  
-  添加长整型数据作为键值对。
+  添加长整型数据作为键值对.
 * --ef extra_key extra_float_value  
-  添加浮点型数据作为键值对。
+  添加浮点型数据作为键值对.
 * --eu extra_key extra_uri_value  
-  添加 URI 数据作为键值对。
+  添加 URI 数据作为键值对.
 * --ecn extra_key extra_component_name_value  
-  添加组件名称，将其作为 ComponentName 对象进行转换和传递。
+  添加组件名称, 将其作为 ComponentName 对象进行转换和传递.
 * --eia extra_key extra_int_value[,extra_int_value...]  
-  添加整数数组。
+  添加整数数组.
 * --ela extra_key extra_long_value[,extra_long_value...]  
-  添加长整型数组。
+  添加长整型数组.
 * --efa extra_key extra_float_value[,extra_float_value...]  
-  添加浮点型数组。
+  添加浮点型数组.
 * --grant-read-uri-permission  
-  包含标志 FLAG_GRANT_READ_URI_PERMISSION。
+  包含标志 FLAG_GRANT_READ_URI_PERMISSION.
 * --grant-write-uri-permission  
-  包含标志 FLAG_GRANT_WRITE_URI_PERMISSION。
+  包含标志 FLAG_GRANT_WRITE_URI_PERMISSION.
 * --debug-log-resolution  
-  包含标志 FLAG_DEBUG_LOG_RESOLUTION。
+  包含标志 FLAG_DEBUG_LOG_RESOLUTION.
 * --exclude-stopped-packages  
-  包含标志 FLAG_EXCLUDE_STOPPED_PACKAGES。
+  包含标志 FLAG_EXCLUDE_STOPPED_PACKAGES.
 * --include-stopped-packages  
-  包含标志 FLAG_INCLUDE_STOPPED_PACKAGES。
+  包含标志 FLAG_INCLUDE_STOPPED_PACKAGES.
 * --activity-brought-to-front  
-  包含标志 FLAG_ACTIVITY_BROUGHT_TO_FRONT。
+  包含标志 FLAG_ACTIVITY_BROUGHT_TO_FRONT.
 * --activity-clear-top  
-  包含标志 FLAG_ACTIVITY_CLEAR_TOP。
+  包含标志 FLAG_ACTIVITY_CLEAR_TOP.
 * --activity-clear-when-task-reset  
-  包含标志 FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET。
+  包含标志 FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET.
 * --activity-exclude-from-recents  
-  包含标志 FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS。
+  包含标志 FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS.
 * --activity-launched-from-history  
-  包含标志 FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY。
+  包含标志 FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY.
 * --activity-multiple-task  
-  包含标志 FLAG_ACTIVITY_MULTIPLE_TASK。
+  包含标志 FLAG_ACTIVITY_MULTIPLE_TASK.
 * --activity-no-animation  
-  包含标志 FLAG_ACTIVITY_NO_ANIMATION。
+  包含标志 FLAG_ACTIVITY_NO_ANIMATION.
 * --activity-no-history  
-  包含标志 FLAG_ACTIVITY_NO_HISTORY。
+  包含标志 FLAG_ACTIVITY_NO_HISTORY.
 * --activity-no-user-action  
-  包含标志 FLAG_ACTIVITY_NO_USER_ACTION。
+  包含标志 FLAG_ACTIVITY_NO_USER_ACTION.
 * --activity-previous-is-top  
-  包含标志 FLAG_ACTIVITY_PREVIOUS_IS_TOP。
+  包含标志 FLAG_ACTIVITY_PREVIOUS_IS_TOP.
 * --activity-reorder-to-front  
-  包含标志 FLAG_ACTIVITY_REORDER_TO_FRONT。
+  包含标志 FLAG_ACTIVITY_REORDER_TO_FRONT.
 * --activity-reset-task-if-needed  
-  包含标志 FLAG_ACTIVITY_RESET_TASK_IF_NEEDED。
+  包含标志 FLAG_ACTIVITY_RESET_TASK_IF_NEEDED.
 * --activity-single-top  
-  包含标志 FLAG_ACTIVITY_SINGLE_TOP。
+  包含标志 FLAG_ACTIVITY_SINGLE_TOP.
 * --activity-clear-task  
-  包含标志 FLAG_ACTIVITY_CLEAR_TASK。
+  包含标志 FLAG_ACTIVITY_CLEAR_TASK.
 * --activity-task-on-home  
-  包含标志 FLAG_ACTIVITY_TASK_ON_HOME。
+  包含标志 FLAG_ACTIVITY_TASK_ON_HOME.
 * --receiver-registered-only  
-  包含标志 FLAG_RECEIVER_REGISTERED_ONLY。
+  包含标志 FLAG_RECEIVER_REGISTERED_ONLY.
 * --receiver-replace-pending  
-  包含标志 FLAG_RECEIVER_REPLACE_PENDING。
+  包含标志 FLAG_RECEIVER_REPLACE_PENDING.
 * --selector  
-  需要使用 -d 和 -t 选项以设置 intent 数据和类型。
+  需要使用 -d 和 -t 选项以设置 intent 数据和类型.
 
 #### URI component package
 
-如果不受上述某一选项的限制，您可以直接指定 URI、软件包名称和组件名称。当参数不受限制时，如果参数包含一个“:”（冒号），则此工具假定参数是一个 URI；如果参数包含一个“/”（正斜杠），则此工具假定参数是一个组件名称；否则，此工具假定参数是一个软件包名称。
+如果不受上述某一选项的限制, 您可以直接指定 URI、软件包名称和组件名称. 当参数不受限制时, 如果参数包含一个“:”（冒号）, 则此工具假定参数是一个 URI；如果参数包含一个“/”（正斜杠）, 则此工具假定参数是一个组件名称；否则, 此工具假定参数是一个软件包名称.
 
 ## 应用包名
 
-所谓应用包名，是唯一确定应用的标识。例如微信的包名是"com.tencent.mm", QQ的包名是"com.tencent.mobileqq"。  
-要获取一个应用的包名，可以通过函数`getPackageName(appName)`获取。参见帮助->其他一般函数。
+所谓应用包名, 是唯一确定应用的标识. 例如微信的包名是"com.tencent.mm", QQ的包名是"com.tencent.mobileqq".   
+要获取一个应用的包名, 可以通过函数`getPackageName(appName)`获取. 参见帮助->其他一般函数.
 
 ## pm命令
 
-pm命令用于管理应用程序，例如卸载应用、冻结应用等。  
-**以下命令均以"pm "开头，例如"shell(\"pm disable com.tencent.mm\");"(冻结微信)**
+pm命令用于管理应用程序, 例如卸载应用、冻结应用等.   
+**以下命令均以"pm "开头, 例如"shell(\"pm disable com.tencent.mm\");"(冻结微信)**
 
 ### list packages [options] filter
 
-输出所有软件包，或者，仅输出包名称包含 filter 中的文本的软件包。  
+输出所有软件包, 或者, 仅输出包名称包含 filter 中的文本的软件包.   
 选项：
 
-* -f：查看它们的关联文件。
-* -d：进行过滤以仅显示已停用的软件包。
-* -e：进行过滤以仅显示已启用的软件包。
-* -s：进行过滤以仅显示系统软件包。
-* -3：进行过滤以仅显示第三方软件包。
-* -i：查看软件包的安装程序。
-* -u：也包括卸载的软件包。
-* --user user_id：要查询的用户空间。
+* -f：查看它们的关联文件.
+* -d：进行过滤以仅显示已停用的软件包.
+* -e：进行过滤以仅显示已启用的软件包.
+* -s：进行过滤以仅显示系统软件包.
+* -3：进行过滤以仅显示第三方软件包.
+* -i：查看软件包的安装程序.
+* -u：也包括卸载的软件包.
+* --user user_id：要查询的用户空间.
 
 ### list permission-groups
 
-输出所有已知的权限组。
+输出所有已知的权限组.
 
 ### list permissions [options] group
 
-输出所有已知权限，或者，仅输出 group 中的权限。  
+输出所有已知权限, 或者, 仅输出 group 中的权限.   
 选项：
 
-* -g：按组加以组织。
-* -f：输出所有信息。
-* -s：简短摘要。
-* -d：仅列出危险权限。
-* -u：仅列出用户将看到的权限。
+* -g：按组加以组织.
+* -f：输出所有信息.
+* -s：简短摘要.
+* -d：仅列出危险权限.
+* -u：仅列出用户将看到的权限.
 
 ### list instrumentation [options]
 
-列出所有测试软件包。  
+列出所有测试软件包.   
 选项：
 
-* -f：列出用于测试软件包的 APK 文件。
-* target_package：列出仅用于此应用的测试软件包。
+* -f：列出用于测试软件包的 APK 文件.
+* target_package：列出仅用于此应用的测试软件包.
 
 ### list features
 
-输出系统的所有功能。
+输出系统的所有功能.
 
 ### list libraries
 
-输出当前设备支持的所有库。
+输出当前设备支持的所有库.
 
 ### list users
 
-输出系统上的所有用户。
+输出系统上的所有用户.
 
 ### path package
 
-输出给定 package 的 APK 的路径。
+输出给定 package 的 APK 的路径.
 
 ### install [options] path
 
-将软件包（通过 path 指定）安装到系统。  
+将软件包（通过 path 指定）安装到系统.   
 选项：
 
-* -l：安装具有转发锁定功能的软件包。
-* -r：重新安装现有应用，保留其数据。
-* -t：允许安装测试 APK。
-* -i installer_package_name：指定安装程序软件包名称。
-* -s：在共享的大容量存储（如 sdcard）上安装软件包。
-* -f：在内部系统内存上安装软件包。
-* -d：允许版本代码降级。
-* -g：授予应用清单文件中列出的所有权限。
+* -l：安装具有转发锁定功能的软件包.
+* -r：重新安装现有应用, 保留其数据.
+* -t：允许安装测试 APK.
+* -i installer_package_name：指定安装程序软件包名称.
+* -s：在共享的大容量存储（如 sdcard）上安装软件包.
+* -f：在内部系统内存上安装软件包.
+* -d：允许版本代码降级.
+* -g：授予应用清单文件中列出的所有权限.
 
 ### uninstall [options] package
 
-从系统中卸载软件包。  
+从系统中卸载软件包.   
 选项：
 
-* -k：移除软件包后保留数据和缓存目录。
+* -k：移除软件包后保留数据和缓存目录.
 
 ### clear package
 
-删除与软件包关联的所有数据。
+删除与软件包关联的所有数据.
 
 ### enable package_or_component
 
-启用给定软件包或组件（作为“package/class”写入）。
+启用给定软件包或组件（作为“package/class”写入）.
 
 ### disable package_or_component
 
-停用给定软件包或组件（作为“package/class”写入）。
+停用给定软件包或组件（作为“package/class”写入）.
 
 ### disable-user [options] package_or_component
 
 选项：
 
-* --user user_id：要停用的用户。
+* --user user_id：要停用的用户.
 
 ### grant package_name permission
 
-向应用授予权限。在运行 Android 6.0（API 级别 23）及更高版本的设备上，可以是应用清单中声明的任何权限。在运行 Android 5.1（API 级别 22）和更低版本的设备上，必须是应用定义的可选权限。
+向应用授予权限. 在运行 Android 6.0（API 级别 23）及更高版本的设备上, 可以是应用清单中声明的任何权限. 在运行 Android 5.1（API 级别 22）和更低版本的设备上, 必须是应用定义的可选权限.
 
 ### revoke package_name permission
 
-从应用中撤销权限。在运行 Android 6.0（API 级别 23）及更高版本的设备上，可以是应用清单中声明的任何权限。在运行 Android 5.1（API 级别 22）和更低版本的设备上，必须是应用定义的可选权限。
+从应用中撤销权限. 在运行 Android 6.0（API 级别 23）及更高版本的设备上, 可以是应用清单中声明的任何权限. 在运行 Android 5.1（API 级别 22）和更低版本的设备上, 必须是应用定义的可选权限.
 
 ### set-install-location location
 
-更改默认安装位置。位置值：
+更改默认安装位置. 位置值：
 
-* 0：自动—让系统决定最佳位置。
-* 1：内部—安装在内部设备存储上。
-* 2：外部—安装在外部介质上。
+* 0：自动—让系统决定最佳位置.
+* 1：内部—安装在内部设备存储上.
+* 2：外部—安装在外部介质上.
 
-> 注：此命令仅用于调试目的；使用此命令会导致应用中断和其他意外行为。
+> 注：此命令仅用于调试目的；使用此命令会导致应用中断和其他意外行为.
 
 ### get-install-location
 
-返回当前安装位置。返回值：
+返回当前安装位置. 返回值：
 
-* 0 [auto]：让系统决定最佳位置。
+* 0 [auto]：让系统决定最佳位置.
 * 1 [internal]：安装在内部设备存储上
 * 2 [external]：安装在外部介质上
 
 ### set-permission-enforced permission [true|false]
 
-指定是否应强制执行给定的权限。
+指定是否应强制执行给定的权限.
 
 ### trim-caches desired_free_space
 
-减少缓存文件以达到给定的可用空间。
+减少缓存文件以达到给定的可用空间.
 
 ### create-user user_name
 
-使用给定的 user_name 创建新用户，输出新用户的标识符。
+使用给定的 user_name 创建新用户, 输出新用户的标识符.
 
 ### remove-user user_id
 
-移除具有给定的 user_id 的用户，删除与该用户关联的所有数据。
+移除具有给定的 user_id 的用户, 删除与该用户关联的所有数据.
 
 ### get-max-users
 
-输出设备支持的最大用户数。
+输出设备支持的最大用户数.
 
 ## 其他命令
 
 ### 进行屏幕截图
 
-screencap 命令是一个用于对设备显示屏进行屏幕截图的 shell 实用程序。在 shell 中，此语法为：
+screencap 命令是一个用于对设备显示屏进行屏幕截图的 shell 实用程序. 在 shell 中, 此语法为：
 
 ```
 screencap filename
diff --git a/api/sidebar.md b/api/sidebar.md
new file mode 100644
index 0000000..548e9ad
--- /dev/null
+++ b/api/sidebar.md
@@ -0,0 +1,76 @@
+* [Overview - 综述](overview)
+* [About - 关于文档](documentation)
+* [Progress - 部署进度](progress)
+* [Changelog - 更新日志](changelog)
+* [Q & A - 疑难解答](qa)
+
+* &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash;
+
+* [Global - 全局对象](global)
+* [Automator - 自动化](automator)
+* [AutoJs6 - 本体应用](autojs)
+* [App - 通用应用](app)
+* [Color - 颜色](color)
+* [Image - 图像](image)
+* [Keys - 按键](keys)
+* [Device - 设备](device)
+* [Storage - 储存](storages)
+* [File - 文件](files)
+* [Engine - 引擎](engines)
+* [Task - 任务](tasks)
+* [Module - 模块](modules)
+* [Plugins - 插件](plugins)
+* [Console - 控制台](console)
+* [Shell](shell)
+* [Media - 多媒体](media)
+* [Sensor - 传感器](sensors)
+* [Recorder - 记录器](recorder)
+* [Timer - 定时器](timers)
+* [Thread - 线程](threads)
+* [Continuation - 协程](continuation)
+* [Event - 事件监听](events)
+* [Dialog - 对话框](dialogs)
+* [Floaty - 悬浮窗](floaty)
+* [Canvas - 画布](canvas)
+* [UI - 用户界面](ui)
+* [Web - 万维网](web)
+* [HTTP](http)
+* [Base64](base64)
+* [Crypto - 密文](crypto)
+* [Internationalization - 国际化](i18n)
+* [E4X](e4x)
+
+* &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash;
+
+* [Glossaries - 术语](glossaries)
+* [Exceptions - 异常](exceptions)
+* [Intent - 意图](intentType)
+* [Runtime - 运行时](runtime)
+* [Context - 上下文](context)
+* [Activity - 活动](activity)
+
+* &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash;
+
+* [Data Types - 数据类型](dataTypes)
+* [UiSelector - 选择器](uiSelectorType)
+* [UiObject - 控件节点](uiObjectType)
+* [UiObjectCollection - 控件集合](uiObjectCollectionType)
+* [UiObjectActions - 控件节点行为](uiObjectActionsType)
+* [App - 应用枚举类](appType)
+
+* &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash;
+
+* [Polyfill - 代码填泥](polyfill)
+* [Arrayx - Array 扩展](arrayx)
+* [Numberx - Number 扩展](numberx)
+* [Mathx - Math 扩展](mathx)
+
+* &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash;
+
+* [Scripting Java - 脚本化 Java](scriptingJava)
+* [Android API Level - 安卓 API 级别](apiLevel)
+
+* &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash; &ndash;
+
+* [GitHub - 应用项目地址](https://github.com/SuperMonster003/AutoJs6/)
+* [GitHub - 文档项目地址](https://github.com/SuperMonster003/AutoJs6-Documentation)
\ No newline at end of file
diff --git a/api/static/docsify-config.js b/api/static/docsify-config.js
new file mode 100644
index 0000000..4c5aae0
--- /dev/null
+++ b/api/static/docsify-config.js
@@ -0,0 +1,17 @@
+window.$docsify = {
+    name: 'AutoJs6',
+    repo: 'SuperMonster003/AutoJs6-Documentation',
+    notFoundPage: true,
+    loadSidebar: true,
+    subMaxLevel: 3,
+    coverpage: true,
+    loadNavbar: true,
+    auto2top: true,
+    homepage: 'overview.md',
+    search: {
+        maxAge: 86400000, // Expiration time, the default one day
+        paths: 'auto',
+        placeholder: '搜索文档',
+        noData: '无搜索结果',
+    },
+};
\ No newline at end of file
diff --git a/api/static/docsify.js b/api/static/docsify.js
new file mode 100644
index 0000000..92864eb
--- /dev/null
+++ b/api/static/docsify.js
@@ -0,0 +1,9719 @@
+(function () {
+    /**
+     * Create a cached version of a pure function.
+     * @param {*} fn The function call to be cached
+     * @void
+     */
+
+    function cached(fn) {
+        var cache = Object.create(null);
+        return function (str) {
+            var key = isPrimitive(str) ? str : JSON.stringify(str);
+            var hit = cache[key];
+            return hit || (cache[key] = fn(str));
+        };
+    }
+
+    /**
+     * Hyphenate a camelCase string.
+     */
+    var hyphenate = cached(function (str) {
+        return str.replace(/([A-Z])/g, function (m) {
+            return '-' + m.toLowerCase();
+        });
+    });
+
+    var hasOwn = Object.prototype.hasOwnProperty;
+
+    /**
+     * Simple Object.assign polyfill
+     * @param {Object} to The object to be merged with
+     * @returns {Object} The merged object
+     */
+    var merge =
+        Object.assign ||
+        function (to) {
+            var arguments$1 = arguments;
+
+            for (var i = 1; i < arguments.length; i++) {
+                var from = Object(arguments$1[i]);
+
+                for (var key in from) {
+                    if (hasOwn.call(from, key)) {
+                        to[key] = from[key];
+                    }
+                }
+            }
+
+            return to;
+        };
+
+    /**
+     * Check if value is primitive
+     * @param {*} value Checks if a value is primitive
+     * @returns {Boolean} Result of the check
+     */
+    function isPrimitive(value) {
+        return typeof value === 'string' || typeof value === 'number';
+    }
+
+    /**
+     * Performs no operation.
+     * @void
+     */
+    function noop() {
+    }
+
+    /**
+     * Check if value is function
+     * @param {*} obj Any javascript object
+     * @returns {Boolean} True if the passed-in value is a function
+     */
+    function isFn(obj) {
+        return typeof obj === 'function';
+    }
+
+    /**
+     * Check if url is external
+     * @param {String} string  url
+     * @returns {Boolean} True if the passed-in url is external
+     */
+    function isExternal(url) {
+        var match = url.match(
+            /^([^:/?#]+:)?(?:\/{2,}([^/?#]*))?([^?#]+)?(\?[^#]*)?(#.*)?/,
+        );
+
+        if (
+            typeof match[1] === 'string' &&
+            match[1].length > 0 &&
+            match[1].toLowerCase() !== location.protocol
+        ) {
+            return true;
+        }
+        if (
+            typeof match[2] === 'string' &&
+            match[2].length > 0 &&
+            match[2].replace(
+                new RegExp(
+                    ':(' + { 'http:': 80, 'https:': 443 }[location.protocol] + ')?$',
+                ),
+                '',
+            ) !== location.host
+        ) {
+            return true;
+        }
+        return false;
+    }
+
+    var inBrowser = !false;
+
+    var isMobile = document.body.clientWidth <= 600;
+
+    /**
+     * @see https://github.com/MoOx/pjax/blob/master/lib/is-supported.js
+     */
+    var supportsPushState =
+
+        (function () {
+            // Borrowed wholesale from https://github.com/defunkt/jquery-pjax
+            return (
+                window.history &&
+                window.history.pushState &&
+                window.history.replaceState &&
+                // PushState isn’t reliable on iOS until 5.
+                !navigator.userAgent.match(
+                    /((iPod|iPhone|iPad).+\bOS\s+[1-4]\D|WebApps\/.+CFNetwork)/,
+                )
+            );
+        })();
+
+    var cacheNode = {};
+
+    /**
+     * Get Node
+     * @param  {String|Element} el A DOM element
+     * @param  {Boolean} noCache Flag to use or not use the cache
+     * @return {Element} The found node element
+     */
+    function getNode(el, noCache) {
+        if (noCache === void 0) noCache = false;
+
+        if (typeof el === 'string') {
+            if (typeof window.Vue !== 'undefined') {
+                return find(el);
+            }
+
+            el = noCache ? find(el) : cacheNode[el] || (cacheNode[el] = find(el));
+        }
+
+        return el;
+    }
+
+    var $ = document;
+
+    var body = $.body;
+
+    var head = $.head;
+
+    /**
+     * Find elements
+     * @param {String|Element} el The root element where to perform the search from
+     * @param {Element} node The query
+     * @returns {Element} The found DOM element
+     * @example
+     * find('nav') => document.querySelector('nav')
+     * find(nav, 'a') => nav.querySelector('a')
+     */
+    function find(el, node) {
+        return node ? el.querySelector(node) : $.querySelector(el);
+    }
+
+    /**
+     * Find all elements
+     * @param {String|Element} el The root element where to perform the search from
+     * @param {Element} node The query
+     * @returns {Array<Element>} An array of DOM elements
+     * @example
+     * findAll('a') => [].slice.call(document.querySelectorAll('a'))
+     * findAll(nav, 'a') => [].slice.call(nav.querySelectorAll('a'))
+     */
+    function findAll(el, node) {
+        return [].slice.call(
+            node ? el.querySelectorAll(node) : $.querySelectorAll(el),
+        );
+    }
+
+    function create(node, tpl) {
+        node = $.createElement(node);
+        if (tpl) {
+            node.innerHTML = tpl;
+        }
+
+        return node;
+    }
+
+    function appendTo(target, el) {
+        return target.appendChild(el);
+    }
+
+    function before(target, el) {
+        return target.insertBefore(el, target.children[0]);
+    }
+
+    function on(el, type, handler) {
+        isFn(type)
+            ? window.addEventListener(el, type)
+            : el.addEventListener(type, handler);
+    }
+
+    function off(el, type, handler) {
+        isFn(type)
+            ? window.removeEventListener(el, type)
+            : el.removeEventListener(type, handler);
+    }
+
+    /**
+     * Toggle class
+     * @param {String|Element} el The element that needs the class to be toggled
+     * @param {Element} type The type of action to be performed on the classList (toggle by default)
+     * @param {String} val Name of the class to be toggled
+     * @void
+     * @example
+     * toggleClass(el, 'active') => el.classList.toggle('active')
+     * toggleClass(el, 'add', 'active') => el.classList.add('active')
+     */
+    function toggleClass(el, type, val) {
+        el && el.classList[val ? type : 'toggle'](val || type);
+    }
+
+    function style(content) {
+        appendTo(head, create('style', content));
+    }
+
+    /**
+     * Fork https://github.com/bendrucker/document-ready/blob/master/index.js
+     * @param {Function} callback The callbacack to be called when the page is loaded
+     * @returns {Number|void} If the page is already laoded returns the result of the setTimeout callback,
+     *  otherwise it only attaches the callback to the DOMContentLoaded event
+     */
+    function documentReady(callback, doc) {
+        if (doc === void 0) doc = document;
+
+        var state = doc.readyState;
+
+        if (state === 'complete' || state === 'interactive') {
+            return setTimeout(callback, 0);
+        }
+
+        doc.addEventListener('DOMContentLoaded', callback);
+    }
+
+    var dom = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        getNode: getNode,
+        $: $,
+        body: body,
+        head: head,
+        find: find,
+        findAll: findAll,
+        create: create,
+        appendTo: appendTo,
+        before: before,
+        on: on,
+        off: off,
+        toggleClass: toggleClass,
+        style: style,
+        documentReady: documentReady,
+    });
+
+    var decode = decodeURIComponent;
+    var encode = encodeURIComponent;
+
+    function parseQuery(query) {
+        var res = {};
+
+        query = query.trim().replace(/^(\?|#|&)/, '');
+
+        if (!query) {
+            return res;
+        }
+
+        // Simple parse
+        query.split('&').forEach(function (param) {
+            var parts = param.replace(/\+/g, ' ').split('=');
+
+            res[parts[0]] = parts[1] && decode(parts[1]);
+        });
+
+        return res;
+    }
+
+    function stringifyQuery(obj, ignores) {
+        if (ignores === void 0) ignores = [];
+
+        var qs = [];
+
+        for (var key in obj) {
+            if (ignores.indexOf(key) > -1) {
+                continue;
+            }
+
+            qs.push(
+                obj[key]
+                    ? ((encode(key)) + '=' + (encode(obj[key]))).toLowerCase()
+                    : encode(key),
+            );
+        }
+
+        return qs.length ? ('?' + (qs.join('&'))) : '';
+    }
+
+    var isAbsolutePath = cached(function (path) {
+        return /(:|(\/{2}))/g.test(path);
+    });
+
+    var removeParams = cached(function (path) {
+        return path.split(/[?#]/)[0];
+    });
+
+    var getParentPath = cached(function (path) {
+        if (/\/$/g.test(path)) {
+            return path;
+        }
+
+        var matchingParts = path.match(/(\S*\/)[^/]+$/);
+        return matchingParts ? matchingParts[1] : '';
+    });
+
+    var cleanPath = cached(function (path) {
+        return path.replace(/^\/+/, '/').replace(/([^:])\/{2,}/g, '$1/');
+    });
+
+    var resolvePath = cached(function (path) {
+        var segments = path.replace(/^\//, '').split('/');
+        var resolved = [];
+        for (var i = 0, len = segments.length; i < len; i++) {
+            var segment = segments[i];
+            if (segment === '..') {
+                resolved.pop();
+            } else if (segment !== '.') {
+                resolved.push(segment);
+            }
+        }
+
+        return '/' + resolved.join('/');
+    });
+
+    /**
+     * Normalises the URI path to handle the case where Docsify is
+     * hosted off explicit files, i.e. /index.html. This function
+     * eliminates any path segments that contain `#` fragments.
+     *
+     * This is used to map browser URIs to markdown file sources.
+     *
+     * For example:
+     *
+     * http://example.org/base/index.html#/blah
+     *
+     * would be mapped to:
+     *
+     * http://example.org/base/blah.md.
+     *
+     * See here for more information:
+     *
+     * https://github.com/docsifyjs/docsify/pull/1372
+     *
+     * @param {string} path The URI path to normalise
+     * @return {string} { path, query }
+     */
+
+    function normaliseFragment(path) {
+        return path
+            .split('/')
+            .filter(function (p) {
+                return p.indexOf('#') === -1;
+            })
+            .join('/');
+    }
+
+    function getPath() {
+        var args = [], len = arguments.length;
+        while (len--) args[len] = arguments[len];
+
+        return cleanPath(args.map(normaliseFragment).join('/'));
+    }
+
+    var replaceSlug = cached(function (path) {
+        return path.replace('#', '?id=');
+    });
+
+    function endsWith(str, suffix) {
+        return str.indexOf(suffix, str.length - suffix.length) !== -1;
+    }
+
+    var cached$1 = {};
+
+    function getAlias(path, alias, last) {
+        var match = Object.keys(alias).filter(function (key) {
+            var re = cached$1[key] || (cached$1[key] = new RegExp(('^' + key + '$')));
+            return re.test(path) && path !== last;
+        })[0];
+
+        return match
+            ? getAlias(path.replace(cached$1[match], alias[match]), alias, path)
+            : path;
+    }
+
+    function getFileName(path, ext) {
+        return new RegExp(('\\.(' + (ext.replace(/^\./, '')) + '|html)$'), 'g').test(path)
+            ? path
+            : /\/$/g.test(path)
+                ? (path + 'README' + ext)
+                : ('' + path + ext);
+    }
+
+    var History = function History(config) {
+        this.config = config;
+    };
+
+    History.prototype.getBasePath = function getBasePath() {
+        return this.config.basePath;
+    };
+
+    History.prototype.getFile = function getFile(path, isRelative) {
+        if (path === void 0) path = this.getCurrentPath();
+
+        var ref = this;
+        var config = ref.config;
+        var base = this.getBasePath();
+        var ext = typeof config.ext === 'string' ? config.ext : '.md';
+
+        path = config.alias ? getAlias(path, config.alias) : path;
+        path = getFileName(path, ext);
+        path = path === ('/README' + ext) ? config.homepage || path : path;
+        path = isAbsolutePath(path) ? path : getPath(base, path);
+
+        if (isRelative) {
+            path = path.replace(new RegExp(('^' + base)), '');
+        }
+
+        return path;
+    };
+
+    History.prototype.onchange = function onchange(cb) {
+        if (cb === void 0) cb = noop;
+
+        cb();
+    };
+
+    History.prototype.getCurrentPath = function getCurrentPath() {
+    };
+
+    History.prototype.normalize = function normalize() {
+    };
+
+    History.prototype.parse = function parse() {
+    };
+
+    History.prototype.toURL = function toURL(path, params, currentRoute) {
+        var local = currentRoute && path[0] === '#';
+        var route = this.parse(replaceSlug(path));
+
+        route.query = merge({}, route.query, params);
+        path = route.path + stringifyQuery(route.query);
+        path = path.replace(/\.md(\?)|\.md$/, '$1');
+
+        if (local) {
+            var idIndex = currentRoute.indexOf('?');
+            path =
+                (idIndex > 0 ? currentRoute.substring(0, idIndex) : currentRoute) +
+                path;
+        }
+
+        if (this.config.relativePath && path.indexOf('/') !== 0) {
+            var currentDir = currentRoute.substring(
+                0,
+                currentRoute.lastIndexOf('/') + 1,
+            );
+            return cleanPath(resolvePath(currentDir + path));
+        }
+
+        return cleanPath('/' + path);
+    };
+
+    function replaceHash(path) {
+        var i = location.href.indexOf('#');
+        location.replace(location.href.slice(0, i >= 0 ? i : 0) + '#' + path);
+    }
+
+    var HashHistory = /*@__PURE__*/(function (History) {
+        function HashHistory(config) {
+            History.call(this, config);
+            this.mode = 'hash';
+        }
+
+        if (History) HashHistory.__proto__ = History;
+        HashHistory.prototype = Object.create(History && History.prototype);
+        HashHistory.prototype.constructor = HashHistory;
+
+        HashHistory.prototype.getBasePath = function getBasePath() {
+            var path = window.location.pathname || '';
+            var base = this.config.basePath;
+
+            // This handles the case where Docsify is served off an
+            // explicit file path, i.e.`/base/index.html#/blah`. This
+            // prevents the `/index.html` part of the URI from being
+            // remove during routing.
+            // See here: https://github.com/docsifyjs/docsify/pull/1372
+            var basePath = endsWith(path, '.html')
+                ? path + '#/' + base
+                : path + '/' + base;
+            return /^(\/|https?:)/g.test(base) ? base : cleanPath(basePath);
+        };
+
+        HashHistory.prototype.getCurrentPath = function getCurrentPath() {
+            // We can't use location.hash here because it's not
+            // consistent across browsers - Firefox will pre-decode it!
+            var href = location.href;
+            var index = href.indexOf('#');
+            return index === -1 ? '' : href.slice(index + 1);
+        };
+
+        /** @param {((params: {source: TODO}) => void)} [cb] */
+        HashHistory.prototype.onchange = function onchange(cb) {
+            if (cb === void 0) cb = noop;
+
+            // The hashchange event does not tell us if it originated from
+            // a clicked link or by moving back/forward in the history;
+            // therefore we set a `navigating` flag when a link is clicked
+            // to be able to tell these two scenarios apart
+            var navigating = false;
+
+            on('click', function (e) {
+                var el = e.target.tagName === 'A' ? e.target : e.target.parentNode;
+
+                if (el && el.tagName === 'A' && !/_blank/.test(el.target)) {
+                    navigating = true;
+                }
+            });
+
+            on('hashchange', function (e) {
+                var source = navigating ? 'navigate' : 'history';
+                navigating = false;
+                cb({ event: e, source: source });
+            });
+        };
+
+        HashHistory.prototype.normalize = function normalize() {
+            var path = this.getCurrentPath();
+
+            path = replaceSlug(path);
+
+            if (path.charAt(0) === '/') {
+                return replaceHash(path);
+            }
+
+            replaceHash('/' + path);
+        };
+
+        /**
+         * Parse the url
+         * @param {string} [path=location.herf] URL to be parsed
+         * @return {object} { path, query }
+         */
+        HashHistory.prototype.parse = function parse(path) {
+            if (path === void 0) path = location.href;
+
+            var query = '';
+
+            var hashIndex = path.indexOf('#');
+            if (hashIndex >= 0) {
+                path = path.slice(hashIndex + 1);
+            }
+
+            var queryIndex = path.indexOf('?');
+            if (queryIndex >= 0) {
+                query = path.slice(queryIndex + 1);
+                path = path.slice(0, queryIndex);
+            }
+
+            return {
+                path: path,
+                file: this.getFile(path, true),
+                query: parseQuery(query),
+            };
+        };
+
+        HashHistory.prototype.toURL = function toURL(path, params, currentRoute) {
+            return '#' + History.prototype.toURL.call(this, path, params, currentRoute);
+        };
+
+        return HashHistory;
+    }(History));
+
+    /** @typedef {any} TODO */
+
+    var HTML5History = /*@__PURE__*/(function (History) {
+        function HTML5History(config) {
+            History.call(this, config);
+            this.mode = 'history';
+        }
+
+        if (History) HTML5History.__proto__ = History;
+        HTML5History.prototype = Object.create(History && History.prototype);
+        HTML5History.prototype.constructor = HTML5History;
+
+        HTML5History.prototype.getCurrentPath = function getCurrentPath() {
+            var base = this.getBasePath();
+            var path = window.location.pathname;
+
+            if (base && path.indexOf(base) === 0) {
+                path = path.slice(base.length);
+            }
+
+            return (path || '/') + window.location.search + window.location.hash;
+        };
+
+        HTML5History.prototype.onchange = function onchange(cb) {
+            var this$1 = this;
+            if (cb === void 0) cb = noop;
+
+            on('click', function (e) {
+                var el = e.target.tagName === 'A' ? e.target : e.target.parentNode;
+
+                if (el && el.tagName === 'A' && !/_blank/.test(el.target)) {
+                    e.preventDefault();
+                    var url = el.href;
+                    // solve history.pushState cross-origin issue
+                    if (this$1.config.crossOriginLinks.indexOf(url) !== -1) {
+                        window.open(url, '_self');
+                    } else {
+                        window.history.pushState({ key: url }, '', url);
+                    }
+                    cb({ event: e, source: 'navigate' });
+                }
+            });
+
+            on('popstate', function (e) {
+                cb({ event: e, source: 'history' });
+            });
+        };
+
+        /**
+         * Parse the url
+         * @param {string} [path=location.href] URL to be parsed
+         * @return {object} { path, query }
+         */
+        HTML5History.prototype.parse = function parse(path) {
+            if (path === void 0) path = location.href;
+
+            var query = '';
+
+            var queryIndex = path.indexOf('?');
+            if (queryIndex >= 0) {
+                query = path.slice(queryIndex + 1);
+                path = path.slice(0, queryIndex);
+            }
+
+            var base = getPath(location.origin);
+            var baseIndex = path.indexOf(base);
+
+            if (baseIndex > -1) {
+                path = path.slice(baseIndex + base.length);
+            }
+
+            return {
+                path: path,
+                file: this.getFile(path),
+                query: parseQuery(query),
+            };
+        };
+
+        return HTML5History;
+    }(History));
+
+    /**
+     * @typedef {{
+     *   path?: string
+     * }} Route
+     */
+
+    /** @type {Route} */
+    var lastRoute = {};
+
+    /** @typedef {import('../Docsify').Constructor} Constructor */
+
+    /**
+     * @template {!Constructor} T
+     * @param {T} Base - The class to extend
+     */
+    function Router(Base) {
+        return /*@__PURE__*/(function (Base) {
+            function Router() {
+                var args = [], len = arguments.length;
+                while (len--) args[len] = arguments[len];
+
+                Base.apply(this, args);
+
+                this.route = {};
+            }
+
+            if (Base) Router.__proto__ = Base;
+            Router.prototype = Object.create(Base && Base.prototype);
+            Router.prototype.constructor = Router;
+
+            Router.prototype.updateRender = function updateRender() {
+                this.router.normalize();
+                this.route = this.router.parse();
+                body.setAttribute('data-page', this.route.file);
+            };
+
+            Router.prototype.initRouter = function initRouter() {
+                var this$1 = this;
+
+                var config = this.config;
+                var mode = config.routerMode || 'hash';
+                var router;
+
+                if (mode === 'history' && supportsPushState) {
+                    router = new HTML5History(config);
+                } else {
+                    router = new HashHistory(config);
+                }
+
+                this.router = router;
+                this.updateRender();
+                lastRoute = this.route;
+
+                // eslint-disable-next-line no-unused-vars
+                router.onchange(function (params) {
+                    this$1.updateRender();
+                    this$1._updateRender();
+
+                    if (lastRoute.path === this$1.route.path) {
+                        this$1.$resetEvents(params.source);
+                        return;
+                    }
+
+                    this$1.$fetch(noop, this$1.$resetEvents.bind(this$1, params.source));
+                    lastRoute = this$1.route;
+                });
+            };
+
+            return Router;
+        }(Base));
+    }
+
+    var RGX = /([^{]*?)\w(?=\})/g;
+
+    var MAP = {
+        YYYY: 'getFullYear',
+        YY: 'getYear',
+        MM: function (d) {
+            return d.getMonth() + 1;
+        },
+        DD: 'getDate',
+        HH: 'getHours',
+        mm: 'getMinutes',
+        ss: 'getSeconds',
+        fff: 'getMilliseconds',
+    };
+
+    function tinydate(str, custom) {
+        var parts = [], offset = 0;
+
+        str.replace(RGX, function (key, _, idx) {
+            // save preceding string
+            parts.push(str.substring(offset, idx - 1));
+            offset = idx += key.length + 1;
+            // save function
+            parts.push(custom && custom[key] || function (d) {
+                return ('00' + (typeof MAP[key] === 'string' ? d[MAP[key]]() : MAP[key](d))).slice(-key.length);
+            });
+        });
+
+        if (offset !== str.length) {
+            parts.push(str.substring(offset));
+        }
+
+        return function (arg) {
+            var out = '', i = 0, d = arg || new Date();
+            for (; i < parts.length; i++) {
+                out += (typeof parts[i] === 'string') ? parts[i] : parts[i](d);
+            }
+            return out;
+        };
+    }
+
+    /*! @license DOMPurify 2.3.1 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/2.3.1/LICENSE */
+
+    function _toConsumableArray(arr) {
+        if (Array.isArray(arr)) {
+            for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
+                arr2[i] = arr[i];
+            }
+            return arr2;
+        } else {
+            return Array.from(arr);
+        }
+    }
+
+    var hasOwnProperty = Object.hasOwnProperty,
+        setPrototypeOf = Object.setPrototypeOf,
+        isFrozen = Object.isFrozen,
+        getPrototypeOf = Object.getPrototypeOf,
+        getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+    var freeze = Object.freeze,
+        seal = Object.seal,
+        create$1 = Object.create; // eslint-disable-line import/no-mutable-exports
+
+    var _ref = typeof Reflect !== 'undefined' && Reflect,
+        apply = _ref.apply,
+        construct = _ref.construct;
+
+    if (!apply) {
+        apply = function apply(fun, thisValue, args) {
+            return fun.apply(thisValue, args);
+        };
+    }
+
+    if (!freeze) {
+        freeze = function freeze(x) {
+            return x;
+        };
+    }
+
+    if (!seal) {
+        seal = function seal(x) {
+            return x;
+        };
+    }
+
+    if (!construct) {
+        construct = function construct(Func, args) {
+            return new (Function.prototype.bind.apply(Func, [ null ].concat(_toConsumableArray(args))))();
+        };
+    }
+
+    var arrayForEach = unapply(Array.prototype.forEach);
+    var arrayPop = unapply(Array.prototype.pop);
+    var arrayPush = unapply(Array.prototype.push);
+
+    var stringToLowerCase = unapply(String.prototype.toLowerCase);
+    var stringMatch = unapply(String.prototype.match);
+    var stringReplace = unapply(String.prototype.replace);
+    var stringIndexOf = unapply(String.prototype.indexOf);
+    var stringTrim = unapply(String.prototype.trim);
+
+    var regExpTest = unapply(RegExp.prototype.test);
+
+    var typeErrorCreate = unconstruct(TypeError);
+
+    function unapply(func) {
+        return function (thisArg) {
+            var arguments$1 = arguments;
+
+            for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+                args[_key - 1] = arguments$1[_key];
+            }
+
+            return apply(func, thisArg, args);
+        };
+    }
+
+    function unconstruct(func) {
+        return function () {
+            var arguments$1 = arguments;
+
+            for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+                args[_key2] = arguments$1[_key2];
+            }
+
+            return construct(func, args);
+        };
+    }
+
+    /* Add properties to a lookup table */
+    function addToSet(set, array) {
+        if (setPrototypeOf) {
+            // Make 'in' and truthy checks like Boolean(set.constructor)
+            // independent of any properties defined on Object.prototype.
+            // Prevent prototype setters from intercepting set as a this value.
+            setPrototypeOf(set, null);
+        }
+
+        var l = array.length;
+        while (l--) {
+            var element = array[l];
+            if (typeof element === 'string') {
+                var lcElement = stringToLowerCase(element);
+                if (lcElement !== element) {
+                    // Config presets (e.g. tags.js, attrs.js) are immutable.
+                    if (!isFrozen(array)) {
+                        array[l] = lcElement;
+                    }
+
+                    element = lcElement;
+                }
+            }
+
+            set[element] = true;
+        }
+
+        return set;
+    }
+
+    /* Shallow clone an object */
+    function clone(object) {
+        var newObject = create$1(null);
+
+        var property = void 0;
+        for (property in object) {
+            if (apply(hasOwnProperty, object, [ property ])) {
+                newObject[property] = object[property];
+            }
+        }
+
+        return newObject;
+    }
+
+    /* IE10 doesn't support __lookupGetter__ so lets'
+   * simulate it. It also automatically checks
+   * if the prop is function or getter and behaves
+   * accordingly. */
+    function lookupGetter(object, prop) {
+        while (object !== null) {
+            var desc = getOwnPropertyDescriptor(object, prop);
+            if (desc) {
+                if (desc.get) {
+                    return unapply(desc.get);
+                }
+
+                if (typeof desc.value === 'function') {
+                    return unapply(desc.value);
+                }
+            }
+
+            object = getPrototypeOf(object);
+        }
+
+        function fallbackValue(element) {
+            console.warn('fallback value for', element);
+            return null;
+        }
+
+        return fallbackValue;
+    }
+
+    var html = freeze([ 'a', 'abbr', 'acronym', 'address', 'area', 'article', 'aside', 'audio', 'b', 'bdi', 'bdo', 'big', 'blink', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'center', 'cite', 'code', 'col', 'colgroup', 'content', 'data', 'datalist', 'dd', 'decorator', 'del', 'details', 'dfn', 'dialog', 'dir', 'div', 'dl', 'dt', 'element', 'em', 'fieldset', 'figcaption', 'figure', 'font', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'img', 'input', 'ins', 'kbd', 'label', 'legend', 'li', 'main', 'map', 'mark', 'marquee', 'menu', 'menuitem', 'meter', 'nav', 'nobr', 'ol', 'optgroup', 'option', 'output', 'p', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'section', 'select', 'shadow', 'small', 'source', 'spacer', 'span', 'strike', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'time', 'tr', 'track', 'tt', 'u', 'ul', 'var', 'video', 'wbr' ]);
+
+    // SVG
+    var svg = freeze([ 'svg', 'a', 'altglyph', 'altglyphdef', 'altglyphitem', 'animatecolor', 'animatemotion', 'animatetransform', 'circle', 'clippath', 'defs', 'desc', 'ellipse', 'filter', 'font', 'g', 'glyph', 'glyphref', 'hkern', 'image', 'line', 'lineargradient', 'marker', 'mask', 'metadata', 'mpath', 'path', 'pattern', 'polygon', 'polyline', 'radialgradient', 'rect', 'stop', 'style', 'switch', 'symbol', 'text', 'textpath', 'title', 'tref', 'tspan', 'view', 'vkern' ]);
+
+    var svgFilters = freeze([ 'feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap', 'feDistantLight', 'feFlood', 'feFuncA', 'feFuncB', 'feFuncG', 'feFuncR', 'feGaussianBlur', 'feMerge', 'feMergeNode', 'feMorphology', 'feOffset', 'fePointLight', 'feSpecularLighting', 'feSpotLight', 'feTile', 'feTurbulence' ]);
+
+    // List of SVG elements that are disallowed by default.
+    // We still need to know them so that we can do namespace
+    // checks properly in case one wants to add them to
+    // allow-list.
+    var svgDisallowed = freeze([ 'animate', 'color-profile', 'cursor', 'discard', 'fedropshadow', 'feimage', 'font-face', 'font-face-format', 'font-face-name', 'font-face-src', 'font-face-uri', 'foreignobject', 'hatch', 'hatchpath', 'mesh', 'meshgradient', 'meshpatch', 'meshrow', 'missing-glyph', 'script', 'set', 'solidcolor', 'unknown', 'use' ]);
+
+    var mathMl = freeze([ 'math', 'menclose', 'merror', 'mfenced', 'mfrac', 'mglyph', 'mi', 'mlabeledtr', 'mmultiscripts', 'mn', 'mo', 'mover', 'mpadded', 'mphantom', 'mroot', 'mrow', 'ms', 'mspace', 'msqrt', 'mstyle', 'msub', 'msup', 'msubsup', 'mtable', 'mtd', 'mtext', 'mtr', 'munder', 'munderover' ]);
+
+    // Similarly to SVG, we want to know all MathML elements,
+    // even those that we disallow by default.
+    var mathMlDisallowed = freeze([ 'maction', 'maligngroup', 'malignmark', 'mlongdiv', 'mscarries', 'mscarry', 'msgroup', 'mstack', 'msline', 'msrow', 'semantics', 'annotation', 'annotation-xml', 'mprescripts', 'none' ]);
+
+    var text = freeze([ '#text' ]);
+
+    var html$1 = freeze([ 'accept', 'action', 'align', 'alt', 'autocapitalize', 'autocomplete', 'autopictureinpicture', 'autoplay', 'background', 'bgcolor', 'border', 'capture', 'cellpadding', 'cellspacing', 'checked', 'cite', 'class', 'clear', 'color', 'cols', 'colspan', 'controls', 'controlslist', 'coords', 'crossorigin', 'datetime', 'decoding', 'default', 'dir', 'disabled', 'disablepictureinpicture', 'disableremoteplayback', 'download', 'draggable', 'enctype', 'enterkeyhint', 'face', 'for', 'headers', 'height', 'hidden', 'high', 'href', 'hreflang', 'id', 'inputmode', 'integrity', 'ismap', 'kind', 'label', 'lang', 'list', 'loading', 'loop', 'low', 'max', 'maxlength', 'media', 'method', 'min', 'minlength', 'multiple', 'muted', 'name', 'noshade', 'novalidate', 'nowrap', 'open', 'optimum', 'pattern', 'placeholder', 'playsinline', 'poster', 'preload', 'pubdate', 'radiogroup', 'readonly', 'rel', 'required', 'rev', 'reversed', 'role', 'rows', 'rowspan', 'spellcheck', 'scope', 'selected', 'shape', 'size', 'sizes', 'span', 'srclang', 'start', 'src', 'srcset', 'step', 'style', 'summary', 'tabindex', 'title', 'translate', 'type', 'usemap', 'valign', 'value', 'width', 'xmlns', 'slot' ]);
+
+    var svg$1 = freeze([ 'accent-height', 'accumulate', 'additive', 'alignment-baseline', 'ascent', 'attributename', 'attributetype', 'azimuth', 'basefrequency', 'baseline-shift', 'begin', 'bias', 'by', 'class', 'clip', 'clippathunits', 'clip-path', 'clip-rule', 'color', 'color-interpolation', 'color-interpolation-filters', 'color-profile', 'color-rendering', 'cx', 'cy', 'd', 'dx', 'dy', 'diffuseconstant', 'direction', 'display', 'divisor', 'dur', 'edgemode', 'elevation', 'end', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'filterunits', 'flood-color', 'flood-opacity', 'font-family', 'font-size', 'font-size-adjust', 'font-stretch', 'font-style', 'font-variant', 'font-weight', 'fx', 'fy', 'g1', 'g2', 'glyph-name', 'glyphref', 'gradientunits', 'gradienttransform', 'height', 'href', 'id', 'image-rendering', 'in', 'in2', 'k', 'k1', 'k2', 'k3', 'k4', 'kerning', 'keypoints', 'keysplines', 'keytimes', 'lang', 'lengthadjust', 'letter-spacing', 'kernelmatrix', 'kernelunitlength', 'lighting-color', 'local', 'marker-end', 'marker-mid', 'marker-start', 'markerheight', 'markerunits', 'markerwidth', 'maskcontentunits', 'maskunits', 'max', 'mask', 'media', 'method', 'mode', 'min', 'name', 'numoctaves', 'offset', 'operator', 'opacity', 'order', 'orient', 'orientation', 'origin', 'overflow', 'paint-order', 'path', 'pathlength', 'patterncontentunits', 'patterntransform', 'patternunits', 'points', 'preservealpha', 'preserveaspectratio', 'primitiveunits', 'r', 'rx', 'ry', 'radius', 'refx', 'refy', 'repeatcount', 'repeatdur', 'restart', 'result', 'rotate', 'scale', 'seed', 'shape-rendering', 'specularconstant', 'specularexponent', 'spreadmethod', 'startoffset', 'stddeviation', 'stitchtiles', 'stop-color', 'stop-opacity', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke', 'stroke-width', 'style', 'surfacescale', 'systemlanguage', 'tabindex', 'targetx', 'targety', 'transform', 'text-anchor', 'text-decoration', 'text-rendering', 'textlength', 'type', 'u1', 'u2', 'unicode', 'values', 'viewbox', 'visibility', 'version', 'vert-adv-y', 'vert-origin-x', 'vert-origin-y', 'width', 'word-spacing', 'wrap', 'writing-mode', 'xchannelselector', 'ychannelselector', 'x', 'x1', 'x2', 'xmlns', 'y', 'y1', 'y2', 'z', 'zoomandpan' ]);
+
+    var mathMl$1 = freeze([ 'accent', 'accentunder', 'align', 'bevelled', 'close', 'columnsalign', 'columnlines', 'columnspan', 'denomalign', 'depth', 'dir', 'display', 'displaystyle', 'encoding', 'fence', 'frame', 'height', 'href', 'id', 'largeop', 'length', 'linethickness', 'lspace', 'lquote', 'mathbackground', 'mathcolor', 'mathsize', 'mathvariant', 'maxsize', 'minsize', 'movablelimits', 'notation', 'numalign', 'open', 'rowalign', 'rowlines', 'rowspacing', 'rowspan', 'rspace', 'rquote', 'scriptlevel', 'scriptminsize', 'scriptsizemultiplier', 'selection', 'separator', 'separators', 'stretchy', 'subscriptshift', 'supscriptshift', 'symmetric', 'voffset', 'width', 'xmlns' ]);
+
+    var xml = freeze([ 'xlink:href', 'xml:id', 'xlink:title', 'xml:space', 'xmlns:xlink' ]);
+
+    // eslint-disable-next-line unicorn/better-regex
+    var MUSTACHE_EXPR = seal(/\{\{[\s\S]*|[\s\S]*\}\}/gm); // Specify template detection regex for SAFE_FOR_TEMPLATES mode
+    var ERB_EXPR = seal(/<%[\s\S]*|[\s\S]*%>/gm);
+    var DATA_ATTR = seal(/^data-[\-\w.\u00B7-\uFFFF]/); // eslint-disable-line no-useless-escape
+    var ARIA_ATTR = seal(/^aria-[\-\w]+$/); // eslint-disable-line no-useless-escape
+    var IS_ALLOWED_URI = seal(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i, // eslint-disable-line no-useless-escape
+    );
+    var IS_SCRIPT_OR_DATA = seal(/^(?:\w+script|data):/i);
+    var ATTR_WHITESPACE = seal(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g, // eslint-disable-line no-control-regex
+    );
+
+    var _typeof = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? function (obj) {
+        return typeof obj;
+    } : function (obj) {
+        return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj;
+    };
+
+    function _toConsumableArray$1(arr) {
+        if (Array.isArray(arr)) {
+            for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
+                arr2[i] = arr[i];
+            }
+            return arr2;
+        } else {
+            return Array.from(arr);
+        }
+    }
+
+    var getGlobal = function getGlobal() {
+        return typeof window === 'undefined' ? null : window;
+    };
+
+    /**
+     * Creates a no-op policy for internal use only.
+     * Don't export this function outside this module!
+     * @param {?TrustedTypePolicyFactory} trustedTypes The policy factory.
+     * @param {Document} document The document object (to determine policy name suffix)
+     * @return {?TrustedTypePolicy} The policy created (or null, if Trusted Types
+     * are not supported).
+     */
+    var _createTrustedTypesPolicy = function _createTrustedTypesPolicy(trustedTypes, document) {
+        if ((typeof trustedTypes === 'undefined' ? 'undefined' : _typeof(trustedTypes)) !== 'object' || typeof trustedTypes.createPolicy !== 'function') {
+            return null;
+        }
+
+        // Allow the callers to control the unique policy name
+        // by adding a data-tt-policy-suffix to the script element with the DOMPurify.
+        // Policy creation with duplicate names throws in Trusted Types.
+        var suffix = null;
+        var ATTR_NAME = 'data-tt-policy-suffix';
+        if (document.currentScript && document.currentScript.hasAttribute(ATTR_NAME)) {
+            suffix = document.currentScript.getAttribute(ATTR_NAME);
+        }
+
+        var policyName = 'dompurify' + (suffix ? '#' + suffix : '');
+
+        try {
+            return trustedTypes.createPolicy(policyName, {
+                createHTML: function createHTML(html$$1) {
+                    return html$$1;
+                },
+            });
+        } catch (_) {
+            // Policy creation failed (most likely another DOMPurify script has
+            // already run). Skip creating the policy, as this will only cause errors
+            // if TT are enforced.
+            console.warn('TrustedTypes policy ' + policyName + ' could not be created.');
+            return null;
+        }
+    };
+
+    function createDOMPurify() {
+        var window = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getGlobal();
+
+        var DOMPurify = function DOMPurify(root) {
+            return createDOMPurify(root);
+        };
+
+        /**
+         * Version label, exposed for easier checks
+         * if DOMPurify is up to date or not
+         */
+        DOMPurify.version = '2.3.1';
+
+        /**
+         * Array of elements that DOMPurify removed during sanitation.
+         * Empty if nothing was removed.
+         */
+        DOMPurify.removed = [];
+
+        if (!window || !window.document || window.document.nodeType !== 9) {
+            // Not running in a browser, provide a factory function
+            // so that you can pass your own Window
+            DOMPurify.isSupported = false;
+
+            return DOMPurify;
+        }
+
+        var originalDocument = window.document;
+
+        var document = window.document;
+        var DocumentFragment = window.DocumentFragment,
+            HTMLTemplateElement = window.HTMLTemplateElement,
+            Node = window.Node,
+            Element = window.Element,
+            NodeFilter = window.NodeFilter,
+            _window$NamedNodeMap = window.NamedNodeMap,
+            NamedNodeMap = _window$NamedNodeMap === undefined ? window.NamedNodeMap || window.MozNamedAttrMap : _window$NamedNodeMap,
+            Text = window.Text,
+            Comment = window.Comment,
+            DOMParser = window.DOMParser,
+            trustedTypes = window.trustedTypes;
+
+
+        var ElementPrototype = Element.prototype;
+
+        var cloneNode = lookupGetter(ElementPrototype, 'cloneNode');
+        var getNextSibling = lookupGetter(ElementPrototype, 'nextSibling');
+        var getChildNodes = lookupGetter(ElementPrototype, 'childNodes');
+        var getParentNode = lookupGetter(ElementPrototype, 'parentNode');
+
+        // As per issue #47, the web-components registry is inherited by a
+        // new document created via createHTMLDocument. As per the spec
+        // (http://w3c.github.io/webcomponents/spec/custom/#creating-and-passing-registries)
+        // a new empty registry is used when creating a template contents owner
+        // document, so we use that as our parent document to ensure nothing
+        // is inherited.
+        if (typeof HTMLTemplateElement === 'function') {
+            var template = document.createElement('template');
+            if (template.content && template.content.ownerDocument) {
+                document = template.content.ownerDocument;
+            }
+        }
+
+        var trustedTypesPolicy = _createTrustedTypesPolicy(trustedTypes, originalDocument);
+        var emptyHTML = trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML('') : '';
+
+        var _document = document,
+            implementation = _document.implementation,
+            createNodeIterator = _document.createNodeIterator,
+            createDocumentFragment = _document.createDocumentFragment,
+            getElementsByTagName = _document.getElementsByTagName;
+        var importNode = originalDocument.importNode;
+
+
+        var documentMode = {};
+        try {
+            documentMode = clone(document).documentMode ? document.documentMode : {};
+        } catch (_) {
+        }
+
+        var hooks = {};
+
+        /**
+         * Expose whether this browser supports running the full DOMPurify.
+         */
+        DOMPurify.isSupported = typeof getParentNode === 'function' && implementation && typeof implementation.createHTMLDocument !== 'undefined' && documentMode !== 9;
+
+        var MUSTACHE_EXPR$$1 = MUSTACHE_EXPR,
+            ERB_EXPR$$1 = ERB_EXPR,
+            DATA_ATTR$$1 = DATA_ATTR,
+            ARIA_ATTR$$1 = ARIA_ATTR,
+            IS_SCRIPT_OR_DATA$$1 = IS_SCRIPT_OR_DATA,
+            ATTR_WHITESPACE$$1 = ATTR_WHITESPACE;
+        var IS_ALLOWED_URI$$1 = IS_ALLOWED_URI;
+
+        /**
+         * We consider the elements and attributes below to be safe. Ideally
+         * don't add any new ones but feel free to remove unwanted ones.
+         */
+
+        /* allowed element names */
+
+        var ALLOWED_TAGS = null;
+        var DEFAULT_ALLOWED_TAGS = addToSet({}, [].concat(_toConsumableArray$1(html), _toConsumableArray$1(svg), _toConsumableArray$1(svgFilters), _toConsumableArray$1(mathMl), _toConsumableArray$1(text)));
+
+        /* Allowed attribute names */
+        var ALLOWED_ATTR = null;
+        var DEFAULT_ALLOWED_ATTR = addToSet({}, [].concat(_toConsumableArray$1(html$1), _toConsumableArray$1(svg$1), _toConsumableArray$1(mathMl$1), _toConsumableArray$1(xml)));
+
+        /* Explicitly forbidden tags (overrides ALLOWED_TAGS/ADD_TAGS) */
+        var FORBID_TAGS = null;
+
+        /* Explicitly forbidden attributes (overrides ALLOWED_ATTR/ADD_ATTR) */
+        var FORBID_ATTR = null;
+
+        /* Decide if ARIA attributes are okay */
+        var ALLOW_ARIA_ATTR = true;
+
+        /* Decide if custom data attributes are okay */
+        var ALLOW_DATA_ATTR = true;
+
+        /* Decide if unknown protocols are okay */
+        var ALLOW_UNKNOWN_PROTOCOLS = false;
+
+        /* Output should be safe for common template engines.
+     * This means, DOMPurify removes data attributes, mustaches and ERB
+     */
+        var SAFE_FOR_TEMPLATES = false;
+
+        /* Decide if document with <html>... should be returned */
+        var WHOLE_DOCUMENT = false;
+
+        /* Track whether config is already set on this instance of DOMPurify. */
+        var SET_CONFIG = false;
+
+        /* Decide if all elements (e.g. style, script) must be children of
+     * document.body. By default, browsers might move them to document.head */
+        var FORCE_BODY = false;
+
+        /* Decide if a DOM `HTMLBodyElement` should be returned, instead of a html
+     * string (or a TrustedHTML object if Trusted Types are supported).
+     * If `WHOLE_DOCUMENT` is enabled a `HTMLHtmlElement` will be returned instead
+     */
+        var RETURN_DOM = false;
+
+        /* Decide if a DOM `DocumentFragment` should be returned, instead of a html
+     * string  (or a TrustedHTML object if Trusted Types are supported) */
+        var RETURN_DOM_FRAGMENT = false;
+
+        /* If `RETURN_DOM` or `RETURN_DOM_FRAGMENT` is enabled, decide if the returned DOM
+     * `Node` is imported into the current `Document`. If this flag is not enabled the
+     * `Node` will belong (its ownerDocument) to a fresh `HTMLDocument`, created by
+     * DOMPurify.
+     *
+     * This defaults to `true` starting DOMPurify 2.2.0. Note that setting it to `false`
+     * might cause XSS from attacks hidden in closed shadowroots in case the browser
+     * supports Declarative Shadow: DOM https://web.dev/declarative-shadow-dom/
+     */
+        var RETURN_DOM_IMPORT = true;
+
+        /* Try to return a Trusted Type object instead of a string, return a string in
+     * case Trusted Types are not supported  */
+        var RETURN_TRUSTED_TYPE = false;
+
+        /* Output should be free from DOM clobbering attacks? */
+        var SANITIZE_DOM = true;
+
+        /* Keep element content when removing element? */
+        var KEEP_CONTENT = true;
+
+        /* If a `Node` is passed to sanitize(), then performs sanitization in-place instead
+     * of importing it into a new Document and returning a sanitized copy */
+        var IN_PLACE = false;
+
+        /* Allow usage of profiles like html, svg and mathMl */
+        var USE_PROFILES = {};
+
+        /* Tags to ignore content of when KEEP_CONTENT is true */
+        var FORBID_CONTENTS = null;
+        var DEFAULT_FORBID_CONTENTS = addToSet({}, [ 'annotation-xml', 'audio', 'colgroup', 'desc', 'foreignobject', 'head', 'iframe', 'math', 'mi', 'mn', 'mo', 'ms', 'mtext', 'noembed', 'noframes', 'noscript', 'plaintext', 'script', 'style', 'svg', 'template', 'thead', 'title', 'video', 'xmp' ]);
+
+        /* Tags that are safe for data: URIs */
+        var DATA_URI_TAGS = null;
+        var DEFAULT_DATA_URI_TAGS = addToSet({}, [ 'audio', 'video', 'img', 'source', 'image', 'track' ]);
+
+        /* Attributes safe for values like "javascript:" */
+        var URI_SAFE_ATTRIBUTES = null;
+        var DEFAULT_URI_SAFE_ATTRIBUTES = addToSet({}, [ 'alt', 'class', 'for', 'id', 'label', 'name', 'pattern', 'placeholder', 'role', 'summary', 'title', 'value', 'style', 'xmlns' ]);
+
+        var MATHML_NAMESPACE = 'http://www.w3.org/1998/Math/MathML';
+        var SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
+        var HTML_NAMESPACE = 'http://www.w3.org/1999/xhtml';
+        /* Document namespace */
+        var NAMESPACE = HTML_NAMESPACE;
+        var IS_EMPTY_INPUT = false;
+
+        /* Keep a reference to config to pass to hooks */
+        var CONFIG = null;
+
+        /* Ideally, do not touch anything below this line */
+        /* ______________________________________________ */
+
+        var formElement = document.createElement('form');
+
+        /**
+         * _parseConfig
+         *
+         * @param  {Object} cfg optional config literal
+         */
+            // eslint-disable-next-line complexity
+        var _parseConfig = function _parseConfig(cfg) {
+                if (CONFIG && CONFIG === cfg) {
+                    return;
+                }
+
+                /* Shield configuration object from tampering */
+                if (!cfg || (typeof cfg === 'undefined' ? 'undefined' : _typeof(cfg)) !== 'object') {
+                    cfg = {};
+                }
+
+                /* Shield configuration object from prototype pollution */
+                cfg = clone(cfg);
+
+                /* Set configuration parameters */
+                ALLOWED_TAGS = 'ALLOWED_TAGS' in cfg ? addToSet({}, cfg.ALLOWED_TAGS) : DEFAULT_ALLOWED_TAGS;
+                ALLOWED_ATTR = 'ALLOWED_ATTR' in cfg ? addToSet({}, cfg.ALLOWED_ATTR) : DEFAULT_ALLOWED_ATTR;
+                URI_SAFE_ATTRIBUTES = 'ADD_URI_SAFE_ATTR' in cfg ? addToSet(clone(DEFAULT_URI_SAFE_ATTRIBUTES), cfg.ADD_URI_SAFE_ATTR) : DEFAULT_URI_SAFE_ATTRIBUTES;
+                DATA_URI_TAGS = 'ADD_DATA_URI_TAGS' in cfg ? addToSet(clone(DEFAULT_DATA_URI_TAGS), cfg.ADD_DATA_URI_TAGS) : DEFAULT_DATA_URI_TAGS;
+                FORBID_CONTENTS = 'FORBID_CONTENTS' in cfg ? addToSet({}, cfg.FORBID_CONTENTS) : DEFAULT_FORBID_CONTENTS;
+                FORBID_TAGS = 'FORBID_TAGS' in cfg ? addToSet({}, cfg.FORBID_TAGS) : {};
+                FORBID_ATTR = 'FORBID_ATTR' in cfg ? addToSet({}, cfg.FORBID_ATTR) : {};
+                USE_PROFILES = 'USE_PROFILES' in cfg ? cfg.USE_PROFILES : false;
+                ALLOW_ARIA_ATTR = cfg.ALLOW_ARIA_ATTR !== false; // Default true
+                ALLOW_DATA_ATTR = cfg.ALLOW_DATA_ATTR !== false; // Default true
+                ALLOW_UNKNOWN_PROTOCOLS = cfg.ALLOW_UNKNOWN_PROTOCOLS || false; // Default false
+                SAFE_FOR_TEMPLATES = cfg.SAFE_FOR_TEMPLATES || false; // Default false
+                WHOLE_DOCUMENT = cfg.WHOLE_DOCUMENT || false; // Default false
+                RETURN_DOM = cfg.RETURN_DOM || false; // Default false
+                RETURN_DOM_FRAGMENT = cfg.RETURN_DOM_FRAGMENT || false; // Default false
+                RETURN_DOM_IMPORT = cfg.RETURN_DOM_IMPORT !== false; // Default true
+                RETURN_TRUSTED_TYPE = cfg.RETURN_TRUSTED_TYPE || false; // Default false
+                FORCE_BODY = cfg.FORCE_BODY || false; // Default false
+                SANITIZE_DOM = cfg.SANITIZE_DOM !== false; // Default true
+                KEEP_CONTENT = cfg.KEEP_CONTENT !== false; // Default true
+                IN_PLACE = cfg.IN_PLACE || false; // Default false
+                IS_ALLOWED_URI$$1 = cfg.ALLOWED_URI_REGEXP || IS_ALLOWED_URI$$1;
+                NAMESPACE = cfg.NAMESPACE || HTML_NAMESPACE;
+                if (SAFE_FOR_TEMPLATES) {
+                    ALLOW_DATA_ATTR = false;
+                }
+
+                if (RETURN_DOM_FRAGMENT) {
+                    RETURN_DOM = true;
+                }
+
+                /* Parse profile info */
+                if (USE_PROFILES) {
+                    ALLOWED_TAGS = addToSet({}, [].concat(_toConsumableArray$1(text)));
+                    ALLOWED_ATTR = [];
+                    if (USE_PROFILES.html === true) {
+                        addToSet(ALLOWED_TAGS, html);
+                        addToSet(ALLOWED_ATTR, html$1);
+                    }
+
+                    if (USE_PROFILES.svg === true) {
+                        addToSet(ALLOWED_TAGS, svg);
+                        addToSet(ALLOWED_ATTR, svg$1);
+                        addToSet(ALLOWED_ATTR, xml);
+                    }
+
+                    if (USE_PROFILES.svgFilters === true) {
+                        addToSet(ALLOWED_TAGS, svgFilters);
+                        addToSet(ALLOWED_ATTR, svg$1);
+                        addToSet(ALLOWED_ATTR, xml);
+                    }
+
+                    if (USE_PROFILES.mathMl === true) {
+                        addToSet(ALLOWED_TAGS, mathMl);
+                        addToSet(ALLOWED_ATTR, mathMl$1);
+                        addToSet(ALLOWED_ATTR, xml);
+                    }
+                }
+
+                /* Merge configuration parameters */
+                if (cfg.ADD_TAGS) {
+                    if (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS) {
+                        ALLOWED_TAGS = clone(ALLOWED_TAGS);
+                    }
+
+                    addToSet(ALLOWED_TAGS, cfg.ADD_TAGS);
+                }
+
+                if (cfg.ADD_ATTR) {
+                    if (ALLOWED_ATTR === DEFAULT_ALLOWED_ATTR) {
+                        ALLOWED_ATTR = clone(ALLOWED_ATTR);
+                    }
+
+                    addToSet(ALLOWED_ATTR, cfg.ADD_ATTR);
+                }
+
+                if (cfg.ADD_URI_SAFE_ATTR) {
+                    addToSet(URI_SAFE_ATTRIBUTES, cfg.ADD_URI_SAFE_ATTR);
+                }
+
+                if (cfg.FORBID_CONTENTS) {
+                    if (FORBID_CONTENTS === DEFAULT_FORBID_CONTENTS) {
+                        FORBID_CONTENTS = clone(FORBID_CONTENTS);
+                    }
+
+                    addToSet(FORBID_CONTENTS, cfg.FORBID_CONTENTS);
+                }
+
+                /* Add #text in case KEEP_CONTENT is set to true */
+                if (KEEP_CONTENT) {
+                    ALLOWED_TAGS['#text'] = true;
+                }
+
+                /* Add html, head and body to ALLOWED_TAGS in case WHOLE_DOCUMENT is true */
+                if (WHOLE_DOCUMENT) {
+                    addToSet(ALLOWED_TAGS, [ 'html', 'head', 'body' ]);
+                }
+
+                /* Add tbody to ALLOWED_TAGS in case tables are permitted, see #286, #365 */
+                if (ALLOWED_TAGS.table) {
+                    addToSet(ALLOWED_TAGS, [ 'tbody' ]);
+                    delete FORBID_TAGS.tbody;
+                }
+
+                // Prevent further manipulation of configuration.
+                // Not available in IE8, Safari 5, etc.
+                if (freeze) {
+                    freeze(cfg);
+                }
+
+                CONFIG = cfg;
+            };
+
+        var MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, [ 'mi', 'mo', 'mn', 'ms', 'mtext' ]);
+
+        var HTML_INTEGRATION_POINTS = addToSet({}, [ 'foreignobject', 'desc', 'title', 'annotation-xml' ]);
+
+        /* Keep track of all possible SVG and MathML tags
+     * so that we can perform the namespace checks
+     * correctly. */
+        var ALL_SVG_TAGS = addToSet({}, svg);
+        addToSet(ALL_SVG_TAGS, svgFilters);
+        addToSet(ALL_SVG_TAGS, svgDisallowed);
+
+        var ALL_MATHML_TAGS = addToSet({}, mathMl);
+        addToSet(ALL_MATHML_TAGS, mathMlDisallowed);
+
+        /**
+         *
+         *
+         * @param  {Element} element a DOM element whose namespace is being checked
+         * @returns {boolean} Return false if the element has a
+         *  namespace that a spec-compliant parser would never
+         *  return. Return true otherwise.
+         */
+        var _checkValidNamespace = function _checkValidNamespace(element) {
+            var parent = getParentNode(element);
+
+            // In JSDOM, if we're inside shadow DOM, then parentNode
+            // can be null. We just simulate parent in this case.
+            if (!parent || !parent.tagName) {
+                parent = {
+                    namespaceURI: HTML_NAMESPACE,
+                    tagName: 'template',
+                };
+            }
+
+            var tagName = stringToLowerCase(element.tagName);
+            var parentTagName = stringToLowerCase(parent.tagName);
+
+            if (element.namespaceURI === SVG_NAMESPACE) {
+                // The only way to switch from HTML namespace to SVG
+                // is via <svg>. If it happens via any other tag, then
+                // it should be killed.
+                if (parent.namespaceURI === HTML_NAMESPACE) {
+                    return tagName === 'svg';
+                }
+
+                // The only way to switch from MathML to SVG is via
+                // svg if parent is either <annotation-xml> or MathML
+                // text integration points.
+                if (parent.namespaceURI === MATHML_NAMESPACE) {
+                    return tagName === 'svg' && (parentTagName === 'annotation-xml' || MATHML_TEXT_INTEGRATION_POINTS[parentTagName]);
+                }
+
+                // We only allow elements that are defined in SVG
+                // spec. All others are disallowed in SVG namespace.
+                return Boolean(ALL_SVG_TAGS[tagName]);
+            }
+
+            if (element.namespaceURI === MATHML_NAMESPACE) {
+                // The only way to switch from HTML namespace to MathML
+                // is via <math>. If it happens via any other tag, then
+                // it should be killed.
+                if (parent.namespaceURI === HTML_NAMESPACE) {
+                    return tagName === 'math';
+                }
+
+                // The only way to switch from SVG to MathML is via
+                // <math> and HTML integration points
+                if (parent.namespaceURI === SVG_NAMESPACE) {
+                    return tagName === 'math' && HTML_INTEGRATION_POINTS[parentTagName];
+                }
+
+                // We only allow elements that are defined in MathML
+                // spec. All others are disallowed in MathML namespace.
+                return Boolean(ALL_MATHML_TAGS[tagName]);
+            }
+
+            if (element.namespaceURI === HTML_NAMESPACE) {
+                // The only way to switch from SVG to HTML is via
+                // HTML integration points, and from MathML to HTML
+                // is via MathML text integration points
+                if (parent.namespaceURI === SVG_NAMESPACE && !HTML_INTEGRATION_POINTS[parentTagName]) {
+                    return false;
+                }
+
+                if (parent.namespaceURI === MATHML_NAMESPACE && !MATHML_TEXT_INTEGRATION_POINTS[parentTagName]) {
+                    return false;
+                }
+
+                // Certain elements are allowed in both SVG and HTML
+                // namespace. We need to specify them explicitly
+                // so that they don't get erronously deleted from
+                // HTML namespace.
+                var commonSvgAndHTMLElements = addToSet({}, [ 'title', 'style', 'font', 'a', 'script' ]);
+
+                // We disallow tags that are specific for MathML
+                // or SVG and should never appear in HTML namespace
+                return !ALL_MATHML_TAGS[tagName] && (commonSvgAndHTMLElements[tagName] || !ALL_SVG_TAGS[tagName]);
+            }
+
+            // The code should never reach this place (this means
+            // that the element somehow got namespace that is not
+            // HTML, SVG or MathML). Return false just in case.
+            return false;
+        };
+
+        /**
+         * _forceRemove
+         *
+         * @param  {Node} node a DOM node
+         */
+        var _forceRemove = function _forceRemove(node) {
+            arrayPush(DOMPurify.removed, { element: node });
+            try {
+                // eslint-disable-next-line unicorn/prefer-dom-node-remove
+                node.parentNode.removeChild(node);
+            } catch (_) {
+                try {
+                    node.outerHTML = emptyHTML;
+                } catch (_) {
+                    node.remove();
+                }
+            }
+        };
+
+        /**
+         * _removeAttribute
+         *
+         * @param  {String} name an Attribute name
+         * @param  {Node} node a DOM node
+         */
+        var _removeAttribute = function _removeAttribute(name, node) {
+            try {
+                arrayPush(DOMPurify.removed, {
+                    attribute: node.getAttributeNode(name),
+                    from: node,
+                });
+            } catch (_) {
+                arrayPush(DOMPurify.removed, {
+                    attribute: null,
+                    from: node,
+                });
+            }
+
+            node.removeAttribute(name);
+
+            // We void attribute values for unremovable "is"" attributes
+            if (name === 'is' && !ALLOWED_ATTR[name]) {
+                if (RETURN_DOM || RETURN_DOM_FRAGMENT) {
+                    try {
+                        _forceRemove(node);
+                    } catch (_) {
+                    }
+                } else {
+                    try {
+                        node.setAttribute(name, '');
+                    } catch (_) {
+                    }
+                }
+            }
+        };
+
+        /**
+         * _initDocument
+         *
+         * @param  {String} dirty a string of dirty markup
+         * @return {Document} a DOM, filled with the dirty markup
+         */
+        var _initDocument = function _initDocument(dirty) {
+            /* Create a HTML document */
+            var doc = void 0;
+            var leadingWhitespace = void 0;
+
+            if (FORCE_BODY) {
+                dirty = '<remove></remove>' + dirty;
+            } else {
+                /* If FORCE_BODY isn't used, leading whitespace needs to be preserved manually */
+                var matches = stringMatch(dirty, /^[\r\n\t ]+/);
+                leadingWhitespace = matches && matches[0];
+            }
+
+            var dirtyPayload = trustedTypesPolicy ? trustedTypesPolicy.createHTML(dirty) : dirty;
+            /*
+       * Use the DOMParser API by default, fallback later if needs be
+       * DOMParser not work for svg when has multiple root element.
+       */
+            if (NAMESPACE === HTML_NAMESPACE) {
+                try {
+                    doc = new DOMParser().parseFromString(dirtyPayload, 'text/html');
+                } catch (_) {
+                }
+            }
+
+            /* Use createHTMLDocument in case DOMParser is not available */
+            if (!doc || !doc.documentElement) {
+                doc = implementation.createDocument(NAMESPACE, 'template', null);
+                try {
+                    doc.documentElement.innerHTML = IS_EMPTY_INPUT ? '' : dirtyPayload;
+                } catch (_) {
+                    // Syntax error if dirtyPayload is invalid xml
+                }
+            }
+
+            var body = doc.body || doc.documentElement;
+
+            if (dirty && leadingWhitespace) {
+                body.insertBefore(document.createTextNode(leadingWhitespace), body.childNodes[0] || null);
+            }
+
+            /* Work on whole document or just its body */
+            if (NAMESPACE === HTML_NAMESPACE) {
+                return getElementsByTagName.call(doc, WHOLE_DOCUMENT ? 'html' : 'body')[0];
+            }
+
+            return WHOLE_DOCUMENT ? doc.documentElement : body;
+        };
+
+        /**
+         * _createIterator
+         *
+         * @param  {Document} root document/fragment to create iterator for
+         * @return {Iterator} iterator instance
+         */
+        var _createIterator = function _createIterator(root) {
+            return createNodeIterator.call(root.ownerDocument || root, root, NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_TEXT, null, false);
+        };
+
+        /**
+         * _isClobbered
+         *
+         * @param  {Node} elm element to check for clobbering attacks
+         * @return {Boolean} true if clobbered, false if safe
+         */
+        var _isClobbered = function _isClobbered(elm) {
+            if (elm instanceof Text || elm instanceof Comment) {
+                return false;
+            }
+
+            if (typeof elm.nodeName !== 'string' || typeof elm.textContent !== 'string' || typeof elm.removeChild !== 'function' || !(elm.attributes instanceof NamedNodeMap) || typeof elm.removeAttribute !== 'function' || typeof elm.setAttribute !== 'function' || typeof elm.namespaceURI !== 'string' || typeof elm.insertBefore !== 'function') {
+                return true;
+            }
+
+            return false;
+        };
+
+        /**
+         * _isNode
+         *
+         * @param  {Node} obj object to check whether it's a DOM node
+         * @return {Boolean} true is object is a DOM node
+         */
+        var _isNode = function _isNode(object) {
+            return (typeof Node === 'undefined' ? 'undefined' : _typeof(Node)) === 'object' ? object instanceof Node : object && (typeof object === 'undefined' ? 'undefined' : _typeof(object)) === 'object' && typeof object.nodeType === 'number' && typeof object.nodeName === 'string';
+        };
+
+        /**
+         * _executeHook
+         * Execute user configurable hooks
+         *
+         * @param  {String} entryPoint  Name of the hook's entry point
+         * @param  {Node} currentNode node to work on with the hook
+         * @param  {Object} data additional hook parameters
+         */
+        var _executeHook = function _executeHook(entryPoint, currentNode, data) {
+            if (!hooks[entryPoint]) {
+                return;
+            }
+
+            arrayForEach(hooks[entryPoint], function (hook) {
+                hook.call(DOMPurify, currentNode, data, CONFIG);
+            });
+        };
+
+        /**
+         * _sanitizeElements
+         *
+         * @protect nodeName
+         * @protect textContent
+         * @protect removeChild
+         *
+         * @param   {Node} currentNode to check for permission to exist
+         * @return  {Boolean} true if node was killed, false if left alive
+         */
+        var _sanitizeElements = function _sanitizeElements(currentNode) {
+            var content = void 0;
+
+            /* Execute a hook if present */
+            _executeHook('beforeSanitizeElements', currentNode, null);
+
+            /* Check if element is clobbered or can clobber */
+            if (_isClobbered(currentNode)) {
+                _forceRemove(currentNode);
+                return true;
+            }
+
+            /* Check if tagname contains Unicode */
+            if (stringMatch(currentNode.nodeName, /[\u0080-\uFFFF]/)) {
+                _forceRemove(currentNode);
+                return true;
+            }
+
+            /* Now let's check the element's type and name */
+            var tagName = stringToLowerCase(currentNode.nodeName);
+
+            /* Execute a hook if present */
+            _executeHook('uponSanitizeElement', currentNode, {
+                tagName: tagName,
+                allowedTags: ALLOWED_TAGS,
+            });
+
+            /* Detect mXSS attempts abusing namespace confusion */
+            if (!_isNode(currentNode.firstElementChild) && (!_isNode(currentNode.content) || !_isNode(currentNode.content.firstElementChild)) && regExpTest(/<[/\w]/g, currentNode.innerHTML) && regExpTest(/<[/\w]/g, currentNode.textContent)) {
+                _forceRemove(currentNode);
+                return true;
+            }
+
+            /* Mitigate a problem with templates inside select */
+            if (tagName === 'select' && regExpTest(/<template/i, currentNode.innerHTML)) {
+                _forceRemove(currentNode);
+                return true;
+            }
+
+            /* Remove element if anything forbids its presence */
+            if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {
+                /* Keep content except for bad-listed elements */
+                if (KEEP_CONTENT && !FORBID_CONTENTS[tagName]) {
+                    var parentNode = getParentNode(currentNode) || currentNode.parentNode;
+                    var childNodes = getChildNodes(currentNode) || currentNode.childNodes;
+
+                    if (childNodes && parentNode) {
+                        var childCount = childNodes.length;
+
+                        for (var i = childCount - 1; i >= 0; --i) {
+                            parentNode.insertBefore(cloneNode(childNodes[i], true), getNextSibling(currentNode));
+                        }
+                    }
+                }
+
+                _forceRemove(currentNode);
+                return true;
+            }
+
+            /* Check whether element has a valid namespace */
+            if (currentNode instanceof Element && !_checkValidNamespace(currentNode)) {
+                _forceRemove(currentNode);
+                return true;
+            }
+
+            if ((tagName === 'noscript' || tagName === 'noembed') && regExpTest(/<\/no(script|embed)/i, currentNode.innerHTML)) {
+                _forceRemove(currentNode);
+                return true;
+            }
+
+            /* Sanitize element content to be template-safe */
+            if (SAFE_FOR_TEMPLATES && currentNode.nodeType === 3) {
+                /* Get the element's text content */
+                content = currentNode.textContent;
+                content = stringReplace(content, MUSTACHE_EXPR$$1, ' ');
+                content = stringReplace(content, ERB_EXPR$$1, ' ');
+                if (currentNode.textContent !== content) {
+                    arrayPush(DOMPurify.removed, { element: currentNode.cloneNode() });
+                    currentNode.textContent = content;
+                }
+            }
+
+            /* Execute a hook if present */
+            _executeHook('afterSanitizeElements', currentNode, null);
+
+            return false;
+        };
+
+        /**
+         * _isValidAttribute
+         *
+         * @param  {string} lcTag Lowercase tag name of containing element.
+         * @param  {string} lcName Lowercase attribute name.
+         * @param  {string} value Attribute value.
+         * @return {Boolean} Returns true if `value` is valid, otherwise false.
+         */
+            // eslint-disable-next-line complexity
+        var _isValidAttribute = function _isValidAttribute(lcTag, lcName, value) {
+                /* Make sure attribute cannot clobber */
+                if (SANITIZE_DOM && (lcName === 'id' || lcName === 'name') && (value in document || value in formElement)) {
+                    return false;
+                }
+
+                /* Allow valid data-* attributes: At least one character after "-"
+          (https://html.spec.whatwg.org/multipage/dom.html#embedding-custom-non-visible-data-with-the-data-*-attributes)
+          XML-compatible (https://html.spec.whatwg.org/multipage/infrastructure.html#xml-compatible and http://www.w3.org/TR/xml/#d0e804)
+          We don't need to check the value; it's always URI safe. */
+                if (ALLOW_DATA_ATTR && !FORBID_ATTR[lcName] && regExpTest(DATA_ATTR$$1, lcName)) ; else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR$$1, lcName)) ; else if (!ALLOWED_ATTR[lcName] || FORBID_ATTR[lcName]) {
+                    return false;
+
+                    /* Check value is safe. First, is attr inert? If so, is safe */
+                } else if (URI_SAFE_ATTRIBUTES[lcName]) ; else if (regExpTest(IS_ALLOWED_URI$$1, stringReplace(value, ATTR_WHITESPACE$$1, ''))) ; else if ((lcName === 'src' || lcName === 'xlink:href' || lcName === 'href') && lcTag !== 'script' && stringIndexOf(value, 'data:') === 0 && DATA_URI_TAGS[lcTag]) ; else if (ALLOW_UNKNOWN_PROTOCOLS && !regExpTest(IS_SCRIPT_OR_DATA$$1, stringReplace(value, ATTR_WHITESPACE$$1, ''))) ; else if (!value) ; else {
+                    return false;
+                }
+
+                return true;
+            };
+
+        /**
+         * _sanitizeAttributes
+         *
+         * @protect attributes
+         * @protect nodeName
+         * @protect removeAttribute
+         * @protect setAttribute
+         *
+         * @param  {Node} currentNode to sanitize
+         */
+        var _sanitizeAttributes = function _sanitizeAttributes(currentNode) {
+            var attr = void 0;
+            var value = void 0;
+            var lcName = void 0;
+            var l = void 0;
+            /* Execute a hook if present */
+            _executeHook('beforeSanitizeAttributes', currentNode, null);
+
+            var attributes = currentNode.attributes;
+
+            /* Check if we have attributes; if not we might have a text node */
+
+            if (!attributes) {
+                return;
+            }
+
+            var hookEvent = {
+                attrName: '',
+                attrValue: '',
+                keepAttr: true,
+                allowedAttributes: ALLOWED_ATTR,
+            };
+            l = attributes.length;
+
+            /* Go backwards over all attributes; safely remove bad ones */
+            while (l--) {
+                attr = attributes[l];
+                var _attr = attr,
+                    name = _attr.name,
+                    namespaceURI = _attr.namespaceURI;
+
+                value = stringTrim(attr.value);
+                lcName = stringToLowerCase(name);
+
+                /* Execute a hook if present */
+                hookEvent.attrName = lcName;
+                hookEvent.attrValue = value;
+                hookEvent.keepAttr = true;
+                hookEvent.forceKeepAttr = undefined; // Allows developers to see this is a property they can set
+                _executeHook('uponSanitizeAttribute', currentNode, hookEvent);
+                value = hookEvent.attrValue;
+                /* Did the hooks approve of the attribute? */
+                if (hookEvent.forceKeepAttr) {
+                    continue;
+                }
+
+                /* Remove attribute */
+                _removeAttribute(name, currentNode);
+
+                /* Did the hooks approve of the attribute? */
+                if (!hookEvent.keepAttr) {
+                    continue;
+                }
+
+                /* Work around a security issue in jQuery 3.0 */
+                if (regExpTest(/\/>/i, value)) {
+                    _removeAttribute(name, currentNode);
+                    continue;
+                }
+
+                /* Sanitize attribute content to be template-safe */
+                if (SAFE_FOR_TEMPLATES) {
+                    value = stringReplace(value, MUSTACHE_EXPR$$1, ' ');
+                    value = stringReplace(value, ERB_EXPR$$1, ' ');
+                }
+
+                /* Is `value` valid for this attribute? */
+                var lcTag = currentNode.nodeName.toLowerCase();
+                if (!_isValidAttribute(lcTag, lcName, value)) {
+                    continue;
+                }
+
+                /* Handle invalid data-* attribute set by try-catching it */
+                try {
+                    if (namespaceURI) {
+                        currentNode.setAttributeNS(namespaceURI, name, value);
+                    } else {
+                        /* Fallback to setAttribute() for browser-unrecognized namespaces e.g. "x-schema". */
+                        currentNode.setAttribute(name, value);
+                    }
+
+                    arrayPop(DOMPurify.removed);
+                } catch (_) {
+                }
+            }
+
+            /* Execute a hook if present */
+            _executeHook('afterSanitizeAttributes', currentNode, null);
+        };
+
+        /**
+         * _sanitizeShadowDOM
+         *
+         * @param  {DocumentFragment} fragment to iterate over recursively
+         */
+        var _sanitizeShadowDOM = function _sanitizeShadowDOM(fragment) {
+            var shadowNode = void 0;
+            var shadowIterator = _createIterator(fragment);
+
+            /* Execute a hook if present */
+            _executeHook('beforeSanitizeShadowDOM', fragment, null);
+
+            while (shadowNode = shadowIterator.nextNode()) {
+                /* Execute a hook if present */
+                _executeHook('uponSanitizeShadowNode', shadowNode, null);
+
+                /* Sanitize tags and elements */
+                if (_sanitizeElements(shadowNode)) {
+                    continue;
+                }
+
+                /* Deep shadow DOM detected */
+                if (shadowNode.content instanceof DocumentFragment) {
+                    _sanitizeShadowDOM(shadowNode.content);
+                }
+
+                /* Check attributes, sanitize if necessary */
+                _sanitizeAttributes(shadowNode);
+            }
+
+            /* Execute a hook if present */
+            _executeHook('afterSanitizeShadowDOM', fragment, null);
+        };
+
+        /**
+         * Sanitize
+         * Public method providing core sanitation functionality
+         *
+         * @param {String|Node} dirty string or DOM node
+         * @param {Object} configuration object
+         */
+        // eslint-disable-next-line complexity
+        DOMPurify.sanitize = function (dirty, cfg) {
+            var body = void 0;
+            var importedNode = void 0;
+            var currentNode = void 0;
+            var oldNode = void 0;
+            var returnNode = void 0;
+            /* Make sure we have a string to sanitize.
+        DO NOT return early, as this will return the wrong type if
+        the user has requested a DOM object rather than a string */
+            IS_EMPTY_INPUT = !dirty;
+            if (IS_EMPTY_INPUT) {
+                dirty = '<!-->';
+            }
+
+            /* Stringify, in case dirty is an object */
+            if (typeof dirty !== 'string' && !_isNode(dirty)) {
+                // eslint-disable-next-line no-negated-condition
+                if (typeof dirty.toString !== 'function') {
+                    throw typeErrorCreate('toString is not a function');
+                } else {
+                    dirty = dirty.toString();
+                    if (typeof dirty !== 'string') {
+                        throw typeErrorCreate('dirty is not a string, aborting');
+                    }
+                }
+            }
+
+            /* Check we can run. Otherwise fall back or ignore */
+            if (!DOMPurify.isSupported) {
+                if (_typeof(window.toStaticHTML) === 'object' || typeof window.toStaticHTML === 'function') {
+                    if (typeof dirty === 'string') {
+                        return window.toStaticHTML(dirty);
+                    }
+
+                    if (_isNode(dirty)) {
+                        return window.toStaticHTML(dirty.outerHTML);
+                    }
+                }
+
+                return dirty;
+            }
+
+            /* Assign config vars */
+            if (!SET_CONFIG) {
+                _parseConfig(cfg);
+            }
+
+            /* Clean up removed elements */
+            DOMPurify.removed = [];
+
+            /* Check if dirty is correctly typed for IN_PLACE */
+            if (typeof dirty === 'string') {
+                IN_PLACE = false;
+            }
+
+            if (IN_PLACE) ; else if (dirty instanceof Node) {
+                /* If dirty is a DOM element, append to an empty document to avoid
+           elements being stripped by the parser */
+                body = _initDocument('<!---->');
+                importedNode = body.ownerDocument.importNode(dirty, true);
+                if (importedNode.nodeType === 1 && importedNode.nodeName === 'BODY') {
+                    /* Node is already a body, use as is */
+                    body = importedNode;
+                } else if (importedNode.nodeName === 'HTML') {
+                    body = importedNode;
+                } else {
+                    // eslint-disable-next-line unicorn/prefer-dom-node-append
+                    body.appendChild(importedNode);
+                }
+            } else {
+                /* Exit directly if we have nothing to do */
+                if (!RETURN_DOM && !SAFE_FOR_TEMPLATES && !WHOLE_DOCUMENT &&
+                    // eslint-disable-next-line unicorn/prefer-includes
+                    dirty.indexOf('<') === -1) {
+                    return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(dirty) : dirty;
+                }
+
+                /* Initialize the document to work on */
+                body = _initDocument(dirty);
+
+                /* Check we have a DOM node from the data */
+                if (!body) {
+                    return RETURN_DOM ? null : emptyHTML;
+                }
+            }
+
+            /* Remove first element node (ours) if FORCE_BODY is set */
+            if (body && FORCE_BODY) {
+                _forceRemove(body.firstChild);
+            }
+
+            /* Get node iterator */
+            var nodeIterator = _createIterator(IN_PLACE ? dirty : body);
+
+            /* Now start iterating over the created document */
+            while (currentNode = nodeIterator.nextNode()) {
+                /* Fix IE's strange behavior with manipulated textNodes #89 */
+                if (currentNode.nodeType === 3 && currentNode === oldNode) {
+                    continue;
+                }
+
+                /* Sanitize tags and elements */
+                if (_sanitizeElements(currentNode)) {
+                    continue;
+                }
+
+                /* Shadow DOM detected, sanitize it */
+                if (currentNode.content instanceof DocumentFragment) {
+                    _sanitizeShadowDOM(currentNode.content);
+                }
+
+                /* Check attributes, sanitize if necessary */
+                _sanitizeAttributes(currentNode);
+
+                oldNode = currentNode;
+            }
+
+            oldNode = null;
+
+            /* If we sanitized `dirty` in-place, return it. */
+            if (IN_PLACE) {
+                return dirty;
+            }
+
+            /* Return sanitized string or DOM */
+            if (RETURN_DOM) {
+                if (RETURN_DOM_FRAGMENT) {
+                    returnNode = createDocumentFragment.call(body.ownerDocument);
+
+                    while (body.firstChild) {
+                        // eslint-disable-next-line unicorn/prefer-dom-node-append
+                        returnNode.appendChild(body.firstChild);
+                    }
+                } else {
+                    returnNode = body;
+                }
+
+                if (RETURN_DOM_IMPORT) {
+                    /*
+            AdoptNode() is not used because internal state is not reset
+            (e.g. the past names map of a HTMLFormElement), this is safe
+            in theory but we would rather not risk another attack vector.
+            The state that is cloned by importNode() is explicitly defined
+            by the specs.
+          */
+                    returnNode = importNode.call(originalDocument, returnNode, true);
+                }
+
+                return returnNode;
+            }
+
+            var serializedHTML = WHOLE_DOCUMENT ? body.outerHTML : body.innerHTML;
+
+            /* Sanitize final string template-safe */
+            if (SAFE_FOR_TEMPLATES) {
+                serializedHTML = stringReplace(serializedHTML, MUSTACHE_EXPR$$1, ' ');
+                serializedHTML = stringReplace(serializedHTML, ERB_EXPR$$1, ' ');
+            }
+
+            return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(serializedHTML) : serializedHTML;
+        };
+
+        /**
+         * Public method to set the configuration once
+         * setConfig
+         *
+         * @param {Object} cfg configuration object
+         */
+        DOMPurify.setConfig = function (cfg) {
+            _parseConfig(cfg);
+            SET_CONFIG = true;
+        };
+
+        /**
+         * Public method to remove the configuration
+         * clearConfig
+         *
+         */
+        DOMPurify.clearConfig = function () {
+            CONFIG = null;
+            SET_CONFIG = false;
+        };
+
+        /**
+         * Public method to check if an attribute value is valid.
+         * Uses last set config, if any. Otherwise, uses config defaults.
+         * isValidAttribute
+         *
+         * @param  {string} tag Tag name of containing element.
+         * @param  {string} attr Attribute name.
+         * @param  {string} value Attribute value.
+         * @return {Boolean} Returns true if `value` is valid. Otherwise, returns false.
+         */
+        DOMPurify.isValidAttribute = function (tag, attr, value) {
+            /* Initialize shared config vars if necessary. */
+            if (!CONFIG) {
+                _parseConfig({});
+            }
+
+            var lcTag = stringToLowerCase(tag);
+            var lcName = stringToLowerCase(attr);
+            return _isValidAttribute(lcTag, lcName, value);
+        };
+
+        /**
+         * AddHook
+         * Public method to add DOMPurify hooks
+         *
+         * @param {String} entryPoint entry point for the hook to add
+         * @param {Function} hookFunction function to execute
+         */
+        DOMPurify.addHook = function (entryPoint, hookFunction) {
+            if (typeof hookFunction !== 'function') {
+                return;
+            }
+
+            hooks[entryPoint] = hooks[entryPoint] || [];
+            arrayPush(hooks[entryPoint], hookFunction);
+        };
+
+        /**
+         * RemoveHook
+         * Public method to remove a DOMPurify hook at a given entryPoint
+         * (pops it from the stack of hooks if more are present)
+         *
+         * @param {String} entryPoint entry point for the hook to remove
+         */
+        DOMPurify.removeHook = function (entryPoint) {
+            if (hooks[entryPoint]) {
+                arrayPop(hooks[entryPoint]);
+            }
+        };
+
+        /**
+         * RemoveHooks
+         * Public method to remove all DOMPurify hooks at a given entryPoint
+         *
+         * @param  {String} entryPoint entry point for the hooks to remove
+         */
+        DOMPurify.removeHooks = function (entryPoint) {
+            if (hooks[entryPoint]) {
+                hooks[entryPoint] = [];
+            }
+        };
+
+        /**
+         * RemoveAllHooks
+         * Public method to remove all DOMPurify hooks
+         *
+         */
+        DOMPurify.removeAllHooks = function () {
+            hooks = {};
+        };
+
+        return DOMPurify;
+    }
+
+    var purify = createDOMPurify();
+
+    var barEl;
+    var timeId;
+
+    /**
+     * Init progress component
+     */
+    function init() {
+        var div = create('div');
+
+        div.classList.add('progress');
+        appendTo(body, div);
+        barEl = div;
+    }
+
+    /**
+     * Render progress bar
+     */
+    function progressbar(ref) {
+        var loaded = ref.loaded;
+        var total = ref.total;
+        var step = ref.step;
+
+        var num;
+
+        !barEl && init();
+
+        if (step) {
+            num = parseInt(barEl.style.width || 0, 10) + step;
+            num = num > 80 ? 80 : num;
+        } else {
+            num = Math.floor((loaded / total) * 100);
+        }
+
+        barEl.style.opacity = 1;
+        barEl.style.width = num >= 95 ? '100%' : num + '%';
+
+        if (num >= 95) {
+            clearTimeout(timeId);
+            // eslint-disable-next-line no-unused-vars
+            timeId = setTimeout(function (_) {
+                barEl.style.opacity = 0;
+                barEl.style.width = '0%';
+            }, 200);
+        }
+    }
+
+    /* eslint-disable no-unused-vars */
+
+    var cache = {};
+
+    /**
+     * Ajax GET implmentation
+     * @param {string} url Resource URL
+     * @param {boolean} [hasBar=false] Has progress bar
+     * @param {String[]} headers Array of headers
+     * @return {Promise} Promise response
+     */
+    function get(url, hasBar, headers) {
+        if (hasBar === void 0) hasBar = false;
+        if (headers === void 0) headers = {};
+
+        var xhr = new XMLHttpRequest();
+        var on = function () {
+            xhr.addEventListener.apply(xhr, arguments);
+        };
+
+        var cached = cache[url];
+
+        if (cached) {
+            return {
+                then: function (cb) {
+                    return cb(cached.content, cached.opt);
+                }, abort: noop,
+            };
+        }
+
+        xhr.open('GET', url);
+        for (var i in headers) {
+            if (hasOwn.call(headers, i)) {
+                xhr.setRequestHeader(i, headers[i]);
+            }
+        }
+
+        xhr.send();
+
+        return {
+            then: function (success, error) {
+                if (error === void 0) error = noop;
+
+                if (hasBar) {
+                    var id = setInterval(
+                        function (_) {
+                            return progressbar({
+                                step: Math.floor(Math.random() * 5 + 1),
+                            });
+                        },
+                        500,
+                    );
+
+                    on('progress', progressbar);
+                    on('loadend', function (evt) {
+                        progressbar(evt);
+                        clearInterval(id);
+                    });
+                }
+
+                on('error', error);
+                on('load', function (ref) {
+                    var target = ref.target;
+
+                    if (target.status >= 400) {
+                        error(target);
+                    } else {
+                        var result = (cache[url] = {
+                            content: target.response,
+                            opt: {
+                                updatedAt: xhr.getResponseHeader('last-modified'),
+                            },
+                        });
+
+                        success(result.content, result.opt);
+                    }
+                });
+            },
+            abort: function (_) {
+                return xhr.readyState !== 4 && xhr.abort();
+            },
+        };
+    }
+
+    function replaceVar(block, color) {
+        block.innerHTML = block.innerHTML.replace(
+            /var\(\s*--theme-color.*?\)/g,
+            color,
+        );
+    }
+
+    function cssVars(color) {
+        // Variable support
+        if (window.CSS && window.CSS.supports && window.CSS.supports('(--v:red)')) {
+            return;
+        }
+
+        var styleBlocks = findAll('style:not(.inserted),link');
+        [].forEach.call(styleBlocks, function (block) {
+            if (block.nodeName === 'STYLE') {
+                replaceVar(block, color);
+            } else if (block.nodeName === 'LINK') {
+                var href = block.getAttribute('href');
+
+                if (!/\.css$/.test(href)) {
+                    return;
+                }
+
+                get(href).then(function (res) {
+                    var style = create('style', res);
+
+                    head.appendChild(style);
+                    replaceVar(style, color);
+                });
+            }
+        });
+    }
+
+    /* eslint-disable no-unused-vars */
+
+    var title = $.title;
+
+    /**
+     * Toggle button
+     * @param {Element} el Button to be toggled
+     * @void
+     */
+    function btn(el) {
+        var toggle = function (_) {
+            return body.classList.toggle('close');
+        };
+
+        el = getNode(el);
+        if (el === null || el === undefined) {
+            return;
+        }
+
+        on(el, 'click', function (e) {
+            e.stopPropagation();
+            toggle();
+        });
+
+        isMobile &&
+        on(
+            body,
+            'click',
+            function (_) {
+                return body.classList.contains('close') && toggle();
+            },
+        );
+    }
+
+    function collapse(el) {
+        el = getNode(el);
+        if (el === null || el === undefined) {
+            return;
+        }
+
+        on(el, 'click', function (ref) {
+            var target = ref.target;
+
+            if (
+                target.nodeName === 'A' &&
+                target.nextSibling &&
+                target.nextSibling.classList &&
+                target.nextSibling.classList.contains('app-sub-sidebar')
+            ) {
+                toggleClass(target.parentNode, 'collapse');
+            }
+        });
+    }
+
+    function sticky() {
+        var cover = getNode('section.cover');
+        if (!cover) {
+            return;
+        }
+
+        var coverHeight = cover.getBoundingClientRect().height;
+
+        if (window.pageYOffset >= coverHeight || cover.classList.contains('hidden')) {
+            toggleClass(body, 'add', 'sticky');
+        } else {
+            toggleClass(body, 'remove', 'sticky');
+        }
+    }
+
+    /**
+     * Get and active link
+     * @param  {Object} router Router
+     * @param  {String|Element} el Target element
+     * @param  {Boolean} isParent Active parent
+     * @param  {Boolean} autoTitle Automatically set title
+     * @return {Element} Active element
+     */
+    function getAndActive(router, el, isParent, autoTitle) {
+        el = getNode(el);
+        var links = [];
+        if (el !== null && el !== undefined) {
+            links = findAll(el, 'a');
+        }
+
+        var hash = decodeURI(router.toURL(router.getCurrentPath()));
+        var target;
+
+        links
+            .sort(function (a, b) {
+                return b.href.length - a.href.length;
+            })
+            .forEach(function (a) {
+                var href = decodeURI(a.getAttribute('href'));
+                var node = isParent ? a.parentNode : a;
+
+                a.title = a.title || a.innerText;
+
+                if (hash.indexOf(href) === 0 && !target) {
+                    target = a;
+                    toggleClass(node, 'add', 'active');
+                } else {
+                    toggleClass(node, 'remove', 'active');
+                }
+            });
+
+        if (autoTitle) {
+            $.title = target
+                ? target.title || ((target.innerText) + ' - ' + title)
+                : title;
+        }
+
+        return target;
+    }
+
+    var _createClass = function () {
+        function defineProperties(target, props) {
+            for (var i = 0; i < props.length; i++) {
+                var descriptor = props[i];
+                descriptor.enumerable = descriptor.enumerable || false;
+                descriptor.configurable = true;
+                if ('value' in descriptor) {
+                    descriptor.writable = true;
+                }
+                Object.defineProperty(target, descriptor.key, descriptor);
+            }
+        }
+
+        return function (Constructor, protoProps, staticProps) {
+            if (protoProps) {
+                defineProperties(Constructor.prototype, protoProps);
+            }
+            if (staticProps) {
+                defineProperties(Constructor, staticProps);
+            }
+            return Constructor;
+        };
+    }();
+
+    function _classCallCheck(instance, Constructor) {
+        if (!(instance instanceof Constructor)) {
+            throw new TypeError('Cannot call a class as a function');
+        }
+    }
+
+    var SingleTweener = function () {
+        function SingleTweener() {
+            var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+            _classCallCheck(this, SingleTweener);
+
+            this.start = opts.start;
+            this.end = opts.end;
+            this.decimal = opts.decimal;
+        }
+
+        _createClass(SingleTweener, [ {
+            key: 'getIntermediateValue',
+            value: function getIntermediateValue(tick) {
+                if (this.decimal) {
+                    return tick;
+                } else {
+                    return Math.round(tick);
+                }
+            },
+        }, {
+            key: 'getFinalValue',
+            value: function getFinalValue() {
+                return this.end;
+            },
+        } ]);
+
+        return SingleTweener;
+    }();
+
+    var _createClass$1 = function () {
+        function defineProperties(target, props) {
+            for (var i = 0; i < props.length; i++) {
+                var descriptor = props[i];
+                descriptor.enumerable = descriptor.enumerable || false;
+                descriptor.configurable = true;
+                if ('value' in descriptor) {
+                    descriptor.writable = true;
+                }
+                Object.defineProperty(target, descriptor.key, descriptor);
+            }
+        }
+
+        return function (Constructor, protoProps, staticProps) {
+            if (protoProps) {
+                defineProperties(Constructor.prototype, protoProps);
+            }
+            if (staticProps) {
+                defineProperties(Constructor, staticProps);
+            }
+            return Constructor;
+        };
+    }();
+
+    function _classCallCheck$1(instance, Constructor) {
+        if (!(instance instanceof Constructor)) {
+            throw new TypeError('Cannot call a class as a function');
+        }
+    }
+
+    var Tweezer = function () {
+        function Tweezer() {
+            var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+            _classCallCheck$1(this, Tweezer);
+
+            this.duration = opts.duration || 1000;
+            this.ease = opts.easing || this._defaultEase;
+            this.tweener = opts.tweener || new SingleTweener(opts);
+            this.start = this.tweener.start;
+            this.end = this.tweener.end;
+
+            this.frame = null;
+            this.next = null;
+            this.isRunning = false;
+            this.events = {};
+            this.direction = this.start < this.end ? 'up' : 'down';
+        }
+
+        _createClass$1(Tweezer, [ {
+            key: 'begin',
+            value: function begin() {
+                if (!this.isRunning && this.next !== this.end) {
+                    this.frame = window.requestAnimationFrame(this._tick.bind(this));
+                }
+                return this;
+            },
+        }, {
+            key: 'stop',
+            value: function stop() {
+                window.cancelAnimationFrame(this.frame);
+                this.isRunning = false;
+                this.frame = null;
+                this.timeStart = null;
+                this.next = null;
+                return this;
+            },
+        }, {
+            key: 'on',
+            value: function on(name, handler) {
+                this.events[name] = this.events[name] || [];
+                this.events[name].push(handler);
+                return this;
+            },
+        }, {
+            key: '_emit',
+            value: function _emit(name, val) {
+                var _this = this;
+
+                var e = this.events[name];
+                e && e.forEach(function (handler) {
+                    return handler.call(_this, val);
+                });
+            },
+        }, {
+            key: '_tick',
+            value: function _tick(currentTime) {
+                this.isRunning = true;
+
+                var lastTick = this.next || this.start;
+
+                if (!this.timeStart) {
+                    this.timeStart = currentTime;
+                }
+                this.timeElapsed = currentTime - this.timeStart;
+                this.next = this.ease(this.timeElapsed, this.start, this.end - this.start, this.duration);
+
+                if (this._shouldTick(lastTick)) {
+                    this._emit('tick', this.tweener.getIntermediateValue(this.next));
+                    this.frame = window.requestAnimationFrame(this._tick.bind(this));
+                } else {
+                    this._emit('tick', this.tweener.getFinalValue());
+                    this._emit('done', null);
+                }
+            },
+        }, {
+            key: '_shouldTick',
+            value: function _shouldTick(lastTick) {
+                return {
+                    up: this.next < this.end && lastTick <= this.next,
+                    down: this.next > this.end && lastTick >= this.next,
+                }[this.direction];
+            },
+        }, {
+            key: '_defaultEase',
+            value: function _defaultEase(t, b, c, d) {
+                if ((t /= d / 2) < 1) {
+                    return c / 2 * t * t + b;
+                }
+                return -c / 2 * (--t * (t - 2) - 1) + b;
+            },
+        } ]);
+
+        return Tweezer;
+    }();
+
+    var currentScript = document.currentScript;
+
+    /** @param {import('./Docsify').Docsify} vm */
+    function config(vm) {
+        var config = merge(
+            {
+                el: '#app',
+                repo: '',
+                maxLevel: 6,
+                subMaxLevel: 0,
+                loadSidebar: null,
+                loadNavbar: null,
+                homepage: 'README.md',
+                coverpage: '',
+                basePath: '',
+                auto2top: false,
+                name: '',
+                themeColor: '',
+                nameLink: window.location.pathname,
+                autoHeader: false,
+                executeScript: null,
+                noEmoji: false,
+                ga: '',
+                ext: '.md',
+                mergeNavbar: false,
+                formatUpdated: '',
+                // This config for the links inside markdown
+                externalLinkTarget: '_blank',
+                // This config for the corner
+                cornerExternalLinkTarget: '_blank',
+                externalLinkRel: 'noopener',
+                routerMode: 'hash',
+                noCompileLinks: [],
+                crossOriginLinks: [],
+                relativePath: false,
+                topMargin: 0,
+            },
+            typeof window.$docsify === 'function'
+                ? window.$docsify(vm)
+                : window.$docsify,
+        );
+
+        var script =
+            currentScript ||
+            [].slice
+                .call(document.getElementsByTagName('script'))
+                .filter(function (n) {
+                    return /docsify\./.test(n.src);
+                })[0];
+
+        if (script) {
+            for (var prop in config) {
+                if (hasOwn.call(config, prop)) {
+                    var val = script.getAttribute('data-' + hyphenate(prop));
+
+                    if (isPrimitive(val)) {
+                        config[prop] = val === '' ? true : val;
+                    }
+                }
+            }
+        }
+
+        if (config.loadSidebar === true) {
+            config.loadSidebar = 'sidebar' + config.ext;
+        }
+
+        if (config.loadNavbar === true) {
+            config.loadNavbar = 'navbar' + config.ext;
+        }
+
+        if (config.coverpage === true) {
+            config.coverpage = 'coverpage' + config.ext;
+        }
+
+        if (config.repo === true) {
+            config.repo = '';
+        }
+
+        if (config.name === true) {
+            config.name = '';
+        }
+
+        window.$docsify = config;
+
+        return config;
+    }
+
+    var nav = {};
+    var hoverOver = false;
+    var scroller = null;
+    var enableScrollEvent = true;
+    var coverHeight = 0;
+
+    function scrollTo(el, offset) {
+        if (offset === void 0) offset = 0;
+
+        if (scroller) {
+            scroller.stop();
+        }
+
+        enableScrollEvent = false;
+        scroller = new Tweezer({
+            start: window.pageYOffset,
+            end:
+                Math.round(el.getBoundingClientRect().top) + window.pageYOffset - offset,
+            duration: 500,
+        })
+            .on('tick', function (v) {
+                return window.scrollTo(0, v);
+            })
+            .on('done', function () {
+                enableScrollEvent = true;
+                scroller = null;
+            })
+            .begin();
+    }
+
+    function highlight(path) {
+        if (!enableScrollEvent) {
+            return;
+        }
+
+        var sidebar = getNode('.sidebar');
+        var anchors = findAll('.anchor');
+        var wrap = find(sidebar, '.sidebar-nav');
+        var active = find(sidebar, 'li.active');
+        var doc = document.documentElement;
+        var top = ((doc && doc.scrollTop) || document.body.scrollTop) - coverHeight;
+        var last;
+
+        for (var i = 0, len = anchors.length; i < len; i += 1) {
+            var node = anchors[i];
+
+            if (node.offsetTop > top) {
+                if (!last) {
+                    last = node;
+                }
+
+                break;
+            } else {
+                last = node;
+            }
+        }
+
+        if (!last) {
+            return;
+        }
+
+        var li = nav[getNavKey(path, last.getAttribute('data-id'))];
+
+        if (!li || li === active) {
+            return;
+        }
+
+        active && active.classList.remove('active');
+        li.classList.add('active');
+        active = li;
+
+        // Scroll into view
+        // https://github.com/vuejs/vuejs.org/blob/master/themes/vue/source/js/common.js#L282-L297
+        if (!hoverOver && body.classList.contains('sticky')) {
+            var height = sidebar.clientHeight;
+            var curOffset = 0;
+            var cur = active.offsetTop + active.clientHeight + 40;
+            var isInView =
+                active.offsetTop >= wrap.scrollTop && cur <= wrap.scrollTop + height;
+            var notThan = cur - curOffset < height;
+
+            sidebar.scrollTop = isInView
+                ? wrap.scrollTop
+                : notThan
+                    ? curOffset
+                    : cur - height;
+        }
+    }
+
+    function getNavKey(path, id) {
+        return ((decodeURIComponent(path)) + '?id=' + (decodeURIComponent(id)));
+    }
+
+    function scrollActiveSidebar(router) {
+        var cover = find('.cover.show');
+        coverHeight = cover ? cover.offsetHeight : 0;
+
+        var sidebar = getNode('.sidebar');
+        var lis = [];
+        if (sidebar !== null && sidebar !== undefined) {
+            lis = findAll(sidebar, 'li');
+        }
+
+        for (var i = 0, len = lis.length; i < len; i += 1) {
+            var li = lis[i];
+            var a = li.querySelector('a');
+            if (!a) {
+                continue;
+            }
+
+            var href = a.getAttribute('href');
+
+            if (href !== '/') {
+                var ref = router.parse(href);
+                var id = ref.query.id;
+                var path$1 = ref.path;
+                if (id) {
+                    href = getNavKey(path$1, id);
+                }
+            }
+
+            if (href) {
+                nav[decodeURIComponent(href)] = li;
+            }
+        }
+
+        if (isMobile) {
+            return;
+        }
+
+        var path = removeParams(router.getCurrentPath());
+        off('scroll', function () {
+            return highlight(path);
+        });
+        on('scroll', function () {
+            return highlight(path);
+        });
+        on(sidebar, 'mouseover', function () {
+            hoverOver = true;
+        });
+        on(sidebar, 'mouseleave', function () {
+            hoverOver = false;
+        });
+    }
+
+    function scrollIntoView(path, id) {
+        if (!id) {
+            return;
+        }
+        var topMargin = config().topMargin;
+        var section = find('#' + id);
+        section && scrollTo(section, topMargin);
+
+        var li = nav[getNavKey(path, id)];
+        var sidebar = getNode('.sidebar');
+        var active = find(sidebar, 'li.active');
+        active && active.classList.remove('active');
+        li && li.classList.add('active');
+    }
+
+    var scrollEl = $.scrollingElement || $.documentElement;
+
+    function scroll2Top(offset) {
+        if (offset === void 0) offset = 0;
+
+        scrollEl.scrollTop = offset === true ? 0 : Number(offset);
+    }
+
+    var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+    function createCommonjsModule(fn, module) {
+        return module = { exports: {} }, fn(module, module.exports), module.exports;
+    }
+
+    var defaults = createCommonjsModule(function (module) {
+        function getDefaults() {
+            return {
+                baseUrl: null,
+                breaks: false,
+                gfm: true,
+                headerIds: true,
+                headerPrefix: '',
+                highlight: null,
+                langPrefix: 'language-',
+                mangle: true,
+                pedantic: false,
+                renderer: null,
+                sanitize: false,
+                sanitizer: null,
+                silent: false,
+                smartLists: false,
+                smartypants: false,
+                tokenizer: null,
+                walkTokens: null,
+                xhtml: false,
+            };
+        }
+
+        function changeDefaults(newDefaults) {
+            module.exports.defaults = newDefaults;
+        }
+
+        module.exports = {
+            defaults: getDefaults(),
+            getDefaults: getDefaults,
+            changeDefaults: changeDefaults,
+        };
+    });
+    var defaults_1 = defaults.defaults;
+    var defaults_2 = defaults.getDefaults;
+    var defaults_3 = defaults.changeDefaults;
+
+    /**
+     * Helpers
+     */
+    var escapeTest = /[&<>"']/;
+    var escapeReplace = /[&<>"']/g;
+    var escapeTestNoEncode = /[<>"']|&(?!#?\w+;)/;
+    var escapeReplaceNoEncode = /[<>"']|&(?!#?\w+;)/g;
+    var escapeReplacements = {
+        '&': '&amp;',
+        '<': '&lt;',
+        '>': '&gt;',
+        '"': '&quot;',
+        '\'': '&#39;',
+    };
+    var getEscapeReplacement = function (ch) {
+        return escapeReplacements[ch];
+    };
+
+    function escape(html, encode) {
+        if (encode) {
+            if (escapeTest.test(html)) {
+                return html.replace(escapeReplace, getEscapeReplacement);
+            }
+        } else {
+            if (escapeTestNoEncode.test(html)) {
+                return html.replace(escapeReplaceNoEncode, getEscapeReplacement);
+            }
+        }
+
+        return html;
+    }
+
+    var unescapeTest = /&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/ig;
+
+    function unescape(html) {
+        // explicitly match decimal, hex, and named HTML entities
+        return html.replace(unescapeTest, function (_, n) {
+            n = n.toLowerCase();
+            if (n === 'colon') {
+                return ':';
+            }
+            if (n.charAt(0) === '#') {
+                return n.charAt(1) === 'x'
+                    ? String.fromCharCode(parseInt(n.substring(2), 16))
+                    : String.fromCharCode(+n.substring(1));
+            }
+            return '';
+        });
+    }
+
+    var caret = /(^|[^\[])\^/g;
+
+    function edit(regex, opt) {
+        regex = regex.source || regex;
+        opt = opt || '';
+        var obj = {
+            replace: function (name, val) {
+                val = val.source || val;
+                val = val.replace(caret, '$1');
+                regex = regex.replace(name, val);
+                return obj;
+            },
+            getRegex: function () {
+                return new RegExp(regex, opt);
+            },
+        };
+        return obj;
+    }
+
+    var nonWordAndColonTest = /[^\w:]/g;
+    var originIndependentUrl = /^$|^[a-z][a-z0-9+.-]*:|^[?#]/i;
+
+    function cleanUrl(sanitize, base, href) {
+        if (sanitize) {
+            var prot;
+            try {
+                prot = decodeURIComponent(unescape(href))
+                    .replace(nonWordAndColonTest, '')
+                    .toLowerCase();
+            } catch (e) {
+                return null;
+            }
+            if (prot.indexOf('javascript:') === 0 || prot.indexOf('vbscript:') === 0 || prot.indexOf('data:') === 0) {
+                return null;
+            }
+        }
+        if (base && !originIndependentUrl.test(href)) {
+            href = resolveUrl(base, href);
+        }
+        try {
+            href = encodeURI(href).replace(/%25/g, '%');
+        } catch (e) {
+            return null;
+        }
+        return href;
+    }
+
+    var baseUrls = {};
+    var justDomain = /^[^:]+:\/*[^/]*$/;
+    var protocol = /^([^:]+:)[\s\S]*$/;
+    var domain = /^([^:]+:\/*[^/]*)[\s\S]*$/;
+
+    function resolveUrl(base, href) {
+        if (!baseUrls[' ' + base]) {
+            // we can ignore everything in base after the last slash of its path component,
+            // but we might need to add _that_
+            // https://tools.ietf.org/html/rfc3986#section-3
+            if (justDomain.test(base)) {
+                baseUrls[' ' + base] = base + '/';
+            } else {
+                baseUrls[' ' + base] = rtrim(base, '/', true);
+            }
+        }
+        base = baseUrls[' ' + base];
+        var relativeBase = base.indexOf(':') === -1;
+
+        if (href.substring(0, 2) === '//') {
+            if (relativeBase) {
+                return href;
+            }
+            return base.replace(protocol, '$1') + href;
+        } else if (href.charAt(0) === '/') {
+            if (relativeBase) {
+                return href;
+            }
+            return base.replace(domain, '$1') + href;
+        } else {
+            return base + href;
+        }
+    }
+
+    var noopTest = {
+        exec: function noopTest() {
+        },
+    };
+
+    function merge$1(obj) {
+        var arguments$1 = arguments;
+
+        var i = 1,
+            target,
+            key;
+
+        for (; i < arguments.length; i++) {
+            target = arguments$1[i];
+            for (key in target) {
+                if (Object.prototype.hasOwnProperty.call(target, key)) {
+                    obj[key] = target[key];
+                }
+            }
+        }
+
+        return obj;
+    }
+
+    function splitCells(tableRow, count) {
+        // ensure that every cell-delimiting pipe has a space
+        // before it to distinguish it from an escaped pipe
+        var row = tableRow.replace(/\|/g, function (match, offset, str) {
+                var escaped = false,
+                    curr = offset;
+                while (--curr >= 0 && str[curr] === '\\') {
+                    escaped = !escaped;
+                }
+                if (escaped) {
+                    // odd number of slashes means | is escaped
+                    // so we leave it alone
+                    return '|';
+                } else {
+                    // add space before unescaped |
+                    return ' |';
+                }
+            }),
+            cells = row.split(/ \|/);
+        var i = 0;
+
+        if (cells.length > count) {
+            cells.splice(count);
+        } else {
+            while (cells.length < count) {
+                cells.push('');
+            }
+        }
+
+        for (; i < cells.length; i++) {
+            // leading or trailing whitespace is ignored per the gfm spec
+            cells[i] = cells[i].trim().replace(/\\\|/g, '|');
+        }
+        return cells;
+    }
+
+    // Remove trailing 'c's. Equivalent to str.replace(/c*$/, '').
+    // /c*$/ is vulnerable to REDOS.
+    // invert: Remove suffix of non-c chars instead. Default falsey.
+    function rtrim(str, c, invert) {
+        var l = str.length;
+        if (l === 0) {
+            return '';
+        }
+
+        // Length of suffix matching the invert condition.
+        var suffLen = 0;
+
+        // Step left until we fail to match the invert condition.
+        while (suffLen < l) {
+            var currChar = str.charAt(l - suffLen - 1);
+            if (currChar === c && !invert) {
+                suffLen++;
+            } else if (currChar !== c && invert) {
+                suffLen++;
+            } else {
+                break;
+            }
+        }
+
+        return str.substr(0, l - suffLen);
+    }
+
+    function findClosingBracket(str, b) {
+        if (str.indexOf(b[1]) === -1) {
+            return -1;
+        }
+        var l = str.length;
+        var level = 0,
+            i = 0;
+        for (; i < l; i++) {
+            if (str[i] === '\\') {
+                i++;
+            } else if (str[i] === b[0]) {
+                level++;
+            } else if (str[i] === b[1]) {
+                level--;
+                if (level < 0) {
+                    return i;
+                }
+            }
+        }
+        return -1;
+    }
+
+    function checkSanitizeDeprecation(opt) {
+        if (opt && opt.sanitize && !opt.silent) {
+            console.warn('marked(): sanitize and sanitizer parameters are deprecated since version 0.7.0, should not be used and will be removed in the future. Read more here: https://marked.js.org/#/USING_ADVANCED.md#options');
+        }
+    }
+
+    // copied from https://stackoverflow.com/a/5450113/806777
+    function repeatString(pattern, count) {
+        if (count < 1) {
+            return '';
+        }
+        var result = '';
+        while (count > 1) {
+            if (count & 1) {
+                result += pattern;
+            }
+            count >>= 1;
+            pattern += pattern;
+        }
+        return result + pattern;
+    }
+
+    var helpers = {
+        escape: escape,
+        unescape: unescape,
+        edit: edit,
+        cleanUrl: cleanUrl,
+        resolveUrl: resolveUrl,
+        noopTest: noopTest,
+        merge: merge$1,
+        splitCells: splitCells,
+        rtrim: rtrim,
+        findClosingBracket: findClosingBracket,
+        checkSanitizeDeprecation: checkSanitizeDeprecation,
+        repeatString: repeatString,
+    };
+
+    var defaults$1 = defaults.defaults;
+
+    var rtrim$1 = helpers.rtrim;
+    var splitCells$1 = helpers.splitCells;
+    var escape$1 = helpers.escape;
+    var findClosingBracket$1 = helpers.findClosingBracket;
+
+    function outputLink(cap, link, raw) {
+        var href = link.href;
+        var title = link.title ? escape$1(link.title) : null;
+        var text = cap[1].replace(/\\([\[\]])/g, '$1');
+
+        if (cap[0].charAt(0) !== '!') {
+            return {
+                type: 'link',
+                raw: raw,
+                href: href,
+                title: title,
+                text: text,
+            };
+        } else {
+            return {
+                type: 'image',
+                raw: raw,
+                href: href,
+                title: title,
+                text: escape$1(text),
+            };
+        }
+    }
+
+    function indentCodeCompensation(raw, text) {
+        var matchIndentToCode = raw.match(/^(\s+)(?:```)/);
+
+        if (matchIndentToCode === null) {
+            return text;
+        }
+
+        var indentToCode = matchIndentToCode[1];
+
+        return text
+            .split('\n')
+            .map(function (node) {
+                var matchIndentInNode = node.match(/^\s+/);
+                if (matchIndentInNode === null) {
+                    return node;
+                }
+
+                var indentInNode = matchIndentInNode[0];
+
+                if (indentInNode.length >= indentToCode.length) {
+                    return node.slice(indentToCode.length);
+                }
+
+                return node;
+            })
+            .join('\n');
+    }
+
+    /**
+     * Tokenizer
+     */
+    var Tokenizer = /*@__PURE__*/(function () {
+        function Tokenizer(options) {
+            this.options = options || defaults$1;
+        }
+
+        Tokenizer.prototype.space = function space(src) {
+            var cap = this.rules.block.newline.exec(src);
+            if (cap) {
+                if (cap[0].length > 1) {
+                    return {
+                        type: 'space',
+                        raw: cap[0],
+                    };
+                }
+                return { raw: '\n' };
+            }
+        };
+
+        Tokenizer.prototype.code = function code(src, tokens) {
+            var cap = this.rules.block.code.exec(src);
+            if (cap) {
+                var lastToken = tokens[tokens.length - 1];
+                // An indented code block cannot interrupt a paragraph.
+                if (lastToken && lastToken.type === 'paragraph') {
+                    return {
+                        raw: cap[0],
+                        text: cap[0].trimRight(),
+                    };
+                }
+
+                var text = cap[0].replace(/^ {1,4}/gm, '');
+                return {
+                    type: 'code',
+                    raw: cap[0],
+                    codeBlockStyle: 'indented',
+                    text: !this.options.pedantic
+                        ? rtrim$1(text, '\n')
+                        : text,
+                };
+            }
+        };
+
+        Tokenizer.prototype.fences = function fences(src) {
+            var cap = this.rules.block.fences.exec(src);
+            if (cap) {
+                var raw = cap[0];
+                var text = indentCodeCompensation(raw, cap[3] || '');
+
+                return {
+                    type: 'code',
+                    raw: raw,
+                    lang: cap[2] ? cap[2].trim() : cap[2],
+                    text: text,
+                };
+            }
+        };
+
+        Tokenizer.prototype.heading = function heading(src) {
+            var cap = this.rules.block.heading.exec(src);
+            if (cap) {
+                var text = cap[2].trim();
+
+                // remove trailing #s
+                if (/#$/.test(text)) {
+                    var trimmed = rtrim$1(text, '#');
+                    if (this.options.pedantic) {
+                        text = trimmed.trim();
+                    } else if (!trimmed || / $/.test(trimmed)) {
+                        // CommonMark requires space before trailing #s
+                        text = trimmed.trim();
+                    }
+                }
+
+                return {
+                    type: 'heading',
+                    raw: cap[0],
+                    depth: cap[1].length,
+                    text: text,
+                };
+            }
+        };
+
+        Tokenizer.prototype.nptable = function nptable(src) {
+            var cap = this.rules.block.nptable.exec(src);
+            if (cap) {
+                var item = {
+                    type: 'table',
+                    header: splitCells$1(cap[1].replace(/^ *| *\| *$/g, '')),
+                    align: cap[2].replace(/^ *|\| *$/g, '').split(/ *\| */),
+                    cells: cap[3] ? cap[3].replace(/\n$/, '').split('\n') : [],
+                    raw: cap[0],
+                };
+
+                if (item.header.length === item.align.length) {
+                    var l = item.align.length;
+                    var i;
+                    for (i = 0; i < l; i++) {
+                        if (/^ *-+: *$/.test(item.align[i])) {
+                            item.align[i] = 'right';
+                        } else if (/^ *:-+: *$/.test(item.align[i])) {
+                            item.align[i] = 'center';
+                        } else if (/^ *:-+ *$/.test(item.align[i])) {
+                            item.align[i] = 'left';
+                        } else {
+                            item.align[i] = null;
+                        }
+                    }
+
+                    l = item.cells.length;
+                    for (i = 0; i < l; i++) {
+                        item.cells[i] = splitCells$1(item.cells[i], item.header.length);
+                    }
+
+                    return item;
+                }
+            }
+        };
+
+        Tokenizer.prototype.hr = function hr(src) {
+            var cap = this.rules.block.hr.exec(src);
+            if (cap) {
+                return {
+                    type: 'hr',
+                    raw: cap[0],
+                };
+            }
+        };
+
+        Tokenizer.prototype.blockquote = function blockquote(src) {
+            var cap = this.rules.block.blockquote.exec(src);
+            if (cap) {
+                var text = cap[0].replace(/^ *> ?/gm, '');
+
+                return {
+                    type: 'blockquote',
+                    raw: cap[0],
+                    text: text,
+                };
+            }
+        };
+
+        Tokenizer.prototype.list = function list(src) {
+            var cap = this.rules.block.list.exec(src);
+            if (cap) {
+                var raw = cap[0];
+                var bull = cap[2];
+                var isordered = bull.length > 1;
+
+                var list = {
+                    type: 'list',
+                    raw: raw,
+                    ordered: isordered,
+                    start: isordered ? +bull.slice(0, -1) : '',
+                    loose: false,
+                    items: [],
+                };
+
+                // Get each top-level item.
+                var itemMatch = cap[0].match(this.rules.block.item);
+
+                var next = false,
+                    item,
+                    space,
+                    bcurr,
+                    bnext,
+                    addBack,
+                    loose,
+                    istask,
+                    ischecked;
+
+                var l = itemMatch.length;
+                bcurr = this.rules.block.listItemStart.exec(itemMatch[0]);
+                for (var i = 0; i < l; i++) {
+                    item = itemMatch[i];
+                    raw = item;
+
+                    // Determine whether the next list item belongs here.
+                    // Backpedal if it does not belong in this list.
+                    if (i !== l - 1) {
+                        bnext = this.rules.block.listItemStart.exec(itemMatch[i + 1]);
+                        if (
+                            !this.options.pedantic
+                                ? bnext[1].length > bcurr[0].length || bnext[1].length > 3
+                                : bnext[1].length > bcurr[1].length
+                        ) {
+                            // nested list
+                            itemMatch.splice(i, 2, itemMatch[i] + '\n' + itemMatch[i + 1]);
+                            i--;
+                            l--;
+                            continue;
+                        } else {
+                            if (
+                                // different bullet style
+                                !this.options.pedantic || this.options.smartLists
+                                    ? bnext[2][bnext[2].length - 1] !== bull[bull.length - 1]
+                                    : isordered === (bnext[2].length === 1)
+                            ) {
+                                addBack = itemMatch.slice(i + 1).join('\n');
+                                list.raw = list.raw.substring(0, list.raw.length - addBack.length);
+                                i = l - 1;
+                            }
+                        }
+                        bcurr = bnext;
+                    }
+
+                    // Remove the list item's bullet
+                    // so it is seen as the next token.
+                    space = item.length;
+                    item = item.replace(/^ *([*+-]|\d+[.)]) ?/, '');
+
+                    // Outdent whatever the
+                    // list item contains. Hacky.
+                    if (~item.indexOf('\n ')) {
+                        space -= item.length;
+                        item = !this.options.pedantic
+                            ? item.replace(new RegExp('^ {1,' + space + '}', 'gm'), '')
+                            : item.replace(/^ {1,4}/gm, '');
+                    }
+
+                    // Determine whether item is loose or not.
+                    // Use: /(^|\n)(?! )[^\n]+\n\n(?!\s*$)/
+                    // for discount behavior.
+                    loose = next || /\n\n(?!\s*$)/.test(item);
+                    if (i !== l - 1) {
+                        next = item.charAt(item.length - 1) === '\n';
+                        if (!loose) {
+                            loose = next;
+                        }
+                    }
+
+                    if (loose) {
+                        list.loose = true;
+                    }
+
+                    // Check for task list items
+                    if (this.options.gfm) {
+                        istask = /^\[[ xX]\] /.test(item);
+                        ischecked = undefined;
+                        if (istask) {
+                            ischecked = item[1] !== ' ';
+                            item = item.replace(/^\[[ xX]\] +/, '');
+                        }
+                    }
+
+                    list.items.push({
+                        type: 'list_item',
+                        raw: raw,
+                        task: istask,
+                        checked: ischecked,
+                        loose: loose,
+                        text: item,
+                    });
+                }
+
+                return list;
+            }
+        };
+
+        Tokenizer.prototype.html = function html(src) {
+            var cap = this.rules.block.html.exec(src);
+            if (cap) {
+                return {
+                    type: this.options.sanitize
+                        ? 'paragraph'
+                        : 'html',
+                    raw: cap[0],
+                    pre: !this.options.sanitizer
+                        && (cap[1] === 'pre' || cap[1] === 'script' || cap[1] === 'style'),
+                    text: this.options.sanitize ? (this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape$1(cap[0])) : cap[0],
+                };
+            }
+        };
+
+        Tokenizer.prototype.def = function def(src) {
+            var cap = this.rules.block.def.exec(src);
+            if (cap) {
+                if (cap[3]) {
+                    cap[3] = cap[3].substring(1, cap[3].length - 1);
+                }
+                var tag = cap[1].toLowerCase().replace(/\s+/g, ' ');
+                return {
+                    tag: tag,
+                    raw: cap[0],
+                    href: cap[2],
+                    title: cap[3],
+                };
+            }
+        };
+
+        Tokenizer.prototype.table = function table(src) {
+            var cap = this.rules.block.table.exec(src);
+            if (cap) {
+                var item = {
+                    type: 'table',
+                    header: splitCells$1(cap[1].replace(/^ *| *\| *$/g, '')),
+                    align: cap[2].replace(/^ *|\| *$/g, '').split(/ *\| */),
+                    cells: cap[3] ? cap[3].replace(/\n$/, '').split('\n') : [],
+                };
+
+                if (item.header.length === item.align.length) {
+                    item.raw = cap[0];
+
+                    var l = item.align.length;
+                    var i;
+                    for (i = 0; i < l; i++) {
+                        if (/^ *-+: *$/.test(item.align[i])) {
+                            item.align[i] = 'right';
+                        } else if (/^ *:-+: *$/.test(item.align[i])) {
+                            item.align[i] = 'center';
+                        } else if (/^ *:-+ *$/.test(item.align[i])) {
+                            item.align[i] = 'left';
+                        } else {
+                            item.align[i] = null;
+                        }
+                    }
+
+                    l = item.cells.length;
+                    for (i = 0; i < l; i++) {
+                        item.cells[i] = splitCells$1(
+                            item.cells[i].replace(/^ *\| *| *\| *$/g, ''),
+                            item.header.length);
+                    }
+
+                    return item;
+                }
+            }
+        };
+
+        Tokenizer.prototype.lheading = function lheading(src) {
+            var cap = this.rules.block.lheading.exec(src);
+            if (cap) {
+                return {
+                    type: 'heading',
+                    raw: cap[0],
+                    depth: cap[2].charAt(0) === '=' ? 1 : 2,
+                    text: cap[1],
+                };
+            }
+        };
+
+        Tokenizer.prototype.paragraph = function paragraph(src) {
+            var cap = this.rules.block.paragraph.exec(src);
+            if (cap) {
+                return {
+                    type: 'paragraph',
+                    raw: cap[0],
+                    text: cap[1].charAt(cap[1].length - 1) === '\n'
+                        ? cap[1].slice(0, -1)
+                        : cap[1],
+                };
+            }
+        };
+
+        Tokenizer.prototype.text = function text(src, tokens) {
+            var cap = this.rules.block.text.exec(src);
+            if (cap) {
+                var lastToken = tokens[tokens.length - 1];
+                if (lastToken && lastToken.type === 'text') {
+                    return {
+                        raw: cap[0],
+                        text: cap[0],
+                    };
+                }
+
+                return {
+                    type: 'text',
+                    raw: cap[0],
+                    text: cap[0],
+                };
+            }
+        };
+
+        Tokenizer.prototype.escape = function escape$1$1(src) {
+            var cap = this.rules.inline.escape.exec(src);
+            if (cap) {
+                return {
+                    type: 'escape',
+                    raw: cap[0],
+                    text: escape$1(cap[1]),
+                };
+            }
+        };
+
+        Tokenizer.prototype.tag = function tag(src, inLink, inRawBlock) {
+            var cap = this.rules.inline.tag.exec(src);
+            if (cap) {
+                if (!inLink && /^<a /i.test(cap[0])) {
+                    inLink = true;
+                } else if (inLink && /^<\/a>/i.test(cap[0])) {
+                    inLink = false;
+                }
+                if (!inRawBlock && /^<(pre|code|kbd|script)(\s|>)/i.test(cap[0])) {
+                    inRawBlock = true;
+                } else if (inRawBlock && /^<\/(pre|code|kbd|script)(\s|>)/i.test(cap[0])) {
+                    inRawBlock = false;
+                }
+
+                return {
+                    type: this.options.sanitize
+                        ? 'text'
+                        : 'html',
+                    raw: cap[0],
+                    inLink: inLink,
+                    inRawBlock: inRawBlock,
+                    text: this.options.sanitize
+                        ? (this.options.sanitizer
+                            ? this.options.sanitizer(cap[0])
+                            : escape$1(cap[0]))
+                        : cap[0],
+                };
+            }
+        };
+
+        Tokenizer.prototype.link = function link(src) {
+            var cap = this.rules.inline.link.exec(src);
+            if (cap) {
+                var trimmedUrl = cap[2].trim();
+                if (!this.options.pedantic && /^</.test(trimmedUrl)) {
+                    // commonmark requires matching angle brackets
+                    if (!(/>$/.test(trimmedUrl))) {
+                        return;
+                    }
+
+                    // ending angle bracket cannot be escaped
+                    var rtrimSlash = rtrim$1(trimmedUrl.slice(0, -1), '\\');
+                    if ((trimmedUrl.length - rtrimSlash.length) % 2 === 0) {
+                        return;
+                    }
+                } else {
+                    // find closing parenthesis
+                    var lastParenIndex = findClosingBracket$1(cap[2], '()');
+                    if (lastParenIndex > -1) {
+                        var start = cap[0].indexOf('!') === 0 ? 5 : 4;
+                        var linkLen = start + cap[1].length + lastParenIndex;
+                        cap[2] = cap[2].substring(0, lastParenIndex);
+                        cap[0] = cap[0].substring(0, linkLen).trim();
+                        cap[3] = '';
+                    }
+                }
+                var href = cap[2];
+                var title = '';
+                if (this.options.pedantic) {
+                    // split pedantic href and title
+                    var link = /^([^'"]*[^\s])\s+(['"])(.*)\2/.exec(href);
+
+                    if (link) {
+                        href = link[1];
+                        title = link[3];
+                    }
+                } else {
+                    title = cap[3] ? cap[3].slice(1, -1) : '';
+                }
+
+                href = href.trim();
+                if (/^</.test(href)) {
+                    if (this.options.pedantic && !(/>$/.test(trimmedUrl))) {
+                        // pedantic allows starting angle bracket without ending angle bracket
+                        href = href.slice(1);
+                    } else {
+                        href = href.slice(1, -1);
+                    }
+                }
+                return outputLink(cap, {
+                    href: href ? href.replace(this.rules.inline._escapes, '$1') : href,
+                    title: title ? title.replace(this.rules.inline._escapes, '$1') : title,
+                }, cap[0]);
+            }
+        };
+
+        Tokenizer.prototype.reflink = function reflink(src, links) {
+            var cap;
+            if ((cap = this.rules.inline.reflink.exec(src))
+                || (cap = this.rules.inline.nolink.exec(src))) {
+                var link = (cap[2] || cap[1]).replace(/\s+/g, ' ');
+                link = links[link.toLowerCase()];
+                if (!link || !link.href) {
+                    var text = cap[0].charAt(0);
+                    return {
+                        type: 'text',
+                        raw: text,
+                        text: text,
+                    };
+                }
+                return outputLink(cap, link, cap[0]);
+            }
+        };
+
+        Tokenizer.prototype.strong = function strong(src, maskedSrc, prevChar) {
+            if (prevChar === void 0) prevChar = '';
+
+            var match = this.rules.inline.strong.start.exec(src);
+
+            if (match && (!match[1] || (match[1] && (prevChar === '' || this.rules.inline.punctuation.exec(prevChar))))) {
+                maskedSrc = maskedSrc.slice(-1 * src.length);
+                var endReg = match[0] === '**' ? this.rules.inline.strong.endAst : this.rules.inline.strong.endUnd;
+
+                endReg.lastIndex = 0;
+
+                var cap;
+                while ((match = endReg.exec(maskedSrc)) != null) {
+                    cap = this.rules.inline.strong.middle.exec(maskedSrc.slice(0, match.index + 3));
+                    if (cap) {
+                        return {
+                            type: 'strong',
+                            raw: src.slice(0, cap[0].length),
+                            text: src.slice(2, cap[0].length - 2),
+                        };
+                    }
+                }
+            }
+        };
+
+        Tokenizer.prototype.em = function em(src, maskedSrc, prevChar) {
+            if (prevChar === void 0) prevChar = '';
+
+            var match = this.rules.inline.em.start.exec(src);
+
+            if (match && (!match[1] || (match[1] && (prevChar === '' || this.rules.inline.punctuation.exec(prevChar))))) {
+                maskedSrc = maskedSrc.slice(-1 * src.length);
+                var endReg = match[0] === '*' ? this.rules.inline.em.endAst : this.rules.inline.em.endUnd;
+
+                endReg.lastIndex = 0;
+
+                var cap;
+                while ((match = endReg.exec(maskedSrc)) != null) {
+                    cap = this.rules.inline.em.middle.exec(maskedSrc.slice(0, match.index + 2));
+                    if (cap) {
+                        return {
+                            type: 'em',
+                            raw: src.slice(0, cap[0].length),
+                            text: src.slice(1, cap[0].length - 1),
+                        };
+                    }
+                }
+            }
+        };
+
+        Tokenizer.prototype.codespan = function codespan(src) {
+            var cap = this.rules.inline.code.exec(src);
+            if (cap) {
+                var text = cap[2].replace(/\n/g, ' ');
+                var hasNonSpaceChars = /[^ ]/.test(text);
+                var hasSpaceCharsOnBothEnds = /^ /.test(text) && / $/.test(text);
+                if (hasNonSpaceChars && hasSpaceCharsOnBothEnds) {
+                    text = text.substring(1, text.length - 1);
+                }
+                text = escape$1(text, true);
+                return {
+                    type: 'codespan',
+                    raw: cap[0],
+                    text: text,
+                };
+            }
+        };
+
+        Tokenizer.prototype.br = function br(src) {
+            var cap = this.rules.inline.br.exec(src);
+            if (cap) {
+                return {
+                    type: 'br',
+                    raw: cap[0],
+                };
+            }
+        };
+
+        Tokenizer.prototype.del = function del(src) {
+            var cap = this.rules.inline.del.exec(src);
+            if (cap) {
+                return {
+                    type: 'del',
+                    raw: cap[0],
+                    text: cap[2],
+                };
+            }
+        };
+
+        Tokenizer.prototype.autolink = function autolink(src, mangle) {
+            var cap = this.rules.inline.autolink.exec(src);
+            if (cap) {
+                var text, href;
+                if (cap[2] === '@') {
+                    text = escape$1(this.options.mangle ? mangle(cap[1]) : cap[1]);
+                    href = 'mailto:' + text;
+                } else {
+                    text = escape$1(cap[1]);
+                    href = text;
+                }
+
+                return {
+                    type: 'link',
+                    raw: cap[0],
+                    text: text,
+                    href: href,
+                    tokens: [
+                        {
+                            type: 'text',
+                            raw: text,
+                            text: text,
+                        },
+                    ],
+                };
+            }
+        };
+
+        Tokenizer.prototype.url = function url(src, mangle) {
+            var cap;
+            if (cap = this.rules.inline.url.exec(src)) {
+                var text, href;
+                if (cap[2] === '@') {
+                    text = escape$1(this.options.mangle ? mangle(cap[0]) : cap[0]);
+                    href = 'mailto:' + text;
+                } else {
+                    // do extended autolink path validation
+                    var prevCapZero;
+                    do {
+                        prevCapZero = cap[0];
+                        cap[0] = this.rules.inline._backpedal.exec(cap[0])[0];
+                    } while (prevCapZero !== cap[0]);
+                    text = escape$1(cap[0]);
+                    if (cap[1] === 'www.') {
+                        href = 'http://' + text;
+                    } else {
+                        href = text;
+                    }
+                }
+                return {
+                    type: 'link',
+                    raw: cap[0],
+                    text: text,
+                    href: href,
+                    tokens: [
+                        {
+                            type: 'text',
+                            raw: text,
+                            text: text,
+                        },
+                    ],
+                };
+            }
+        };
+
+        Tokenizer.prototype.inlineText = function inlineText(src, inRawBlock, smartypants) {
+            var cap = this.rules.inline.text.exec(src);
+            if (cap) {
+                var text;
+                if (inRawBlock) {
+                    text = this.options.sanitize ? (this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape$1(cap[0])) : cap[0];
+                } else {
+                    text = escape$1(this.options.smartypants ? smartypants(cap[0]) : cap[0]);
+                }
+                return {
+                    type: 'text',
+                    raw: cap[0],
+                    text: text,
+                };
+            }
+        };
+
+        return Tokenizer;
+    }());
+
+    var noopTest$1 = helpers.noopTest;
+    var edit$1 = helpers.edit;
+    var merge$2 = helpers.merge;
+
+    /**
+     * Block-Level Grammar
+     */
+    var block = {
+        newline: /^(?: *(?:\n|$))+/,
+        code: /^( {4}[^\n]+(?:\n(?: *(?:\n|$))*)?)+/,
+        fences: /^ {0,3}(`{3,}(?=[^`\n]*\n)|~{3,})([^\n]*)\n(?:|([\s\S]*?)\n)(?: {0,3}\1[~`]* *(?:\n+|$)|$)/,
+        hr: /^ {0,3}((?:- *){3,}|(?:_ *){3,}|(?:\* *){3,})(?:\n+|$)/,
+        heading: /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/,
+        blockquote: /^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/,
+        list: /^( {0,3})(bull) [\s\S]+?(?:hr|def|\n{2,}(?! )(?! {0,3}bull )\n*|\s*$)/,
+        html: '^ {0,3}(?:' // optional indentation
+            + '<(script|pre|style)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)' // (1)
+            + '|comment[^\\n]*(\\n+|$)' // (2)
+            + '|<\\?[\\s\\S]*?(?:\\?>\\n*|$)' // (3)
+            + '|<![A-Z][\\s\\S]*?(?:>\\n*|$)' // (4)
+            + '|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)' // (5)
+            + '|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:\\n{2,}|$)' // (6)
+            + '|<(?!script|pre|style)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:\\n{2,}|$)' // (7) open tag
+            + '|</(?!script|pre|style)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:\\n{2,}|$)' // (7) closing tag
+            + ')',
+        def: /^ {0,3}\[(label)\]: *\n? *<?([^\s>]+)>?(?:(?: +\n? *| *\n *)(title))? *(?:\n+|$)/,
+        nptable: noopTest$1,
+        table: noopTest$1,
+        lheading: /^([^\n]+)\n {0,3}(=+|-+) *(?:\n+|$)/,
+        // regex template, placeholders will be replaced according to different paragraph
+        // interruption rules of commonmark and the original markdown spec:
+        _paragraph: /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html| +\n)[^\n]+)*)/,
+        text: /^[^\n]+/,
+    };
+
+    block._label = /(?!\s*\])(?:\\[\[\]]|[^\[\]])+/;
+    block._title = /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/;
+    block.def = edit$1(block.def)
+        .replace('label', block._label)
+        .replace('title', block._title)
+        .getRegex();
+
+    block.bullet = /(?:[*+-]|\d{1,9}[.)])/;
+    block.item = /^( *)(bull) ?[^\n]*(?:\n(?! *bull ?)[^\n]*)*/;
+    block.item = edit$1(block.item, 'gm')
+        .replace(/bull/g, block.bullet)
+        .getRegex();
+
+    block.listItemStart = edit$1(/^( *)(bull)/)
+        .replace('bull', block.bullet)
+        .getRegex();
+
+    block.list = edit$1(block.list)
+        .replace(/bull/g, block.bullet)
+        .replace('hr', '\\n+(?=\\1?(?:(?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$))')
+        .replace('def', '\\n+(?=' + block.def.source + ')')
+        .getRegex();
+
+    block._tag = 'address|article|aside|base|basefont|blockquote|body|caption'
+        + '|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption'
+        + '|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe'
+        + '|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option'
+        + '|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr'
+        + '|track|ul';
+    block._comment = /<!--(?!-?>)[\s\S]*?(?:-->|$)/;
+    block.html = edit$1(block.html, 'i')
+        .replace('comment', block._comment)
+        .replace('tag', block._tag)
+        .replace('attribute', / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/)
+        .getRegex();
+
+    block.paragraph = edit$1(block._paragraph)
+        .replace('hr', block.hr)
+        .replace('heading', ' {0,3}#{1,6} ')
+        .replace('|lheading', '') // setex headings don't interrupt commonmark paragraphs
+        .replace('blockquote', ' {0,3}>')
+        .replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n')
+        .replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
+        .replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|!--)')
+        .replace('tag', block._tag) // pars can be interrupted by type (6) html blocks
+        .getRegex();
+
+    block.blockquote = edit$1(block.blockquote)
+        .replace('paragraph', block.paragraph)
+        .getRegex();
+
+    /**
+     * Normal Block Grammar
+     */
+
+    block.normal = merge$2({}, block);
+
+    /**
+     * GFM Block Grammar
+     */
+
+    block.gfm = merge$2({}, block.normal, {
+        nptable: '^ *([^|\\n ].*\\|.*)\\n' // Header
+            + ' {0,3}([-:]+ *\\|[-| :]*)' // Align
+            + '(?:\\n((?:(?!\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)', // Cells
+        table: '^ *\\|(.+)\\n' // Header
+            + ' {0,3}\\|?( *[-:]+[-| :]*)' // Align
+            + '(?:\\n *((?:(?!\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)', // Cells
+    });
+
+    block.gfm.nptable = edit$1(block.gfm.nptable)
+        .replace('hr', block.hr)
+        .replace('heading', ' {0,3}#{1,6} ')
+        .replace('blockquote', ' {0,3}>')
+        .replace('code', ' {4}[^\\n]')
+        .replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n')
+        .replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
+        .replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|!--)')
+        .replace('tag', block._tag) // tables can be interrupted by type (6) html blocks
+        .getRegex();
+
+    block.gfm.table = edit$1(block.gfm.table)
+        .replace('hr', block.hr)
+        .replace('heading', ' {0,3}#{1,6} ')
+        .replace('blockquote', ' {0,3}>')
+        .replace('code', ' {4}[^\\n]')
+        .replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n')
+        .replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
+        .replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|!--)')
+        .replace('tag', block._tag) // tables can be interrupted by type (6) html blocks
+        .getRegex();
+
+    /**
+     * Pedantic grammar (original John Gruber's loose markdown specification)
+     */
+
+    block.pedantic = merge$2({}, block.normal, {
+        html: edit$1(
+            '^ *(?:comment *(?:\\n|\\s*$)'
+            + '|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)' // closed tag
+            + '|<tag(?:"[^"]*"|\'[^\']*\'|\\s[^\'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))')
+            .replace('comment', block._comment)
+            .replace(/tag/g, '(?!(?:'
+                + 'a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub'
+                + '|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)'
+                + '\\b)\\w+(?!:|[^\\w\\s@]*@)\\b')
+            .getRegex(),
+        def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/,
+        heading: /^(#{1,6})(.*)(?:\n+|$)/,
+        fences: noopTest$1, // fences not supported
+        paragraph: edit$1(block.normal._paragraph)
+            .replace('hr', block.hr)
+            .replace('heading', ' *#{1,6} *[^\n]')
+            .replace('lheading', block.lheading)
+            .replace('blockquote', ' {0,3}>')
+            .replace('|fences', '')
+            .replace('|list', '')
+            .replace('|html', '')
+            .getRegex(),
+    });
+
+    /**
+     * Inline-Level Grammar
+     */
+    var inline = {
+        escape: /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/,
+        autolink: /^<(scheme:[^\s\x00-\x1f<>]*|email)>/,
+        url: noopTest$1,
+        tag: '^comment'
+            + '|^</[a-zA-Z][\\w:-]*\\s*>' // self-closing tag
+            + '|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>' // open tag
+            + '|^<\\?[\\s\\S]*?\\?>' // processing instruction, e.g. <?php ?>
+            + '|^<![a-zA-Z]+\\s[\\s\\S]*?>' // declaration, e.g. <!DOCTYPE html>
+            + '|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>', // CDATA section
+        link: /^!?\[(label)\]\(\s*(href)(?:\s+(title))?\s*\)/,
+        reflink: /^!?\[(label)\]\[(?!\s*\])((?:\\[\[\]]?|[^\[\]\\])+)\]/,
+        nolink: /^!?\[(?!\s*\])((?:\[[^\[\]]*\]|\\[\[\]]|[^\[\]])*)\](?:\[\])?/,
+        reflinkSearch: 'reflink|nolink(?!\\()',
+        strong: {
+            start: /^(?:(\*\*(?=[*punctuation]))|\*\*)(?![\s])|__/, // (1) returns if starts w/ punctuation
+            middle: /^\*\*(?:(?:(?!overlapSkip)(?:[^*]|\\\*)|overlapSkip)|\*(?:(?!overlapSkip)(?:[^*]|\\\*)|overlapSkip)*?\*)+?\*\*$|^__(?![\s])((?:(?:(?!overlapSkip)(?:[^_]|\\_)|overlapSkip)|_(?:(?!overlapSkip)(?:[^_]|\\_)|overlapSkip)*?_)+?)__$/,
+            endAst: /[^punctuation\s]\*\*(?!\*)|[punctuation]\*\*(?!\*)(?:(?=[punctuation_\s]|$))/, // last char can't be punct, or final * must also be followed by punct (or endline)
+            endUnd: /[^\s]__(?!_)(?:(?=[punctuation*\s])|$)/, // last char can't be a space, and final _ must preceed punct or \s (or endline)
+        },
+        em: {
+            start: /^(?:(\*(?=[punctuation]))|\*)(?![*\s])|_/, // (1) returns if starts w/ punctuation
+            middle: /^\*(?:(?:(?!overlapSkip)(?:[^*]|\\\*)|overlapSkip)|\*(?:(?!overlapSkip)(?:[^*]|\\\*)|overlapSkip)*?\*)+?\*$|^_(?![_\s])(?:(?:(?!overlapSkip)(?:[^_]|\\_)|overlapSkip)|_(?:(?!overlapSkip)(?:[^_]|\\_)|overlapSkip)*?_)+?_$/,
+            endAst: /[^punctuation\s]\*(?!\*)|[punctuation]\*(?!\*)(?:(?=[punctuation_\s]|$))/, // last char can't be punct, or final * must also be followed by punct (or endline)
+            endUnd: /[^\s]_(?!_)(?:(?=[punctuation*\s])|$)/, // last char can't be a space, and final _ must preceed punct or \s (or endline)
+        },
+        code: /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/,
+        br: /^( {2,}|\\)\n(?!\s*$)/,
+        del: noopTest$1,
+        text: /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*]|\b_|$)|[^ ](?= {2,}\n)))/,
+        punctuation: /^([\s*punctuation])/,
+    };
+
+    // list of punctuation marks from common mark spec
+    // without * and _ to workaround cases with double emphasis
+    inline._punctuation = '!"#$%&\'()+\\-.,/:;<=>?@\\[\\]`^{|}~';
+    inline.punctuation = edit$1(inline.punctuation).replace(/punctuation/g, inline._punctuation).getRegex();
+
+    // sequences em should skip over [title](link), `code`, <html>
+    inline._blockSkip = '\\[[^\\]]*?\\]\\([^\\)]*?\\)|`[^`]*?`|<[^>]*?>';
+    inline._overlapSkip = '__[^_]*?__|\\*\\*\\[^\\*\\]*?\\*\\*';
+
+    inline._comment = edit$1(block._comment).replace('(?:-->|$)', '-->').getRegex();
+
+    inline.em.start = edit$1(inline.em.start)
+        .replace(/punctuation/g, inline._punctuation)
+        .getRegex();
+
+    inline.em.middle = edit$1(inline.em.middle)
+        .replace(/punctuation/g, inline._punctuation)
+        .replace(/overlapSkip/g, inline._overlapSkip)
+        .getRegex();
+
+    inline.em.endAst = edit$1(inline.em.endAst, 'g')
+        .replace(/punctuation/g, inline._punctuation)
+        .getRegex();
+
+    inline.em.endUnd = edit$1(inline.em.endUnd, 'g')
+        .replace(/punctuation/g, inline._punctuation)
+        .getRegex();
+
+    inline.strong.start = edit$1(inline.strong.start)
+        .replace(/punctuation/g, inline._punctuation)
+        .getRegex();
+
+    inline.strong.middle = edit$1(inline.strong.middle)
+        .replace(/punctuation/g, inline._punctuation)
+        .replace(/overlapSkip/g, inline._overlapSkip)
+        .getRegex();
+
+    inline.strong.endAst = edit$1(inline.strong.endAst, 'g')
+        .replace(/punctuation/g, inline._punctuation)
+        .getRegex();
+
+    inline.strong.endUnd = edit$1(inline.strong.endUnd, 'g')
+        .replace(/punctuation/g, inline._punctuation)
+        .getRegex();
+
+    inline.blockSkip = edit$1(inline._blockSkip, 'g')
+        .getRegex();
+
+    inline.overlapSkip = edit$1(inline._overlapSkip, 'g')
+        .getRegex();
+
+    inline._escapes = /\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/g;
+
+    inline._scheme = /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/;
+    inline._email = /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/;
+    inline.autolink = edit$1(inline.autolink)
+        .replace('scheme', inline._scheme)
+        .replace('email', inline._email)
+        .getRegex();
+
+    inline._attribute = /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/;
+
+    inline.tag = edit$1(inline.tag)
+        .replace('comment', inline._comment)
+        .replace('attribute', inline._attribute)
+        .getRegex();
+
+    inline._label = /(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/;
+    inline._href = /<(?:\\.|[^\n<>\\])+>|[^\s\x00-\x1f]*/;
+    inline._title = /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/;
+
+    inline.link = edit$1(inline.link)
+        .replace('label', inline._label)
+        .replace('href', inline._href)
+        .replace('title', inline._title)
+        .getRegex();
+
+    inline.reflink = edit$1(inline.reflink)
+        .replace('label', inline._label)
+        .getRegex();
+
+    inline.reflinkSearch = edit$1(inline.reflinkSearch, 'g')
+        .replace('reflink', inline.reflink)
+        .replace('nolink', inline.nolink)
+        .getRegex();
+
+    /**
+     * Normal Inline Grammar
+     */
+
+    inline.normal = merge$2({}, inline);
+
+    /**
+     * Pedantic Inline Grammar
+     */
+
+    inline.pedantic = merge$2({}, inline.normal, {
+        strong: {
+            start: /^__|\*\*/,
+            middle: /^__(?=\S)([\s\S]*?\S)__(?!_)|^\*\*(?=\S)([\s\S]*?\S)\*\*(?!\*)/,
+            endAst: /\*\*(?!\*)/g,
+            endUnd: /__(?!_)/g,
+        },
+        em: {
+            start: /^_|\*/,
+            middle: /^()\*(?=\S)([\s\S]*?\S)\*(?!\*)|^_(?=\S)([\s\S]*?\S)_(?!_)/,
+            endAst: /\*(?!\*)/g,
+            endUnd: /_(?!_)/g,
+        },
+        link: edit$1(/^!?\[(label)\]\((.*?)\)/)
+            .replace('label', inline._label)
+            .getRegex(),
+        reflink: edit$1(/^!?\[(label)\]\s*\[([^\]]*)\]/)
+            .replace('label', inline._label)
+            .getRegex(),
+    });
+
+    /**
+     * GFM Inline Grammar
+     */
+
+    inline.gfm = merge$2({}, inline.normal, {
+        escape: edit$1(inline.escape).replace('])', '~|])').getRegex(),
+        _extended_email: /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/,
+        url: /^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/,
+        _backpedal: /(?:[^?!.,:;*_~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_~)]+(?!$))+/,
+        del: /^(~~?)(?=[^\s~])([\s\S]*?[^\s~])\1(?=[^~]|$)/,
+        text: /^([`~]+|[^`~])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*~]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@))|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@))/,
+    });
+
+    inline.gfm.url = edit$1(inline.gfm.url, 'i')
+        .replace('email', inline.gfm._extended_email)
+        .getRegex();
+    /**
+     * GFM + Line Breaks Inline Grammar
+     */
+
+    inline.breaks = merge$2({}, inline.gfm, {
+        br: edit$1(inline.br).replace('{2,}', '*').getRegex(),
+        text: edit$1(inline.gfm.text)
+            .replace('\\b_', '\\b_| {2,}\\n')
+            .replace(/\{2,\}/g, '*')
+            .getRegex(),
+    });
+
+    var rules = {
+        block: block,
+        inline: inline,
+    };
+
+    var defaults$2 = defaults.defaults;
+
+    var block$1 = rules.block;
+    var inline$1 = rules.inline;
+
+    var repeatString$1 = helpers.repeatString;
+
+    /**
+     * smartypants text replacement
+     */
+    function smartypants(text) {
+        return text
+            // em-dashes
+            .replace(/---/g, '\u2014')
+            // en-dashes
+            .replace(/--/g, '\u2013')
+            // opening singles
+            .replace(/(^|[-\u2014/(\[{"\s])'/g, '$1\u2018')
+            // closing singles & apostrophes
+            .replace(/'/g, '\u2019')
+            // opening doubles
+            .replace(/(^|[-\u2014/(\[{\u2018\s])"/g, '$1\u201c')
+            // closing doubles
+            .replace(/"/g, '\u201d')
+            // ellipses
+            .replace(/\.{3}/g, '\u2026');
+    }
+
+    /**
+     * mangle email addresses
+     */
+    function mangle(text) {
+        var out = '',
+            i,
+            ch;
+
+        var l = text.length;
+        for (i = 0; i < l; i++) {
+            ch = text.charCodeAt(i);
+            if (Math.random() > 0.5) {
+                ch = 'x' + ch.toString(16);
+            }
+            out += '&#' + ch + ';';
+        }
+
+        return out;
+    }
+
+    /**
+     * Block Lexer
+     */
+    var Lexer = /*@__PURE__*/(function () {
+        function Lexer(options) {
+            this.tokens = [];
+            this.tokens.links = Object.create(null);
+            this.options = options || defaults$2;
+            this.options.tokenizer = this.options.tokenizer || new Tokenizer();
+            this.tokenizer = this.options.tokenizer;
+            this.tokenizer.options = this.options;
+
+            var rules = {
+                block: block$1.normal,
+                inline: inline$1.normal,
+            };
+
+            if (this.options.pedantic) {
+                rules.block = block$1.pedantic;
+                rules.inline = inline$1.pedantic;
+            } else if (this.options.gfm) {
+                rules.block = block$1.gfm;
+                if (this.options.breaks) {
+                    rules.inline = inline$1.breaks;
+                } else {
+                    rules.inline = inline$1.gfm;
+                }
+            }
+            this.tokenizer.rules = rules;
+        }
+
+        var staticAccessors = { rules: { configurable: true } };
+
+        /**
+         * Expose Rules
+         */
+        staticAccessors.rules.get = function () {
+            return {
+                block: block$1,
+                inline: inline$1,
+            };
+        };
+
+        /**
+         * Static Lex Method
+         */
+        Lexer.lex = function lex(src, options) {
+            var lexer = new Lexer(options);
+            return lexer.lex(src);
+        };
+
+        /**
+         * Static Lex Inline Method
+         */
+        Lexer.lexInline = function lexInline(src, options) {
+            var lexer = new Lexer(options);
+            return lexer.inlineTokens(src);
+        };
+
+        /**
+         * Preprocessing
+         */
+        Lexer.prototype.lex = function lex(src) {
+            src = src
+                .replace(/\r\n|\r/g, '\n')
+                .replace(/\t/g, '    ');
+
+            this.blockTokens(src, this.tokens, true);
+
+            this.inline(this.tokens);
+
+            return this.tokens;
+        };
+
+        /**
+         * Lexing
+         */
+        Lexer.prototype.blockTokens = function blockTokens(src, tokens, top) {
+            if (tokens === void 0) tokens = [];
+            if (top === void 0) top = true;
+
+            if (this.options.pedantic) {
+                src = src.replace(/^ +$/gm, '');
+            }
+            var token, i, l, lastToken;
+
+            while (src) {
+                // newline
+                if (token = this.tokenizer.space(src)) {
+                    src = src.substring(token.raw.length);
+                    if (token.type) {
+                        tokens.push(token);
+                    }
+                    continue;
+                }
+
+                // code
+                if (token = this.tokenizer.code(src, tokens)) {
+                    src = src.substring(token.raw.length);
+                    if (token.type) {
+                        tokens.push(token);
+                    } else {
+                        lastToken = tokens[tokens.length - 1];
+                        lastToken.raw += '\n' + token.raw;
+                        lastToken.text += '\n' + token.text;
+                    }
+                    continue;
+                }
+
+                // fences
+                if (token = this.tokenizer.fences(src)) {
+                    src = src.substring(token.raw.length);
+                    tokens.push(token);
+                    continue;
+                }
+
+                // heading
+                if (token = this.tokenizer.heading(src)) {
+                    src = src.substring(token.raw.length);
+                    tokens.push(token);
+                    continue;
+                }
+
+                // table no leading pipe (gfm)
+                if (token = this.tokenizer.nptable(src)) {
+                    src = src.substring(token.raw.length);
+                    tokens.push(token);
+                    continue;
+                }
+
+                // hr
+                if (token = this.tokenizer.hr(src)) {
+                    src = src.substring(token.raw.length);
+                    tokens.push(token);
+                    continue;
+                }
+
+                // blockquote
+                if (token = this.tokenizer.blockquote(src)) {
+                    src = src.substring(token.raw.length);
+                    token.tokens = this.blockTokens(token.text, [], top);
+                    tokens.push(token);
+                    continue;
+                }
+
+                // list
+                if (token = this.tokenizer.list(src)) {
+                    src = src.substring(token.raw.length);
+                    l = token.items.length;
+                    for (i = 0; i < l; i++) {
+                        token.items[i].tokens = this.blockTokens(token.items[i].text, [], false);
+                    }
+                    tokens.push(token);
+                    continue;
+                }
+
+                // html
+                if (token = this.tokenizer.html(src)) {
+                    src = src.substring(token.raw.length);
+                    tokens.push(token);
+                    continue;
+                }
+
+                // def
+                if (top && (token = this.tokenizer.def(src))) {
+                    src = src.substring(token.raw.length);
+                    if (!this.tokens.links[token.tag]) {
+                        this.tokens.links[token.tag] = {
+                            href: token.href,
+                            title: token.title,
+                        };
+                    }
+                    continue;
+                }
+
+                // table (gfm)
+                if (token = this.tokenizer.table(src)) {
+                    src = src.substring(token.raw.length);
+                    tokens.push(token);
+                    continue;
+                }
+
+                // lheading
+                if (token = this.tokenizer.lheading(src)) {
+                    src = src.substring(token.raw.length);
+                    tokens.push(token);
+                    continue;
+                }
+
+                // top-level paragraph
+                if (top && (token = this.tokenizer.paragraph(src))) {
+                    src = src.substring(token.raw.length);
+                    tokens.push(token);
+                    continue;
+                }
+
+                // text
+                if (token = this.tokenizer.text(src, tokens)) {
+                    src = src.substring(token.raw.length);
+                    if (token.type) {
+                        tokens.push(token);
+                    } else {
+                        lastToken = tokens[tokens.length - 1];
+                        lastToken.raw += '\n' + token.raw;
+                        lastToken.text += '\n' + token.text;
+                    }
+                    continue;
+                }
+
+                if (src) {
+                    var errMsg = 'Infinite loop on byte: ' + src.charCodeAt(0);
+                    if (this.options.silent) {
+                        console.error(errMsg);
+                        break;
+                    } else {
+                        throw new Error(errMsg);
+                    }
+                }
+            }
+
+            return tokens;
+        };
+
+        Lexer.prototype.inline = function inline(tokens) {
+            var i,
+                j,
+                k,
+                l2,
+                row,
+                token;
+
+            var l = tokens.length;
+            for (i = 0; i < l; i++) {
+                token = tokens[i];
+                switch (token.type) {
+                    case 'paragraph':
+                    case 'text':
+                    case 'heading': {
+                        token.tokens = [];
+                        this.inlineTokens(token.text, token.tokens);
+                        break;
+                    }
+                    case 'table': {
+                        token.tokens = {
+                            header: [],
+                            cells: [],
+                        };
+
+                        // header
+                        l2 = token.header.length;
+                        for (j = 0; j < l2; j++) {
+                            token.tokens.header[j] = [];
+                            this.inlineTokens(token.header[j], token.tokens.header[j]);
+                        }
+
+                        // cells
+                        l2 = token.cells.length;
+                        for (j = 0; j < l2; j++) {
+                            row = token.cells[j];
+                            token.tokens.cells[j] = [];
+                            for (k = 0; k < row.length; k++) {
+                                token.tokens.cells[j][k] = [];
+                                this.inlineTokens(row[k], token.tokens.cells[j][k]);
+                            }
+                        }
+
+                        break;
+                    }
+                    case 'blockquote': {
+                        this.inline(token.tokens);
+                        break;
+                    }
+                    case 'list': {
+                        l2 = token.items.length;
+                        for (j = 0; j < l2; j++) {
+                            this.inline(token.items[j].tokens);
+                        }
+                        break;
+                    }
+                }
+            }
+
+            return tokens;
+        };
+
+        /**
+         * Lexing/Compiling
+         */
+        Lexer.prototype.inlineTokens = function inlineTokens(src, tokens, inLink, inRawBlock) {
+            if (tokens === void 0) tokens = [];
+            if (inLink === void 0) inLink = false;
+            if (inRawBlock === void 0) inRawBlock = false;
+
+            var token;
+
+            // String with links masked to avoid interference with em and strong
+            var maskedSrc = src;
+            var match;
+            var keepPrevChar, prevChar;
+
+            // Mask out reflinks
+            if (this.tokens.links) {
+                var links = Object.keys(this.tokens.links);
+                if (links.length > 0) {
+                    while ((match = this.tokenizer.rules.inline.reflinkSearch.exec(maskedSrc)) != null) {
+                        if (links.includes(match[0].slice(match[0].lastIndexOf('[') + 1, -1))) {
+                            maskedSrc = maskedSrc.slice(0, match.index) + '[' + repeatString$1('a', match[0].length - 2) + ']' + maskedSrc.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex);
+                        }
+                    }
+                }
+            }
+            // Mask out other blocks
+            while ((match = this.tokenizer.rules.inline.blockSkip.exec(maskedSrc)) != null) {
+                maskedSrc = maskedSrc.slice(0, match.index) + '[' + repeatString$1('a', match[0].length - 2) + ']' + maskedSrc.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);
+            }
+
+            while (src) {
+                if (!keepPrevChar) {
+                    prevChar = '';
+                }
+                keepPrevChar = false;
+                // escape
+                if (token = this.tokenizer.escape(src)) {
+                    src = src.substring(token.raw.length);
+                    tokens.push(token);
+                    continue;
+                }
+
+                // tag
+                if (token = this.tokenizer.tag(src, inLink, inRawBlock)) {
+                    src = src.substring(token.raw.length);
+                    inLink = token.inLink;
+                    inRawBlock = token.inRawBlock;
+                    tokens.push(token);
+                    continue;
+                }
+
+                // link
+                if (token = this.tokenizer.link(src)) {
+                    src = src.substring(token.raw.length);
+                    if (token.type === 'link') {
+                        token.tokens = this.inlineTokens(token.text, [], true, inRawBlock);
+                    }
+                    tokens.push(token);
+                    continue;
+                }
+
+                // reflink, nolink
+                if (token = this.tokenizer.reflink(src, this.tokens.links)) {
+                    src = src.substring(token.raw.length);
+                    if (token.type === 'link') {
+                        token.tokens = this.inlineTokens(token.text, [], true, inRawBlock);
+                    }
+                    tokens.push(token);
+                    continue;
+                }
+
+                // strong
+                if (token = this.tokenizer.strong(src, maskedSrc, prevChar)) {
+                    src = src.substring(token.raw.length);
+                    token.tokens = this.inlineTokens(token.text, [], inLink, inRawBlock);
+                    tokens.push(token);
+                    continue;
+                }
+
+                // em
+                if (token = this.tokenizer.em(src, maskedSrc, prevChar)) {
+                    src = src.substring(token.raw.length);
+                    token.tokens = this.inlineTokens(token.text, [], inLink, inRawBlock);
+                    tokens.push(token);
+                    continue;
+                }
+
+                // code
+                if (token = this.tokenizer.codespan(src)) {
+                    src = src.substring(token.raw.length);
+                    tokens.push(token);
+                    continue;
+                }
+
+                // br
+                if (token = this.tokenizer.br(src)) {
+                    src = src.substring(token.raw.length);
+                    tokens.push(token);
+                    continue;
+                }
+
+                // del (gfm)
+                if (token = this.tokenizer.del(src)) {
+                    src = src.substring(token.raw.length);
+                    token.tokens = this.inlineTokens(token.text, [], inLink, inRawBlock);
+                    tokens.push(token);
+                    continue;
+                }
+
+                // autolink
+                if (token = this.tokenizer.autolink(src, mangle)) {
+                    src = src.substring(token.raw.length);
+                    tokens.push(token);
+                    continue;
+                }
+
+                // url (gfm)
+                if (!inLink && (token = this.tokenizer.url(src, mangle))) {
+                    src = src.substring(token.raw.length);
+                    tokens.push(token);
+                    continue;
+                }
+
+                // text
+                if (token = this.tokenizer.inlineText(src, inRawBlock, smartypants)) {
+                    src = src.substring(token.raw.length);
+                    prevChar = token.raw.slice(-1);
+                    keepPrevChar = true;
+                    tokens.push(token);
+                    continue;
+                }
+
+                if (src) {
+                    var errMsg = 'Infinite loop on byte: ' + src.charCodeAt(0);
+                    if (this.options.silent) {
+                        console.error(errMsg);
+                        break;
+                    } else {
+                        throw new Error(errMsg);
+                    }
+                }
+            }
+
+            return tokens;
+        };
+
+        Object.defineProperties(Lexer, staticAccessors);
+
+        return Lexer;
+    }());
+
+    var defaults$3 = defaults.defaults;
+
+    var cleanUrl$1 = helpers.cleanUrl;
+    var escape$2 = helpers.escape;
+
+    /**
+     * Renderer
+     */
+    var Renderer = /*@__PURE__*/(function () {
+        function Renderer(options) {
+            this.options = options || defaults$3;
+        }
+
+        Renderer.prototype.code = function code(code$1, infostring, escaped) {
+            var lang = (infostring || '').match(/\S*/)[0];
+            if (this.options.highlight) {
+                var out = this.options.highlight(code$1, lang);
+                if (out != null && out !== code$1) {
+                    escaped = true;
+                    code$1 = out;
+                }
+            }
+
+            code$1 = code$1.replace(/\n$/, '') + '\n';
+
+            if (!lang) {
+                return '<pre><code>'
+                    + (escaped ? code$1 : escape$2(code$1, true))
+                    + '</code></pre>\n';
+            }
+
+            return '<pre><code class="'
+                + this.options.langPrefix
+                + escape$2(lang, true)
+                + '">'
+                + (escaped ? code$1 : escape$2(code$1, true))
+                + '</code></pre>\n';
+        };
+
+        Renderer.prototype.blockquote = function blockquote(quote) {
+            return '<blockquote>\n' + quote + '</blockquote>\n';
+        };
+
+        Renderer.prototype.html = function html(html$1) {
+            return html$1;
+        };
+
+        Renderer.prototype.heading = function heading(text, level, raw, slugger) {
+            if (this.options.headerIds) {
+                return '<h'
+                    + level
+                    + ' id="'
+                    + this.options.headerPrefix
+                    + slugger.slug(raw)
+                    + '">'
+                    + text
+                    + '</h'
+                    + level
+                    + '>\n';
+            }
+            // ignore IDs
+            return '<h' + level + '>' + text + '</h' + level + '>\n';
+        };
+
+        Renderer.prototype.hr = function hr() {
+            return this.options.xhtml ? '<hr/>\n' : '<hr>\n';
+        };
+
+        Renderer.prototype.list = function list(body, ordered, start) {
+            var type = ordered ? 'ol' : 'ul',
+                startatt = (ordered && start !== 1) ? (' start="' + start + '"') : '';
+            return '<' + type + startatt + '>\n' + body + '</' + type + '>\n';
+        };
+
+        Renderer.prototype.listitem = function listitem(text) {
+            return '<li>' + text + '</li>\n';
+        };
+
+        Renderer.prototype.checkbox = function checkbox(checked) {
+            return '<input '
+                + (checked ? 'checked="" ' : '')
+                + 'disabled="" type="checkbox"'
+                + (this.options.xhtml ? ' /' : '')
+                + '> ';
+        };
+
+        Renderer.prototype.paragraph = function paragraph(text) {
+            return '<p>' + text + '</p>\n';
+        };
+
+        Renderer.prototype.table = function table(header, body) {
+            if (body) {
+                body = '<tbody>' + body + '</tbody>';
+            }
+
+            return '<table>\n'
+                + '<thead>\n'
+                + header
+                + '</thead>\n'
+                + body
+                + '</table>\n';
+        };
+
+        Renderer.prototype.tablerow = function tablerow(content) {
+            return '<tr>\n' + content + '</tr>\n';
+        };
+
+        Renderer.prototype.tablecell = function tablecell(content, flags) {
+            var type = flags.header ? 'th' : 'td';
+            var tag = flags.align
+                ? '<' + type + ' align="' + flags.align + '">'
+                : '<' + type + '>';
+            return tag + content + '</' + type + '>\n';
+        };
+
+        // span level renderer
+        Renderer.prototype.strong = function strong(text) {
+            return '<strong>' + text + '</strong>';
+        };
+
+        Renderer.prototype.em = function em(text) {
+            return '<em>' + text + '</em>';
+        };
+
+        Renderer.prototype.codespan = function codespan(text) {
+            return '<code>' + text + '</code>';
+        };
+
+        Renderer.prototype.br = function br() {
+            return this.options.xhtml ? '<br/>' : '<br>';
+        };
+
+        Renderer.prototype.del = function del(text) {
+            return '<del>' + text + '</del>';
+        };
+
+        Renderer.prototype.link = function link(href, title, text) {
+            href = cleanUrl$1(this.options.sanitize, this.options.baseUrl, href);
+            if (href === null) {
+                return text;
+            }
+            var out = '<a href="' + escape$2(href) + '"';
+            if (title) {
+                out += ' title="' + title + '"';
+            }
+            out += '>' + text + '</a>';
+            return out;
+        };
+
+        Renderer.prototype.image = function image(href, title, text) {
+            href = cleanUrl$1(this.options.sanitize, this.options.baseUrl, href);
+            if (href === null) {
+                return text;
+            }
+
+            var out = '<img src="' + href + '" alt="' + text + '"';
+            if (title) {
+                out += ' title="' + title + '"';
+            }
+            out += this.options.xhtml ? '/>' : '>';
+            return out;
+        };
+
+        Renderer.prototype.text = function text(text$1) {
+            return text$1;
+        };
+
+        return Renderer;
+    }());
+
+    /**
+     * TextRenderer
+     * returns only the textual part of the token
+     */
+    var TextRenderer = /*@__PURE__*/(function () {
+        function TextRenderer() {
+        }
+
+        TextRenderer.prototype.strong = function strong(text) {
+            return text;
+        };
+
+        TextRenderer.prototype.em = function em(text) {
+            return text;
+        };
+
+        TextRenderer.prototype.codespan = function codespan(text) {
+            return text;
+        };
+
+        TextRenderer.prototype.del = function del(text) {
+            return text;
+        };
+
+        TextRenderer.prototype.html = function html(text) {
+            return text;
+        };
+
+        TextRenderer.prototype.text = function text(text$1) {
+            return text$1;
+        };
+
+        TextRenderer.prototype.link = function link(href, title, text) {
+            return '' + text;
+        };
+
+        TextRenderer.prototype.image = function image(href, title, text) {
+            return '' + text;
+        };
+
+        TextRenderer.prototype.br = function br() {
+            return '';
+        };
+
+        return TextRenderer;
+    }());
+
+    /**
+     * Slugger generates header id
+     */
+    var Slugger = /*@__PURE__*/(function () {
+        function Slugger() {
+            this.seen = {};
+        }
+
+        Slugger.prototype.serialize = function serialize(value) {
+            return value
+                .toLowerCase()
+                .trim()
+                // remove html tags
+                .replace(/<[!\/a-z].*?>/ig, '')
+                // remove unwanted chars
+                .replace(/[\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&()*+,./:;<=>?@[\]^`{|}~]/g, '')
+                .replace(/\s/g, '-');
+        };
+
+        /**
+         * Finds the next safe (unique) slug to use
+         */
+        Slugger.prototype.getNextSafeSlug = function getNextSafeSlug(originalSlug, isDryRun) {
+            var slug = originalSlug;
+            var occurenceAccumulator = 0;
+            if (this.seen.hasOwnProperty(slug)) {
+                occurenceAccumulator = this.seen[originalSlug];
+                do {
+                    occurenceAccumulator++;
+                    slug = originalSlug + '-' + occurenceAccumulator;
+                } while (this.seen.hasOwnProperty(slug));
+            }
+            if (!isDryRun) {
+                this.seen[originalSlug] = occurenceAccumulator;
+                this.seen[slug] = 0;
+            }
+            return slug;
+        };
+
+        /**
+         * Convert string to unique id
+         * @param {object} options
+         * @param {boolean} options.dryrun Generates the next unique slug without updating the internal accumulator.
+         */
+        Slugger.prototype.slug = function slug(value, options) {
+            if (options === void 0) options = {};
+
+            var slug = this.serialize(value);
+            return this.getNextSafeSlug(slug, options.dryrun);
+        };
+
+        return Slugger;
+    }());
+
+    var defaults$4 = defaults.defaults;
+
+    var unescape$1 = helpers.unescape;
+
+    /**
+     * Parsing & Compiling
+     */
+    var Parser = /*@__PURE__*/(function () {
+        function Parser(options) {
+            this.options = options || defaults$4;
+            this.options.renderer = this.options.renderer || new Renderer();
+            this.renderer = this.options.renderer;
+            this.renderer.options = this.options;
+            this.textRenderer = new TextRenderer();
+            this.slugger = new Slugger();
+        }
+
+        /**
+         * Static Parse Method
+         */
+        Parser.parse = function parse(tokens, options) {
+            var parser = new Parser(options);
+            return parser.parse(tokens);
+        };
+
+        /**
+         * Static Parse Inline Method
+         */
+        Parser.parseInline = function parseInline(tokens, options) {
+            var parser = new Parser(options);
+            return parser.parseInline(tokens);
+        };
+
+        /**
+         * Parse Loop
+         */
+        Parser.prototype.parse = function parse(tokens, top) {
+            if (top === void 0) top = true;
+
+            var out = '',
+                i,
+                j,
+                k,
+                l2,
+                l3,
+                row,
+                cell,
+                header,
+                body,
+                token,
+                ordered,
+                start,
+                loose,
+                itemBody,
+                item,
+                checked,
+                task,
+                checkbox;
+
+            var l = tokens.length;
+            for (i = 0; i < l; i++) {
+                token = tokens[i];
+                switch (token.type) {
+                    case 'space': {
+                        continue;
+                    }
+                    case 'hr': {
+                        out += this.renderer.hr();
+                        continue;
+                    }
+                    case 'heading': {
+                        out += this.renderer.heading(
+                            this.parseInline(token.tokens),
+                            token.depth,
+                            unescape$1(this.parseInline(token.tokens, this.textRenderer)),
+                            this.slugger);
+                        continue;
+                    }
+                    case 'code': {
+                        out += this.renderer.code(token.text,
+                            token.lang,
+                            token.escaped);
+                        continue;
+                    }
+                    case 'table': {
+                        header = '';
+
+                        // header
+                        cell = '';
+                        l2 = token.header.length;
+                        for (j = 0; j < l2; j++) {
+                            cell += this.renderer.tablecell(
+                                this.parseInline(token.tokens.header[j]),
+                                { header: true, align: token.align[j] },
+                            );
+                        }
+                        header += this.renderer.tablerow(cell);
+
+                        body = '';
+                        l2 = token.cells.length;
+                        for (j = 0; j < l2; j++) {
+                            row = token.tokens.cells[j];
+
+                            cell = '';
+                            l3 = row.length;
+                            for (k = 0; k < l3; k++) {
+                                cell += this.renderer.tablecell(
+                                    this.parseInline(row[k]),
+                                    { header: false, align: token.align[k] },
+                                );
+                            }
+
+                            body += this.renderer.tablerow(cell);
+                        }
+                        out += this.renderer.table(header, body);
+                        continue;
+                    }
+                    case 'blockquote': {
+                        body = this.parse(token.tokens);
+                        out += this.renderer.blockquote(body);
+                        continue;
+                    }
+                    case 'list': {
+                        ordered = token.ordered;
+                        start = token.start;
+                        loose = token.loose;
+                        l2 = token.items.length;
+
+                        body = '';
+                        for (j = 0; j < l2; j++) {
+                            item = token.items[j];
+                            checked = item.checked;
+                            task = item.task;
+
+                            itemBody = '';
+                            if (item.task) {
+                                checkbox = this.renderer.checkbox(checked);
+                                if (loose) {
+                                    if (item.tokens.length > 0 && item.tokens[0].type === 'text') {
+                                        item.tokens[0].text = checkbox + ' ' + item.tokens[0].text;
+                                        if (item.tokens[0].tokens && item.tokens[0].tokens.length > 0 && item.tokens[0].tokens[0].type === 'text') {
+                                            item.tokens[0].tokens[0].text = checkbox + ' ' + item.tokens[0].tokens[0].text;
+                                        }
+                                    } else {
+                                        item.tokens.unshift({
+                                            type: 'text',
+                                            text: checkbox,
+                                        });
+                                    }
+                                } else {
+                                    itemBody += checkbox;
+                                }
+                            }
+
+                            itemBody += this.parse(item.tokens, loose);
+                            body += this.renderer.listitem(itemBody, task, checked);
+                        }
+
+                        out += this.renderer.list(body, ordered, start);
+                        continue;
+                    }
+                    case 'html': {
+                        // TODO parse inline content if parameter markdown=1
+                        out += this.renderer.html(token.text);
+                        continue;
+                    }
+                    case 'paragraph': {
+                        out += this.renderer.paragraph(this.parseInline(token.tokens));
+                        continue;
+                    }
+                    case 'text': {
+                        body = token.tokens ? this.parseInline(token.tokens) : token.text;
+                        while (i + 1 < l && tokens[i + 1].type === 'text') {
+                            token = tokens[++i];
+                            body += '\n' + (token.tokens ? this.parseInline(token.tokens) : token.text);
+                        }
+                        out += top ? this.renderer.paragraph(body) : body;
+                        continue;
+                    }
+                    default: {
+                        var errMsg = 'Token with "' + token.type + '" type was not found.';
+                        if (this.options.silent) {
+                            console.error(errMsg);
+                            return;
+                        } else {
+                            throw new Error(errMsg);
+                        }
+                    }
+                }
+            }
+
+            return out;
+        };
+
+        /**
+         * Parse Inline Tokens
+         */
+        Parser.prototype.parseInline = function parseInline(tokens, renderer) {
+            renderer = renderer || this.renderer;
+            var out = '',
+                i,
+                token;
+
+            var l = tokens.length;
+            for (i = 0; i < l; i++) {
+                token = tokens[i];
+                switch (token.type) {
+                    case 'escape': {
+                        out += renderer.text(token.text);
+                        break;
+                    }
+                    case 'html': {
+                        out += renderer.html(token.text);
+                        break;
+                    }
+                    case 'link': {
+                        out += renderer.link(token.href, token.title, this.parseInline(token.tokens, renderer));
+                        break;
+                    }
+                    case 'image': {
+                        out += renderer.image(token.href, token.title, token.text);
+                        break;
+                    }
+                    case 'strong': {
+                        out += renderer.strong(this.parseInline(token.tokens, renderer));
+                        break;
+                    }
+                    case 'em': {
+                        out += renderer.em(this.parseInline(token.tokens, renderer));
+                        break;
+                    }
+                    case 'codespan': {
+                        out += renderer.codespan(token.text);
+                        break;
+                    }
+                    case 'br': {
+                        out += renderer.br();
+                        break;
+                    }
+                    case 'del': {
+                        out += renderer.del(this.parseInline(token.tokens, renderer));
+                        break;
+                    }
+                    case 'text': {
+                        out += renderer.text(token.text);
+                        break;
+                    }
+                    default: {
+                        var errMsg = 'Token with "' + token.type + '" type was not found.';
+                        if (this.options.silent) {
+                            console.error(errMsg);
+                            return;
+                        } else {
+                            throw new Error(errMsg);
+                        }
+                    }
+                }
+            }
+            return out;
+        };
+
+        return Parser;
+    }());
+
+    var merge$3 = helpers.merge;
+    var checkSanitizeDeprecation$1 = helpers.checkSanitizeDeprecation;
+    var escape$3 = helpers.escape;
+
+    var getDefaults = defaults.getDefaults;
+    var changeDefaults = defaults.changeDefaults;
+    var defaults$5 = defaults.defaults;
+
+    /**
+     * Marked
+     */
+    function marked(src, opt, callback) {
+        // throw error in case of non string input
+        if (typeof src === 'undefined' || src === null) {
+            throw new Error('marked(): input parameter is undefined or null');
+        }
+        if (typeof src !== 'string') {
+            throw new Error('marked(): input parameter is of type '
+                + Object.prototype.toString.call(src) + ', string expected');
+        }
+
+        if (typeof opt === 'function') {
+            callback = opt;
+            opt = null;
+        }
+
+        opt = merge$3({}, marked.defaults, opt || {});
+        checkSanitizeDeprecation$1(opt);
+
+        if (callback) {
+            var highlight = opt.highlight;
+            var tokens;
+
+            try {
+                tokens = Lexer.lex(src, opt);
+            } catch (e) {
+                return callback(e);
+            }
+
+            var done = function (err) {
+                var out;
+
+                if (!err) {
+                    try {
+                        out = Parser.parse(tokens, opt);
+                    } catch (e) {
+                        err = e;
+                    }
+                }
+
+                opt.highlight = highlight;
+
+                return err
+                    ? callback(err)
+                    : callback(null, out);
+            };
+
+            if (!highlight || highlight.length < 3) {
+                return done();
+            }
+
+            delete opt.highlight;
+
+            if (!tokens.length) {
+                return done();
+            }
+
+            var pending = 0;
+            marked.walkTokens(tokens, function (token) {
+                if (token.type === 'code') {
+                    pending++;
+                    setTimeout(function () {
+                        highlight(token.text, token.lang, function (err, code) {
+                            if (err) {
+                                return done(err);
+                            }
+                            if (code != null && code !== token.text) {
+                                token.text = code;
+                                token.escaped = true;
+                            }
+
+                            pending--;
+                            if (pending === 0) {
+                                done();
+                            }
+                        });
+                    }, 0);
+                }
+            });
+
+            if (pending === 0) {
+                done();
+            }
+
+            return;
+        }
+
+        try {
+            var tokens$1 = Lexer.lex(src, opt);
+            if (opt.walkTokens) {
+                marked.walkTokens(tokens$1, opt.walkTokens);
+            }
+            return Parser.parse(tokens$1, opt);
+        } catch (e) {
+            e.message += '\nPlease report this to https://github.com/markedjs/marked.';
+            if (opt.silent) {
+                return '<p>An error occurred:</p><pre>'
+                    + escape$3(e.message + '', true)
+                    + '</pre>';
+            }
+            throw e;
+        }
+    }
+
+    /**
+     * Options
+     */
+
+    marked.options =
+        marked.setOptions = function (opt) {
+            merge$3(marked.defaults, opt);
+            changeDefaults(marked.defaults);
+            return marked;
+        };
+
+    marked.getDefaults = getDefaults;
+
+    marked.defaults = defaults$5;
+
+    /**
+     * Use Extension
+     */
+
+    marked.use = function (extension) {
+        var opts = merge$3({}, extension);
+        if (extension.renderer) {
+            var renderer = marked.defaults.renderer || new Renderer();
+            var loop = function (prop) {
+                var prevRenderer = renderer[prop];
+                renderer[prop] = function () {
+                    var args = [], len = arguments.length;
+                    while (len--) args[len] = arguments[len];
+
+                    var ret = extension.renderer[prop].apply(renderer, args);
+                    if (ret === false) {
+                        ret = prevRenderer.apply(renderer, args);
+                    }
+                    return ret;
+                };
+            };
+
+            for (var prop in extension.renderer) loop(prop);
+            opts.renderer = renderer;
+        }
+        if (extension.tokenizer) {
+            var tokenizer = marked.defaults.tokenizer || new Tokenizer();
+            var loop$1 = function (prop) {
+                var prevTokenizer = tokenizer[prop$1];
+                tokenizer[prop$1] = function () {
+                    var args = [], len = arguments.length;
+                    while (len--) args[len] = arguments[len];
+
+                    var ret = extension.tokenizer[prop$1].apply(tokenizer, args);
+                    if (ret === false) {
+                        ret = prevTokenizer.apply(tokenizer, args);
+                    }
+                    return ret;
+                };
+            };
+
+            for (var prop$1 in extension.tokenizer) loop$1(prop);
+            opts.tokenizer = tokenizer;
+        }
+        if (extension.walkTokens) {
+            var walkTokens = marked.defaults.walkTokens;
+            opts.walkTokens = function (token) {
+                extension.walkTokens(token);
+                if (walkTokens) {
+                    walkTokens(token);
+                }
+            };
+        }
+        marked.setOptions(opts);
+    };
+
+    /**
+     * Run callback for every token
+     */
+
+    marked.walkTokens = function (tokens, callback) {
+        for (var i$3 = 0, list$3 = tokens; i$3 < list$3.length; i$3 += 1) {
+            var token = list$3[i$3];
+
+            callback(token);
+            switch (token.type) {
+                case 'table': {
+                    for (var i = 0, list = token.tokens.header; i < list.length; i += 1) {
+                        var cell = list[i];
+
+                        marked.walkTokens(cell, callback);
+                    }
+                    for (var i$2 = 0, list$2 = token.tokens.cells; i$2 < list$2.length; i$2 += 1) {
+                        var row = list$2[i$2];
+
+                        for (var i$1 = 0, list$1 = row; i$1 < list$1.length; i$1 += 1) {
+                            var cell$1 = list$1[i$1];
+
+                            marked.walkTokens(cell$1, callback);
+                        }
+                    }
+                    break;
+                }
+                case 'list': {
+                    marked.walkTokens(token.items, callback);
+                    break;
+                }
+                default: {
+                    if (token.tokens) {
+                        marked.walkTokens(token.tokens, callback);
+                    }
+                }
+            }
+        }
+    };
+
+    /**
+     * Parse Inline
+     */
+    marked.parseInline = function (src, opt) {
+        // throw error in case of non string input
+        if (typeof src === 'undefined' || src === null) {
+            throw new Error('marked.parseInline(): input parameter is undefined or null');
+        }
+        if (typeof src !== 'string') {
+            throw new Error('marked.parseInline(): input parameter is of type '
+                + Object.prototype.toString.call(src) + ', string expected');
+        }
+
+        opt = merge$3({}, marked.defaults, opt || {});
+        checkSanitizeDeprecation$1(opt);
+
+        try {
+            var tokens = Lexer.lexInline(src, opt);
+            if (opt.walkTokens) {
+                marked.walkTokens(tokens, opt.walkTokens);
+            }
+            return Parser.parseInline(tokens, opt);
+        } catch (e) {
+            e.message += '\nPlease report this to https://github.com/markedjs/marked.';
+            if (opt.silent) {
+                return '<p>An error occurred:</p><pre>'
+                    + escape$3(e.message + '', true)
+                    + '</pre>';
+            }
+            throw e;
+        }
+    };
+
+    /**
+     * Expose
+     */
+
+    marked.Parser = Parser;
+    marked.parser = Parser.parse;
+
+    marked.Renderer = Renderer;
+    marked.TextRenderer = TextRenderer;
+
+    marked.Lexer = Lexer;
+    marked.lexer = Lexer.lex;
+
+    marked.Tokenizer = Tokenizer;
+
+    marked.Slugger = Slugger;
+
+    marked.parse = marked;
+
+    var marked_1 = marked;
+
+    /**
+     * Render github corner
+     * @param  {Object} data URL for the View Source on Github link
+     * @param {String} cornerExternalLinkTarge value of the target attribute of the link
+     * @return {String} SVG element as string
+     */
+    function corner(data, cornerExternalLinkTarge) {
+        if (!data) {
+            return '';
+        }
+
+        if (!/\/\//.test(data)) {
+            data = 'https://github.com/' + data;
+        }
+
+        data = data.replace(/^git\+/, '');
+        // Double check
+        cornerExternalLinkTarge = cornerExternalLinkTarge || '_blank';
+
+        return (
+            '<a href="' + data + '" target="' + cornerExternalLinkTarge + '" class="github-corner" aria-label="View source on Github">' +
+            '<svg viewBox="0 0 250 250" aria-hidden="true">' +
+            '<path d="M0,0 L115,115 L130,115 L142,142 L250,250 L250,0 Z"></path>' +
+            '<path d="M128.3,109.0 C113.8,99.7 119.0,89.6 119.0,89.6 C122.0,82.7 120.5,78.6 120.5,78.6 C119.2,72.0 123.4,76.3 123.4,76.3 C127.3,80.9 125.5,87.3 125.5,87.3 C122.9,97.6 130.6,101.9 134.4,103.2" fill="currentColor" style="transform-origin: 130px 106px;" class="octo-arm"></path>' +
+            '<path d="M115.0,115.0 C114.9,115.1 118.7,116.5 119.8,115.4 L133.7,101.6 C136.9,99.2 139.9,98.4 142.2,98.6 C133.8,88.0 127.5,74.4 143.8,58.0 C148.5,53.4 154.0,51.2 159.7,51.0 C160.3,49.4 163.2,43.6 171.4,40.1 C171.4,40.1 176.1,42.5 178.8,56.2 C183.1,58.6 187.2,61.8 190.9,65.4 C194.5,69.0 197.7,73.2 200.1,77.6 C213.8,80.2 216.3,84.9 216.3,84.9 C212.7,93.1 206.9,96.0 205.4,96.6 C205.1,102.4 203.0,107.8 198.3,112.5 C181.9,128.9 168.3,122.5 157.7,114.1 C157.9,116.9 156.7,120.9 152.7,124.9 L141.0,136.5 C139.8,137.7 141.6,141.9 141.8,141.8 Z" fill="currentColor" class="octo-body"></path>' +
+            '</svg>' +
+            '</a>'
+        );
+    }
+
+    /**
+     * Renders main content
+     * @param {Object} config Configuration object
+     * @returns {String} HTML of the main content
+     */
+    function main(config) {
+        var name = config.name ? config.name : '';
+
+        var aside =
+            '<button class="sidebar-toggle" aria-label="Menu">' +
+            '<div class="sidebar-toggle-button">' +
+            '<span></span><span></span><span></span>' +
+            '</div>' +
+            '</button>' +
+            '<aside class="sidebar">' +
+            (config.name
+                ? ('<h1 class="app-name"><a class="app-name-link" data-nosearch>' + (config.logo ? ('<img alt="' + name + '" src=' + (config.logo) + '>') : name) + '</a></h1>')
+                : '') +
+            '<div class="sidebar-nav"><!--sidebar--></div>' +
+            '</aside>';
+        return (
+            '<main>' + aside +
+            '<section class="content">' +
+            '<article class="markdown-section" id="main"><!--main--></article>' +
+            '</section>' +
+            '</main>'
+        );
+    }
+
+    /**
+     * Cover Page
+     * @returns {String} Cover page
+     */
+    function cover() {
+        var SL = ', 100%, 85%';
+        var bgc =
+            'linear-gradient(to left bottom, ' +
+            'hsl(' + (Math.floor(Math.random() * 255) + SL) + ') 0%,' +
+            'hsl(' + (Math.floor(Math.random() * 255) + SL) + ') 100%)';
+
+        return (
+            '<section class="cover show" style="background: ' + bgc + '">' +
+            '<div class="mask"></div>' +
+            '<div class="cover-main"><!--cover--></div>' +
+            '</section>'
+        );
+    }
+
+    /**
+     * Render tree
+     * @param  {Array} toc Array of TOC section links
+     * @param  {String} tpl TPL list
+     * @return {String} Rendered tree
+     */
+    function tree(toc, tpl) {
+        if (tpl === void 0) tpl = '<ul class="app-sub-sidebar">{inner}</ul>';
+
+        if (!toc || !toc.length) {
+            return '';
+        }
+
+        var innerHTML = '';
+        toc.forEach(function (node) {
+            var title = node.title.replace(/(<([^>]+)>)/g, '');
+            innerHTML += '<li><a class="section-link" href="' + (node.slug) + '" title="' + title + '">' + (node.title) + '</a></li>';
+            if (node.children) {
+                innerHTML += tree(node.children, tpl);
+            }
+        });
+        return tpl.replace('{inner}', innerHTML);
+    }
+
+    function helper(className, content) {
+        return ('<p class="' + className + '">' + (content.slice(5).trim()) + '</p>');
+    }
+
+    function theme(color) {
+        return ('<style>:root{--theme-color: ' + color + ';}</style>');
+    }
+
+    /**
+     * Gen toc tree
+     * @link https://github.com/killercup/grock/blob/5280ae63e16c5739e9233d9009bc235ed7d79a50/styles/solarized/assets/js/behavior.coffee#L54-L81
+     * @param  {Array} toc List of TOC elements
+     * @param  {Number} maxLevel Deep level
+     * @return {Array} Headlines
+     */
+    function genTree(toc, maxLevel) {
+        var headlines = [];
+        var last = {};
+
+        toc.forEach(function (headline) {
+            var level = headline.level || 1;
+            var len = level - 1;
+
+            if (level > maxLevel) {
+                return;
+            }
+
+            if (last[len]) {
+                last[len].children = (last[len].children || []).concat(headline);
+            } else {
+                headlines.push(headline);
+            }
+
+            last[level] = headline;
+        });
+
+        return headlines;
+    }
+
+    var cache$1 = {};
+    var re = /[\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&()*+,./:;<=>?@[\]^`{|}~]/g;
+
+    function lower(string) {
+        return string.toLowerCase();
+    }
+
+    function slugify(str) {
+        if (typeof str !== 'string') {
+            return '';
+        }
+
+        var slug = str
+            .trim()
+            .replace(/[A-Z]+/g, lower)
+            .replace(/<[^>]+>/g, '')
+            .replace(re, '')
+            .replace(/\s/g, '-')
+            .replace(/-+/g, '-')
+            .replace(/^(\d)/, '_$1');
+        var count = cache$1[slug];
+
+        count = hasOwn.call(cache$1, slug) ? count + 1 : 0;
+        cache$1[slug] = count;
+
+        if (count) {
+            slug = slug + '-' + count;
+        }
+
+        return slug;
+    }
+
+    slugify.clear = function () {
+        cache$1 = {};
+    };
+
+    function replace(m, $1) {
+        return (
+            '<img class="emoji" src="https://github.githubassets.com/images/icons/emoji/' +
+            $1 +
+            '.png" alt="' +
+            $1 +
+            '" />'
+        );
+    }
+
+    function emojify(text) {
+        return text
+            .replace(/:\+1:/g, ':thumbsup:')
+            .replace(/:-1:/g, ':thumbsdown:')
+            .replace(/<(pre|template|code)[^>]*?>[\s\S]+?<\/(pre|template|code)>/g, function (m) {
+                    return m.replace(/:/g, '__colon__');
+                },
+            )
+            .replace(/:(\w+?):/gi, (window.emojify) || replace)
+            .replace(/__colon__/g, ':');
+    }
+
+    /**
+     * Converts a colon formatted string to a object with properties.
+     *
+     * This is process a provided string and look for any tokens in the format
+     * of `:name[=value]` and then convert it to a object and return.
+     * An example of this is ':include :type=code :fragment=demo' is taken and
+     * then converted to:
+     *
+     * ```
+     * {
+     *  include: '',
+     *  type: 'code',
+     *  fragment: 'demo'
+     * }
+     * ```
+     *
+     * @param {string}   str   The string to parse.
+     *
+     * @return {object}  The original string and parsed object, { str, config }.
+     */
+    function getAndRemoveConfig(str) {
+        if (str === void 0) str = '';
+
+        var config = {};
+
+        if (str) {
+            str = str
+                .replace(/^('|")/, '')
+                .replace(/('|")$/, '')
+                .replace(/(?:^|\s):([\w-]+:?)=?([\w-%]+)?/g, function (m, key, value) {
+                    if (key.indexOf(':') === -1) {
+                        config[key] = (value && value.replace(/&quot;/g, '')) || true;
+                        return '';
+                    }
+
+                    return m;
+                })
+                .trim();
+        }
+
+        return { str: str, config: config };
+    }
+
+    /**
+     * Remove the <a> tag from sidebar when the header with link, details see issue 1069
+     * @param {string}   str   The string to deal with.
+     *
+     * @return {string}   str   The string after delete the <a> element.
+     */
+    function removeAtag(str) {
+        if (str === void 0) str = '';
+
+        return str.replace(/(<\/?a.*?>)/gi, '');
+    }
+
+    var imageCompiler = function (ref) {
+        var renderer = ref.renderer;
+        var contentBase = ref.contentBase;
+        var router = ref.router;
+
+        return (renderer.image = function (href, title, text) {
+            var url = href;
+            var attrs = [];
+
+            var ref = getAndRemoveConfig(title);
+            var str = ref.str;
+            var config = ref.config;
+            title = str;
+
+            if (config['no-zoom']) {
+                attrs.push('data-no-zoom');
+            }
+
+            if (title) {
+                attrs.push(('title="' + title + '"'));
+            }
+
+            if (config.size) {
+                var ref$1 = config.size.split('x');
+                var width = ref$1[0];
+                var height = ref$1[1];
+                if (height) {
+                    attrs.push(('width="' + width + '" height="' + height + '"'));
+                } else {
+                    attrs.push(('width="' + width + '"'));
+                }
+            }
+
+            if (config.class) {
+                attrs.push(('class="' + (config.class) + '"'));
+            }
+
+            if (config.id) {
+                attrs.push(('id="' + (config.id) + '"'));
+            }
+
+            if (!isAbsolutePath(href)) {
+                url = getPath(contentBase, getParentPath(router.getCurrentPath()), href);
+            }
+
+            if (attrs.length > 0) {
+                return ('<img src="' + url + '" data-origin="' + href + '" alt="' + text + '" ' + (attrs.join(
+                    ' ',
+                )) + ' />');
+            }
+
+            return ('<img src="' + url + '" data-origin="' + href + '" alt="' + text + '"' + attrs + '>');
+        });
+    };
+
+    var prism = createCommonjsModule(function (module) {
+        /* **********************************************
+       Begin prism-core.js
+  ********************************************** */
+
+        /// <reference lib="WebWorker"/>
+
+        var _self = (typeof window !== 'undefined')
+            ? window   // if in browser
+            : (
+                (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope)
+                    ? self // if in worker
+                    : {}   // if in node js
+            );
+
+        /**
+         * Prism: Lightweight, robust, elegant syntax highlighting
+         *
+         * @license MIT <https://opensource.org/licenses/MIT>
+         * @author Lea Verou <https://lea.verou.me>
+         * @namespace
+         * @public
+         */
+        var Prism = (function (_self) {
+
+            // Private helper vars
+            var lang = /\blang(?:uage)?-([\w-]+)\b/i;
+            var uniqueId = 0;
+
+
+            var _ = {
+                /**
+                 * By default, Prism will attempt to highlight all code elements (by calling {@link Prism.highlightAll}) on the
+                 * current page after the page finished loading. This might be a problem if e.g. you wanted to asynchronously load
+                 * additional languages or plugins yourself.
+                 *
+                 * By setting this value to `true`, Prism will not automatically highlight all code elements on the page.
+                 *
+                 * You obviously have to change this value before the automatic highlighting started. To do this, you can add an
+                 * empty Prism object into the global scope before loading the Prism script like this:
+                 *
+                 * ```js
+                 * window.Prism = window.Prism || {};
+                 * Prism.manual = true;
+                 * // add a new <script> to load Prism's script
+                 * ```
+                 *
+                 * @default false
+                 * @type {boolean}
+                 * @memberof Prism
+                 * @public
+                 */
+                manual: _self.Prism && _self.Prism.manual,
+                disableWorkerMessageHandler: _self.Prism && _self.Prism.disableWorkerMessageHandler,
+
+                /**
+                 * A namespace for utility methods.
+                 *
+                 * All function in this namespace that are not explicitly marked as _public_ are for __internal use only__ and may
+                 * change or disappear at any time.
+                 *
+                 * @namespace
+                 * @memberof Prism
+                 */
+                util: {
+                    encode: function encode(tokens) {
+                        if (tokens instanceof Token) {
+                            return new Token(tokens.type, encode(tokens.content), tokens.alias);
+                        } else if (Array.isArray(tokens)) {
+                            return tokens.map(encode);
+                        } else {
+                            return tokens.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/\u00a0/g, ' ');
+                        }
+                    },
+
+                    /**
+                     * Returns the name of the type of the given value.
+                     *
+                     * @param {any} o
+                     * @returns {string}
+                     * @example
+                     * type(null)      === 'Null'
+                     * type(undefined) === 'Undefined'
+                     * type(123)       === 'Number'
+                     * type('foo')     === 'String'
+                     * type(true)      === 'Boolean'
+                     * type([1, 2])    === 'Array'
+                     * type({})        === 'Object'
+                     * type(String)    === 'Function'
+                     * type(/abc+/)    === 'RegExp'
+                     */
+                    type: function (o) {
+                        return Object.prototype.toString.call(o).slice(8, -1);
+                    },
+
+                    /**
+                     * Returns a unique number for the given object. Later calls will still return the same number.
+                     *
+                     * @param {Object} obj
+                     * @returns {number}
+                     */
+                    objId: function (obj) {
+                        if (!obj['__id']) {
+                            Object.defineProperty(obj, '__id', { value: ++uniqueId });
+                        }
+                        return obj['__id'];
+                    },
+
+                    /**
+                     * Creates a deep clone of the given object.
+                     *
+                     * The main intended use of this function is to clone language definitions.
+                     *
+                     * @param {T} o
+                     * @param {Record<number, any>} [visited]
+                     * @returns {T}
+                     * @template T
+                     */
+                    clone: function deepClone(o, visited) {
+                        visited = visited || {};
+
+                        var clone, id;
+                        switch (_.util.type(o)) {
+                            case 'Object':
+                                id = _.util.objId(o);
+                                if (visited[id]) {
+                                    return visited[id];
+                                }
+                                clone = /** @type {Record<string, any>} */ ({});
+                                visited[id] = clone;
+
+                                for (var key in o) {
+                                    if (o.hasOwnProperty(key)) {
+                                        clone[key] = deepClone(o[key], visited);
+                                    }
+                                }
+
+                                return /** @type {any} */ (clone);
+
+                            case 'Array':
+                                id = _.util.objId(o);
+                                if (visited[id]) {
+                                    return visited[id];
+                                }
+                                clone = [];
+                                visited[id] = clone;
+
+                                (/** @type {Array} */(/** @type {any} */(o))).forEach(function (v, i) {
+                                    clone[i] = deepClone(v, visited);
+                                });
+
+                                return /** @type {any} */ (clone);
+
+                            default:
+                                return o;
+                        }
+                    },
+
+                    /**
+                     * Returns the Prism language of the given element set by a `language-xxxx` or `lang-xxxx` class.
+                     *
+                     * If no language is set for the element or the element is `null` or `undefined`, `none` will be returned.
+                     *
+                     * @param {Element} element
+                     * @returns {string}
+                     */
+                    getLanguage: function (element) {
+                        while (element && !lang.test(element.className)) {
+                            element = element.parentElement;
+                        }
+                        if (element) {
+                            return (element.className.match(lang) || [ , 'none' ])[1].toLowerCase();
+                        }
+                        return 'none';
+                    },
+
+                    /**
+                     * Returns the script element that is currently executing.
+                     *
+                     * This does __not__ work for line script element.
+                     *
+                     * @returns {HTMLScriptElement | null}
+                     */
+                    currentScript: function () {
+                        if (typeof document === 'undefined') {
+                            return null;
+                        }
+                        if ('currentScript' in document && 1 < 2 /* hack to trip TS' flow analysis */) {
+                            return /** @type {any} */ (document.currentScript);
+                        }
+
+                        // IE11 workaround
+                        // we'll get the src of the current script by parsing IE11's error stack trace
+                        // this will not work for inline scripts
+
+                        try {
+                            throw new Error();
+                        } catch (err) {
+                            // Get file src url from stack. Specifically works with the format of stack traces in IE.
+                            // A stack will look like this:
+                            //
+                            // Error
+                            //    at _.util.currentScript (http://localhost/components/prism-core.js:119:5)
+                            //    at Global code (http://localhost/components/prism-core.js:606:1)
+
+                            var src = (/at [^(\r\n]*\((.*):.+:.+\)$/i.exec(err.stack) || [])[1];
+                            if (src) {
+                                var scripts = document.getElementsByTagName('script');
+                                for (var i in scripts) {
+                                    if (scripts[i].src == src) {
+                                        return scripts[i];
+                                    }
+                                }
+                            }
+                            return null;
+                        }
+                    },
+
+                    /**
+                     * Returns whether a given class is active for `element`.
+                     *
+                     * The class can be activated if `element` or one of its ancestors has the given class and it can be deactivated
+                     * if `element` or one of its ancestors has the negated version of the given class. The _negated version_ of the
+                     * given class is just the given class with a `no-` prefix.
+                     *
+                     * Whether the class is active is determined by the closest ancestor of `element` (where `element` itself is
+                     * closest ancestor) that has the given class or the negated version of it. If neither `element` nor any of its
+                     * ancestors have the given class or the negated version of it, then the default activation will be returned.
+                     *
+                     * In the paradoxical situation where the closest ancestor contains __both__ the given class and the negated
+                     * version of it, the class is considered active.
+                     *
+                     * @param {Element} element
+                     * @param {string} className
+                     * @param {boolean} [defaultActivation=false]
+                     * @returns {boolean}
+                     */
+                    isActive: function (element, className, defaultActivation) {
+                        var no = 'no-' + className;
+
+                        while (element) {
+                            var classList = element.classList;
+                            if (classList.contains(className)) {
+                                return true;
+                            }
+                            if (classList.contains(no)) {
+                                return false;
+                            }
+                            element = element.parentElement;
+                        }
+                        return !!defaultActivation;
+                    },
+                },
+
+                /**
+                 * This namespace contains all currently loaded languages and the some helper functions to create and modify languages.
+                 *
+                 * @namespace
+                 * @memberof Prism
+                 * @public
+                 */
+                languages: {
+                    /**
+                     * Creates a deep copy of the language with the given id and appends the given tokens.
+                     *
+                     * If a token in `redef` also appears in the copied language, then the existing token in the copied language
+                     * will be overwritten at its original position.
+                     *
+                     * ## Best practices
+                     *
+                     * Since the position of overwriting tokens (token in `redef` that overwrite tokens in the copied language)
+                     * doesn't matter, they can technically be in any order. However, this can be confusing to others that trying to
+                     * understand the language definition because, normally, the order of tokens matters in Prism grammars.
+                     *
+                     * Therefore, it is encouraged to order overwriting tokens according to the positions of the overwritten tokens.
+                     * Furthermore, all non-overwriting tokens should be placed after the overwriting ones.
+                     *
+                     * @param {string} id The id of the language to extend. This has to be a key in `Prism.languages`.
+                     * @param {Grammar} redef The new tokens to append.
+                     * @returns {Grammar} The new language created.
+                     * @public
+                     * @example
+                     * Prism.languages['css-with-colors'] = Prism.languages.extend('css', {
+                     *     // Prism.languages.css already has a 'comment' token, so this token will overwrite CSS' 'comment' token
+                     *     // at its original position
+                     *     'comment': { ... },
+                     *     // CSS doesn't have a 'color' token, so this token will be appended
+                     *     'color': /\b(?:red|green|blue)\b/
+                     * });
+                     */
+                    extend: function (id, redef) {
+                        var lang = _.util.clone(_.languages[id]);
+
+                        for (var key in redef) {
+                            lang[key] = redef[key];
+                        }
+
+                        return lang;
+                    },
+
+                    /**
+                     * Inserts tokens _before_ another token in a language definition or any other grammar.
+                     *
+                     * ## Usage
+                     *
+                     * This helper method makes it easy to modify existing languages. For example, the CSS language definition
+                     * not only defines CSS highlighting for CSS documents, but also needs to define highlighting for CSS embedded
+                     * in HTML through `<style>` elements. To do this, it needs to modify `Prism.languages.markup` and add the
+                     * appropriate tokens. However, `Prism.languages.markup` is a regular JavaScript object literal, so if you do
+                     * this:
+                     *
+                     * ```js
+                     * Prism.languages.markup.style = {
+                     *     // token
+                     * };
+                     * ```
+                     *
+                     * then the `style` token will be added (and processed) at the end. `insertBefore` allows you to insert tokens
+                     * before existing tokens. For the CSS example above, you would use it like this:
+                     *
+                     * ```js
+                     * Prism.languages.insertBefore('markup', 'cdata', {
+                     *     'style': {
+                     *         // token
+                     *     }
+                     * });
+                     * ```
+                     *
+                     * ## Special cases
+                     *
+                     * If the grammars of `inside` and `insert` have tokens with the same name, the tokens in `inside`'s grammar
+                     * will be ignored.
+                     *
+                     * This behavior can be used to insert tokens after `before`:
+                     *
+                     * ```js
+                     * Prism.languages.insertBefore('markup', 'comment', {
+                     *     'comment': Prism.languages.markup.comment,
+                     *     // tokens after 'comment'
+                     * });
+                     * ```
+                     *
+                     * ## Limitations
+                     *
+                     * The main problem `insertBefore` has to solve is iteration order. Since ES2015, the iteration order for object
+                     * properties is guaranteed to be the insertion order (except for integer keys) but some browsers behave
+                     * differently when keys are deleted and re-inserted. So `insertBefore` can't be implemented by temporarily
+                     * deleting properties which is necessary to insert at arbitrary positions.
+                     *
+                     * To solve this problem, `insertBefore` doesn't actually insert the given tokens into the target object.
+                     * Instead, it will create a new object and replace all references to the target object with the new one. This
+                     * can be done without temporarily deleting properties, so the iteration order is well-defined.
+                     *
+                     * However, only references that can be reached from `Prism.languages` or `insert` will be replaced. I.e. if
+                     * you hold the target object in a variable, then the value of the variable will not change.
+                     *
+                     * ```js
+                     * var oldMarkup = Prism.languages.markup;
+                     * var newMarkup = Prism.languages.insertBefore('markup', 'comment', { ... });
+                     *
+                     * assert(oldMarkup !== Prism.languages.markup);
+                     * assert(newMarkup === Prism.languages.markup);
+                     * ```
+                     *
+                     * @param {string} inside The property of `root` (e.g. a language id in `Prism.languages`) that contains the
+                     * object to be modified.
+                     * @param {string} before The key to insert before.
+                     * @param {Grammar} insert An object containing the key-value pairs to be inserted.
+                     * @param {Object<string, any>} [root] The object containing `inside`, i.e. the object that contains the
+                     * object to be modified.
+                     *
+                     * Defaults to `Prism.languages`.
+                     * @returns {Grammar} The new grammar object.
+                     * @public
+                     */
+                    insertBefore: function (inside, before, insert, root) {
+                        root = root || /** @type {any} */ (_.languages);
+                        var grammar = root[inside];
+                        /** @type {Grammar} */
+                        var ret = {};
+
+                        for (var token in grammar) {
+                            if (grammar.hasOwnProperty(token)) {
+
+                                if (token == before) {
+                                    for (var newToken in insert) {
+                                        if (insert.hasOwnProperty(newToken)) {
+                                            ret[newToken] = insert[newToken];
+                                        }
+                                    }
+                                }
+
+                                // Do not insert token which also occur in insert. See #1525
+                                if (!insert.hasOwnProperty(token)) {
+                                    ret[token] = grammar[token];
+                                }
+                            }
+                        }
+
+                        var old = root[inside];
+                        root[inside] = ret;
+
+                        // Update references in other language definitions
+                        _.languages.DFS(_.languages, function (key, value) {
+                            if (value === old && key != inside) {
+                                this[key] = ret;
+                            }
+                        });
+
+                        return ret;
+                    },
+
+                    // Traverse a language definition with Depth First Search
+                    DFS: function DFS(o, callback, type, visited) {
+                        visited = visited || {};
+
+                        var objId = _.util.objId;
+
+                        for (var i in o) {
+                            if (o.hasOwnProperty(i)) {
+                                callback.call(o, i, o[i], type || i);
+
+                                var property = o[i],
+                                    propertyType = _.util.type(property);
+
+                                if (propertyType === 'Object' && !visited[objId(property)]) {
+                                    visited[objId(property)] = true;
+                                    DFS(property, callback, null, visited);
+                                } else if (propertyType === 'Array' && !visited[objId(property)]) {
+                                    visited[objId(property)] = true;
+                                    DFS(property, callback, i, visited);
+                                }
+                            }
+                        }
+                    },
+                },
+
+                plugins: {},
+
+                /**
+                 * This is the most high-level function in Prism’s API.
+                 * It fetches all the elements that have a `.language-xxxx` class and then calls {@link Prism.highlightElement} on
+                 * each one of them.
+                 *
+                 * This is equivalent to `Prism.highlightAllUnder(document, async, callback)`.
+                 *
+                 * @param {boolean} [async=false] Same as in {@link Prism.highlightAllUnder}.
+                 * @param {HighlightCallback} [callback] Same as in {@link Prism.highlightAllUnder}.
+                 * @memberof Prism
+                 * @public
+                 */
+                highlightAll: function (async, callback) {
+                    _.highlightAllUnder(document, async, callback);
+                },
+
+                /**
+                 * Fetches all the descendants of `container` that have a `.language-xxxx` class and then calls
+                 * {@link Prism.highlightElement} on each one of them.
+                 *
+                 * The following hooks will be run:
+                 * 1. `before-highlightall`
+                 * 2. `before-all-elements-highlight`
+                 * 3. All hooks of {@link Prism.highlightElement} for each element.
+                 *
+                 * @param {ParentNode} container The root element, whose descendants that have a `.language-xxxx` class will be highlighted.
+                 * @param {boolean} [async=false] Whether each element is to be highlighted asynchronously using Web Workers.
+                 * @param {HighlightCallback} [callback] An optional callback to be invoked on each element after its highlighting is done.
+                 * @memberof Prism
+                 * @public
+                 */
+                highlightAllUnder: function (container, async, callback) {
+                    var env = {
+                        callback: callback,
+                        container: container,
+                        selector: 'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code',
+                    };
+
+                    _.hooks.run('before-highlightall', env);
+
+                    env.elements = Array.prototype.slice.apply(env.container.querySelectorAll(env.selector));
+
+                    _.hooks.run('before-all-elements-highlight', env);
+
+                    for (var i = 0, element; element = env.elements[i++];) {
+                        _.highlightElement(element, async === true, env.callback);
+                    }
+                },
+
+                /**
+                 * Highlights the code inside a single element.
+                 *
+                 * The following hooks will be run:
+                 * 1. `before-sanity-check`
+                 * 2. `before-highlight`
+                 * 3. All hooks of {@link Prism.highlight}. These hooks will be run by an asynchronous worker if `async` is `true`.
+                 * 4. `before-insert`
+                 * 5. `after-highlight`
+                 * 6. `complete`
+                 *
+                 * Some the above hooks will be skipped if the element doesn't contain any text or there is no grammar loaded for
+                 * the element's language.
+                 *
+                 * @param {Element} element The element containing the code.
+                 * It must have a class of `language-xxxx` to be processed, where `xxxx` is a valid language identifier.
+                 * @param {boolean} [async=false] Whether the element is to be highlighted asynchronously using Web Workers
+                 * to improve performance and avoid blocking the UI when highlighting very large chunks of code. This option is
+                 * [disabled by default](https://prismjs.com/faq.html#why-is-asynchronous-highlighting-disabled-by-default).
+                 *
+                 * Note: All language definitions required to highlight the code must be included in the main `prism.js` file for
+                 * asynchronous highlighting to work. You can build your own bundle on the
+                 * [Download page](https://prismjs.com/download.html).
+                 * @param {HighlightCallback} [callback] An optional callback to be invoked after the highlighting is done.
+                 * Mostly useful when `async` is `true`, since in that case, the highlighting is done asynchronously.
+                 * @memberof Prism
+                 * @public
+                 */
+                highlightElement: function (element, async, callback) {
+                    // Find language
+                    var language = _.util.getLanguage(element);
+                    var grammar = _.languages[language];
+
+                    // Set language on the element, if not present
+                    element.className = element.className.replace(lang, '').replace(/\s+/g, ' ') + ' language-' + language;
+
+                    // Set language on the parent, for styling
+                    var parent = element.parentElement;
+                    if (parent && parent.nodeName.toLowerCase() === 'pre') {
+                        parent.className = parent.className.replace(lang, '').replace(/\s+/g, ' ') + ' language-' + language;
+                    }
+
+                    var code = element.textContent;
+
+                    var env = {
+                        element: element,
+                        language: language,
+                        grammar: grammar,
+                        code: code,
+                    };
+
+                    function insertHighlightedCode(highlightedCode) {
+                        env.highlightedCode = highlightedCode;
+
+                        _.hooks.run('before-insert', env);
+
+                        env.element.innerHTML = env.highlightedCode;
+
+                        _.hooks.run('after-highlight', env);
+                        _.hooks.run('complete', env);
+                        callback && callback.call(env.element);
+                    }
+
+                    _.hooks.run('before-sanity-check', env);
+
+                    if (!env.code) {
+                        _.hooks.run('complete', env);
+                        callback && callback.call(env.element);
+                        return;
+                    }
+
+                    _.hooks.run('before-highlight', env);
+
+                    if (!env.grammar) {
+                        insertHighlightedCode(_.util.encode(env.code));
+                        return;
+                    }
+
+                    if (async && _self.Worker) {
+                        var worker = new Worker(_.filename);
+
+                        worker.onmessage = function (evt) {
+                            insertHighlightedCode(evt.data);
+                        };
+
+                        worker.postMessage(JSON.stringify({
+                            language: env.language,
+                            code: env.code,
+                            immediateClose: true,
+                        }));
+                    } else {
+                        insertHighlightedCode(_.highlight(env.code, env.grammar, env.language));
+                    }
+                },
+
+                /**
+                 * Low-level function, only use if you know what you’re doing. It accepts a string of text as input
+                 * and the language definitions to use, and returns a string with the HTML produced.
+                 *
+                 * The following hooks will be run:
+                 * 1. `before-tokenize`
+                 * 2. `after-tokenize`
+                 * 3. `wrap`: On each {@link Token}.
+                 *
+                 * @param {string} text A string with the code to be highlighted.
+                 * @param {Grammar} grammar An object containing the tokens to use.
+                 *
+                 * Usually a language definition like `Prism.languages.markup`.
+                 * @param {string} language The name of the language definition passed to `grammar`.
+                 * @returns {string} The highlighted HTML.
+                 * @memberof Prism
+                 * @public
+                 * @example
+                 * Prism.highlight('var foo = true;', Prism.languages.javascript, 'javascript');
+                 */
+                highlight: function (text, grammar, language) {
+                    var env = {
+                        code: text,
+                        grammar: grammar,
+                        language: language,
+                    };
+                    _.hooks.run('before-tokenize', env);
+                    env.tokens = _.tokenize(env.code, env.grammar);
+                    _.hooks.run('after-tokenize', env);
+                    return Token.stringify(_.util.encode(env.tokens), env.language);
+                },
+
+                /**
+                 * This is the heart of Prism, and the most low-level function you can use. It accepts a string of text as input
+                 * and the language definitions to use, and returns an array with the tokenized code.
+                 *
+                 * When the language definition includes nested tokens, the function is called recursively on each of these tokens.
+                 *
+                 * This method could be useful in other contexts as well, as a very crude parser.
+                 *
+                 * @param {string} text A string with the code to be highlighted.
+                 * @param {Grammar} grammar An object containing the tokens to use.
+                 *
+                 * Usually a language definition like `Prism.languages.markup`.
+                 * @returns {TokenStream} An array of strings and tokens, a token stream.
+                 * @memberof Prism
+                 * @public
+                 * @example
+                 * let code = `var foo = 0;`;
+                 * let tokens = Prism.tokenize(code, Prism.languages.javascript);
+                 * tokens.forEach(token => {
+                 *     if (token instanceof Prism.Token && token.type === 'number') {
+                 *         console.log(`Found numeric literal: ${token.content}`);
+                 *     }
+                 * });
+                 */
+                tokenize: function (text, grammar) {
+                    var rest = grammar.rest;
+                    if (rest) {
+                        for (var token in rest) {
+                            grammar[token] = rest[token];
+                        }
+
+                        delete grammar.rest;
+                    }
+
+                    var tokenList = new LinkedList();
+                    addAfter(tokenList, tokenList.head, text);
+
+                    matchGrammar(text, tokenList, grammar, tokenList.head, 0);
+
+                    return toArray(tokenList);
+                },
+
+                /**
+                 * @namespace
+                 * @memberof Prism
+                 * @public
+                 */
+                hooks: {
+                    all: {},
+
+                    /**
+                     * Adds the given callback to the list of callbacks for the given hook.
+                     *
+                     * The callback will be invoked when the hook it is registered for is run.
+                     * Hooks are usually directly run by a highlight function but you can also run hooks yourself.
+                     *
+                     * One callback function can be registered to multiple hooks and the same hook multiple times.
+                     *
+                     * @param {string} name The name of the hook.
+                     * @param {HookCallback} callback The callback function which is given environment variables.
+                     * @public
+                     */
+                    add: function (name, callback) {
+                        var hooks = _.hooks.all;
+
+                        hooks[name] = hooks[name] || [];
+
+                        hooks[name].push(callback);
+                    },
+
+                    /**
+                     * Runs a hook invoking all registered callbacks with the given environment variables.
+                     *
+                     * Callbacks will be invoked synchronously and in the order in which they were registered.
+                     *
+                     * @param {string} name The name of the hook.
+                     * @param {Object<string, any>} env The environment variables of the hook passed to all callbacks registered.
+                     * @public
+                     */
+                    run: function (name, env) {
+                        var callbacks = _.hooks.all[name];
+
+                        if (!callbacks || !callbacks.length) {
+                            return;
+                        }
+
+                        for (var i = 0, callback; callback = callbacks[i++];) {
+                            callback(env);
+                        }
+                    },
+                },
+
+                Token: Token,
+            };
+            _self.Prism = _;
+
+
+            // Typescript note:
+            // The following can be used to import the Token type in JSDoc:
+            //
+            //   @typedef {InstanceType<import("./prism-core")["Token"]>} Token
+
+            /**
+             * Creates a new token.
+             *
+             * @param {string} type See {@link Token#type type}
+             * @param {string | TokenStream} content See {@link Token#content content}
+             * @param {string|string[]} [alias] The alias(es) of the token.
+             * @param {string} [matchedStr=""] A copy of the full string this token was created from.
+             * @class
+             * @global
+             * @public
+             */
+            function Token(type, content, alias, matchedStr) {
+                /**
+                 * The type of the token.
+                 *
+                 * This is usually the key of a pattern in a {@link Grammar}.
+                 *
+                 * @type {string}
+                 * @see GrammarToken
+                 * @public
+                 */
+                this.type = type;
+                /**
+                 * The strings or tokens contained by this token.
+                 *
+                 * This will be a token stream if the pattern matched also defined an `inside` grammar.
+                 *
+                 * @type {string | TokenStream}
+                 * @public
+                 */
+                this.content = content;
+                /**
+                 * The alias(es) of the token.
+                 *
+                 * @type {string|string[]}
+                 * @see GrammarToken
+                 * @public
+                 */
+                this.alias = alias;
+                // Copy of the full string this token was created from
+                this.length = (matchedStr || '').length | 0;
+            }
+
+            /**
+             * A token stream is an array of strings and {@link Token Token} objects.
+             *
+             * Token streams have to fulfill a few properties that are assumed by most functions (mostly internal ones) that process
+             * them.
+             *
+             * 1. No adjacent strings.
+             * 2. No empty strings.
+             *
+             *    The only exception here is the token stream that only contains the empty string and nothing else.
+             *
+             * @typedef {Array<string | Token>} TokenStream
+             * @global
+             * @public
+             */
+
+            /**
+             * Converts the given token or token stream to an HTML representation.
+             *
+             * The following hooks will be run:
+             * 1. `wrap`: On each {@link Token}.
+             *
+             * @param {string | Token | TokenStream} o The token or token stream to be converted.
+             * @param {string} language The name of current language.
+             * @returns {string} The HTML representation of the token or token stream.
+             * @memberof Token
+             * @static
+             */
+            Token.stringify = function stringify(o, language) {
+                if (typeof o == 'string') {
+                    return o;
+                }
+                if (Array.isArray(o)) {
+                    var s = '';
+                    o.forEach(function (e) {
+                        s += stringify(e, language);
+                    });
+                    return s;
+                }
+
+                var env = {
+                    type: o.type,
+                    content: stringify(o.content, language),
+                    tag: 'span',
+                    classes: [ 'token', o.type ],
+                    attributes: {},
+                    language: language,
+                };
+
+                var aliases = o.alias;
+                if (aliases) {
+                    if (Array.isArray(aliases)) {
+                        Array.prototype.push.apply(env.classes, aliases);
+                    } else {
+                        env.classes.push(aliases);
+                    }
+                }
+
+                _.hooks.run('wrap', env);
+
+                var attributes = '';
+                for (var name in env.attributes) {
+                    attributes += ' ' + name + '="' + (env.attributes[name] || '').replace(/"/g, '&quot;') + '"';
+                }
+
+                return '<' + env.tag + ' class="' + env.classes.join(' ') + '"' + attributes + '>' + env.content + '</' + env.tag + '>';
+            };
+
+            /**
+             * @param {RegExp} pattern
+             * @param {number} pos
+             * @param {string} text
+             * @param {boolean} lookbehind
+             * @returns {RegExpExecArray | null}
+             */
+            function matchPattern(pattern, pos, text, lookbehind) {
+                pattern.lastIndex = pos;
+                var match = pattern.exec(text);
+                if (match && lookbehind && match[1]) {
+                    // change the match to remove the text matched by the Prism lookbehind group
+                    var lookbehindLength = match[1].length;
+                    match.index += lookbehindLength;
+                    match[0] = match[0].slice(lookbehindLength);
+                }
+                return match;
+            }
+
+            /**
+             * @param {string} text
+             * @param {LinkedList<string | Token>} tokenList
+             * @param {any} grammar
+             * @param {LinkedListNode<string | Token>} startNode
+             * @param {number} startPos
+             * @param {RematchOptions} [rematch]
+             * @returns {void}
+             * @private
+             *
+             * @typedef RematchOptions
+             * @property {string} cause
+             * @property {number} reach
+             */
+            function matchGrammar(text, tokenList, grammar, startNode, startPos, rematch) {
+                for (var token in grammar) {
+                    if (!grammar.hasOwnProperty(token) || !grammar[token]) {
+                        continue;
+                    }
+
+                    var patterns = grammar[token];
+                    patterns = Array.isArray(patterns) ? patterns : [ patterns ];
+
+                    for (var j = 0; j < patterns.length; ++j) {
+                        if (rematch && rematch.cause == token + ',' + j) {
+                            return;
+                        }
+
+                        var patternObj = patterns[j],
+                            inside = patternObj.inside,
+                            lookbehind = !!patternObj.lookbehind,
+                            greedy = !!patternObj.greedy,
+                            alias = patternObj.alias;
+
+                        if (greedy && !patternObj.pattern.global) {
+                            // Without the global flag, lastIndex won't work
+                            var flags = patternObj.pattern.toString().match(/[imsuy]*$/)[0];
+                            patternObj.pattern = RegExp(patternObj.pattern.source, flags + 'g');
+                        }
+
+                        /** @type {RegExp} */
+                        var pattern = patternObj.pattern || patternObj;
+
+                        for ( // iterate the token list and keep track of the current token/string position
+                            var currentNode = startNode.next, pos = startPos;
+                            currentNode !== tokenList.tail;
+                            pos += currentNode.value.length, currentNode = currentNode.next
+                        ) {
+
+                            if (rematch && pos >= rematch.reach) {
+                                break;
+                            }
+
+                            var str = currentNode.value;
+
+                            if (tokenList.length > text.length) {
+                                // Something went terribly wrong, ABORT, ABORT!
+                                return;
+                            }
+
+                            if (str instanceof Token) {
+                                continue;
+                            }
+
+                            var removeCount = 1; // this is the to parameter of removeBetween
+                            var match;
+
+                            if (greedy) {
+                                match = matchPattern(pattern, pos, text, lookbehind);
+                                if (!match) {
+                                    break;
+                                }
+
+                                var from = match.index;
+                                var to = match.index + match[0].length;
+                                var p = pos;
+
+                                // find the node that contains the match
+                                p += currentNode.value.length;
+                                while (from >= p) {
+                                    currentNode = currentNode.next;
+                                    p += currentNode.value.length;
+                                }
+                                // adjust pos (and p)
+                                p -= currentNode.value.length;
+                                pos = p;
+
+                                // the current node is a Token, then the match starts inside another Token, which is invalid
+                                if (currentNode.value instanceof Token) {
+                                    continue;
+                                }
+
+                                // find the last node which is affected by this match
+                                for (
+                                    var k = currentNode;
+                                    k !== tokenList.tail && (p < to || typeof k.value === 'string');
+                                    k = k.next
+                                ) {
+                                    removeCount++;
+                                    p += k.value.length;
+                                }
+                                removeCount--;
+
+                                // replace with the new match
+                                str = text.slice(pos, p);
+                                match.index -= pos;
+                            } else {
+                                match = matchPattern(pattern, 0, str, lookbehind);
+                                if (!match) {
+                                    continue;
+                                }
+                            }
+
+                            var from = match.index,
+                                matchStr = match[0],
+                                before = str.slice(0, from),
+                                after = str.slice(from + matchStr.length);
+
+                            var reach = pos + str.length;
+                            if (rematch && reach > rematch.reach) {
+                                rematch.reach = reach;
+                            }
+
+                            var removeFrom = currentNode.prev;
+
+                            if (before) {
+                                removeFrom = addAfter(tokenList, removeFrom, before);
+                                pos += before.length;
+                            }
+
+                            removeRange(tokenList, removeFrom, removeCount);
+
+                            var wrapped = new Token(token, inside ? _.tokenize(matchStr, inside) : matchStr, alias, matchStr);
+                            currentNode = addAfter(tokenList, removeFrom, wrapped);
+
+                            if (after) {
+                                addAfter(tokenList, currentNode, after);
+                            }
+
+                            if (removeCount > 1) {
+                                // at least one Token object was removed, so we have to do some rematching
+                                // this can only happen if the current pattern is greedy
+                                matchGrammar(text, tokenList, grammar, currentNode.prev, pos, {
+                                    cause: token + ',' + j,
+                                    reach: reach,
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+
+            /**
+             * @typedef LinkedListNode
+             * @property {T} value
+             * @property {LinkedListNode<T> | null} prev The previous node.
+             * @property {LinkedListNode<T> | null} next The next node.
+             * @template T
+             * @private
+             */
+
+            /**
+             * @template T
+             * @private
+             */
+            function LinkedList() {
+                /** @type {LinkedListNode<T>} */
+                var head = { value: null, prev: null, next: null };
+                /** @type {LinkedListNode<T>} */
+                var tail = { value: null, prev: head, next: null };
+                head.next = tail;
+
+                /** @type {LinkedListNode<T>} */
+                this.head = head;
+                /** @type {LinkedListNode<T>} */
+                this.tail = tail;
+                this.length = 0;
+            }
+
+            /**
+             * Adds a new node with the given value to the list.
+             * @param {LinkedList<T>} list
+             * @param {LinkedListNode<T>} node
+             * @param {T} value
+             * @returns {LinkedListNode<T>} The added node.
+             * @template T
+             */
+            function addAfter(list, node, value) {
+                // assumes that node != list.tail && values.length >= 0
+                var next = node.next;
+
+                var newNode = { value: value, prev: node, next: next };
+                node.next = newNode;
+                next.prev = newNode;
+                list.length++;
+
+                return newNode;
+            }
+
+            /**
+             * Removes `count` nodes after the given node. The given node will not be removed.
+             * @param {LinkedList<T>} list
+             * @param {LinkedListNode<T>} node
+             * @param {number} count
+             * @template T
+             */
+            function removeRange(list, node, count) {
+                var next = node.next;
+                for (var i = 0; i < count && next !== list.tail; i++) {
+                    next = next.next;
+                }
+                node.next = next;
+                next.prev = node;
+                list.length -= i;
+            }
+
+            /**
+             * @param {LinkedList<T>} list
+             * @returns {T[]}
+             * @template T
+             */
+            function toArray(list) {
+                var array = [];
+                var node = list.head.next;
+                while (node !== list.tail) {
+                    array.push(node.value);
+                    node = node.next;
+                }
+                return array;
+            }
+
+
+            if (!_self.document) {
+                if (!_self.addEventListener) {
+                    // in Node.js
+                    return _;
+                }
+
+                if (!_.disableWorkerMessageHandler) {
+                    // In worker
+                    _self.addEventListener('message', function (evt) {
+                        var message = JSON.parse(evt.data),
+                            lang = message.language,
+                            code = message.code,
+                            immediateClose = message.immediateClose;
+
+                        _self.postMessage(_.highlight(code, _.languages[lang], lang));
+                        if (immediateClose) {
+                            _self.close();
+                        }
+                    }, false);
+                }
+
+                return _;
+            }
+
+            // Get current script and highlight
+            var script = _.util.currentScript();
+
+            if (script) {
+                _.filename = script.src;
+
+                if (script.hasAttribute('data-manual')) {
+                    _.manual = true;
+                }
+            }
+
+            function highlightAutomaticallyCallback() {
+                if (!_.manual) {
+                    _.highlightAll();
+                }
+            }
+
+            if (!_.manual) {
+                // If the document state is "loading", then we'll use DOMContentLoaded.
+                // If the document state is "interactive" and the prism.js script is deferred, then we'll also use the
+                // DOMContentLoaded event because there might be some plugins or languages which have also been deferred and they
+                // might take longer one animation frame to execute which can create a race condition where only some plugins have
+                // been loaded when Prism.highlightAll() is executed, depending on how fast resources are loaded.
+                // See https://github.com/PrismJS/prism/issues/2102
+                var readyState = document.readyState;
+                if (readyState === 'loading' || readyState === 'interactive' && script && script.defer) {
+                    document.addEventListener('DOMContentLoaded', highlightAutomaticallyCallback);
+                } else {
+                    if (window.requestAnimationFrame) {
+                        window.requestAnimationFrame(highlightAutomaticallyCallback);
+                    } else {
+                        window.setTimeout(highlightAutomaticallyCallback, 16);
+                    }
+                }
+            }
+
+            return _;
+
+        })(_self);
+
+        if (module.exports) {
+            module.exports = Prism;
+        }
+
+        // hack for components to work correctly in node.js
+        if (typeof commonjsGlobal !== 'undefined') {
+            commonjsGlobal.Prism = Prism;
+        }
+
+        // some additional documentation/types
+
+        /**
+         * The expansion of a simple `RegExp` literal to support additional properties.
+         *
+         * @typedef GrammarToken
+         * @property {RegExp} pattern The regular expression of the token.
+         * @property {boolean} [lookbehind=false] If `true`, then the first capturing group of `pattern` will (effectively)
+         * behave as a lookbehind group meaning that the captured text will not be part of the matched text of the new token.
+         * @property {boolean} [greedy=false] Whether the token is greedy.
+         * @property {string|string[]} [alias] An optional alias or list of aliases.
+         * @property {Grammar} [inside] The nested grammar of this token.
+         *
+         * The `inside` grammar will be used to tokenize the text value of each token of this kind.
+         *
+         * This can be used to make nested and even recursive language definitions.
+         *
+         * Note: This can cause infinite recursion. Be careful when you embed different languages or even the same language into
+         * each another.
+         * @global
+         * @public
+         */
+
+        /**
+         * @typedef Grammar
+         * @type {Object<string, RegExp | GrammarToken | Array<RegExp | GrammarToken>>}
+         * @property {Grammar} [rest] An optional grammar object that will be appended to this grammar.
+         * @global
+         * @public
+         */
+
+        /**
+         * A function which will invoked after an element was successfully highlighted.
+         *
+         * @callback HighlightCallback
+         * @param {Element} element The element successfully highlighted.
+         * @returns {void}
+         * @global
+         * @public
+         */
+
+        /**
+         * @callback HookCallback
+         * @param {Object<string, any>} env The environment variables of the hook.
+         * @returns {void}
+         * @global
+         * @public
+         */
+
+
+        /* **********************************************
+       Begin prism-markup.js
+  ********************************************** */
+
+        Prism.languages.markup = {
+            'comment': /<!--[\s\S]*?-->/,
+            'prolog': /<\?[\s\S]+?\?>/,
+            'doctype': {
+                // https://www.w3.org/TR/xml/#NT-doctypedecl
+                pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
+                greedy: true,
+                inside: {
+                    'internal-subset': {
+                        pattern: /(\[)[\s\S]+(?=\]>$)/,
+                        lookbehind: true,
+                        greedy: true,
+                        inside: null, // see below
+                    },
+                    'string': {
+                        pattern: /"[^"]*"|'[^']*'/,
+                        greedy: true,
+                    },
+                    'punctuation': /^<!|>$|[[\]]/,
+                    'doctype-tag': /^DOCTYPE/,
+                    'name': /[^\s<>'"]+/,
+                },
+            },
+            'cdata': /<!\[CDATA\[[\s\S]*?]]>/i,
+            'tag': {
+                pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
+                greedy: true,
+                inside: {
+                    'tag': {
+                        pattern: /^<\/?[^\s>\/]+/,
+                        inside: {
+                            'punctuation': /^<\/?/,
+                            'namespace': /^[^\s>\/:]+:/,
+                        },
+                    },
+                    'attr-value': {
+                        pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
+                        inside: {
+                            'punctuation': [
+                                {
+                                    pattern: /^=/,
+                                    alias: 'attr-equals',
+                                },
+                                /"|'/,
+                            ],
+                        },
+                    },
+                    'punctuation': /\/?>/,
+                    'attr-name': {
+                        pattern: /[^\s>\/]+/,
+                        inside: {
+                            'namespace': /^[^\s>\/:]+:/,
+                        },
+                    },
+
+                },
+            },
+            'entity': [
+                {
+                    pattern: /&[\da-z]{1,8};/i,
+                    alias: 'named-entity',
+                },
+                /&#x?[\da-f]{1,8};/i,
+            ],
+        };
+
+        Prism.languages.markup['tag'].inside['attr-value'].inside['entity'] =
+            Prism.languages.markup['entity'];
+        Prism.languages.markup['doctype'].inside['internal-subset'].inside = Prism.languages.markup;
+
+        // Plugin to make entity title show the real entity, idea by Roman Komarov
+        Prism.hooks.add('wrap', function (env) {
+
+            if (env.type === 'entity') {
+                env.attributes['title'] = env.content.replace(/&amp;/, '&');
+            }
+        });
+
+        Object.defineProperty(Prism.languages.markup.tag, 'addInlined', {
+            /**
+             * Adds an inlined language to markup.
+             *
+             * An example of an inlined language is CSS with `<style>` tags.
+             *
+             * @param {string} tagName The name of the tag that contains the inlined language. This name will be treated as
+             * case insensitive.
+             * @param {string} lang The language key.
+             * @example
+             * addInlined('style', 'css');
+             */
+            value: function addInlined(tagName, lang) {
+                var includedCdataInside = {};
+                includedCdataInside['language-' + lang] = {
+                    pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
+                    lookbehind: true,
+                    inside: Prism.languages[lang],
+                };
+                includedCdataInside['cdata'] = /^<!\[CDATA\[|\]\]>$/i;
+
+                var inside = {
+                    'included-cdata': {
+                        pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+                        inside: includedCdataInside,
+                    },
+                };
+                inside['language-' + lang] = {
+                    pattern: /[\s\S]+/,
+                    inside: Prism.languages[lang],
+                };
+
+                var def = {};
+                def[tagName] = {
+                    pattern: RegExp(/(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(/__/g, function () {
+                        return tagName;
+                    }), 'i'),
+                    lookbehind: true,
+                    greedy: true,
+                    inside: inside,
+                };
+
+                Prism.languages.insertBefore('markup', 'cdata', def);
+            },
+        });
+
+        Prism.languages.html = Prism.languages.markup;
+        Prism.languages.mathml = Prism.languages.markup;
+        Prism.languages.svg = Prism.languages.markup;
+
+        Prism.languages.xml = Prism.languages.extend('markup', {});
+        Prism.languages.ssml = Prism.languages.xml;
+        Prism.languages.atom = Prism.languages.xml;
+        Prism.languages.rss = Prism.languages.xml;
+
+
+        /* **********************************************
+       Begin prism-css.js
+  ********************************************** */
+
+        (function (Prism) {
+
+            var string = /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/;
+
+            Prism.languages.css = {
+                'comment': /\/\*[\s\S]*?\*\//,
+                'atrule': {
+                    pattern: /@[\w-](?:[^;{\s]|\s+(?![\s{]))*(?:;|(?=\s*\{))/,
+                    inside: {
+                        'rule': /^@[\w-]+/,
+                        'selector-function-argument': {
+                            pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,
+                            lookbehind: true,
+                            alias: 'selector',
+                        },
+                        'keyword': {
+                            pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
+                            lookbehind: true,
+                        },
+                        // See rest below
+                    },
+                },
+                'url': {
+                    // https://drafts.csswg.org/css-values-3/#urls
+                    pattern: RegExp('\\burl\\((?:' + string.source + '|' + /(?:[^\\\r\n()"']|\\[\s\S])*/.source + ')\\)', 'i'),
+                    greedy: true,
+                    inside: {
+                        'function': /^url/i,
+                        'punctuation': /^\(|\)$/,
+                        'string': {
+                            pattern: RegExp('^' + string.source + '$'),
+                            alias: 'url',
+                        },
+                    },
+                },
+                'selector': RegExp('[^{}\\s](?:[^{};"\'\\s]|\\s+(?![\\s{])|' + string.source + ')*(?=\\s*\\{)'),
+                'string': {
+                    pattern: string,
+                    greedy: true,
+                },
+                'property': /(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,
+                'important': /!important\b/i,
+                'function': /[-a-z0-9]+(?=\()/i,
+                'punctuation': /[(){};:,]/,
+            };
+
+            Prism.languages.css['atrule'].inside.rest = Prism.languages.css;
+
+            var markup = Prism.languages.markup;
+            if (markup) {
+                markup.tag.addInlined('style', 'css');
+
+                Prism.languages.insertBefore('inside', 'attr-value', {
+                    'style-attr': {
+                        pattern: /(^|["'\s])style\s*=\s*(?:"[^"]*"|'[^']*')/i,
+                        lookbehind: true,
+                        inside: {
+                            'attr-value': {
+                                pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
+                                inside: {
+                                    'style': {
+                                        pattern: /(["'])[\s\S]+(?=["']$)/,
+                                        lookbehind: true,
+                                        alias: 'language-css',
+                                        inside: Prism.languages.css,
+                                    },
+                                    'punctuation': [
+                                        {
+                                            pattern: /^=/,
+                                            alias: 'attr-equals',
+                                        },
+                                        /"|'/,
+                                    ],
+                                },
+                            },
+                            'attr-name': /^style/i,
+                        },
+                    },
+                }, markup.tag);
+            }
+
+        }(Prism));
+
+
+        /* **********************************************
+       Begin prism-clike.js
+  ********************************************** */
+
+        Prism.languages.clike = {
+            'comment': [
+                {
+                    pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+                    lookbehind: true,
+                    greedy: true,
+                },
+                {
+                    pattern: /(^|[^\\:])\/\/.*/,
+                    lookbehind: true,
+                    greedy: true,
+                },
+            ],
+            'string': {
+                pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+                greedy: true,
+            },
+            'class-name': {
+                pattern: /(\b(?:class|interface|extends|implements|trait|instanceof|new)\s+|\bcatch\s+\()[\w.\\]+/i,
+                lookbehind: true,
+                inside: {
+                    'punctuation': /[.\\]/,
+                },
+            },
+            'keyword': /\b(?:if|else|while|do|for|return|in|instanceof|function|new|try|throw|catch|finally|null|break|continue)\b/,
+            'boolean': /\b(?:true|false)\b/,
+            'function': /\w+(?=\()/,
+            'number': /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
+            'operator': /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/,
+            'punctuation': /[{}[\];(),.:]/,
+        };
+
+
+        /* **********************************************
+       Begin prism-javascript.js
+  ********************************************** */
+
+        Prism.languages.javascript = Prism.languages.badjs = Prism.languages.extend('clike', {
+            'class-name': [
+                Prism.languages.clike['class-name'],
+                {
+                    pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:prototype|constructor))/,
+                    lookbehind: true,
+                },
+            ],
+            'keyword': [
+                {
+                    pattern: /((?:^|})\s*)(?:catch|finally)\b/,
+                    lookbehind: true,
+                },
+                {
+                    pattern: /(^|[^.]|\.\.\.\s*)\b(?:as|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|for|from|function|(?:get|set)(?=\s*[\[$\w\xA0-\uFFFF])|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/,
+                    lookbehind: true,
+                } ],
+            // Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444)
+            'function': /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
+            'number': /\b(?:(?:0[xX](?:[\dA-Fa-f](?:_[\dA-Fa-f])?)+|0[bB](?:[01](?:_[01])?)+|0[oO](?:[0-7](?:_[0-7])?)+)n?|(?:\d(?:_\d)?)+n|NaN|Infinity)\b|(?:\b(?:\d(?:_\d)?)+\.?(?:\d(?:_\d)?)*|\B\.(?:\d(?:_\d)?)+)(?:[Ee][+-]?(?:\d(?:_\d)?)+)?/,
+            'operator': /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/,
+        });
+
+        Prism.languages.javascript['class-name'][0].pattern = /(\b(?:class|interface|extends|implements|instanceof|new)\s+)[\w.\\]+/;
+
+        Prism.languages.insertBefore('javascript', 'keyword', {
+            'regex': {
+                pattern: /((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)\/(?:\[(?:[^\]\\\r\n]|\\.)*]|\\.|[^/\\\[\r\n])+\/[gimyus]{0,6}(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/,
+                lookbehind: true,
+                greedy: true,
+                inside: {
+                    'regex-source': {
+                        pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
+                        lookbehind: true,
+                        alias: 'language-regex',
+                        inside: Prism.languages.regex,
+                    },
+                    'regex-flags': /[a-z]+$/,
+                    'regex-delimiter': /^\/|\/$/,
+                },
+            },
+            // This must be declared before keyword because we use "function" inside the look-forward
+            'function-variable': {
+                pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/,
+                alias: 'function',
+            },
+            'parameter': [
+                {
+                    pattern: /(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,
+                    lookbehind: true,
+                    inside: Prism.languages.javascript,
+                },
+                {
+                    pattern: /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
+                    inside: Prism.languages.javascript,
+                },
+                {
+                    pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
+                    lookbehind: true,
+                    inside: Prism.languages.javascript,
+                },
+                {
+                    pattern: /((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*)\(\s*|\]\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*\{)/,
+                    lookbehind: true,
+                    inside: Prism.languages.javascript,
+                },
+            ],
+            'constant': /\b[A-Z](?:[A-Z_]|\dx?)*\b/,
+        });
+
+        Prism.languages.insertBefore('javascript', 'string', {
+            'template-string': {
+                pattern: /`(?:\\[\s\S]|\${(?:[^{}]|{(?:[^{}]|{[^}]*})*})+}|(?!\${)[^\\`])*`/,
+                greedy: true,
+                inside: {
+                    'template-punctuation': {
+                        pattern: /^`|`$/,
+                        alias: 'string',
+                    },
+                    'interpolation': {
+                        pattern: /((?:^|[^\\])(?:\\{2})*)\${(?:[^{}]|{(?:[^{}]|{[^}]*})*})+}/,
+                        lookbehind: true,
+                        inside: {
+                            'interpolation-punctuation': {
+                                pattern: /^\${|}$/,
+                                alias: 'punctuation',
+                            },
+                            rest: Prism.languages.javascript,
+                        },
+                    },
+                    'string': /[\s\S]+/,
+                },
+            },
+        });
+
+        if (Prism.languages.markup) {
+            Prism.languages.markup.tag.addInlined('script', 'javascript');
+        }
+
+        Prism.languages.js = Prism.languages.javascript;
+        Prism.languages.e4x = Prism.languages.javascript;
+
+        // Java.
+
+        (function (Prism) {
+
+            var keywords = /\b(?:abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|exports|extends|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|module|native|new|non-sealed|null|open|opens|package|permits|private|protected|provides|public|record(?!\s*[(){}[\]<>=%~.:,;?+\-*/&|^])|requires|return|sealed|short|static|strictfp|super|switch|synchronized|this|throw|throws|to|transient|transitive|try|uses|var|void|volatile|while|with|yield)\b/;
+
+            // full package (optional) + parent classes (optional)
+            var classNamePrefix = /(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/.source;
+
+            // based on the java naming conventions
+            var className = {
+                pattern: RegExp(/(^|[^\w.])/.source + classNamePrefix + /[A-Z](?:[\d_A-Z]*[a-z]\w*)?\b/.source),
+                lookbehind: true,
+                inside: {
+                    'namespace': {
+                        pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/,
+                        inside: {
+                            'punctuation': /\./,
+                        },
+                    },
+                    'punctuation': /\./,
+                },
+            };
+
+            Prism.languages.java = Prism.languages.extend('clike', {
+                'string': {
+                    pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"/,
+                    lookbehind: true,
+                    greedy: true,
+                },
+                'class-name': [
+                    className,
+                    {
+                        // variables, parameters, and constructor references
+                        // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)
+                        pattern: RegExp(/(^|[^\w.])/.source + classNamePrefix + /[A-Z]\w*(?=\s+\w+\s*[;,=()]|\s*(?:\[[\s,]*\]\s*)?::\s*new\b)/.source),
+                        lookbehind: true,
+                        inside: className.inside,
+                    },
+                    {
+                        // class names based on keyword
+                        // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)
+                        pattern: RegExp(/(\b(?:class|enum|extends|implements|instanceof|interface|new|record|throws)\s+)/.source + classNamePrefix + /[A-Z]\w*\b/.source),
+                        lookbehind: true,
+                        inside: className.inside,
+                    },
+                ],
+                'keyword': keywords,
+                'function': [
+                    Prism.languages.clike.function,
+                    {
+                        pattern: /(::\s*)[a-z_]\w*/,
+                        lookbehind: true,
+                    },
+                ],
+                'number': /\b0b[01][01_]*L?\b|\b0x(?:\.[\da-f_p+-]+|[\da-f_]+(?:\.[\da-f_p+-]+)?)\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfl]?/i,
+                'operator': {
+                    pattern: /(^|[^.])(?:<<=?|>>>?=?|->|--|\+\+|&&|\|\||::|[?:~]|[-+*/%&|^!=<>]=?)/m,
+                    lookbehind: true,
+                },
+            });
+
+            Prism.languages.insertBefore('java', 'string', {
+                'triple-quoted-string': {
+                    // http://openjdk.java.net/jeps/355#Description
+                    pattern: /"""[ \t]*[\r\n](?:(?:"|"")?(?:\\.|[^"\\]))*"""/,
+                    greedy: true,
+                    alias: 'string',
+                },
+                'char': {
+                    pattern: /'(?:\\.|[^'\\\r\n]){1,6}'/,
+                    greedy: true,
+                },
+            });
+
+            Prism.languages.insertBefore('java', 'class-name', {
+                'annotation': {
+                    pattern: /(^|[^.])@\w+(?:\s*\.\s*\w+)*/,
+                    lookbehind: true,
+                    alias: 'punctuation',
+                },
+                'generics': {
+                    pattern: /<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&))*>)*>)*>)*>/,
+                    inside: {
+                        'class-name': className,
+                        'keyword': keywords,
+                        'punctuation': /[<>(),.:]/,
+                        'operator': /[?&|]/,
+                    },
+                },
+                'import': [
+                    {
+                        pattern: RegExp(/(\bimport\s+)/.source + classNamePrefix + /(?:[A-Z]\w*|\*)(?=\s*;)/.source),
+                        lookbehind: true,
+                        inside: {
+                            'namespace': className.inside.namespace,
+                            'punctuation': /\./,
+                            'operator': /\*/,
+                            'class-name': /\w+/,
+                        },
+                    },
+                    {
+                        pattern: RegExp(/(\bimport\s+static\s+)/.source + classNamePrefix + /(?:\w+|\*)(?=\s*;)/.source),
+                        lookbehind: true,
+                        alias: 'static',
+                        inside: {
+                            'namespace': className.inside.namespace,
+                            'static': /\b\w+$/,
+                            'punctuation': /\./,
+                            'operator': /\*/,
+                            'class-name': /\w+/,
+                        },
+                    },
+                ],
+                'namespace': {
+                    pattern: RegExp(
+                        /(\b(?:exports|import(?:\s+static)?|module|open|opens|package|provides|requires|to|transitive|uses|with)\s+)(?!<keyword>)[a-z]\w*(?:\.[a-z]\w*)*\.?/
+                            .source.replace(/<keyword>/g, function () {
+                            return keywords.source;
+                        })),
+                    lookbehind: true,
+                    inside: {
+                        'punctuation': /\./,
+                    },
+                },
+            });
+        }(Prism));
+
+        // Json.
+        // https://www.json.org/json-en.html
+
+        (function (Prism) {
+            Prism.languages.json = {
+                'property': {
+                    pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?=\s*:)/,
+                    lookbehind: true,
+                    greedy: true,
+                },
+                'string': {
+                    pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?!\s*:)/,
+                    lookbehind: true,
+                    greedy: true,
+                },
+                'comment': {
+                    pattern: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
+                    greedy: true,
+                },
+                'number': /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+                'punctuation': /[{}[\],]/,
+                'operator': /:/,
+                'boolean': /\b(?:false|true)\b/,
+                'null': {
+                    pattern: /\bnull\b/,
+                    alias: 'keyword',
+                },
+            };
+
+            Prism.languages.webmanifest = Prism.languages.json;
+        })(Prism);
+
+        // Kotlin.
+
+        (function (Prism) {
+            Prism.languages.kotlin = Prism.languages.extend('clike', {
+                'keyword': {
+                    // The lookbehind prevents wrong highlighting of e.g. kotlin.properties.get
+                    pattern: /(^|[^.])\b(?:abstract|actual|annotation|as|break|by|catch|class|companion|const|constructor|continue|crossinline|data|do|dynamic|else|enum|expect|external|final|finally|for|fun|get|if|import|in|infix|init|inline|inner|interface|internal|is|lateinit|noinline|null|object|open|operator|out|override|package|private|protected|public|reified|return|sealed|set|super|suspend|tailrec|this|throw|to|try|typealias|val|var|vararg|when|where|while)\b/,
+                    lookbehind: true
+                },
+                'function': [
+                    {
+                        pattern: /(?:`[^\r\n`]+`|\b\w+)(?=\s*\()/,
+                        greedy: true
+                    },
+                    {
+                        pattern: /(\.)(?:`[^\r\n`]+`|\w+)(?=\s*\{)/,
+                        lookbehind: true,
+                        greedy: true
+                    }
+                ],
+                'number': /\b(?:0[xX][\da-fA-F]+(?:_[\da-fA-F]+)*|0[bB][01]+(?:_[01]+)*|\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?(?:[eE][+-]?\d+(?:_\d+)*)?[fFL]?)\b/,
+                'operator': /\+[+=]?|-[-=>]?|==?=?|!(?:!|==?)?|[\/*%<>]=?|[?:]:?|\.\.|&&|\|\||\b(?:and|inv|or|shl|shr|ushr|xor)\b/
+            });
+
+            delete Prism.languages.kotlin['class-name'];
+
+            var interpolationInside = {
+                'interpolation-punctuation': {
+                    pattern: /^\$\{?|\}$/,
+                    alias: 'punctuation'
+                },
+                'expression': {
+                    pattern: /[\s\S]+/,
+                    inside: Prism.languages.kotlin
+                }
+            };
+
+            Prism.languages.insertBefore('kotlin', 'string', {
+                // https://kotlinlang.org/spec/expressions.html#string-interpolation-expressions
+                'string-literal': [
+                    {
+                        pattern: /"""(?:[^$]|\$(?:(?!\{)|\{[^{}]*\}))*?"""/,
+                        alias: 'multiline',
+                        inside: {
+                            'interpolation': {
+                                pattern: /\$(?:[a-z_]\w*|\{[^{}]*\})/i,
+                                inside: interpolationInside
+                            },
+                            'string': /[\s\S]+/
+                        }
+                    },
+                    {
+                        pattern: /"(?:[^"\\\r\n$]|\\.|\$(?:(?!\{)|\{[^{}]*\}))*"/,
+                        alias: 'singleline',
+                        inside: {
+                            'interpolation': {
+                                pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:[a-z_]\w*|\{[^{}]*\})/i,
+                                lookbehind: true,
+                                inside: interpolationInside
+                            },
+                            'string': /[\s\S]+/
+                        }
+                    }
+                ],
+                'char': {
+                    // https://kotlinlang.org/spec/expressions.html#character-literals
+                    pattern: /'(?:[^'\\\r\n]|\\(?:.|u[a-fA-F0-9]{0,4}))'/,
+                    greedy: true
+                }
+            });
+
+            delete Prism.languages.kotlin['string'];
+
+            Prism.languages.insertBefore('kotlin', 'keyword', {
+                'annotation': {
+                    pattern: /\B@(?:\w+:)?(?:[A-Z]\w*|\[[^\]]+\])/,
+                    alias: 'builtin'
+                }
+            });
+
+            Prism.languages.insertBefore('kotlin', 'function', {
+                'label': {
+                    pattern: /\b\w+@|@\w+\b/,
+                    alias: 'symbol'
+                }
+            });
+
+            Prism.languages.kt = Prism.languages.kotlin;
+            Prism.languages.kts = Prism.languages.kotlin;
+        }(Prism));
+
+        /* **********************************************
+       Begin prism-file-highlight.js
+  ********************************************** */
+
+        (function () {
+            if (typeof self === 'undefined' || !self.Prism || !self.document) {
+                return;
+            }
+
+            // https://developer.mozilla.org/en-US/docs/Web/API/Element/matches#Polyfill
+            if (!Element.prototype.matches) {
+                Element.prototype.matches = Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;
+            }
+
+            var Prism = window.Prism;
+
+            var LOADING_MESSAGE = 'Loading…';
+            var FAILURE_MESSAGE = function (status, message) {
+                return '✖ Error ' + status + ' while fetching file: ' + message;
+            };
+            var FAILURE_EMPTY_MESSAGE = '✖ Error: File does not exist or is empty';
+
+            var EXTENSIONS = {
+                'js': 'javascript',
+                'py': 'python',
+                'rb': 'ruby',
+                'ps1': 'powershell',
+                'psm1': 'powershell',
+                'sh': 'bash',
+                'bat': 'batch',
+                'h': 'c',
+                'tex': 'latex',
+            };
+
+            var STATUS_ATTR = 'data-src-status';
+            var STATUS_LOADING = 'loading';
+            var STATUS_LOADED = 'loaded';
+            var STATUS_FAILED = 'failed';
+
+            var SELECTOR = 'pre[data-src]:not([' + STATUS_ATTR + '="' + STATUS_LOADED + '"])'
+                + ':not([' + STATUS_ATTR + '="' + STATUS_LOADING + '"])';
+
+            var lang = /\blang(?:uage)?-([\w-]+)\b/i;
+
+            /**
+             * Sets the Prism `language-xxxx` or `lang-xxxx` class to the given language.
+             *
+             * @param {HTMLElement} element
+             * @param {string} language
+             * @returns {void}
+             */
+            function setLanguageClass(element, language) {
+                var className = element.className;
+                className = className.replace(lang, ' ') + ' language-' + language;
+                element.className = className.replace(/\s+/g, ' ').trim();
+            }
+
+
+            Prism.hooks.add('before-highlightall', function (env) {
+                env.selector += ', ' + SELECTOR;
+            });
+
+            Prism.hooks.add('before-sanity-check', function (env) {
+                var pre = /** @type {HTMLPreElement} */ (env.element);
+                if (pre.matches(SELECTOR)) {
+                    env.code = ''; // fast-path the whole thing and go to complete
+
+                    pre.setAttribute(STATUS_ATTR, STATUS_LOADING); // mark as loading
+
+                    // add code element with loading message
+                    var code = pre.appendChild(document.createElement('CODE'));
+                    code.textContent = LOADING_MESSAGE;
+
+                    var src = pre.getAttribute('data-src');
+
+                    var language = env.language;
+                    if (language === 'none') {
+                        // the language might be 'none' because there is no language set;
+                        // in this case, we want to use the extension as the language
+                        var extension = (/\.(\w+)$/.exec(src) || [ , 'none' ])[1];
+                        language = EXTENSIONS[extension] || extension;
+                    }
+
+                    // set language classes
+                    setLanguageClass(code, language);
+                    setLanguageClass(pre, language);
+
+                    // preload the language
+                    var autoloader = Prism.plugins.autoloader;
+                    if (autoloader) {
+                        autoloader.loadLanguages(language);
+                    }
+
+                    // load file
+                    var xhr = new XMLHttpRequest();
+                    xhr.open('GET', src, true);
+                    xhr.onreadystatechange = function () {
+                        if (xhr.readyState == 4) {
+                            if (xhr.status < 400 && xhr.responseText) {
+                                // mark as loaded
+                                pre.setAttribute(STATUS_ATTR, STATUS_LOADED);
+
+                                // highlight code
+                                code.textContent = xhr.responseText;
+                                Prism.highlightElement(code);
+
+                            } else {
+                                // mark as failed
+                                pre.setAttribute(STATUS_ATTR, STATUS_FAILED);
+
+                                if (xhr.status >= 400) {
+                                    code.textContent = FAILURE_MESSAGE(xhr.status, xhr.statusText);
+                                } else {
+                                    code.textContent = FAILURE_EMPTY_MESSAGE;
+                                }
+                            }
+                        }
+                    };
+                    xhr.send(null);
+                }
+            });
+
+            Prism.plugins.fileHighlight = {
+                /**
+                 * Executes the File Highlight plugin for all matching `pre` elements under the given container.
+                 *
+                 * Note: Elements which are already loaded or currently loading will not be touched by this method.
+                 *
+                 * @param {ParentNode} [container=document]
+                 */
+                highlight: function highlight(container) {
+                    var elements = (container || document).querySelectorAll(SELECTOR);
+
+                    for (var i = 0, element; element = elements[i++];) {
+                        Prism.highlightElement(element);
+                    }
+                },
+            };
+
+            var logged = false;
+            /** @deprecated Use `Prism.plugins.fileHighlight.highlight` instead. */
+            Prism.fileHighlight = function () {
+                if (!logged) {
+                    console.warn('Prism.fileHighlight is deprecated. Use `Prism.plugins.fileHighlight.highlight` instead.');
+                    logged = true;
+                }
+                Prism.plugins.fileHighlight.highlight.apply(this, arguments);
+            };
+
+        })();
+    });
+
+    (function (Prism) {
+
+        /**
+         * Returns the placeholder for the given language id and index.
+         *
+         * @param {string} language
+         * @param {string|number} index
+         * @returns {string}
+         */
+        function getPlaceholder(language, index) {
+            return '___' + language.toUpperCase() + index + '___';
+        }
+
+        Object.defineProperties(Prism.languages['markup-templating'] = {}, {
+            buildPlaceholders: {
+                /**
+                 * Tokenize all inline templating expressions matching `placeholderPattern`.
+                 *
+                 * If `replaceFilter` is provided, only matches of `placeholderPattern` for which `replaceFilter` returns
+                 * `true` will be replaced.
+                 *
+                 * @param {object} env The environment of the `before-tokenize` hook.
+                 * @param {string} language The language id.
+                 * @param {RegExp} placeholderPattern The matches of this pattern will be replaced by placeholders.
+                 * @param {(match: string) => boolean} [replaceFilter]
+                 */
+                value: function (env, language, placeholderPattern, replaceFilter) {
+                    if (env.language !== language) {
+                        return;
+                    }
+
+                    var tokenStack = env.tokenStack = [];
+
+                    env.code = env.code.replace(placeholderPattern, function (match) {
+                        if (typeof replaceFilter === 'function' && !replaceFilter(match)) {
+                            return match;
+                        }
+                        var i = tokenStack.length;
+                        var placeholder;
+
+                        // Check for existing strings
+                        while (env.code.indexOf(placeholder = getPlaceholder(language, i)) !== -1) {
+                            ++i;
+                        }
+
+                        // Create a sparse array
+                        tokenStack[i] = match;
+
+                        return placeholder;
+                    });
+
+                    // Switch the grammar to markup
+                    env.grammar = Prism.languages.markup;
+                },
+            },
+            tokenizePlaceholders: {
+                /**
+                 * Replace placeholders with proper tokens after tokenizing.
+                 *
+                 * @param {object} env The environment of the `after-tokenize` hook.
+                 * @param {string} language The language id.
+                 */
+                value: function (env, language) {
+                    if (env.language !== language || !env.tokenStack) {
+                        return;
+                    }
+
+                    // Switch the grammar back
+                    env.grammar = Prism.languages[language];
+
+                    var j = 0;
+                    var keys = Object.keys(env.tokenStack);
+
+                    function walkTokens(tokens) {
+                        for (var i = 0; i < tokens.length; i++) {
+                            // all placeholders are replaced already
+                            if (j >= keys.length) {
+                                break;
+                            }
+
+                            var token = tokens[i];
+                            if (typeof token === 'string' || (token.content && typeof token.content === 'string')) {
+                                var k = keys[j];
+                                var t = env.tokenStack[k];
+                                var s = typeof token === 'string' ? token : token.content;
+                                var placeholder = getPlaceholder(language, k);
+
+                                var index = s.indexOf(placeholder);
+                                if (index > -1) {
+                                    ++j;
+
+                                    var before = s.substring(0, index);
+                                    var middle = new Prism.Token(language, Prism.tokenize(t, env.grammar), 'language-' + language, t);
+                                    var after = s.substring(index + placeholder.length);
+
+                                    var replacement = [];
+                                    if (before) {
+                                        replacement.push.apply(replacement, walkTokens([ before ]));
+                                    }
+                                    replacement.push(middle);
+                                    if (after) {
+                                        replacement.push.apply(replacement, walkTokens([ after ]));
+                                    }
+
+                                    if (typeof token === 'string') {
+                                        tokens.splice.apply(tokens, [ i, 1 ].concat(replacement));
+                                    } else {
+                                        token.content = replacement;
+                                    }
+                                }
+                            } else if (token.content /* && typeof token.content !== 'string' */) {
+                                walkTokens(token.content);
+                            }
+                        }
+
+                        return tokens;
+                    }
+
+                    walkTokens(env.tokens);
+                },
+            },
+        });
+
+    }(Prism));
+
+    var highlightCodeCompiler = function (ref) {
+        var renderer = ref.renderer;
+
+        return (renderer.code = function (code, lang) {
+            if (lang === void 0) lang = 'markup';
+
+            var langOrMarkup = prism.languages[lang] || prism.languages.markup;
+            var text = prism.highlight(
+                code.replace(/@DOCSIFY_QM@/g, '`'),
+                langOrMarkup,
+                lang,
+            );
+
+            return ('<pre v-pre data-lang="' + lang + '"><code class="lang-' + lang + '">' + text + '</code></pre>');
+        });
+    };
+
+    var paragraphCompiler = function (ref) {
+        var renderer = ref.renderer;
+
+        return (renderer.paragraph = function (text) {
+            var result;
+            if (/^!&gt;/.test(text)) {
+                result = helper('tip', text);
+            } else if (/^\?&gt;/.test(text)) {
+                result = helper('warn', text);
+            } else {
+                result = '<p>' + text + '</p>';
+            }
+
+            return result;
+        });
+    };
+
+    var taskListCompiler = function (ref) {
+        var renderer = ref.renderer;
+
+        return (renderer.list = function (body, ordered, start) {
+            var isTaskList = /<li class="task-list-item">/.test(
+                body.split('class="task-list"')[0],
+            );
+            var isStartReq = start && start > 1;
+            var tag = ordered ? 'ol' : 'ul';
+            var tagAttrs = [
+                isTaskList ? 'class="task-list"' : '',
+                isStartReq ? ('start="' + start + '"') : '' ]
+                .join(' ')
+                .trim();
+
+            return ('<' + tag + ' ' + tagAttrs + '>' + body + '</' + tag + '>');
+        });
+    };
+
+    var taskListItemCompiler = function (ref) {
+        var renderer = ref.renderer;
+
+        return (renderer.listitem = function (text) {
+            var isTaskItem = /^(<input.*type="checkbox"[^>]*>)/.test(text);
+            var html = isTaskItem
+                ? ('<li class="task-list-item"><label>' + text + '</label></li>')
+                : ('<li>' + text + '</li>');
+
+            return html;
+        });
+    };
+
+    var linkCompiler = function (ref) {
+        var renderer = ref.renderer;
+        var router = ref.router;
+        var linkTarget = ref.linkTarget;
+        var linkRel = ref.linkRel;
+        var compilerClass = ref.compilerClass;
+
+        return (renderer.link = function (href, title, text) {
+            if (title === void 0) title = '';
+
+            var attrs = [];
+            var ref = getAndRemoveConfig(title);
+            var str = ref.str;
+            var config = ref.config;
+            linkTarget = config.target || linkTarget;
+            linkRel =
+                linkTarget === '_blank'
+                    ? compilerClass.config.externalLinkRel || 'noopener'
+                    : '';
+            title = str;
+
+            if (
+                !isAbsolutePath(href) &&
+                !compilerClass._matchNotCompileLink(href) &&
+                !config.ignore
+            ) {
+                if (href === compilerClass.config.homepage) {
+                    href = 'README';
+                }
+
+                href = router.toURL(href, null, router.getCurrentPath());
+            } else {
+                if (!isAbsolutePath(href) && href.slice(0, 2) === './') {
+                    href =
+                        document.URL.replace(/\/(?!.*\/).*/, '/').replace('#/./', '') + href;
+                }
+                attrs.push(href.indexOf('mailto:') === 0 ? '' : ('target="' + linkTarget + '"'));
+                attrs.push(
+                    href.indexOf('mailto:') === 0
+                        ? ''
+                        : linkRel !== ''
+                            ? (' rel="' + linkRel + '"')
+                            : '',
+                );
+            }
+
+            // special case to check crossorigin urls
+            if (
+                config.crossorgin &&
+                linkTarget === '_self' &&
+                compilerClass.config.routerMode === 'history'
+            ) {
+                if (compilerClass.config.crossOriginLinks.indexOf(href) === -1) {
+                    compilerClass.config.crossOriginLinks.push(href);
+                }
+            }
+
+            if (config.disabled) {
+                attrs.push('disabled');
+                href = 'javascript:void(0)';
+            }
+
+            if (config.class) {
+                attrs.push(('class="' + (config.class) + '"'));
+            }
+
+            if (config.id) {
+                attrs.push(('id="' + (config.id) + '"'));
+            }
+
+            if (title) {
+                attrs.push(('title="' + title + '"'));
+            }
+
+            return ('<a href="' + href + '" ' + (attrs.join(' ')) + '>' + text + '</a>');
+        });
+    };
+
+    var cachedLinks = {};
+
+    var compileMedia = {
+        markdown: function markdown(url) {
+            return {
+                url: url,
+            };
+        },
+        mermaid: function mermaid(url) {
+            return {
+                url: url,
+            };
+        },
+        iframe: function iframe(url, title) {
+            return {
+                html: ('<iframe src="' + url + '" ' + (title ||
+                    'width=100% height=400') + '></iframe>'),
+            };
+        },
+        video: function video(url, title) {
+            return {
+                html: ('<video src="' + url + '" ' + (title || 'controls') + '>Not Support</video>'),
+            };
+        },
+        audio: function audio(url, title) {
+            return {
+                html: ('<audio src="' + url + '" ' + (title || 'controls') + '>Not Support</audio>'),
+            };
+        },
+        code: function code(url, title) {
+            var lang = url.match(/\.(\w+)$/);
+
+            lang = title || (lang && lang[1]);
+            if (lang === 'md') {
+                lang = 'markdown';
+            }
+
+            return {
+                url: url,
+                lang: lang,
+            };
+        },
+    };
+
+    var Compiler = function Compiler(config, router) {
+        var this$1 = this;
+
+        this.config = config;
+        this.router = router;
+        this.cacheTree = {};
+        this.toc = [];
+        this.cacheTOC = {};
+        this.linkTarget = config.externalLinkTarget || '_blank';
+        this.linkRel =
+            this.linkTarget === '_blank' ? config.externalLinkRel || 'noopener' : '';
+        this.contentBase = router.getBasePath();
+
+        var renderer = this._initRenderer();
+        this.heading = renderer.heading;
+        var compile;
+        var mdConf = config.markdown || {};
+
+        if (isFn(mdConf)) {
+            compile = mdConf(marked_1, renderer);
+        } else {
+            marked_1.setOptions(
+                merge(mdConf, {
+                    renderer: merge(renderer, mdConf.renderer),
+                }),
+            );
+            compile = marked_1;
+        }
+
+        this._marked = compile;
+        this.compile = function (text) {
+            var isCached = true;
+            // eslint-disable-next-line no-unused-vars
+            var result = cached(function (_) {
+                isCached = false;
+                var html = '';
+
+                if (!text) {
+                    return text;
+                }
+
+                if (isPrimitive(text)) {
+                    html = compile(text);
+                } else {
+                    html = compile.parser(text);
+                }
+
+                html = config.noEmoji ? html : emojify(html);
+                slugify.clear();
+
+                return html;
+            })(text);
+
+            var curFileName = this$1.router.parse().file;
+
+            if (isCached) {
+                this$1.toc = this$1.cacheTOC[curFileName];
+            } else {
+                this$1.cacheTOC[curFileName] = [].concat(this$1.toc);
+            }
+
+            return result;
+        };
+    };
+
+    /**
+     * Pulls content from file and renders inline on the page as a embedded item.
+     *
+     * This allows you to embed different file types on the returned
+     * page.
+     * The basic format is:
+     * ```
+     * [filename](_media/example.md ':include')
+     * ```
+     *
+     * @param {string} href The href to the file to embed in the page.
+     * @param {string} titleTitle of the link used to make the embed.
+     *
+     * @return {type} Return value description.
+     */
+    Compiler.prototype.compileEmbed = function compileEmbed(href, title) {
+        var ref = getAndRemoveConfig(title);
+        var str = ref.str;
+        var config = ref.config;
+        var embed;
+        title = str;
+
+        if (config.include) {
+            if (!isAbsolutePath(href)) {
+                href = getPath(
+                    this.contentBase,
+                    getParentPath(this.router.getCurrentPath()),
+                    href,
+                );
+            }
+
+            var media;
+            if (config.type && (media = compileMedia[config.type])) {
+                embed = media.call(this, href, title);
+                embed.type = config.type;
+            } else {
+                var type = 'code';
+                if (/\.(md|markdown)/.test(href)) {
+                    type = 'markdown';
+                } else if (/\.mmd/.test(href)) {
+                    type = 'mermaid';
+                } else if (/\.html?/.test(href)) {
+                    type = 'iframe';
+                } else if (/\.(mp4|ogg)/.test(href)) {
+                    type = 'video';
+                } else if (/\.mp3/.test(href)) {
+                    type = 'audio';
+                }
+
+                embed = compileMedia[type].call(this, href, title);
+                embed.type = type;
+            }
+
+            embed.fragment = config.fragment;
+
+            return embed;
+        }
+    };
+
+    Compiler.prototype._matchNotCompileLink = function _matchNotCompileLink(link) {
+        var links = this.config.noCompileLinks || [];
+
+        for (var i = 0; i < links.length; i++) {
+            var n = links[i];
+            var re = cachedLinks[n] || (cachedLinks[n] = new RegExp(('^' + n + '$')));
+
+            if (re.test(link)) {
+                return link;
+            }
+        }
+    };
+
+    Compiler.prototype._initRenderer = function _initRenderer() {
+        var renderer = new marked_1.Renderer();
+        var ref = this;
+        var linkTarget = ref.linkTarget;
+        var linkRel = ref.linkRel;
+        var router = ref.router;
+        var contentBase = ref.contentBase;
+        var _self = this;
+        var origin = {};
+
+        /**
+         * Render anchor tag
+         * @link https://github.com/markedjs/marked#overriding-renderer-methods
+         * @param {String} text Text content
+         * @param {Number} level Type of heading (h<level> tag)
+         * @returns {String} Heading element
+         */
+        origin.heading = renderer.heading = function (text, level) {
+            var ref = getAndRemoveConfig(text);
+            var str = ref.str;
+            var config = ref.config;
+            var nextToc = { level: level, title: removeAtag(str) };
+
+            if (/<!-- {docsify-ignore} -->/g.test(str)) {
+                str = str.replace('<!-- {docsify-ignore} -->', '');
+                nextToc.title = removeAtag(str);
+                nextToc.ignoreSubHeading = true;
+            }
+
+            if (/{docsify-ignore}/g.test(str)) {
+                str = str.replace('{docsify-ignore}', '');
+                nextToc.title = removeAtag(str);
+                nextToc.ignoreSubHeading = true;
+            }
+
+            if (/<!-- {docsify-ignore-all} -->/g.test(str)) {
+                str = str.replace('<!-- {docsify-ignore-all} -->', '');
+                nextToc.title = removeAtag(str);
+                nextToc.ignoreAllSubs = true;
+            }
+
+            if (/{docsify-ignore-all}/g.test(str)) {
+                str = str.replace('{docsify-ignore-all}', '');
+                nextToc.title = removeAtag(str);
+                nextToc.ignoreAllSubs = true;
+            }
+
+            var slug = slugify(config.id || str);
+            var url = router.toURL(router.getCurrentPath(), { id: slug });
+            nextToc.slug = url;
+            _self.toc.push(nextToc);
+
+            return ('<h' + level + ' id="' + slug + '"><a href="' + url + '" data-id="' + slug + '" class="anchor"><span>' + str + '</span></a></h' + level + '>');
+        };
+
+        origin.code = highlightCodeCompiler({ renderer: renderer });
+        origin.link = linkCompiler({
+            renderer: renderer,
+            router: router,
+            linkTarget: linkTarget,
+            linkRel: linkRel,
+            compilerClass: _self,
+        });
+        origin.paragraph = paragraphCompiler({ renderer: renderer });
+        origin.image = imageCompiler({ renderer: renderer, contentBase: contentBase, router: router });
+        origin.list = taskListCompiler({ renderer: renderer });
+        origin.listitem = taskListItemCompiler({ renderer: renderer });
+
+        renderer.origin = origin;
+
+        return renderer;
+    };
+
+    /**
+     * Compile sidebar
+     * @param {String} text Text content
+     * @param {Number} level Type of heading (h<level> tag)
+     * @returns {String} Sidebar element
+     */
+    Compiler.prototype.sidebar = function sidebar(text, level) {
+        var ref = this;
+        var toc = ref.toc;
+        var currentPath = this.router.getCurrentPath();
+        var html = '';
+
+        if (text) {
+            html = this.compile(text);
+        } else {
+            for (var i = 0; i < toc.length; i++) {
+                if (toc[i].ignoreSubHeading) {
+                    var deletedHeaderLevel = toc[i].level;
+                    toc.splice(i, 1);
+                    // Remove headers who are under current header
+                    for (
+                        var j = i;
+                        j < toc.length && deletedHeaderLevel < toc[j].level;
+                        j++
+                    ) {
+                        toc.splice(j, 1) && j-- && i++;
+                    }
+
+                    i--;
+                }
+            }
+
+            var tree$1 = this.cacheTree[currentPath] || genTree(toc, level);
+            html = tree(tree$1, '<ul>{inner}</ul>');
+            this.cacheTree[currentPath] = tree$1;
+        }
+
+        return html;
+    };
+
+    /**
+     * Compile sub sidebar
+     * @param {Number} level Type of heading (h<level> tag)
+     * @returns {String} Sub-sidebar element
+     */
+    Compiler.prototype.subSidebar = function subSidebar(level) {
+        if (!level) {
+            this.toc = [];
+            return;
+        }
+
+        var currentPath = this.router.getCurrentPath();
+        var ref = this;
+        var cacheTree = ref.cacheTree;
+        var toc = ref.toc;
+
+        toc[0] && toc[0].ignoreAllSubs && toc.splice(0);
+        toc[0] && toc[0].level === 1 && toc.shift();
+
+        for (var i = 0; i < toc.length; i++) {
+            toc[i].ignoreSubHeading && toc.splice(i, 1) && i--;
+        }
+
+        var tree$1 = cacheTree[currentPath] || genTree(toc, level);
+
+        cacheTree[currentPath] = tree$1;
+        this.toc = [];
+        return tree(tree$1);
+    };
+
+    Compiler.prototype.header = function header(text, level) {
+        return this.heading(text, level);
+    };
+
+    Compiler.prototype.article = function article(text) {
+        return this.compile(text);
+    };
+
+    /**
+     * Compile cover page
+     * @param {Text} text Text content
+     * @returns {String} Cover page
+     */
+    Compiler.prototype.cover = function cover(text) {
+        var cacheToc = this.toc.slice();
+        var html = this.compile(text);
+
+        this.toc = cacheToc.slice();
+
+        return html;
+    };
+
+    var minIndent = function (string) {
+        var match = string.match(/^[ \t]*(?=\S)/gm);
+
+        if (!match) {
+            return 0;
+        }
+
+        return match.reduce(function (r, a) {
+            return Math.min(r, a.length);
+        }, Infinity);
+    };
+
+    var stripIndent = function (string) {
+        var indent = minIndent(string);
+
+        if (indent === 0) {
+            return string;
+        }
+
+        var regex = new RegExp(('^[ \\t]{' + indent + '}'), 'gm');
+
+        return string.replace(regex, '');
+    };
+
+    var cached$2 = {};
+
+    function walkFetchEmbed(ref, cb) {
+        var embedTokens = ref.embedTokens;
+        var compile = ref.compile;
+        var fetch = ref.fetch;
+
+        var token;
+        var step = 0;
+        var count = 1;
+
+        if (!embedTokens.length) {
+            return cb({});
+        }
+
+        while ((token = embedTokens[step++])) {
+            // eslint-disable-next-line no-shadow
+            var next = (function (token) {
+                return function (text) {
+                    var embedToken;
+                    if (text) {
+                        if (token.embed.type === 'markdown') {
+                            var path = token.embed.url.split('/');
+                            path.pop();
+                            path = path.join('/');
+                            // Resolves relative links to absolute
+                            text = text.replace(/\[([^[\]]+)\]\(([^)]+)\)/g, function (x) {
+                                var linkBeginIndex = x.indexOf('(');
+                                if (x.slice(linkBeginIndex, linkBeginIndex + 2) === '(.') {
+                                    return (
+                                        x.substring(0, linkBeginIndex) +
+                                        '(' + (window.location.protocol) + '//' + (window.location.host) + path + '/' +
+                                        x.substring(linkBeginIndex + 1, x.length - 1) +
+                                        ')'
+                                    );
+                                }
+                                return x;
+                            });
+
+                            // This may contain YAML front matter and will need to be stripped.
+                            var frontMatterInstalled =
+                                ($docsify.frontMatter || {}).installed || false;
+                            if (frontMatterInstalled === true) {
+                                text = $docsify.frontMatter.parseMarkdown(text);
+                            }
+
+                            embedToken = compile.lexer(text);
+                        } else if (token.embed.type === 'code') {
+                            if (token.embed.fragment) {
+                                var fragment = token.embed.fragment;
+                                var pattern = new RegExp(
+                                    ('(?:###|\\/\\/\\/)\\s*\\[' + fragment + '\\]([\\s\\S]*)(?:###|\\/\\/\\/)\\s*\\[' + fragment + '\\]'),
+                                );
+                                text = stripIndent((text.match(pattern) || [])[1] || '').trim();
+                            }
+
+                            embedToken = compile.lexer(
+                                '```' +
+                                token.embed.lang +
+                                '\n' +
+                                text.replace(/`/g, '@DOCSIFY_QM@') +
+                                '\n```\n',
+                            );
+                        } else if (token.embed.type === 'mermaid') {
+                            embedToken = [
+                                { type: 'html', text: ('<div class="mermaid">\n' + text + '\n</div>') } ];
+                            embedToken.links = {};
+                        } else {
+                            embedToken = [ { type: 'html', text: text } ];
+                            embedToken.links = {};
+                        }
+                    }
+
+                    cb({ token: token, embedToken: embedToken });
+                    if (++count >= step) {
+                        cb({});
+                    }
+                };
+            })(token);
+
+            if (token.embed.url) {
+                {
+                    get(token.embed.url).then(next);
+                }
+            } else {
+                next(token.embed.html);
+            }
+        }
+    }
+
+    function prerenderEmbed(ref, done) {
+        var compiler = ref.compiler;
+        var raw = ref.raw;
+        if (raw === void 0) raw = '';
+        var fetch = ref.fetch;
+
+        var hit = cached$2[raw];
+        if (hit) {
+            var copy = hit.slice();
+            copy.links = hit.links;
+            return done(copy);
+        }
+
+        var compile = compiler._marked;
+        var tokens = compile.lexer(raw);
+        var embedTokens = [];
+        var linkRE = compile.Lexer.rules.inline.link;
+        var links = tokens.links;
+
+        tokens.forEach(function (token, index) {
+            if (token.type === 'paragraph') {
+                token.text = token.text.replace(
+                    new RegExp(linkRE.source, 'g'),
+                    function (src, filename, href, title) {
+                        var embed = compiler.compileEmbed(href, title);
+
+                        if (embed) {
+                            embedTokens.push({
+                                index: index,
+                                embed: embed,
+                            });
+                        }
+
+                        return src;
+                    },
+                );
+            }
+        });
+
+        // keep track of which tokens have been embedded so far
+        // so that we know where to insert the embedded tokens as they
+        // are returned
+        var moves = [];
+        walkFetchEmbed({ compile: compile, embedTokens: embedTokens, fetch: fetch }, function (ref) {
+            var embedToken = ref.embedToken;
+            var token = ref.token;
+
+            if (token) {
+                // iterate through the array of previously inserted tokens
+                // to determine where the current embedded tokens should be inserted
+                var index = token.index;
+                moves.forEach(function (pos) {
+                    if (index > pos.start) {
+                        index += pos.length;
+                    }
+                });
+
+                merge(links, embedToken.links);
+
+                tokens = tokens
+                    .slice(0, index)
+                    .concat(embedToken, tokens.slice(index + 1));
+                moves.push({ start: index, length: embedToken.length - 1 });
+            } else {
+                cached$2[raw] = tokens.concat();
+                tokens.links = cached$2[raw].links = links;
+                done(tokens);
+            }
+        });
+    }
+
+    /* eslint-disable no-unused-vars */
+
+    var vueGlobalData;
+
+    function executeScript() {
+        var script = findAll('.markdown-section>script')
+            .filter(function (s) {
+                return !/template/.test(s.type);
+            })[0];
+        if (!script) {
+            return false;
+        }
+
+        var code = script.innerText.trim();
+        if (!code) {
+            return false;
+        }
+
+        new Function(code)();
+    }
+
+    function formatUpdated(html, updated, fn) {
+        updated =
+            typeof fn === 'function'
+                ? fn(updated)
+                : typeof fn === 'string'
+                    ? tinydate(fn)(new Date(updated))
+                    : updated;
+
+        return html.replace(/{docsify-updated}/g, updated);
+    }
+
+    function renderMain(html) {
+        var docsifyConfig = this.config;
+        var markdownElm = find('.markdown-section');
+        var vueVersion =
+            'Vue' in window &&
+            window.Vue.version &&
+            Number(window.Vue.version.charAt(0));
+
+        var isMountedVue = function (elm) {
+            var isVue2 = Boolean(elm.__vue__ && elm.__vue__._isVue);
+            var isVue3 = Boolean(elm._vnode && elm._vnode.__v_skip);
+
+            return isVue2 || isVue3;
+        };
+
+        if (!html) {
+            html = '<h1>404 - Not found</h1>';
+        }
+
+        if ('Vue' in window) {
+            var mountedElms = findAll('.markdown-section > *')
+                .filter(function (elm) {
+                    return isMountedVue(elm);
+                });
+
+            // Destroy/unmount existing Vue instances
+            for (var i = 0, list = mountedElms; i < list.length; i += 1) {
+                var mountedElm = list[i];
+
+                if (vueVersion === 2) {
+                    mountedElm.__vue__.$destroy();
+                } else if (vueVersion === 3) {
+                    mountedElm.__vue_app__.unmount();
+                }
+            }
+        }
+
+        this._renderTo(markdownElm, html);
+
+        // Render sidebar with the TOC
+        !docsifyConfig.loadSidebar && this._renderSidebar();
+
+        // Execute markdown <script>
+        if (
+            docsifyConfig.executeScript ||
+            ('Vue' in window && docsifyConfig.executeScript !== false)
+        ) {
+            executeScript();
+        }
+
+        // Handle Vue content not mounted by markdown <script>
+        if ('Vue' in window) {
+            var vueMountData = [];
+            var vueComponentNames = Object.keys(docsifyConfig.vueComponents || {});
+
+            // Register global vueComponents
+            if (vueVersion === 2 && vueComponentNames.length) {
+                vueComponentNames.forEach(function (name) {
+                    var isNotRegistered = !window.Vue.options.components[name];
+
+                    if (isNotRegistered) {
+                        window.Vue.component(name, docsifyConfig.vueComponents[name]);
+                    }
+                });
+            }
+
+            // Store global data() return value as shared data object
+            if (
+                !vueGlobalData &&
+                docsifyConfig.vueGlobalOptions &&
+                typeof docsifyConfig.vueGlobalOptions.data === 'function'
+            ) {
+                vueGlobalData = docsifyConfig.vueGlobalOptions.data();
+            }
+
+            // vueMounts
+            vueMountData.push.apply(
+                vueMountData, Object.keys(docsifyConfig.vueMounts || {})
+                    .map(function (cssSelector) {
+                        return [
+                            find(markdownElm, cssSelector),
+                            docsifyConfig.vueMounts[cssSelector] ];
+                    })
+                    .filter(function (ref) {
+                        var elm = ref[0];
+                        var vueConfig = ref[1];
+
+                        return elm;
+                    }),
+            );
+
+            // Template syntax, vueComponents, vueGlobalOptions
+            if (docsifyConfig.vueGlobalOptions || vueComponentNames.length) {
+                var reHasBraces = /{{2}[^{}]*}{2}/;
+                // Matches Vue full and shorthand syntax as attributes in HTML tags.
+                //
+                // Full syntax examples:
+                // v-foo, v-foo[bar], v-foo-bar, v-foo:bar-baz.prop
+                //
+                // Shorthand syntax examples:
+                // @foo, @foo.bar, @foo.bar.baz, @[foo], :foo, :[foo]
+                //
+                // Markup examples:
+                // <div v-html>{{ html }}</div>
+                // <div v-text="msg"></div>
+                // <div v-bind:text-content.prop="text">
+                // <button v-on:click="doThis"></button>
+                // <button v-on:click.once="doThis"></button>
+                // <button v-on:[event]="doThis"></button>
+                // <button @click.stop.prevent="doThis">
+                // <a :href="url">
+                // <a :[key]="url">
+                var reHasDirective = /<[^>/]+\s([@:]|v-)[\w-:.[\]]+[=>\s]/;
+
+                vueMountData.push.apply(
+                    vueMountData, findAll('.markdown-section > *')
+                        // Remove duplicates
+                        .filter(function (elm) {
+                            return !vueMountData.some(function (ref) {
+                                var e = ref[0];
+                                var c = ref[1];
+
+                                return e === elm;
+                            });
+                        })
+                        // Detect Vue content
+                        .filter(function (elm) {
+                            var isVueMount =
+                                // is a component
+                                elm.tagName.toLowerCase() in
+                                (docsifyConfig.vueComponents || {}) ||
+                                // has a component(s)
+                                elm.querySelector(vueComponentNames.join(',') || null) ||
+                                // has curly braces
+                                reHasBraces.test(elm.outerHTML) ||
+                                // has content directive
+                                reHasDirective.test(elm.outerHTML);
+
+                            return isVueMount;
+                        })
+                        .map(function (elm) {
+                            // Clone global configuration
+                            var vueConfig = merge({}, docsifyConfig.vueGlobalOptions || {});
+
+                            // Replace vueGlobalOptions data() return value with shared data object.
+                            // This provides a global store for all Vue instances that receive
+                            // vueGlobalOptions as their configuration.
+                            if (vueGlobalData) {
+                                vueConfig.data = function () {
+                                    return vueGlobalData;
+                                };
+                            }
+
+                            return [ elm, vueConfig ];
+                        }),
+                );
+            }
+
+            // Mount
+            for (var i$1 = 0, list$1 = vueMountData; i$1 < list$1.length; i$1 += 1) {
+                var ref = list$1[i$1];
+                var mountElm = ref[0];
+                var vueConfig = ref[1];
+
+                var isVueAttr = 'data-isvue';
+                var isSkipElm =
+                    // Is an invalid tag
+                    mountElm.matches('pre, script') ||
+                    // Is a mounted instance
+                    isMountedVue(mountElm) ||
+                    // Has mounted instance(s)
+                    mountElm.querySelector(('[' + isVueAttr + ']'));
+
+                if (!isSkipElm) {
+                    mountElm.setAttribute(isVueAttr, '');
+
+                    if (vueVersion === 2) {
+                        vueConfig.el = undefined;
+                        new window.Vue(vueConfig).$mount(mountElm);
+                    } else if (vueVersion === 3) {
+                        var app = window.Vue.createApp(vueConfig);
+
+                        // Register global vueComponents
+                        vueComponentNames.forEach(function (name) {
+                            var config = docsifyConfig.vueComponents[name];
+
+                            app.component(name, config);
+                        });
+
+                        app.mount(mountElm);
+                    }
+                }
+            }
+        }
+    }
+
+    function renderNameLink(vm) {
+        var el = getNode('.app-name-link');
+        var nameLink = vm.config.nameLink;
+        var path = vm.route.path;
+
+        if (!el) {
+            return;
+        }
+
+        if (isPrimitive(vm.config.nameLink)) {
+            el.setAttribute('href', nameLink);
+        } else if (typeof nameLink === 'object') {
+            var match = Object.keys(nameLink).filter(
+                function (key) {
+                    return path.indexOf(key) > -1;
+                },
+            )[0];
+
+            el.setAttribute('href', nameLink[match]);
+        }
+    }
+
+    /** @typedef {import('../Docsify').Constructor} Constructor */
+
+    /**
+     * @template {!Constructor} T
+     * @param {T} Base - The class to extend
+     */
+    function Render(Base) {
+        return /*@__PURE__*/(function (Base) {
+            function Render() {
+                Base.apply(this, arguments);
+            }
+
+            if (Base) Render.__proto__ = Base;
+            Render.prototype = Object.create(Base && Base.prototype);
+            Render.prototype.constructor = Render;
+
+            Render.prototype._renderTo = function _renderTo(el, content, replace) {
+                var node = getNode(el);
+                if (node) {
+                    node[replace ? 'outerHTML' : 'innerHTML'] = content;
+                }
+            };
+
+            Render.prototype._renderSidebar = function _renderSidebar(text) {
+                var ref = this.config;
+                var maxLevel = ref.maxLevel;
+                var subMaxLevel = ref.subMaxLevel;
+                var loadSidebar = ref.loadSidebar;
+                var hideSidebar = ref.hideSidebar;
+
+                if (hideSidebar) {
+                    // FIXME : better styling solution
+                    [
+                        document.querySelector('aside.sidebar'),
+                        document.querySelector('button.sidebar-toggle') ].forEach(function (node) {
+                        return node.parentNode.removeChild(node);
+                    });
+                    document.querySelector('section.content').style.right = 'unset';
+                    document.querySelector('section.content').style.left = 'unset';
+                    document.querySelector('section.content').style.position = 'relative';
+                    document.querySelector('section.content').style.width = '100%';
+                    return null;
+                }
+
+                this._renderTo('.sidebar-nav', this.compiler.sidebar(text, maxLevel));
+                var activeEl = getAndActive(this.router, '.sidebar-nav', true, true);
+                if (loadSidebar && activeEl) {
+                    activeEl.parentNode.innerHTML +=
+                        this.compiler.subSidebar(subMaxLevel) || '';
+                } else {
+                    // Reset toc
+                    this.compiler.subSidebar();
+                }
+
+                // Bind event
+                this._bindEventOnRendered(activeEl);
+            };
+
+            Render.prototype._bindEventOnRendered = function _bindEventOnRendered(activeEl) {
+                var ref = this.config;
+                var autoHeader = ref.autoHeader;
+
+                scrollActiveSidebar(this.router);
+
+                if (autoHeader && activeEl) {
+                    var main = getNode('#main');
+                    var firstNode = main.children[0];
+                    if (firstNode && firstNode.tagName !== 'H1') {
+                        var h1 = this.compiler.header(activeEl.innerText, 1);
+                        var wrapper = create('div', h1);
+                        before(main, wrapper.children[0]);
+                    }
+                }
+            };
+
+            Render.prototype._renderNav = function _renderNav(text) {
+                text && this._renderTo('nav', this.compiler.compile(text));
+                if (this.config.loadNavbar) {
+                    getAndActive(this.router, 'nav');
+                }
+            };
+
+            Render.prototype._renderMain = function _renderMain(text, opt, next) {
+                var this$1 = this;
+                if (opt === void 0) opt = {};
+
+                if (!text) {
+                    return renderMain.call(this, text);
+                }
+
+                this.callHook('beforeEach', text, function (result) {
+                    var html;
+                    var callback = function () {
+                        if (opt.updatedAt) {
+                            html = formatUpdated(
+                                html,
+                                opt.updatedAt,
+                                this$1.config.formatUpdated,
+                            );
+                        }
+
+                        this$1.callHook('afterEach', html, function (hookData) {
+                                return renderMain.call(this$1, hookData);
+                            },
+                        );
+                    };
+
+                    if (this$1.isHTML) {
+                        html = this$1.result = text;
+                        callback();
+                        next();
+                    } else {
+                        prerenderEmbed(
+                            {
+                                compiler: this$1.compiler,
+                                raw: result,
+                            },
+                            function (tokens) {
+                                html = this$1.compiler.compile(tokens);
+                                html = this$1.isRemoteUrl
+                                    ? purify.sanitize(html, { ADD_TAGS: [ 'script' ] })
+                                    : html;
+                                callback();
+                                next();
+                            },
+                        );
+                    }
+                });
+            };
+
+            Render.prototype._renderCover = function _renderCover(text, coverOnly) {
+                var el = getNode('.cover');
+
+                toggleClass(
+                    getNode('main'),
+                    coverOnly ? 'add' : 'remove',
+                    'hidden',
+                );
+                if (!text) {
+                    toggleClass(el, 'remove', 'show');
+                    return;
+                }
+
+                toggleClass(el, 'add', 'show');
+
+                var html = this.coverIsHTML ? text : this.compiler.cover(text);
+
+                var m = html
+                    .trim()
+                    .match('<p><img.*?data-origin="(.*?)"[^a]+alt="(.*?)">([^<]*?)</p>$');
+
+                if (m) {
+                    if (m[2] === 'color') {
+                        el.style.background = m[1] + (m[3] || '');
+                    } else {
+                        var path = m[1];
+
+                        toggleClass(el, 'add', 'has-mask');
+                        if (!isAbsolutePath(m[1])) {
+                            path = getPath(this.router.getBasePath(), m[1]);
+                        }
+
+                        el.style.backgroundImage = 'url(' + path + ')';
+                        el.style.backgroundSize = 'cover';
+                        el.style.backgroundPosition = 'center center';
+                    }
+
+                    html = html.replace(m[0], '');
+                }
+
+                this._renderTo('.cover-main', html);
+                sticky();
+            };
+
+            Render.prototype._updateRender = function _updateRender() {
+                // Render name link
+                renderNameLink(this);
+            };
+
+            Render.prototype.initRender = function initRender() {
+                var config = this.config;
+
+                // Init markdown compiler
+                this.compiler = new Compiler(config, this.router);
+                {
+                    /* eslint-disable-next-line camelcase */
+                    window.__current_docsify_compiler__ = this.compiler;
+                }
+
+                var id = config.el || '#app';
+                var navEl = find('nav') || create('nav');
+
+                var el = find(id);
+                var html = '';
+                var navAppendToTarget = body;
+
+                if (el) {
+                    if (config.repo) {
+                        html += corner(config.repo, config.cornerExternalLinkTarge);
+                    }
+
+                    if (config.coverpage) {
+                        html += cover();
+                    }
+
+                    if (config.logo) {
+                        var isBase64 = /^data:image/.test(config.logo);
+                        var isExternal = /(?:http[s]?:)?\/\//.test(config.logo);
+                        var isRelative = /^\./.test(config.logo);
+
+                        if (!isBase64 && !isExternal && !isRelative) {
+                            config.logo = getPath(this.router.getBasePath(), config.logo);
+                        }
+                    }
+
+                    html += main(config);
+                    // Render main app
+                    this._renderTo(el, html, true);
+                } else {
+                    this.rendered = true;
+                }
+
+                if (config.mergeNavbar && isMobile) {
+                    navAppendToTarget = find('.sidebar');
+                } else {
+                    navEl.classList.add('app-nav');
+
+                    if (!config.repo) {
+                        navEl.classList.add('no-badge');
+                    }
+                }
+
+                // Add nav
+                if (config.loadNavbar) {
+                    before(navAppendToTarget, navEl);
+                }
+
+                if (config.themeColor) {
+                    $.head.appendChild(
+                        create('div', theme(config.themeColor)).firstElementChild,
+                    );
+                    // Polyfll
+                    cssVars(config.themeColor);
+                }
+
+                this._updateRender();
+                toggleClass(body, 'ready');
+            };
+
+            return Render;
+        }(Base));
+    }
+
+    /* eslint-disable no-unused-vars */
+
+    function loadNested(path, qs, file, next, vm, first) {
+        path = first ? path : path.replace(/\/$/, '');
+        path = getParentPath(path);
+
+        if (!path) {
+            return;
+        }
+
+        get(
+            vm.router.getFile(path + file) + qs,
+            false,
+            vm.config.requestHeaders,
+        ).then(next, function (_) {
+            return loadNested(path, qs, file, next, vm);
+        });
+    }
+
+    /** @typedef {import('../Docsify').Constructor} Constructor */
+
+    /**
+     * @template {!Constructor} T
+     * @param {T} Base - The class to extend
+     */
+    function Fetch(Base) {
+        var last;
+
+        var abort = function () {
+            return last && last.abort && last.abort();
+        };
+        var request = function (url, hasbar, requestHeaders) {
+            abort();
+            last = get(url, true, requestHeaders);
+            return last;
+        };
+
+        var get404Path = function (path, config) {
+            var notFoundPage = config.notFoundPage;
+            var ext = config.ext;
+            var defaultPath = '_404' + (ext || '.md');
+            var key;
+            var path404;
+
+            switch (typeof notFoundPage) {
+                case 'boolean':
+                    path404 = defaultPath;
+                    break;
+                case 'string':
+                    path404 = notFoundPage;
+                    break;
+
+                case 'object':
+                    key = Object.keys(notFoundPage)
+                        .sort(function (a, b) {
+                            return b.length - a.length;
+                        })
+                        .filter(function (k) {
+                            return path.match(new RegExp('^' + k));
+                        })[0];
+
+                    path404 = (key && notFoundPage[key]) || defaultPath;
+                    break;
+            }
+
+            return path404;
+        };
+
+        return /*@__PURE__*/(function (Base) {
+            function Fetch() {
+                Base.apply(this, arguments);
+            }
+
+            if (Base) Fetch.__proto__ = Base;
+            Fetch.prototype = Object.create(Base && Base.prototype);
+            Fetch.prototype.constructor = Fetch;
+
+            Fetch.prototype._loadSideAndNav = function _loadSideAndNav(path, qs, loadSidebar, cb) {
+                var this$1 = this;
+
+                return function () {
+                    if (!loadSidebar) {
+                        return cb();
+                    }
+
+                    var fn = function (result) {
+                        this$1._renderSidebar(result);
+                        cb();
+                    };
+
+                    // Load sidebar
+                    loadNested(path, qs, loadSidebar, fn, this$1, true);
+                };
+            };
+
+            Fetch.prototype._fetch = function _fetch(cb) {
+                var this$1 = this;
+                if (cb === void 0) cb = noop;
+
+                var ref = this.route;
+                var query = ref.query;
+                var ref$1 = this.route;
+                var path = ref$1.path;
+
+                // Prevent loading remote content via URL hash
+                // Ex: https://foo.com/#//bar.com/file.md
+                if (isExternal(path)) {
+                    history.replaceState(null, '', '#');
+                    this.router.normalize();
+                } else {
+                    var qs = stringifyQuery(query, [ 'id' ]);
+                    var ref$2 = this.config;
+                    var loadNavbar = ref$2.loadNavbar;
+                    var requestHeaders = ref$2.requestHeaders;
+                    var loadSidebar = ref$2.loadSidebar;
+                    // Abort last request
+
+                    var file = this.router.getFile(path);
+                    var req = request(file + qs, true, requestHeaders);
+
+                    this.isRemoteUrl = isExternal(file);
+                    // Current page is html
+                    this.isHTML = /\.html$/g.test(file);
+
+                    // Load main content
+                    req.then(
+                        function (text, opt) {
+                            return this$1._renderMain(
+                                text,
+                                opt,
+                                this$1._loadSideAndNav(path, qs, loadSidebar, cb),
+                            );
+                        },
+                        function (_) {
+                            this$1._fetchFallbackPage(path, qs, cb) ||
+                            this$1._fetch404(file, qs, cb);
+                        },
+                    );
+
+                    // Load nav
+                    loadNavbar &&
+                    loadNested(
+                        path,
+                        qs,
+                        loadNavbar,
+                        function (text) {
+                            return this$1._renderNav(text);
+                        },
+                        this,
+                        true,
+                    );
+                }
+            };
+
+            Fetch.prototype._fetchCover = function _fetchCover() {
+                var this$1 = this;
+
+                var ref = this.config;
+                var coverpage = ref.coverpage;
+                var requestHeaders = ref.requestHeaders;
+                var query = this.route.query;
+                var root = getParentPath(this.route.path);
+
+                if (coverpage) {
+                    var path = null;
+                    var routePath = this.route.path;
+                    if (typeof coverpage === 'string') {
+                        if (routePath === '/') {
+                            path = coverpage;
+                        }
+                    } else if (Array.isArray(coverpage)) {
+                        path = coverpage.indexOf(routePath) > -1 && 'coverpage';
+                    } else {
+                        var cover = coverpage[routePath];
+                        path = cover === true ? 'coverpage' : cover;
+                    }
+
+                    var coverOnly = Boolean(path) && this.config.onlyCover;
+                    if (path) {
+                        path = this.router.getFile(root + path);
+                        this.coverIsHTML = /\.html$/g.test(path);
+                        get(
+                            path + stringifyQuery(query, [ 'id' ]),
+                            false,
+                            requestHeaders,
+                        ).then(function (text) {
+                            return this$1._renderCover(text, coverOnly);
+                        });
+                    } else {
+                        this._renderCover(null, coverOnly);
+                    }
+
+                    return coverOnly;
+                }
+            };
+
+            Fetch.prototype.$fetch = function $fetch(cb, $resetEvents) {
+                var this$1 = this;
+                if (cb === void 0) cb = noop;
+                if ($resetEvents === void 0) $resetEvents = this.$resetEvents.bind(this);
+
+                var done = function () {
+                    this$1.callHook('doneEach');
+                    cb();
+                };
+
+                var onlyCover = this._fetchCover();
+
+                if (onlyCover) {
+                    done();
+                } else {
+                    this._fetch(function () {
+                        $resetEvents();
+                        done();
+                    });
+                }
+            };
+
+            Fetch.prototype._fetchFallbackPage = function _fetchFallbackPage(path, qs, cb) {
+                var this$1 = this;
+                if (cb === void 0) cb = noop;
+
+                var ref = this.config;
+                var requestHeaders = ref.requestHeaders;
+                var fallbackLanguages = ref.fallbackLanguages;
+                var loadSidebar = ref.loadSidebar;
+
+                if (!fallbackLanguages) {
+                    return false;
+                }
+
+                var local = path.split('/')[1];
+
+                if (fallbackLanguages.indexOf(local) === -1) {
+                    return false;
+                }
+
+                var newPath = this.router.getFile(
+                    path.replace(new RegExp(('^/' + local)), ''),
+                );
+                var req = request(newPath + qs, true, requestHeaders);
+
+                req.then(
+                    function (text, opt) {
+                        return this$1._renderMain(
+                            text,
+                            opt,
+                            this$1._loadSideAndNav(path, qs, loadSidebar, cb),
+                        );
+                    },
+                    function () {
+                        return this$1._fetch404(path, qs, cb);
+                    },
+                );
+
+                return true;
+            };
+
+            /**
+             * Load the 404 page
+             * @param {String} path URL to be loaded
+             * @param {*} qs TODO: define
+             * @param {Function} cb Callback
+             * @returns {Boolean} True if the requested page is not found
+             * @private
+             */
+            Fetch.prototype._fetch404 = function _fetch404(path, qs, cb) {
+                var this$1 = this;
+                if (cb === void 0) cb = noop;
+
+                var ref = this.config;
+                var loadSidebar = ref.loadSidebar;
+                var requestHeaders = ref.requestHeaders;
+                var notFoundPage = ref.notFoundPage;
+
+                var fnLoadSideAndNav = this._loadSideAndNav(path, qs, loadSidebar, cb);
+                if (notFoundPage) {
+                    var path404 = get404Path(path, this.config);
+
+                    request(this.router.getFile(path404), true, requestHeaders).then(
+                        function (text, opt) {
+                            return this$1._renderMain(text, opt, fnLoadSideAndNav);
+                        },
+                        function () {
+                            return this$1._renderMain(null, {}, fnLoadSideAndNav);
+                        },
+                    );
+                    return true;
+                }
+
+                this._renderMain(null, {}, fnLoadSideAndNav);
+                return false;
+            };
+
+            Fetch.prototype.initFetch = function initFetch() {
+                var this$1 = this;
+
+                var ref = this.config;
+                var loadSidebar = ref.loadSidebar;
+
+                // Server-Side Rendering
+                if (this.rendered) {
+                    var activeEl = getAndActive(this.router, '.sidebar-nav', true, true);
+                    if (loadSidebar && activeEl) {
+                        activeEl.parentNode.innerHTML += window.__SUB_SIDEBAR__;
+                    }
+
+                    this._bindEventOnRendered(activeEl);
+                    this.$resetEvents();
+                    this.callHook('doneEach');
+                    this.callHook('ready');
+                } else {
+                    this.$fetch(function (_) {
+                        return this$1.callHook('ready');
+                    });
+                }
+            };
+
+            return Fetch;
+        }(Base));
+    }
+
+    /** @typedef {import('../Docsify').Constructor} Constructor */
+
+    /**
+     * @template {!Constructor} T
+     * @param {T} Base - The class to extend
+     */
+    function Events(Base) {
+        return /*@__PURE__*/(function (Base) {
+            function Events() {
+                Base.apply(this, arguments);
+            }
+
+            if (Base) Events.__proto__ = Base;
+            Events.prototype = Object.create(Base && Base.prototype);
+            Events.prototype.constructor = Events;
+
+            Events.prototype.$resetEvents = function $resetEvents(source) {
+                var this$1 = this;
+
+                var ref = this.config;
+                var auto2top = ref.auto2top;
+
+                (function () {
+                    // Rely on the browser's scroll auto-restoration when going back or forward
+                    if (source === 'history') {
+                        return;
+                    }
+                    // Scroll to ID if specified
+                    if (this$1.route.query.id) {
+                        scrollIntoView(this$1.route.path, this$1.route.query.id);
+                    }
+                    // Scroll to top if a link was clicked and auto2top is enabled
+                    if (source === 'navigate') {
+                        auto2top && scroll2Top(auto2top);
+                    }
+                })();
+
+                if (this.config.loadNavbar) {
+                    getAndActive(this.router, 'nav');
+                }
+            };
+
+            Events.prototype.initEvent = function initEvent() {
+                // Bind toggle button
+                btn('button.sidebar-toggle', this.router);
+                collapse('.sidebar', this.router);
+                // Bind sticky effect
+                if (this.config.coverpage) {
+                    !isMobile && on('scroll', sticky);
+                } else {
+                    body.classList.add('sticky');
+                }
+            };
+
+            return Events;
+        }(Base));
+    }
+
+
+    var util = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        cached: cached,
+        hyphenate: hyphenate,
+        hasOwn: hasOwn,
+        merge: merge,
+        isPrimitive: isPrimitive,
+        noop: noop,
+        isFn: isFn,
+        isExternal: isExternal,
+        inBrowser: inBrowser,
+        isMobile: isMobile,
+        supportsPushState: supportsPushState,
+        parseQuery: parseQuery,
+        stringifyQuery: stringifyQuery,
+        isAbsolutePath: isAbsolutePath,
+        removeParams: removeParams,
+        getParentPath: getParentPath,
+        cleanPath: cleanPath,
+        resolvePath: resolvePath,
+        getPath: getPath,
+        replaceSlug: replaceSlug,
+        endsWith: endsWith,
+    });
+
+    // TODO This is deprecated, kept for backwards compatibility. Remove in next
+    // major release. We'll tell people to get everything from the DOCSIFY global
+    // when using the global build, but we'll highly recommend for them to import
+    // from the ESM build (f.e. lib/docsify.esm.js and lib/docsify.min.esm.js).
+    function initGlobalAPI() {
+        window.Docsify = {
+            util: util,
+            dom: dom,
+            get: get,
+            slugify: slugify,
+            version: '4.12.2',
+        };
+        window.DocsifyCompiler = Compiler;
+        window.marked = marked_1;
+        window.Prism = prism;
+    }
+
+    /** @typedef {import('../Docsify').Constructor} Constructor */
+
+    /**
+     * @template {!Constructor} T
+     * @param {T} Base - The class to extend
+     */
+    function Lifecycle(Base) {
+        return /*@__PURE__*/(function (Base) {
+            function Lifecycle() {
+                Base.apply(this, arguments);
+            }
+
+            if (Base) Lifecycle.__proto__ = Base;
+            Lifecycle.prototype = Object.create(Base && Base.prototype);
+            Lifecycle.prototype.constructor = Lifecycle;
+
+            Lifecycle.prototype.initLifecycle = function initLifecycle() {
+                var this$1 = this;
+
+                var hooks = [
+                    'init',
+                    'mounted',
+                    'beforeEach',
+                    'afterEach',
+                    'doneEach',
+                    'ready' ];
+
+                this._hooks = {};
+                this._lifecycle = {};
+
+                hooks.forEach(function (hook) {
+                    var arr = (this$1._hooks[hook] = []);
+                    this$1._lifecycle[hook] = function (fn) {
+                        return arr.push(fn);
+                    };
+                });
+            };
+
+            Lifecycle.prototype.callHook = function callHook(hookName, data, next) {
+                if (next === void 0) next = noop;
+
+                var queue = this._hooks[hookName];
+
+                var step = function (index) {
+                    var hookFn = queue[index];
+
+                    if (index >= queue.length) {
+                        next(data);
+                    } else if (typeof hookFn === 'function') {
+                        if (hookFn.length === 2) {
+                            hookFn(data, function (result) {
+                                data = result;
+                                step(index + 1);
+                            });
+                        } else {
+                            var result = hookFn(data);
+                            data = result === undefined ? data : result;
+                            step(index + 1);
+                        }
+                    } else {
+                        step(index + 1);
+                    }
+                };
+
+                step(0);
+            };
+
+            return Lifecycle;
+        }(Base));
+    }
+
+    /** @typedef {new (...args: any[]) => any} Constructor */
+
+        // eslint-disable-next-line new-cap
+    var Docsify = /*@__PURE__*/(function (superclass) {
+            function Docsify() {
+                superclass.call(this);
+
+                this.config = config(this);
+
+                this.initLifecycle(); // Init hooks
+                this.initPlugin(); // Install plugins
+                this.callHook('init');
+                this.initRouter(); // Add router
+                this.initRender(); // Render base DOM
+                this.initEvent(); // Bind events
+                this.initFetch(); // Fetch data
+                this.callHook('mounted');
+            }
+
+            if (superclass) Docsify.__proto__ = superclass;
+            Docsify.prototype = Object.create(superclass && superclass.prototype);
+            Docsify.prototype.constructor = Docsify;
+
+            Docsify.prototype.initPlugin = function initPlugin() {
+                var this$1 = this;
+
+                []
+                    .concat(this.config.plugins)
+                    .forEach(function (fn) {
+                        return isFn(fn) && fn(this$1._lifecycle, this$1);
+                    });
+            };
+
+            return Docsify;
+        }(Fetch(Events(Render(Router(Lifecycle(Object)))))));
+
+    /**
+     * Global API
+     */
+    initGlobalAPI();
+
+    /**
+     * Run Docsify
+     */
+    // eslint-disable-next-line no-unused-vars
+    documentReady(function (_) {
+        return new Docsify();
+    });
+
+}());
diff --git a/api/static/docsify.min.js b/api/static/docsify.min.js
deleted file mode 100644
index 1cf6fa6..0000000
--- a/api/static/docsify.min.js
+++ /dev/null
@@ -1 +0,0 @@
-!function(){function s(n){var r=Object.create(null);return function(e){var t=c(e)?e:JSON.stringify(e);return r[t]||(r[t]=n(e))}}var a=s(function(e){return e.replace(/([A-Z])/g,function(e){return"-"+e.toLowerCase()})}),l=Object.prototype.hasOwnProperty,p=Object.assign||function(e){for(var t=arguments,n=1;n<arguments.length;n++){var r,i=Object(t[n]);for(r in i)l.call(i,r)&&(e[r]=i[r])}return e};function c(e){return"string"==typeof e||"number"==typeof e}function u(){}function d(e){return"function"==typeof e}var h=document.body.clientWidth<=600,f=window.history&&window.history.pushState&&window.history.replaceState&&!navigator.userAgent.match(/((iPod|iPhone|iPad).+\bOS\s+[1-4]\D|WebApps\/.+CFNetwork)/),n={};function g(e,t){if(void 0===t&&(t=!1),"string"==typeof e){if(void 0!==window.Vue)return y(e);e=t?y(e):n[e]||(n[e]=y(e))}return e}var m=document,v=m.body,b=m.head;function y(e,t){return t?e.querySelector(t):m.querySelector(e)}function k(e,t){return[].slice.call(t?e.querySelectorAll(t):m.querySelectorAll(e))}function w(e,t){return e=m.createElement(e),t&&(e.innerHTML=t),e}function o(e,t){return e.appendChild(t)}function x(e,t){return e.insertBefore(t,e.children[0])}function _(e,t,n){d(t)?window.addEventListener(e,t):e.addEventListener(t,n)}function S(e,t,n){d(t)?window.removeEventListener(e,t):e.removeEventListener(t,n)}function A(e,t,n){e&&e.classList[n?t:"toggle"](n||t)}function e(e,t){void 0===t&&(t=document);var n=t.readyState;if("complete"===n||"interactive"===n)return setTimeout(e,0);t.addEventListener("DOMContentLoaded",e)}var t=Object.freeze({__proto__:null,getNode:g,$:m,body:v,head:b,find:y,findAll:k,create:w,appendTo:o,before:x,on:_,off:S,toggleClass:A,style:function(e){o(b,w("style",e))},documentReady:e}),T=document.currentScript;function E(e){var t,n=p({el:"#app",repo:"",maxLevel:6,subMaxLevel:0,loadSidebar:null,loadNavbar:null,homepage:"README.md",coverpage:"",basePath:"",auto2top:!1,name:"",themeColor:"",nameLink:window.location.pathname,autoHeader:!1,executeScript:null,noEmoji:!1,ga:"",ext:".md",mergeNavbar:!1,formatUpdated:"",externalLinkTarget:"_blank",cornerExternalLinkTarget:"_blank",externalLinkRel:"noopener",routerMode:"hash",noCompileLinks:[],crossOriginLinks:[],relativePath:!1,topMargin:0},"function"==typeof window.$docsify?window.$docsify(e):window.$docsify),r=T||[].slice.call(document.getElementsByTagName("script")).filter(function(e){return/docsify\./.test(e.src)})[0];if(r)for(var i in n){!l.call(n,i)||c(t=r.getAttribute("data-"+a(i)))&&(n[i]=""===t||t)}return!0===n.loadSidebar&&(n.loadSidebar="_sidebar"+n.ext),!0===n.loadNavbar&&(n.loadNavbar="_navbar"+n.ext),!0===n.coverpage&&(n.coverpage="_coverpage"+n.ext),!0===n.repo&&(n.repo=""),!0===n.name&&(n.name=""),window.$docsify=n}var R=/([^{]*?)\w(?=\})/g,$={YYYY:"getFullYear",YY:"getYear",MM:function(e){return e.getMonth()+1},DD:"getDate",HH:"getHours",mm:"getMinutes",ss:"getSeconds",fff:"getMilliseconds"};var i,r=Object.hasOwnProperty,O=Object.setPrototypeOf,C=Object.isFrozen,L=Object.getPrototypeOf,F=Object.getOwnPropertyDescriptor,Re=Object.freeze,z=Object.seal,M=Object.create,N="undefined"!=typeof Reflect&&Reflect,P=(P=N.apply)||function(e,t,n){return e.apply(t,n)},Re=Re||function(e){return e},z=z||function(e){return e},D=(D=N.construct)||function(e,t){return new(Function.prototype.bind.apply(e,[null].concat(function(e){if(Array.isArray(e)){for(var t=0,n=Array(e.length);t<e.length;t++)n[t]=e[t];return n}return Array.from(e)}(t))))},$e=I(Array.prototype.forEach),Oe=I(Array.prototype.pop),Ce=I(Array.prototype.push),Le=I(String.prototype.toLowerCase),Fe=I(String.prototype.match),ze=I(String.prototype.replace),Me=I(String.prototype.indexOf),Ne=I(String.prototype.trim),Pe=I(RegExp.prototype.test),De=(i=TypeError,function(){for(var e=arguments,t=arguments.length,n=Array(t),r=0;r<t;r++)n[r]=e[r];return D(i,n)});function I(a){return function(e){for(var t=arguments,n=arguments.length,r=Array(1<n?n-1:0),i=1;i<n;i++)r[i-1]=t[i];return P(a,e,r)}}function Ie(e,t){O&&O(e,null);for(var n=t.length;n--;){var r,i=t[n];"string"!=typeof i||(r=Le(i))!==i&&(C(t)||(t[n]=r),i=r),e[i]=!0}return e}function je(e){var t=M(null),n=void 0;for(n in e)P(r,e,[n])&&(t[n]=e[n]);return t}function qe(e,t){for(;null!==e;){var n=F(e,t);if(n){if(n.get)return I(n.get);if("function"==typeof n.value)return I(n.value)}e=L(e)}return null}var He=Re(["a","abbr","acronym","address","area","article","aside","audio","b","bdi","bdo","big","blink","blockquote","body","br","button","canvas","caption","center","cite","code","col","colgroup","content","data","datalist","dd","decorator","del","details","dfn","dialog","dir","div","dl","dt","element","em","fieldset","figcaption","figure","font","footer","form","h1","h2","h3","h4","h5","h6","head","header","hgroup","hr","html","i","img","input","ins","kbd","label","legend","li","main","map","mark","marquee","menu","menuitem","meter","nav","nobr","ol","optgroup","option","output","p","picture","pre","progress","q","rp","rt","ruby","s","samp","section","select","shadow","small","source","spacer","span","strike","strong","style","sub","summary","sup","table","tbody","td","template","textarea","tfoot","th","thead","time","tr","track","tt","u","ul","var","video","wbr"]),Ue=Re(["svg","a","altglyph","altglyphdef","altglyphitem","animatecolor","animatemotion","animatetransform","circle","clippath","defs","desc","ellipse","filter","font","g","glyph","glyphref","hkern","image","line","lineargradient","marker","mask","metadata","mpath","path","pattern","polygon","polyline","radialgradient","rect","stop","style","switch","symbol","text","textpath","title","tref","tspan","view","vkern"]),Be=Re(["feBlend","feColorMatrix","feComponentTransfer","feComposite","feConvolveMatrix","feDiffuseLighting","feDisplacementMap","feDistantLight","feFlood","feFuncA","feFuncB","feFuncG","feFuncR","feGaussianBlur","feMerge","feMergeNode","feMorphology","feOffset","fePointLight","feSpecularLighting","feSpotLight","feTile","feTurbulence"]),Ze=Re(["animate","color-profile","cursor","discard","fedropshadow","feimage","font-face","font-face-format","font-face-name","font-face-src","font-face-uri","foreignobject","hatch","hatchpath","mesh","meshgradient","meshpatch","meshrow","missing-glyph","script","set","solidcolor","unknown","use"]),Ge=Re(["math","menclose","merror","mfenced","mfrac","mglyph","mi","mlabeledtr","mmultiscripts","mn","mo","mover","mpadded","mphantom","mroot","mrow","ms","mspace","msqrt","mstyle","msub","msup","msubsup","mtable","mtd","mtext","mtr","munder","munderover"]),We=Re(["maction","maligngroup","malignmark","mlongdiv","mscarries","mscarry","msgroup","mstack","msline","msrow","semantics","annotation","annotation-xml","mprescripts","none"]),Ve=Re(["#text"]),Ye=Re(["accept","action","align","alt","autocapitalize","autocomplete","autopictureinpicture","autoplay","background","bgcolor","border","capture","cellpadding","cellspacing","checked","cite","class","clear","color","cols","colspan","controls","controlslist","coords","crossorigin","datetime","decoding","default","dir","disabled","disablepictureinpicture","disableremoteplayback","download","draggable","enctype","enterkeyhint","face","for","headers","height","hidden","high","href","hreflang","id","inputmode","integrity","ismap","kind","label","lang","list","loading","loop","low","max","maxlength","media","method","min","minlength","multiple","muted","name","noshade","novalidate","nowrap","open","optimum","pattern","placeholder","playsinline","poster","preload","pubdate","radiogroup","readonly","rel","required","rev","reversed","role","rows","rowspan","spellcheck","scope","selected","shape","size","sizes","span","srclang","start","src","srcset","step","style","summary","tabindex","title","translate","type","usemap","valign","value","width","xmlns"]),Xe=Re(["accent-height","accumulate","additive","alignment-baseline","ascent","attributename","attributetype","azimuth","basefrequency","baseline-shift","begin","bias","by","class","clip","clippathunits","clip-path","clip-rule","color","color-interpolation","color-interpolation-filters","color-profile","color-rendering","cx","cy","d","dx","dy","diffuseconstant","direction","display","divisor","dur","edgemode","elevation","end","fill","fill-opacity","fill-rule","filter","filterunits","flood-color","flood-opacity","font-family","font-size","font-size-adjust","font-stretch","font-style","font-variant","font-weight","fx","fy","g1","g2","glyph-name","glyphref","gradientunits","gradienttransform","height","href","id","image-rendering","in","in2","k","k1","k2","k3","k4","kerning","keypoints","keysplines","keytimes","lang","lengthadjust","letter-spacing","kernelmatrix","kernelunitlength","lighting-color","local","marker-end","marker-mid","marker-start","markerheight","markerunits","markerwidth","maskcontentunits","maskunits","max","mask","media","method","mode","min","name","numoctaves","offset","operator","opacity","order","orient","orientation","origin","overflow","paint-order","path","pathlength","patterncontentunits","patterntransform","patternunits","points","preservealpha","preserveaspectratio","primitiveunits","r","rx","ry","radius","refx","refy","repeatcount","repeatdur","restart","result","rotate","scale","seed","shape-rendering","specularconstant","specularexponent","spreadmethod","startoffset","stddeviation","stitchtiles","stop-color","stop-opacity","stroke-dasharray","stroke-dashoffset","stroke-linecap","stroke-linejoin","stroke-miterlimit","stroke-opacity","stroke","stroke-width","style","surfacescale","systemlanguage","tabindex","targetx","targety","transform","text-anchor","text-decoration","text-rendering","textlength","type","u1","u2","unicode","values","viewbox","visibility","version","vert-adv-y","vert-origin-x","vert-origin-y","width","word-spacing","wrap","writing-mode","xchannelselector","ychannelselector","x","x1","x2","xmlns","y","y1","y2","z","zoomandpan"]),Ke=Re(["accent","accentunder","align","bevelled","close","columnsalign","columnlines","columnspan","denomalign","depth","dir","display","displaystyle","encoding","fence","frame","height","href","id","largeop","length","linethickness","lspace","lquote","mathbackground","mathcolor","mathsize","mathvariant","maxsize","minsize","movablelimits","notation","numalign","open","rowalign","rowlines","rowspacing","rowspan","rspace","rquote","scriptlevel","scriptminsize","scriptsizemultiplier","selection","separator","separators","stretchy","subscriptshift","supscriptshift","symmetric","voffset","width","xmlns"]),Qe=Re(["xlink:href","xml:id","xlink:title","xml:space","xmlns:xlink"]),Je=z(/\{\{[\s\S]*|[\s\S]*\}\}/gm),et=z(/<%[\s\S]*|[\s\S]*%>/gm),tt=z(/^data-[\-\w.\u00B7-\uFFFF]/),nt=z(/^aria-[\-\w]+$/),rt=z(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i),it=z(/^(?:\w+script|data):/i),at=z(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g),ot="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e};function st(e){if(Array.isArray(e)){for(var t=0,n=Array(e.length);t<e.length;t++)n[t]=e[t];return n}return Array.from(e)}var lt=function(){return"undefined"==typeof window?null:window},ct=function(e,t){if("object"!==(void 0===e?"undefined":ot(e))||"function"!=typeof e.createPolicy)return null;var n=null,r="data-tt-policy-suffix";t.currentScript&&t.currentScript.hasAttribute(r)&&(n=t.currentScript.getAttribute(r));var i="dompurify"+(n?"#"+n:"");try{return e.createPolicy(i,{createHTML:function(e){return e}})}catch(e){return console.warn("TrustedTypes policy "+i+" could not be created."),null}};var j,q,H=function t(e){function c(e){return t(e)}var s=0<arguments.length&&void 0!==e?e:lt();if(c.version="2.2.6",c.removed=[],!s||!s.document||9!==s.document.nodeType)return c.isSupported=!1,c;var l=s.document,a=s.document,u=s.DocumentFragment,n=s.HTMLTemplateElement,p=s.Node,o=s.Element,r=s.NodeFilter,i=s.NamedNodeMap,d=void 0===i?s.NamedNodeMap||s.MozNamedAttrMap:i,h=s.Text,f=s.Comment,g=s.DOMParser,e=s.trustedTypes,i=o.prototype,m=qe(i,"cloneNode"),v=qe(i,"nextSibling"),b=qe(i,"childNodes"),y=qe(i,"parentNode");"function"!=typeof n||(n=a.createElement("template")).content&&n.content.ownerDocument&&(a=n.content.ownerDocument);var k=ct(e,l),w=k&&ee?k.createHTML(""):"",x=a.implementation,_=a.createNodeIterator,S=a.getElementsByTagName,A=a.createDocumentFragment,T=l.importNode,E={};try{E=je(a).documentMode?a.documentMode:{}}catch(e){}var R={};c.isSupported=x&&void 0!==x.createHTMLDocument&&9!==E;function $(e){ce&&ce===e||(e&&"object"===(void 0===e?"undefined":ot(e))||(e={}),e=je(e),D="ALLOWED_TAGS"in e?Ie({},e.ALLOWED_TAGS):I,j="ALLOWED_ATTR"in e?Ie({},e.ALLOWED_ATTR):q,se="ADD_URI_SAFE_ATTR"in e?Ie(je(le),e.ADD_URI_SAFE_ATTR):le,ae="ADD_DATA_URI_TAGS"in e?Ie(je(oe),e.ADD_DATA_URI_TAGS):oe,H="FORBID_TAGS"in e?Ie({},e.FORBID_TAGS):{},U="FORBID_ATTR"in e?Ie({},e.FORBID_ATTR):{},O="USE_PROFILES"in e&&e.USE_PROFILES,B=!1!==e.ALLOW_ARIA_ATTR,Z=!1!==e.ALLOW_DATA_ATTR,G=e.ALLOW_UNKNOWN_PROTOCOLS||!1,W=e.SAFE_FOR_TEMPLATES||!1,V=e.WHOLE_DOCUMENT||!1,K=e.RETURN_DOM||!1,Q=e.RETURN_DOM_FRAGMENT||!1,J=!1!==e.RETURN_DOM_IMPORT,ee=e.RETURN_TRUSTED_TYPE||!1,X=e.FORCE_BODY||!1,te=!1!==e.SANITIZE_DOM,ne=!1!==e.KEEP_CONTENT,re=e.IN_PLACE||!1,P=e.ALLOWED_URI_REGEXP||P,W&&(Z=!1),Q&&(K=!0),O&&(D=Ie({},[].concat(st(Ve))),j=[],!0===O.html&&(Ie(D,He),Ie(j,Ye)),!0===O.svg&&(Ie(D,Ue),Ie(j,Xe),Ie(j,Qe)),!0===O.svgFilters&&(Ie(D,Be),Ie(j,Xe),Ie(j,Qe)),!0===O.mathMl&&(Ie(D,Ge),Ie(j,Ke),Ie(j,Qe))),e.ADD_TAGS&&(D===I&&(D=je(D)),Ie(D,e.ADD_TAGS)),e.ADD_ATTR&&(j===q&&(j=je(j)),Ie(j,e.ADD_ATTR)),e.ADD_URI_SAFE_ATTR&&Ie(se,e.ADD_URI_SAFE_ATTR),ne&&(D["#text"]=!0),V&&Ie(D,["html","head","body"]),D.table&&(Ie(D,["tbody"]),delete H.tbody),Re&&Re(e),ce=e)}var O,C=Je,L=et,F=tt,z=nt,M=it,N=at,P=rt,D=null,I=Ie({},[].concat(st(He),st(Ue),st(Be),st(Ge),st(Ve))),j=null,q=Ie({},[].concat(st(Ye),st(Xe),st(Ke),st(Qe))),H=null,U=null,B=!0,Z=!0,G=!1,W=!1,V=!1,Y=!1,X=!1,K=!1,Q=!1,J=!0,ee=!1,te=!0,ne=!0,re=!1,ie=Ie({},["annotation-xml","audio","colgroup","desc","foreignobject","head","iframe","math","mi","mn","mo","ms","mtext","noembed","noframes","noscript","plaintext","script","style","svg","template","thead","title","video","xmp"]),ae=null,oe=Ie({},["audio","video","img","source","image","track"]),se=null,le=Ie({},["alt","class","for","id","label","name","pattern","placeholder","summary","title","value","style","xmlns"]),ce=null,ue=a.createElement("form"),pe=Ie({},["mi","mo","mn","ms","mtext"]),de=Ie({},["foreignobject","desc","title","annotation-xml"]),he=Ie({},Ue);Ie(he,Be),Ie(he,Ze);var fe=Ie({},Ge);Ie(fe,We);function ge(t){Ce(c.removed,{element:t});try{t.parentNode.removeChild(t)}catch(e){try{t.outerHTML=w}catch(e){t.remove()}}}function me(e,t){try{Ce(c.removed,{attribute:t.getAttributeNode(e),from:t})}catch(e){Ce(c.removed,{attribute:null,from:t})}t.removeAttribute(e)}function ve(e){var t=void 0,n=void 0;X?e="<remove></remove>"+e:n=(r=Fe(e,/^[\r\n\t ]+/))&&r[0];var r,i=k?k.createHTML(e):e;try{t=(new g).parseFromString(i,"text/html")}catch(e){}return t&&t.documentElement||((r=(t=x.createHTMLDocument("")).body).parentNode.removeChild(r.parentNode.firstElementChild),r.outerHTML=i),e&&n&&t.body.insertBefore(a.createTextNode(n),t.body.childNodes[0]||null),S.call(t,V?"html":"body")[0]}function be(e){return _.call(e.ownerDocument||e,e,r.SHOW_ELEMENT|r.SHOW_COMMENT|r.SHOW_TEXT,function(){return r.FILTER_ACCEPT},!1)}function ye(e){return"object"===(void 0===p?"undefined":ot(p))?e instanceof p:e&&"object"===(void 0===e?"undefined":ot(e))&&"number"==typeof e.nodeType&&"string"==typeof e.nodeName}function ke(e,t,n){R[e]&&$e(R[e],function(e){e.call(c,t,n,ce)})}function we(e){var t;if(ke("beforeSanitizeElements",e,null),!((n=e)instanceof h||n instanceof f||"string"==typeof n.nodeName&&"string"==typeof n.textContent&&"function"==typeof n.removeChild&&n.attributes instanceof d&&"function"==typeof n.removeAttribute&&"function"==typeof n.setAttribute&&"string"==typeof n.namespaceURI&&"function"==typeof n.insertBefore))return ge(e),1;if(Fe(e.nodeName,/[\u0080-\uFFFF]/))return ge(e),1;var n=Le(e.nodeName);if(ke("uponSanitizeElement",e,{tagName:n,allowedTags:D}),!ye(e.firstElementChild)&&(!ye(e.content)||!ye(e.content.firstElementChild))&&Pe(/<[/\w]/g,e.innerHTML)&&Pe(/<[/\w]/g,e.textContent))return ge(e),1;if(D[n]&&!H[n])return e instanceof o&&!function(e){var t=y(e);t&&t.tagName||(t={namespaceURI:Ee,tagName:"template"});var n=Le(e.tagName),r=Le(t.tagName);return e.namespaceURI===Te?t.namespaceURI===Ee?"svg"===n:t.namespaceURI===Ae?"svg"===n&&("annotation-xml"===r||pe[r]):Boolean(he[n]):e.namespaceURI===Ae?t.namespaceURI===Ee?"math"===n:t.namespaceURI===Te?"math"===n&&de[r]:Boolean(fe[n]):e.namespaceURI===Ee&&(t.namespaceURI!==Te||de[r])&&(t.namespaceURI!==Ae||pe[r])&&(r=Ie({},["title","style","font","a","script"]),!fe[n]&&(r[n]||!he[n]))}(e)||("noscript"===n||"noembed"===n)&&Pe(/<\/no(script|embed)/i,e.innerHTML)?(ge(e),1):(W&&3===e.nodeType&&(t=e.textContent,t=ze(t,C," "),t=ze(t,L," "),e.textContent!==t&&(Ce(c.removed,{element:e.cloneNode()}),e.textContent=t)),ke("afterSanitizeElements",e,null),0);if(ne&&!ie[n])for(var r=y(e),i=b(e),a=i.length-1;0<=a;--a)r.insertBefore(m(i[a],!0),v(e));return ge(e),1}function xe(e,t,n){if(te&&("id"===t||"name"===t)&&(n in a||n in ue))return!1;if(!(Z&&Pe(F,t)||B&&Pe(z,t))){if(!j[t]||U[t])return!1;if(!se[t]&&!Pe(P,ze(n,N,""))&&("src"!==t&&"xlink:href"!==t&&"href"!==t||"script"===e||0!==Me(n,"data:")||!ae[e])&&(!G||Pe(M,ze(n,N,"")))&&n)return!1}return!0}function _e(e){var t=void 0,n=void 0;ke("beforeSanitizeAttributes",e,null);var r=e.attributes;if(r){for(var i={attrName:"",attrValue:"",keepAttr:!0,allowedAttributes:j},n=r.length;n--;){var a=(l=r[n]).name,o=l.namespaceURI,t=Ne(l.value),s=Le(a);if(i.attrName=s,i.attrValue=t,i.keepAttr=!0,i.forceKeepAttr=void 0,ke("uponSanitizeAttribute",e,i),t=i.attrValue,!i.forceKeepAttr&&(me(a,e),i.keepAttr))if(Pe(/\/>/i,t))me(a,e);else{W&&(t=ze(t,C," "),t=ze(t,L," "));var l=e.nodeName.toLowerCase();if(xe(l,s,t))try{o?e.setAttributeNS(o,a,t):e.setAttribute(a,t),Oe(c.removed)}catch(e){}}}ke("afterSanitizeAttributes",e,null)}}function Se(e){var t,n=be(e);for(ke("beforeSanitizeShadowDOM",e,null);t=n.nextNode();)ke("uponSanitizeShadowNode",t,null),we(t)||(t.content instanceof u&&Se(t.content),_e(t));ke("afterSanitizeShadowDOM",e,null)}var Ae="http://www.w3.org/1998/Math/MathML",Te="http://www.w3.org/2000/svg",Ee="http://www.w3.org/1999/xhtml";return c.sanitize=function(e,t){var n,r=void 0,i=void 0,a=void 0;if("string"!=typeof(e=e||"\x3c!--\x3e")&&!ye(e)){if("function"!=typeof e.toString)throw De("toString is not a function");if("string"!=typeof(e=e.toString()))throw De("dirty is not a string, aborting")}if(!c.isSupported){if("object"===ot(s.toStaticHTML)||"function"==typeof s.toStaticHTML){if("string"==typeof e)return s.toStaticHTML(e);if(ye(e))return s.toStaticHTML(e.outerHTML)}return e}if(Y||$(t),c.removed=[],"string"==typeof e&&(re=!1),!re)if(e instanceof p)1===(t=(r=ve("\x3c!----\x3e")).ownerDocument.importNode(e,!0)).nodeType&&"BODY"===t.nodeName||"HTML"===t.nodeName?r=t:r.appendChild(t);else{if(!K&&!W&&!V&&-1===e.indexOf("<"))return k&&ee?k.createHTML(e):e;if(!(r=ve(e)))return K?null:w}r&&X&&ge(r.firstChild);for(var o=be(re?e:r);n=o.nextNode();)3===n.nodeType&&n===i||we(n)||(n.content instanceof u&&Se(n.content),_e(n),i=n);if(i=null,re)return e;if(K){if(Q)for(a=A.call(r.ownerDocument);r.firstChild;)a.appendChild(r.firstChild);else a=r;return J&&(a=T.call(l,a,!0)),a}return e=V?r.outerHTML:r.innerHTML,W&&(e=ze(e,C," "),e=ze(e,L," ")),k&&ee?k.createHTML(e):e},c.setConfig=function(e){$(e),Y=!0},c.clearConfig=function(){ce=null,Y=!1},c.isValidAttribute=function(e,t,n){return ce||$({}),e=Le(e),t=Le(t),xe(e,t,n)},c.addHook=function(e,t){"function"==typeof t&&(R[e]=R[e]||[],Ce(R[e],t))},c.removeHook=function(e){R[e]&&Oe(R[e])},c.removeHooks=function(e){R[e]&&(R[e]=[])},c.removeAllHooks=function(){R={}},c}();function U(e){var t,n=e.loaded,r=e.total,i=e.step;j||((e=w("div")).classList.add("progress"),o(v,e),j=e),t=i?80<(t=parseInt(j.style.width||0,10)+i)?80:t:Math.floor(n/r*100),j.style.opacity=1,j.style.width=95<=t?"100%":t+"%",95<=t&&(clearTimeout(q),q=setTimeout(function(e){j.style.opacity=0,j.style.width="0%"},200))}var B={};function Z(i,e,t){void 0===e&&(e=!1),void 0===t&&(t={});function a(){o.addEventListener.apply(o,arguments)}var n,o=new XMLHttpRequest,r=B[i];if(r)return{then:function(e){return e(r.content,r.opt)},abort:u};for(n in o.open("GET",i),t)l.call(t,n)&&o.setRequestHeader(n,t[n]);return o.send(),{then:function(t,n){var r;void 0===n&&(n=u),e&&(r=setInterval(function(e){return U({step:Math.floor(5*Math.random()+1)})},500),a("progress",U),a("loadend",function(e){U(e),clearInterval(r)})),a("error",n),a("load",function(e){e=e.target;400<=e.status?n(e):(e=B[i]={content:e.response,opt:{updatedAt:o.getResponseHeader("last-modified")}},t(e.content,e.opt))})},abort:function(e){return 4!==o.readyState&&o.abort()}}}function G(e,t){e.innerHTML=e.innerHTML.replace(/var\(\s*--theme-color.*?\)/g,t)}function W(e,t,n,r){void 0===r&&(r=u);var i=e._hooks[t],a=function(t){var e=i[t];t>=i.length?r(n):"function"==typeof e?2===e.length?e(n,function(e){n=e,a(t+1)}):(e=e(n),n=void 0===e?n:e,a(t+1)):a(t+1)};a(0)}var V=m.title;function Y(){var e,t=g("section.cover");t&&(e=t.getBoundingClientRect().height,window.pageYOffset>=e||t.classList.contains("hidden")?A(v,"add","sticky"):A(v,"remove","sticky"))}function X(e,t,r,n){var i=[];null!=(t=g(t))&&(i=k(t,"a"));var a,o=decodeURI(e.toURL(e.getCurrentPath()));return i.sort(function(e,t){return t.href.length-e.href.length}).forEach(function(e){var t=decodeURI(e.getAttribute("href")),n=r?e.parentNode:e;e.title=e.title||e.innerText,0!==o.indexOf(t)||a?A(n,"remove","active"):(a=e,A(n,"add","active"))}),n&&(m.title=a?a.title||a.innerText+" - "+V:V),a}var K=decodeURIComponent,Q=encodeURIComponent;function J(e){var t={};return(e=e.trim().replace(/^(\?|#|&)/,""))&&e.split("&").forEach(function(e){e=e.replace(/\+/g," ").split("=");t[e[0]]=e[1]&&K(e[1])}),t}function ee(e,t){void 0===t&&(t=[]);var n,r=[];for(n in e)-1<t.indexOf(n)||r.push(e[n]?(Q(n)+"="+Q(e[n])).toLowerCase():Q(n));return r.length?"?"+r.join("&"):""}var te=s(function(e){return/(:|(\/{2}))/g.test(e)}),ne=s(function(e){return e.split(/[?#]/)[0]}),re=s(function(e){if(/\/$/g.test(e))return e;e=e.match(/(\S*\/)[^/]+$/);return e?e[1]:""}),ie=s(function(e){return e.replace(/^\/+/,"/").replace(/([^:])\/{2,}/g,"$1/")}),ae=s(function(e){for(var t=e.replace(/^\//,"").split("/"),n=[],r=0,i=t.length;r<i;r++){var a=t[r];".."===a?n.pop():"."!==a&&n.push(a)}return"/"+n.join("/")});function oe(e){return e.split("/").filter(function(e){return-1===e.indexOf("#")}).join("/")}function se(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];return ie(e.map(oe).join("/"))}var le=s(function(e){return e.replace("#","?id=")});function ce(e,t){return-1!==e.indexOf(t,e.length-t.length)}function ue(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}var pe=(function(e,t,n){return t&&ue(e.prototype,t),n&&ue(e,n),e}(de,[{key:"getIntermediateValue",value:function(e){return this.decimal?e:Math.round(e)}},{key:"getFinalValue",value:function(){return this.end}}]),de);function de(){var e=0<arguments.length&&void 0!==arguments[0]?arguments[0]:{};!function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,de),this.start=e.start,this.end=e.end,this.decimal=e.decimal}function he(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}var fe=(function(e,t,n){return t&&he(e.prototype,t),n&&he(e,n),e}(ge,[{key:"begin",value:function(){return this.isRunning||this.next===this.end||(this.frame=window.requestAnimationFrame(this._tick.bind(this))),this}},{key:"stop",value:function(){return window.cancelAnimationFrame(this.frame),this.isRunning=!1,this.frame=null,this.timeStart=null,this.next=null,this}},{key:"on",value:function(e,t){return this.events[e]=this.events[e]||[],this.events[e].push(t),this}},{key:"_emit",value:function(e,t){var n=this,e=this.events[e];e&&e.forEach(function(e){return e.call(n,t)})}},{key:"_tick",value:function(e){this.isRunning=!0;var t=this.next||this.start;this.timeStart||(this.timeStart=e),this.timeElapsed=e-this.timeStart,this.next=this.ease(this.timeElapsed,this.start,this.end-this.start,this.duration),this._shouldTick(t)?(this._emit("tick",this.tweener.getIntermediateValue(this.next)),this.frame=window.requestAnimationFrame(this._tick.bind(this))):(this._emit("tick",this.tweener.getFinalValue()),this._emit("done",null))}},{key:"_shouldTick",value:function(e){return{up:this.next<this.end&&e<=this.next,down:this.next>this.end&&e>=this.next}[this.direction]}},{key:"_defaultEase",value:function(e,t,n,r){return(e/=r/2)<1?n/2*e*e+t:-n/2*(--e*(e-2)-1)+t}}]),ge);function ge(){var e=0<arguments.length&&void 0!==arguments[0]?arguments[0]:{};!function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,ge),this.duration=e.duration||1e3,this.ease=e.easing||this._defaultEase,this.tweener=e.tweener||new pe(e),this.start=this.tweener.start,this.end=this.tweener.end,this.frame=null,this.next=null,this.isRunning=!1,this.events={},this.direction=this.start<this.end?"up":"down"}var me={},ve=!1,be=null,ye=!0,ke=0;function we(e){if(ye){for(var t,n,r=g(".sidebar"),i=k(".anchor"),a=y(r,".sidebar-nav"),o=y(r,"li.active"),s=document.documentElement,l=(s&&s.scrollTop||document.body.scrollTop)-ke,c=0,u=i.length;c<u;c+=1){var p=i[c];if(p.offsetTop>l){t=t||p;break}t=p}!t||(n=me[xe(e,t.getAttribute("data-id"))])&&n!==o&&(o&&o.classList.remove("active"),n.classList.add("active"),o=n,!ve&&v.classList.contains("sticky")&&(s=r.clientHeight,e=o.offsetTop+o.clientHeight+40,n=o.offsetTop>=a.scrollTop&&e<=a.scrollTop+s,o=+e<s,r.scrollTop=n?a.scrollTop:o?0:e-s))}}function xe(e,t){return decodeURIComponent(e)+"?id="+decodeURIComponent(t)}function _e(e,t){var n,r;t&&(r=E().topMargin,(n=y("#"+t))&&(n=n,void 0===(r=r)&&(r=0),be&&be.stop(),ye=!1,be=new fe({start:window.pageYOffset,end:Math.round(n.getBoundingClientRect().top)+window.pageYOffset-r,duration:500}).on("tick",function(e){return window.scrollTo(0,e)}).on("done",function(){ye=!0,be=null}).begin()),e=me[xe(e,t)],(t=y(g(".sidebar"),"li.active"))&&t.classList.remove("active"),e&&e.classList.add("active"))}var Se=m.scrollingElement||m.documentElement;var Ae="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{};function Te(e,t){return e(t={exports:{}},t.exports),t.exports}function Ee(e){return gt[e]}var ut=Te(function(t){function e(){return{baseUrl:null,breaks:!1,gfm:!0,headerIds:!0,headerPrefix:"",highlight:null,langPrefix:"language-",mangle:!0,pedantic:!1,renderer:null,sanitize:!1,sanitizer:null,silent:!1,smartLists:!1,smartypants:!1,tokenizer:null,walkTokens:null,xhtml:!1}}t.exports={defaults:e(),getDefaults:e,changeDefaults:function(e){t.exports.defaults=e}}}),pt=(ut.defaults,ut.getDefaults,ut.changeDefaults,/[&<>"']/),dt=/[&<>"']/g,ht=/[<>"']|&(?!#?\w+;)/,ft=/[<>"']|&(?!#?\w+;)/g,gt={"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"};var mt=/&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/gi;function vt(e){return e.replace(mt,function(e,t){return"colon"===(t=t.toLowerCase())?":":"#"===t.charAt(0)?"x"===t.charAt(1)?String.fromCharCode(parseInt(t.substring(2),16)):String.fromCharCode(+t.substring(1)):""})}var bt=/(^|[^\[])\^/g;var yt=/[^\w:]/g,kt=/^$|^[a-z][a-z0-9+.-]*:|^[?#]/i;var wt={},xt=/^[^:]+:\/*[^/]*$/,_t=/^([^:]+:)[\s\S]*$/,St=/^([^:]+:\/*[^/]*)[\s\S]*$/;function At(e,t){wt[" "+e]||(xt.test(e)?wt[" "+e]=e+"/":wt[" "+e]=Tt(e,"/",!0));var n=-1===(e=wt[" "+e]).indexOf(":");return"//"===t.substring(0,2)?n?t:e.replace(_t,"$1")+t:"/"===t.charAt(0)?n?t:e.replace(St,"$1")+t:e+t}function Tt(e,t,n){var r=e.length;if(0===r)return"";for(var i=0;i<r;){var a=e.charAt(r-i-1);if(a!==t||n){if(a===t||!n)break;i++}else i++}return e.substr(0,r-i)}var Et=function(e,t){if(t){if(pt.test(e))return e.replace(dt,Ee)}else if(ht.test(e))return e.replace(ft,Ee);return e},Rt=vt,$t=function(n,e){n=n.source||n,e=e||"";var r={replace:function(e,t){return t=(t=t.source||t).replace(bt,"$1"),n=n.replace(e,t),r},getRegex:function(){return new RegExp(n,e)}};return r},Ot=function(e,t,n){if(e){var r;try{r=decodeURIComponent(vt(n)).replace(yt,"").toLowerCase()}catch(e){return null}if(0===r.indexOf("javascript:")||0===r.indexOf("vbscript:")||0===r.indexOf("data:"))return null}t&&!kt.test(n)&&(n=At(t,n));try{n=encodeURI(n).replace(/%25/g,"%")}catch(e){return null}return n},Ct={exec:function(){}},Lt=function(e){for(var t,n,r=arguments,i=1;i<arguments.length;i++)for(n in t=r[i])Object.prototype.hasOwnProperty.call(t,n)&&(e[n]=t[n]);return e},Ft=function(e,t){var n=e.replace(/\|/g,function(e,t,n){for(var r=!1,i=t;0<=--i&&"\\"===n[i];)r=!r;return r?"|":" |"}).split(/ \|/),r=0;if(n.length>t)n.splice(t);else for(;n.length<t;)n.push("");for(;r<n.length;r++)n[r]=n[r].trim().replace(/\\\|/g,"|");return n},zt=function(e,t){if(-1===e.indexOf(t[1]))return-1;for(var n=e.length,r=0,i=0;i<n;i++)if("\\"===e[i])i++;else if(e[i]===t[0])r++;else if(e[i]===t[1]&&--r<0)return i;return-1},N=function(e){e&&e.sanitize&&!e.silent&&console.warn("marked(): sanitize and sanitizer parameters are deprecated since version 0.7.0, should not be used and will be removed in the future. Read more here: https://marked.js.org/#/USING_ADVANCED.md#options")},z=function(e,t){if(t<1)return"";for(var n="";1<t;)1&t&&(n+=e),t>>=1,e+=e;return n+e},Mt=ut.defaults,Nt=Tt,Pt=Ft,Dt=Et,It=zt;function jt(e,t,n){var r=t.href,i=t.title?Dt(t.title):null,t=e[1].replace(/\\([\[\]])/g,"$1");return"!"!==e[0].charAt(0)?{type:"link",raw:n,href:r,title:i,text:t}:{type:"image",raw:n,href:r,title:i,text:Dt(t)}}var qt=function(){function e(e){this.options=e||Mt}return e.prototype.space=function(e){e=this.rules.block.newline.exec(e);if(e)return 1<e[0].length?{type:"space",raw:e[0]}:{raw:"\n"}},e.prototype.code=function(e,t){e=this.rules.block.code.exec(e);if(e){t=t[t.length-1];if(t&&"paragraph"===t.type)return{raw:e[0],text:e[0].trimRight()};t=e[0].replace(/^ {1,4}/gm,"");return{type:"code",raw:e[0],codeBlockStyle:"indented",text:this.options.pedantic?t:Nt(t,"\n")}}},e.prototype.fences=function(e){var t=this.rules.block.fences.exec(e);if(t){var n=t[0],e=function(e,t){if(null===(e=e.match(/^(\s+)(?:```)/)))return t;var n=e[1];return t.split("\n").map(function(e){var t=e.match(/^\s+/);return null!==t&&t[0].length>=n.length?e.slice(n.length):e}).join("\n")}(n,t[3]||"");return{type:"code",raw:n,lang:t[2]?t[2].trim():t[2],text:e}}},e.prototype.heading=function(e){var t=this.rules.block.heading.exec(e);if(t){var n=t[2].trim();return/#$/.test(n)&&(e=Nt(n,"#"),!this.options.pedantic&&e&&!/ $/.test(e)||(n=e.trim())),{type:"heading",raw:t[0],depth:t[1].length,text:n}}},e.prototype.nptable=function(e){e=this.rules.block.nptable.exec(e);if(e){var t={type:"table",header:Pt(e[1].replace(/^ *| *\| *$/g,"")),align:e[2].replace(/^ *|\| *$/g,"").split(/ *\| */),cells:e[3]?e[3].replace(/\n$/,"").split("\n"):[],raw:e[0]};if(t.header.length===t.align.length){for(var n=t.align.length,r=0;r<n;r++)/^ *-+: *$/.test(t.align[r])?t.align[r]="right":/^ *:-+: *$/.test(t.align[r])?t.align[r]="center":/^ *:-+ *$/.test(t.align[r])?t.align[r]="left":t.align[r]=null;for(n=t.cells.length,r=0;r<n;r++)t.cells[r]=Pt(t.cells[r],t.header.length);return t}}},e.prototype.hr=function(e){e=this.rules.block.hr.exec(e);if(e)return{type:"hr",raw:e[0]}},e.prototype.blockquote=function(e){var t=this.rules.block.blockquote.exec(e);if(t){e=t[0].replace(/^ *> ?/gm,"");return{type:"blockquote",raw:t[0],text:e}}},e.prototype.list=function(e){e=this.rules.block.list.exec(e);if(e){for(var t,n,r,i,a,o=e[0],s=e[2],l=1<s.length,c={type:"list",raw:o,ordered:l,start:l?+s.slice(0,-1):"",loose:!1,items:[]},u=e[0].match(this.rules.block.item),p=!1,d=u.length,h=this.rules.block.listItemStart.exec(u[0]),f=0;f<d;f++){if(o=t=u[f],f!==d-1){if(r=this.rules.block.listItemStart.exec(u[f+1]),this.options.pedantic?r[1].length>h[1].length:r[1].length>h[0].length||3<r[1].length){u.splice(f,2,u[f]+"\n"+u[f+1]),f--,d--;continue}(!this.options.pedantic||this.options.smartLists?r[2][r[2].length-1]!==s[s.length-1]:l==(1===r[2].length))&&(n=u.slice(f+1).join("\n"),c.raw=c.raw.substring(0,c.raw.length-n.length),f=d-1),h=r}r=t.length,~(t=t.replace(/^ *([*+-]|\d+[.)]) ?/,"")).indexOf("\n ")&&(r-=t.length,t=this.options.pedantic?t.replace(/^ {1,4}/gm,""):t.replace(new RegExp("^ {1,"+r+"}","gm"),"")),r=p||/\n\n(?!\s*$)/.test(t),f!==d-1&&(p="\n"===t.charAt(t.length-1),r=r||p),r&&(c.loose=!0),this.options.gfm&&(a=void 0,(i=/^\[[ xX]\] /.test(t))&&(a=" "!==t[1],t=t.replace(/^\[[ xX]\] +/,""))),c.items.push({type:"list_item",raw:o,task:i,checked:a,loose:r,text:t})}return c}},e.prototype.html=function(e){e=this.rules.block.html.exec(e);if(e)return{type:this.options.sanitize?"paragraph":"html",raw:e[0],pre:!this.options.sanitizer&&("pre"===e[1]||"script"===e[1]||"style"===e[1]),text:this.options.sanitize?this.options.sanitizer?this.options.sanitizer(e[0]):Dt(e[0]):e[0]}},e.prototype.def=function(e){e=this.rules.block.def.exec(e);if(e)return e[3]&&(e[3]=e[3].substring(1,e[3].length-1)),{tag:e[1].toLowerCase().replace(/\s+/g," "),raw:e[0],href:e[2],title:e[3]}},e.prototype.table=function(e){e=this.rules.block.table.exec(e);if(e){var t={type:"table",header:Pt(e[1].replace(/^ *| *\| *$/g,"")),align:e[2].replace(/^ *|\| *$/g,"").split(/ *\| */),cells:e[3]?e[3].replace(/\n$/,"").split("\n"):[]};if(t.header.length===t.align.length){t.raw=e[0];for(var n=t.align.length,r=0;r<n;r++)/^ *-+: *$/.test(t.align[r])?t.align[r]="right":/^ *:-+: *$/.test(t.align[r])?t.align[r]="center":/^ *:-+ *$/.test(t.align[r])?t.align[r]="left":t.align[r]=null;for(n=t.cells.length,r=0;r<n;r++)t.cells[r]=Pt(t.cells[r].replace(/^ *\| *| *\| *$/g,""),t.header.length);return t}}},e.prototype.lheading=function(e){e=this.rules.block.lheading.exec(e);if(e)return{type:"heading",raw:e[0],depth:"="===e[2].charAt(0)?1:2,text:e[1]}},e.prototype.paragraph=function(e){e=this.rules.block.paragraph.exec(e);if(e)return{type:"paragraph",raw:e[0],text:"\n"===e[1].charAt(e[1].length-1)?e[1].slice(0,-1):e[1]}},e.prototype.text=function(e,t){e=this.rules.block.text.exec(e);if(e){t=t[t.length-1];return t&&"text"===t.type?{raw:e[0],text:e[0]}:{type:"text",raw:e[0],text:e[0]}}},e.prototype.escape=function(e){e=this.rules.inline.escape.exec(e);if(e)return{type:"escape",raw:e[0],text:Dt(e[1])}},e.prototype.tag=function(e,t,n){e=this.rules.inline.tag.exec(e);if(e)return!t&&/^<a /i.test(e[0])?t=!0:t&&/^<\/a>/i.test(e[0])&&(t=!1),!n&&/^<(pre|code|kbd|script)(\s|>)/i.test(e[0])?n=!0:n&&/^<\/(pre|code|kbd|script)(\s|>)/i.test(e[0])&&(n=!1),{type:this.options.sanitize?"text":"html",raw:e[0],inLink:t,inRawBlock:n,text:this.options.sanitize?this.options.sanitizer?this.options.sanitizer(e[0]):Dt(e[0]):e[0]}},e.prototype.link=function(e){var t=this.rules.inline.link.exec(e);if(t){var n=t[2].trim();if(!this.options.pedantic&&/^</.test(n)){if(!/>$/.test(n))return;e=Nt(n.slice(0,-1),"\\");if((n.length-e.length)%2==0)return}else{var r=It(t[2],"()");-1<r&&(a=(0===t[0].indexOf("!")?5:4)+t[1].length+r,t[2]=t[2].substring(0,r),t[0]=t[0].substring(0,a).trim(),t[3]="")}var i,r=t[2],a="";return this.options.pedantic?(i=/^([^'"]*[^\s])\s+(['"])(.*)\2/.exec(r),i&&(r=i[1],a=i[3])):a=t[3]?t[3].slice(1,-1):"",r=r.trim(),/^</.test(r)&&(r=this.options.pedantic&&!/>$/.test(n)?r.slice(1):r.slice(1,-1)),jt(t,{href:r?r.replace(this.rules.inline._escapes,"$1"):r,title:a?a.replace(this.rules.inline._escapes,"$1"):a},t[0])}},e.prototype.reflink=function(e,t){if((n=this.rules.inline.reflink.exec(e))||(n=this.rules.inline.nolink.exec(e))){e=(n[2]||n[1]).replace(/\s+/g," ");if((e=t[e.toLowerCase()])&&e.href)return jt(n,e,n[0]);var n=n[0].charAt(0);return{type:"text",raw:n,text:n}}},e.prototype.strong=function(e,t,n){void 0===n&&(n="");var r=this.rules.inline.strong.start.exec(e);if(r&&(!r[1]||r[1]&&(""===n||this.rules.inline.punctuation.exec(n)))){t=t.slice(-1*e.length);var i,a="**"===r[0]?this.rules.inline.strong.endAst:this.rules.inline.strong.endUnd;for(a.lastIndex=0;null!=(r=a.exec(t));)if(i=this.rules.inline.strong.middle.exec(t.slice(0,r.index+3)))return{type:"strong",raw:e.slice(0,i[0].length),text:e.slice(2,i[0].length-2)}}},e.prototype.em=function(e,t,n){void 0===n&&(n="");var r=this.rules.inline.em.start.exec(e);if(r&&(!r[1]||r[1]&&(""===n||this.rules.inline.punctuation.exec(n)))){t=t.slice(-1*e.length);var i,a="*"===r[0]?this.rules.inline.em.endAst:this.rules.inline.em.endUnd;for(a.lastIndex=0;null!=(r=a.exec(t));)if(i=this.rules.inline.em.middle.exec(t.slice(0,r.index+2)))return{type:"em",raw:e.slice(0,i[0].length),text:e.slice(1,i[0].length-1)}}},e.prototype.codespan=function(e){var t=this.rules.inline.code.exec(e);if(t){var n=t[2].replace(/\n/g," "),r=/[^ ]/.test(n),e=/^ /.test(n)&&/ $/.test(n);return r&&e&&(n=n.substring(1,n.length-1)),n=Dt(n,!0),{type:"codespan",raw:t[0],text:n}}},e.prototype.br=function(e){e=this.rules.inline.br.exec(e);if(e)return{type:"br",raw:e[0]}},e.prototype.del=function(e){e=this.rules.inline.del.exec(e);if(e)return{type:"del",raw:e[0],text:e[2]}},e.prototype.autolink=function(e,t){e=this.rules.inline.autolink.exec(e);if(e){var n,t="@"===e[2]?"mailto:"+(n=Dt(this.options.mangle?t(e[1]):e[1])):n=Dt(e[1]);return{type:"link",raw:e[0],text:n,href:t,tokens:[{type:"text",raw:n,text:n}]}}},e.prototype.url=function(e,t){var n,r,i,a;if(n=this.rules.inline.url.exec(e)){if("@"===n[2])i="mailto:"+(r=Dt(this.options.mangle?t(n[0]):n[0]));else{for(;a=n[0],n[0]=this.rules.inline._backpedal.exec(n[0])[0],a!==n[0];);r=Dt(n[0]),i="www."===n[1]?"http://"+r:r}return{type:"link",raw:n[0],text:r,href:i,tokens:[{type:"text",raw:r,text:r}]}}},e.prototype.inlineText=function(e,t,n){e=this.rules.inline.text.exec(e);if(e){n=t?this.options.sanitize?this.options.sanitizer?this.options.sanitizer(e[0]):Dt(e[0]):e[0]:Dt(this.options.smartypants?n(e[0]):e[0]);return{type:"text",raw:e[0],text:n}}},e}(),Ft=Ct,zt=$t,Ct=Lt,$t={newline:/^(?: *(?:\n|$))+/,code:/^( {4}[^\n]+(?:\n(?: *(?:\n|$))*)?)+/,fences:/^ {0,3}(`{3,}(?=[^`\n]*\n)|~{3,})([^\n]*)\n(?:|([\s\S]*?)\n)(?: {0,3}\1[~`]* *(?:\n+|$)|$)/,hr:/^ {0,3}((?:- *){3,}|(?:_ *){3,}|(?:\* *){3,})(?:\n+|$)/,heading:/^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/,blockquote:/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/,list:/^( {0,3})(bull) [\s\S]+?(?:hr|def|\n{2,}(?! )(?! {0,3}bull )\n*|\s*$)/,html:"^ {0,3}(?:<(script|pre|style)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>\\n*|$)|<![A-Z][\\s\\S]*?(?:>\\n*|$)|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:\\n{2,}|$)|<(?!script|pre|style)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:\\n{2,}|$)|</(?!script|pre|style)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:\\n{2,}|$))",def:/^ {0,3}\[(label)\]: *\n? *<?([^\s>]+)>?(?:(?: +\n? *| *\n *)(title))? *(?:\n+|$)/,nptable:Ft,table:Ft,lheading:/^([^\n]+)\n {0,3}(=+|-+) *(?:\n+|$)/,_paragraph:/^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html| +\n)[^\n]+)*)/,text:/^[^\n]+/,_label:/(?!\s*\])(?:\\[\[\]]|[^\[\]])+/,_title:/(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/};$t.def=zt($t.def).replace("label",$t._label).replace("title",$t._title).getRegex(),$t.bullet=/(?:[*+-]|\d{1,9}[.)])/,$t.item=/^( *)(bull) ?[^\n]*(?:\n(?! *bull ?)[^\n]*)*/,$t.item=zt($t.item,"gm").replace(/bull/g,$t.bullet).getRegex(),$t.listItemStart=zt(/^( *)(bull)/).replace("bull",$t.bullet).getRegex(),$t.list=zt($t.list).replace(/bull/g,$t.bullet).replace("hr","\\n+(?=\\1?(?:(?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$))").replace("def","\\n+(?="+$t.def.source+")").getRegex(),$t._tag="address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul",$t._comment=/<!--(?!-?>)[\s\S]*?(?:-->|$)/,$t.html=zt($t.html,"i").replace("comment",$t._comment).replace("tag",$t._tag).replace("attribute",/ +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex(),$t.paragraph=zt($t._paragraph).replace("hr",$t.hr).replace("heading"," {0,3}#{1,6} ").replace("|lheading","").replace("blockquote"," {0,3}>").replace("fences"," {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list"," {0,3}(?:[*+-]|1[.)]) ").replace("html","</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|!--)").replace("tag",$t._tag).getRegex(),$t.blockquote=zt($t.blockquote).replace("paragraph",$t.paragraph).getRegex(),$t.normal=Ct({},$t),$t.gfm=Ct({},$t.normal,{nptable:"^ *([^|\\n ].*\\|.*)\\n {0,3}([-:]+ *\\|[-| :]*)(?:\\n((?:(?!\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)",table:"^ *\\|(.+)\\n {0,3}\\|?( *[-:]+[-| :]*)(?:\\n *((?:(?!\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)"}),$t.gfm.nptable=zt($t.gfm.nptable).replace("hr",$t.hr).replace("heading"," {0,3}#{1,6} ").replace("blockquote"," {0,3}>").replace("code"," {4}[^\\n]").replace("fences"," {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list"," {0,3}(?:[*+-]|1[.)]) ").replace("html","</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|!--)").replace("tag",$t._tag).getRegex(),$t.gfm.table=zt($t.gfm.table).replace("hr",$t.hr).replace("heading"," {0,3}#{1,6} ").replace("blockquote"," {0,3}>").replace("code"," {4}[^\\n]").replace("fences"," {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list"," {0,3}(?:[*+-]|1[.)]) ").replace("html","</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|!--)").replace("tag",$t._tag).getRegex(),$t.pedantic=Ct({},$t.normal,{html:zt("^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)|<tag(?:\"[^\"]*\"|'[^']*'|\\s[^'\"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))").replace("comment",$t._comment).replace(/tag/g,"(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(),def:/^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/,heading:/^(#{1,6})(.*)(?:\n+|$)/,fences:Ft,paragraph:zt($t.normal._paragraph).replace("hr",$t.hr).replace("heading"," *#{1,6} *[^\n]").replace("lheading",$t.lheading).replace("blockquote"," {0,3}>").replace("|fences","").replace("|list","").replace("|html","").getRegex()});Ft={escape:/^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/,autolink:/^<(scheme:[^\s\x00-\x1f<>]*|email)>/,url:Ft,tag:"^comment|^</[a-zA-Z][\\w:-]*\\s*>|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^<![a-zA-Z]+\\s[\\s\\S]*?>|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>",link:/^!?\[(label)\]\(\s*(href)(?:\s+(title))?\s*\)/,reflink:/^!?\[(label)\]\[(?!\s*\])((?:\\[\[\]]?|[^\[\]\\])+)\]/,nolink:/^!?\[(?!\s*\])((?:\[[^\[\]]*\]|\\[\[\]]|[^\[\]])*)\](?:\[\])?/,reflinkSearch:"reflink|nolink(?!\\()",strong:{start:/^(?:(\*\*(?=[*punctuation]))|\*\*)(?![\s])|__/,middle:/^\*\*(?:(?:(?!overlapSkip)(?:[^*]|\\\*)|overlapSkip)|\*(?:(?!overlapSkip)(?:[^*]|\\\*)|overlapSkip)*?\*)+?\*\*$|^__(?![\s])((?:(?:(?!overlapSkip)(?:[^_]|\\_)|overlapSkip)|_(?:(?!overlapSkip)(?:[^_]|\\_)|overlapSkip)*?_)+?)__$/,endAst:/[^punctuation\s]\*\*(?!\*)|[punctuation]\*\*(?!\*)(?:(?=[punctuation_\s]|$))/,endUnd:/[^\s]__(?!_)(?:(?=[punctuation*\s])|$)/},em:{start:/^(?:(\*(?=[punctuation]))|\*)(?![*\s])|_/,middle:/^\*(?:(?:(?!overlapSkip)(?:[^*]|\\\*)|overlapSkip)|\*(?:(?!overlapSkip)(?:[^*]|\\\*)|overlapSkip)*?\*)+?\*$|^_(?![_\s])(?:(?:(?!overlapSkip)(?:[^_]|\\_)|overlapSkip)|_(?:(?!overlapSkip)(?:[^_]|\\_)|overlapSkip)*?_)+?_$/,endAst:/[^punctuation\s]\*(?!\*)|[punctuation]\*(?!\*)(?:(?=[punctuation_\s]|$))/,endUnd:/[^\s]_(?!_)(?:(?=[punctuation*\s])|$)/},code:/^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/,br:/^( {2,}|\\)\n(?!\s*$)/,del:Ft,text:/^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*]|\b_|$)|[^ ](?= {2,}\n)))/,punctuation:/^([\s*punctuation])/,_punctuation:"!\"#$%&'()+\\-.,/:;<=>?@\\[\\]`^{|}~"};Ft.punctuation=zt(Ft.punctuation).replace(/punctuation/g,Ft._punctuation).getRegex(),Ft._blockSkip="\\[[^\\]]*?\\]\\([^\\)]*?\\)|`[^`]*?`|<[^>]*?>",Ft._overlapSkip="__[^_]*?__|\\*\\*\\[^\\*\\]*?\\*\\*",Ft._comment=zt($t._comment).replace("(?:--\x3e|$)","--\x3e").getRegex(),Ft.em.start=zt(Ft.em.start).replace(/punctuation/g,Ft._punctuation).getRegex(),Ft.em.middle=zt(Ft.em.middle).replace(/punctuation/g,Ft._punctuation).replace(/overlapSkip/g,Ft._overlapSkip).getRegex(),Ft.em.endAst=zt(Ft.em.endAst,"g").replace(/punctuation/g,Ft._punctuation).getRegex(),Ft.em.endUnd=zt(Ft.em.endUnd,"g").replace(/punctuation/g,Ft._punctuation).getRegex(),Ft.strong.start=zt(Ft.strong.start).replace(/punctuation/g,Ft._punctuation).getRegex(),Ft.strong.middle=zt(Ft.strong.middle).replace(/punctuation/g,Ft._punctuation).replace(/overlapSkip/g,Ft._overlapSkip).getRegex(),Ft.strong.endAst=zt(Ft.strong.endAst,"g").replace(/punctuation/g,Ft._punctuation).getRegex(),Ft.strong.endUnd=zt(Ft.strong.endUnd,"g").replace(/punctuation/g,Ft._punctuation).getRegex(),Ft.blockSkip=zt(Ft._blockSkip,"g").getRegex(),Ft.overlapSkip=zt(Ft._overlapSkip,"g").getRegex(),Ft._escapes=/\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/g,Ft._scheme=/[a-zA-Z][a-zA-Z0-9+.-]{1,31}/,Ft._email=/[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/,Ft.autolink=zt(Ft.autolink).replace("scheme",Ft._scheme).replace("email",Ft._email).getRegex(),Ft._attribute=/\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/,Ft.tag=zt(Ft.tag).replace("comment",Ft._comment).replace("attribute",Ft._attribute).getRegex(),Ft._label=/(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/,Ft._href=/<(?:\\.|[^\n<>\\])+>|[^\s\x00-\x1f]*/,Ft._title=/"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/,Ft.link=zt(Ft.link).replace("label",Ft._label).replace("href",Ft._href).replace("title",Ft._title).getRegex(),Ft.reflink=zt(Ft.reflink).replace("label",Ft._label).getRegex(),Ft.reflinkSearch=zt(Ft.reflinkSearch,"g").replace("reflink",Ft.reflink).replace("nolink",Ft.nolink).getRegex(),Ft.normal=Ct({},Ft),Ft.pedantic=Ct({},Ft.normal,{strong:{start:/^__|\*\*/,middle:/^__(?=\S)([\s\S]*?\S)__(?!_)|^\*\*(?=\S)([\s\S]*?\S)\*\*(?!\*)/,endAst:/\*\*(?!\*)/g,endUnd:/__(?!_)/g},em:{start:/^_|\*/,middle:/^()\*(?=\S)([\s\S]*?\S)\*(?!\*)|^_(?=\S)([\s\S]*?\S)_(?!_)/,endAst:/\*(?!\*)/g,endUnd:/_(?!_)/g},link:zt(/^!?\[(label)\]\((.*?)\)/).replace("label",Ft._label).getRegex(),reflink:zt(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label",Ft._label).getRegex()}),Ft.gfm=Ct({},Ft.normal,{escape:zt(Ft.escape).replace("])","~|])").getRegex(),_extended_email:/[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/,url:/^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/,_backpedal:/(?:[^?!.,:;*_~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_~)]+(?!$))+/,del:/^(~~?)(?=[^\s~])([\s\S]*?[^\s~])\1(?=[^~]|$)/,text:/^([`~]+|[^`~])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*~]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@))|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@))/}),Ft.gfm.url=zt(Ft.gfm.url,"i").replace("email",Ft.gfm._extended_email).getRegex(),Ft.breaks=Ct({},Ft.gfm,{br:zt(Ft.br).replace("{2,}","*").getRegex(),text:zt(Ft.gfm.text).replace("\\b_","\\b_| {2,}\\n").replace(/\{2,\}/g,"*").getRegex()});var Ft={block:$t,inline:Ft},Ht=ut.defaults,Ut=Ft.block,Bt=Ft.inline,Zt=z;function Gt(e){return e.replace(/---/g,"—").replace(/--/g,"–").replace(/(^|[-\u2014/(\[{"\s])'/g,"$1‘").replace(/'/g,"’").replace(/(^|[-\u2014/(\[{\u2018\s])"/g,"$1“").replace(/"/g,"”").replace(/\.{3}/g,"…")}function Wt(e){for(var t,n="",r=e.length,i=0;i<r;i++)t=e.charCodeAt(i),.5<Math.random()&&(t="x"+t.toString(16)),n+="&#"+t+";";return n}var Vt=function(){function n(e){this.tokens=[],this.tokens.links=Object.create(null),this.options=e||Ht,this.options.tokenizer=this.options.tokenizer||new qt,this.tokenizer=this.options.tokenizer,this.tokenizer.options=this.options;e={block:Ut.normal,inline:Bt.normal};this.options.pedantic?(e.block=Ut.pedantic,e.inline=Bt.pedantic):this.options.gfm&&(e.block=Ut.gfm,this.options.breaks?e.inline=Bt.breaks:e.inline=Bt.gfm),this.tokenizer.rules=e}var e={rules:{configurable:!0}};return e.rules.get=function(){return{block:Ut,inline:Bt}},n.lex=function(e,t){return new n(t).lex(e)},n.lexInline=function(e,t){return new n(t).inlineTokens(e)},n.prototype.lex=function(e){return e=e.replace(/\r\n|\r/g,"\n").replace(/\t/g,"    "),this.blockTokens(e,this.tokens,!0),this.inline(this.tokens),this.tokens},n.prototype.blockTokens=function(e,t,n){var r,i,a,o;for(void 0===t&&(t=[]),void 0===n&&(n=!0),this.options.pedantic&&(e=e.replace(/^ +$/gm,""));e;)if(r=this.tokenizer.space(e))e=e.substring(r.raw.length),r.type&&t.push(r);else if(r=this.tokenizer.code(e,t))e=e.substring(r.raw.length),r.type?t.push(r):((o=t[t.length-1]).raw+="\n"+r.raw,o.text+="\n"+r.text);else if(r=this.tokenizer.fences(e))e=e.substring(r.raw.length),t.push(r);else if(r=this.tokenizer.heading(e))e=e.substring(r.raw.length),t.push(r);else if(r=this.tokenizer.nptable(e))e=e.substring(r.raw.length),t.push(r);else if(r=this.tokenizer.hr(e))e=e.substring(r.raw.length),t.push(r);else if(r=this.tokenizer.blockquote(e))e=e.substring(r.raw.length),r.tokens=this.blockTokens(r.text,[],n),t.push(r);else if(r=this.tokenizer.list(e)){for(e=e.substring(r.raw.length),a=r.items.length,i=0;i<a;i++)r.items[i].tokens=this.blockTokens(r.items[i].text,[],!1);t.push(r)}else if(r=this.tokenizer.html(e))e=e.substring(r.raw.length),t.push(r);else if(n&&(r=this.tokenizer.def(e)))e=e.substring(r.raw.length),this.tokens.links[r.tag]||(this.tokens.links[r.tag]={href:r.href,title:r.title});else if(r=this.tokenizer.table(e))e=e.substring(r.raw.length),t.push(r);else if(r=this.tokenizer.lheading(e))e=e.substring(r.raw.length),t.push(r);else if(n&&(r=this.tokenizer.paragraph(e)))e=e.substring(r.raw.length),t.push(r);else if(r=this.tokenizer.text(e,t))e=e.substring(r.raw.length),r.type?t.push(r):((o=t[t.length-1]).raw+="\n"+r.raw,o.text+="\n"+r.text);else if(e){var s="Infinite loop on byte: "+e.charCodeAt(0);if(this.options.silent){console.error(s);break}throw new Error(s)}return t},n.prototype.inline=function(e){for(var t,n,r,i,a,o=e.length,s=0;s<o;s++)switch((a=e[s]).type){case"paragraph":case"text":case"heading":a.tokens=[],this.inlineTokens(a.text,a.tokens);break;case"table":for(a.tokens={header:[],cells:[]},r=a.header.length,t=0;t<r;t++)a.tokens.header[t]=[],this.inlineTokens(a.header[t],a.tokens.header[t]);for(r=a.cells.length,t=0;t<r;t++)for(i=a.cells[t],a.tokens.cells[t]=[],n=0;n<i.length;n++)a.tokens.cells[t][n]=[],this.inlineTokens(i[n],a.tokens.cells[t][n]);break;case"blockquote":this.inline(a.tokens);break;case"list":for(r=a.items.length,t=0;t<r;t++)this.inline(a.items[t].tokens)}return e},n.prototype.inlineTokens=function(e,t,n,r){var i;void 0===t&&(t=[]),void 0===n&&(n=!1),void 0===r&&(r=!1);var a,o,s,l=e;if(this.tokens.links){var c=Object.keys(this.tokens.links);if(0<c.length)for(;null!=(a=this.tokenizer.rules.inline.reflinkSearch.exec(l));)c.includes(a[0].slice(a[0].lastIndexOf("[")+1,-1))&&(l=l.slice(0,a.index)+"["+Zt("a",a[0].length-2)+"]"+l.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex))}for(;null!=(a=this.tokenizer.rules.inline.blockSkip.exec(l));)l=l.slice(0,a.index)+"["+Zt("a",a[0].length-2)+"]"+l.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);for(;e;)if(o||(s=""),o=!1,i=this.tokenizer.escape(e))e=e.substring(i.raw.length),t.push(i);else if(i=this.tokenizer.tag(e,n,r))e=e.substring(i.raw.length),n=i.inLink,r=i.inRawBlock,t.push(i);else if(i=this.tokenizer.link(e))e=e.substring(i.raw.length),"link"===i.type&&(i.tokens=this.inlineTokens(i.text,[],!0,r)),t.push(i);else if(i=this.tokenizer.reflink(e,this.tokens.links))e=e.substring(i.raw.length),"link"===i.type&&(i.tokens=this.inlineTokens(i.text,[],!0,r)),t.push(i);else if(i=this.tokenizer.strong(e,l,s))e=e.substring(i.raw.length),i.tokens=this.inlineTokens(i.text,[],n,r),t.push(i);else if(i=this.tokenizer.em(e,l,s))e=e.substring(i.raw.length),i.tokens=this.inlineTokens(i.text,[],n,r),t.push(i);else if(i=this.tokenizer.codespan(e))e=e.substring(i.raw.length),t.push(i);else if(i=this.tokenizer.br(e))e=e.substring(i.raw.length),t.push(i);else if(i=this.tokenizer.del(e))e=e.substring(i.raw.length),i.tokens=this.inlineTokens(i.text,[],n,r),t.push(i);else if(i=this.tokenizer.autolink(e,Wt))e=e.substring(i.raw.length),t.push(i);else if(n||!(i=this.tokenizer.url(e,Wt))){if(i=this.tokenizer.inlineText(e,r,Gt))e=e.substring(i.raw.length),s=i.raw.slice(-1),o=!0,t.push(i);else if(e){var u="Infinite loop on byte: "+e.charCodeAt(0);if(this.options.silent){console.error(u);break}throw new Error(u)}}else e=e.substring(i.raw.length),t.push(i);return t},Object.defineProperties(n,e),n}(),Yt=ut.defaults,Xt=Ot,Kt=Et,Qt=function(){function e(e){this.options=e||Yt}return e.prototype.code=function(e,t,n){var r=(t||"").match(/\S*/)[0];return!this.options.highlight||null!=(t=this.options.highlight(e,r))&&t!==e&&(n=!0,e=t),e=e.replace(/\n$/,"")+"\n",r?'<pre><code class="'+this.options.langPrefix+Kt(r,!0)+'">'+(n?e:Kt(e,!0))+"</code></pre>\n":"<pre><code>"+(n?e:Kt(e,!0))+"</code></pre>\n"},e.prototype.blockquote=function(e){return"<blockquote>\n"+e+"</blockquote>\n"},e.prototype.html=function(e){return e},e.prototype.heading=function(e,t,n,r){return this.options.headerIds?"<h"+t+' id="'+this.options.headerPrefix+r.slug(n)+'">'+e+"</h"+t+">\n":"<h"+t+">"+e+"</h"+t+">\n"},e.prototype.hr=function(){return this.options.xhtml?"<hr/>\n":"<hr>\n"},e.prototype.list=function(e,t,n){var r=t?"ol":"ul";return"<"+r+(t&&1!==n?' start="'+n+'"':"")+">\n"+e+"</"+r+">\n"},e.prototype.listitem=function(e){return"<li>"+e+"</li>\n"},e.prototype.checkbox=function(e){return"<input "+(e?'checked="" ':"")+'disabled="" type="checkbox"'+(this.options.xhtml?" /":"")+"> "},e.prototype.paragraph=function(e){return"<p>"+e+"</p>\n"},e.prototype.table=function(e,t){return"<table>\n<thead>\n"+e+"</thead>\n"+(t=t&&"<tbody>"+t+"</tbody>")+"</table>\n"},e.prototype.tablerow=function(e){return"<tr>\n"+e+"</tr>\n"},e.prototype.tablecell=function(e,t){var n=t.header?"th":"td";return(t.align?"<"+n+' align="'+t.align+'">':"<"+n+">")+e+"</"+n+">\n"},e.prototype.strong=function(e){return"<strong>"+e+"</strong>"},e.prototype.em=function(e){return"<em>"+e+"</em>"},e.prototype.codespan=function(e){return"<code>"+e+"</code>"},e.prototype.br=function(){return this.options.xhtml?"<br/>":"<br>"},e.prototype.del=function(e){return"<del>"+e+"</del>"},e.prototype.link=function(e,t,n){if(null===(e=Xt(this.options.sanitize,this.options.baseUrl,e)))return n;e='<a href="'+Kt(e)+'"';return t&&(e+=' title="'+t+'"'),e+=">"+n+"</a>"},e.prototype.image=function(e,t,n){if(null===(e=Xt(this.options.sanitize,this.options.baseUrl,e)))return n;n='<img src="'+e+'" alt="'+n+'"';return t&&(n+=' title="'+t+'"'),n+=this.options.xhtml?"/>":">"},e.prototype.text=function(e){return e},e}(),Jt=function(){function e(){}return e.prototype.strong=function(e){return e},e.prototype.em=function(e){return e},e.prototype.codespan=function(e){return e},e.prototype.del=function(e){return e},e.prototype.html=function(e){return e},e.prototype.text=function(e){return e},e.prototype.link=function(e,t,n){return""+n},e.prototype.image=function(e,t,n){return""+n},e.prototype.br=function(){return""},e}(),en=function(){function e(){this.seen={}}return e.prototype.serialize=function(e){return e.toLowerCase().trim().replace(/<[!\/a-z].*?>/gi,"").replace(/[\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&()*+,./:;<=>?@[\]^`{|}~]/g,"").replace(/\s/g,"-")},e.prototype.getNextSafeSlug=function(e,t){var n=e,r=0;if(this.seen.hasOwnProperty(n))for(r=this.seen[e];n=e+"-"+ ++r,this.seen.hasOwnProperty(n););return t||(this.seen[e]=r,this.seen[n]=0),n},e.prototype.slug=function(e,t){void 0===t&&(t={});var n=this.serialize(e);return this.getNextSafeSlug(n,t.dryrun)},e}(),tn=ut.defaults,nn=Rt,rn=function(){function n(e){this.options=e||tn,this.options.renderer=this.options.renderer||new Qt,this.renderer=this.options.renderer,this.renderer.options=this.options,this.textRenderer=new Jt,this.slugger=new en}return n.parse=function(e,t){return new n(t).parse(e)},n.parseInline=function(e,t){return new n(t).parseInline(e)},n.prototype.parse=function(e,t){void 0===t&&(t=!0);for(var n,r,i,a,o,s,l,c,u,p,d,h,f,g,m,v="",b=e.length,y=0;y<b;y++)switch((c=e[y]).type){case"space":continue;case"hr":v+=this.renderer.hr();continue;case"heading":v+=this.renderer.heading(this.parseInline(c.tokens),c.depth,nn(this.parseInline(c.tokens,this.textRenderer)),this.slugger);continue;case"code":v+=this.renderer.code(c.text,c.lang,c.escaped);continue;case"table":for(s=u="",i=c.header.length,n=0;n<i;n++)s+=this.renderer.tablecell(this.parseInline(c.tokens.header[n]),{header:!0,align:c.align[n]});for(u+=this.renderer.tablerow(s),l="",i=c.cells.length,n=0;n<i;n++){for(s="",a=(o=c.tokens.cells[n]).length,r=0;r<a;r++)s+=this.renderer.tablecell(this.parseInline(o[r]),{header:!1,align:c.align[r]});l+=this.renderer.tablerow(s)}v+=this.renderer.table(u,l);continue;case"blockquote":l=this.parse(c.tokens),v+=this.renderer.blockquote(l);continue;case"list":for(u=c.ordered,k=c.start,p=c.loose,i=c.items.length,l="",n=0;n<i;n++)f=(h=c.items[n]).checked,g=h.task,d="",h.task&&(m=this.renderer.checkbox(f),p?0<h.tokens.length&&"text"===h.tokens[0].type?(h.tokens[0].text=m+" "+h.tokens[0].text,h.tokens[0].tokens&&0<h.tokens[0].tokens.length&&"text"===h.tokens[0].tokens[0].type&&(h.tokens[0].tokens[0].text=m+" "+h.tokens[0].tokens[0].text)):h.tokens.unshift({type:"text",text:m}):d+=m),d+=this.parse(h.tokens,p),l+=this.renderer.listitem(d,g,f);v+=this.renderer.list(l,u,k);continue;case"html":v+=this.renderer.html(c.text);continue;case"paragraph":v+=this.renderer.paragraph(this.parseInline(c.tokens));continue;case"text":for(l=c.tokens?this.parseInline(c.tokens):c.text;y+1<b&&"text"===e[y+1].type;)l+="\n"+((c=e[++y]).tokens?this.parseInline(c.tokens):c.text);v+=t?this.renderer.paragraph(l):l;continue;default:var k='Token with "'+c.type+'" type was not found.';if(this.options.silent)return void console.error(k);throw new Error(k)}return v},n.prototype.parseInline=function(e,t){t=t||this.renderer;for(var n="",r=e.length,i=0;i<r;i++)switch((a=e[i]).type){case"escape":n+=t.text(a.text);break;case"html":n+=t.html(a.text);break;case"link":n+=t.link(a.href,a.title,this.parseInline(a.tokens,t));break;case"image":n+=t.image(a.href,a.title,a.text);break;case"strong":n+=t.strong(this.parseInline(a.tokens,t));break;case"em":n+=t.em(this.parseInline(a.tokens,t));break;case"codespan":n+=t.codespan(a.text);break;case"br":n+=t.br();break;case"del":n+=t.del(this.parseInline(a.tokens,t));break;case"text":n+=t.text(a.text);break;default:var a='Token with "'+a.type+'" type was not found.';if(this.options.silent)return void console.error(a);throw new Error(a)}return n},n}(),an=Lt,on=N,sn=Et,Et=ut.getDefaults,ln=ut.changeDefaults,ut=ut.defaults;function cn(e,n,r){if(null==e)throw new Error("marked(): input parameter is undefined or null");if("string"!=typeof e)throw new Error("marked(): input parameter is of type "+Object.prototype.toString.call(e)+", string expected");if("function"==typeof n&&(r=n,n=null),n=an({},cn.defaults,n||{}),on(n),r){var i,a=n.highlight;try{i=Vt.lex(e,n)}catch(e){return r(e)}function o(t){var e;if(!t)try{e=rn.parse(i,n)}catch(e){t=e}return n.highlight=a,t?r(t):r(null,e)}if(!a||a.length<3)return o();if(delete n.highlight,!i.length)return o();var s=0;return cn.walkTokens(i,function(n){"code"===n.type&&(s++,setTimeout(function(){a(n.text,n.lang,function(e,t){return e?o(e):(null!=t&&t!==n.text&&(n.text=t,n.escaped=!0),void(0===--s&&o()))})},0))}),void(0===s&&o())}try{var t=Vt.lex(e,n);return n.walkTokens&&cn.walkTokens(t,n.walkTokens),rn.parse(t,n)}catch(e){if(e.message+="\nPlease report this to https://github.com/markedjs/marked.",n.silent)return"<p>An error occurred:</p><pre>"+sn(e.message+"",!0)+"</pre>";throw e}}cn.options=cn.setOptions=function(e){return an(cn.defaults,e),ln(cn.defaults),cn},cn.getDefaults=Et,cn.defaults=ut,cn.use=function(a){var t,e=an({},a);if(a.renderer){var n,o=cn.defaults.renderer||new Qt;for(n in a.renderer)!function(r){var i=o[r];o[r]=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];var n=a.renderer[r].apply(o,e);return!1===n&&(n=i.apply(o,e)),n}}(n);e.renderer=o}if(a.tokenizer){var i,s=cn.defaults.tokenizer||new qt;for(i in a.tokenizer)!function(){var r=s[i];s[i]=function(){for(var e=[],t=arguments.length;t--;)e[t]=arguments[t];var n=a.tokenizer[i].apply(s,e);return!1===n&&(n=r.apply(s,e)),n}}();e.tokenizer=s}a.walkTokens&&(t=cn.defaults.walkTokens,e.walkTokens=function(e){a.walkTokens(e),t&&t(e)}),cn.setOptions(e)},cn.walkTokens=function(e,t){for(var n=0,r=e;n<r.length;n+=1){var i=r[n];switch(t(i),i.type){case"table":for(var a=0,o=i.tokens.header;a<o.length;a+=1){var s=o[a];cn.walkTokens(s,t)}for(var l=0,c=i.tokens.cells;l<c.length;l+=1)for(var u=0,p=c[l];u<p.length;u+=1){var d=p[u];cn.walkTokens(d,t)}break;case"list":cn.walkTokens(i.items,t);break;default:i.tokens&&cn.walkTokens(i.tokens,t)}}},cn.parseInline=function(e,t){if(null==e)throw new Error("marked.parseInline(): input parameter is undefined or null");if("string"!=typeof e)throw new Error("marked.parseInline(): input parameter is of type "+Object.prototype.toString.call(e)+", string expected");t=an({},cn.defaults,t||{}),on(t);try{var n=Vt.lexInline(e,t);return t.walkTokens&&cn.walkTokens(n,t.walkTokens),rn.parseInline(n,t)}catch(e){if(e.message+="\nPlease report this to https://github.com/markedjs/marked.",t.silent)return"<p>An error occurred:</p><pre>"+sn(e.message+"",!0)+"</pre>";throw e}},cn.Parser=rn,cn.parser=rn.parse,cn.Renderer=Qt,cn.TextRenderer=Jt,cn.Lexer=Vt,cn.lexer=Vt.lex,cn.Tokenizer=qt,cn.Slugger=en;var un=cn.parse=cn;function pn(e,n){if(void 0===n&&(n='<ul class="app-sub-sidebar">{inner}</ul>'),!e||!e.length)return"";var r="";return e.forEach(function(e){var t=e.title.replace(/(<([^>]+)>)/g,"");r+='<li><a class="section-link" href="'+e.slug+'" title="'+t+'">'+e.title+"</a></li>",e.children&&(r+=pn(e.children,n))}),n.replace("{inner}",r)}function dn(e,t){return'<p class="'+e+'">'+t.slice(5).trim()+"</p>"}function hn(e,r){var i=[],a={};return e.forEach(function(e){var t=e.level||1,n=t-1;r<t||(a[n]?a[n].children=(a[n].children||[]).concat(e):i.push(e),a[t]=e)}),i}var fn={},gn=/[\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&()*+,./:;<=>?@[\]^`{|}~]/g;function mn(e){return e.toLowerCase()}function vn(e){if("string"!=typeof e)return"";var t=e.trim().replace(/[A-Z]+/g,mn).replace(/<[^>]+>/g,"").replace(gn,"").replace(/\s/g,"-").replace(/-+/g,"-").replace(/^(\d)/,"_$1"),e=fn[t],e=l.call(fn,t)?e+1:0;return(fn[t]=e)&&(t=t+"-"+e),t}function bn(e,t){return'<img class="emoji" src="https://github.githubassets.com/images/icons/emoji/'+t+'.png" alt="'+t+'" />'}function yn(e){void 0===e&&(e="");var r={};return{str:e=e&&e.replace(/^'/,"").replace(/'$/,"").replace(/(?:^|\s):([\w-]+:?)=?([\w-%]+)?/g,function(e,t,n){return-1===t.indexOf(":")?(r[t]=n&&n.replace(/&quot;/g,"")||!0,""):e}).trim(),config:r}}function kn(e){return void 0===e&&(e=""),e.replace(/(<\/?a.*?>)/gi,"")}vn.clear=function(){fn={}};var wn,xn=Te(function(e){var o,s,l,c,u,r,t,i=function(l){var c=/\blang(?:uage)?-([\w-]+)\b/i,t=0,O={manual:l.Prism&&l.Prism.manual,disableWorkerMessageHandler:l.Prism&&l.Prism.disableWorkerMessageHandler,util:{encode:function e(t){return t instanceof C?new C(t.type,e(t.content),t.alias):Array.isArray(t)?t.map(e):t.replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/\u00a0/g," ")},type:function(e){return Object.prototype.toString.call(e).slice(8,-1)},objId:function(e){return e.__id||Object.defineProperty(e,"__id",{value:++t}),e.__id},clone:function n(e,r){var i,t;switch(r=r||{},O.util.type(e)){case"Object":if(t=O.util.objId(e),r[t])return r[t];for(var a in i={},r[t]=i,e)e.hasOwnProperty(a)&&(i[a]=n(e[a],r));return i;case"Array":return(t=O.util.objId(e),r[t])?r[t]:(i=[],r[t]=i,e.forEach(function(e,t){i[t]=n(e,r)}),i);default:return e}},getLanguage:function(e){for(;e&&!c.test(e.className);)e=e.parentElement;return e?(e.className.match(c)||[,"none"])[1].toLowerCase():"none"},currentScript:function(){if("undefined"==typeof document)return null;if("currentScript"in document)return document.currentScript;try{throw new Error}catch(e){var t=(/at [^(\r\n]*\((.*):.+:.+\)$/i.exec(e.stack)||[])[1];if(t){var n,r=document.getElementsByTagName("script");for(n in r)if(r[n].src==t)return r[n]}return null}},isActive:function(e,t,n){for(var r="no-"+t;e;){var i=e.classList;if(i.contains(t))return!0;if(i.contains(r))return!1;e=e.parentElement}return!!n}},languages:{extend:function(e,t){var n,r=O.util.clone(O.languages[e]);for(n in t)r[n]=t[n];return r},insertBefore:function(n,e,t,r){var i,a=(r=r||O.languages)[n],o={};for(i in a)if(a.hasOwnProperty(i)){if(i==e)for(var s in t)t.hasOwnProperty(s)&&(o[s]=t[s]);t.hasOwnProperty(i)||(o[i]=a[i])}var l=r[n];return r[n]=o,O.languages.DFS(O.languages,function(e,t){t===l&&e!=n&&(this[e]=o)}),o},DFS:function e(t,n,r,i){i=i||{};var a,o,s,l=O.util.objId;for(a in t){t.hasOwnProperty(a)&&(n.call(t,a,t[a],r||a),o=t[a],"Object"!==(s=O.util.type(o))||i[l(o)]?"Array"!==s||i[l(o)]||(i[l(o)]=!0,e(o,n,a,i)):(i[l(o)]=!0,e(o,n,null,i)))}}},plugins:{},highlightAll:function(e,t){O.highlightAllUnder(document,e,t)},highlightAllUnder:function(e,t,n){var r={callback:n,container:e,selector:'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code'};O.hooks.run("before-highlightall",r),r.elements=Array.prototype.slice.apply(r.container.querySelectorAll(r.selector)),O.hooks.run("before-all-elements-highlight",r);for(var i,a=0;i=r.elements[a++];)O.highlightElement(i,!0===t,r.callback)},highlightElement:function(e,t,n){var r=O.util.getLanguage(e),i=O.languages[r];e.className=e.className.replace(c,"").replace(/\s+/g," ")+" language-"+r;var a=e.parentElement;a&&"pre"===a.nodeName.toLowerCase()&&(a.className=a.className.replace(c,"").replace(/\s+/g," ")+" language-"+r);var o={element:e,language:r,grammar:i,code:e.textContent};function s(e){o.highlightedCode=e,O.hooks.run("before-insert",o),o.element.innerHTML=o.highlightedCode,O.hooks.run("after-highlight",o),O.hooks.run("complete",o),n&&n.call(o.element)}if(O.hooks.run("before-sanity-check",o),!o.code)return O.hooks.run("complete",o),void(n&&n.call(o.element));O.hooks.run("before-highlight",o),o.grammar?t&&l.Worker?((t=new Worker(O.filename)).onmessage=function(e){s(e.data)},t.postMessage(JSON.stringify({language:o.language,code:o.code,immediateClose:!0}))):s(O.highlight(o.code,o.grammar,o.language)):s(O.util.encode(o.code))},highlight:function(e,t,n){n={code:e,grammar:t,language:n};return O.hooks.run("before-tokenize",n),n.tokens=O.tokenize(n.code,n.grammar),O.hooks.run("after-tokenize",n),C.stringify(O.util.encode(n.tokens),n.language)},tokenize:function(e,t){var n=t.rest;if(n){for(var r in n)t[r]=n[r];delete t.rest}var i=new a;return F(i,i.head,e),function e(t,n,r,i,a,o){for(var s in r)if(r.hasOwnProperty(s)&&r[s]){var l=r[s];l=Array.isArray(l)?l:[l];for(var c=0;c<l.length;++c){if(o&&o.cause==s+","+c)return;var u,p=l[c],d=p.inside,h=!!p.lookbehind,f=!!p.greedy,g=p.alias;f&&!p.pattern.global&&(u=p.pattern.toString().match(/[imsuy]*$/)[0],p.pattern=RegExp(p.pattern.source,u+"g"));for(var m=p.pattern||p,v=i.next,b=a;v!==n.tail&&!(o&&b>=o.reach);b+=v.value.length,v=v.next){var y=v.value;if(n.length>t.length)return;if(!(y instanceof C)){var k,w=1;if(f){if(!(k=L(m,b,t,h)))break;var x=k.index,_=k.index+k[0].length,S=b;for(S+=v.value.length;S<=x;)v=v.next,S+=v.value.length;if(S-=v.value.length,b=S,v.value instanceof C)continue;for(var A=v;A!==n.tail&&(S<_||"string"==typeof A.value);A=A.next)w++,S+=A.value.length;w--,y=t.slice(b,S),k.index-=b}else if(!(k=L(m,0,y,h)))continue;var x=k.index,T=k[0],E=y.slice(0,x),R=y.slice(x+T.length),$=b+y.length;o&&$>o.reach&&(o.reach=$);var y=v.prev;E&&(y=F(n,y,E),b+=E.length),z(n,y,w);var T=new C(s,d?O.tokenize(T,d):T,g,T);v=F(n,y,T),R&&F(n,v,R),1<w&&e(t,n,r,v.prev,b,{cause:s+","+c,reach:$})}}}}}(e,i,t,i.head,0),function(e){var t=[],n=e.head.next;for(;n!==e.tail;)t.push(n.value),n=n.next;return t}(i)},hooks:{all:{},add:function(e,t){var n=O.hooks.all;n[e]=n[e]||[],n[e].push(t)},run:function(e,t){var n=O.hooks.all[e];if(n&&n.length)for(var r,i=0;r=n[i++];)r(t)}},Token:C};function C(e,t,n,r){this.type=e,this.content=t,this.alias=n,this.length=0|(r||"").length}function L(e,t,n,r){e.lastIndex=t;n=e.exec(n);return n&&r&&n[1]&&(r=n[1].length,n.index+=r,n[0]=n[0].slice(r)),n}function a(){var e={value:null,prev:null,next:null},t={value:null,prev:e,next:null};e.next=t,this.head=e,this.tail=t,this.length=0}function F(e,t,n){var r=t.next,n={value:n,prev:t,next:r};return t.next=n,r.prev=n,e.length++,n}function z(e,t,n){for(var r=t.next,i=0;i<n&&r!==e.tail;i++)r=r.next;(t.next=r).prev=t,e.length-=i}if(l.Prism=O,C.stringify=function t(e,n){if("string"==typeof e)return e;if(Array.isArray(e)){var r="";return e.forEach(function(e){r+=t(e,n)}),r}var i={type:e.type,content:t(e.content,n),tag:"span",classes:["token",e.type],attributes:{},language:n},e=e.alias;e&&(Array.isArray(e)?Array.prototype.push.apply(i.classes,e):i.classes.push(e)),O.hooks.run("wrap",i);var a,o="";for(a in i.attributes)o+=" "+a+'="'+(i.attributes[a]||"").replace(/"/g,"&quot;")+'"';return"<"+i.tag+' class="'+i.classes.join(" ")+'"'+o+">"+i.content+"</"+i.tag+">"},!l.document)return l.addEventListener&&(O.disableWorkerMessageHandler||l.addEventListener("message",function(e){var t=JSON.parse(e.data),n=t.language,e=t.code,t=t.immediateClose;l.postMessage(O.highlight(e,O.languages[n],n)),t&&l.close()},!1)),O;var e,n=O.util.currentScript();function r(){O.manual||O.highlightAll()}return n&&(O.filename=n.src,n.hasAttribute("data-manual")&&(O.manual=!0)),O.manual||("loading"===(e=document.readyState)||"interactive"===e&&n&&n.defer?document.addEventListener("DOMContentLoaded",r):window.requestAnimationFrame?window.requestAnimationFrame(r):window.setTimeout(r,16)),O}("undefined"!=typeof window?window:"undefined"!=typeof WorkerGlobalScope&&self instanceof WorkerGlobalScope?self:{});function p(e,t){var n=(n=e.className).replace(r," ")+" language-"+t;e.className=n.replace(/\s+/g," ").trim()}e.exports&&(e.exports=i),void 0!==Ae&&(Ae.Prism=i),i.languages.markup={comment:/<!--[\s\S]*?-->/,prolog:/<\?[\s\S]+?\?>/,doctype:{pattern:/<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,greedy:!0,inside:{"internal-subset":{pattern:/(\[)[\s\S]+(?=\]>$)/,lookbehind:!0,greedy:!0,inside:null},string:{pattern:/"[^"]*"|'[^']*'/,greedy:!0},punctuation:/^<!|>$|[[\]]/,"doctype-tag":/^DOCTYPE/,name:/[^\s<>'"]+/}},cdata:/<!\[CDATA\[[\s\S]*?]]>/i,tag:{pattern:/<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,greedy:!0,inside:{tag:{pattern:/^<\/?[^\s>\/]+/,inside:{punctuation:/^<\/?/,namespace:/^[^\s>\/:]+:/}},"attr-value":{pattern:/=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,inside:{punctuation:[{pattern:/^=/,alias:"attr-equals"},/"|'/]}},punctuation:/\/?>/,"attr-name":{pattern:/[^\s>\/]+/,inside:{namespace:/^[^\s>\/:]+:/}}}},entity:[{pattern:/&[\da-z]{1,8};/i,alias:"named-entity"},/&#x?[\da-f]{1,8};/i]},i.languages.markup.tag.inside["attr-value"].inside.entity=i.languages.markup.entity,i.languages.markup.doctype.inside["internal-subset"].inside=i.languages.markup,i.hooks.add("wrap",function(e){"entity"===e.type&&(e.attributes.title=e.content.replace(/&amp;/,"&"))}),Object.defineProperty(i.languages.markup.tag,"addInlined",{value:function(e,t){var n={};n["language-"+t]={pattern:/(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,lookbehind:!0,inside:i.languages[t]},n.cdata=/^<!\[CDATA\[|\]\]>$/i;n={"included-cdata":{pattern:/<!\[CDATA\[[\s\S]*?\]\]>/i,inside:n}};n["language-"+t]={pattern:/[\s\S]+/,inside:i.languages[t]};t={};t[e]={pattern:RegExp(/(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(/__/g,function(){return e}),"i"),lookbehind:!0,greedy:!0,inside:n},i.languages.insertBefore("markup","cdata",t)}}),i.languages.html=i.languages.markup,i.languages.mathml=i.languages.markup,i.languages.svg=i.languages.markup,i.languages.xml=i.languages.extend("markup",{}),i.languages.ssml=i.languages.xml,i.languages.atom=i.languages.xml,i.languages.rss=i.languages.xml,function(e){var t=/("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/;e.languages.css={comment:/\/\*[\s\S]*?\*\//,atrule:{pattern:/@[\w-](?:[^;{\s]|\s+(?![\s{]))*(?:;|(?=\s*\{))/,inside:{rule:/^@[\w-]+/,"selector-function-argument":{pattern:/(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,lookbehind:!0,alias:"selector"},keyword:{pattern:/(^|[^\w-])(?:and|not|only|or)(?![\w-])/,lookbehind:!0}}},url:{pattern:RegExp("\\burl\\((?:"+t.source+"|"+/(?:[^\\\r\n()"']|\\[\s\S])*/.source+")\\)","i"),greedy:!0,inside:{function:/^url/i,punctuation:/^\(|\)$/,string:{pattern:RegExp("^"+t.source+"$"),alias:"url"}}},selector:RegExp("[^{}\\s](?:[^{};\"'\\s]|\\s+(?![\\s{])|"+t.source+")*(?=\\s*\\{)"),string:{pattern:t,greedy:!0},property:/(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,important:/!important\b/i,function:/[-a-z0-9]+(?=\()/i,punctuation:/[(){};:,]/},e.languages.css.atrule.inside.rest=e.languages.css;t=e.languages.markup;t&&(t.tag.addInlined("style","css"),e.languages.insertBefore("inside","attr-value",{"style-attr":{pattern:/(^|["'\s])style\s*=\s*(?:"[^"]*"|'[^']*')/i,lookbehind:!0,inside:{"attr-value":{pattern:/=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,inside:{style:{pattern:/(["'])[\s\S]+(?=["']$)/,lookbehind:!0,alias:"language-css",inside:e.languages.css},punctuation:[{pattern:/^=/,alias:"attr-equals"},/"|'/]}},"attr-name":/^style/i}}},t.tag))}(i),i.languages.clike={comment:[{pattern:/(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,lookbehind:!0,greedy:!0},{pattern:/(^|[^\\:])\/\/.*/,lookbehind:!0,greedy:!0}],string:{pattern:/(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,greedy:!0},"class-name":{pattern:/(\b(?:class|interface|extends|implements|trait|instanceof|new)\s+|\bcatch\s+\()[\w.\\]+/i,lookbehind:!0,inside:{punctuation:/[.\\]/}},keyword:/\b(?:if|else|while|do|for|return|in|instanceof|function|new|try|throw|catch|finally|null|break|continue)\b/,boolean:/\b(?:true|false)\b/,function:/\w+(?=\()/,number:/\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,operator:/[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/,punctuation:/[{}[\];(),.:]/},i.languages.javascript=i.languages.extend("clike",{"class-name":[i.languages.clike["class-name"],{pattern:/(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:prototype|constructor))/,lookbehind:!0}],keyword:[{pattern:/((?:^|})\s*)(?:catch|finally)\b/,lookbehind:!0},{pattern:/(^|[^.]|\.\.\.\s*)\b(?:as|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|for|from|function|(?:get|set)(?=\s*[\[$\w\xA0-\uFFFF])|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/,lookbehind:!0}],function:/#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,number:/\b(?:(?:0[xX](?:[\dA-Fa-f](?:_[\dA-Fa-f])?)+|0[bB](?:[01](?:_[01])?)+|0[oO](?:[0-7](?:_[0-7])?)+)n?|(?:\d(?:_\d)?)+n|NaN|Infinity)\b|(?:\b(?:\d(?:_\d)?)+\.?(?:\d(?:_\d)?)*|\B\.(?:\d(?:_\d)?)+)(?:[Ee][+-]?(?:\d(?:_\d)?)+)?/,operator:/--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/}),i.languages.javascript["class-name"][0].pattern=/(\b(?:class|interface|extends|implements|instanceof|new)\s+)[\w.\\]+/,i.languages.insertBefore("javascript","keyword",{regex:{pattern:/((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)\/(?:\[(?:[^\]\\\r\n]|\\.)*]|\\.|[^/\\\[\r\n])+\/[gimyus]{0,6}(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/,lookbehind:!0,greedy:!0,inside:{"regex-source":{pattern:/^(\/)[\s\S]+(?=\/[a-z]*$)/,lookbehind:!0,alias:"language-regex",inside:i.languages.regex},"regex-flags":/[a-z]+$/,"regex-delimiter":/^\/|\/$/}},"function-variable":{pattern:/#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/,alias:"function"},parameter:[{pattern:/(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,lookbehind:!0,inside:i.languages.javascript},{pattern:/(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,inside:i.languages.javascript},{pattern:/(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,lookbehind:!0,inside:i.languages.javascript},{pattern:/((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*)\(\s*|\]\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*\{)/,lookbehind:!0,inside:i.languages.javascript}],constant:/\b[A-Z](?:[A-Z_]|\dx?)*\b/}),i.languages.insertBefore("javascript","string",{"template-string":{pattern:/`(?:\\[\s\S]|\${(?:[^{}]|{(?:[^{}]|{[^}]*})*})+}|(?!\${)[^\\`])*`/,greedy:!0,inside:{"template-punctuation":{pattern:/^`|`$/,alias:"string"},interpolation:{pattern:/((?:^|[^\\])(?:\\{2})*)\${(?:[^{}]|{(?:[^{}]|{[^}]*})*})+}/,lookbehind:!0,inside:{"interpolation-punctuation":{pattern:/^\${|}$/,alias:"punctuation"},rest:i.languages.javascript}},string:/[\s\S]+/}}}),i.languages.markup&&i.languages.markup.tag.addInlined("script","javascript"),i.languages.js=i.languages.javascript,"undefined"!=typeof self&&self.Prism&&self.document&&(Element.prototype.matches||(Element.prototype.matches=Element.prototype.msMatchesSelector||Element.prototype.webkitMatchesSelector),o=window.Prism,s={js:"javascript",py:"python",rb:"ruby",ps1:"powershell",psm1:"powershell",sh:"bash",bat:"batch",h:"c",tex:"latex"},u="pre[data-src]:not(["+(l="data-src-status")+'="loaded"]):not(['+l+'="'+(c="loading")+'"])',r=/\blang(?:uage)?-([\w-]+)\b/i,o.hooks.add("before-highlightall",function(e){e.selector+=", "+u}),o.hooks.add("before-sanity-check",function(e){var t,n,r,i,a=e.element;a.matches(u)&&(e.code="",a.setAttribute(l,c),(t=a.appendChild(document.createElement("CODE"))).textContent="Loading…",n=a.getAttribute("data-src"),"none"===(e=e.language)&&(r=(/\.(\w+)$/.exec(n)||[,"none"])[1],e=s[r]||r),p(t,e),p(a,e),(r=o.plugins.autoloader)&&r.loadLanguages(e),(i=new XMLHttpRequest).open("GET",n,!0),i.onreadystatechange=function(){4==i.readyState&&(i.status<400&&i.responseText?(a.setAttribute(l,"loaded"),t.textContent=i.responseText,o.highlightElement(t)):(a.setAttribute(l,"failed"),400<=i.status?t.textContent="✖ Error "+i.status+" while fetching file: "+i.statusText:t.textContent="✖ Error: File does not exist or is empty"))},i.send(null))}),t=!(o.plugins.fileHighlight={highlight:function(e){for(var t,n=(e||document).querySelectorAll(u),r=0;t=n[r++];)o.highlightElement(t)}}),o.fileHighlight=function(){t||(console.warn("Prism.fileHighlight is deprecated. Use `Prism.plugins.fileHighlight.highlight` instead."),t=!0),o.plugins.fileHighlight.highlight.apply(this,arguments)})});function _n(e,t){return"___"+e.toUpperCase()+t+"___"}wn=Prism,Object.defineProperties(wn.languages["markup-templating"]={},{buildPlaceholders:{value:function(r,i,e,a){var o;r.language===i&&(o=r.tokenStack=[],r.code=r.code.replace(e,function(e){if("function"==typeof a&&!a(e))return e;for(var t,n=o.length;-1!==r.code.indexOf(t=_n(i,n));)++n;return o[n]=e,t}),r.grammar=wn.languages.markup)}},tokenizePlaceholders:{value:function(c,u){var p,d;c.language===u&&c.tokenStack&&(c.grammar=wn.languages[u],p=0,d=Object.keys(c.tokenStack),function e(t){for(var n=0;n<t.length&&!(p>=d.length);n++){var r,i,a,o,s,l=t[n];"string"==typeof l||l.content&&"string"==typeof l.content?(i=d[p],a=c.tokenStack[i],r="string"==typeof l?l:l.content,s=_n(u,i),-1<(o=r.indexOf(s))&&(++p,i=r.substring(0,o),a=new wn.Token(u,wn.tokenize(a,c.grammar),"language-"+u,a),o=r.substring(o+s.length),s=[],i&&s.push.apply(s,e([i])),s.push(a),o&&s.push.apply(s,e([o])),"string"==typeof l?t.splice.apply(t,[n,1].concat(s)):l.content=s)):l.content&&e(l.content)}return t}(c.tokens))}}});var Sn={},An={markdown:function(e){return{url:e}},mermaid:function(e){return{url:e}},iframe:function(e,t){return{html:'<iframe src="'+e+'" '+(t||"width=100% height=400")+"></iframe>"}},video:function(e,t){return{html:'<video src="'+e+'" '+(t||"controls")+">Not Support</video>"}},audio:function(e,t){return{html:'<audio src="'+e+'" '+(t||"controls")+">Not Support</audio>"}},code:function(e,t){var n=e.match(/\.(\w+)$/);return"md"===(n=t||n&&n[1])&&(n="markdown"),{url:e,lang:n}}},Tn=function(i,e){var a=this;this.config=i,this.router=e,this.cacheTree={},this.toc=[],this.cacheTOC={},this.linkTarget=i.externalLinkTarget||"_blank",this.linkRel="_blank"===this.linkTarget?i.externalLinkRel||"noopener":"",this.contentBase=e.getBasePath();var t=this._initRenderer();this.heading=t.heading;var e=i.markdown||{},o=d(e)?e(un,t):(un.setOptions(p(e,{renderer:p(t,e.renderer)})),un);this._marked=o,this.compile=function(n){var r=!0,e=s(function(e){r=!1;var t="";return n?(t=c(n)?o(n):o.parser(n),t=i.noEmoji?t:t.replace(/:\+1:/g,":thumbsup:").replace(/:-1:/g,":thumbsdown:").replace(/<(pre|template|code)[^>]*?>[\s\S]+?<\/(pre|template|code)>/g,function(e){return e.replace(/:/g,"__colon__")}).replace(/:(\w+?):/gi,window.emojify||bn).replace(/__colon__/g,":"),vn.clear(),t):n})(n),t=a.router.parse().file;return r?a.toc=a.cacheTOC[t]:a.cacheTOC[t]=[].concat(a.toc),e}};Tn.prototype.compileEmbed=function(e,t){var n,r,i=yn(t),a=i.str,i=i.config;if(t=a,i.include)return te(e)||(e=se(this.contentBase,re(this.router.getCurrentPath()),e)),i.type&&(r=An[i.type])?(n=r.call(this,e,t)).type=i.type:(r="code",/\.(md|markdown)/.test(e)?r="markdown":/\.mmd/.test(e)?r="mermaid":/\.html?/.test(e)?r="iframe":/\.(mp4|ogg)/.test(e)?r="video":/\.mp3/.test(e)&&(r="audio"),(n=An[r].call(this,e,t)).type=r),n.fragment=i.fragment,n},Tn.prototype._matchNotCompileLink=function(e){for(var t=this.config.noCompileLinks||[],n=0;n<t.length;n++){var r=t[n];if((Sn[r]||(Sn[r]=new RegExp("^"+r+"$"))).test(e))return e}},Tn.prototype._initRenderer=function(){var o,s,l,c,u,p,e=new un.Renderer,t=this.linkTarget,n=this.linkRel,a=this.router,r=this.contentBase,d=this,i={};return i.heading=e.heading=function(e,t){var n=yn(e),r=n.str,i=n.config,e={level:t,title:kn(r)};/<!-- {docsify-ignore} -->/g.test(r)&&(r=r.replace("\x3c!-- {docsify-ignore} --\x3e",""),e.title=kn(r),e.ignoreSubHeading=!0),/{docsify-ignore}/g.test(r)&&(r=r.replace("{docsify-ignore}",""),e.title=kn(r),e.ignoreSubHeading=!0),/<!-- {docsify-ignore-all} -->/g.test(r)&&(r=r.replace("\x3c!-- {docsify-ignore-all} --\x3e",""),e.title=kn(r),e.ignoreAllSubs=!0),/{docsify-ignore-all}/g.test(r)&&(r=r.replace("{docsify-ignore-all}",""),e.title=kn(r),e.ignoreAllSubs=!0);n=vn(i.id||r),i=a.toURL(a.getCurrentPath(),{id:n});return e.slug=i,d.toc.push(e),"<h"+t+' id="'+n+'"><a href="'+i+'" data-id="'+n+'" class="anchor"><span>'+r+"</span></a></h"+t+">"},i.code={renderer:e}.renderer.code=function(e,t){void 0===t&&(t="markup");var n=xn.languages[t]||xn.languages.markup;return'<pre v-pre data-lang="'+t+'"><code class="lang-'+t+'">'+xn.highlight(e.replace(/@DOCSIFY_QM@/g,"`"),n,t)+"</code></pre>"},i.link=(n=(t={renderer:e,router:a,linkTarget:t,linkRel:n,compilerClass:d}).renderer,o=t.router,s=t.linkTarget,l=t.linkRel,c=t.compilerClass,n.link=function(e,t,n){void 0===t&&(t="");var r=[],i=yn(t),a=i.str,i=i.config;return s=i.target||s,l="_blank"===s?c.config.externalLinkRel||"noopener":"",t=a,te(e)||c._matchNotCompileLink(e)||i.ignore?(te(e)||"./"!==e.slice(0,2)||(e=document.URL.replace(/\/(?!.*\/).*/,"/").replace("#/./","")+e),r.push(0===e.indexOf("mailto:")?"":'target="'+s+'"'),r.push(0!==e.indexOf("mailto:")&&""!==l?' rel="'+l+'"':"")):(e===c.config.homepage&&(e="README"),e=o.toURL(e,null,o.getCurrentPath())),i.crossorgin&&"_self"===s&&"history"===c.config.routerMode&&-1===c.config.crossOriginLinks.indexOf(e)&&c.config.crossOriginLinks.push(e),i.disabled&&(r.push("disabled"),e="javascript:void(0)"),i.class&&r.push('class="'+i.class+'"'),i.id&&r.push('id="'+i.id+'"'),t&&r.push('title="'+t+'"'),'<a href="'+e+'" '+r.join(" ")+">"+n+"</a>"}),i.paragraph={renderer:e}.renderer.paragraph=function(e){e=/^!&gt;/.test(e)?dn("tip",e):/^\?&gt;/.test(e)?dn("warn",e):"<p>"+e+"</p>";return e},i.image=(r=(n={renderer:e,contentBase:r,router:a}).renderer,u=n.contentBase,p=n.router,r.image=function(e,t,n){var r=e,i=[],a=yn(t),o=a.str,a=a.config;return t=o,a["no-zoom"]&&i.push("data-no-zoom"),t&&i.push('title="'+t+'"'),a.size&&(t=(o=a.size.split("x"))[0],(o=o[1])?i.push('width="'+t+'" height="'+o+'"'):i.push('width="'+t+'"')),a.class&&i.push('class="'+a.class+'"'),a.id&&i.push('id="'+a.id+'"'),te(e)||(r=se(u,re(p.getCurrentPath()),e)),0<i.length?'<img src="'+r+'" data-origin="'+e+'" alt="'+n+'" '+i.join(" ")+" />":'<img src="'+r+'" data-origin="'+e+'" alt="'+n+'"'+i+">"}),i.list={renderer:e}.renderer.list=function(e,t,n){t=t?"ol":"ul";return"<"+t+" "+[/<li class="task-list-item">/.test(e.split('class="task-list"')[0])?'class="task-list"':"",n&&1<n?'start="'+n+'"':""].join(" ").trim()+">"+e+"</"+t+">"},i.listitem={renderer:e}.renderer.listitem=function(e){return/^(<input.*type="checkbox"[^>]*>)/.test(e)?'<li class="task-list-item"><label>'+e+"</label></li>":"<li>"+e+"</li>"},e.origin=i,e},Tn.prototype.sidebar=function(e,t){var n=this.toc,r=this.router.getCurrentPath(),i="";if(e)i=this.compile(e);else{for(var a=0;a<n.length;a++)if(n[a].ignoreSubHeading){var o=n[a].level;n.splice(a,1);for(var s=a;s<n.length&&o<n[s].level;s++)n.splice(s,1)&&s--&&a++;a--}t=this.cacheTree[r]||hn(n,t),i=pn(t,"<ul>{inner}</ul>");this.cacheTree[r]=t}return i},Tn.prototype.subSidebar=function(e){if(e){var t=this.router.getCurrentPath(),n=this.cacheTree,r=this.toc;r[0]&&r[0].ignoreAllSubs&&r.splice(0),r[0]&&1===r[0].level&&r.shift();for(var i=0;i<r.length;i++)r[i].ignoreSubHeading&&r.splice(i,1)&&i--;e=n[t]||hn(r,e);return n[t]=e,this.toc=[],pn(e)}this.toc=[]},Tn.prototype.header=function(e,t){return this.heading(e,t)},Tn.prototype.article=function(e){return this.compile(e)},Tn.prototype.cover=function(e){var t=this.toc.slice(),e=this.compile(e);return this.toc=t.slice(),e};var En,Rn=function(e){var t=function(e){e=e.match(/^[ \t]*(?=\S)/gm);return e?e.reduce(function(e,t){return Math.min(e,t.length)},1/0):0}(e);if(0===t)return e;t=new RegExp("^[ \\t]{"+t+"}","gm");return e.replace(t,"")},$n={};function On(e,r){var a=e.compiler,i=e.raw;void 0===i&&(i="");var t=e.fetch,e=$n[i];if(e){var n=e.slice();return n.links=e.links,r(n)}var n=a._marked,o=n.lexer(i),s=[],l=n.Lexer.rules.inline.link,c=o.links;o.forEach(function(e,i){"paragraph"===e.type&&(e.text=e.text.replace(new RegExp(l.source,"g"),function(e,t,n,r){r=a.compileEmbed(n,r);return r&&s.push({index:i,embed:r}),e}))});var u=[];!function(e,a){var t,n=e.embedTokens,o=e.compile,s=(e.fetch,0),l=1;if(!n.length)return a({});for(;t=n[s++];){var r=function(i){return function(e){var t,n,r;e&&("markdown"===i.embed.type?((n=i.embed.url.split("/")).pop(),n=n.join("/"),e=e.replace(/\[([^[\]]+)\]\(([^)]+)\)/g,function(e){var t=e.indexOf("(");return"(."===e.slice(t,t+2)?e.substring(0,t)+"("+window.location.protocol+"//"+window.location.host+n+"/"+e.substring(t+1,e.length-1)+")":e}),!0===(($docsify.frontMatter||{}).installed||!1)&&(e=$docsify.frontMatter.parseMarkdown(e)),t=o.lexer(e)):"code"===i.embed.type?(i.embed.fragment&&(r=i.embed.fragment,r=new RegExp("(?:###|\\/\\/\\/)\\s*\\["+r+"\\]([\\s\\S]*)(?:###|\\/\\/\\/)\\s*\\["+r+"\\]"),e=Rn((e.match(r)||[])[1]||"").trim()),t=o.lexer("```"+i.embed.lang+"\n"+e.replace(/`/g,"@DOCSIFY_QM@")+"\n```\n")):"mermaid"===i.embed.type?(t=[{type:"html",text:'<div class="mermaid">\n'+e+"\n</div>"}]).links={}:(t=[{type:"html",text:e}]).links={}),a({token:i,embedToken:t}),++l>=s&&a({})}}(t);t.embed.url?Z(t.embed.url).then(r):r(t.embed.html)}}({compile:n,embedTokens:s,fetch:t},function(e){var t,n=e.embedToken,e=e.token;e?(t=e.index,u.forEach(function(e){t>e.start&&(t+=e.length)}),p(c,n.links),o=o.slice(0,t).concat(n,o.slice(t+1)),u.push({start:t,length:n.length-1})):($n[i]=o.concat(),o.links=$n[i].links=c,r(o))})}function Cn(e,t,n){var r,i,a,o;return t="function"==typeof n?n(t):"string"==typeof n?(a=[],o=0,(r=n).replace(R,function(t,e,n){a.push(r.substring(o,n-1)),o=n+=t.length+1,a.push(i&&i[t]||function(e){return("00"+("string"==typeof $[t]?e[$[t]]():$[t](e))).slice(-t.length)})}),o!==r.length&&a.push(r.substring(o)),function(e){for(var t="",n=0,r=e||new Date;n<a.length;n++)t+="string"==typeof a[n]?a[n]:a[n](r);return t}(new Date(t))):t,e.replace(/{docsify-updated}/g,t)}function Ln(e){function t(e){var t=Boolean(e.__vue__&&e.__vue__._isVue),e=Boolean(e._vnode&&e._vnode.__v_skip);return t||e}var n=this.config,r=y(".markdown-section"),i="Vue"in window&&window.Vue.version&&Number(window.Vue.version.charAt(0));if(e=e||"<h1>404 - Not found</h1>","Vue"in window)for(var a=0,o=k(".markdown-section > *").filter(t);a<o.length;a+=1){var s=o[a];2===i?s.__vue__.$destroy():3===i&&s.__vue_app__.unmount()}if(this._renderTo(r,e),n.loadSidebar||this._renderSidebar(),(n.executeScript||"Vue"in window&&!1!==n.executeScript)&&(!(e=k(".markdown-section>script").filter(function(e){return!/template/.test(e.type)})[0])||(e=e.innerText.trim())&&new Function(e)()),"Vue"in window){var l,c,u=[],p=Object.keys(n.vueComponents||{});2===i&&p.length&&p.forEach(function(e){window.Vue.options.components[e]||window.Vue.component(e,n.vueComponents[e])}),!En&&n.vueGlobalOptions&&"function"==typeof n.vueGlobalOptions.data&&(En=n.vueGlobalOptions.data()),u.push.apply(u,Object.entries(n.vueMounts||{}).map(function(e){var t=e[0],e=e[1];return[y(r,t),e]}).filter(function(e){var t=e[0];e[1];return t})),(n.vueGlobalOptions||p.length)&&(l=/{{2}[^{}]*}{2}/,c=/<[^>/]+\s([@:]|v-)[\w-:.[\]]+[=>\s]/,u.push.apply(u,k(".markdown-section > *").filter(function(n){return!u.some(function(e){var t=e[0];e[1];return t===n})}).filter(function(e){return e.tagName.toLowerCase()in(n.vueComponents||{})||e.querySelector(p.join(",")||null)||l.test(e.outerHTML)||c.test(e.outerHTML)}).map(function(e){var t=Object.assign({},n.vueGlobalOptions||{});return En&&(t.data=function(){return En}),[e,t]})));for(var d=0,h=u;d<h.length;d+=1){var f,g=h[d],m=g[0],v=g[1],g="data-isvue";m.matches("pre, script")||t(m)||m.querySelector("["+g+"]")||(m.setAttribute(g,""),2===i?(v.el=void 0,new window.Vue(v).$mount(m)):3===i&&(f=window.Vue.createApp(v),p.forEach(function(e){var t=n.vueComponents[e];f.component(e,t)}),f.mount(m)))}}}function Fn(e){var t=e.config;e.compiler=new Tn(t,e.router),window.__current_docsify_compiler__=e.compiler;var n,r,i,a,o,s=t.el||"#app",l=y("nav")||w("nav"),c=y(s),u="",p=v;c?(t.repo&&(u+=(a=t.repo,s=t.cornerExternalLinkTarge,a?(/\/\//.test(a)||(a="https://github.com/"+a),'<a href="'+(a=a.replace(/^git\+/,""))+'" target="'+(s=s||"_blank")+'" class="github-corner" aria-label="View source on Github"><svg viewBox="0 0 250 250" aria-hidden="true"><path d="M0,0 L115,115 L130,115 L142,142 L250,250 L250,0 Z"></path><path d="M128.3,109.0 C113.8,99.7 119.0,89.6 119.0,89.6 C122.0,82.7 120.5,78.6 120.5,78.6 C119.2,72.0 123.4,76.3 123.4,76.3 C127.3,80.9 125.5,87.3 125.5,87.3 C122.9,97.6 130.6,101.9 134.4,103.2" fill="currentColor" style="transform-origin: 130px 106px;" class="octo-arm"></path><path d="M115.0,115.0 C114.9,115.1 118.7,116.5 119.8,115.4 L133.7,101.6 C136.9,99.2 139.9,98.4 142.2,98.6 C133.8,88.0 127.5,74.4 143.8,58.0 C148.5,53.4 154.0,51.2 159.7,51.0 C160.3,49.4 163.2,43.6 171.4,40.1 C171.4,40.1 176.1,42.5 178.8,56.2 C183.1,58.6 187.2,61.8 190.9,65.4 C194.5,69.0 197.7,73.2 200.1,77.6 C213.8,80.2 216.3,84.9 216.3,84.9 C212.7,93.1 206.9,96.0 205.4,96.6 C205.1,102.4 203.0,107.8 198.3,112.5 C181.9,128.9 168.3,122.5 157.7,114.1 C157.9,116.9 156.7,120.9 152.7,124.9 L141.0,136.5 C139.8,137.7 141.6,141.9 141.8,141.8 Z" fill="currentColor" class="octo-body"></path></svg></a>'):"")),t.coverpage&&(u+=(i=", 100%, 85%",'<section class="cover show" style="background: '+("linear-gradient(to left bottom, hsl("+Math.floor(255*Math.random())+i+") 0%,hsl("+Math.floor(255*Math.random())+i+") 100%)")+'"><div class="mask"></div><div class="cover-main">\x3c!--cover--\x3e</div></section>')),t.logo&&(i=/^data:image/.test(t.logo),n=/(?:http[s]?:)?\/\//.test(t.logo),r=/^\./.test(t.logo),i||n||r||(t.logo=se(e.router.getBasePath(),t.logo))),u+=(r=(n=t).name?n.name:"","<main>"+('<button class="sidebar-toggle" aria-label="Menu"><div class="sidebar-toggle-button"><span></span><span></span><span></span></div></button><aside class="sidebar">'+(n.name?'<h1 class="app-name"><a class="app-name-link" data-nosearch>'+(n.logo?'<img alt="'+r+'" src='+n.logo+">":r)+"</a></h1>":"")+'<div class="sidebar-nav">\x3c!--sidebar--\x3e</div></aside>')+'<section class="content"><article class="markdown-section" id="main">\x3c!--main--\x3e</article></section></main>'),e._renderTo(c,u,!0)):e.rendered=!0,t.mergeNavbar&&h?p=y(".sidebar"):(l.classList.add("app-nav"),t.repo||l.classList.add("no-badge")),t.loadNavbar&&x(p,l),t.themeColor&&(m.head.appendChild(w("div","<style>:root{--theme-color: "+t.themeColor+";}</style>").firstElementChild),o=t.themeColor,window.CSS&&window.CSS.supports&&window.CSS.supports("(--v:red)")||(t=k("style:not(.inserted),link"),[].forEach.call(t,function(e){if("STYLE"===e.nodeName)G(e,o);else if("LINK"===e.nodeName){e=e.getAttribute("href");if(!/\.css$/.test(e))return;Z(e).then(function(e){e=w("style",e);b.appendChild(e),G(e,o)})}}))),e._updateRender(),A(v,"ready")}var zn={};ut=function(e){this.config=e};function Mn(e){var t=location.href.indexOf("#");location.replace(location.href.slice(0,0<=t?t:0)+"#"+e)}ut.prototype.getBasePath=function(){return this.config.basePath},ut.prototype.getFile=function(e,t){void 0===e&&(e=this.getCurrentPath());var n,r,i=this.config,a=this.getBasePath(),o="string"==typeof i.ext?i.ext:".md";return e=i.alias?function e(t,n,r){var i=Object.keys(n).filter(function(e){return(zn[e]||(zn[e]=new RegExp("^"+e+"$"))).test(t)&&t!==r})[0];return i?e(t.replace(zn[i],n[i]),n,t):t}(e,i.alias):e,n=e,r=o,e=(e=new RegExp("\\.("+r.replace(/^\./,"")+"|html)$","g").test(n)?n:/\/$/g.test(n)?n+"README"+r:""+n+r)==="/README"+o&&i.homepage||e,e=te(e)?e:se(a,e),t&&(e=e.replace(new RegExp("^"+a),"")),e},ut.prototype.onchange=function(e){void 0===e&&(e=u),e()},ut.prototype.getCurrentPath=function(){},ut.prototype.normalize=function(){},ut.prototype.parse=function(){},ut.prototype.toURL=function(e,t,n){var r=n&&"#"===e[0],i=this.parse(le(e));if(i.query=p({},i.query,t),e=(e=i.path+ee(i.query)).replace(/\.md(\?)|\.md$/,"$1"),r&&(e=(0<(r=n.indexOf("?"))?n.substring(0,r):n)+e),this.config.relativePath&&0!==e.indexOf("/")){n=n.substring(0,n.lastIndexOf("/")+1);return ie(ae(n+e))}return ie("/"+e)};var Nn=function(r){function e(e){r.call(this,e),this.mode="hash"}return r&&(e.__proto__=r),((e.prototype=Object.create(r&&r.prototype)).constructor=e).prototype.getBasePath=function(){var e=window.location.pathname||"",t=this.config.basePath,e=ce(e,".html")?e+"#/"+t:e+"/"+t;return/^(\/|https?:)/g.test(t)?t:ie(e)},e.prototype.getCurrentPath=function(){var e=location.href,t=e.indexOf("#");return-1===t?"":e.slice(t+1)},e.prototype.onchange=function(n){void 0===n&&(n=u);var r=!1;_("click",function(e){e="A"===e.target.tagName?e.target:e.target.parentNode;e&&"A"===e.tagName&&!/_blank/.test(e.target)&&(r=!0)}),_("hashchange",function(e){var t=r?"navigate":"history";r=!1,n({event:e,source:t})})},e.prototype.normalize=function(){var e=this.getCurrentPath();if("/"===(e=le(e)).charAt(0))return Mn(e);Mn("/"+e)},e.prototype.parse=function(e){void 0===e&&(e=location.href);var t="",n=e.indexOf("#");0<=n&&(e=e.slice(n+1));n=e.indexOf("?");return 0<=n&&(t=e.slice(n+1),e=e.slice(0,n)),{path:e,file:this.getFile(e,!0),query:J(t)}},e.prototype.toURL=function(e,t,n){return"#"+r.prototype.toURL.call(this,e,t,n)},e}(ut),Pn=function(t){function e(e){t.call(this,e),this.mode="history"}return t&&(e.__proto__=t),((e.prototype=Object.create(t&&t.prototype)).constructor=e).prototype.getCurrentPath=function(){var e=this.getBasePath(),t=window.location.pathname;return e&&0===t.indexOf(e)&&(t=t.slice(e.length)),(t||"/")+window.location.search+window.location.hash},e.prototype.onchange=function(n){var r=this;void 0===n&&(n=u),_("click",function(e){var t="A"===e.target.tagName?e.target:e.target.parentNode;"A"!==t.tagName||/_blank/.test(t.target)||(e.preventDefault(),t=t.href,-1!==r.config.crossOriginLinks.indexOf(t)?window.open(t,"_self"):window.history.pushState({key:t},"",t),n({event:e,source:"navigate"}))}),_("popstate",function(e){n({event:e,source:"history"})})},e.prototype.parse=function(e){void 0===e&&(e=location.href);var t="",n=e.indexOf("?");0<=n&&(t=e.slice(n+1),e=e.slice(0,n));var r=se(location.origin),n=e.indexOf(r);return-1<n&&(e=e.slice(n+r.length)),{path:e,file:this.getFile(e),query:J(t)}},e}(ut);var Dn={};function In(e){e.router.normalize(),e.route=e.router.parse(),v.setAttribute("data-page",e.route.file)}function jn(e){function t(e){return v.classList.toggle("close")}var n;n="button.sidebar-toggle",e.router,null!=(n=g(n))&&(_(n,"click",function(e){e.stopPropagation(),t()}),h&&_(v,"click",function(e){return v.classList.contains("close")&&t()})),n=".sidebar",e.router,null!=(n=g(n))&&_(n,"click",function(e){e=e.target;"A"===e.nodeName&&e.nextSibling&&e.nextSibling.classList&&e.nextSibling.classList.contains("app-sub-sidebar")&&A(e.parentNode,"collapse")}),e.config.coverpage?h||_("scroll",Y):v.classList.add("sticky")}function qn(t,n,r,i,a,e){t=e?t:t.replace(/\/$/,""),(t=re(t))&&Z(a.router.getFile(t+r)+n,!1,a.config.requestHeaders).then(i,function(e){return qn(t,n,r,i,a)})}function Hn(e){e=e.match(/^([^:/?#]+:)?(?:\/\/([^/?#]*))?([^?#]+)?(\?[^#]*)?(#.*)?/);return"string"==typeof e[1]&&0<e[1].length&&e[1].toLowerCase()!==location.protocol||"string"==typeof e[2]&&0<e[2].length&&e[2].replace(new RegExp(":("+{"http:":80,"https:":443}[location.protocol]+")?$"),"")!==location.host}var Un=Object.freeze({__proto__:null,cached:s,hyphenate:a,hasOwn:l,merge:p,isPrimitive:c,noop:u,isFn:d,inBrowser:!0,isMobile:h,supportsPushState:f,parseQuery:J,stringifyQuery:ee,isAbsolutePath:te,removeParams:ne,getParentPath:re,cleanPath:ie,resolvePath:ae,getPath:se,replaceSlug:le,endsWith:ce});function Bn(){this._init()}var Zn,Gn,Wn,Vn=Bn.prototype;function Yn(e,t,n){return Wn&&Wn.abort&&Wn.abort(),Wn=Z(e,!0,n)}Vn._init=function(){var n,t,r,i,e,a,o=this;o.config=E(o),(n=o)._hooks={},n._lifecycle={},["init","mounted","beforeEach","afterEach","doneEach","ready"].forEach(function(e){var t=n._hooks[e]=[];n._lifecycle[e]=function(e){return t.push(e)}}),[].concat((t=o).config.plugins).forEach(function(e){return d(e)&&e(t._lifecycle,t)}),W(o,"init"),e=new("history"===((e=(r=o).config).routerMode||"hash")&&f?Pn:Nn)(e),r.router=e,In(r),Dn=r.route,e.onchange(function(e){In(r),r._updateRender(),Dn.path!==r.route.path?(r.$fetch(u,r.$resetEvents.bind(r,e.source)),Dn=r.route):r.$resetEvents(e.source)}),Fn(o),jn(o),a=(i=o).config.loadSidebar,i.rendered?(e=X(i.router,".sidebar-nav",!0,!0),a&&e&&(e.parentNode.innerHTML+=window.__SUB_SIDEBAR__),i._bindEventOnRendered(e),i.$resetEvents(),W(i,"doneEach"),W(i,"ready")):i.$fetch(function(e){return W(i,"ready")}),W(o,"mounted")},Vn.route={},(Zn=Vn)._renderTo=function(e,t,n){e=g(e);e&&(e[n?"outerHTML":"innerHTML"]=t)},Zn._renderSidebar=function(e){var t=this.config,n=t.maxLevel,r=t.subMaxLevel,i=t.loadSidebar;if(t.hideSidebar)return[document.querySelector("aside.sidebar"),document.querySelector("button.sidebar-toggle")].forEach(function(e){return e.parentNode.removeChild(e)}),document.querySelector("section.content").style.right="unset",document.querySelector("section.content").style.left="unset",document.querySelector("section.content").style.position="relative",document.querySelector("section.content").style.width="100%",null;this._renderTo(".sidebar-nav",this.compiler.sidebar(e,n));n=X(this.router,".sidebar-nav",!0,!0);i&&n?n.parentNode.innerHTML+=this.compiler.subSidebar(r)||"":this.compiler.subSidebar(),this._bindEventOnRendered(n)},Zn._bindEventOnRendered=function(e){var t,n=this.config.autoHeader;!function(e){var t=y(".cover.show");ke=t?t.offsetHeight:0;var t=g(".sidebar"),n=[];null!=t&&(n=k(t,"li"));for(var r,i=0,a=n.length;i<a;i+=1){var o,s,l=n[i],c=l.querySelector("a");c&&("/"!==(o=c.getAttribute("href"))&&(c=(s=e.parse(o)).query.id,s=s.path,c&&(o=xe(s,c))),o&&(me[decodeURIComponent(o)]=l))}h||(r=ne(e.getCurrentPath()),S("scroll",function(){return we(r)}),_("scroll",function(){return we(r)}),_(t,"mouseover",function(){ve=!0}),_(t,"mouseleave",function(){ve=!1}))}(this.router),n&&e&&((n=(t=g("#main")).children[0])&&"H1"!==n.tagName&&x(t,w("div",this.compiler.header(e.innerText,1)).children[0]))},Zn._renderNav=function(e){e&&this._renderTo("nav",this.compiler.compile(e)),this.config.loadNavbar&&X(this.router,"nav")},Zn._renderMain=function(r,i,a){var o=this;if(void 0===i&&(i={}),!r)return Ln.call(this,r);W(this,"beforeEach",r,function(e){function t(){i.updatedAt&&(n=Cn(n,i.updatedAt,o.config.formatUpdated)),W(o,"afterEach",n,function(e){return Ln.call(o,e)})}var n;o.isHTML?(n=o.result=r,t(),a()):On({compiler:o.compiler,raw:e},function(e){n=o.compiler.compile(e),n=o.isRemoteUrl?H.sanitize(n,{ADD_TAGS:["script"]}):n,t(),a()})})},Zn._renderCover=function(e,t){var n,r=g(".cover");A(g("main"),t?"add":"remove","hidden"),e?(A(r,"add","show"),(t=(n=this.coverIsHTML?e:this.compiler.cover(e)).trim().match('<p><img.*?data-origin="(.*?)"[^a]+alt="(.*?)">([^<]*?)</p>$'))&&("color"===t[2]?r.style.background=t[1]+(t[3]||""):(e=t[1],A(r,"add","has-mask"),te(t[1])||(e=se(this.router.getBasePath(),t[1])),r.style.backgroundImage="url("+e+")",r.style.backgroundSize="cover",r.style.backgroundPosition="center center"),n=n.replace(t[0],"")),this._renderTo(".cover-main",n),Y()):A(r,"remove","show")},Zn._updateRender=function(){var e,t,n,r;e=this,t=g(".app-name-link"),n=e.config.nameLink,r=e.route.path,t&&(c(e.config.nameLink)?t.setAttribute("href",n):"object"==typeof n&&(e=Object.keys(n).filter(function(e){return-1<r.indexOf(e)})[0],t.setAttribute("href",n[e])))},(Gn=Vn)._loadSideAndNav=function(e,t,n,r){var i=this;return function(){if(!n)return r();qn(e,t,n,function(e){i._renderSidebar(e),r()},i,!0)}},Gn._fetch=function(n){var r=this;void 0===n&&(n=u);var i,e,t,a,o,s=this.route.query,l=this.route.path;Hn(l)?(history.replaceState(null,"","#"),this.router.normalize()):(i=ee(s,["id"]),t=(e=this.config).loadNavbar,s=e.requestHeaders,a=e.loadSidebar,o=this.router.getFile(l),s=Yn(o+i,0,s),this.isRemoteUrl=Hn(o),this.isHTML=/\.html$/g.test(o),s.then(function(e,t){return r._renderMain(e,t,r._loadSideAndNav(l,i,a,n))},function(e){r._fetchFallbackPage(l,i,n)||r._fetch404(o,i,n)}),t&&qn(l,i,t,function(e){return r._renderNav(e)},this,!0))},Gn._fetchCover=function(){var t=this,e=this.config,n=e.coverpage,r=e.requestHeaders,i=this.route.query,a=re(this.route.path);if(n){var o=null,e=this.route.path;"string"==typeof n?"/"===e&&(o=n):o=Array.isArray(n)?-1<n.indexOf(e)&&"_coverpage":!0===(e=n[e])?"_coverpage":e;var s=Boolean(o)&&this.config.onlyCover;return o?(o=this.router.getFile(a+o),this.coverIsHTML=/\.html$/g.test(o),Z(o+ee(i,["id"]),!1,r).then(function(e){return t._renderCover(e,s)})):this._renderCover(null,s),s}},Gn.$fetch=function(e,t){var n=this;void 0===e&&(e=u),void 0===t&&(t=this.$resetEvents.bind(this));function r(){W(n,"doneEach"),e()}this._fetchCover()?r():this._fetch(function(){t(),r()})},Gn._fetchFallbackPage=function(n,r,i){var a=this;void 0===i&&(i=u);var e=this.config,t=e.requestHeaders,o=e.fallbackLanguages,s=e.loadSidebar;if(!o)return!1;e=n.split("/")[1];if(-1===o.indexOf(e))return!1;e=this.router.getFile(n.replace(new RegExp("^/"+e),""));return Yn(e+r,0,t).then(function(e,t){return a._renderMain(e,t,a._loadSideAndNav(n,r,s,i))},function(){return a._fetch404(n,r,i)}),!0},Gn._fetch404=function(e,t,n){var r=this;void 0===n&&(n=u);var i=this.config,a=i.loadSidebar,o=i.requestHeaders,i=i.notFoundPage,s=this._loadSideAndNav(e,t,a,n);if(i){e=function(t,e){var n,r=e.notFoundPage,i="_404"+(e.ext||".md");switch(typeof r){case"boolean":n=i;break;case"string":n=r;break;case"object":n=(e=Object.keys(r).sort(function(e,t){return t.length-e.length}).filter(function(e){return t.match(new RegExp("^"+e))})[0])&&r[e]||i}return n}(e,this.config);return Yn(this.router.getFile(e),0,o).then(function(e,t){return r._renderMain(e,t,s)},function(){return r._renderMain(null,{},s)}),!0}return this._renderMain(null,{},s),!1},Vn.$resetEvents=function(e){var t=this,n=this.config.auto2top;"history"!==e&&(t.route.query.id&&_e(t.route.path,t.route.query.id),"navigate"===e&&n&&(void 0===(n=n)&&(n=0),Se.scrollTop=!0===n?0:Number(n))),this.config.loadNavbar&&X(this.router,"nav")},window.Docsify={util:Un,dom:t,get:Z,slugify:vn,version:"4.12.0"},window.DocsifyCompiler=Tn,window.marked=un,window.Prism=xn,e(function(e){return new Bn})}();
diff --git a/api/static/search.js b/api/static/search.js
new file mode 100644
index 0000000..cf22e38
--- /dev/null
+++ b/api/static/search.js
@@ -0,0 +1,555 @@
+(function () {
+    /**
+     * Converts a colon formatted string to a object with properties.
+     *
+     * This is process a provided string and look for any tokens in the format
+     * of `:name[=value]` and then convert it to a object and return.
+     * An example of this is ':include :type=code :fragment=demo' is taken and
+     * then converted to:
+     *
+     * ```
+     * {
+     *  include: '',
+     *  type: 'code',
+     *  fragment: 'demo'
+     * }
+     * ```
+     *
+     * @param {string}   str   The string to parse.
+     *
+     * @return {object}  The original string and parsed object, { str, config }.
+     */
+    function getAndRemoveConfig(str) {
+        if (str === void 0) str = '';
+
+        var config = {};
+
+        if (str) {
+            str = str
+                .replace(/^('|")/, '')
+                .replace(/('|")$/, '')
+                .replace(/(?:^|\s):([\w-]+:?)=?([\w-%]+)?/g, function (m, key, value) {
+                    if (key.indexOf(':') === -1) {
+                        config[key] = (value && value.replace(/&quot;/g, '')) || true;
+                        return '';
+                    }
+
+                    return m;
+                })
+                .trim();
+        }
+
+        return { str: str, config: config };
+    }
+
+    /* eslint-disable no-unused-vars */
+
+    var INDEXS = {};
+
+    var LOCAL_STORAGE = {
+        EXPIRE_KEY: 'docsify.search.expires',
+        INDEX_KEY: 'docsify.search.index',
+    };
+
+    function resolveExpireKey(namespace) {
+        return namespace
+            ? ((LOCAL_STORAGE.EXPIRE_KEY) + '/' + namespace)
+            : LOCAL_STORAGE.EXPIRE_KEY;
+    }
+
+    function resolveIndexKey(namespace) {
+        return namespace
+            ? ((LOCAL_STORAGE.INDEX_KEY) + '/' + namespace)
+            : LOCAL_STORAGE.INDEX_KEY;
+    }
+
+    function escapeHtml(string) {
+        var entityMap = {
+            '&': '&amp;',
+            '<': '&lt;',
+            '>': '&gt;',
+            '"': '&quot;',
+            '\'': '&#39;',
+        };
+
+        return String(string).replace(/[&<>"']/g, function (s) {
+            return entityMap[s];
+        });
+    }
+
+    function getAllPaths(router) {
+        var paths = [];
+
+        Docsify.dom
+            .findAll('.sidebar-nav a:not(.section-link):not([data-nosearch])')
+            .forEach(function (node) {
+                var href = node.href;
+                var originHref = node.getAttribute('href');
+                var path = router.parse(href).path;
+
+                if (
+                    path &&
+                    paths.indexOf(path) === -1 &&
+                    !Docsify.util.isAbsolutePath(originHref)
+                ) {
+                    paths.push(path);
+                }
+            });
+
+        return paths;
+    }
+
+    function getTableData(token) {
+        if (!token.text && token.type === 'table') {
+            token.cells.unshift(token.header);
+            token.text = token.cells
+                .map(function (rows) {
+                    return rows.join(' | ');
+                })
+                .join(' |\n ');
+        }
+        return token.text;
+    }
+
+    function getListData(token) {
+        if (!token.text && token.type === 'list') {
+            token.text = token.raw;
+        }
+        return token.text;
+    }
+
+    function saveData(maxAge, expireKey, indexKey) {
+        localStorage.setItem(expireKey, Date.now() + maxAge);
+        localStorage.setItem(indexKey, JSON.stringify(INDEXS));
+    }
+
+    function genIndex(path, content, router, depth) {
+        if (content === void 0) content = '';
+
+        var tokens = window.marked.lexer(content);
+        var slugify = window.Docsify.slugify;
+        var index = {};
+        var slug;
+        var title = '';
+
+        tokens.forEach(function (token, tokenIndex) {
+            if (token.type === 'heading' && token.depth <= depth) {
+                var ref = getAndRemoveConfig(token.text);
+                var str = ref.str;
+                var config = ref.config;
+
+                if (config.id) {
+                    slug = router.toURL(path, { id: slugify(config.id) });
+                } else {
+                    slug = router.toURL(path, { id: slugify(escapeHtml(token.text)) });
+                }
+
+                if (str) {
+                    title = str
+                        .replace(/<!-- {docsify-ignore} -->/, '')
+                        .replace(/{docsify-ignore}/, '')
+                        .replace(/<!-- {docsify-ignore-all} -->/, '')
+                        .replace(/{docsify-ignore-all}/, '')
+                        .trim();
+                }
+
+                index[slug] = { slug: slug, title: title, body: '' };
+            } else {
+                if (tokenIndex === 0) {
+                    slug = router.toURL(path);
+                    index[slug] = {
+                        slug: slug,
+                        title: path !== '/' ? path.slice(1) : 'Home Page',
+                        body: token.text || '',
+                    };
+                }
+
+                if (!slug) {
+                    return;
+                }
+
+                if (!index[slug]) {
+                    index[slug] = { slug: slug, title: '', body: '' };
+                } else if (index[slug].body) {
+                    token.text = getTableData(token);
+                    token.text = getListData(token);
+
+                    index[slug].body += '\n' + (token.text || '');
+                } else {
+                    token.text = getTableData(token);
+                    token.text = getListData(token);
+
+                    index[slug].body = index[slug].body
+                        ? index[slug].body + token.text
+                        : token.text;
+                }
+            }
+        });
+        slugify.clear();
+        return index;
+    }
+
+    function ignoreDiacriticalMarks(keyword) {
+        if (keyword && keyword.normalize) {
+            return keyword.normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+        }
+        return keyword;
+    }
+
+    /**
+     * @param {String} query Search query
+     * @returns {Array} Array of results
+     */
+    function search(query) {
+        var matchingResults = [];
+        var data = [];
+        Object.keys(INDEXS).forEach(function (key) {
+            data = data.concat(Object.keys(INDEXS[key]).map(function (page) {
+                return INDEXS[key][page];
+            }));
+        });
+
+        query = query.trim();
+        var keywords = query.split(/[\s\-，\\/]+/);
+        if (keywords.length !== 1) {
+            keywords = [].concat(query, keywords);
+        }
+
+        var loop = function (i) {
+            var post = data[i];
+            var matchesScore = 0;
+            var resultStr = '';
+            var handlePostTitle = '';
+            var handlePostContent = '';
+            var postTitle = post.title && post.title.trim();
+            var postContent = post.body && post.body.trim();
+            var postUrl = post.slug || '';
+
+            if (postTitle) {
+                keywords.forEach(function (keyword) {
+                    // From https://github.com/sindresorhus/escape-string-regexp
+                    var regEx = new RegExp(
+                        escapeHtml(ignoreDiacriticalMarks(keyword)).replace(
+                            /[|\\{}()[\]^$+*?.]/g,
+                            '\\$&',
+                        ),
+                        'gi',
+                    );
+                    var indexTitle = -1;
+                    var indexContent = -1;
+                    handlePostTitle = postTitle
+                        ? escapeHtml(ignoreDiacriticalMarks(postTitle))
+                        : postTitle;
+                    handlePostContent = postContent
+                        ? escapeHtml(ignoreDiacriticalMarks(postContent))
+                        : postContent;
+
+                    indexTitle = postTitle ? handlePostTitle.search(regEx) : -1;
+                    indexContent = postContent ? handlePostContent.search(regEx) : -1;
+
+                    if (indexTitle >= 0 || indexContent >= 0) {
+                        matchesScore += indexTitle >= 0 ? 3 : indexContent >= 0 ? 2 : 0;
+                        if (indexContent < 0) {
+                            indexContent = 0;
+                        }
+
+                        var start = 0;
+                        var end = 0;
+
+                        start = indexContent < 11 ? 0 : indexContent - 10;
+                        end = start === 0 ? 70 : indexContent + keyword.length + 60;
+
+                        if (postContent && end > postContent.length) {
+                            end = postContent.length;
+                        }
+
+                        var matchContent =
+                            '...' +
+                            handlePostContent
+                                .substring(start, end)
+                                .replace(
+                                    regEx,
+                                    function (word) {
+                                        return ('<em class="search-keyword">' + word + '</em>');
+                                    },
+                                ) +
+                            '...';
+
+                        resultStr += matchContent;
+                    }
+                });
+
+                if (matchesScore > 0) {
+                    var matchingPost = {
+                        title: handlePostTitle,
+                        content: postContent ? resultStr : '',
+                        url: postUrl,
+                        score: matchesScore,
+                    };
+
+                    matchingResults.push(matchingPost);
+                }
+            }
+        };
+
+        for (var i = 0; i < data.length; i++) loop(i);
+
+        return matchingResults.sort(function (r1, r2) {
+            return r2.score - r1.score;
+        });
+    }
+
+    function init(config, vm) {
+        var isAuto = config.paths === 'auto';
+        var paths = isAuto ? getAllPaths(vm.router) : config.paths;
+
+        var namespaceSuffix = '';
+
+        // only in auto mode
+        if (paths.length && isAuto && config.pathNamespaces) {
+            var path = paths[0];
+
+            if (Array.isArray(config.pathNamespaces)) {
+                namespaceSuffix =
+                    config.pathNamespaces.filter(
+                        function (prefix) {
+                            return path.slice(0, prefix.length) === prefix;
+                        },
+                    )[0] || namespaceSuffix;
+            } else if (config.pathNamespaces instanceof RegExp) {
+                var matches = path.match(config.pathNamespaces);
+
+                if (matches) {
+                    namespaceSuffix = matches[0];
+                }
+            }
+            var isExistHome = paths.indexOf(namespaceSuffix + '/') === -1;
+            var isExistReadme = paths.indexOf(namespaceSuffix + '/README') === -1;
+            if (isExistHome && isExistReadme) {
+                paths.unshift(namespaceSuffix + '/');
+            }
+        } else if (paths.indexOf('/') === -1 && paths.indexOf('/README') === -1) {
+            paths.unshift('/');
+        }
+
+        var expireKey = resolveExpireKey(config.namespace) + namespaceSuffix;
+        var indexKey = resolveIndexKey(config.namespace) + namespaceSuffix;
+
+        var isExpired = localStorage.getItem(expireKey) < Date.now();
+
+        INDEXS = JSON.parse(localStorage.getItem(indexKey));
+
+        if (isExpired) {
+            INDEXS = {};
+        } else if (!isAuto) {
+            return;
+        }
+
+        var len = paths.length;
+        var count = 0;
+
+        paths.forEach(function (path) {
+            if (INDEXS[path]) {
+                return count++;
+            }
+
+            Docsify.get(vm.router.getFile(path), false, vm.config.requestHeaders).then(
+                function (result) {
+                    INDEXS[path] = genIndex(path, result, vm.router, config.depth);
+                    len === ++count && saveData(config.maxAge, expireKey, indexKey);
+                },
+            );
+        });
+    }
+
+    /* eslint-disable no-unused-vars */
+
+    var NO_DATA_TEXT = '';
+    var options;
+
+    function style() {
+        var code = '\n.sidebar {\n  padding-top: 0;\n}\n\n.search {\n  margin-bottom: 20px;\n  padding: 6px;\n  border-bottom: 1px solid #eee;\n}\n\n.search .input-wrap {\n  display: flex;\n  align-items: center;\n}\n\n.search .results-panel {\n  display: none;\n}\n\n.search .results-panel.show {\n  display: block;\n}\n\n.search input {\n  outline: none;\n  border: none;\n  width: 100%;\n  padding: 0 7px;\n  line-height: 36px;\n  font-size: 14px;\n  border: 1px solid transparent;\n}\n\n.search input:focus {\n  box-shadow: 0 0 5px var(--theme-color, #42b983);\n  border: 1px solid var(--theme-color, #42b983);\n}\n\n.search input::-webkit-search-decoration,\n.search input::-webkit-search-cancel-button,\n.search input {\n  -webkit-appearance: none;\n  -moz-appearance: none;\n  appearance: none;\n}\n.search .clear-button {\n  cursor: pointer;\n  width: 36px;\n  text-align: right;\n  display: none;\n}\n\n.search .clear-button.show {\n  display: block;\n}\n\n.search .clear-button svg {\n  transform: scale(.5);\n}\n\n.search h2 {\n  font-size: 17px;\n  margin: 10px 0;\n}\n\n.search a {\n  text-decoration: none;\n  color: inherit;\n}\n\n.search .matching-post {\n  border-bottom: 1px solid #eee;\n}\n\n.search .matching-post:last-child {\n  border-bottom: 0;\n}\n\n.search p {\n  font-size: 14px;\n  overflow: hidden;\n  text-overflow: ellipsis;\n  display: -webkit-box;\n  -webkit-line-clamp: 2;\n  -webkit-box-orient: vertical;\n}\n\n.search p.empty {\n  text-align: center;\n}\n\n.app-name.hide, .sidebar-nav.hide {\n  display: none;\n}';
+
+        Docsify.dom.style(code);
+    }
+
+    function tpl(defaultValue) {
+        if (defaultValue === void 0) defaultValue = '';
+
+        var html = '<div class="input-wrap">\n      <input type="search" value="' + defaultValue + '" aria-label="Search text" />\n      <div class="clear-button">\n        <svg width="26" height="24">\n          <circle cx="12" cy="12" r="11" fill="#ccc" />\n          <path stroke="white" stroke-width="2" d="M8.25,8.25,15.75,15.75" />\n          <path stroke="white" stroke-width="2"d="M8.25,15.75,15.75,8.25" />\n        </svg>\n      </div>\n    </div>\n    <div class="results-panel"></div>\n    </div>';
+        var el = Docsify.dom.create('div', html);
+        var aside = Docsify.dom.find('aside');
+
+        Docsify.dom.toggleClass(el, 'search');
+        Docsify.dom.before(aside, el);
+    }
+
+    function doSearch(value) {
+        var $search = Docsify.dom.find('div.search');
+        var $panel = Docsify.dom.find($search, '.results-panel');
+        var $clearBtn = Docsify.dom.find($search, '.clear-button');
+        var $sidebarNav = Docsify.dom.find('.sidebar-nav');
+        var $appName = Docsify.dom.find('.app-name');
+
+        if (!value) {
+            $panel.classList.remove('show');
+            $clearBtn.classList.remove('show');
+            $panel.innerHTML = '';
+
+            if (options.hideOtherSidebarContent) {
+                $sidebarNav && $sidebarNav.classList.remove('hide');
+                $appName && $appName.classList.remove('hide');
+            }
+
+            return;
+        }
+
+        var matchs = search(value);
+
+        var html = '';
+        matchs.forEach(function (post) {
+            html += '<div class="matching-post">\n<a href="' + (post.url) + '">\n<h2>' + (post.title) + '</h2>\n<p>' + (post.content) + '</p>\n</a>\n</div>';
+        });
+
+        $panel.classList.add('show');
+        $clearBtn.classList.add('show');
+        $panel.innerHTML = html || ('<p class="empty">' + NO_DATA_TEXT + '</p>');
+        if (options.hideOtherSidebarContent) {
+            $sidebarNav && $sidebarNav.classList.add('hide');
+            $appName && $appName.classList.add('hide');
+        }
+    }
+
+    function bindEvents() {
+        var $search = Docsify.dom.find('div.search');
+        var $input = Docsify.dom.find($search, 'input');
+        var $inputWrap = Docsify.dom.find($search, '.input-wrap');
+
+        var timeId;
+
+        /**
+         Prevent to Fold sidebar.
+
+         When searching on the mobile end,
+         the sidebar is collapsed when you click the INPUT box,
+         making it impossible to search.
+         */
+        Docsify.dom.on(
+            $search,
+            'click',
+            function (e) {
+                return [ 'A', 'H2', 'P', 'EM' ].indexOf(e.target.tagName) === -1 &&
+                    e.stopPropagation();
+            },
+        );
+        Docsify.dom.on($input, 'input', function (e) {
+            clearTimeout(timeId);
+            timeId = setTimeout(function (_) {
+                return doSearch(e.target.value.trim());
+            }, 100);
+        });
+        Docsify.dom.on($inputWrap, 'click', function (e) {
+            // Click input outside
+            if (e.target.tagName !== 'INPUT') {
+                $input.value = '';
+                doSearch();
+            }
+        });
+    }
+
+    function updatePlaceholder(text, path) {
+        var $input = Docsify.dom.getNode('.search input[type="search"]');
+
+        if (!$input) {
+            return;
+        }
+
+        if (typeof text === 'string') {
+            $input.placeholder = text;
+        } else {
+            var match = Object.keys(text).filter(function (key) {
+                return path.indexOf(key) > -1;
+            })[0];
+            $input.placeholder = text[match];
+        }
+    }
+
+    function updateNoData(text, path) {
+        if (typeof text === 'string') {
+            NO_DATA_TEXT = text;
+        } else {
+            var match = Object.keys(text).filter(function (key) {
+                return path.indexOf(key) > -1;
+            })[0];
+            NO_DATA_TEXT = text[match];
+        }
+    }
+
+    function updateOptions(opts) {
+        options = opts;
+    }
+
+    function init$1(opts, vm) {
+        var keywords = vm.router.parse().query.s;
+
+        updateOptions(opts);
+        style();
+        tpl(keywords);
+        bindEvents();
+        keywords && setTimeout(function (_) {
+            return doSearch(keywords);
+        }, 500);
+    }
+
+    function update(opts, vm) {
+        updateOptions(opts);
+        updatePlaceholder(opts.placeholder, vm.route.path);
+        updateNoData(opts.noData, vm.route.path);
+    }
+
+    /* eslint-disable no-unused-vars */
+
+    var CONFIG = {
+        placeholder: 'Type to search',
+        noData: 'No Results!',
+        paths: 'auto',
+        depth: 2,
+        maxAge: 86400000, // 1 day
+        hideOtherSidebarContent: false,
+        namespace: undefined,
+        pathNamespaces: undefined,
+    };
+
+    var install = function (hook, vm) {
+        var util = Docsify.util;
+        var opts = vm.config.search || CONFIG;
+
+        if (Array.isArray(opts)) {
+            CONFIG.paths = opts;
+        } else if (typeof opts === 'object') {
+            CONFIG.paths = Array.isArray(opts.paths) ? opts.paths : 'auto';
+            CONFIG.maxAge = util.isPrimitive(opts.maxAge) ? opts.maxAge : CONFIG.maxAge;
+            CONFIG.placeholder = opts.placeholder || CONFIG.placeholder;
+            CONFIG.noData = opts.noData || CONFIG.noData;
+            CONFIG.depth = opts.depth || CONFIG.depth;
+            CONFIG.hideOtherSidebarContent =
+                opts.hideOtherSidebarContent || CONFIG.hideOtherSidebarContent;
+            CONFIG.namespace = opts.namespace || CONFIG.namespace;
+            CONFIG.pathNamespaces = opts.pathNamespaces || CONFIG.pathNamespaces;
+        }
+
+        var isAuto = CONFIG.paths === 'auto';
+
+        hook.mounted(function (_) {
+            init$1(CONFIG, vm);
+            !isAuto && init(CONFIG, vm);
+        });
+        hook.doneEach(function (_) {
+            update(CONFIG, vm);
+            isAuto && init(CONFIG, vm);
+        });
+    };
+
+    $docsify.plugins = [].concat(install, $docsify.plugins);
+
+}());
\ No newline at end of file
diff --git a/api/static/search.min.js b/api/static/search.min.js
deleted file mode 100644
index 5c426b2..0000000
--- a/api/static/search.min.js
+++ /dev/null
@@ -1 +0,0 @@
-!function(){var n,e={};function t(n){var e={"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;","/":"&#x2F;"};return String(n).replace(/[&<>"'/]/g,function(n){return e[n]})}function o(t,o){n=Docsify;var a="auto"===t.paths,i=localStorage.getItem("docsify.search.expires")<Date.now();if(e=JSON.parse(localStorage.getItem("docsify.search.index")),i)e={};else if(!a)return;var r=a?function(e){var t=[];return n.dom.findAll("a:not([data-nosearch])").forEach(function(n){var o=n.href,a=n.getAttribute("href"),i=e.parse(o).path;i&&-1===t.indexOf(i)&&!Docsify.util.isAbsolutePath(a)&&t.push(i)}),t}(o.router):t.paths,s=r.length,c=0;r.forEach(function(a){if(e[a])return c++;n.get(o.router.getFile(a),!1,o.config.requestHeaders).then(function(n){e[a]=function(n,e,t,o){void 0===e&&(e="");var a,i=window.marked.lexer(e),r=window.Docsify.slugify,s={};return i.forEach(function(e){if("heading"===e.type&&e.depth<=o)a=t.toURL(n,{id:r(e.text)}),s[a]={slug:a,title:e.text,body:""};else{if(!a)return;s[a]?s[a].body?s[a].body+="\n"+(e.text||""):s[a].body=e.text:s[a]={slug:a,title:"",body:""}}}),r.clear(),s}(a,n,o.router,t.depth),s===++c&&(i=t.maxAge,localStorage.setItem("docsify.search.expires",Date.now()+i),localStorage.setItem("docsify.search.index",JSON.stringify(e)));var i})})}var a="";function i(n){var o=Docsify.dom.find("div.search"),i=Docsify.dom.find(o,".results-panel"),r=Docsify.dom.find(o,".clear-button");if(!n)return i.classList.remove("show"),r.classList.remove("show"),void(i.innerHTML="");var s="";(function(n){var o=[],a=[];Object.keys(e).forEach(function(n){a=a.concat(Object.keys(e[n]).map(function(t){return e[n][t]}))});var i=(n=n.trim()).split(/[\s\-，\\/]+/);1!==i.length&&(i=[].concat(n,i));for(var r=function(n){var e=a[n],r=!1,s="",c=e.title&&e.title.trim(),l=e.body&&e.body.trim(),d=e.slug||"";if(c&&l&&(i.forEach(function(n){var e=new RegExp(n.replace(/[|\\{}()[\]^$+*?.]/g,"\\$&"),"gi"),o=-1,a=-1;if(o=c&&c.search(e),a=l&&l.search(e),o<0&&a<0)r=!1;else{r=!0,a<0&&(a=0);var i=0,d=0;(d=0==(i=a<11?0:a-10)?70:a+n.length+60)>l.length&&(d=l.length);var h="..."+t(l).substring(i,d).replace(e,'<em class="search-keyword">'+n+"</em>")+"...";s+=h}}),r)){var h={title:t(c),content:s,url:d};o.push(h)}},s=0;s<a.length;s++)r(s);return o})(n).forEach(function(n){s+='<div class="matching-post">\n<a href="'+n.url+'">\n<h2>'+n.title+"</h2>\n<p>"+n.content+"</p>\n</a>\n</div>"}),i.classList.add("show"),r.classList.add("show"),i.innerHTML=s||'<p class="empty">'+a+"</p>"}function r(n,e){var t=e.router.parse().query.s;Docsify.dom.style("\n.sidebar {\npadding-top: 0;\n}\n\n.search {\nmargin-bottom: 20px;\npadding: 6px;\nborder-bottom: 1px solid #eee;\n}\n\n.search .input-wrap {\ndisplay: flex;\nalign-items: center;\n}\n\n.search .results-panel {\ndisplay: none;\n}\n\n.search .results-panel.show {\ndisplay: block;\n}\n\n.search input {\noutline: none;\nborder: none;\nwidth: 100%;\npadding: 0 7px;\nline-height: 36px;\nfont-size: 14px;\n}\n\n.search input::-webkit-search-decoration,\n.search input::-webkit-search-cancel-button,\n.search input {\n-webkit-appearance: none;\n-moz-appearance: none;\nappearance: none;\n}\n.search .clear-button {\nwidth: 36px;\ntext-align: right;\ndisplay: none;\n}\n\n.search .clear-button.show {\ndisplay: block;\n}\n\n.search .clear-button svg {\ntransform: scale(.5);\n}\n\n.search h2 {\nfont-size: 17px;\nmargin: 10px 0;\n}\n\n.search a {\ntext-decoration: none;\ncolor: inherit;\n}\n\n.search .matching-post {\nborder-bottom: 1px solid #eee;\n}\n\n.search .matching-post:last-child {\nborder-bottom: 0;\n}\n\n.search p {\nfont-size: 14px;\noverflow: hidden;\ntext-overflow: ellipsis;\ndisplay: -webkit-box;\n-webkit-line-clamp: 2;\n-webkit-box-orient: vertical;\n}\n\n.search p.empty {\ntext-align: center;\n}"),function(n,e){void 0===e&&(e="");var t='<div class="input-wrap">\n<input type="search" value="'+e+'" />\n<div class="clear-button">\n<svg width="26" height="24">\n<circle cx="12" cy="12" r="11" fill="#ccc" />\n<path stroke="white" stroke-width="2" d="M8.25,8.25,15.75,15.75" />\n<path stroke="white" stroke-width="2"d="M8.25,15.75,15.75,8.25" />\n</svg>\n</div>\n</div>\n<div class="results-panel"></div>\n</div>',o=Docsify.dom.create("div",t),a=Docsify.dom.find("aside");Docsify.dom.toggleClass(o,"search"),Docsify.dom.before(a,o)}(0,t),function(){var n,e=Docsify.dom.find("div.search"),t=Docsify.dom.find(e,"input"),o=Docsify.dom.find(e,".input-wrap");Docsify.dom.on(e,"click",function(n){return"A"!==n.target.tagName&&n.stopPropagation()}),Docsify.dom.on(t,"input",function(e){clearTimeout(n),n=setTimeout(function(n){return i(e.target.value.trim())},100)}),Docsify.dom.on(o,"click",function(n){"INPUT"!==n.target.tagName&&(t.value="",i())})}(),t&&setTimeout(function(n){return i(t)},500)}function s(n,e){!function(n,e){var t=Docsify.dom.getNode('.search input[type="search"]');if(t)if("string"==typeof n)t.placeholder=n;else{var o=Object.keys(n).filter(function(n){return e.indexOf(n)>-1})[0];t.placeholder=n[o]}}(n.placeholder,e.route.path),function(n,e){if("string"==typeof n)a=n;else{var t=Object.keys(n).filter(function(n){return e.indexOf(n)>-1})[0];a=n[t]}}(n.noData,e.route.path)}var c={placeholder:"搜索文档",noData:"无搜索结果",paths:"auto",depth:2,maxAge:864e5};$docsify.plugins=[].concat(function(n,e){var t=Docsify.util,a=e.config.search||c;Array.isArray(a)?c.paths=a:"object"==typeof a&&(c.paths=Array.isArray(a.paths)?a.paths:"auto",c.maxAge=t.isPrimitive(a.maxAge)?a.maxAge:c.maxAge,c.placeholder=a.placeholder||c.placeholder,c.noData=a.noData||c.noData,c.depth=a.depth||c.depth);var i="auto"===c.paths;n.mounted(function(n){r(0,e),!i&&o(c,e)}),n.doneEach(function(n){s(c,e),i&&o(c,e)})},$docsify.plugins)}();
diff --git a/api/static/vue.css b/api/static/vue.css
index 028ac3b..19f1164 100644
--- a/api/static/vue.css
+++ b/api/static/vue.css
@@ -1 +1,1250 @@
-@import url("https://fonts.googleapis.com/css?family=Roboto+Mono|Source+Sans+Pro:300,400,600");*{-webkit-font-smoothing:antialiased;-webkit-overflow-scrolling:touch;-webkit-tap-highlight-color:rgba(0,0,0,0);-webkit-text-size-adjust:none;-webkit-touch-callout:none;box-sizing:border-box}body:not(.ready){overflow:hidden}body:not(.ready) .app-nav,body:not(.ready)>nav,body:not(.ready) [data-cloak]{display:none}div#app{font-size:30px;font-weight:lighter;margin:40vh auto;text-align:center}div#app:empty:before{content:"Loading..."}.emoji{height:1.2rem;vertical-align:middle}.progress{background-color:var(--theme-color,#42b983);height:2px;left:0;position:fixed;right:0;top:0;transition:width .2s,opacity .4s;width:0;z-index:999999}.search .search-keyword,.search a:hover{color:var(--theme-color,#42b983)}.search .search-keyword{font-style:normal;font-weight:700}body,html{height:100%}body{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;color:#34495e;font-family:Source Sans Pro,Helvetica Neue,Arial,sans-serif;font-size:15px;letter-spacing:0;margin:0;overflow-x:hidden}img{max-width:100%}a[disabled]{cursor:not-allowed;opacity:.6}kbd{border:1px solid #ccc;border-radius:3px;display:inline-block;font-size:12px!important;line-height:12px;margin-bottom:3px;padding:3px 5px;vertical-align:middle}li input[type=checkbox]{margin:0 .2em .25em 0;vertical-align:middle}.app-nav{margin:25px 60px 0 0;position:absolute;right:0;text-align:right;z-index:10}.app-nav.no-badge{margin-right:25px}.app-nav p{margin:0}.app-nav>a{margin:0 1rem;padding:5px 0}.app-nav li,.app-nav ul{display:inline-block;list-style:none;margin:0}.app-nav a{color:inherit;font-size:16px;text-decoration:none;transition:color .3s}.app-nav a.active,.app-nav a:hover{color:var(--theme-color,#42b983)}.app-nav a.active{border-bottom:2px solid var(--theme-color,#42b983)}.app-nav li{display:inline-block;margin:0 1rem;padding:5px 0;position:relative;cursor:pointer}.app-nav li ul{background-color:#fff;border:1px solid;border-color:#ddd #ddd #ccc;border-radius:4px;box-sizing:border-box;display:none;max-height:calc(100vh - 61px);overflow-y:auto;padding:10px 0;position:absolute;right:-15px;text-align:left;top:100%;white-space:nowrap}.app-nav li ul li{display:block;font-size:14px;line-height:1rem;margin:8px 14px;white-space:nowrap}.app-nav li ul a{display:block;font-size:inherit;margin:0;padding:0}.app-nav li ul a.active{border-bottom:0}.app-nav li:hover ul{display:block}.github-corner{border-bottom:0;position:fixed;right:0;text-decoration:none;top:0;z-index:1}.github-corner:hover .octo-arm{-webkit-animation:octocat-wave .56s ease-in-out;animation:octocat-wave .56s ease-in-out}.github-corner svg{color:#fff;fill:var(--theme-color,#42b983);height:80px;width:80px}main{display:block;position:relative;width:100vw;height:100%;z-index:0}main.hidden{display:none}.anchor{display:inline-block;text-decoration:none;transition:all .3s}.anchor span{color:#34495e}.anchor:hover{text-decoration:underline}.sidebar{border-right:1px solid rgba(0,0,0,.07);overflow-y:auto;padding:40px 0 0;position:absolute;top:0;bottom:0;left:0;transition:transform .25s ease-out;width:300px;z-index:20}.sidebar>h1{margin:0 auto 1rem;font-size:1.5rem;font-weight:300;text-align:center}.sidebar>h1 a{color:inherit;text-decoration:none}.sidebar>h1 .app-nav{display:block;position:static}.sidebar .sidebar-nav{line-height:2em;padding-bottom:40px}.sidebar li.collapse .app-sub-sidebar{display:none}.sidebar ul{margin:0 0 0 15px;padding:0}.sidebar li>p{font-weight:700;margin:0}.sidebar ul,.sidebar ul li{list-style:none}.sidebar ul li a{border-bottom:none;display:block}.sidebar ul li ul{padding-left:20px}.sidebar::-webkit-scrollbar{width:4px}.sidebar::-webkit-scrollbar-thumb{background:transparent;border-radius:4px}.sidebar:hover::-webkit-scrollbar-thumb{background:hsla(0,0%,53.3%,.4)}.sidebar:hover::-webkit-scrollbar-track{background:hsla(0,0%,53.3%,.1)}.sidebar-toggle{background-color:transparent;background-color:hsla(0,0%,100%,.8);border:0;outline:none;padding:10px;position:absolute;bottom:0;left:0;text-align:center;transition:opacity .3s;width:284px;z-index:30;cursor:pointer}.sidebar-toggle:hover .sidebar-toggle-button{opacity:.4}.sidebar-toggle span{background-color:var(--theme-color,#42b983);display:block;margin-bottom:4px;width:16px;height:2px}body.sticky .sidebar,body.sticky .sidebar-toggle{position:fixed}.content{padding-top:60px;position:absolute;top:0;right:0;bottom:0;left:300px;transition:left .25s ease}.markdown-section{margin:0 auto;max-width:80%;padding:30px 15px 40px;position:relative}.markdown-section>*{box-sizing:border-box;font-size:inherit}.markdown-section>:first-child{margin-top:0!important}.markdown-section hr{border:none;border-bottom:1px solid #eee;margin:2em 0}.markdown-section iframe{border:1px solid #eee;width:1px;min-width:100%}.markdown-section table{border-collapse:collapse;border-spacing:0;display:block;margin-bottom:1rem;overflow:auto;width:100%}.markdown-section th{font-weight:700}.markdown-section td,.markdown-section th{border:1px solid #ddd;padding:6px 13px}.markdown-section tr{border-top:1px solid #ccc}.markdown-section p.tip,.markdown-section tr:nth-child(2n){background-color:#f8f8f8}.markdown-section p.tip{border-bottom-right-radius:2px;border-left:4px solid #f66;border-top-right-radius:2px;margin:2em 0;padding:12px 24px 12px 30px;position:relative}.markdown-section p.tip:before{background-color:#f66;border-radius:100%;color:#fff;content:"!";font-family:Dosis,Source Sans Pro,Helvetica Neue,Arial,sans-serif;font-size:14px;font-weight:700;left:-12px;line-height:20px;position:absolute;height:20px;width:20px;text-align:center;top:14px}.markdown-section p.tip code{background-color:#efefef}.markdown-section p.tip em{color:#34495e}.markdown-section p.warn{background:rgba(66,185,131,.1);border-radius:2px;padding:1rem}.markdown-section ul.task-list>li{list-style-type:none}body.close .sidebar{transform:translateX(-300px)}body.close .sidebar-toggle{width:auto}body.close .content{left:0}@media print{.app-nav,.github-corner,.sidebar,.sidebar-toggle{display:none}}@media screen and (max-width:768px){.github-corner,.sidebar,.sidebar-toggle{position:fixed}.app-nav{margin-top:16px}.app-nav li ul{top:30px}main{height:auto;overflow-x:hidden}.sidebar{left:-300px;transition:transform .25s ease-out}.content{left:0;max-width:100vw;position:static;padding-top:20px;transition:transform .25s ease}.app-nav,.github-corner{transition:transform .25s ease-out}.sidebar-toggle{background-color:transparent;width:auto;padding:30px 30px 10px 10px}body.close .sidebar{transform:translateX(300px)}body.close .sidebar-toggle{background-color:hsla(0,0%,100%,.8);transition:background-color 1s;width:284px;padding:10px}body.close .content{transform:translateX(300px)}body.close .app-nav,body.close .github-corner{display:none}.github-corner:hover .octo-arm{-webkit-animation:none;animation:none}.github-corner .octo-arm{-webkit-animation:octocat-wave .56s ease-in-out;animation:octocat-wave .56s ease-in-out}}@-webkit-keyframes octocat-wave{0%,to{transform:rotate(0)}20%,60%{transform:rotate(-25deg)}40%,80%{transform:rotate(10deg)}}@keyframes octocat-wave{0%,to{transform:rotate(0)}20%,60%{transform:rotate(-25deg)}40%,80%{transform:rotate(10deg)}}section.cover{align-items:center;background-position:50%;background-repeat:no-repeat;background-size:cover;height:100vh;width:100vw;display:none}section.cover.show{display:flex}section.cover.has-mask .mask{background-color:#fff;opacity:.8;position:absolute;top:0;height:100%;width:100%}section.cover .cover-main{flex:1;margin:-20px 16px 0;text-align:center;position:relative}section.cover a{color:inherit}section.cover a,section.cover a:hover{text-decoration:none}section.cover p{line-height:1.5rem;margin:1em 0}section.cover h1{color:inherit;font-size:2.5rem;font-weight:300;margin:.625rem 0 2.5rem;position:relative;text-align:center}section.cover h1 a{display:block}section.cover h1 small{bottom:-.4375rem;font-size:1rem;position:absolute}section.cover blockquote{font-size:1.5rem;text-align:center}section.cover ul{line-height:1.8;list-style-type:none;margin:1em auto;max-width:500px;padding:0}section.cover .cover-main>p:last-child a{border-radius:2rem;border:1px solid var(--theme-color,#42b983);box-sizing:border-box;color:var(--theme-color,#42b983);display:inline-block;font-size:1.05rem;letter-spacing:.1rem;margin:.5rem 1rem;padding:.75em 2rem;text-decoration:none;transition:all .15s ease}section.cover .cover-main>p:last-child a:last-child{background-color:var(--theme-color,#42b983);color:#fff}section.cover .cover-main>p:last-child a:last-child:hover{color:inherit;opacity:.8}section.cover .cover-main>p:last-child a:hover{color:inherit}section.cover blockquote>p>a{border-bottom:2px solid var(--theme-color,#42b983);transition:color .3s}section.cover blockquote>p>a:hover{color:var(--theme-color,#42b983)}.sidebar,body{background-color:#fff}.sidebar{color:#364149}.sidebar li{margin:6px 0}.sidebar ul li a{color:#505d6b;font-size:14px;font-weight:400;overflow:hidden;text-decoration:none;text-overflow:ellipsis;white-space:nowrap}.sidebar ul li a:hover{text-decoration:underline}.sidebar ul li ul{padding:0}.sidebar ul li.active>a{border-right:2px solid;color:var(--theme-color,#42b983);font-weight:600}.app-sub-sidebar li:before{content:"-";padding-right:4px;float:left}.markdown-section h1,.markdown-section h2,.markdown-section h3,.markdown-section h4,.markdown-section strong{color:#2c3e50;font-weight:600}.markdown-section a{color:var(--theme-color,#42b983);font-weight:600}.markdown-section h1{font-size:2rem;margin:0 0 1rem}.markdown-section h2{font-size:1.75rem;margin:45px 0 .8rem}.markdown-section h3{font-size:1.5rem;margin:40px 0 .6rem}.markdown-section h4{font-size:1.25rem}.markdown-section h5{font-size:1rem}.markdown-section h6{color:#777;font-size:1rem}.markdown-section figure,.markdown-section p{margin:1.2em 0}.markdown-section ol,.markdown-section p,.markdown-section ul{line-height:1.6rem;word-spacing:.05rem}.markdown-section ol,.markdown-section ul{padding-left:1.5rem}.markdown-section blockquote{border-left:4px solid var(--theme-color,#42b983);color:#858585;margin:2em 0;padding-left:20px}.markdown-section blockquote p{font-weight:600;margin-left:0}.markdown-section iframe{margin:1em 0}.markdown-section em{color:#7f8c8d}.markdown-section code,.markdown-section output:after,.markdown-section pre{font-family:Roboto Mono,Monaco,courier,monospace}.markdown-section code,.markdown-section pre{background-color:#f8f8f8}.markdown-section output,.markdown-section pre{margin:1.2em 0;position:relative}.markdown-section output,.markdown-section pre>code{border-radius:2px;display:block}.markdown-section output:after,.markdown-section pre>code{-moz-osx-font-smoothing:initial;-webkit-font-smoothing:initial}.markdown-section code{border-radius:2px;color:#e96900;margin:0 2px;padding:3px 5px;white-space:pre-wrap}.markdown-section>:not(h1):not(h2):not(h3):not(h4):not(h5):not(h6) code{font-size:.8rem}.markdown-section pre{padding:0 1.4rem;line-height:1.5rem;overflow:auto;word-wrap:normal}.markdown-section pre>code{color:#525252;font-size:.8rem;padding:2.2em 5px;line-height:inherit;margin:0 2px;max-width:inherit;overflow:inherit;white-space:inherit}.markdown-section output{padding:1.7rem 1.4rem;border:1px dotted #ccc}.markdown-section output>:first-child{margin-top:0}.markdown-section output>:last-child{margin-bottom:0}.markdown-section code:after,.markdown-section code:before,.markdown-section output:after,.markdown-section output:before{letter-spacing:.05rem}.markdown-section output:after,.markdown-section pre:after{color:#ccc;font-size:.6rem;font-weight:600;height:15px;line-height:15px;padding:5px 10px 0;position:absolute;right:0;text-align:right;top:0;content:attr(data-lang)}.token.cdata,.token.comment,.token.doctype,.token.prolog{color:#8e908c}.token.namespace{opacity:.7}.token.boolean,.token.number{color:#c76b29}.token.punctuation{color:#525252}.token.property{color:#c08b30}.token.tag{color:#2973b7}.token.string{color:var(--theme-color,#42b983)}.token.selector{color:#6679cc}.token.attr-name{color:#2973b7}.language-css .token.string,.style .token.string,.token.entity,.token.url{color:#22a2c9}.token.attr-value,.token.control,.token.directive,.token.unit{color:var(--theme-color,#42b983)}.token.function,.token.keyword{color:#e96900}.token.atrule,.token.regex,.token.statement{color:#22a2c9}.token.placeholder,.token.variable{color:#3d8fd1}.token.deleted{text-decoration:line-through}.token.inserted{border-bottom:1px dotted #202746;text-decoration:none}.token.italic{font-style:italic}.token.bold,.token.important{font-weight:700}.token.important{color:#c94922}.token.entity{cursor:help}code .token{-moz-osx-font-smoothing:initial;-webkit-font-smoothing:initial;min-height:1.5rem;position:relative;left:auto}
\ No newline at end of file
+@import url("https://fonts.googleapis.com/css?family=Roboto+Mono|Source+Sans+Pro:300,400,600");
+
+* {
+    -webkit-font-smoothing: antialiased;
+    -webkit-overflow-scrolling: touch;
+    -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
+    -webkit-text-size-adjust: none;
+    -webkit-touch-callout: none;
+    box-sizing: border-box
+}
+
+body:not(.ready) {
+    overflow: hidden
+}
+
+body:not(.ready) .app-nav, body:not(.ready) > nav, body:not(.ready) [data-cloak] {
+    display: none
+}
+
+div#app {
+    font-size: 30px;
+    font-weight: lighter;
+    margin: 40vh auto;
+    text-align: center
+}
+
+div#app:empty:before {
+    content: "Loading..."
+}
+
+.emoji {
+    height: 1.2rem;
+    vertical-align: middle
+}
+
+.progress {
+    background-color: var(--theme-color, #3DB47E);
+    height: 2px;
+    left: 0;
+    position: fixed;
+    right: 0;
+    top: 0;
+    transition: width .2s, opacity .4s;
+    width: 0;
+    z-index: 999999
+}
+
+.search .search-keyword, .search a:hover {
+    color: var(--theme-color, #3DB47E)
+}
+
+.search .search-keyword {
+    font-style: normal;
+    font-weight: 700
+}
+
+body, html {
+    height: 100%
+}
+
+body {
+    -moz-osx-font-smoothing: grayscale;
+    -webkit-font-smoothing: antialiased;
+    color: #34495e;
+    font-family: Source Sans Pro, Helvetica Neue, Arial, sans-serif;
+    font-size: 15px;
+    letter-spacing: 0;
+    margin: 0;
+    overflow-x: hidden
+}
+
+img {
+    max-width: 100%
+}
+
+a[disabled] {
+    cursor: not-allowed;
+    opacity: .6
+}
+
+kbd {
+    border: 1px solid #ccc;
+    border-radius: 3px;
+    display: inline-block;
+    font-size: 12px !important;
+    line-height: 12px;
+    margin-bottom: 3px;
+    padding: 3px 5px;
+    vertical-align: middle
+}
+
+li input[type=checkbox] {
+    margin: 0 .2em .25em 0;
+    vertical-align: middle
+}
+
+.app-nav {
+    margin: 25px 60px 0 0;
+    position: absolute;
+    right: 0;
+    text-align: right;
+    z-index: 10
+}
+
+.app-nav.no-badge {
+    margin-right: 25px
+}
+
+.app-nav p {
+    margin: 0
+}
+
+.app-nav > a {
+    margin: 0 1rem;
+    padding: 5px 0
+}
+
+.app-nav li, .app-nav ul {
+    display: inline-block;
+    list-style: none;
+    margin: 0
+}
+
+.app-nav a {
+    color: inherit;
+    font-size: 16px;
+    text-decoration: none;
+    transition: color .3s
+}
+
+.app-nav a.active, .app-nav a:hover {
+    color: var(--theme-color, #3DB47E)
+}
+
+.app-nav a.active {
+    border-bottom: 2px solid var(--theme-color, #3DB47E)
+}
+
+.app-nav li {
+    display: inline-block;
+    margin: 0 1rem;
+    padding: 5px 0;
+    position: relative;
+    cursor: pointer
+}
+
+.app-nav li ul {
+    background-color: #fff;
+    border: 1px solid;
+    border-color: #ddd #ddd #ccc;
+    border-radius: 4px;
+    box-sizing: border-box;
+    display: none;
+    max-height: calc(100vh - 61px);
+    overflow-y: auto;
+    padding: 10px 0;
+    position: absolute;
+    right: -15px;
+    text-align: left;
+    top: 100%;
+    white-space: nowrap
+}
+
+.app-nav li ul li {
+    display: block;
+    font-size: 14px;
+    line-height: 1rem;
+    margin: 8px 14px;
+    white-space: nowrap
+}
+
+.app-nav li ul a {
+    display: block;
+    font-size: inherit;
+    margin: 0;
+    padding: 0
+}
+
+.app-nav li ul a.active {
+    border-bottom: 0
+}
+
+.app-nav li:hover ul {
+    display: block
+}
+
+.github-corner {
+    border-bottom: 0;
+    position: fixed;
+    right: 0;
+    text-decoration: none;
+    top: 0;
+    z-index: 1
+}
+
+.github-corner:hover .octo-arm {
+    -webkit-animation: octocat-wave .56s ease-in-out;
+    animation: octocat-wave .56s ease-in-out
+}
+
+.github-corner svg {
+    color: #fff;
+    fill: var(--theme-color, #3DB47E);
+    height: 80px;
+    width: 80px
+}
+
+main {
+    display: block;
+    position: relative;
+    width: 100vw;
+    height: 100%;
+    z-index: 0
+}
+
+main.hidden {
+    display: none
+}
+
+.anchor {
+    display: inline-block;
+    text-decoration: none;
+    transition: all .3s
+}
+
+.anchor span {
+    color: #34495e
+}
+
+.anchor:hover {
+    text-decoration: underline
+}
+
+.sidebar {
+    border-right: 1px solid rgba(0, 0, 0, .07);
+    overflow-y: auto;
+    padding: 40px 0 0;
+    position: absolute;
+    top: 0;
+    bottom: 0;
+    left: 0;
+    transition: transform .25s ease-out;
+    width: 300px;
+    z-index: 20
+}
+
+.sidebar > h1 {
+    margin: 0 auto 1rem;
+    font-size: 1.5rem;
+    font-weight: 300;
+    text-align: center
+}
+
+.sidebar > h1 a {
+    color: inherit;
+    text-decoration: none
+}
+
+.sidebar > h1 .app-nav {
+    display: block;
+    position: static
+}
+
+.sidebar .sidebar-nav {
+    line-height: 2em;
+    padding-bottom: 40px
+}
+
+.sidebar li.collapse .app-sub-sidebar {
+    display: none
+}
+
+.sidebar ul {
+    margin: 0 0 0 15px;
+    padding: 0
+}
+
+.sidebar li > p {
+    font-weight: 700;
+    margin: 0
+}
+
+.sidebar ul, .sidebar ul li {
+    list-style: none
+}
+
+.sidebar ul li a {
+    border-bottom: none;
+    display: block
+}
+
+.sidebar ul li ul {
+    padding-left: 20px
+}
+
+.sidebar::-webkit-scrollbar {
+    width: 4px
+}
+
+.sidebar::-webkit-scrollbar-thumb {
+    background: transparent;
+    border-radius: 4px
+}
+
+.sidebar:hover::-webkit-scrollbar-thumb {
+    background: hsla(0, 0%, 53.3%, .4)
+}
+
+.sidebar:hover::-webkit-scrollbar-track {
+    background: hsla(0, 0%, 53.3%, .1)
+}
+
+.sidebar-toggle {
+    background-color: hsla(0, 0%, 100%, .8);
+    border: 0;
+    outline: none;
+    padding: 10px;
+    position: absolute;
+    bottom: 0;
+    left: 0;
+    text-align: center;
+    transition: opacity .3s;
+    width: 284px;
+    z-index: 30;
+    cursor: pointer
+}
+
+.sidebar-toggle:hover .sidebar-toggle-button {
+    opacity: .4
+}
+
+.sidebar-toggle span {
+    background-color: var(--theme-color, #3DB47E);
+    display: block;
+    margin-bottom: 4px;
+    width: 16px;
+    height: 2px
+}
+
+body.sticky .sidebar, body.sticky .sidebar-toggle {
+    position: fixed
+}
+
+.content {
+    padding-top: 60px;
+    position: absolute;
+    top: 0;
+    right: 0;
+    bottom: 0;
+    left: 300px;
+    transition: left .25s ease
+}
+
+.markdown-section {
+    margin: 0 auto;
+    max-width: 80%;
+    padding: 30px 15px 40px;
+    position: relative
+}
+
+.markdown-section > * {
+    box-sizing: border-box;
+    font-size: inherit
+}
+
+.markdown-section > :first-child {
+    margin-top: 0 !important
+}
+
+.markdown-section hr {
+    border: none;
+    border-bottom: 1px solid #CFD8DC;
+    margin: 2em 0
+}
+
+.markdown-section iframe {
+    border: 1px solid #eee;
+    width: 1px;
+    min-width: 100%
+}
+
+.markdown-section table {
+    border-collapse: collapse;
+    border-spacing: 0;
+    display: block;
+    margin-bottom: 1rem;
+    overflow: auto;
+    width: 100%
+}
+
+.markdown-section th {
+    font-weight: 700
+}
+
+.markdown-section td, .markdown-section th {
+    border: 1px solid #ddd;
+    padding: 6px 13px
+}
+
+.markdown-section tr {
+    border-top: 1px solid #ccc
+}
+
+.markdown-section p.tip, .markdown-section tr:nth-child(2n) {
+    background-color: #f8f8f8
+}
+
+.markdown-section p.tip {
+    border-bottom-right-radius: 2px;
+    border-left: 4px solid #f66;
+    border-top-right-radius: 2px;
+    margin: 2em 0;
+    padding: 12px 24px 12px 30px;
+    position: relative
+}
+
+.markdown-section p.tip:before {
+    background-color: #f66;
+    border-radius: 100%;
+    color: #fff;
+    content: "!";
+    font-family: Dosis, Source Sans Pro, Helvetica Neue, Arial, sans-serif;
+    font-size: 14px;
+    font-weight: 700;
+    left: -12px;
+    line-height: 20px;
+    position: absolute;
+    height: 20px;
+    width: 20px;
+    text-align: center;
+    top: 14px
+}
+
+.markdown-section p.tip code {
+    background-color: #efefef
+}
+
+.markdown-section p.tip em {
+    color: #34495e
+}
+
+.markdown-section p.warn {
+    background: rgba(66, 185, 131, .1);
+    border-radius: 2px;
+    padding: 1rem
+}
+
+.markdown-section ul.task-list > li {
+    list-style-type: none
+}
+
+body.close .sidebar {
+    transform: translateX(-300px)
+}
+
+body.close .sidebar-toggle {
+    width: auto
+}
+
+body.close .content {
+    left: 0
+}
+
+@media print {
+    .app-nav, .github-corner, .sidebar, .sidebar-toggle {
+        display: none
+    }
+}
+
+@media screen and (max-width: 768px) {
+    .github-corner, .sidebar, .sidebar-toggle {
+        position: fixed
+    }
+
+    .app-nav {
+        margin-top: 16px
+    }
+
+    .app-nav li ul {
+        top: 30px
+    }
+
+    main {
+        height: auto;
+        overflow-x: hidden
+    }
+
+    .sidebar {
+        left: -300px;
+        transition: transform .25s ease-out
+    }
+
+    .content {
+        left: 0;
+        max-width: 100vw;
+        position: static;
+        padding-top: 20px;
+        transition: transform .25s ease
+    }
+
+    .app-nav, .github-corner {
+        transition: transform .25s ease-out
+    }
+
+    .sidebar-toggle {
+        background-color: transparent;
+        width: auto;
+        padding: 30px 30px 10px 10px
+    }
+
+    body.close .sidebar {
+        transform: translateX(300px)
+    }
+
+    body.close .sidebar-toggle {
+        background-color: hsla(0, 0%, 100%, .8);
+        transition: background-color 1s;
+        width: 284px;
+        padding: 10px
+    }
+
+    body.close .content {
+        transform: translateX(300px)
+    }
+
+    body.close .app-nav, body.close .github-corner {
+        display: none
+    }
+
+    .github-corner:hover .octo-arm {
+        -webkit-animation: none;
+        animation: none
+    }
+
+    .github-corner .octo-arm {
+        -webkit-animation: octocat-wave .56s ease-in-out;
+        animation: octocat-wave .56s ease-in-out
+    }
+}
+
+@-webkit-keyframes octocat-wave {
+    0%, to {
+        transform: rotate(0)
+    }
+    20%, 60% {
+        transform: rotate(-25deg)
+    }
+    40%, 80% {
+        transform: rotate(10deg)
+    }
+}
+
+@keyframes octocat-wave {
+    0%, to {
+        transform: rotate(0)
+    }
+    20%, 60% {
+        transform: rotate(-25deg)
+    }
+    40%, 80% {
+        transform: rotate(10deg)
+    }
+}
+
+section.cover {
+    align-items: center;
+    background-position: 50%;
+    background-repeat: no-repeat;
+    background-size: cover;
+    height: 100vh;
+    width: 100vw;
+    display: none
+}
+
+section.cover.show {
+    display: flex
+}
+
+section.cover.has-mask .mask {
+    background-color: #fff;
+    opacity: .8;
+    position: absolute;
+    top: 0;
+    height: 100%;
+    width: 100%
+}
+
+section.cover .cover-main {
+    flex: 1;
+    margin: -20px 16px 0;
+    text-align: center;
+    position: relative
+}
+
+section.cover a {
+    color: inherit
+}
+
+section.cover a, section.cover a:hover {
+    text-decoration: none
+}
+
+section.cover p {
+    line-height: 1.5rem;
+    margin: 1em 0
+}
+
+section.cover h1 {
+    color: inherit;
+    font-size: 2.5rem;
+    font-weight: 300;
+    margin: .625rem 0 2.5rem;
+    position: relative;
+    text-align: center
+}
+
+section.cover h1 a {
+    display: block
+}
+
+section.cover h1 small {
+    bottom: -.4375rem;
+    font-size: 1rem;
+    position: absolute
+}
+
+section.cover blockquote {
+    font-size: 1.5rem;
+    text-align: center
+}
+
+section.cover ul {
+    line-height: 1.8;
+    list-style-type: none;
+    margin: 1em auto;
+    max-width: 500px;
+    padding: 0
+}
+
+section.cover .cover-main > p:last-child a {
+    border-radius: 2rem;
+    border: 1px solid var(--theme-color, #3DB47E);
+    box-sizing: border-box;
+    color: var(--theme-color, #3DB47E);
+    display: inline-block;
+    font-size: 1.05rem;
+    letter-spacing: .1rem;
+    margin: .5rem 1rem;
+    padding: .75em 2rem;
+    text-decoration: none;
+    transition: all .15s ease
+}
+
+section.cover .cover-main > p:last-child a:last-child {
+    background-color: var(--theme-color, #3DB47E);
+    color: #fff
+}
+
+section.cover .cover-main > p:last-child a:last-child:hover {
+    color: inherit;
+    opacity: .8
+}
+
+section.cover .cover-main > p:last-child a:hover {
+    color: inherit
+}
+
+section.cover blockquote > p > a {
+    border-bottom: 2px solid var(--theme-color, #3DB47E);
+    transition: color .3s
+}
+
+section.cover blockquote > p > a:hover {
+    color: var(--theme-color, #3DB47E)
+}
+
+.sidebar, body {
+    background-color: #fff
+}
+
+.sidebar {
+    color: #364149
+}
+
+.sidebar li {
+    margin: 6px 0
+}
+
+.sidebar ul li a {
+    color: #505d6b;
+    font-size: 14px;
+    font-weight: 400;
+    overflow: hidden;
+    text-decoration: none;
+    text-overflow: ellipsis;
+    white-space: nowrap
+}
+
+.sidebar ul li a:hover {
+    text-decoration: underline
+}
+
+.sidebar ul li ul {
+    padding: 0
+}
+
+.sidebar ul li.active > a {
+    border-right: 2px solid;
+    color: var(--theme-color, #3DB47E);
+    font-weight: 600
+}
+
+.app-sub-sidebar li:before {
+    content: "-";
+    padding-right: 4px;
+    float: left
+}
+
+.markdown-section h1, .markdown-section h2, .markdown-section h3, .markdown-section h4, .markdown-section strong {
+    color: #2c3e50;
+    font-weight: 600
+}
+
+.markdown-section a {
+    color: var(--theme-color, #3DB47E);
+    font-weight: 600
+}
+
+.markdown-section h1 {
+    font-size: 2rem;
+    margin: 0 0 1rem
+}
+
+.markdown-section h2 {
+    font-size: 1.75rem;
+    margin: 45px 0 .8rem
+}
+
+.markdown-section h3 {
+    font-size: 1.5rem;
+    margin: 40px 0 .6rem
+}
+
+.markdown-section h4 {
+    font-size: 1.25rem
+}
+
+.markdown-section h5 {
+    font-size: 1rem
+}
+
+.markdown-section h6 {
+    color: #777;
+    font-size: 1rem
+}
+
+.markdown-section figure, .markdown-section p {
+    margin: 1.2em 0
+}
+
+.markdown-section ol, .markdown-section p, .markdown-section ul {
+    line-height: 1.6rem;
+    word-spacing: .05rem
+}
+
+.markdown-section ol, .markdown-section ul {
+    padding-left: 1.5rem
+}
+
+.markdown-section blockquote {
+    border-left: 4px solid var(--theme-color, #3DB47E);
+    color: #858585;
+    margin: 2em 0;
+    padding-left: 20px
+}
+
+.markdown-section blockquote p {
+    font-weight: 600;
+    margin-left: 0
+}
+
+.markdown-section iframe {
+    margin: 1em 0
+}
+
+.markdown-section em {
+    color: #7f8c8d
+}
+
+.markdown-section code, .markdown-section output:after, .markdown-section pre {
+    font-family: Roboto Mono, Monaco, courier, monospace
+}
+
+.markdown-section code, .markdown-section pre {
+    background-color: #f8f8f8
+}
+
+.markdown-section output, .markdown-section pre {
+    margin: 1.2em 0;
+    position: relative
+}
+
+.markdown-section output, .markdown-section pre > code {
+    border-radius: 2px;
+    display: block
+}
+
+.markdown-section output:after, .markdown-section pre > code {
+    -moz-osx-font-smoothing: initial;
+    -webkit-font-smoothing: initial
+}
+
+.markdown-section code {
+    border-radius: 2px;
+    color: #AC1900;
+    margin: 0 2px;
+    padding: 3px 5px;
+    white-space: pre-wrap
+}
+
+.markdown-section strong code {
+    color: #E65100;
+}
+
+.markdown-section > :not(h1):not(h2):not(h3):not(h4):not(h5):not(h6) code {
+    font-size: .8rem
+}
+
+.markdown-section pre {
+    padding: 0 1.4rem;
+    line-height: 1.5rem;
+    overflow: auto;
+    word-wrap: normal
+}
+
+.markdown-section pre > code {
+    color: #525252;
+    font-size: .8rem;
+    padding: 2.2em 5px;
+    line-height: inherit;
+    margin: 0 2px;
+    max-width: inherit;
+    overflow: inherit;
+    white-space: inherit
+}
+
+.markdown-section output {
+    padding: 1.7rem 1.4rem;
+    border: 1px dotted #ccc
+}
+
+.markdown-section output > :first-child {
+    margin-top: 0
+}
+
+.markdown-section output > :last-child {
+    margin-bottom: 0
+}
+
+.markdown-section code:after, .markdown-section code:before, .markdown-section output:after, .markdown-section output:before {
+    letter-spacing: .05rem
+}
+
+.markdown-section output:after, .markdown-section pre:after {
+    color: #ccc;
+    font-size: .6rem;
+    font-weight: 600;
+    height: 15px;
+    line-height: 15px;
+    padding: 5px 10px 0;
+    position: absolute;
+    right: 0;
+    text-align: right;
+    top: 0;
+    content: attr(data-lang)
+}
+
+.token.cdata, .token.comment, .token.doctype, .token.prolog {
+    color: #8C8C8C
+}
+
+.token.namespace {
+    opacity: .7
+}
+
+.token.boolean {
+    color: #8A653B;
+}
+
+.token.number {
+    color: #1750EB
+}
+
+.token.punctuation {
+    color: #525252
+}
+
+.token.property {
+    color: #248F8F;
+}
+
+.token.tag {
+    color: #8A653B
+}
+
+.token.string {
+    color: var(--theme-color, #067D17)
+}
+
+.token.selector {
+    color: #9B880D
+}
+
+.token.attr-name {
+    color: #6A8759
+}
+
+.language-css .token.string, .style .token.string, .token.entity, .token.url {
+    color: #6A8759
+}
+
+.token.attr-value, .token.control, .token.directive, .token.unit {
+    color: var(--theme-color, #39B27B)
+}
+
+.token.function {
+    color: #BC5100
+}
+
+.token.keyword {
+    color: #0033B3
+}
+
+.token.atrule, .token.regex, .token.statement {
+    color: #1750EB
+}
+
+.token.placeholder, .token.variable {
+    color: #248F8F
+}
+
+.token.deleted {
+    text-decoration: line-through
+}
+
+.token.inserted {
+    border-bottom: 1px dotted #202746;
+    text-decoration: none
+}
+
+.token.italic {
+    font-style: italic
+}
+
+.token.bold, .token.important {
+    font-weight: 700
+}
+
+.token.important {
+    color: #CC7832
+}
+
+.token.entity {
+    cursor: help
+}
+
+code .token {
+    -moz-osx-font-smoothing: initial;
+    -webkit-font-smoothing: initial;
+    min-height: 1.5rem;
+    position: relative;
+    left: auto
+}
+
+@media (prefers-color-scheme: dark) {
+    .sidebar, body {
+        color: #B0BEC5;
+        background-color: #202020;
+    }
+
+    .progress {
+        background-color: var(--theme-color, #26A69A);
+    }
+
+    .search .search-keyword, .search a:hover {
+        color: var(--theme-color, #26A69A)
+    }
+
+    .search input {
+        color: #B0BEC5;
+        background-color: #202020;
+    }
+
+    .search .clear-button circle {
+        fill: #424242;
+    }
+
+    kbd {
+        border: 1px solid #B0BEC5;
+    }
+
+    .app-nav a.active, .app-nav a:hover {
+        color: var(--theme-color, #26A69A)
+    }
+
+    .app-nav a.active {
+        border-bottom: 2px solid var(--theme-color, #26A69A)
+    }
+
+    .app-nav li ul {
+        background-color: #202020;
+        border: 1px solid;
+        border-color: #ddd #ddd #B0BEC5;
+    }
+
+    .github-corner svg {
+        color: #bfbfbf;
+        fill: var(--theme-color, #1B5E20);
+    }
+
+    .anchor span {
+        color: #B0BEC5;
+    }
+
+    .sidebar {
+        border-right: 1px solid rgba(0, 0, 0, .07);
+        background-color: #202020;
+    }
+
+    .sidebar:hover::-webkit-scrollbar-thumb {
+        background: hsla(0, 0%, 53.3%, .4)
+    }
+
+    .sidebar:hover::-webkit-scrollbar-track {
+        background: hsla(0, 0%, 53.3%, .1)
+    }
+
+    .sidebar-toggle {
+        background-color: #202020 !important;
+    }
+
+    .sidebar-toggle span {
+        background-color: var(--theme-color, #1B5E20);
+    }
+
+    .markdown-section hr {
+        border-bottom: 1px solid #37474F;
+    }
+
+    .markdown-section iframe {
+        border: 1px solid #eee;
+    }
+
+    .markdown-section td, .markdown-section th {
+        border: 1px solid #ddd;
+    }
+
+    .markdown-section tr {
+        border-top: 1px solid #B0BEC5
+    }
+
+    .markdown-section p.tip, .markdown-section tr:nth-child(2n) {
+        background-color: #202020;
+    }
+
+    .markdown-section p.tip {
+        border-left: 4px solid #f66;
+    }
+
+    .markdown-section p.tip:before {
+        background-color: #f66;
+        color: #fff;
+    }
+
+    .markdown-section p.tip code {
+        background-color: #202020;
+    }
+
+    .markdown-section p.tip em {
+        color: #34495e
+    }
+
+    .markdown-section p.warn {
+        background: rgba(66, 185, 131, .1);
+    }
+
+    section.cover.has-mask .mask {
+        background-color: #202020;
+    }
+
+    section.cover a {
+        color: inherit
+    }
+
+    section.cover h1 {
+        color: inherit;
+    }
+
+    section.cover .cover-main > p:last-child a {
+        border: 1px solid var(--theme-color, #3db47e);
+        color: var(--theme-color, #26A69A);
+    }
+
+    section.cover .cover-main > p:last-child a:last-child {
+        background-color: var(--theme-color, #26A69A);
+        color: #fff
+    }
+
+    section.cover .cover-main > p:last-child a:last-child:hover {
+        color: inherit;
+    }
+
+    section.cover .cover-main > p:last-child a:hover {
+        color: inherit
+    }
+
+    section.cover blockquote > p > a {
+        border-bottom: 2px solid var(--theme-color, #26A69A);
+        transition: color .3s
+    }
+
+    section.cover blockquote > p > a:hover {
+        color: var(--theme-color, #26A69A)
+    }
+
+    .sidebar ul li a {
+        color: #B0BEC5;
+    }
+
+    .sidebar ul li.active > a {
+        color: var(--theme-color, #26A69A);
+    }
+
+    .markdown-section h1, .markdown-section h2, .markdown-section h3, .markdown-section h4, .markdown-section strong {
+        color: #B0BEC5;
+    }
+
+    .markdown-section a {
+        color: var(--theme-color, #26A69A);
+    }
+
+    .markdown-section h6 {
+        color: #777;
+    }
+
+    .markdown-section blockquote {
+        border-left: 4px solid var(--theme-color, #439889);
+        color: #9E9E9E;
+    }
+
+    .markdown-section em {
+        color: #7f8c8d
+    }
+
+    .markdown-section code, .markdown-section pre {
+        background-color: #1C313A;
+    }
+
+    .markdown-section code {
+        color: #AEC4C7;
+    }
+
+    .markdown-section strong code {
+        color: #AEC4C7;
+    }
+
+    .markdown-section pre > code {
+        color: #BDBDBD;
+    }
+
+    .markdown-section output {
+        border: 1px dotted #B0BEC5
+    }
+
+    .markdown-section output:after, .markdown-section pre:after {
+        color: #B0BEC5;
+    }
+
+    .token.cdata, .token.comment, .token.doctype, .token.prolog {
+        color: #8e908c;
+    }
+
+    .token.punctuation {
+        color: #BDBDBD
+    }
+
+    .token.boolean {
+        color: #CC7832;
+    }
+
+    .token.number {
+        color: #6897BB
+    }
+
+    .token.property {
+        color: #9876AA
+    }
+
+    .token.tag {
+        color: #8A653B
+    }
+
+    .token.string {
+        color: var(--theme-color, #6A8759)
+    }
+
+    .token.selector {
+        color: #BBB529
+    }
+
+    .token.attr-name {
+        color: #6A8759
+    }
+
+    .language-css .token.string,
+    .style .token.string,
+    .token.entity,
+    .token.url {
+        color: #6A8759
+    }
+
+    .token.attr-value, .token.control, .token.directive, .token.unit {
+        color: var(--theme-color, #26A69A)
+    }
+
+    .token.function {
+        color: #C8A415
+    }
+
+    .token.keyword {
+        color: #CC7832
+    }
+
+    .token.atrule, .token.regex, .token.statement {
+        color: #6897BB
+    }
+
+    .token.placeholder, .token.variable {
+        color: #9876AA
+    }
+
+    .token.inserted {
+        border-bottom: 1px dotted #7e859f;
+    }
+
+    .token.important {
+        color: #CC7832
+    }
+
+}
\ No newline at end of file
diff --git a/api/storages.md b/api/storages.md
index 68d1bcb..17e3bd3 100644
--- a/api/storages.md
+++ b/api/storages.md
@@ -1,21 +1,26 @@
-# Storages
+# 存储 (Storages)
+
+---
+
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
 
-> Stability: 2 - Stable
+---
 
-storages模块提供了保存简单数据、用户配置等的支持。保存的数据除非应用被卸载或者被主动删除，否则会一直保留。
+storages模块提供了保存简单数据、用户配置等的支持. 保存的数据除非应用被卸载或者被主动删除, 否则会一直保留.
 
-storages支持`number`, `boolean`, `string`等数据类型以及把`Object`, `Array`用`JSON.stringify`序列化存取。
+storages支持`number`, `boolean`, `string`等数据类型以及把`Object`, `Array`用`JSON.stringify`序列化存取.
 
-storages保存的数据在脚本之间是共享的，任何脚本只要知道storage名称便可以获取到相应的数据，因此它不能用于敏感数据的储存。
-storages无法像Web开发中LocalStorage一样提供根据域名独立的存储，因为脚本的路径随时可能改变。
+storages保存的数据在脚本之间是共享的, 任何脚本只要知道storage名称便可以获取到相应的数据, 因此它不能用于敏感数据的储存.
+storages无法像Web开发中LocalStorage一样提供根据域名独立的存储, 因为脚本的路径随时可能改变.
 
 ## storages.create(name)
 
 * `name` {string} 本地存储名称
 
-创建一个本地存储并返回一个`Storage`对象。不同名称的本地存储的数据是隔开的，而相同名称的本地存储的数据是共享的。
+创建一个本地存储并返回一个`Storage`对象. 不同名称的本地存储的数据是隔开的, 而相同名称的本地存储的数据是共享的.
 
-例如在一个脚本中，创建名称为ABC的存储并存入a=123:
+例如在一个脚本中, 创建名称为ABC的存储并存入a=123:
 
 ```
 var storage = storages.create("ABC");
@@ -29,7 +34,7 @@ var storage = storages.create("ABC");
 log("a = " + storage.get("a"));
 ```
 
-因此，本地存储的名称比较重要，尽量使用含有域名、作者邮箱等唯一信息的名称来避免冲突，例如：
+因此, 本地存储的名称比较重要, 尽量使用含有域名、作者邮箱等唯一信息的名称来避免冲突, 例如：
 
 ```
 var storage = storages.create("2732014414@qq.com:ABC");
@@ -39,42 +44,42 @@ var storage = storages.create("2732014414@qq.com:ABC");
 
 * `name` {string} 本地存储名称
 
-删除一个本地存储以及他的全部数据。如果该存储不存在，返回false；否则返回true。
+删除一个本地存储以及他的全部数据. 如果该存储不存在, 返回false；否则返回true.
 
 # Storages
 
 ## Storage.get(key[, defaultValue])
 
 * `key` {string} 键值
-* `defaultValue` {any} 可选，默认值
+* `defaultValue` {any} 可选, 默认值
 
-从本地存储中取出键值为key的数据并返回。
+从本地存储中取出键值为key的数据并返回.
 
-如果该存储中不包含该数据，这时若指定了默认值参数则返回默认值，否则返回undefined。
+如果该存储中不包含该数据, 这时若指定了默认值参数则返回默认值, 否则返回undefined.
 
-返回的数据可能是任意数据类型，这取决于使用`Storage.put`保存该键值的数据时的数据类型。
+返回的数据可能是任意数据类型, 这取决于使用`Storage.put`保存该键值的数据时的数据类型.
 
 ## Storage.put(key, value)
 
 * `key` {string} 键值
 * `value` {any} 值
 
-把值value保存到本地存储中。value可以是undefined以外的任意数据类型。如果value为undefined则抛出TypeError。
+把值value保存到本地存储中. value可以是undefined以外的任意数据类型. 如果value为undefined则抛出TypeError.
 
-存储的过程实际上是使用JSON.stringify把value转换为字符串再保存，因此value必须是可JSON化的才能被接受。
+存储的过程实际上是使用JSON.stringify把value转换为字符串再保存, 因此value必须是可JSON化的才能被接受.
 
 ## Storage.remove(key)
 
 * `key` {string} 键值
 
-移除键值为key的数据。不返回任何值。
+移除键值为key的数据. 不返回任何值.
 
 ## Storage.contains(key)
 
 * `key` {string} 键值
 
-返回该本地存储是否包含键值为key的数据。是则返回true，否则返回false。
+返回该本地存储是否包含键值为key的数据. 是则返回true, 否则返回false.
 
 ## Storage.clear()
 
-移除该本地存储的所有数据。不返回任何值。
\ No newline at end of file
+移除该本地存储的所有数据. 不返回任何值.
\ No newline at end of file
diff --git a/api/tasks.md b/api/tasks.md
new file mode 100644
index 0000000..6234666
--- /dev/null
+++ b/api/tasks.md
@@ -0,0 +1,10 @@
+# 任务 (Tasks)
+
+---
+
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
+
+---
+
+
diff --git a/api/threads.md b/api/threads.md
index 6710550..4c995c3 100644
--- a/api/threads.md
+++ b/api/threads.md
@@ -1,21 +1,26 @@
-# Threads
+# 线程 (Threads)
 
-> Stability: 1 - Experiment
+---
 
-threads模块提供了多线程支持，可以启动新线程来运行脚本。
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
 
-脚本主线程会等待所有子线程执行完成后才停止执行，因此如果子线程中有死循环，请在必要的时候调用`exit()`来直接停止脚本或`threads.shutDownAll()`来停止所有子线程。
+---
 
-通过`threads.start()`启动的所有线程会在脚本被强制停止时自动停止。
+threads模块提供了多线程支持, 可以启动新线程来运行脚本.
 
-由于JavaScript自身没有多线程的支持，因此您可能会遇到意料之外的问题。
+脚本主线程会等待所有子线程执行完成后才停止执行, 因此如果子线程中有死循环, 请在必要的时候调用`exit()`来直接停止脚本或`threads.shutDownAll()`来停止所有子线程.
+
+通过`threads.start()`启动的所有线程会在脚本被强制停止时自动停止.
+
+由于JavaScript自身没有多线程的支持, 因此您可能会遇到意料之外的问题.
 
 ## threads.start(action)
 
 * `action` {Function} 要在新线程执行的函数
 * 返回 [Thread](#threads_thread)
 
-启动一个新线程并执行action。
+启动一个新线程并执行action.
 
 例如:
 
@@ -31,7 +36,7 @@ while(true){
 }
 ```
 
-通过该函数返回的[Thread](#threads_thread)对象可以获取该线程的状态，控制该线程的运行中。例如:
+通过该函数返回的[Thread](#threads_thread)对象可以获取该线程的状态, 控制该线程的运行中. 例如:
 
 ```
 var thread = threads.start(function(){
@@ -43,42 +48,42 @@ var thread = threads.start(function(){
 thread.interrupt();
 ```
 
-更多信息参见[Thread](#threads_thread)。
+更多信息参见[Thread](#threads_thread).
 
 ## threads.shutDownAll()
 
-停止所有通过`threads.start()`启动的子线程。
+停止所有通过`threads.start()`启动的子线程.
 
 ## threads.currentThread()
 
 * 返回 [Thread](#threads_thread)
 
-返回当前线程。
+返回当前线程.
 
 ## threads.disposable()
 
 * 返回 [Disposable](#threads_disposable)
 
-新建一个Disposable对象，用于等待另一个线程的某个一次性结果。更多信息参见[线程通信](#threads_线程通信)以及[Disposable](#threads_disposable)。
+新建一个Disposable对象, 用于等待另一个线程的某个一次性结果. 更多信息参见[线程通信](#threads_线程通信)以及[Disposable](#threads_disposable).
 
 ## threads.atomic([initialValue])
 
-* `initialValue` {number} 初始整数值，默认为0
+* `initialValue` {number} 初始整数值, 默认为0
 * 返回[AtomicLong](https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicLong.html)
 
-新建一个整数原子变量。更多信息参见[线程安全](#threads_线程安全)以及[AtomicLong](https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicLong.html)。
+新建一个整数原子变量. 更多信息参见[线程安全](#threads_线程安全)以及[AtomicLong](https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicLong.html).
 
 ## threads.lock()
 
 * 返回[ReentrantLock](https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/locks/ReentrantLock.html)
 
-新建一个可重入锁。更多信息参见[线程安全](#threads_线程安全)以及[ReentrantLock](https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/locks/ReentrantLock.html)。
+新建一个可重入锁. 更多信息参见[线程安全](#threads_线程安全)以及[ReentrantLock](https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/locks/ReentrantLock.html).
 
 # Thread
 
-线程对象，`threads.start()`返回的对象，用于获取和控制线程的状态，与其他线程交互等。
+线程对象, `threads.start()`返回的对象, 用于获取和控制线程的状态, 与其他线程交互等.
 
-Thread对象提供了和timers模块一样的API，例如`setTimeout()`, `setInterval()`等，用于在该线程执行相应的定时回调，从而使线程之间可以直接交互。例如：
+Thread对象提供了和timers模块一样的API, 例如`setTimeout()`, `setInterval()`等, 用于在该线程执行相应的定时回调, 从而使线程之间可以直接交互. 例如：
 
 ```
 var thread = threads.start(function(){
@@ -104,13 +109,13 @@ thread.interrupt();
 
 ## Thread.interrupt()
 
-中断线程运行。
+中断线程运行.
 
 ## Thread.join([timeout])
 
-* `timeout` {number} 等待时间，单位毫秒
+* `timeout` {number} 等待时间, 单位毫秒
 
-等待线程执行完成。如果timeout为0，则会一直等待直至该线程执行完成；否则最多等待timeout毫秒的时间。
+等待线程执行完成. 如果timeout为0, 则会一直等待直至该线程执行完成；否则最多等待timeout毫秒的时间.
 
 例如:
 
@@ -131,11 +136,11 @@ toast("sum = " + sum);
 
 * 返回 {boolean}
 
-返回线程是否存活。如果线程仍未开始或已经结束，返回`false`; 如果线程已经开始或者正在运行中，返回`true`。
+返回线程是否存活. 如果线程仍未开始或已经结束, 返回`false`; 如果线程已经开始或者正在运行中, 返回`true`.
 
 ## waitFor()
 
-等待线程开始执行。调用`threads.start()`以后线程仍然需要一定时间才能开始执行，因此调用此函数会等待线程开始执行；如果线程已经处于执行状态则立即返回。
+等待线程开始执行. 调用`threads.start()`以后线程仍然需要一定时间才能开始执行, 因此调用此函数会等待线程开始执行；如果线程已经处于执行状态则立即返回.
 
 ```
 var thread = threads.start(function(){
@@ -149,9 +154,9 @@ thread.setTimeout(function(){
 
 ## Thread.setTimeout(callback, delay\[, ...args\])
 
-参见[timers.setTimeout()](timers.html#timers_settimeout_callback_delay_args)。
+参见[timers.setTimeout()](timers.html#timers_settimeout_callback_delay_args).
 
-区别在于, 该定时器会在该线程执行。如果当前线程仍未开始执行或已经执行结束，则抛出`IllegalStateException`。
+区别在于, 该定时器会在该线程执行. 如果当前线程仍未开始执行或已经执行结束, 则抛出`IllegalStateException`.
 
 ```
 log("当前线程(主线程):" + threads.currentThread());
@@ -170,46 +175,46 @@ thread.setTimeout(function(){
 
 ## Thread.setInterval(callback, delay\[, ...args\])
 
-参见[timers.setInterval()](timers.html#timers_setinterval_callback_delay_args)。
+参见[timers.setInterval()](timers.html#timers_setinterval_callback_delay_args).
 
-区别在于, 该定时器会在该线程执行。如果当前线程仍未开始执行或已经执行结束，则抛出`IllegalStateException`。
+区别在于, 该定时器会在该线程执行. 如果当前线程仍未开始执行或已经执行结束, 则抛出`IllegalStateException`.
 
 ## Thread.setImmediate(callback[, ...args])
 
-参见[timers.setImmediate()](timers.html#timers_setimmediate_callback_delay_args)。
+参见[timers.setImmediate()](timers.html#timers_setimmediate_callback_delay_args).
 
-区别在于, 该定时器会在该线程执行。如果当前线程仍未开始执行或已经执行结束，则抛出`IllegalStateException`。
+区别在于, 该定时器会在该线程执行. 如果当前线程仍未开始执行或已经执行结束, 则抛出`IllegalStateException`.
 
 ## Thread.clearInterval(id)
 
-参见[timers.clearInterval()](timers.html#timers_clearinterval_id)。
+参见[timers.clearInterval()](timers.html#timers_clearinterval_id).
 
-区别在于, 该定时器会在该线程执行。如果当前线程仍未开始执行或已经执行结束，则抛出`IllegalStateException`。
+区别在于, 该定时器会在该线程执行. 如果当前线程仍未开始执行或已经执行结束, 则抛出`IllegalStateException`.
 
 ## Thread.clearTimeout(id)
 
-参见[timers.clearTimeout()](timers.html#timers_cleartimeout_id)。
+参见[timers.clearTimeout()](timers.html#timers_cleartimeout_id).
 
-区别在于, 该定时器会在该线程执行。如果当前线程仍未开始执行或已经执行结束，则抛出`IllegalStateException`。
+区别在于, 该定时器会在该线程执行. 如果当前线程仍未开始执行或已经执行结束, 则抛出`IllegalStateException`.
 
 ## Thread.clearImmediate(id)
 
-参见[timers.clearImmediate()](timers.html#timers_clearimmediate_id)。
+参见[timers.clearImmediate()](timers.html#timers_clearimmediate_id).
 
-区别在于, 该定时器会在该线程执行。如果当前线程仍未开始执行或已经执行结束，则抛出`IllegalStateException`。
+区别在于, 该定时器会在该线程执行. 如果当前线程仍未开始执行或已经执行结束, 则抛出`IllegalStateException`.
 
 # 线程安全
 
-线程安全问题是一个相对专业的编程问题，本章节只提供给有需要的用户。
+线程安全问题是一个相对专业的编程问题, 本章节只提供给有需要的用户.
 
 引用维基百科的解释：
-> 线程安全是编程中的术语，指某个函数、函数库在多线程环境中被调用时，能够正确地处理多个线程之间的共享变量，使程序功能正确完成。
+> 线程安全是编程中的术语, 指某个函数、函数库在多线程环境中被调用时, 能够正确地处理多个线程之间的共享变量, 使程序功能正确完成.
 
-在Auto.js中，线程间变量在符合JavaScript变量作用域规则的前提下是共享的，例如全局变量在所有线程都能访问，并且保证他们在所有线程的可见性。但是，不保证任何操作的原子性。例如经典的自增"i++"将不是原子性操作。
+在Auto.js中, 线程间变量在符合JavaScript变量作用域规则的前提下是共享的, 例如全局变量在所有线程都能访问, 并且保证他们在所有线程的可见性. 但是, 不保证任何操作的原子性. 例如经典的自增"i++"将不是原子性操作.
 
-Rhino和Auto.js提供了一些简单的设施来解决简单的线程安全问题，如锁`threads.lock()`, 函数同步锁`sync()`, 整数原子变量`threads.atomic()`等。
+Rhino和Auto.js提供了一些简单的设施来解决简单的线程安全问题, 如锁`threads.lock()`, 函数同步锁`sync()`, 整数原子变量`threads.atomic()`等.
 
-例如，对于多线程共享下的整数的自增操作(自增操作会导致问题，是因为自增操作实际上为`i = i + 1`，也就是先读取i的值, 把他加1, 再赋值给i, 如果两个线程同时进行自增操作，可能出现i的值只增加了1的情况)，应该使用`threads.atomic()`函数来新建一个整数原子变量，或者使用锁`threads.lock()`来保证操作的原子性，或者用`sync()`来增加同步锁。
+例如, 对于多线程共享下的整数的自增操作(自增操作会导致问题, 是因为自增操作实际上为`i = i + 1`, 也就是先读取i的值, 把他加1, 再赋值给i, 如果两个线程同时进行自增操作, 可能出现i的值只增加了1的情况), 应该使用`threads.atomic()`函数来新建一个整数原子变量, 或者使用锁`threads.lock()`来保证操作的原子性, 或者用`sync()`来增加同步锁.
 
 线程不安全的代码如下：
 
@@ -225,7 +230,7 @@ while(true){
 }
 ```
 
-此段代码运行后打开日志，可以看到日志中有重复的值出现。
+此段代码运行后打开日志, 可以看到日志中有重复的值出现.
 
 使用`threads.atomic()`的线程安全的代码如下:
 
@@ -265,7 +270,7 @@ while(true){
 或者:
 
 ```
-//sync函数会把里面的函数加上同步锁，使得在同一时刻最多只能有一个线程执行这个函数
+//sync函数会把里面的函数加上同步锁, 使得在同一时刻最多只能有一个线程执行这个函数
 var i = 0;
 var getAndIncrement = sync(function(){
     return i++;
@@ -280,7 +285,7 @@ while(true){
 }
 ```
 
-另外，数组Array不是线程安全的，如果有这种复杂的需求，请用Android和Java相关API来实现。例如`CopyOnWriteList`, `Vector`等都是代替数组的线程安全的类，用于不同的场景。例如:
+另外, 数组Array不是线程安全的, 如果有这种复杂的需求, 请用Android和Java相关API来实现. 例如`CopyOnWriteList`, `Vector`等都是代替数组的线程安全的类, 用于不同的场景. 例如:
 
 ```
 var nums = new java.util.Vector();
@@ -290,7 +295,7 @@ toast("长度为" + nums.size());
 toast("第一个元素为" + nums.get(0));
 ```
 
-但很明显的是，这些类不像数组那样简便易用，也不能使用诸如`slice()`之类的方便的函数。在未来可能会加入线程安全的数组来解决这个问题。当然您也可以为每个数组的操作加锁来解决线程安全问题：
+但很明显的是, 这些类不像数组那样简便易用, 也不能使用诸如`slice()`之类的方便的函数. 在未来可能会加入线程安全的数组来解决这个问题. 当然您也可以为每个数组的操作加锁来解决线程安全问题：
 
 ```
 var nums = [];
@@ -323,7 +328,7 @@ numsLock.unlock();
 * `func` {Function} 函数
 * 返回 {Function}
 
-给函数func加上同步锁并作为一个新函数返回。
+给函数func加上同步锁并作为一个新函数返回.
 
 ```
 var i = 0;
@@ -338,9 +343,9 @@ toast(i);
 
 # 线程通信
 
-Auto.js提供了一些简单的设施来支持简单的线程通信。`threads.disposable()`用于一个线程等待另一个线程的(一次性)结果，同时`Lock.newCondition()`提供了Condition对象用于一般的线程通信(await, signal)。另外，`events`模块也可以用于线程通信，通过指定`EventEmiiter`的回调执行的线程来实现。
+Auto.js提供了一些简单的设施来支持简单的线程通信. `threads.disposable()`用于一个线程等待另一个线程的(一次性)结果, 同时`Lock.newCondition()`提供了Condition对象用于一般的线程通信(await, signal). 另外, `events`模块也可以用于线程通信, 通过指定`EventEmiiter`的回调执行的线程来实现.
 
-使用`threads.disposable()`可以简单地等待和获取某个线程的执行结果。例如要等待某个线程计算"1+.....+10000":
+使用`threads.disposable()`可以简单地等待和获取某个线程的执行结果. 例如要等待某个线程计算"1+.....+10000":
 
 ```
 var sum = threads.disposable();
@@ -363,7 +368,7 @@ toast("sum = " + sum.blockedGet());
 ```
 //新建一个锁
 var lock = threads.lock();
-//新建一个条件，即"计算完成"
+//新建一个条件, 即"计算完成"
 var complete = lock.newCondition();
 var sum = 0;
 threads.start(function(){
@@ -403,4 +408,4 @@ sum.on('result', function(s){
 });
 ```
 
-有关线程的其他问题，例如生产者消费者等问题，请用Java相关方法解决，例如`java.util.concurrent.BlockingQueue`。
\ No newline at end of file
+有关线程的其他问题, 例如生产者消费者等问题, 请用Java相关方法解决, 例如`java.util.concurrent.BlockingQueue`.
\ No newline at end of file
diff --git a/api/timers.md b/api/timers.md
index cff7c64..8ce2d77 100644
--- a/api/timers.md
+++ b/api/timers.md
@@ -1,12 +1,17 @@
-# Timers
+# 定时器 (Timers)
 
-> Stability: 2 - Stable
+---
 
-timers 模块暴露了一个全局的 API，用于在某个未来时间段调用调度函数。 因为定时器函数是全局的，所以使用该 API 无需调用 timers.***
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
 
-Auto.js 中的计时器函数实现了与 Web 浏览器提供的定时器类似的 API，除了它使用了一个不同的内部实现，它是基于 Android Looper-Handler消息循环机制构建的。其实现机制与Node.js比较相似。
+---
 
-例如，要在5秒后发出消息"hello":
+timers 模块暴露了一个全局的 API, 用于在某个未来时间段调用调度函数.  因为定时器函数是全局的, 所以使用该 API 无需调用 timers.***
+
+Auto.js 中的计时器函数实现了与 Web 浏览器提供的定时器类似的 API, 除了它使用了一个不同的内部实现, 它是基于 Android Looper-Handler消息循环机制构建的. 其实现机制与Node.js比较相似.
+
+例如, 要在5秒后发出消息"hello":
 
 ```
 setTimeout(function(){
@@ -14,7 +19,7 @@ setTimeout(function(){
 }, 5000);
 ```
 
-需要注意的是，这些定时器仍然是单线程的。如果脚本主体有耗时操作或死循环，则设定的定时器不能被及时执行，例如：
+需要注意的是, 这些定时器仍然是单线程的. 如果脚本主体有耗时操作或死循环, 则设定的定时器不能被及时执行, 例如：
 
 ```
 setTimeout(function(){
@@ -38,42 +43,42 @@ while(true);
 
 ## setInterval(callback, delay\[, ...args\])
 
-* `callback` {Function} 当定时器到点时要调用的函数。
-* `delay` {number} 调用 callback 之前要等待的毫秒数。
-* `...args` {any} 当调用 callback 时要传入的可选参数。
+* `callback` {Function} 当定时器到点时要调用的函数.
+* `delay` {number} 调用 callback 之前要等待的毫秒数.
+* `...args` {any} 当调用 callback 时要传入的可选参数.
 
-预定每隔 delay 毫秒重复执行的 callback。 返回一个用于 clearInterval() 的 id。
+预定每隔 delay 毫秒重复执行的 callback.  返回一个用于 clearInterval() 的 id.
 
-当 delay 小于 0 时，delay 会被设为 0。
+当 delay 小于 0 时, delay 会被设为 0.
 
 ## setTimeout(callback, delay\[, ...args\])
 
-* `callback` {Function} 当定时器到点时要调用的函数。
-* `delay` {number} 调用 callback 之前要等待的毫秒数。
-* `...args` {any} 当调用 callback 时要传入的可选参数。
+* `callback` {Function} 当定时器到点时要调用的函数.
+* `delay` {number} 调用 callback 之前要等待的毫秒数.
+* `...args` {any} 当调用 callback 时要传入的可选参数.
 
-预定在 delay 毫秒之后执行的单次 callback。 返回一个用于 clearTimeout() 的 id。
+预定在 delay 毫秒之后执行的单次 callback.  返回一个用于 clearTimeout() 的 id.
 
-callback 可能不会精确地在 delay 毫秒被调用。 Auto.js 不能保证回调被触发的确切时间，也不能保证它们的顺序。 回调会在尽可能接近所指定的时间上调用。
+callback 可能不会精确地在 delay 毫秒被调用.  Auto.js 不能保证回调被触发的确切时间, 也不能保证它们的顺序.  回调会在尽可能接近所指定的时间上调用.
 
-当 delay 小于 0 时，delay 会被设为 0。
+当 delay 小于 0 时, delay 会被设为 0.
 
 ## setImmediate(callback[, ...args])
 
-* `callback` {Function} 在Looper循环的当前回合结束时要调用的函数。
-* `...args` {any} 当调用 callback 时要传入的可选参数。
+* `callback` {Function} 在Looper循环的当前回合结束时要调用的函数.
+* `...args` {any} 当调用 callback 时要传入的可选参数.
 
-预定立即执行的 callback，它是在 I/O 事件的回调之后被触发。 返回一个用于 clearImmediate() 的 id。
+预定立即执行的 callback, 它是在 I/O 事件的回调之后被触发.  返回一个用于 clearImmediate() 的 id.
 
-当多次调用 setImmediate() 时，callback 函数会按照它们被创建的顺序依次执行。 每次事件循环迭代都会处理整个回调队列。 如果一个立即定时器是被一个正在执行的回调排入队列的，则该定时器直到下一次事件循环迭代才会被触发。
+当多次调用 setImmediate() 时, callback 函数会按照它们被创建的顺序依次执行.  每次事件循环迭代都会处理整个回调队列.  如果一个立即定时器是被一个正在执行的回调排入队列的, 则该定时器直到下一次事件循环迭代才会被触发.
 
-setImmediate()、setInterval() 和 setTimeout() 方法每次都会返回表示预定的计时器的id。 它们可用于取消定时器并防止触发。
+setImmediate()、setInterval() 和 setTimeout() 方法每次都会返回表示预定的计时器的id.  它们可用于取消定时器并防止触发.
 
 ## clearInterval(id)
 
-* `id` {number} 一个 setInterval() 返回的 id。
+* `id` {number} 一个 setInterval() 返回的 id.
 
-取消一个由 setInterval() 创建的循环定时任务。
+取消一个由 setInterval() 创建的循环定时任务.
 
 例如：
 
@@ -90,12 +95,12 @@ setTimeout(function(){
 
 ## clearTimeout(id)
 
-* `id` {number} 一个 setTimeout() 返回的 id。
+* `id` {number} 一个 setTimeout() 返回的 id.
 
-取消一个由 setTimeout() 创建的定时任务。
+取消一个由 setTimeout() 创建的定时任务.
 
 ## clearImmediate(id)
 
-* `id` {number} 一个 setImmediate() 返回的 id。
+* `id` {number} 一个 setImmediate() 返回的 id.
 
-取消一个由 setImmediate() 创建的 Immediate 对象。
+取消一个由 setImmediate() 创建的 Immediate 对象.
diff --git a/api/toc.md b/api/toc.md
new file mode 100644
index 0000000..d11b189
--- /dev/null
+++ b/api/toc.md
@@ -0,0 +1,84 @@
+@// NB(chrisdickinson): if you move this file, be sure to update tools/doc/html.js to
+@// point at the new location.
+
+* [Overview - 综述](overview)
+* [About - 关于文档](documentation)
+* [Progress - 完善进度](progress)
+* [Changelog - 更新日志](changelog)
+* [Q&A - 疑难解答](qa)
+
+<div class="line"></div>
+
+* [MDN - JavaScript 基础](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/)
+* [JavaScript.info - JavaScript 教程](https://zh.javascript.info/)
+
+<div class="line"></div>
+
+* [Global - 全局对象](global)
+* [Automator - 自动化](automator)
+* [AutoJs6 - 本体应用](autojs)
+* [App - 通用应用](app)
+* [Color - 颜色](color)
+* [Image - 图像](image)
+* [Keys - 按键](keys)
+* [Device - 设备](device)
+* [Storage - 储存](storages)
+* [File - 文件](files)
+* [Engine - 引擎](engines)
+* [Task - 任务](tasks)
+* [Module - 模块](modules)
+* [Plugins - 插件](plugins)
+* [Console - 控制台](console)
+* [Shell](shell)
+* [Media - 多媒体](media)
+* [Sensor - 传感器](sensors)
+* [Recorder - 记录器](recorder)
+* [Timer - 定时器](timers)
+* [Thread - 线程](threads)
+* [Continuation - 协程](continuation)
+* [Event - 事件监听](events)
+* [Dialog - 对话框](dialogs)
+* [Floaty - 悬浮窗](floaty)
+* [Canvas - 画布](canvas)
+* [UI - 用户界面](ui)
+* [Web - 万维网](web)
+* [HTTP](http)
+* [Base64](base64)
+* [Crypto - 密文](crypto)
+* [Internationalization - 国际化](i18n)
+* [E4X](e4x)
+
+<div class="line"></div>
+
+* [Glossaries - 术语](glossaries)
+* [Exceptions - 异常](exceptions)
+* [Intent - 意图](intentType)
+* [Runtime - 运行时](runtime)
+* [Context - 上下文](context)
+* [Activity - 活动](activity)
+
+<div class="line"></div>
+
+* [Data Types - 数据类型](dataTypes)
+* [UiSelector - 选择器](uiSelectorType)
+* [UiObject - 控件节点](uiObjectType)
+* [UiObjectCollection - 控件集合](uiObjectCollectionType)
+* [UiObjectActions - 控件节点行为](uiObjectActionsType)
+* [App - 应用枚举类](appType)
+
+<div class="line"></div>
+
+* [Polyfill - 代码填泥](polyfill)
+* [Arrayx - Array 扩展](arrayx)
+* [Numberx - Number 扩展](numberx)
+* [Mathx - Math 扩展](mathx)
+
+<div class="line"></div>
+
+* [Scripting Java - 脚本化 Java](scriptingJava)
+* [Android API Level - 安卓 API 级别](apiLevel)
+
+<div class="line"></div>
+
+* [GitHub - 应用项目地址](https://github.com/SuperMonster003/AutoJs6/)
+* [GitHub - 文档项目地址](https://github.com/SuperMonster003/AutoJs6-Documentation)
\ No newline at end of file
diff --git a/api/ui.md b/api/ui.md
index 87b3a75..d54a811 100644
--- a/api/ui.md
+++ b/api/ui.md
@@ -1,12 +1,19 @@
-# 用户界面: UI
+# 用户界面 (UI)
 
-ui模块提供了编写用户界面的支持。
+---
 
-    给Android开发者或者高阶用户的提醒，Auto.js的UI系统来自于Android，所有属性和方法都能在Android源码中找到。如果某些代码或属性没有出现在Auto.js的文档中，可以参考Android的文档。
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
+
+---
+
+ui模块提供了编写用户界面的支持.
+
+    给Android开发者或者高阶用户的提醒, Auto.js的UI系统来自于Android, 所有属性和方法都能在Android源码中找到. 如果某些代码或属性没有出现在Auto.js的文档中, 可以参考Android的文档.
     View: https://developer.android.google.cn/reference/android/view/View?hl=cn
     Widget: https://developer.android.google.cn/reference/android/widget/package-summary?hl=cn
 
-带有ui的脚本的的最前面必须使用`"ui";`指定ui模式，否则脚本将不会以ui模式运行。正确示范:s
+带有ui的脚本的的最前面必须使用`"ui";`指定ui模式, 否则脚本将不会以ui模式运行. 正确示范:s
 
 ```
 "ui";
@@ -14,11 +21,11 @@ ui模块提供了编写用户界面的支持。
 //脚本的其他代码
 ```
 
-字符串"ui"的前面可以有注释、空行和空格**[v4.1.0新增]**，但是不能有其他代码。
+字符串"ui"的前面可以有注释、空行和空格**[v4.1.0新增]**, 但是不能有其他代码.
 
-界面是由视图(View)组成的。View分成两种，控件(Widget)和布局(Layout)。控件(Widget)用来具体显示文字、图片、网页等，比如文本控件(text)用来显示文字，按钮控件(button)则可以显示一个按钮并提供点击效果，图片控件(img)则用来显示来自网络或者文件的图片，除此之外还有输入框控件(input)、进度条控件(progressbar)、单选复选框控件(checkbox)等；布局(Layout)则是装着一个或多个控件的"容器"，用于控制在他里面的控件的位置，比如垂直布局(vertical)会把他里面的控件从上往下依次显示(即纵向排列)，水平布局(horizontal)则会把他里面的控件从左往右依次显示(即横向排列)，以及帧布局(frame)，他会把他里面的控件直接在左上角显示，如果有多个控件，后面的控件会重叠在前面的控件上。
+界面是由视图(View)组成的. View分成两种, 控件(Widget)和布局(Layout). 控件(Widget)用来具体显示文字、图片、网页等, 比如文本控件(text)用来显示文字, 按钮控件(button)则可以显示一个按钮并提供点击效果, 图片控件(img)则用来显示来自网络或者文件的图片, 除此之外还有输入框控件(input)、进度条控件(progressbar)、单选复选框控件(checkbox)等；布局(Layout)则是装着一个或多个控件的"容器", 用于控制在他里面的控件的位置, 比如垂直布局(vertical)会把他里面的控件从上往下依次显示(即纵向排列), 水平布局(horizontal)则会把他里面的控件从左往右依次显示(即横向排列), 以及帧布局(frame), 他会把他里面的控件直接在左上角显示, 如果有多个控件, 后面的控件会重叠在前面的控件上.
 
-我们使用xml来编写界面，并通过`ui.layout()`函数指定界面的布局xml。举个例子：
+我们使用xml来编写界面, 并通过`ui.layout()`函数指定界面的布局xml. 举个例子：
 
 ```
 "ui";
@@ -30,13 +37,13 @@ $ui.layout(
 );
 ```
 
-在这个例子中，第3~6行的部分就是xml，指定了界面的具体内容。代码的第3行的标签`<vertical> ... </vertical>`表示垂直布局，布局的标签通常以`<...>`开始，以`</...>`结束，两个标签之间的内容就是布局里面的内容，例如`<frame> ... </frame>`。在这个例子中第4, 5行的内容就是垂直布局(vertical)里面的内容。代码的第4行是一个按钮控件(button)，控件的标签通常以`<...`开始，以`/>`结束，他们之间是控件的具体属性，例如`<text ... />`。在这个例子中`text="第一个按钮"`的部分就是按钮控件(button)的属性，这个属性指定了这个按钮控件的文本内容(text)为"第一个按钮"。
+在这个例子中, 第3~6行的部分就是xml, 指定了界面的具体内容. 代码的第3行的标签`<vertical> ... </vertical>`表示垂直布局, 布局的标签通常以`<...>`开始, 以`</...>`结束, 两个标签之间的内容就是布局里面的内容, 例如`<frame> ... </frame>`. 在这个例子中第4, 5行的内容就是垂直布局(vertical)里面的内容. 代码的第4行是一个按钮控件(button), 控件的标签通常以`<...`开始, 以`/>`结束, 他们之间是控件的具体属性, 例如`<text ... />`. 在这个例子中`text="第一个按钮"`的部分就是按钮控件(button)的属性, 这个属性指定了这个按钮控件的文本内容(text)为"第一个按钮".
 
-代码的第5行和第4行一样，也是一个按钮控件，只不过他的文本内容为"第二个按钮"。这两个控件在垂直布局中，因此会纵向排列，效果如图：
+代码的第5行和第4行一样, 也是一个按钮控件, 只不过他的文本内容为"第二个按钮". 这两个控件在垂直布局中, 因此会纵向排列, 效果如图：
 
 ![ex1](images/ex1.png)
 
-如果我们把这个例子的垂直布局(vertical)改成水平布局(horizontal)，也即：
+如果我们把这个例子的垂直布局(vertical)改成水平布局(horizontal), 也即：
 
 ```
 "ui";
@@ -48,11 +55,11 @@ ui.layout(
 );
 ```
 
-则这两个按钮会横向排列，效果如图：
+则这两个按钮会横向排列, 效果如图：
 
 ![ex1-horizontal](images/ex1-horizontal.png)
 
-一个控件可以指定多个属性(甚至可以不指定任何属性)，用空格隔开即可；布局同样也可以指定属性，例如:
+一个控件可以指定多个属性(甚至可以不指定任何属性), 用空格隔开即可；布局同样也可以指定属性, 例如:
 
 ```
 "ui";
@@ -64,25 +71,25 @@ ui.layout(
 );
 ```
 
-第三行`bg="#ff0000"`指定了垂直布局的背景色(bg)为"#ff0000"，这是一个RGB颜色，表示红色(有关RGB的相关知识参见[RGB颜色对照表](http://tool.oschina.net/commons?type=3))。第四行的`textSize="20sp"`则指定了按钮控件的字体大小(textSize)为"20sp"，sp是一个字体单位，暂时不用深入理会。上述代码的效果如图：
+第三行`bg="#ff0000"`指定了垂直布局的背景色(bg)为"#ff0000", 这是一个RGB颜色, 表示红色(有关RGB的相关知识参见[RGB颜色对照表](http://tool.oschina.net/commons?type=3)). 第四行的`textSize="20sp"`则指定了按钮控件的字体大小(textSize)为"20sp", sp是一个字体单位, 暂时不用深入理会. 上述代码的效果如图：
 
 ![ex-properties](images/ex1-properties.png)
 
-一个界面便由一些布局和控件组成。为了便于文档阅读，我们再说明一下以下术语：
+一个界面便由一些布局和控件组成. 为了便于文档阅读, 我们再说明一下以下术语：
 
-* 子视图, 子控件: 布局里面的控件是这个布局的子控件/子视图。实际上布局里面不仅仅只能有控件，还可以是嵌套的布局。因此用子视图(Child View)更准确一些。在上面的例子中，按钮便是垂直布局的子控件。
-* 父视图，父布局：直接包含一个控件的布局是这个控件的父布局/父视图(Parent View)。在上面的例子中，垂直布局便是按钮的父布局。
+* 子视图, 子控件: 布局里面的控件是这个布局的子控件/子视图. 实际上布局里面不仅仅只能有控件, 还可以是嵌套的布局. 因此用子视图(Child View)更准确一些. 在上面的例子中, 按钮便是垂直布局的子控件.
+* 父视图, 父布局：直接包含一个控件的布局是这个控件的父布局/父视图(Parent View). 在上面的例子中, 垂直布局便是按钮的父布局.
 
 # 视图: View
 
-控件和布局都属于视图(View)。在这个章节中将介绍所有控件和布局的共有的属性和函数。例如属性背景，宽高等(所有控件和布局都能设置背景和宽高)，函数`click()`设置视图(View)被点击时执行的动作。
+控件和布局都属于视图(View). 在这个章节中将介绍所有控件和布局的共有的属性和函数. 例如属性背景, 宽高等(所有控件和布局都能设置背景和宽高), 函数`click()`设置视图(View)被点击时执行的动作.
 
 ## attr(name, value)
 
 * `name` {string} 属性名称
 * `value` {string} 属性的值
 
-设置属性的值。属性指定是View在xml中的属性。例如可以通过语句`attr("text", "文本")`来设置文本控件的文本值。
+设置属性的值. 属性指定是View在xml中的属性. 例如可以通过语句`attr("text", "文本")`来设置文本控件的文本值.
 
 ```javascript
 "ui";
@@ -104,14 +111,14 @@ $ui.post(() => {
 }, 5000);
 ```
 
-**注意：**并不是所有属性都能在js代码设置，有一些属性只能在布局创建时设置，例如style属性；还有一些属性虽然能在代码中设置，但是还没支持；对于这些情况，在Auto.js Pro 8.1.0+会抛出异常，其他版本则不会抛出异常。
+**注意：**并不是所有属性都能在js代码设置, 有一些属性只能在布局创建时设置, 例如style属性；还有一些属性虽然能在代码中设置, 但是还没支持；对于这些情况, 在Auto.js Pro 8.1.0+会抛出异常, 其他版本则不会抛出异常.
 
 ## attr(name)
 
 * `name` {string} 属性名称
 * 返回 {string}
 
-获取属性的值。
+获取属性的值.
 
 ```javascript
 "ui";
@@ -141,7 +148,7 @@ function plusOne() {
 
 ## w
 
-View的宽度，是属性`width`的缩写形式。可以设置的值为`*`, `auto`和具体数值。其中`*`表示宽度**尽量**填满父布局，而`auto`表示宽度将根据View的内容自动调整(自适应宽度)。例如：
+View的宽度, 是属性`width`的缩写形式. 可以设置的值为`*`, `auto`和具体数值. 其中`*`表示宽度**尽量**填满父布局, 而`auto`表示宽度将根据View的内容自动调整(自适应宽度). 例如：
 
 ```
 "ui";
@@ -153,13 +160,13 @@ ui.layout(
 );
 ```
 
-在这个例子中，第一个按钮为自适应宽度，第二个按钮为填满父布局，显示效果为：
+在这个例子中, 第一个按钮为自适应宽度, 第二个按钮为填满父布局, 显示效果为：
 
 ![ex-w](images/ex-w.png)
 
-如果不设置该属性，则不同的控件和布局有不同的默认宽度，大多数为`auto`。
+如果不设置该属性, 则不同的控件和布局有不同的默认宽度, 大多数为`auto`.
 
-宽度属性也可以指定一个具体数值。例如`w="20"`，`w="20px"`等。不加单位的情况下默认单位为dp，其他单位包括px(像素), mm(毫米), in(英寸)。有关尺寸单位的更多内容，参见[尺寸的单位: Dimension](#ui_尺寸的单位_Dimension)。
+宽度属性也可以指定一个具体数值. 例如`w="20"`, `w="20px"`等. 不加单位的情况下默认单位为dp, 其他单位包括px(像素), mm(毫米), in(英寸). 有关尺寸单位的更多内容, 参见[尺寸的单位: Dimension](#ui_尺寸的单位_Dimension).
 
 ```
 "ui";
@@ -173,15 +180,15 @@ ui.layout(
 
 ## h
 
-View的高度，是属性`height`的缩写形式。可以设置的值为`*`, `auto`和具体数值。其中`*`表示宽度**尽量**填满父布局，而`auto`表示宽度将根据View的内容自动调整(自适应宽度)。
+View的高度, 是属性`height`的缩写形式. 可以设置的值为`*`, `auto`和具体数值. 其中`*`表示宽度**尽量**填满父布局, 而`auto`表示宽度将根据View的内容自动调整(自适应宽度).
 
-如果不设置该属性，则不同的控件和布局有不同的默认高度，大多数为`auto`。
+如果不设置该属性, 则不同的控件和布局有不同的默认高度, 大多数为`auto`.
 
-宽度属性也可以指定一个具体数值。例如`h="20"`，`h="20px"`等。不加单位的情况下默认单位为dp，其他单位包括px(像素), mm(毫米), in(英寸)。有关尺寸单位的更多内容，参见[尺寸的单位: Dimension](#ui_尺寸的单位_Dimension)。
+宽度属性也可以指定一个具体数值. 例如`h="20"`, `h="20px"`等. 不加单位的情况下默认单位为dp, 其他单位包括px(像素), mm(毫米), in(英寸). 有关尺寸单位的更多内容, 参见[尺寸的单位: Dimension](#ui_尺寸的单位_Dimension).
 
 ## id
 
-View的id，用来区分一个界面下的不同控件和布局，一个界面的id在同一个界面下通常是唯一的，也就是一般不存在两个View有相同的id。id属性也是连接xml布局和JavaScript代码的桥梁，在代码中可以通过一个View的id来获取到这个View，并对他进行操作(设置点击动作、设置属性、获取属性等)。例如：
+View的id, 用来区分一个界面下的不同控件和布局, 一个界面的id在同一个界面下通常是唯一的, 也就是一般不存在两个View有相同的id. id属性也是连接xml布局和JavaScript代码的桥梁, 在代码中可以通过一个View的id来获取到这个View, 并对他进行操作(设置点击动作、设置属性、获取属性等). 例如：
 
 ```
 "ui";
@@ -194,12 +201,12 @@ ui.layout(
 toast(ui.ok.getText());
 ```
 
-这个例子中有一个按钮控件"确定"，id属性为"ok"，那么我们可以在代码中使用`ui.ok`来获取他，再通过`getText()`函数获取到这个按钮控件的文本内容。
-另外这个例子中使用帧布局(frame)是因为，我们只有一个控件，因此用于最简单的布局帧布局。
+这个例子中有一个按钮控件"确定", id属性为"ok", 那么我们可以在代码中使用`ui.ok`来获取他, 再通过`getText()`函数获取到这个按钮控件的文本内容.
+另外这个例子中使用帧布局(frame)是因为, 我们只有一个控件, 因此用于最简单的布局帧布局.
 
 ## gravity
 
-View的"重力"。用于决定View的内容相对于View的位置，可以设置的值为:
+View的"重力". 用于决定View的内容相对于View的位置, 可以设置的值为:
 
 * `left` 靠左
 * `right` 靠右
@@ -209,7 +216,7 @@ View的"重力"。用于决定View的内容相对于View的位置，可以设置
 * `center_vertical` 垂直居中
 * `center_horizontal` 水平居中
 
-例如对于一个按钮控件，`gravity="right"`会使其中的文本内容靠右显示。例如：
+例如对于一个按钮控件, `gravity="right"`会使其中的文本内容靠右显示. 例如：
 
 ```
 "ui";
@@ -224,11 +231,11 @@ ui.layout(
 
 ![ex-gravity](images/ex-gravity.png)
 
-这些属性是可以组合的，例如`gravity="right|bottom"`的View他的内容会在右下角。
+这些属性是可以组合的, 例如`gravity="right|bottom"`的View他的内容会在右下角.
 
 ## layout_gravity
 
-View在布局中的"重力"，用于决定View本身在他的**父布局**的位置，可以设置的值和gravity属性相同。注意把这个属性和gravity属性区分开来。
+View在布局中的"重力", 用于决定View本身在他的**父布局**的位置, 可以设置的值和gravity属性相同. 注意把这个属性和gravity属性区分开来.
 
 ```
 "ui";
@@ -240,15 +247,15 @@ ui.layout(
 );
 ```
 
-在这个例子中，我们让帧布局(frame)的大小占满整个屏幕，通过给第一个按钮设置属性`layout_gravity="center"`来使得按钮在帧布局中居中，通过给第二个按钮设置属性`layout_gravity="right|bottom"`使得他在帧布局中位于右下角。效果如图：
+在这个例子中, 我们让帧布局(frame)的大小占满整个屏幕, 通过给第一个按钮设置属性`layout_gravity="center"`来使得按钮在帧布局中居中, 通过给第二个按钮设置属性`layout_gravity="right|bottom"`使得他在帧布局中位于右下角. 效果如图：
 
 ![ex-layout-gravity](images/ex-layout-gravity.png)
 
-要注意的是，layout_gravity的属性不一定总是生效的，具体取决于布局的类别。例如不能让水平布局中的第一个子控件靠底部显示(否则和水平布局本身相违背)。
+要注意的是, layout_gravity的属性不一定总是生效的, 具体取决于布局的类别. 例如不能让水平布局中的第一个子控件靠底部显示(否则和水平布局本身相违背).
 
 ## margin
 
-margin为View和其他View的间距，即外边距。margin属性包括四个值:
+margin为View和其他View的间距, 即外边距. margin属性包括四个值:
 
 * `marginLeft` 左外边距
 * `marginRight` 右外边距
@@ -257,9 +264,9 @@ margin为View和其他View的间距，即外边距。margin属性包括四个值
 
 而margin属性本身的值可以有三种格式:
 
-* `margin="marginAll"` 指定各个外边距都是该值。例如`margin="10"`表示左右上下边距都是10dp。
-* `margin="marginLeft marginTop marginRight marginBottom"` 分别指定各个外边距。例如`margin="10 20 30 40"`表示左边距为10dp, 上边距为20dp, 右边距为30dp, 下边距为40dp
-* `margin="marginHorizontal marginVertical"` 指定水平外边距和垂直外边距。例如`margin="10 20"`表示左右边距为10dp, 上下边距为20dp。
+* `margin="marginAll"` 指定各个外边距都是该值. 例如`margin="10"`表示左右上下边距都是10dp.
+* `margin="marginLeft marginTop marginRight marginBottom"` 分别指定各个外边距. 例如`margin="10 20 30 40"`表示左边距为10dp, 上边距为20dp, 右边距为30dp, 下边距为40dp
+* `margin="marginHorizontal marginVertical"` 指定水平外边距和垂直外边距. 例如`margin="10 20"`表示左右边距为10dp, 上下边距为20dp.
 
 用一个例子来具体理解外边距的含义：
 
@@ -281,11 +288,11 @@ ui.layout(
 
 ![ex2-margin](images/ex2-margin.png)
 
-有关margin属性的单位，参见[尺寸的单位: Dimension](#ui_尺寸的单位_Dimension)。
+有关margin属性的单位, 参见[尺寸的单位: Dimension](#ui_尺寸的单位_Dimension).
 
 ## marginLeft
 
-View的左外边距。如果该属性和margin属性指定的值冲突，则在后面的属性生效，前面的属性无效，例如`margin="20" marginLeft="10"`的左外边距为10dp，其他外边距为20dp。
+View的左外边距. 如果该属性和margin属性指定的值冲突, 则在后面的属性生效, 前面的属性无效, 例如`margin="20" marginLeft="10"`的左外边距为10dp, 其他外边距为20dp.
 
 ```
 "ui";
@@ -297,31 +304,31 @@ ui.layout(
 );
 ```
 
-第一个按钮指定了左外边距为50dp，则他和他的父布局水平布局(horizontal)的左边的间距为50dp, 效果如图：
+第一个按钮指定了左外边距为50dp, 则他和他的父布局水平布局(horizontal)的左边的间距为50dp, 效果如图：
 
 ![ex-marginLeft](images/ex-marginLeft.png)
 
 ## marginRight
 
-View的右外边距。如果该属性和margin属性指定的值冲突，则在后面的属性生效，前面的属性无效。
+View的右外边距. 如果该属性和margin属性指定的值冲突, 则在后面的属性生效, 前面的属性无效.
 
 ## marginTop
 
-View的上外边距。如果该属性和margin属性指定的值冲突，则在后面的属性生效，前面的属性无效。
+View的上外边距. 如果该属性和margin属性指定的值冲突, 则在后面的属性生效, 前面的属性无效.
 
 ## marginBottom
 
-View的下外边距。如果该属性和margin属性指定的值冲突，则在后面的属性生效，前面的属性无效。
+View的下外边距. 如果该属性和margin属性指定的值冲突, 则在后面的属性生效, 前面的属性无效.
 
 ## padding
 
-View和他的自身内容的间距，也就是内边距。注意和margin属性区分开来，margin属性是View之间的间距，而padding是View和他自身内容的间距。举个例子，一个文本控件的padding也即文本控件的边缘和他的文本内容的间距，paddingLeft即文本控件的左边和他的文本内容的间距。
+View和他的自身内容的间距, 也就是内边距. 注意和margin属性区分开来, margin属性是View之间的间距, 而padding是View和他自身内容的间距. 举个例子, 一个文本控件的padding也即文本控件的边缘和他的文本内容的间距, paddingLeft即文本控件的左边和他的文本内容的间距.
 
 paddding属性的值同样有三种格式：
 
-* `padding="paddingAll"` 指定各个内边距都是该值。例如`padding="10"`表示左右上下内边距都是10dp。
-* `padding="paddingLeft paddingTop paddingRight paddingBottom"` 分别指定各个内边距。例如`padding="10 20 30 40"`表示左内边距为10dp, 上内边距为20dp, 右内边距为30dp, 下内边距为40dp
-* `padding="paddingHorizontal paddingVertical"` 指定水平内边距和垂直内边距。例如`padding="10 20"`表示左右内边距为10dp, 上下内边距为20dp。
+* `padding="paddingAll"` 指定各个内边距都是该值. 例如`padding="10"`表示左右上下内边距都是10dp.
+* `padding="paddingLeft paddingTop paddingRight paddingBottom"` 分别指定各个内边距. 例如`padding="10 20 30 40"`表示左内边距为10dp, 上内边距为20dp, 右内边距为30dp, 下内边距为40dp
+* `padding="paddingHorizontal paddingVertical"` 指定水平内边距和垂直内边距. 例如`padding="10 20"`表示左右内边距为10dp, 上下内边距为20dp.
 
 用一个例子来具体理解内边距的含义：
 
@@ -334,131 +341,131 @@ ui.layout(
 );
 ```
 
-这个例子是一个居中的按钮(通过父布局的`gravity="center"`属性设置)，背景色为红色(`bg="#ff0000"`)，文本内容为"HelloWorld"，左边距为10dp，上边距为20dp，下边距为30dp，右边距为40dp，其显示效果如图：
+这个例子是一个居中的按钮(通过父布局的`gravity="center"`属性设置), 背景色为红色(`bg="#ff0000"`), 文本内容为"HelloWorld", 左边距为10dp, 上边距为20dp, 下边距为30dp, 右边距为40dp, 其显示效果如图：
 
 ![ex-padding](images/ex-padding.png)
 
 ## paddingLeft
 
-View的左内边距。如果该属性和padding属性指定的值冲突，则在后面的属性生效，前面的属性无效。
+View的左内边距. 如果该属性和padding属性指定的值冲突, 则在后面的属性生效, 前面的属性无效.
 
 ## paddingRight
 
-View的右内边距。如果该属性和padding属性指定的值冲突，则在后面的属性生效，前面的属性无效。
+View的右内边距. 如果该属性和padding属性指定的值冲突, 则在后面的属性生效, 前面的属性无效.
 
 ## paddingTop
 
-View的上内边距。如果该属性和padding属性指定的值冲突，则在后面的属性生效，前面的属性无效。
+View的上内边距. 如果该属性和padding属性指定的值冲突, 则在后面的属性生效, 前面的属性无效.
 
 ## paddingBottom
 
-View的下内边距。如果该属性和padding属性指定的值冲突，则在后面的属性生效，前面的属性无效。
+View的下内边距. 如果该属性和padding属性指定的值冲突, 则在后面的属性生效, 前面的属性无效.
 
 ## bg
 
-View的背景。其值可以是一个链接或路径指向的图片，或者RGB格式的颜色，或者其他背景。具体参见[Drawables](#draw)。
+View的背景. 其值可以是一个链接或路径指向的图片, 或者RGB格式的颜色, 或者其他背景. 具体参见[Drawables](#draw).
 
-例如，`bg="#00ff00"`设置背景为绿色，`bg="file:///sdcard/1.png"`设置背景为图片"1.png"，`bg="?attr/selectableItemBackground"`设置背景为点击时出现的波纹效果(可能需要同时设置`clickable="true"`才生效)。
+例如, `bg="#00ff00"`设置背景为绿色, `bg="file:///sdcard/1.png"`设置背景为图片"1.png", `bg="?attr/selectableItemBackground"`设置背景为点击时出现的波纹效果(可能需要同时设置`clickable="true"`才生效).
 
 ## alpha
 
-View的透明度，其值是一个0~1之间的小数，0表示完全透明，1表示完全不透明。例如`alpha="0.5"`表示半透明。
+View的透明度, 其值是一个0~1之间的小数, 0表示完全透明, 1表示完全不透明. 例如`alpha="0.5"`表示半透明.
 
 ## foreground
 
-View的前景。前景即在一个View的内容上显示的内容，可能会覆盖掉View本身的内容。其值和属性bg的值类似。
+View的前景. 前景即在一个View的内容上显示的内容, 可能会覆盖掉View本身的内容. 其值和属性bg的值类似.
 
 ## minHeight
 
-View的最小高度。该值不总是生效的，取决于其父布局是否有足够的空间容纳。
+View的最小高度. 该值不总是生效的, 取决于其父布局是否有足够的空间容纳.
 
 例：`<text height="auto" minHeight="50"/>`
 
-有关该属性的单位，参见[尺寸的单位: Dimension](#ui_尺寸的单位_Dimension)。
+有关该属性的单位, 参见[尺寸的单位: Dimension](#ui_尺寸的单位_Dimension).
 
 ## minWidth
 
-View的最小宽度。该值不总是生效的，取决于其父布局是否有足够的空间容纳。
+View的最小宽度. 该值不总是生效的, 取决于其父布局是否有足够的空间容纳.
 
 例：`<input width="auto" minWidth="50"/>`
 
-有关该属性的单位，参见[尺寸的单位: Dimension](#ui_尺寸的单位_Dimension)。
+有关该属性的单位, 参见[尺寸的单位: Dimension](#ui_尺寸的单位_Dimension).
 
 ## visibility
 
-View的可见性，该属性可以决定View是否显示出来。其值可以为：
+View的可见性, 该属性可以决定View是否显示出来. 其值可以为：
 
-* `gone` 不可见。
-* `visible` 可见。默认情况下View都是可见的。
-* `invisible` 不可见，但仍然占用位置。
+* `gone` 不可见.
+* `visible` 可见. 默认情况下View都是可见的.
+* `invisible` 不可见, 但仍然占用位置.
 
 ## rotation
 
-View的旋转角度。通过该属性可以让这个View顺时针旋转一定的角度。例如`rotation="90"`可以让他顺时针旋转90度。
+View的旋转角度. 通过该属性可以让这个View顺时针旋转一定的角度. 例如`rotation="90"`可以让他顺时针旋转90度.
 
-如果要设置旋转中心，可以通过`transformPivotX`, `transformPivotY`属性设置。默认的旋转中心为View的中心。
+如果要设置旋转中心, 可以通过`transformPivotX`, `transformPivotY`属性设置. 默认的旋转中心为View的中心.
 
 ## transformPivotX
 
-View的变换中心坐标x。用于View的旋转、放缩等变换的中心坐标。例如`transformPivotX="10"`。
+View的变换中心坐标x. 用于View的旋转、放缩等变换的中心坐标. 例如`transformPivotX="10"`.
 
-该坐标的坐标系以View的左上角为原点。也就是x值为变换中心到View的左边的距离。
+该坐标的坐标系以View的左上角为原点. 也就是x值为变换中心到View的左边的距离.
 
-有关该属性的单位，参见[尺寸的单位: Dimension](#ui_尺寸的单位_Dimension)。
+有关该属性的单位, 参见[尺寸的单位: Dimension](#ui_尺寸的单位_Dimension).
 
 ## transformPivotY
 
-View的变换中心坐标y。用于View的旋转、放缩等变换的中心坐标。例如`transformPivotY="10"`。
+View的变换中心坐标y. 用于View的旋转、放缩等变换的中心坐标. 例如`transformPivotY="10"`.
 
-该坐标的坐标系以View的左上角为原点。也就是y值为变换中心到View的上边的距离。
+该坐标的坐标系以View的左上角为原点. 也就是y值为变换中心到View的上边的距离.
 
-有关该属性的单位，参见[尺寸的单位: Dimension](#ui_尺寸的单位_Dimension)。
+有关该属性的单位, 参见[尺寸的单位: Dimension](#ui_尺寸的单位_Dimension).
 
 ## style
 
-设置View的样式。不同控件有不同的可选的内置样式。具体参见各个控件的说明。
+设置View的样式. 不同控件有不同的可选的内置样式. 具体参见各个控件的说明.
 
-需要注意的是，style属性只支持安卓5.1及其以上。
+需要注意的是, style属性只支持安卓5.1及其以上.
 
 # 文本控件: text
 
-文本控件用于显示文本，可以控制文本的字体大小，字体颜色，字体等。
+文本控件用于显示文本, 可以控制文本的字体大小, 字体颜色, 字体等.
 
-以下介绍该控件的主要属性和方法，如果要查看他的所有属性和方法，请阅读[TextView](http://www.zhdoc.net/android/reference/android/widget/TextView.html)。
+以下介绍该控件的主要属性和方法, 如果要查看他的所有属性和方法, 请阅读[TextView](http://www.zhdoc.net/android/reference/android/widget/TextView.html).
 
 ## text
 
-设置文本的内容。例如`text="一段文本"`。
+设置文本的内容. 例如`text="一段文本"`.
 
 ## textColor
 
-设置字体的颜色，可以是RGB格式的颜色(例如#ff00ff)，或者颜色名称(例如red, green等)，具体参见[颜色](#ui_颜色)。
+设置字体的颜色, 可以是RGB格式的颜色(例如#ff00ff), 或者颜色名称(例如red, green等), 具体参见[颜色](#ui_颜色).
 
 示例, 红色字体：`<text text="红色字体" textColor="red"/>`
 
 ## textSize
 
-设置字体的大小，单位一般是sp。按照Material Design的规范，正文字体大小为14sp，标题字体大小为18sp，次标题为16sp。
+设置字体的大小, 单位一般是sp. 按照Material Design的规范, 正文字体大小为14sp, 标题字体大小为18sp, 次标题为16sp.
 
-示例，超大字体: `<text text="超大字体" textSize="40sp"/>`
+示例, 超大字体: `<text text="超大字体" textSize="40sp"/>`
 
 ## textStyle
 
-设置字体的样式，比如斜体、粗体等。可选的值为：
+设置字体的样式, 比如斜体、粗体等. 可选的值为：
 
 * bold 加粗字体
 * italic 斜体
 * normal 正常字体
 
-可以用或("|")把他们组合起来，比如粗斜体为"bold|italic"。
+可以用或("|")把他们组合起来, 比如粗斜体为"bold|italic".
 
-例如，粗体：`<text textStyle="bold" textSize="18sp" text="这是粗体"/>
+例如, 粗体：`<text textStyle="bold" textSize="18sp" text="这是粗体"/>
 
 ## lines
 
-设置文本控件的行数。即使文本内容没有达到设置的行数，控件也会留出相应的宽度来显示空白行；如果文本内容超出了设置的行数，则超出的部分不会显示。
+设置文本控件的行数. 即使文本内容没有达到设置的行数, 控件也会留出相应的宽度来显示空白行；如果文本内容超出了设置的行数, 则超出的部分不会显示.
 
-另外在xml中是不能设置多行文本的，要在代码中设置。例如:
+另外在xml中是不能设置多行文本的, 要在代码中设置. 例如:
 
 ```
 "ui";
@@ -473,40 +480,40 @@ ui.myText.setText("第一行\n第二行\n第三行\n第四行");
 
 ## maxLines
 
-设置文本控件的最大行数。
+设置文本控件的最大行数.
 
 ## typeface
 
-设置字体。可选的值为：
+设置字体. 可选的值为：
 
 * `normal` 正常字体
 * `sans` 衬线字体
 * `serif` 非衬线字体
 * `monospace` 等宽字体
 
-示例，等宽字体: `<text text="等宽字体" typeface="monospace"/>`
+示例, 等宽字体: `<text text="等宽字体" typeface="monospace"/>`
 
 ## ellipsize
 
-设置文本的省略号位置。文本的省略号会在文本内容超出文本控件时显示。可选的值为：
+设置文本的省略号位置. 文本的省略号会在文本内容超出文本控件时显示. 可选的值为：
 
 * `end`   在文本末尾显示省略号
-* `marquee`   跑马灯效果，文本将滚动显示
+* `marquee`   跑马灯效果, 文本将滚动显示
 * `middle`    在文本中间显示省略号
 * `none`    不显示省略号
 * `start`    在文本开头显示省略号
 
 ## ems
 
-当设置该属性后,TextView显示的字符长度（单位是em）,超出的部分将不显示，或者根据ellipsize属性的设置显示省略号。
+当设置该属性后,TextView显示的字符长度（单位是em）,超出的部分将不显示, 或者根据ellipsize属性的设置显示省略号.
 
-例如，限制文本最长为5em: `<text ems="5" ellipsize="end" text="很长很长很长很长很长很长很长的文本"/>
+例如, 限制文本最长为5em: `<text ems="5" ellipsize="end" text="很长很长很长很长很长很长很长的文本"/>
 
 ## autoLink
 
-控制是否自动找到url和电子邮件地址等链接，并转换为可点击的链接。默认值为“none”。
+控制是否自动找到url和电子邮件地址等链接, 并转换为可点击的链接. 默认值为“none”.
 
-设置该值可以让文本中的链接、电话等变成可点击状态。
+设置该值可以让文本中的链接、电话等变成可点击状态.
 
 可选的值为以下的值以其通过或("|")的组合：
 
@@ -521,23 +528,23 @@ ui.myText.setText("第一行\n第二行\n第三行\n第四行");
 
 # 按钮控件: button
 
-按钮控件是一个特殊的文本控件，因此所有文本控件的函数的属性都适用于按钮控件。
+按钮控件是一个特殊的文本控件, 因此所有文本控件的函数的属性都适用于按钮控件.
 
-除此之外，按钮控件有一些内置的样式，通过`style`属性设置，包括：
+除此之外, 按钮控件有一些内置的样式, 通过`style`属性设置, 包括：
 
 * Widget.AppCompat.Button.Colored 带颜色的按钮
 * Widget.AppCompat.Button.Borderless 无边框按钮
 * Widget.AppCompat.Button.Borderless.Colored 带颜色的无边框按钮
 
-这些样式的具体效果参见"示例/界面控件/按钮控件.js"。
+这些样式的具体效果参见"示例/界面控件/按钮控件.js".
 
 例如：`<button style="Widget.AppCompat.Button.Colored" text="漂亮的按钮"/>`
 
 # 输入框控件: input
 
-输入框控件也是一个特殊的文本控件，因此所有文本控件的函数的属性和函数都适用于按钮控件。输入框控件有自己的属性和函数，要查看所有这些内容，阅读[EditText](http://www.zhdoc.net/android/reference/android/widget/EditText.html)。
+输入框控件也是一个特殊的文本控件, 因此所有文本控件的函数的属性和函数都适用于按钮控件. 输入框控件有自己的属性和函数, 要查看所有这些内容, 阅读[EditText](http://www.zhdoc.net/android/reference/android/widget/EditText.html).
 
-对于一个输入框控件，我们可以通过text属性设置他的内容，通过lines属性指定输入框的行数；在代码中通过`getText()`函数获取输入的内容。例如：
+对于一个输入框控件, 我们可以通过text属性设置他的内容, 通过lines属性指定输入框的行数；在代码中通过`getText()`函数获取输入的内容. 例如：
 
 ```
 "ui";
@@ -560,11 +567,11 @@ ui.ok.click(function(){
 
 ![ex-input](ex-input.png)
 
-除此之外，输入框控件有另外一些主要属性(虽然这些属性对于文本控件也是可用的但一般只用于输入框控件)：
+除此之外, 输入框控件有另外一些主要属性(虽然这些属性对于文本控件也是可用的但一般只用于输入框控件)：
 
 ## hint
 
-输入提示。这个提示会在输入框为空的时候显示出来。如图所示:
+输入提示. 这个提示会在输入框为空的时候显示出来. 如图所示:
 
 ![ex-hint](images/ex-hint.png)
 
@@ -581,91 +588,91 @@ ui.layout(
 
 ## textColorHint
 
-指定输入提示的字体颜色。
+指定输入提示的字体颜色.
 
 ## textSizeHint
 
-指定输入提示的字体大小。
+指定输入提示的字体大小.
 
 ## inputType
 
-指定输入框可以输入的文本类型。可选的值为以下值及其用"|"的组合:
-
-* `date`    用于输入日期。
-* `datetime`    用于输入日期和时间。
-* `none`    没有内容类型。此输入框不可编辑。
-* `number`    仅可输入数字。
-* `numberDecimal`    可以与number和它的其他选项组合，以允许输入十进制数(包括小数)。
-* `numberPassword`    仅可输入数字密码。
-* `numberSigned`    可以与number和它的其他选项组合，以允许输入有符号的数。
-* `phone`    用于输入一个电话号码。
-* `text`    只是普通文本。
-* `textAutoComplete`    可以与text和它的其他选项结合, 以指定此字段将做自己的自动完成, 并适当地与输入法交互。
-* `textAutoCorrect`    可以与text和它的其他选项结合, 以请求自动文本输入纠错。
-* `textCapCharacters`    可以与text和它的其他选项结合, 以请求大写所有字符。
-* `textCapSentences`    可以与text和它的其他选项结合, 以请求大写每个句子里面的第一个字符。
-* `textCapWords`    可以与text和它的其他选项结合, 以请求大写每个单词里面的第一个字符。
-* `textEmailAddress`    用于输入一个电子邮件地址。
-* `textEmailSubject`    用于输入电子邮件的主题。
-* `textImeMultiLine`    可以与text和它的其他选项结合，以指示虽然常规文本视图不应为多行, 但如果可以, 则IME应提供多行支持。
-* `textLongMessage`    用于输入长消息的内容。
-* `textMultiLine`    可以与text和它的其他选项结合, 以便在该字段中允许多行文本。如果未设置此标志, 则文本字段将被限制为单行。
-* `textNoSuggestions`    可以与text及它的其他选项结合, 以指示输入法不应显示任何基于字典的单词建议。
-* `textPassword`    用于输入密码。
-* `textPersonName`    用于输入人名。
-* `textPhonetic`    用于输入拼音发音的文本, 如联系人条目中的拼音名称字段。
-* `textPostalAddress`    用于输入邮寄地址。
-* `textShortMessage`    用于输入短的消息内容。
-* `textUri`    用于输入一个URI。
-* `textVisiblePassword`    用于输入可见的密码。
-* `textWebEditText`    用于输入在web表单中的文本。
-* `textWebEmailAddress`    用于在web表单里输入一个电子邮件地址。
-* `textWebPassword`    用于在web表单里输入一个密码。
-* `time`    用于输入时间。
-
-例如，想指定一个输入框的输入类型为小数数字，为: `<input inputType="number|numberDecimal"/>`
+指定输入框可以输入的文本类型. 可选的值为以下值及其用"|"的组合:
+
+* `date`    用于输入日期.
+* `datetime`    用于输入日期和时间.
+* `none`    没有内容类型. 此输入框不可编辑.
+* `number`    仅可输入数字.
+* `numberDecimal`    可以与number和它的其他选项组合, 以允许输入十进制数(包括小数).
+* `numberPassword`    仅可输入数字密码.
+* `numberSigned`    可以与number和它的其他选项组合, 以允许输入有符号的数.
+* `phone`    用于输入一个电话号码.
+* `text`    只是普通文本.
+* `textAutoComplete`    可以与text和它的其他选项结合, 以指定此字段将做自己的自动完成, 并适当地与输入法交互.
+* `textAutoCorrect`    可以与text和它的其他选项结合, 以请求自动文本输入纠错.
+* `textCapCharacters`    可以与text和它的其他选项结合, 以请求大写所有字符.
+* `textCapSentences`    可以与text和它的其他选项结合, 以请求大写每个句子里面的第一个字符.
+* `textCapWords`    可以与text和它的其他选项结合, 以请求大写每个单词里面的第一个字符.
+* `textEmailAddress`    用于输入一个电子邮件地址.
+* `textEmailSubject`    用于输入电子邮件的主题.
+* `textImeMultiLine`    可以与text和它的其他选项结合, 以指示虽然常规文本视图不应为多行, 但如果可以, 则IME应提供多行支持.
+* `textLongMessage`    用于输入长消息的内容.
+* `textMultiLine`    可以与text和它的其他选项结合, 以便在该字段中允许多行文本. 如果未设置此标志, 则文本字段将被限制为单行.
+* `textNoSuggestions`    可以与text及它的其他选项结合, 以指示输入法不应显示任何基于字典的单词建议.
+* `textPassword`    用于输入密码.
+* `textPersonName`    用于输入人名.
+* `textPhonetic`    用于输入拼音发音的文本, 如联系人条目中的拼音名称字段.
+* `textPostalAddress`    用于输入邮寄地址.
+* `textShortMessage`    用于输入短的消息内容.
+* `textUri`    用于输入一个URI.
+* `textVisiblePassword`    用于输入可见的密码.
+* `textWebEditText`    用于输入在web表单中的文本.
+* `textWebEmailAddress`    用于在web表单里输入一个电子邮件地址.
+* `textWebPassword`    用于在web表单里输入一个密码.
+* `time`    用于输入时间.
+
+例如, 想指定一个输入框的输入类型为小数数字, 为: `<input inputType="number|numberDecimal"/>`
 
 ## password
 
-指定输入框输入框是否为密码输入框。默认为`false`。
+指定输入框输入框是否为密码输入框. 默认为`false`.
 
 例如：`<input password="true"/>`
 
 ## numeric
 
-指定输入框输入框是否为数字输入框。默认为`false`。
+指定输入框输入框是否为数字输入框. 默认为`false`.
 
 例如：`<input numeric="true"/>`
 
 ## phoneNumber
 
-指定输入框输入框是否为电话号码输入框。默认为`false`。
+指定输入框输入框是否为电话号码输入框. 默认为`false`.
 
 例如：`<input phoneNumber="true"/>`
 
 ## digits
 
-指定输入框可以输入的字符。例如，要指定输入框只能输入"1234567890+-"，为`<input digits="1234567890+-"/>`。
+指定输入框可以输入的字符. 例如, 要指定输入框只能输入"1234567890+-", 为`<input digits="1234567890+-"/>`.
 
 ## singleLine
 
-指定输入框是否为单行输入框。默认为`false`。您也可以通过`lines="1"`来指定单行输入框。
+指定输入框是否为单行输入框. 默认为`false`. 您也可以通过`lines="1"`来指定单行输入框.
 
 例如：`<input singleLine="true"/>`
 
 # 图片控件: img
 
-图片控件用于显示来自网络、本地或者内嵌数据的图片，并可以指定图片以圆角矩形、圆形等显示。但是不能用于显示gif动态图。
+图片控件用于显示来自网络、本地或者内嵌数据的图片, 并可以指定图片以圆角矩形、圆形等显示. 但是不能用于显示gif动态图.
 
-这里只介绍他的主要方法和属性，如果要查看他的所有方法和属性，阅读[ImageView](http://www.zhdoc.net/android/reference/android/widget/ImageView.html)。
+这里只介绍他的主要方法和属性, 如果要查看他的所有方法和属性, 阅读[ImageView](http://www.zhdoc.net/android/reference/android/widget/ImageView.html).
 
 ## src
 
-使用一个Uri指定图片的来源。可以是图片的地址(http://....)，本地路径(file://....)或者base64数据("data:image/png;base64,...")。
+使用一个Uri指定图片的来源. 可以是图片的地址(http://....), 本地路径(file://....)或者base64数据("data:image/png;base64,...").
 
-如果使用图片地址或本地路径，Auto.js会自动使用适当的缓存来储存这些图片，减少下次加载的时间。
+如果使用图片地址或本地路径, Auto.js会自动使用适当的缓存来储存这些图片, 减少下次加载的时间.
 
-例如，显示百度的logo:
+例如, 显示百度的logo:
 
 ```
 "ui";
@@ -676,8 +683,8 @@ ui.layout(
 );
 ```
 
-再例如，显示文件/sdcard/1.png的图片为 `<img src="file:///sdcard/1.png"/>`。
-再例如，使base64显示一张钱包小图片为：
+再例如, 显示文件/sdcard/1.png的图片为 `<img src="file:///sdcard/1.png"/>`.
+再例如, 使base64显示一张钱包小图片为：
 
 ```
 "ui";
@@ -690,67 +697,67 @@ ui.layout(
 
 ## tint
 
-图片着色，其值是一个颜色名称或RGB颜色值。使用该属性会将图片中的非透明区域都涂上同一颜色。可以用于改变图片的颜色。
+图片着色, 其值是一个颜色名称或RGB颜色值. 使用该属性会将图片中的非透明区域都涂上同一颜色. 可以用于改变图片的颜色.
 
-例如，对于上面的base64的图片: `<img w="40" h="40" tint="red" src="data:image/png;base64,..."/>`，则钱包图标颜色会变成红色。
+例如, 对于上面的base64的图片: `<img w="40" h="40" tint="red" src="data:image/png;base64,..."/>`, 则钱包图标颜色会变成红色.
 
 ## scaleType
 
-控制图片根据图片控件的宽高放缩时的模式。可选的值为：
+控制图片根据图片控件的宽高放缩时的模式. 可选的值为：
 
-* `center`    在控件中居中显示图像, 但不执行缩放。
-* `centerCrop`    保持图像的长宽比缩放图片, 使图像的尺寸 (宽度和高度) 等于或大于控件的相应尺寸 (不包括内边距padding)并且使图像在控件中居中显示。
-* `centerInside`    保持图像的长宽比缩放图片, 使图像的尺寸 (宽度和高度) 小于视图的相应尺寸 (不包括内边距padding)并且图像在控件中居中显示。
+* `center`    在控件中居中显示图像, 但不执行缩放.
+* `centerCrop`    保持图像的长宽比缩放图片, 使图像的尺寸 (宽度和高度) 等于或大于控件的相应尺寸 (不包括内边距padding)并且使图像在控件中居中显示.
+* `centerInside`    保持图像的长宽比缩放图片, 使图像的尺寸 (宽度和高度) 小于视图的相应尺寸 (不包括内边距padding)并且图像在控件中居中显示.
 * `fitCenter`    保持图像的长宽比缩放图片, 使图片的宽**或**高和控件的宽高相同并使图片在控件中居中显示
 * `fitEnd`    保持图像的长宽比缩放图片, 使图片的宽**或**高和控件的宽高相同并使图片在控件中靠右下角显示
 * `fitStart`    保持图像的长宽比缩放图片, 使图片的宽**或**高和控件的宽高相同并使图片在控件靠左上角显示
-* `fitXY`    使图片和宽高和控件的宽高完全匹配，但图片的长宽比可能不能保持一致
-* `matrix`    绘制时使用图像矩阵进行缩放。需要在代码中使用`setImageMatrix(Matrix)`函数才能生效。
+* `fitXY`    使图片和宽高和控件的宽高完全匹配, 但图片的长宽比可能不能保持一致
+* `matrix`    绘制时使用图像矩阵进行缩放. 需要在代码中使用`setImageMatrix(Matrix)`函数才能生效.
 
-默认的scaleType为`fitCenter`；除此之外最常用的是`fitXY`， 他能使图片放缩到控件一样的大小，但图片可能会变形。
+默认的scaleType为`fitCenter`；除此之外最常用的是`fitXY`,  他能使图片放缩到控件一样的大小, 但图片可能会变形.
 
 ## radius
 
-图片控件的半径。如果设置为控件宽高的一半并且控件的宽高相同则图片将剪切为圆形显示；否则图片为圆角矩形显示，半径即为四个圆角的半径，也可以通过`radiusTopLeft`, `radiusTopRight`, `radiusBottomLeft`, `radiusBottomRight`等属性分别设置四个圆角的半径。
+图片控件的半径. 如果设置为控件宽高的一半并且控件的宽高相同则图片将剪切为圆形显示；否则图片为圆角矩形显示, 半径即为四个圆角的半径, 也可以通过`radiusTopLeft`, `radiusTopRight`, `radiusBottomLeft`, `radiusBottomRight`等属性分别设置四个圆角的半径.
 
-例如，圆角矩形的Auto.js图标：`<img w="100" h="100" radius="20" bg="white" src="http://www.autojs.org/assets/uploads/profile/3-profileavatar.png" />`
+例如, 圆角矩形的Auto.js图标：`<img w="100" h="100" radius="20" bg="white" src="http://www.autojs.org/assets/uploads/profile/3-profileavatar.png" />`
 
-有关该属性的单位，参见[尺寸的单位: Dimension](#ui_尺寸的单位_Dimension)。
+有关该属性的单位, 参见[尺寸的单位: Dimension](#ui_尺寸的单位_Dimension).
 
 ## radiusTopLeft
 
-图片控件的左上角圆角的半径。有关该属性的单位，参见[尺寸的单位: Dimension](#ui_尺寸的单位_Dimension)。
+图片控件的左上角圆角的半径. 有关该属性的单位, 参见[尺寸的单位: Dimension](#ui_尺寸的单位_Dimension).
 
 ## radiusTopRight
 
-图片控件的右上角圆角的半径。有关该属性的单位，参见[尺寸的单位: Dimension](#ui_尺寸的单位_Dimension)。
+图片控件的右上角圆角的半径. 有关该属性的单位, 参见[尺寸的单位: Dimension](#ui_尺寸的单位_Dimension).
 
 ## radiusBottomLeft
 
-图片控件的左下角圆角的半径。有关该属性的单位，参见[尺寸的单位: Dimension](#ui_尺寸的单位_Dimension)。
+图片控件的左下角圆角的半径. 有关该属性的单位, 参见[尺寸的单位: Dimension](#ui_尺寸的单位_Dimension).
 
 ## radiusBottomRight
 
-图片控件的右下角圆角的半径。有关该属性的单位，参见[尺寸的单位: Dimension](#ui_尺寸的单位_Dimension)。
+图片控件的右下角圆角的半径. 有关该属性的单位, 参见[尺寸的单位: Dimension](#ui_尺寸的单位_Dimension).
 
 ## borderWidth
 
-图片控件的边框宽度。用于在图片外面显示一个边框，边框会随着图片控件的外形(圆角等)改变而相应变化。
+图片控件的边框宽度. 用于在图片外面显示一个边框, 边框会随着图片控件的外形(圆角等)改变而相应变化.
 例如, 圆角矩形带灰色边框的Auto.js图标：`<img w="100" h="100" radius="20" borderWidth="5" borderColor="gray" bg="white" src="http://www.autojs.org/assets/uploads/profile/3-profileavatar.png" />`
 
 ## borderColor
 
-图片控件的边框颜色。
+图片控件的边框颜色.
 
 ## circle
 
-指定该图片控件的图片是否剪切为圆形显示。如果为`true`，则图片控件会使其宽高保持一致(如果宽高不一致，则保持高度等于宽度)并使圆形的半径为宽度的一半。
+指定该图片控件的图片是否剪切为圆形显示. 如果为`true`, 则图片控件会使其宽高保持一致(如果宽高不一致, 则保持高度等于宽度)并使圆形的半径为宽度的一半.
 
-例如，圆形的Auto.js图标：`<img w="100" h="100" circle="true" bg="white" src="http://www.autojs.org/assets/uploads/profile/3-profileavatar.png" />`
+例如, 圆形的Auto.js图标：`<img w="100" h="100" circle="true" bg="white" src="http://www.autojs.org/assets/uploads/profile/3-profileavatar.png" />`
 
 # 垂直布局: vertical
 
-垂直布局是一种比较简单的布局，会把在它里面的控件按照垂直方向依次摆放，如下图所示：
+垂直布局是一种比较简单的布局, 会把在它里面的控件按照垂直方向依次摆放, 如下图所示：
 
 垂直布局:
 
@@ -768,7 +775,7 @@ ui.layout(
 
 ## layout_weight
 
-垂直布局中的控件可以通过`layout_weight`属性来控制控件高度占垂直布局高度的比例。如果为一个控件指定`layout_weight`, 则这个控件的高度=垂直布局剩余高度 * layout_weight / weightSum；如果不指定weightSum, 则weightSum为所有子控件的layout_weight之和。所谓"剩余高度"，指的是垂直布局中减去没有指定layout_weight的控件的剩余高度。
+垂直布局中的控件可以通过`layout_weight`属性来控制控件高度占垂直布局高度的比例. 如果为一个控件指定`layout_weight`, 则这个控件的高度=垂直布局剩余高度 * layout_weight / weightSum；如果不指定weightSum, 则weightSum为所有子控件的layout_weight之和. 所谓"剩余高度", 指的是垂直布局中减去没有指定layout_weight的控件的剩余高度.
 例如:
 
 ```
@@ -782,7 +789,7 @@ ui.layout(
 );
 ```
 
-在这个布局中，三个控件的layout_weight都是1，也就是他们的高度都会占垂直布局高度的1/3，都是33.3dp.
+在这个布局中, 三个控件的layout_weight都是1, 也就是他们的高度都会占垂直布局高度的1/3, 都是33.3dp.
 再例如：
 
 ```
@@ -796,7 +803,7 @@ ui.layout(
 );
 ```
 
-在这个布局中，第一个控件高度为1/4, 第二个控件为2/4, 第三个控件为1/4.
+在这个布局中, 第一个控件高度为1/4, 第二个控件为2/4, 第三个控件为1/4.
 再例如：
 
 ```
@@ -810,7 +817,7 @@ ui.layout(
 );
 ```
 
-在这个布局中，因为指定了weightSum为5, 因此第一个控件高度为1/5, 第二个控件为2/5, 第三个控件为1/5.
+在这个布局中, 因为指定了weightSum为5, 因此第一个控件高度为1/5, 第二个控件为2/5, 第三个控件为1/5.
 再例如：
 
 ```
@@ -824,9 +831,9 @@ ui.layout(
 );
 ```
 
-在这个布局中，第一个控件并没有指定layout_weight, 而是指定高度为40dp, 因此不加入比例计算，此时布局剩余高度为60dp。第二个控件高度为剩余高度的2/3，也就是40dp，第三个控件高度为剩余高度的1/3，也就是20dp。
+在这个布局中, 第一个控件并没有指定layout_weight, 而是指定高度为40dp, 因此不加入比例计算, 此时布局剩余高度为60dp. 第二个控件高度为剩余高度的2/3, 也就是40dp, 第三个控件高度为剩余高度的1/3, 也就是20dp.
 
-垂直布局的layout_weight属性还可以用于控制他的子控件高度占满剩余空间，例如：
+垂直布局的layout_weight属性还可以用于控制他的子控件高度占满剩余空间, 例如：
 
 ```
 "ui";
@@ -839,11 +846,11 @@ ui.layout(
 );
 ```
 
-在这个布局中，第三个控件的高度会占满除去控件1和控件2的剩余空间。
+在这个布局中, 第三个控件的高度会占满除去控件1和控件2的剩余空间.
 
 # 水平布局: horizontal
 
-水平布局是一种比较简单的布局，会把在它里面的控件按照水平方向依次摆放，如下图所示：
+水平布局是一种比较简单的布局, 会把在它里面的控件按照水平方向依次摆放, 如下图所示：
 水平布局:
 ————————————————————————————
 
@@ -853,15 +860,15 @@ ui.layout(
 
 ## layout_weight
 
-水平布局中也可以使用layout_weight属性来控制子控件的**宽度**占父布局的比例。和垂直布局中类似，不再赘述。
+水平布局中也可以使用layout_weight属性来控制子控件的**宽度**占父布局的比例. 和垂直布局中类似, 不再赘述.
 
 # 线性布局: linear
 
-实际上，垂直布局和水平布局都属于线性布局。线性布局有一个orientation的属性，用于指定布局的方向，可选的值为`vertical`和`horizontal`。
+实际上, 垂直布局和水平布局都属于线性布局. 线性布局有一个orientation的属性, 用于指定布局的方向, 可选的值为`vertical`和`horizontal`.
 
-例如`<linear orientation="vertical"></linear>`相当于`<vertical></vertical>`。
+例如`<linear orientation="vertical"></linear>`相当于`<vertical></vertical>`.
 
-线性布局的默认方向是横向的，因此，一个没有指定orientation属性的线性布局就是横向布局。
+线性布局的默认方向是横向的, 因此, 一个没有指定orientation属性的线性布局就是横向布局.
 
 # 帧布局: frame
 
@@ -877,18 +884,18 @@ ui.layout(
 
 # 开关控件: Switch
 
-开关控件用于表示一个选项是否被选中。
+开关控件用于表示一个选项是否被选中.
 
 ## checked
 
-表示开关是否被选中。可选的值为：
+表示开关是否被选中. 可选的值为：
 
 * `true` 打开开关
 * `false` 关闭开关
 
 ## text
 
-对开关进行描述的文字。
+对开关进行描述的文字.
 
 # 进度条控件: progressbar
 
@@ -906,23 +913,23 @@ ui.layout(
 
 # 卡片: card
 
-卡片控件是一个拥有圆角、阴影的控件。
+卡片控件是一个拥有圆角、阴影的控件.
 
 ## cardBackgroundColor
 
-卡片的背景颜色。
+卡片的背景颜色.
 
 ## cardCornerRadius
 
-卡片的圆角半径。
+卡片的圆角半径.
 
 ## cardElevation
 
-设置卡片在z轴上的高度，来控制阴影的大小。
+设置卡片在z轴上的高度, 来控制阴影的大小.
 
 ## contentPadding
 
-设置卡片的内边距。该属性包括四个值：
+设置卡片的内边距. 该属性包括四个值：
 
 * `contentPaddingLeft` 左内边距
 * `contentPaddingRight` 右内边距
@@ -931,7 +938,7 @@ ui.layout(
 
 ## foreground
 
-使用`foreground="?selectableItemBackground"`属性可以为卡片添加点击效果。
+使用`foreground="?selectableItemBackground"`属性可以为卡片添加点击效果.
 
 # 抽屉布局: drawer
 
@@ -945,24 +952,24 @@ ui.layout(
 
 * `xml` {XML} | {string} 布局XML或者XML字符串
 
-将布局XML渲染为视图（View）对象， 并设置为当前视图。
+将布局XML渲染为视图（View）对象,  并设置为当前视图.
 
 ## ui.layoutFile(xmlFile)
 
 * `xml` {string} 布局XML文件的路径
 
-此函数和`ui.layout`相似，只不过允许传入一个xml文件路径来渲染布局。
+此函数和`ui.layout`相似, 只不过允许传入一个xml文件路径来渲染布局.
 
 ## ui.inflate(xml[, parent = null, attachToParent = false])
 
 * `xml` {string} | {XML} 布局XML或者XML字符串
 * `parent` {View} 父视图
-* `attachToParent` {boolean} 是否渲染的View加到父视图中，默认为false
+* `attachToParent` {boolean} 是否渲染的View加到父视图中, 默认为false
 * 返回 {View}
 
-将布局XML渲染为视图（View）对象。如果该View将作为某个View的子View，我们建议传入`parent`参数，这样在渲染时依赖于父视图的一些布局属性能够正确应用。
+将布局XML渲染为视图（View）对象. 如果该View将作为某个View的子View, 我们建议传入`parent`参数, 这样在渲染时依赖于父视图的一些布局属性能够正确应用.
 
-此函数用于动态创建、显示View。
+此函数用于动态创建、显示View.
 
 ```javascript
 "ui";
@@ -972,8 +979,8 @@ $ui.layout(
     </linear>
 );
 
-// 动态创建3个文本控件，并加到container容器中
-// 这里仅为实例，实际上并不推荐这种做法，如果要展示列表，
+// 动态创建3个文本控件, 并加到container容器中
+// 这里仅为实例, 实际上并不推荐这种做法, 如果要展示列表, 
 // 使用list组件；动态创建十几个、几十个View会让界面卡顿
 for (let i = 0; i < 3; i++) {
     let textView = $ui.inflate(
@@ -989,13 +996,13 @@ for (let i = 0; i < 3; i++) {
 * `name` {string} 组件名称
 * `widget` {Function} 组件
 
-注册一个自定义组件。参考示例->界面控件->自定义控件。
+注册一个自定义组件. 参考示例->界面控件->自定义控件.
 
 # ui.isUiThread()
 
 * 返回 {boolean}
 
-返回当前线程是否是UI线程。
+返回当前线程是否是UI线程.
 
 ```javascript
 "ui";
@@ -1013,28 +1020,28 @@ $threads.start(function () {
 * `id` {string} View的ID
 * 返回 {View}
 
-在当前视图中根据ID查找相应的视图对象并返回。如果当前未设置视图或找不到此ID的视图时返回`null`。
+在当前视图中根据ID查找相应的视图对象并返回. 如果当前未设置视图或找不到此ID的视图时返回`null`.
 
-一般我们都是通过`ui.xxx`来获取id为xxx的控件，如果xxx是一个ui已经有的属性，就可以通过`$ui.findView()`来获取这个控件。
+一般我们都是通过`ui.xxx`来获取id为xxx的控件, 如果xxx是一个ui已经有的属性, 就可以通过`$ui.findView()`来获取这个控件.
 
 ## ui.finish()
 
-结束当前活动并销毁界面。
+结束当前活动并销毁界面.
 
 ## ui.setContentView(view)
 
 * `view` {View}
 
-将视图对象设置为当前视图。
+将视图对象设置为当前视图.
 
 ## ui.post(callback[, delay = 0])
 
 * `callback` {Function} 回调函数
-* `delay` {number} 延迟，单位毫秒
+* `delay` {number} 延迟, 单位毫秒
 
-将`callback`加到UI线程的消息循环中，并延迟delay毫秒后执行（不能准确保证一定在delay毫秒后执行）。
+将`callback`加到UI线程的消息循环中, 并延迟delay毫秒后执行（不能准确保证一定在delay毫秒后执行）.
 
-此函数可以用于UI线程中延时执行动作（sleep不能在UI线程中使用），也可以用于子线程中更新UI。
+此函数可以用于UI线程中延时执行动作（sleep不能在UI线程中使用）, 也可以用于子线程中更新UI.
 
 ```javascript
 "ui";
@@ -1052,7 +1059,7 @@ threads.start({
     for (let i = 0; i < 1000000; i++) {
         sum += i;
     }
-    // 由于不能在子线程操作UI，所以要抛到UI线程执行
+    // 由于不能在子线程操作UI, 所以要抛到UI线程执行
     ui.post(() => {
         ui.result.attr("text", String(sum));
     });
@@ -1064,13 +1071,13 @@ threads.start({
 * `callback` {Function} 回调函数
 * 返回 callback的执行结果
 
-将`callback`在UI线程中执行。如果当前已经在UI线程中，则直接执行`callback`；否则将`callback`抛到UI线程中执行（加到UI线程的消息循环的末尾），**并等待callback执行结束(阻塞当前线程)**。
+将`callback`在UI线程中执行. 如果当前已经在UI线程中, 则直接执行`callback`；否则将`callback`抛到UI线程中执行（加到UI线程的消息循环的末尾）, **并等待callback执行结束(阻塞当前线程)**.
 
 ## ui.statusBarColor(color)
 
 * color {string} | {number} 颜色
 
-设置当前界面的状态栏颜色。
+设置当前界面的状态栏颜色.
 
 ```javascript
 "ui";
@@ -1079,7 +1086,7 @@ ui.statusBarColor("#000000");
 
 ## ui.useAndroidResources()
 
-启用使用Android的布局(layout)、绘图(drawable)、动画(anim)、样式(style)等资源的特性。启用该特性后，在project.json中进行以下配置，就可以像写Android原生一样写界面：
+启用使用Android的布局(layout)、绘图(drawable)、动画(anim)、样式(style)等资源的特性. 启用该特性后, 在project.json中进行以下配置, 就可以像写Android原生一样写界面：
 
 ```json
 {
@@ -1102,7 +1109,7 @@ res文件夹通常为以下结构：
     // ...
 ```
 
-可参考示例->复杂界面->Android原生界面。
+可参考示例->复杂界面->Android原生界面.
 
 # 尺寸的单位: Dimension
 
diff --git a/api/uiObjectActionsType.md b/api/uiObjectActionsType.md
new file mode 100644
index 0000000..f96738b
--- /dev/null
+++ b/api/uiObjectActionsType.md
@@ -0,0 +1,1246 @@
+# 控件节点行为 (UiObjectActions)
+
+UiObjectActions 是一个 Java 接口, 代表 [控件节点 (UiObject)](uiObjectType) 的行为集合.
+
+该接口有一个抽象方法 [performAction](#m-performaction) 是执行具体的控件节点行为的核心.  
+诸如 [ click / copy / paste ] 等方法均是对 performAction 的封装, 因此用户也可利用 performAction 实现自定义控件节点行为的封装.
+
+下表列出了部分行为 ID 名称, 及对应已实现封装的方法名称 (星号表示 AutoJs6 新增方法):
+
+| 行为 ID                                   | 封装方法名                           | 最低 API 等级          |
+|:----------------------------------------|:--------------------------------|--------------------|
+| ACTION_ACCESSIBILITY_FOCUS              | accessibilityFocus              | -                  |
+| ACTION_CLEAR_ACCESSIBILITY_FOCUS        | clearAccessibilityFocus         | -                  |
+| ACTION_CLEAR_FOCUS                      | clearFocus                      | -                  |
+| ACTION_CLEAR_SELECTION                  | clearSelection *                | -                  |
+| ACTION_CLICK                            | click                           | -                  |
+| ACTION_COLLAPSE                         | collapse                        | -                  |
+| ACTION_CONTEXT_CLICK                    | contextClick                    | -                  |
+| ACTION_COPY                             | copy                            | -                  |
+| ACTION_CUT                              | cut                             | -                  |
+| ACTION_DISMISS                          | dismiss                         | -                  |
+| ACTION_DRAG_CANCEL                      | dragCancel *                    | 32 (12.1) [S_V2]   |
+| ACTION_DRAG_DROP                        | dragDrop *                      | 32 (12.1) [S_V2]   |
+| ACTION_DRAG_START                       | dragStart *                     | 32 (12.1) [S_V2]   |
+| ACTION_EXPAND                           | expand                          | -                  |
+| ACTION_FOCUS                            | focus                           | -                  |
+| ACTION_HIDE_TOOLTIP                     | hideTooltip *                   | 28 (9) [P]         |
+| ACTION_IME_ENTER                        | imeEnter *                      | 30 (11) [R]        |
+| ACTION_LONG_CLICK                       | longClick                       | -                  |
+| ACTION_MOVE_WINDOW                      | moveWindow *                    | 26 (8) [O]         |
+| ACTION_NEXT_AT_MOVEMENT_GRANULARITY     | nextAtMovementGranularity *     | -                  |
+| ACTION_NEXT_HTML_ELEMENT                | nextHtmlElement *               | -                  |
+| ACTION_PAGE_DOWN                        | pageDown *                      | 29 (10) [Q]        |
+| ACTION_PAGE_LEFT                        | pageLeft *                      | 29 (10) [Q]        |
+| ACTION_PAGE_RIGHT                       | pageRight *                     | 29 (10) [Q]        |
+| ACTION_PAGE_UP                          | pageUp *                        | 29 (10) [Q]        |
+| ACTION_PASTE                            | paste                           | -                  |
+| ACTION_PRESS_AND_HOLD                   | pressAndHold *                  | 30 (11) [R]        |
+| ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY | previousAtMovementGranularity * | -                  |
+| ACTION_PREVIOUS_HTML_ELEMENT            | previousHtmlElement *           | -                  |
+| ACTION_SCROLL_BACKWARD                  | scrollBackward                  | -                  |
+| ACTION_SCROLL_DOWN                      | scrollDown                      | -                  |
+| ACTION_SCROLL_FORWARD                   | scrollForward                   | -                  |
+| ACTION_SCROLL_LEFT                      | scrollLeft                      | -                  |
+| ACTION_SCROLL_RIGHT                     | scrollRight                     | -                  |
+| ACTION_SCROLL_TO_POSITION               | scrollTo                        | -                  |
+| ACTION_SCROLL_UP                        | scrollUp                        | -                  |
+| ACTION_SELECT                           | select                          | -                  |
+| ACTION_SET_PROGRESS                     | setProgress                     | -                  |
+| ACTION_SET_SELECTION                    | setSelection                    | -                  |
+| ACTION_SET_TEXT                         | setText                         | -                  |
+| ACTION_SHOW_ON_SCREEN                   | show                            | -                  |
+| ACTION_SHOW_TEXT_SUGGESTIONS            | showTextSuggestions *           | 33 (13) [TIRAMISU] |
+| ACTION_SHOW_TOOLTIP                     | showTooltip *                   | 28 (9) [P]         |
+
+若当前设备不满足列表中最低 API 等级要求, 使用对应方法时不会抛出异常, 会静默返回 false:
+
+```js
+/* 
+    例如 ACTION_IME_ENTER 要求设备运行条件不低于 Android API 30 (11) [R].
+    在 API < 30 的设备上一定返回 false 且 IME ENTER 无效果 (但不会抛出异常).
+ */
+console.log(pickup({
+    focusable: true,
+    contentMatch: '.+',
+}, 'imeEnter'));
+```
+
+上表中所有已封装的控件行为对应的方法 **名称** 均已全局化, 有关全局化方法的使用方式及方法的绑定源信息, 可参阅 [全局行为重定向](#全局行为重定向) 小节.
+
+> 参阅: [Android Docs](https://developer.android.com/reference/android/view/accessibility/AccessibilityNodeInfo.AccessibilityAction)
+
+---
+
+<p style="font: bold 2em sans-serif; color: #FF7043">UiObjectActions</p>
+
+---
+
+## [m!] performAction
+
+用于执行指定的控件行为.  
+是一个无默认实现的抽象方法.
+
+### performAction(action, ...arguments)
+
+**`A11Y`**
+
+- **action** { [number](dataTypes#number) } - 行为的唯一标志符 (Action ID)
+- **arguments** { [...](documentation#可变参数)[ActionArgument](#i-actionargument)[[]](documentation#可变参数) } - 行为参数, 用于给行为传递参数
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+实现此方法的类有:
+
+- [UiSelector](uiSelectorType)
+- [UiObject](uiObjectType)
+- [UiObjectCollection](uiObjectCollectionType)
+
+源代码摘要:
+
+- UiSelector
+
+```kotlin
+/* Updated as of Nov 2, 2022. */
+
+override fun performAction(action: Int, vararg arguments: ActionArgument): Boolean {
+    return untilFind().performAction(action, *arguments)
+}
+```
+
+- UiObject
+
+```kotlin
+/* Updated as of Nov 2, 2022. */
+
+override fun performAction(action: Int, vararg arguments: ActionArgument): Boolean {
+    return performAction(action, Bundle().apply { arguments.forEach { it.putIn(this) } })
+}
+
+override fun performAction(action: Int, bundle: Bundle): Boolean = try {
+    when (bundle.isEmpty) {
+        true -> super.performAction(action)
+        else -> super.performAction(action, bundle)
+    }
+} catch (e: IllegalStateException) {
+    false
+}
+```
+
+- UiObjectCollection
+
+```kotlin
+/* Updated as of Nov 2, 2022. */
+
+override fun performAction(action: Int, vararg arguments: ActionArgument): Boolean {
+    var success = true
+    nodes.filterNotNull().forEach { node ->
+        when (arguments.isEmpty()) {
+            true -> node.performAction(action)
+            else -> node.performAction(action, *arguments)
+        }.also { success = success and it }
+    }
+    return success
+}
+```
+
+由此可见, [UiSelector](uiSelectorType) 与 [UiObjectCollection](uiObjectCollectionType) 最终都调用了 [UiObject](uiObjectType) 的 `performAction` 方法, 而 `UiObject` 的 `performAction` 则调用了 Android 系统的 [AccessibilityNodeInfoCompat#performAction](https://developer.android.com/reference/androidx/core/view/accessibility/AccessibilityNodeInfoCompat#performAction(int,android.os.Bundle)) 方法
+
+`UiObjectCollection` 相当于对控件集合中的每一个控件执行 `UiObject#performAction` 方法.  
+`UiSelector` 相当于先执行 [untilFind](uiSelectorType#m-untilfind) 找到当前窗口中所有控件, 将其作为集合执行 `UiObjectCollection#performAction` 方法.
+
+因全局的 `untilFind()` 是 "无条件" 筛选, 会把窗口中所有控件 (往往会有几十甚至成百上千个控件) 全部加入集合中, 此时执行任何 `行为 (Action)`, 都相当于集合中所有控件执行一遍上述行为, 这样的操作往往是无意义的, 很可能造成非预期结果甚至不可控的操作, 因此不建议使用 `UiSelector` 提供的 `行为 (Action)` 方法.
+
+下面列举一个 `UiSelector` 提供的行为, 再次强调不建议使用:
+
+```js
+/* ACTION_SET_TEXT 行为 */
+
+/* 对当前窗口中所有支持设置文本的控件, 将内容设置为 "hello". */
+selector().setText("hello");
+
+/* UiSelector 几乎所有方法均已全局化, setText 位列其中. */
+setText("hello"); /* 效果同上. */
+```
+
+如有上述示例的需求 (对控件设置文本内容), 而且是针对多个控件同时设置, 建议使用选择器定位指定的控件集合, 再统一执行 `行为 (Action)`:
+
+```js
+/* 先筛选集合. */
+let nodes = pickup({
+    focusable: true,
+    textMatch: "name",
+    boundInside: [ cX(0.2), cYx(0.04), cX(0.8), cY(0.92) ],
+}, '[w]');
+
+/* 再执行行为. */
+nodes.forEach(w => w.setText("hello"));
+```
+
+如需对控件执行自定义行为, 可通过 `UiObject#performAction` 实现:
+
+```js
+/* 对控件执行 ACTION_IME_ENTER 行为. */
+
+let { AccessibilityActionCompat } = androidx.core.view.accessibility.AccessibilityNodeInfoCompat;
+
+let w = focusable().contentMatch(/name/).findOnce();
+w.performAction(AccessibilityActionCompat.ACTION_IME_ENTER.id);
+```
+
+有些 `行为 (Action)` 需要指定参数, 此时可借助 [ActionArgument](#i-actionargument) 接口传入参数:
+
+```js
+/* 对控件执行 ACTION_SET_TEXT 及 ACTION_SET_SELECTION 行为. */
+
+let { AccessibilityNodeInfoCompat } = androidx.core.view.accessibility
+let { AccessibilityActionCompat } = AccessibilityNodeInfoCompat;
+let { ActionArgument } = org.autojs.autojs.core.automator;
+
+let w = focusable().contentMatch(/name/).findOnce();
+
+/* ACTION_SET_TEXT 需要一个 ACTION_ARGUMENT_SET_TEXT_CHARSEQUENCE "行为参数". */
+w.performAction(
+    AccessibilityActionCompat.ACTION_SET_TEXT.id,
+    ActionArgument.CharSequenceActionArgument(AccessibilityNodeInfoCompat.ACTION_ARGUMENT_SET_TEXT_CHARSEQUENCE, "hello"),
+);
+
+/* ACTION_SET_SELECTION 需要两个 "行为参数", */
+/* ACTION_ARGUMENT_SELECTION_START_INT 及 ACTION_ARGUMENT_SELECTION_END_INT. */
+w.performAction(
+    AccessibilityActionCompat.ACTION_SET_SELECTION.id,
+    ActionArgument.IntActionArgument(AccessibilityNodeInfoCompat.ACTION_ARGUMENT_SELECTION_START_INT, 1),
+    ActionArgument.IntActionArgument(AccessibilityNodeInfoCompat.ACTION_ARGUMENT_SELECTION_END_INT, 4),
+);
+```
+
+`UiObject` 拥有另一个实例方法 [performAction(action, bundle)](uiObjectType#performactionaction-bundle), 因此上述示例也可改写为:
+
+```js
+let arguments = new android.os.Bundle();
+arguments.putInt(AccessibilityNodeInfoCompat.ACTION_ARGUMENT_SELECTION_START_INT, 1);
+arguments.putInt(AccessibilityNodeInfoCompat.ACTION_ARGUMENT_SELECTION_END_INT, 4);
+w.performAction(AccessibilityActionCompat.ACTION_SET_SELECTION.id, arguments);
+```
+
+如需判断控件是否有某个或某些 `Action`, 可使用 [UiObject#hasAction](uiObjectType#m-hasaction):
+
+```js
+console.log(w.hasAction("ACTION_CLICK"));
+console.log(w.hasAction("CLICK")); /* 前缀 "ACTION_" 可省略. */
+
+/* 检查是否同时拥有多个 Action. */
+console.log(w.hasAction("CLICK", "IME_ENTER", "SCROLL_UP"));
+```
+
+如需使用 `Action` 选择器筛选控件, 可使用 [UiSelector#action](uiSelectorType#m-action):
+
+```js
+console.log(action("ACTION_CLICK").findOnce());
+console.log(action("CLICK").findOnce()); /* 前缀 "ACTION_" 可省略. */
+
+/* 筛选多个 Action. */
+console.log(action("CLICK", "IME_ENTER", "SCROLL_UP").findOnce());
+```
+
+## [m=] click
+
+### click()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 点击 ] 行为.
+
+检查一个控件节点是否可点击:
+
+```js
+console.log(w.clickable());
+console.log(w.isClickable()); /* 同上. */
+```
+
+以下情况可能导致 `w.click()` 返回 `false`:
+
+- 控件不可点击 (`w.clickable()` 为 `false`)
+- 页面无法响应点击事件
+
+有时会出现虽然 `w` 不可点击但 `w.parent()` 或 `w.parent().parent()` 等父级控件可点击的情况:
+
+```js
+function tryClick(w) {
+    let max = 3;
+    let tmp = w;
+    while (max--) {
+        tmp = tmp.parent();
+        if (tmp.isClickable()) {
+            return tmp.click();
+        }
+    }
+    return false;
+}
+
+console.log(tryClick(w));
+
+/* 上述过程可使用 pickup 简化. */
+console.log(pickup(w, 'k3', 'click'));
+```
+
+使用控件的 `click` 方法主要优缺点 (相较于坐标模拟点击):
+
+- [优] 速度较快
+- [优] 适用于位置不断变化的控件
+- [优] 适用于不在窗口可视化范围内的控件
+- [优] 适用于上层被其他控件覆盖或遮挡的控件
+- [劣] 部分控件难以通过选择器精确定位
+- [劣] 部分控件执行 `click` 行为后无响应
+- [劣] 无法完全适应控件属性或层级关系改变的情况
+
+鉴于上述优劣项, 控件的 `click` 方法通常与 [ [global.click](global#m-click) ([automator.click](automator#m-click)) / [UiObject#clickByBounds](uiObjectType.md#m-clickbybounds) ] 等方法配合使用.
+
+## [m=] longClick
+
+### longClick()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 长按 ] 行为.
+
+检查一个控件节点是否可长按:
+
+```js
+console.log(w.longClickable());
+console.log(w.isLongClickable()); /* 同上. */
+```
+
+以下情况可能导致 `w.longClick()` 返回 `false`:
+
+- 控件不可长按 (`w.longClickable()` 为 `false`)
+- 页面无法响应长按事件
+
+## [m=] accessibilityFocus
+
+### accessibilityFocus()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 获取无障碍焦点 ] 行为.
+
+只有在当前设备启用了无障碍软件 (如 [TalkBack](https://support.google.com/accessibility/android/topic/10601570?hl=zh-Hans)) 才能正常使用 accessibilityFocus().
+
+以 TalkBack 为例, 启用后, 当前窗口中获取无障碍焦点的控件将被绿色方框标记其边界, 此时按下键盘回车键或无障碍设备 (如 [D-pad](https://en.wikipedia.org/wiki/D-pad)) 的确定键 (取决于不同设备), 即可激活此控件.
+
+```js
+/* 获得无障碍焦点. */
+console.log(pickup(idEndsWith('fab'), 'accessibilityFocus')); /* boolean 类型结果. */
+
+/* 检查是否已获得无障碍焦点. */
+console.log(pickup(idEndsWith('fab'), 'accessibilityFocused')); /* boolean 类型结果. */
+```
+
+如需清除焦点, 可使用 [clearAccessibilityFocus](#m-clearaccessibilityfocus) 方法.
+
+## [m=] clearAccessibilityFocus
+
+### clearAccessibilityFocus()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 清除无障碍焦点 ] 行为.
+
+只有在当前设备启用了无障碍软件 (如 [TalkBack](https://support.google.com/accessibility/android/topic/10601570?hl=zh-Hans)) 才能正常使用 clearAccessibilityFocus().
+
+```js
+/* 清除无障碍焦点. */
+console.log(pickup(idEndsWith('fab'), 'clearAccessibilityFocus')); /* boolean 类型结果. */
+```
+
+## [m=] focus
+
+### focus()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 获取焦点 ] 行为.
+
+在当前设备连接外置键盘等输入设备时, 按下 TAB 或 方向键可在控件之间 "切换", 这些控件都是 focusable (可被聚焦) 的.
+
+```js
+/* 查看控件是否可被聚焦. */
+console.log(w.focusable());
+console.log(w.isFocusable()); /* 同上. */
+```
+
+当控件被聚焦 (即获取焦点) 后, 可使用输入设备的 ENTER 或 OK 等表示确认的按键激活此控件.  
+如果此控件支持文本输入 (例如常见的 EditText 类型控件), 在被聚焦后, 将出现输入光标, 且可能会弹出软键盘用于用户输入内容.
+
+```js
+/* 打印当前窗口支持聚焦的控件文本内容数组. */
+console.log(pickup({ focusable: true }, 'txt[]'));
+
+/* 按文本内容筛选一个控件并使其获得焦点. */
+pickup([ { focusable: true }, /search/ ], 'focus');
+```
+
+如需清除焦点, 可使用 [clearFocus](#m-clearfocus) 方法.
+
+## [m=] clearFocus
+
+### clearFocus()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 清除焦点 ] 行为.
+
+对一个可被聚焦的控件, 如果它没有获得焦点, 调用 clearFocus 方法时将返回 false.
+
+```js
+/* w 可被聚焦, 但当前未获得焦点. */
+console.log(w.focusable()); // true
+console.log(w.isFocused()); // false
+
+/* isFocused 返回 false, 因此 clearFocus 也返回 false. */
+console.log(w.clearFocus()); // false
+```
+
+## [m=] dragStart
+
+### dragStart()
+
+**`6.2.0`** **`A11Y`** **`API>=32`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 拖放开始 ] 行为.
+
+此操作将初始化系统内部的拖放 (Drag & Drop) 功能.  
+支持拖放的内容将在拖放行为开始前完成准备.
+
+## [m=] dragDrop
+
+### dragDrop()
+
+**`6.2.0`** **`A11Y`** **`API>=32`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 拖放放下 ] 行为.
+
+此操作针对于已开始 ACTION_DRAG_START 行为的拖放目标.
+
+## [m=] dragCancel
+
+### dragCancel()
+
+**`6.2.0`** **`A11Y`** **`API>=32`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 拖放取消 ] 行为.
+
+此操作针对于已开始 ACTION_DRAG_START 行为的拖放目标.
+
+## [m=] imeEnter
+
+### imeEnter()
+
+**`6.2.0`** **`A11Y`** **`API>=30`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 输入法 ENTER 键 ] 行为.
+
+此操作通常只对获得焦点且可编辑的控件有效.
+
+通常 imeEnter 用来模拟回车键在文本控件实现换行功能.  
+另外也可以模拟某些表示确认的操作, 如 [ 搜索 / 发送 / 下一步 / 立即前往 / 开始执行 ] 等.
+
+```js
+/* 模拟回车键. */
+console.log(pickup({
+    className: 'EditText',
+    focused: true,
+}, 'imeEnter')); /* e.g. true */
+```
+
+## [m=] moveWindow
+
+### moveWindow(x, y)
+
+**`6.2.0`** **`A11Y`** **`API>=26`**
+
+- **x** { [number](dataTypes#number) } - X 坐标
+- **y** { [number](dataTypes#number) } - Y 坐标
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 移动窗口到新位置 ] 行为.
+
+## [m=] nextAtMovementGranularity
+
+### nextAtMovementGranularity(granularity, isExtendSelection)
+
+**`6.2.0`** **`A11Y`**
+
+- **granularity** { [number](dataTypes#number) } - 粒度
+- **isExtendSelection** { [boolean](dataTypes#boolean) } - 是否扩展选则文本
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 按粒度移至下一位置 ] 行为.
+
+按指定粒度移动光标到下一个文本实体位置, 例如移动到下一个单词, 下一行, 下一个段落等.
+
+```js
+const AccessibilityNodeInfo = android.view.accessibility.AccessibilityNodeInfo;
+
+let w = pickup([ /.+/, { className: 'EditText' } ]);
+
+/* 按 WORD (单词) 粒度移动. */
+/* 除 WORD 外, 还支持 CHARACTER (字符), LINE (行), PARAGRAPH (段落), PAGE (页) 等粒度. */
+w.nextAtMovementGranularity(AccessibilityNodeInfo.MOVEMENT_GRANULARITY_WORD, false);
+```
+
+## [m=] nextHtmlElement
+
+### nextHtmlElement(element)
+
+**`6.2.0`** **`A11Y`**
+
+- **element** { [string](dataTypes#string) } - 元素名称
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 按元素移至下一位置 ] 行为.
+
+按指定元素名称移动焦点至下一元素位置, 例如移动到下一个按钮, 下一个列表, 下一个输入框等.
+
+```js
+console.log(w.nextHtmlElement("BUTTON"));
+```
+
+## [m=] pageLeft
+
+### pageLeft()
+
+**`6.2.0`** **`A11Y`** **`API>=29`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 使视窗左移的翻页 ] 行为.
+
+此操作使视窗向左移动, 以便将可翻页控件左侧的更多内容 (如有) 展示在视窗内.  
+对于触屏设备, 此操作相当于按住屏幕并向右拖动视图.
+
+- 新可视化内容: 左.
+- 视窗移动方向: 左.
+- 视图移动方向: 右.
+
+## [m=] pageUp
+
+### pageUp()
+
+**`6.2.0`** **`A11Y`** **`API>=29`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 使视窗上移的翻页 ] 行为.
+
+此操作使视窗向上移动, 以便将可翻页控件上方的更多内容 (如有) 展示在视窗内.  
+对于触屏设备, 此操作相当于按住屏幕并向下拖动视图.
+
+- 新可视化内容: 上.
+- 视窗移动方向: 上.
+- 视图移动方向: 下.
+
+## [m=] pageRight
+
+### pageRight()
+
+**`6.2.0`** **`A11Y`** **`API>=29`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 使视窗右移的翻页 ] 行为.
+
+此操作使视窗向右移动, 以便将可翻页控件右侧的更多内容 (如有) 展示在视窗内.  
+对于触屏设备, 此操作相当于按住屏幕并向左拖动视图.
+
+- 新可视化内容: 右.
+- 视窗移动方向: 右.
+- 视图移动方向: 左.
+
+## [m=] pageDown
+
+### pageDown()
+
+**`6.2.0`** **`A11Y`** **`API>=29`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 使视窗下移的翻页 ] 行为.
+
+此操作使视窗向下移动, 以便将可翻页控件下方的更多内容 (如有) 展示在视窗内.  
+对于触屏设备, 此操作相当于按住屏幕并向上拖动视图.
+
+- 新可视化内容: 下.
+- 视窗移动方向: 下.
+- 视图移动方向: 上.
+
+## [m=] pressAndHold
+
+### pressAndHold()
+
+**`6.2.0`** **`A11Y`** **`API>=30`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 按住 ] 行为.
+
+按住即按下并保持, 与 ACTION_LONG_CLICK (长按) 不同.  
+如果控件的单一行为响应是为 "长按" 设计的, 则应该使用封装的 longClick 方法, 而非 pressAndHold 方法.  
+只有控件存在对 "按住" 行为的响应, 才会使 pressAndHold 有效.  
+通常控件不会同时存在上述两种行为的响应.
+
+## [m=] previousAtMovementGranularity
+
+### previousAtMovementGranularity(granularity, isExtendSelection)
+
+**`6.2.0`** **`A11Y`**
+
+- **granularity** { [number](dataTypes#number) } - 粒度
+- **isExtendSelection** { [boolean](dataTypes#boolean) } - 是否扩展选则文本
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 按粒度移至上一位置 ] 行为.
+
+按指定粒度移动光标到上一个文本实体位置, 例如移动到上一个单词, 上一行, 上一个段落等.
+
+```js
+const AccessibilityNodeInfo = android.view.accessibility.AccessibilityNodeInfo;
+
+let w = pickup([ /.+/, { className: 'EditText' } ]);
+
+/* 按 WORD (单词) 粒度移动. */
+/* 除 WORD 外, 还支持 CHARACTER (字符), LINE (行), PARAGRAPH (段落), PAGE (页) 等粒度. */
+w.previousAtMovementGranularity(AccessibilityNodeInfo.MOVEMENT_GRANULARITY_WORD, false);
+```
+
+## [m=] previousHtmlElement
+
+### previousHtmlElement(element)
+
+**`6.2.0`** **`A11Y`**
+
+- **element** { [string](dataTypes#string) } - 元素名称
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 按元素移至上一位置 ] 行为.
+
+按指定元素名称移动焦点至上一元素位置, 例如移动到上一个按钮, 上一个列表, 上一个输入框等.
+
+```js
+console.log(w.previousHtmlElement("BUTTON"));
+```
+
+## [m=] showTextSuggestions
+
+### showTextSuggestions()
+
+**`6.2.0`** **`A11Y`** **`API>=33`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 显示文本建议 ] 行为.
+
+此操作将为一个可编辑文本的控件显示相关输入建议.
+
+## [m=] showTooltip
+
+### showTooltip()
+
+**`6.2.0`** **`A11Y`** **`API>=28`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 显示工具提示信息 ] 行为.
+
+此操作通常只对其视图未在显示工具提示信息的控件有效.
+
+## [m=] hideTooltip
+
+### hideTooltip()
+
+**`6.2.0`** **`A11Y`** **`API>=28`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 隐藏工具提示信息 ] 行为.
+
+此操作通常只对其视图正在显示工具提示信息的控件有效.
+
+## [m=] show
+
+### show()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 显示在视窗内 ] 行为.
+
+此操作使控件的所有边界全部出现在视窗内部.  
+如有需要, 页面会发生滚动.
+
+```js
+/* "关于应用与开发者" 按钮部分 (或全部) 位于视窗外部. */
+let w = pickup("关于应用与开发者");
+
+if (w !== null) {
+    /* 控件将随着页面滚动到视窗内部. */
+    w.show();
+}
+```
+
+> 参阅 [View.requestRectangleOnScreen(Rect)](https://developer.android.com/reference/android/view/View#requestRectangleOnScreen(android.graphics.Rect))
+
+## [m=] dismiss
+
+### dismiss()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 消隐 ] 行为.
+
+检查一个控件节点是否可消隐:
+
+```js
+console.log(w.dismissable());
+console.log(w.isDismissable()); /* 同上. */
+```
+
+## [m=] copy
+
+### copy()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 复制文本 ] 行为.
+
+此操作将控件的已选中文本内容复制到剪贴板.
+
+## [m=] cut
+
+### cut()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 剪切文本 ] 行为.
+
+此操作将控件的已选中文本内容剪切并置于剪贴板.
+
+## [m=] paste
+
+### paste()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 粘贴文本 ] 行为.
+
+此操作将剪贴板的文本内容粘贴到控件的可编辑文本区域.
+
+需额外留意, 自 [Android API 29 (10) [Q]](apiLevel) 起, 剪贴板数据的访问将受到限制.  
+详情参阅 [getClip](global#m-getclip).
+
+## [m=] select
+
+### select()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 选中 ] 行为.
+
+此操作将选中当前控件.
+
+检查一个控件节点是否已被选中:
+
+```js
+console.log(w.selected());
+console.log(w.isSelected()); /* 同上. */
+```
+
+## [m=] expand
+
+### expand()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 展开 ] 行为.
+
+此操作用于展开可展开的控件.
+
+## [m=] collapse
+
+### collapse()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 折叠 ] 行为.
+
+此操作用于折叠 (或收起) 可展开的控件.
+
+## [m=] scrollLeft
+
+### scrollLeft()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 使视窗左移的滚动 ] 行为.
+
+此操作使视窗向左移动, 以便将可滚动控件左侧的更多内容 (如有) 展示在视窗内.  
+对于触屏设备, 此操作相当于按住屏幕并向右拖动视图.
+
+- 新可视化内容: 左.
+- 视窗移动方向: 左.
+- 视图移动方向: 右.
+
+## [m=] scrollUp
+
+### scrollUp()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 使视窗上移的滚动 ] 行为.
+
+此操作使视窗向上移动, 以便将可滚动控件上方的更多内容 (如有) 展示在视窗内.  
+对于触屏设备, 此操作相当于按住屏幕并向下拖动视图.
+
+- 新可视化内容: 上.
+- 视窗移动方向: 上.
+- 视图移动方向: 下.
+
+## [m=] scrollRight
+
+### scrollRight()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 使视窗右移的滚动 ] 行为.
+
+此操作使视窗向右移动, 以便将可滚动控件右侧的更多内容 (如有) 展示在视窗内.  
+对于触屏设备, 此操作相当于按住屏幕并向左拖动视图.
+
+- 新可视化内容: 右.
+- 视窗移动方向: 右.
+- 视图移动方向: 左.
+
+## [m=] scrollDown
+
+### scrollDown()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 使视窗下移的滚动 ] 行为.
+
+此操作使视窗向下移动, 以便将可滚动控件下方的更多内容 (如有) 展示在视窗内.  
+对于触屏设备, 此操作相当于按住屏幕并向上拖动视图.
+
+- 新可视化内容: 下.
+- 视窗移动方向: 下.
+- 视图移动方向: 上.
+
+## [m=] scrollForward
+
+### scrollForward()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 使视窗前移的滚动 ] 行为.
+
+此操作使视窗向前移动, 以便将可滚动控件前方的更多内容 (如有) 展示在视窗内.  
+对于触屏设备, 此操作相当于按住屏幕并向后拖动视图.
+
+- 新可视化内容: 前.
+- 视窗移动方向: 前.
+- 视图移动方向: 后.
+
+> 注: "前" 包括 "左" 或 "上", "后" 包括 "右" 或 "下".
+
+## [m=] scrollBackward
+
+### scrollBackward()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 使视窗后移的滚动 ] 行为.
+
+此操作使视窗向后移动, 以便将可滚动控件后方的更多内容 (如有) 展示在视窗内.  
+对于触屏设备, 此操作相当于按住屏幕并向前拖动视图.
+
+- 新可视化内容: 后.
+- 视窗移动方向: 后.
+- 视图移动方向: 前.
+
+> 注: "前" 包括 "左" 或 "上", "后" 包括 "右" 或 "下".
+
+## [m=] scrollTo
+
+### scrollTo(row, column)
+
+**`A11Y`**
+
+- **row** { [number](dataTypes#number) } - 行序数
+- **column** { [number](dataTypes#number) } - 列序数
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 将指定位置滚动至视窗内 ] 行为.
+
+此操作将集合中指定位置 (以 "行" 和 "列" 标记) 滚动至视窗内.
+
+```js
+scrollable().find().some((w) => {
+    let info = w.getCollectionInfo();
+    if (info !== null) {
+        console.log(info.getRowCount()); /* e.g. 17 */
+        console.log(info.getColumnCount()); /* e.g. 2 */
+        
+        let randRow = Mathx.randInt(info.getRowCount() - 1);
+        let randColumn = Mathx.randInt(info.getColumnCount() - 1);
+        console.log(`${randRow},${randColumn}`); /* e.g. 10,1 */
+        
+        console.log(w.scrollTo(randRow, randColumn)); /* e.g. false */
+        
+        return /* @some */ true;
+    }
+});
+```
+
+## [m=] contextClick
+
+### contextClick()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 上下文点击 ] 行为.
+
+此操作通常会弹出一个上下文菜单, 类似鼠标右键菜单.
+
+> 注: 在 Microsoft Windows 操作系统中, 单击鼠标右键 (或按下键盘的菜单键) 即类似控件的 Context Click (上下文点击) 行为, 弹出的右键菜单又称为 Context Menu (上下文菜单).
+
+## [m=] setText
+
+### setText(text)
+
+**`A11Y`**
+
+- **text** { [string](dataTypes#string) } - 文本
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 设置文本 ] 行为.
+
+此操作将使用新文本替换原有文本, 并将光标置于文本末尾.
+
+```js
+let w = pickup({ className: 'EditText' });
+
+/* 设置文本为 "hello". */
+w.setText("hello");
+
+/* 清空文本. */
+w.setText("");
+```
+
+## [m=] setSelection
+
+### setSelection(start, end)
+
+**`A11Y`**
+
+- **start** { [number](dataTypes#number) } - 开始位置
+- **end** { [number](dataTypes#number) } - 结束位置
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 选择文本 ] 行为.
+
+此操作将按指定范围选中控件的文本内容.
+
+```js
+let w = pickup({ className: 'EditText' });
+
+/* 选中 2 - 3 的 1 个文本, 起始光标停留在 2 位置, 末尾光标停留在 3 位置. */
+w.setSelection(2, 3);
+
+/* 无任何效果, 光标不发生变化. */
+w.setSelection(2, 0);
+w.setSelection(2, -5);
+
+/* 抛出异常. */
+w.setSelection(NaN, 0);
+w.setSelection(Infinity, 0);
+
+/* 选中 0 个文本, 此时起始和末尾两个光标重合. */
+w.setSelection(2, 2);
+```
+
+## [m=] clearSelection
+
+### clearSelection()
+
+**`6.2.0`** **`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 取消选择文本 ] 行为.
+
+## [m=] setProgress
+
+### setProgress(progress)
+
+**`A11Y`**
+
+- **progress** { [number](dataTypes#number) } - 进度值
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [ 设置进度值 ] 行为.
+
+```js
+pickup({ action: ['SET_PROGRESS'] }, '[]').some((w) => {
+    const info = w.getRangeInfo();
+    if (info !== null) {
+        console.log(w.getMin(), w.getMax());
+        let randProgress = Mathx.randInt(w.getMin(), w.getMax());
+        console.log(randProgress);
+        console.log(w.setProgress(randProgress));
+    }
+});
+```
+
+## [I] ActionArgument
+
+控件的行为参数接口.  
+主要用于自定义控件行为的 [performAction](#m-performaction) 抽象方法内.
+
+### [C] IntActionArgument
+
+ActionArgument 的具体类.  
+用于传递 Int 类型的行为参数.
+
+#### [c] (name, value)
+
+- **name** { [string](dataTypes#string) } - 行为名称
+- **value** { [number](dataTypes#number) } - 行为参数值
+- <ins>**returns**</ins> { [ActionArgument](#i-actionargument) }
+
+构造一个 Int 类型的行为参数.
+
+```js
+/* 模拟 scrollTo 封装方法. */
+function scrollTo(x, y) {
+    return w.performAction(
+        AccessibilityActionCompat.ACTION_SCROLL_TO_POSITION.id,
+        ActionArgument.IntActionArgument(AccessibilityNodeInfoCompat.ACTION_ARGUMENT_ROW_INT, x),
+        ActionArgument.IntActionArgument(AccessibilityNodeInfoCompat.ACTION_ARGUMENT_COLUMN_INT, y),
+    );
+}
+```
+
+### [C] BooleanActionArgument
+
+ActionArgument 的具体类.  
+用于传递 Boolean 类型的行为参数.
+
+#### [c] (name, value)
+
+- **name** { [string](dataTypes#string) } - 行为名称
+- **value** { [boolean](dataTypes#boolean) } - 行为参数值
+- <ins>**returns**</ins> { [ActionArgument](#i-actionargument) }
+
+构造一个 Boolean 类型的行为参数.
+
+```js
+/* 模拟 nextAtMovementGranularity 封装方法. */
+function nextAtMovementGranularity(granularity, isExtendSelection) {
+    return w.performAction(
+        AccessibilityActionCompat.ACTION_NEXT_AT_MOVEMENT_GRANULARITY.id,
+        ActionArgument.IntActionArgument(AccessibilityNodeInfoCompat.ACTION_ARGUMENT_MOVEMENT_GRANULARITY_INT, granularity),
+        ActionArgument.BooleanActionArgument(AccessibilityNodeInfoCompat.ACTION_ARGUMENT_EXTEND_SELECTION_BOOLEAN, isExtendSelection),
+    );
+}
+```
+
+### [C] CharSequenceActionArgument
+
+ActionArgument 的具体类.  
+用于传递 CharSequence 类型的行为参数.
+
+#### [c] (name, value)
+
+- **name** { [string](dataTypes#string) } - 行为名称
+- **value** { [string](dataTypes#string) } - 行为参数值
+- <ins>**returns**</ins> { [ActionArgument](#i-actionargument) }
+
+构造一个 CharSequence 类型的行为参数.
+
+```js
+/* 模拟 setText 封装方法. */
+function setText(text) {
+    return w.performAction(
+        AccessibilityActionCompat.ACTION_SET_TEXT.id,
+        ActionArgument.IntActionArgument(AccessibilityNodeInfoCompat.ACTION_ARGUMENT_SET_TEXT_CHARSEQUENCE, text),
+    );
+}
+```
+
+### [C] StringActionArgument
+
+ActionArgument 的具体类.  
+用于传递 String 类型的行为参数.
+
+#### [c] (name, value)
+
+- **name** { [string](dataTypes#string) } - 行为名称
+- **value** { [string](dataTypes#string) } - 行为参数值
+- <ins>**returns**</ins> { [ActionArgument](#i-actionargument) }
+
+构造一个 String 类型的行为参数.
+
+```js
+/* 模拟 nextHtmlElement 封装方法. */
+function nextHtmlElement(element) {
+    return w.performAction(
+        AccessibilityActionCompat.ACTION_NEXT_HTML_ELEMENT.id,
+        ActionArgument.StringActionArgument(AccessibilityNodeInfoCompat.ACTION_ARGUMENT_HTML_ELEMENT_STRING, element),
+    );
+}
+```
+
+### [C] FloatActionArgument
+
+ActionArgument 的具体类.  
+用于传递 Float 类型的行为参数.
+
+#### [c] (name, value)
+
+- **name** { [string](dataTypes#string) } - 行为名称
+- **value** { [number](dataTypes#number) } - 行为参数值
+- <ins>**returns**</ins> { [ActionArgument](#i-actionargument) }
+
+构造一个 Float 类型的行为参数.
+
+```js
+/* 模拟 setProgress 封装方法. */
+function nextHtmlElement(progress) {
+    return w.performAction(
+        AccessibilityActionCompat.ACTION_SET_PROGRESS.id,
+        ActionArgument.FloatActionArgument(AccessibilityNodeInfoCompat.ACTION_ARGUMENT_PROGRESS_VALUE, progress),
+    );
+}
+```
+
+# 全局行为重定向
+
+本章节所有控件行为对应的方法 **名称** 均已全局化, 即支持 [ `click()` / `paste()` / `scrollDown()` / `show()` ] 等全局直接调用的方式来使用.  
+这些方法多数是 UiSelector 实例方法的直接绑定, 但有部分方法被 SimpleActionAutomator 覆盖.
+
+下表列出了控件行为方法对应的绑定源.  
+其中 AUTO 代表 SimpleActionAutomator, SEL 代表 UiSelector.
+
+| Global Actions                | AUTO | SEL |        
+|-------------------------------|:----:|:---:|
+| accessibilityFocus            |      |  √  |
+| clearAccessibilityFocus       |      |  √  |
+| clearFocus                    |      |  √  |
+| clearSelection                |      |  √  |
+| click                         |  √   |     |
+| collapse                      |      |  √  |
+| contextClick                  |      |  √  |
+| copy                          |      |  √  |
+| cut                           |      |  √  |
+| dismiss                       |      |  √  |
+| dragCancel                    |      |  √  |
+| dragDrop                      |      |  √  |
+| dragStart                     |      |  √  |
+| expand                        |      |  √  |
+| focus                         |      |  √  |
+| hideTooltip                   |      |  √  |
+| imeEnter                      |      |  √  |
+| longClick                     |  √   |     |
+| moveWindow                    |      |  √  |
+| nextAtMovementGranularity     |      |  √  |
+| nextHtmlElement               |      |  √  |
+| pageDown                      |      |  √  |
+| pageLeft                      |      |  √  |
+| pageRight                     |      |  √  |
+| pageUp                        |      |  √  |
+| paste                         |      |  √  |
+| pressAndHold                  |      |  √  |
+| previousAtMovementGranularity |      |  √  |
+| previousHtmlElement           |      |  √  |
+| scrollBackward                |      |  √  |
+| scrollDown                    |  √   |     |
+| scrollForward                 |      |  √  |
+| scrollLeft                    |      |  √  |
+| scrollRight                   |      |  √  |
+| scrollTo                      |      |  √  |
+| scrollUp                      |  √   |     |
+| select                        |      |  √  |
+| setProgress                   |      |  √  |
+| setSelection                  |      |  √  |
+| setText                       |  √   |     |
+| show                          |      |  √  |
+| showTextSuggestions           |      |  √  |
+| showTooltip                   |      |  √  |
+
+截至目前 (2022/11), 只有 [ click, longClick, scrollDown, scrollUp, setText ] 全局方法属于 SimpleActionAutomator.
+
+```js
+copy(); /* 相当于 selector().copy(). */
+paste(); /* 相当于 selector().paste(). */
+clearFocus(); /* 相当于 selector().clearFocus(). */
+imeEnter(); /* 相当于 selector().imeEnter(). */
+
+click(1, 2); /* 相当于 automator.click(1, 2). */
+longClick(1, 2); /* 相当于 automator.longClick(1, 2). */
+setText("hello"); /* 相当于 automator.setText("hello"). */
+scrollUp(); /* 相当于 automator.scrollUp(). */
+scrollDown(); /* 相当于 automator.scrollDown(). */
+```
+
+通过 [performAction](#m-performaction) 小节可知, UiSelector 的控件行为方法实际是对当前窗口中所有控件全部执行一次 Action, 因此几乎所有 UiSelector 的控件行为方法均不建议使用.
+
+全局方法 [paste](#m-paste) 是使用率相对较高的控件行为, 且效果往往与预期相符.  
+有关全局方法 `paste` 的执行过程及原理分析可参阅 [UiSelector#paste](uiSelectorType#m-paste) 小节.
\ No newline at end of file
diff --git a/api/uiObjectCollectionType.md b/api/uiObjectCollectionType.md
new file mode 100644
index 0000000..4230e0c
--- /dev/null
+++ b/api/uiObjectCollectionType.md
@@ -0,0 +1,791 @@
+# 控件集合 (UiObjectCollection)
+
+UiObjectCollection 代表 [控件节点 (UiObject)](uiObjectType) 的对象集合.
+
+---
+
+<p style="font: bold 2em sans-serif; color: #FF7043">UiObjectCollection</p>
+
+---
+
+## [@] UiObjectCollection
+
+**`Global`**
+
+AutoJs6 中几乎所有 UiObjectCollection 实例均已借助 Rhino 引擎将其包装为了 NativeArray 类型.  
+因此 JavaScript 的 Array 原型方法在 UiObjectCollection 实例上可以直接使用:
+
+```js
+let wc = contentMatch(/.+/).find();
+wc.toArray().forEach(w => console.log(w.content()));
+wc.forEach(w => console.log(w.content())); /* 效果同上. */
+
+/* 包装后的对象 "是" 一个 JavaScript 数组. */
+console.log(Array.isArray(wc)); // true
+
+/* Array 的原型方法 slice. */
+console.log(typeof wc.slice); // 'function'
+console.log(wc.slice === Array.prototype.slice); // true
+
+/* UiObjectCollection "类" 的实例方法依然全部可用 (如 size, click, each 等). */
+console.log(typeof wc.size); // 'function'
+console.log(typeof wc.click); // 'function'
+console.log(typeof wc.each); // 'function'
+```
+
+经过包装的 UiObjectCollection 将不能通过 instanceof 判断其类型, 但仍可通过 getClass 方法判断:
+
+```js
+let wc = contentMatch(/.+/).find();
+console.log(wc instanceof UiObjectCollection); // false
+console.log(wc.getClass() === UiObjectCollection); // true
+```
+
+除上述 find 方法, children, untilFind, findOf 以及附带集合类结果筛选器的 pickup, 返回的也都是一个经过包装的 UiObjectCollection:
+
+```js
+let s = contentMatch(/.+/);
+let w = pickup(s);
+let wcList = [
+    s.find(),
+    s.untilFind(),
+    s.findOf(w && w.compass('p2') || pickup()),
+    pickup(s, '{}'),
+];
+console.log(wcList.every(o => o.getClass() === UiObjectCollection)); // true
+```
+
+UiObjectCollection 可能为空集合:
+
+```js
+/* 空集合. */
+let wc = contentMatch(/[^\s\S]/).find();
+
+console.log(wc.length); // 0
+
+/* 即使是空集合, 依然是 UiObjectCollection 类型. */
+console.log(wc === null); // false
+console.log(wc.getClass() === UiObjectCollection); // true
+```
+
+集合的遍历即可用 UiObjectCollection 的实例方法 (如 each), 或使用 JavaScript 的数组遍历方法 (如 forEach), 或使用 [ for / for...in (不推荐) / for...of ] 循环:
+
+```js
+/**
+ * @type {UiObjectCollection | Array<UiObject>}
+ */
+let wc = pickup(/.+/, 'wc');
+
+wc.each(w => console.log(detect(w, 'txt')));
+
+wc.forEach(w => console.log(detect(w, 'txt')));
+
+for (let i = 0; i < wc.length; i += 1) {
+    console.log(detect(wc[i], 'txt'));
+}
+
+for (let i in wc) {
+    if (wc.hasOwnProperty(i) && /^\d+$/.test(i)) {
+        console.log(detect(wc[i], 'txt'));
+    }
+}
+
+for (let w of wc) {
+    console.log(detect(w, 'txt'));
+}
+```
+
+控件集合支持 [控件行为 (UiObject Action)](uiObjectActionsType).  
+如 [ click / longClick / imeEnter / setText / focus ] 等.
+
+performAction 源码摘要:
+
+```kotlin
+/* Updated as of Nov 2, 2022. */
+
+override fun performAction(action: Int, vararg arguments: ActionArgument): Boolean {
+    var success = true
+    nodes.filterNotNull().forEach { node ->
+        when (arguments.isEmpty()) {
+            true -> node.performAction(action)
+            else -> node.performAction(action, *arguments)
+        }.also { success = success and it }
+    }
+    return success
+}
+```
+
+由源码摘要可知, 控件集合执行控件行为, 相当于使集合中所有控件依次执行一次控件行为:
+
+```js
+let wc = contentMatch(/[^\s\S]/).find();
+
+/* 对控件集合执行 click 控件行为. */
+wc.click();
+
+/* 相当于对集合中每个控件元素执行控件行为. */
+wc.forEach(w => {
+    if (w !== null) {
+        w.click();
+    }
+});
+```
+
+执行控件行为后, 返回结果是 [boolean](dataTypes#boolean) 类型, 表示集合中所有控件在执行行为过程中未出现失败或异常.
+
+常见可以返回此类型的方法:
+
+- [UiObject#find](uiObjectType#m-find)
+- [UiObject#children](uiObjectType#m-children)
+- [UiSelector#find](uiSelectorType#m-find)
+- [UiSelector#untilFind](uiSelectorType#m-untilfind)
+- [UiSelector.pickup](uiSelectorType#m-pickup)
+
+## [m#] isEmpty
+
+### isEmpty()
+
+**`6.2.0`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+返回集合是否为空.
+
+## [m#] isNotEmpty
+
+### isNotEmpty()
+
+**`6.2.0`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+返回集合是否非空.
+
+## [m#] empty
+
+### empty()
+
+**`DEPRECATED`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+返回集合是否为空.
+
+已弃用, 建议使用 [isEmpty](#m-isempty) 替代.
+
+## [m#] nonEmpty
+
+### nonEmpty()
+
+**`DEPRECATED`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+返回集合是否非空.
+
+已弃用, 建议使用 [isNotEmpty](#m-isnotempty) 替代.
+
+## [m#] toArray
+
+### toArray()
+
+- <ins>**returns**</ins> { [JavaArray](dataTypes#javaarray)<[UiObject](uiObjectType)> }
+
+转换集合为 [Java 数组](dataTypes#javaarray).
+
+## [m#] toList
+
+### toList()
+
+**`6.2.0`**
+
+- <ins>**returns**</ins> { [JavaArrayList](dataTypes#javaarraylist)<[UiObject](uiObjectType)> }
+
+转换集合为 [Java 数组列表](dataTypes#javaarraylist).
+
+## [m#] get
+
+### get(i)
+
+**`DEPRECATED`**
+
+- <ins>**returns**</ins> { [UiObject](uiObjectType) }
+
+按索引获取集合中的 UiObject 元素.
+
+已弃用, 建议使用数组下标形式访问元素.
+
+```js
+let wc = pickup(/.+/, '{}');
+if (wc.length >= 2) {
+    console.log(wc.get(2) instanceof UiObject); // true
+    console.log(wc[2] instanceof UiObject); // true
+}
+```
+
+## [m#] size
+
+### size()
+
+**`DEPRECATED`**
+
+- <ins>**returns**</ins> { [UiObject](uiObjectType) }
+
+返回集合大小.
+
+已弃用, 建议使用 length 属性.
+
+```js
+let wc = pickup(/.+/, '{}');
+console.log(wc.size()); // e.g. 23
+console.log(wc.length); // e.g. 23
+```
+
+## [m#] each
+
+### each(consumer)
+
+**`DEPRECATED`**
+
+- **consumer** { [(](dataTypes#function)w: [UiObject](uiObjectType)[)](dataTypes#function) [=>](dataTypes#function) [void](dataTypes#void) } - 消费者
+- <ins>**returns**</ins> { [UiObjectCollection](uiObjectCollectionType) }
+
+对集合中每个元素执行一次消费.
+
+已弃用, 建议使用 [forEach](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach).
+
+```js
+let wc = pickup(/.+/, '{}');
+wc.each(w => console.log(w.content()));
+wc.forEach(w => console.log(w.content()));
+```
+
+## [m#] find
+
+### find(selector)
+
+**`A11Y`**
+
+- **selector** { [UiSelector](uiSelectorType) } - 选择器
+- <ins>**returns**</ins> { [UiObjectCollection](uiObjectCollectionType) }
+
+筛选新的控件集合.
+
+以集合中每一个元素为根节点, 依次按选择器筛选出所有满足条件的后代节点加入新集合, 将此新集合作为返回结果.
+
+```js
+/* 例如此集合中共有 3 个控件. */
+let wc = pickup(/.+/);
+console.log(wc.length); // 3
+
+/* 3 个控件作为根节点, 其所有的子孙节点分别有 10, 50, 200 个. */
+console.log(wc.map(w => w.find().length)); // [ 10, 50, 200 ]
+
+/* 其中 clickable 为 true 的控件分别有 2, 3, 4 个. */
+console.log(wc.map(w => w.find().filter(c => c.clickable()).length)); // [ 2, 3, 4 ]
+
+/* 因此 wc.find(clickable(true)) 应返回 2 + 3 + 4 个. */
+console.log(wc.find(clickable(true)).length); // 9
+```
+
+## [m#] findOne
+
+### findOne(selector)
+
+**`A11Y`**
+
+- **selector** { [UiSelector](uiSelectorType) } - 选择器
+- <ins>**returns**</ins> { [UiObject](uiObjectType) | [null](dataTypes#null) }
+
+筛选一个控件.
+
+以集合中每一个元素为根节点, 遍历其所有后代节点, 当满足选择器的筛选条件时, 返回此控件并停止筛选.  
+无满足筛选条件的控件时返回 null.
+
+```js
+let wc = pickup(/.+/);
+console.log(wc.findOne(clickable(true))); /* 返回一个可点击控件或 null. */
+```
+
+## [m#] performAction
+
+用于执行控件集合的行为.
+
+集合中所有控件将全部执行指定的行为.
+
+### performAction(action, ...arguments)
+
+**`A11Y`**
+
+- **action** { [number](dataTypes#number) } - 行为的唯一标志符 (Action ID)
+- **arguments** { [...](documentation#可变参数)[ActionArgument](uiObjectActionsType#i-actionargument)[[]](documentation#可变参数) } - 行为参数, 用于给行为传递参数
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+返回行为是否全部执行成功.
+
+> 注: 即使在执行过程中, 某一个控件执行失败, 后续控件依旧继续执行行为, 而非立即终止.
+
+> 参阅: [UiObjectActions](uiObjectActionsType) 章节.
+
+## [m#] click
+
+### click()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 点击 ] 行为](uiObjectActionsType#m-click).
+
+## [m#] longClick
+
+### longClick()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 长按 ] 行为](uiObjectActionsType#m-longclick).
+
+## [m#] accessibilityFocus
+
+### accessibilityFocus()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 获取无障碍焦点 ] 行为](uiObjectActionsType#m-accessibilityfocus).
+
+## [m#] clearAccessibilityFocus
+
+### clearAccessibilityFocus()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 清除无障碍焦点 ] 行为](uiObjectActionsType#m-clearaccessibilityfocus).
+
+## [m#] focus
+
+### focus()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 获取焦点 ] 行为](uiObjectActionsType#m-focus).
+
+## [m#] clearFocus
+
+### clearFocus()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 清除焦点 ] 行为](uiObjectActionsType#m-clearfocus).
+
+## [m#] dragStart
+
+### dragStart()
+
+**`6.2.0`** **`A11Y`** **`API>=32`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 拖放开始 ] 行为](uiObjectActionsType#m-dragstart).
+
+## [m#] dragDrop
+
+### dragDrop()
+
+**`6.2.0`** **`A11Y`** **`API>=32`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 拖放放下 ] 行为](uiObjectActionsType#m-dragdrop).
+
+## [m#] dragCancel
+
+### dragCancel()
+
+**`6.2.0`** **`A11Y`** **`API>=32`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 拖放取消 ] 行为](uiObjectActionsType#m-dragcancel).
+
+## [m#] imeEnter
+
+### imeEnter()
+
+**`6.2.0`** **`A11Y`** **`API>=30`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 输入法 ENTER 键 ] 行为](uiObjectActionsType#m-imeenter).
+
+## [m#] moveWindow
+
+### moveWindow(x, y)
+
+**`6.2.0`** **`A11Y`** **`API>=26`**
+
+- **x** { [number](dataTypes#number) } - X 坐标
+- **y** { [number](dataTypes#number) } - Y 坐标
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 移动窗口到新位置 ] 行为](uiObjectActionsType#m-movewindow).
+
+## [m#] nextAtMovementGranularity
+
+### nextAtMovementGranularity(granularity, isExtendSelection)
+
+**`6.2.0`** **`A11Y`**
+
+- **granularity** { [number](dataTypes#number) } - 粒度
+- **isExtendSelection** { [boolean](dataTypes#boolean) } - 是否扩展选则文本
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 按粒度移至下一位置 ] 行为](uiObjectActionsType#m-nextatmovementgranularity).
+
+## [m#] nextHtmlElement
+
+### nextHtmlElement(element)
+
+**`6.2.0`** **`A11Y`**
+
+- **element** { [string](dataTypes#string) } - 元素名称
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 按元素移至下一位置 ] 行为](uiObjectActionsType#m-nexthtmlelement).
+
+## [m#] pageLeft
+
+### pageLeft()
+
+**`6.2.0`** **`A11Y`** **`API>=29`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 使视窗左移的翻页 ] 行为](uiObjectActionsType#m-pageleft).
+
+## [m#] pageUp
+
+### pageUp()
+
+**`6.2.0`** **`A11Y`** **`API>=29`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 使视窗上移的翻页 ] 行为](uiObjectActionsType#m-pageup).
+
+## [m#] pageRight
+
+### pageRight()
+
+**`6.2.0`** **`A11Y`** **`API>=29`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 使视窗右移的翻页 ] 行为](uiObjectActionsType#m-pageright).
+
+## [m#] pageDown
+
+### pageDown()
+
+**`6.2.0`** **`A11Y`** **`API>=29`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 使视窗下移的翻页 ] 行为](uiObjectActionsType#m-pagedown).
+
+## [m#] pressAndHold
+
+### pressAndHold()
+
+**`6.2.0`** **`A11Y`** **`API>=30`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 按住 ] 行为](uiObjectActionsType#m-pressandhold).
+
+## [m#] previousAtMovementGranularity
+
+### previousAtMovementGranularity(granularity, isExtendSelection)
+
+**`6.2.0`** **`A11Y`**
+
+- **granularity** { [number](dataTypes#number) } - 粒度
+- **isExtendSelection** { [boolean](dataTypes#boolean) } - 是否扩展选则文本
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 按粒度移至上一位置 ] 行为](uiObjectActionsType#m-previousatmovementgranularity).
+
+## [m#] previousHtmlElement
+
+### previousHtmlElement(element)
+
+**`6.2.0`** **`A11Y`**
+
+- **element** { [string](dataTypes#string) } - 元素名称
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 按元素移至上一位置 ] 行为](uiObjectActionsType#m-previoushtmlelement).
+
+## [m#] showTextSuggestions
+
+### showTextSuggestions()
+
+**`6.2.0`** **`A11Y`** **`API>=33`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 显示文本建议 ] 行为](uiObjectActionsType#m-showtextsuggestions).
+
+## [m#] showTooltip
+
+### showTooltip()
+
+**`6.2.0`** **`A11Y`** **`API>=28`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 显示工具提示信息 ] 行为](uiObjectActionsType#m-showtooltip).
+
+## [m#] hideTooltip
+
+### hideTooltip()
+
+**`6.2.0`** **`A11Y`** **`API>=28`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 隐藏工具提示信息 ] 行为](uiObjectActionsType#m-hidetooltip).
+
+## [m#] show
+
+### show()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 显示在视窗内 ] 行为](uiObjectActionsType#m-show).
+
+## [m#] dismiss
+
+### dismiss()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 消隐 ] 行为](uiObjectActionsType#m-dismiss).
+
+## [m#] copy
+
+### copy()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 复制文本 ] 行为](uiObjectActionsType#m-copy).
+
+## [m#] cut
+
+### cut()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 剪切文本 ] 行为](uiObjectActionsType#m-cut).
+
+## [m#] paste
+
+### paste()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 粘贴文本 ] 行为](uiObjectActionsType#m-paste).
+
+## [m#] select
+
+### select()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 选中 ] 行为](uiObjectActionsType#m-select).
+
+## [m#] expand
+
+### expand()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 展开 ] 行为](uiObjectActionsType#m-expand).
+
+## [m#] collapse
+
+### collapse()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 折叠 ] 行为](uiObjectActionsType#m-collapse).
+
+## [m#] scrollLeft
+
+### scrollLeft()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 使视窗左移的滚动 ] 行为](uiObjectActionsType#m-scrollleft).
+
+## [m#] scrollUp
+
+### scrollUp()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 使视窗上移的滚动 ] 行为](uiObjectActionsType#m-scrollup).
+
+## [m#] scrollRight
+
+### scrollRight()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 使视窗右移的滚动 ] 行为](uiObjectActionsType#m-scrollright).
+
+## [m#] scrollDown
+
+### scrollDown()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 使视窗下移的滚动 ] 行为](uiObjectActionsType#m-scrolldown).
+
+## [m#] scrollForward
+
+### scrollForward()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 使视窗前移的滚动 ] 行为](uiObjectActionsType#m-scrollforward).
+
+## [m#] scrollBackward
+
+### scrollBackward()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 使视窗后移的滚动 ] 行为](uiObjectActionsType#m-scrollbackward).
+
+## [m#] scrollTo
+
+### scrollTo(row, column)
+
+**`A11Y`**
+
+- **row** { [number](dataTypes#number) } - 行序数
+- **column** { [number](dataTypes#number) } - 列序数
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 将指定位置滚动至视窗内 ] 行为](uiObjectActionsType#m-scrollto).
+
+## [m#] contextClick
+
+### contextClick()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 上下文点击 ] 行为](uiObjectActionsType#m-contextclick).
+
+## [m#] setText
+
+### setText(text)
+
+**`A11Y`**
+
+- **text** { [string](dataTypes#string) } - 文本
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 设置文本 ] 行为](uiObjectActionsType#m-settext).
+
+## [m#] setSelection
+
+### setSelection(start, end)
+
+**`A11Y`**
+
+- **start** { [number](dataTypes#number) } - 开始位置
+- **end** { [number](dataTypes#number) } - 结束位置
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 选择文本 ] 行为](uiObjectActionsType#m-setselection).
+
+## [m#] clearSelection
+
+### clearSelection()
+
+**`6.2.0`** **`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 取消选择文本 ] 行为](uiObjectActionsType#m-clearselection).
+
+## [m#] setProgress
+
+### setProgress(progress)
+
+**`A11Y`**
+
+- **progress** { [number](dataTypes#number) } - 进度值
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+控件集合执行 [[ 设置进度值 ] 行为](uiObjectActionsType#m-setprogress).
+
+## [m] of
+
+### of(list)
+
+- **list** { [UiSelector](uiSelectorType)[[]](dataTypes#array) } - 控件数组
+- <ins>**returns**</ins> { [UiObjectCollection](uiObjectCollectionType) }
+
+将控件数组转换为 [UiObjectCollection](uiObjectCollectionType).
+
+```js
+let wA = pickup(/hello.+/);
+let wB = pickup({ clickable: true });
+
+let wc = UiObjectCollection.of([ wA, wB ]);
+
+/* 对 UiObjectCollection 进行操作. */
+wc.click();
+```
\ No newline at end of file
diff --git a/api/uiObjectType.md b/api/uiObjectType.md
new file mode 100644
index 0000000..4340ad1
--- /dev/null
+++ b/api/uiObjectType.md
@@ -0,0 +1,2189 @@
+# 控件节点 (UiObject)
+
+UiObject 通常被称为 [ 控件 / 节点 / 控件节点 ], 可看做是一个通过安卓无障碍服务包装的 [AccessibilityNodeInfo](https://developer.android.com/reference/android/view/accessibility/AccessibilityNodeInfo) 对象, 代表一个当前活动窗口中的节点, 通过此节点可收集控件信息或执行控件行为, 进而实现一系列自动化操作.
+
+应用界面通常由控件构成, 如 [ImageView](https://developer.android.com/reference/android/widget/ImageView) 构成图像控件, [TextView](https://developer.android.com/reference/android/widget/TextView) 构成文本控件. 通过不同的布局可决定不同控件的位置, 如 [LinearLayout (线性布局)](https://developer.android.com/reference/android/widget/LinearLayout) 按水平或垂直方式排布及显示控件, [AbsListView (列表布局)](https://developer.android.com/reference/android/widget/AbsListView) 按列表方式排布及显示控件.
+不同的布局方式形成了 [控件层级](glossaries#控件层级).
+
+控件拥有特定的属性, 可分为两种类型, 状态型及行为型.  
+行为型属性可参阅章节 [控件节点行为 (UiObjectActions)](uiObjectActionsType).  
+状态型属性访问均被封装为方法调用的形式, 如访问控件的类名, 需使用 `w.className()` 而非 `w.className`.
+
+> 注: 在 AutoJs6 中, 由 [UiObject](uiObjectType) 代表一个控件节点, 它继承自 [AccessibilityNodeInfoCompat](https://developer.android.com/reference/androidx/core/view/accessibility/AccessibilityNodeInfoCompat), 而并非一个 [View](https://developer.android.com/reference/android/view/View).
+
+---
+
+<p style="font: bold 2em sans-serif; color: #FF7043">UiObject</p>
+
+---
+
+## [@] UiObject
+
+**`Global`**
+
+如需获取一个 UiObject 对象, 通常使用 [选择器](uiSelectorType) 获取.
+
+```js
+/* 获取一个包含任意文本的 UiObject 对象. */
+let w = pickup(/.+/);
+
+/* 当活动窗口中不存在符合筛选条件的控件时返回 null. */
+console.log(w === null);
+
+/* 使用 instanceof 操作符查看对象 w 是否为 UiObject "类" 的实例. */
+console.log(w instanceof UiObject);
+```
+
+多数 UiObject 的实例方法 (如 parent 和 child 等) 均返回自身类型, 因此可实现链式调用:
+
+```js
+let w = pickup('hello');
+/* 获取 w 控件的三级父控件的 2 号索引子控件. */
+w.parent().parent().parent().child(2);
+```
+
+## [m#] parent
+
+### parent()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [UiObject](uiObjectType) | [null](dataTypes#null) }
+
+返回其父控件.
+
+```js
+let w = pickup(/.+/);
+w.parent();
+w.compass('p'); /* 同上. */
+detect(w, 'p'); /* 同上. */
+
+w.parent().parent().parent();
+w.compass('p3'); /* 同上. */
+detect(w, 'p3'); /* 同上. */
+```
+
+## [m#] child
+
+### child(i)
+
+**`A11Y`**
+
+- **i** { [number](dataTypes#number) } - 索引
+- <ins>**returns**</ins> { [UiObject](uiObjectType) | [null](dataTypes#null) }
+
+返回其索引为 i 的子控件.
+
+```js
+let w = pickup(/.+/);
+w.child(3);
+w.compass('c3'); /* 同上. */
+detect(w, 'c3'); /* 同上. */
+
+w.child(3).child(1);
+w.compass('c3c1'); /* 同上. */
+detect(w, 'c3>1'); /* 同上. */
+```
+
+## [m#] children
+
+### children()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [UiObjectCollection](uiObjectCollectionType) }
+
+返回当前节点的子控件集合.
+
+```js
+let cc = pickup({ filter: w => w.children().length > 5 }, 'children');
+
+console.log(cc.length); /* e.g. 10 */
+
+cc.forEach((w) => {
+    let content = w.content();
+    content && console.log(content);
+})
+```
+
+如需返回当前节点下的所有子孙控件集合, 可使用 [UiObject#find()](#m-find).
+
+```js
+let w = pickup({ filter: w => w.children().length > 5 });
+console.log(w.find().length); /* e.g. 20 */
+```
+
+## [m#] childCount
+
+### childCount()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回当前节点的子控件数量.
+
+别名属性或方法:
+
+- `[m#]` getChildCount
+
+## [m#] hasChildren
+
+### hasChildren()
+
+**`6.2.0`** **`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+返回当前节点是否有子节点.
+
+相当于 `childCount() > 0`.
+
+## [m#] indexInParent
+
+### indexInParent()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回当前节点在其父控件的索引值.
+
+```js
+/* 例如 p 控件有 3 个子控件 (a, b, c). */
+
+a.indexInParent(); // 0 
+p.child(0); /* 对应 a. */
+
+console.log(c.indexInParent()); // 2
+p.child(2); /* 对应 c. */
+```
+
+方法 `indexInParent` 通常用于访问临近或相对位置的兄弟节点:
+
+```js
+/* 例如 p 控件有 3 个子控件 (a, b, c). */
+
+/* c 是 b 的相邻兄弟节点 (相对索引为 1). */
+p.child(b.indexInParent() + 1); /* 对应 c. */
+b.compass('s>1'); /* 使用罗盘方法, 效果同上. */
+
+/* a 也是 b 的相邻兄弟节点 (相对索引为 -1). */
+p.child(b.indexInParent() - 1); /* 对应 a. */
+b.compass('s<1'); /* 使用罗盘方法, 效果同上. */
+
+/* a 是 c 的兄弟节点 (相对索引为 -2). */
+p.child(c.indexInParent() - 2); /* 对应 a. */
+b.compass('s<2'); /* 使用罗盘方法, 效果同上. */
+```
+
+有时也需要获取当前节点的父控件在其父控件的索引值:
+
+```js
+let p = pickup({ filter: w => w.depth() > 0 && w.parent().indexInParent() > 0 });
+console.log(p.parent().indexInParent()); // e.g. 2
+```
+
+## [m#] find
+
+### find()
+
+**`Overload 1/2`** **`A11Y`**
+
+- <ins>**returns**</ins> { [UiObjectCollection](uiObjectCollectionType) }
+
+以当前节点作为根节点, 返回其所有的子孙控件集合.
+
+与 [children](#m-children) 方法不同, `w.children()` 返回子控件集合, 而 `w.find()` 返回所有子孙控件集合.
+
+```js
+let root = depth(0).findOnce();
+console.log(root.find().length); // e.g. 500
+console.log(root.children().length); // e.g. 2
+```
+
+子孙控件集合中包含根节点本身:
+
+```js
+/* 找出一个没有任何子孙控件的节点. */
+let w = pickup({ filter: w => w.childCount() === 0 });
+
+/* find() 返回的集合包含其自身, 而非空集合. */
+console.log(w.find().length); // 1
+```
+
+因此, `N 层级子孙控件集合数量` = `N + 1 层级子孙控件数量总和` + `1`:
+
+```js
+let root = depth(0).findOnce();
+let sumA = root.find().length;
+let sumB = root.children().reduce((sum, c) => sum + c.find().length, 0);
+console.log(sumA, sumB); /* sumA 和 sumB 相差 1. */
+```
+
+### find(selector)
+
+**`Overload 2/2`** **`A11Y`**
+
+- **selector** { [selector](uiSelectorType) } - 选择器
+- <ins>**returns**</ins> { [UiObjectCollection](uiObjectCollectionType) }
+
+以当前节点作为根节点, 返回其所有满足选择器筛选条件的子孙控件集合.
+
+```js
+/* 找出 w 控件下所有符合有效内容长度不小于 10 的子孙控件集合. */
+console.log(w.find(contentMatch(/\s*.{10,}\s*/)));
+```
+
+## [m#] findOne
+
+### findOne(selector)
+
+**`A11Y`**
+
+- **selector** { [selector](uiSelectorType) } - 选择器
+- <ins>**returns**</ins> { [UiObject](uiObjectType) }
+
+以当前节点作为根节点, 在其所有子孙控件中找出一个满足选择器筛选条件的控件.
+
+```js
+/* 找出 w 子孙控件中符合有效内容长度不小于 10 的一个控件. */
+console.log(w.findOne(contentMatch(/\s*.{10,}\s*/)));
+```
+
+## [m#] bounds
+
+### bounds()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [AndroidRect](dataTypes#androidrect) }
+
+方法 [boundsInScreen](#m-boundsinscreen) 的别名.
+
+返回一个 [控件矩形 (Rect)](dataTypes#androidrect), 表示控件在屏幕的相对位置及空间范围.
+
+```js
+let bounds = contentMatch(/.+/).findOnce().bounds();
+console.log(bounds); // e.g. Rect(0, 48 - 112, 160)
+```
+
+别名属性或方法:
+
+- `[m#]` [boundsInScreen](#m-boundsinscreen)
+
+## [m#] boundsInScreen
+
+### boundsInScreen()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [AndroidRect](dataTypes#androidrect) }
+
+返回一个 [控件矩形 (Rect)](dataTypes#androidrect), 表示控件在屏幕的相对位置及空间范围.
+
+```js
+let bounds = contentMatch(/.+/).findOnce().boundsInScreen();
+console.log(bounds); // e.g. Rect(0, 48 - 112, 160)
+```
+
+别名属性或方法:
+
+- `[m#]` [bounds](#m-bounds)
+
+## [m#] boundsInParent
+
+### boundsInParent()
+
+**`A11Y`**
+
+**`DEPRECATED`**
+
+- <ins>**returns**</ins> { [AndroidRect](dataTypes#androidrect) }
+
+返回一个 [控件矩形 (Rect)](dataTypes#androidrect), 表示控件于其父控件的相对位置及空间范围.
+
+因其父控件实际上是 `View#getParentForAccessibility()` 的结果, 而非此控件的 `viewParent`, 所以得到的结果是不可靠的.
+
+```js
+let bounds = contentMatch(/.+/).findOnce().boundsInParent();
+console.log(bounds); // e.g. Rect(0, 0 - 112, 112)
+```
+
+## [m#] boundsLeft
+
+### boundsLeft()
+
+**`6.2.0`** **`A11Y`**
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回控件矩形左边界距屏幕左边缘的像素距离.
+
+```js
+let w = pickup(/.+/);
+console.log(w.bounds()); // e.g. Rect(0, 48 - 112, 160)
+console.log(w.bounds().left); // e.g. 0
+console.log(w.boundsLeft()); // e.g. 0
+console.log(w.left()); // e.g. 0
+```
+
+## [m#] boundsTop
+
+### boundsTop()
+
+**`6.2.0`** **`A11Y`**
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回控件矩形上边界距屏幕上边缘的像素距离.
+
+```js
+let w = pickup(/.+/);
+console.log(w.bounds()); // e.g. Rect(0, 48 - 112, 160)
+console.log(w.bounds().top); // e.g. 48
+console.log(w.boundsTop()); // e.g. 48
+console.log(w.top()); // e.g. 48
+```
+
+## [m#] boundsRight
+
+### boundsRight()
+
+**`6.2.0`** **`A11Y`**
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回控件矩形右边界距屏幕左边缘的像素距离.
+
+```js
+let w = pickup(/.+/);
+console.log(w.bounds()); // e.g. Rect(0, 48 - 112, 160)
+console.log(w.bounds().right); // e.g. 112
+console.log(w.right()); // e.g. 112
+console.log(w.boundsRight()); // e.g. 112
+```
+
+## [m#] boundsBottom
+
+### boundsBottom()
+
+**`6.2.0`** **`A11Y`**
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回控件矩形下边界距屏幕上边缘的像素距离.
+
+```js
+let w = pickup(/.+/);
+console.log(w.bounds()); // e.g. Rect(0, 48 - 112, 160)
+console.log(w.bounds().bottom); // e.g. 160
+console.log(w.bottom()); // e.g. 160
+console.log(w.boundsBottom()); // e.g. 160
+```
+
+## [m#] boundsWidth
+
+### boundsWidth()
+
+**`6.2.0`** **`A11Y`**
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回控件矩形的宽度.
+
+```js
+let w = pickup(/.+/);
+console.log(w.bounds()); // e.g. Rect(0, 48 - 112, 160)
+console.log(w.bounds().width()); // e.g. 112
+console.log(w.boundsWidth()); // e.g. 112
+console.log(w.right() - w.left()); // e.g. 112
+```
+
+## [m#] boundsHeight
+
+### boundsHeight()
+
+**`6.2.0`** **`A11Y`**
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回控件矩形的高度.
+
+```js
+let w = pickup(/.+/);
+console.log(w.bounds()); // e.g. Rect(0, 48 - 112, 160)
+console.log(w.bounds().height()); // e.g. 112
+console.log(w.boundsHeight()); // e.g. 112
+console.log(w.bottom() - w.top()); // e.g. 112
+```
+
+## [m#] boundsCenterX
+
+### boundsCenterX()
+
+**`6.2.0`** **`A11Y`**
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回控件矩形的中心 X 坐标 (中心点距屏幕左边缘的像素距离).
+
+该坐标为整数, 非整数数值将按 **向下取整** 处理, 因此会损失精度.
+
+如需保留精度, 可使用 [boundsExactCenterX](#m-boundsexactcenterx).
+
+```js
+let wA = pickup(/.+/);
+console.log(wA.bounds()); // e.g. Rect(0, 48 - 112, 160)
+console.log(wA.bounds().centerX()); // e.g. 56
+console.log(wA.boundsCenterX()); // e.g. 56
+
+let wB = pickup(/.+/);
+console.log(wB.bounds()); // e.g. Rect(0, 0 - 11, 20)
+console.log(wB.boundsCenterX()); // e.g. 5 (5.5 向下取整得 5)
+
+let wC = pickup(/.+/);
+console.log(wC.bounds()); // e.g. Rect(0, 0 - -11, 20)
+console.log(wC.boundsCenterX()); // e.g. -6 (-5.5 向下取整得 -6)
+```
+
+## [m#] boundsExactCenterX
+
+### boundsExactCenterX()
+
+**`6.2.0`** **`A11Y`**
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回控件矩形的中心 X 坐标 (中心点距屏幕左边缘的像素距离).
+
+该坐标将保留精度 (可能为非整数), 如需返回整数结果, 可使用 [boundsCenterX](#m-boundscenterx).
+
+```js
+let wA = pickup(/.+/);
+console.log(wA.bounds()); // e.g. Rect(0, 48 - 112, 160)
+console.log(wA.bounds().exactCenterX()); // e.g. 56
+console.log(wA.boundsExactCenterX()); // e.g. 56
+
+let wB = pickup(/.+/);
+console.log(wB.bounds()); // e.g. Rect(0, 0 - 11, 20)
+console.log(wB.boundsExactCenterX()); // e.g. 5.5
+
+let wC = pickup(/.+/);
+console.log(wC.bounds()); // e.g. Rect(0, 0 - -11, 20)
+console.log(wC.boundsExactCenterX()); // e.g. -5.5
+```
+
+## [m#] boundsCenterY
+
+### boundsCenterY()
+
+**`6.2.0`** **`A11Y`**
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回控件矩形的中心 Y 坐标 (中心点距屏幕上边缘的像素距离).
+
+该坐标为整数, 非整数数值将按 **向下取整** 处理, 因此会损失精度.
+
+如需保留精度, 可使用 [boundsExactCenterY](#m-boundsexactcentery).
+
+```js
+let wA = pickup(/.+/);
+console.log(wA.bounds()); // e.g. Rect(0, 48 - 112, 160)
+console.log(wA.bounds().centerY()); // e.g. 104
+console.log(wA.boundsCenterY()); // e.g. 104
+
+let wB = pickup(/.+/);
+console.log(wB.bounds()); // e.g. Rect(0, 0 - 11, 33)
+console.log(wB.boundsCenterY()); // e.g. 16 (16.5 向下取整得 16)
+
+let wC = pickup(/.+/);
+console.log(wC.bounds()); // e.g. Rect(0, 0 - 11, -33)
+console.log(wC.boundsCenterY()); // e.g. -17 (-16.5 向下取整得 -17)
+```
+
+## [m#] boundsExactCenterY
+
+### boundsExactCenterY()
+
+**`6.2.0`** **`A11Y`**
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回控件矩形的中心 Y 坐标 (中心点距屏幕上边缘的像素距离).
+
+该坐标将保留精度 (可能为非整数), 如需返回整数结果, 可使用 [boundsCenterY](#m-boundscentery).
+
+```js
+let wA = pickup(/.+/);
+console.log(wA.bounds()); // e.g. Rect(0, 48 - 112, 160)
+console.log(wA.bounds().exactCenterY()); // e.g. 104
+console.log(wA.boundsExactCenterY()); // e.g. 104
+
+let wB = pickup(/.+/);
+console.log(wB.bounds()); // e.g. Rect(0, 0 - 11, 33)
+console.log(wB.boundsExactCenterY()); // e.g. 16.5
+
+let wC = pickup(/.+/);
+console.log(wC.bounds()); // e.g. Rect(0, 0 - 11, -33)
+console.log(wC.boundsExactCenterY()); // e.g. -16.5
+```
+
+## [m#] left
+
+### left()
+
+**`6.2.0`** **`A11Y`**
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回控件矩形左边界距屏幕左边缘的像素距离.
+
+[UiObject#boundsLeft](#m-boundsleft) 的别名方法.
+
+## [m#] top
+
+### top()
+
+**`6.2.0`** **`A11Y`**
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回控件矩形上边界距屏幕上边缘的像素距离.
+
+[UiObject#boundsTop](#m-boundstop) 的别名方法.
+
+## [m#] right
+
+### right()
+
+**`6.2.0`** **`A11Y`**
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回控件矩形右边界距屏幕左边缘的像素距离.
+
+[UiObject#boundsRight](#m-boundsright) 的别名方法.
+
+## [m#] bottom
+
+### bottom()
+
+**`6.2.0`** **`A11Y`**
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回控件矩形下边界距屏幕上边缘的像素距离.
+
+[UiObject#boundsBottom](#m-boundsbottom) 的别名方法.
+
+## [m#] width
+
+### width()
+
+**`6.2.0`** **`A11Y`**
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回控件矩形的宽度.
+
+[UiObject#boundsWidth](#m-boundswidth) 的别名方法.
+
+## [m#] height
+
+### height()
+
+**`6.2.0`** **`A11Y`**
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回控件矩形的高度.
+
+[UiObject#boundsHeight](#m-boundsheight) 的别名方法.
+
+## [m#] centerX
+
+### centerX()
+
+**`6.2.0`** **`A11Y`**
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回控件矩形的中心 X 坐标 (中心点距屏幕左边缘的像素距离).
+
+[UiObject#boundsCenterX](#m-boundscenterx) 的别名方法.
+
+## [m#] exactCenterX
+
+### exactCenterX()
+
+**`6.2.0`** **`A11Y`**
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回控件矩形的中心 X 坐标 (中心点距屏幕左边缘的像素距离).
+
+[UiObject#boundsExactCenterX](#m-boundsexactcenterx) 的别名方法.
+
+## [m#] centerY
+
+### centerY()
+
+**`6.2.0`** **`A11Y`**
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回控件矩形的中心 Y 坐标 (中心点距屏幕上边缘的像素距离).
+
+[UiObject#boundsCenterY](#m-boundscentery) 的别名方法.
+
+## [m#] exactCenterY
+
+### exactCenterY()
+
+**`6.2.0`** **`A11Y`**
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回控件矩形的中心 Y 坐标 (中心点距屏幕上边缘的像素距离).
+
+[UiObject#boundsExactCenterY](#m-boundsexactcentery) 的别名方法.
+
+## [m#] point
+
+### point()
+
+**`6.2.0`** **`A11Y`**
+
+- <ins>**returns**</ins> { [OpencvPoint](dataTypes#opencvpoint) }
+
+返回控件矩形的中心点 ([Point](dataTypes#opencvpoint)).
+
+该中心点坐标由 [exactCenterX](#m-exactcenterx) 和 [exactCenterY](#m-exactcentery) 计算获得, 因此会保留精度.
+
+```js
+let wA = pickup(/.+/);
+console.log(wA.bounds()); // e.g. Rect(0, 0 - 10, 12)
+console.log(wA.point()); // e.g. {5.0, 6.0}
+console.log(wA.point().x); // e.g. 5
+
+let wB = pickup(/.+/);
+console.log(wB.bounds()); // e.g. Rect(0, 0 - 11, 13)
+console.log(wB.point()); // e.g. {5.5, 6.5}
+console.log(wB.point().y); // e.g. 6.5
+```
+
+## [m#] size
+
+### size()
+
+**`6.2.0`** **`A11Y`**
+
+- <ins>**returns**</ins> { [OpencvSize](dataTypes#opencvsize) }
+
+返回控件矩形的尺寸 ([Size](dataTypes#opencvsize)).
+
+```js
+let w = pickup(/.+/);
+console.log(w.bounds()); // e.g. Rect(0, 0 - 10, 12)
+console.log(w.size()); // e.g. 10x12
+console.log(w.size().width); // e.g. 10
+console.log(w.size().height); // e.g. 12
+```
+
+## [m#] clickBounds
+
+### clickBounds(offsetX?, offsetY?)
+
+**`6.2.0`** **`Overload [1-3]/3`** **`A11Y`**
+
+- **[ offsetX = 0 ]** { [number](dataTypes#number) } - X 坐标偏移量 (支持负值及百分率)
+- **[ offsetY = 0 ]** { [number](dataTypes#number) } - Y 坐标偏移量 (支持负值及百分率)
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否点击行为已执行且执行过程中无异常
+
+点击控件矩形的中心点坐标.
+
+点击操作借助 [automator.click(x, y)](automator#m-click) 完成, 此操作需要启用无障碍服务.
+
+```js
+let w = pickup(/.+/);
+
+console.log(w.bounds()); // e.g. Rect(0, 60 - 100, 200)
+
+w.clickBounds(); /* 相当于 click(50, 130) . */
+click(w.centerX(), w.centerY()); /* 效果同上. */
+
+w.clickBounds(10); /* X 坐标偏移量为 10 像素, 相当于 click(50 + 10, 130) . */
+w.clickBounds(10, 15); /* X 与 Y 坐标偏移量分别为 10 和 15 像素, 相当于 click(50 + 10, 130 + 15) . */
+w.clickBounds(0, -15); /* Y 坐标偏移量为 -15 像素, 相当于 click(50, 130 - 15) . */
+w.clickBounds(0.2); /* X 坐标偏移量为 20% 屏幕宽度, 相当于 click(50 + 0.2 * device.width, 130) . */
+w.clickBounds(0.2, -0.05); /* X 与 Y 坐标偏移量为 20% 屏幕宽度和 -5% 屏幕高度. */
+```
+
+## [m#] id
+
+### id()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [string](dataTypes#string) | [null](dataTypes#null) }
+
+返回节点的 ID 资源全称 (Fully-Qualified ID Resource Name).
+
+若 ID 不存在, 返回 null.
+
+安卓资源全称格式为 `package:type/entry`, 即 `包名:类型/资源项`.  
+ID 资源全称的 `类型` 为 `id`.  
+一个有效的 ID 资源全称: `com.test:id/some_entry`.
+
+```js
+console.log(idMatch(/.+/).findOnce().id()); // e.g. org.autojs.autojs6:id/action_bar_root
+console.log(idMatch(/.+/).findOnce().fullId()); /* 同上. */
+console.log(idMatch(/.+/).findOnce().getViewIdResourceName()); /* 同上. */
+```
+
+需额外留意, 部分应用的控件 ID 资源全称可能不符合标准:
+
+```js
+/* 标准 ID 全称. */
+let canonicalId = "com.test:id/hello_world";
+
+/* 可能出现的非标准 ID 全称. */
+let peculiarId = "hello_world"; /* 仅含资源项, 无包名及类型标识. */
+```
+
+别名属性或方法:
+
+- `[m#]` getViewIdResourceName
+- `[m#]` [fullId](#m-fullid)
+
+## [m#] fullId
+
+### fullId()
+
+**`6.2.0`** **`A11Y`**
+
+- <ins>**returns**</ins> { [string](dataTypes#string) | [null](dataTypes#null) }
+
+返回节点的 ID 资源全称 (Fully-Qualified ID Resource Name).
+
+若 ID 不存在, 返回 null.
+
+[UiObject#id](#m-id) 的别名方法.
+
+## [m#] idEntry
+
+### idEntry()
+
+**`6.2.0`** **`A11Y`**
+
+- <ins>**returns**</ins> { [string](dataTypes#string) | [null](dataTypes#null) }
+
+返回节点的 ID 资源项名称 (ID Resource Entry Name).
+
+安卓资源全称格式为 `package:type/entry`, 即 `包名:类型/资源项`.  
+例如对于 ID 资源全称 `com.test:id/some_entry`, 其 ID 资源项名称为 `some_entry`.
+
+```js
+/* ID 资源全称. */
+console.log(idMatch(/.+/).findOnce().id()); // e.g. org.autojs.autojs6:id/action_bar_root
+
+/* ID 资源项名称. */
+console.log(idMatch(/.+/).findOnce().idEntry()); // action_bar_root
+console.log(idMatch(/.+/).findOnce().simpleId()); /* 同上. */
+```
+
+别名属性或方法:
+
+- `[m#]` [simpleId](#m-simpleid)
+
+## [m#] simpleId
+
+### simpleId()
+
+**`6.2.0`** **`A11Y`**
+
+- <ins>**returns**</ins> { [string](dataTypes#string) | [null](dataTypes#null) }
+
+返回节点的 ID 资源项名称 (ID Resource Entry Name).
+
+若 ID 不存在, 返回 null.
+
+[UiObject#idEntry](#m-identry) 的别名方法.
+
+## [m#] idHex
+
+### idHex()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [string](dataTypes#string) | [null](dataTypes#null) }
+
+返回节点的 [ID 资源全称](#m-fullid) 的 [资源 ID](glossaries.md#资源-ID) 十六进制字符串值, 简称 `ID 资源十六进制代表值`.
+
+1. 获取 `ID 资源全称` 对应的 `资源 ID`
+2. 将 `资源 ID` 的十六进制值以 `0x` 作为前缀进行组合
+3. 返回组合的字符串值
+
+若 ID 不存在, 返回 null.
+
+```js
+console.log(idMatch(/explorer_item_list/).findOnce().idHex()); /* e.g. 0x7f090117 */
+```
+
+## [m#] text
+
+### text()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [string](dataTypes#string) }
+
+返回控件文本内容.
+
+若文本内容不存在, 返回空字符串.
+
+出于保护隐私目的, `isPassword()` 返回 `true` 的密码类型控件, `text()` 将返回空字符串.
+
+```js
+console.log(textMatch(/.+/).findOnce().text()); /* e.g. hello */
+```
+
+别名属性或方法:
+
+- `[m#]` getText
+
+## [m#] desc
+
+### desc()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [string](dataTypes#string) | [null](dataTypes#null) }
+
+返回控件的内容描述标签.
+
+若内容描述标签容不存在, 返回 null.
+
+内容描述标签可以帮助需要无障碍服务的用户 (如视力障碍人群等) 理解当前控件的用途或说明.  
+如 [TalkBack](https://support.google.com/accessibility/android/topic/10601570?hl=zh-Hans) 开启后可以朗读控件的内容描述标签, 对于理解那些没有文本内容的控件尤其重要.
+
+```js
+console.log(descMatch(/.+/).findOnce().desc()); /* e.g. Restart icon */
+```
+
+别名属性或方法:
+
+- `[m#]` getContentDescription
+
+## [m#] content
+
+### content()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [string](dataTypes#string) }
+
+返回控件内容 (包括内容描述标签或本文内容).
+
+若无内容, 返回空字符串.
+
+`content` 方法相当于 `w.desc() || w.text()`, 即优先获取 [desc](#m-desc) 返回的内容, 若为 null, 继续获取 [text](#m-text) 返回的内容.
+
+```js
+console.log(contentMatch(/.+/).findOnce().content()); /* e.g. Avatar */
+```
+
+## [m#] className
+
+### className()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [string](dataTypes#string) | [null](dataTypes#null) }
+
+返回控件的类名.
+
+若如类名, 返回 null.
+
+```js
+console.log(classNameMatch(/.+/).findOnce().className()); /* e.g. android.widget.EditText */
+```
+
+常见类名:
+
+- android.view.View
+- android.view.ViewGroup
+- android.widget.ImageView
+- android.widget.ImageButton
+- android.widget.Button
+- android.widget.ScrollView
+- android.widget.TextView
+- android.widget.EditText
+- android.widget.Switch
+- android.widget.LinearLayout
+- android.widget.FrameLayout
+- android.widget.RelativeLayout
+
+别名属性或方法:
+
+- `[m#]` getClassName
+
+## [m#] packageName
+
+### packageName()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [string](dataTypes#string) | [null](dataTypes#null) }
+
+返回控件的包名.
+
+若如包名, 返回 null.
+
+```js
+console.log(packageNameMatch(/.+/).findOnce().packageName()); /* e.g. org.autojs.autojs6 */
+```
+
+别名属性或方法:
+
+- `[m#]` getPackageName
+
+## [m#] depth
+
+### depth()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回 [控件层级](glossaries#控件层级) 深度.
+
+顶层控件 (只有一个) 的深度值为 0, 次级控件 (可能有多个) 的深度值全部为 1, 以此类推.
+
+```js
+console.log(findOnce().depth()); // 0
+console.log(contentMatch(/.+/).depth()); /* e.g. 5 */
+```
+
+## [m#] checkable
+
+### checkable()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+返回控件是否可勾选.
+
+别名属性或方法:
+
+- `[m#]` isCheckable
+
+关联属性或方法:
+
+- 检查状态
+    - `[m#]` [checked](#m-checked) (isChecked)
+- 检查可用性
+    - `[m#]` [checkable](#m-checkable) (isCheckable)
+
+## [m#] checked
+
+### checked()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+返回控件是否已勾选.
+
+别名属性或方法:
+
+- `[m#]` isChecked
+
+关联属性或方法:
+
+- 检查状态
+    - `[m#]` [checked](#m-checked) (isChecked)
+- 检查可用性
+    - `[m#]` [checkable](#m-checkable) (isCheckable)
+
+## [m#] focusable
+
+### focusable()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+返回控件是否可聚焦.
+
+别名属性或方法:
+
+- `[m#]` isFocusable
+
+关联属性或方法:
+
+- 检查状态
+    - `[m#]` [focused](#m-focused) (isFocused)
+- 检查可用性
+    - `[m#]` [focusable](#m-focusable) (isFocusable)
+
+## [m#] focused
+
+### focused()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+返回控件是否已聚焦.
+
+别名属性或方法:
+
+- `[m#]` isFocused
+
+关联属性或方法:
+
+- 检查状态
+    - `[m#]` [focused](#m-focused) (isFocused)
+- 检查可用性
+    - `[m#]` [focusable](#m-focusable) (isFocusable)
+
+## [m#] visibleToUser
+
+### visibleToUser()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+返回控件是否对用户可见.
+
+别名属性或方法:
+
+- `[m#]` isVisibleToUser
+
+## [m#] accessibilityFocused
+
+### accessibilityFocused()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+返回控件是否已获取无障碍焦点.
+
+别名属性或方法:
+
+- `[m#]` isAccessibilityFocused
+
+关联属性或方法:
+
+- 检查状态
+    - `[m#]` [accessibilityFocused](#m-accessibilityfocused) (isAccessibilityFocused)
+- 执行行为
+    - `[m#]` [accessibilityFocus](uiObjectActionsType#m-accessibilityfocus)
+
+## [m#] selected
+
+### selected()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+返回控件是否已选中.
+
+别名属性或方法:
+
+- `[m#]` isSelected
+
+关联属性或方法:
+
+- 检查状态
+    - `[m#]` [selected](#m-selected) (isSelected)
+- 执行行为
+    - `[m#]` [select](uiObjectActionsType#m-select)
+
+## [m#] clickable
+
+### clickable()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+返回控件是否可点击.
+
+别名属性或方法:
+
+- `[m#]` isClickable
+
+关联属性或方法:
+
+- 检查状态
+    - `[m#]` [clickable](#m-clickable) (isClickable)
+- 执行行为
+    - `[m#]` [click](uiObjectActionsType#m-click)
+
+## [m#] longClickable
+
+### longClickable()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+返回控件是否可长按.
+
+别名属性或方法:
+
+- `[m#]` isLongClickable
+
+关联属性或方法:
+
+- 检查状态
+    - `[m#]` [longClickable](#m-longclickable) (isLongClickable)
+- 执行行为
+    - `[m#]` [longClick](uiObjectActionsType#m-longclick)
+
+## [m#] enabled
+
+### enabled()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+返回控件是否启用 (未被禁用).
+
+别名属性或方法:
+
+- `[m#]` isEnabled
+
+## [m#] password
+
+### password()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+返回控件是否是密码型控件.
+
+别名属性或方法:
+
+- `[m#]` isPassword
+
+## [m#] scrollable
+
+### scrollable()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+返回控件是否可滚动.
+
+别名属性或方法:
+
+- `[m#]` isScrollable
+
+关联属性或方法:
+
+- 检查状态
+    - `[m#]` [scrollable](#m-scrollable) (isScrollable)
+- 执行行为
+    - `[m#]` [scrollBackward](uiObjectActionsType#m-scrollbackward)
+    - `[m#]` [scrollDown](uiObjectActionsType#m-scrolldown)
+    - `[m#]` [scrollForward](uiObjectActionsType#m-scrollforward)
+    - `[m#]` [scrollLeft](uiObjectActionsType#m-scrollleft)
+    - `[m#]` [scrollRight](uiObjectActionsType#m-scrollright)
+    - `[m#]` [scrollTo](uiObjectActionsType#m-scrollto)
+    - `[m#]` [scrollUp](uiObjectActionsType#m-scrollup)
+
+## [m#] editable
+
+### editable()
+
+**`6.2.0`** **`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+返回控件是否可编辑.
+
+别名属性或方法:
+
+- `[m#]` isEditable
+
+## [m#] rowCount
+
+### rowCount()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+返回 [信息集控件](glossaries#信息集控件) 的行数.
+
+## [m#] columnCount
+
+### columnCount()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+返回 [信息集控件](glossaries#信息集控件) 的列数.
+
+## [m#] row
+
+### row()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+返回 [子项信息集控件](glossaries#子项信息集控件) 所在行的索引值.
+
+## [m#] column
+
+### column()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+返回 [子项信息集控件](glossaries#子项信息集控件) 所在列的索引值.
+
+## [m#] rowSpan
+
+### rowSpan()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+返回 [子项信息集控件](glossaries#子项信息集控件) 纵跨的行数.
+
+## [m#] columnSpan
+
+### columnSpan()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+返回 [子项信息集控件](glossaries#子项信息集控件) 横跨的列数.
+
+## [m#] drawingOrder
+
+### drawingOrder()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [number](dataTypes#number) }
+
+返回节点的视图绘制次序.
+
+此次序由其父节点决定, 是一个相对于其兄弟节点的索引值.  
+在某些情况下, 视图 (View) 绘制的过程本质上是同时发生的, 两个兄弟节点可能返回同一个索引值, 甚至此索引值可能被忽略 (返回默认值 0).
+
+```js
+console.log(pickup(/.+/).drawingOrder()); // e.g. 0
+```
+
+## [m#] actionNames
+
+### actionNames()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [string](dataTypes#string)[[]](dataTypes#array) }
+
+返回控件支持的 [控件行为](uiObjectActionsType) 数组.
+
+```js
+let w = pickup(/.+/);
+
+/* e.g. [ ACTION_CLICK, ACTION_SET_SELECTION, ACTION_FOCUS ] */
+console.log(w.actionNames());
+```
+
+上述示例, 数组中的三个元素代表控件可以执行对应的行为, 即 `w.click()`, `w.setSelection(...)` 及 `w.focus()`.
+
+数组中的元素均为 "ACTION_" 开头的控件行为 ID 的字符串形式.  
+更多控件行为 ID 可参阅 [控件节点行为](uiObjectActionsType) 章节的 `行为 ID` 表格.
+
+如需判断一个控件是否支持一个或多个行为, 可使用 [hasAction](#m-hasaction) 方法.
+
+## [m#] hasAction
+
+### hasAction(...actions)
+
+**`A11Y`**
+
+- **actions** { [...](documentation#可变参数)[string](dataTypes#string)[[]](documentation#可变参数) }
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+返回控件是否 **全部支持** 指定的一个或多个 [控件行为](uiObjectActionsType).
+
+参数 actions 是 [可变参数](documentation#可变参数), 均满足 "ACTION_" 开头的控件行为 ID 的字符串形式 ("ACTION_" 可省略).
+
+```js
+let w = pickup(/.+/);
+
+/* 判断 w 是否可点击. */
+console.log(w.hasAction("ACTION_CLICK"));
+console.log(w.hasAction("CLICK")); /* ACTION_ 前缀可省略. */
+
+/* 判断 w 是否可点击, 可聚焦, 可设置文本. */
+console.log(w.hasAction("ACTION_CLICK", "ACTION_FOCUS", "ACTION_SET_TEXT"));
+console.log(w.hasAction("CLICK", "FOCUS", "SET_TEXT")); /* ACTION_ 前缀可省略. */
+```
+
+更多控件行为 ID 可参阅 [控件节点行为](uiObjectActionsType) 章节的 `行为 ID` 表格.
+
+## [m#] performAction
+
+用于执行指定的控件行为.  
+在 [控件节点行为](uiObjectActionsType) 章节已详细描述相关内容, 此处仅注明几个重载方法的签名, 相关内容将不再赘述.
+
+### performAction(action, ...arguments)
+
+**`Overload 1/2`** **`A11Y`**
+
+- **action** { [number](dataTypes#number) } - 行为的唯一标志符 (Action ID)
+- **arguments** { [...](documentation#可变参数)[ActionArgument](uiObjectActionsType#i-actionargument)[[]](documentation#可变参数) } - 行为参数, 用于给行为传递参数
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+### performAction(action, bundle)
+
+**`Overload 2/2`** **`A11Y`**
+
+- **action** { [number](dataTypes#number) } - 行为的唯一标志符 (Action ID)
+- **bundle** { [AndroidBundle](uiObjectActionsType#i-actionargument) } - 行为参数容器, 用于给行为传递参数
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+## [m#] click
+
+### click()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 点击 ] 行为](uiObjectActionsType#m-click).
+
+## [m#] longClick
+
+### longClick()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 长按 ] 行为](uiObjectActionsType#m-longclick).
+
+## [m#] accessibilityFocus
+
+### accessibilityFocus()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 获取无障碍焦点 ] 行为](uiObjectActionsType#m-accessibilityfocus).
+
+## [m#] clearAccessibilityFocus
+
+### clearAccessibilityFocus()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 清除无障碍焦点 ] 行为](uiObjectActionsType#m-clearaccessibilityfocus).
+
+## [m#] focus
+
+### focus()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 获取焦点 ] 行为](uiObjectActionsType#m-focus).
+
+## [m#] clearFocus
+
+### clearFocus()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 清除焦点 ] 行为](uiObjectActionsType#m-clearfocus).
+
+## [m#] dragStart
+
+### dragStart()
+
+**`6.2.0`** **`A11Y`** **`API>=32`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 拖放开始 ] 行为](uiObjectActionsType#m-dragstart).
+
+## [m#] dragDrop
+
+### dragDrop()
+
+**`6.2.0`** **`A11Y`** **`API>=32`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 拖放放下 ] 行为](uiObjectActionsType#m-dragdrop).
+
+## [m#] dragCancel
+
+### dragCancel()
+
+**`6.2.0`** **`A11Y`** **`API>=32`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 拖放取消 ] 行为](uiObjectActionsType#m-dragcancel).
+
+## [m#] imeEnter
+
+### imeEnter()
+
+**`6.2.0`** **`A11Y`** **`API>=30`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 输入法 ENTER 键 ] 行为](uiObjectActionsType#m-imeenter).
+
+## [m#] moveWindow
+
+### moveWindow(x, y)
+
+**`6.2.0`** **`A11Y`** **`API>=26`**
+
+- **x** { [number](dataTypes#number) } - X 坐标
+- **y** { [number](dataTypes#number) } - Y 坐标
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 移动窗口到新位置 ] 行为](uiObjectActionsType#m-movewindow).
+
+## [m#] nextAtMovementGranularity
+
+### nextAtMovementGranularity(granularity, isExtendSelection)
+
+**`6.2.0`** **`A11Y`**
+
+- **granularity** { [number](dataTypes#number) } - 粒度
+- **isExtendSelection** { [boolean](dataTypes#boolean) } - 是否扩展选则文本
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 按粒度移至下一位置 ] 行为](uiObjectActionsType#m-nextatmovementgranularity).
+
+## [m#] nextHtmlElement
+
+### nextHtmlElement(element)
+
+**`6.2.0`** **`A11Y`**
+
+- **element** { [string](dataTypes#string) } - 元素名称
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 按元素移至下一位置 ] 行为](uiObjectActionsType#m-nexthtmlelement).
+
+## [m#] pageLeft
+
+### pageLeft()
+
+**`6.2.0`** **`A11Y`** **`API>=29`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 使视窗左移的翻页 ] 行为](uiObjectActionsType#m-pageleft).
+
+## [m#] pageUp
+
+### pageUp()
+
+**`6.2.0`** **`A11Y`** **`API>=29`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 使视窗上移的翻页 ] 行为](uiObjectActionsType#m-pageup).
+
+## [m#] pageRight
+
+### pageRight()
+
+**`6.2.0`** **`A11Y`** **`API>=29`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 使视窗右移的翻页 ] 行为](uiObjectActionsType#m-pageright).
+
+## [m#] pageDown
+
+### pageDown()
+
+**`6.2.0`** **`A11Y`** **`API>=29`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 使视窗下移的翻页 ] 行为](uiObjectActionsType#m-pagedown).
+
+## [m#] pressAndHold
+
+### pressAndHold()
+
+**`6.2.0`** **`A11Y`** **`API>=30`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 按住 ] 行为](uiObjectActionsType#m-pressandhold).
+
+## [m#] previousAtMovementGranularity
+
+### previousAtMovementGranularity(granularity, isExtendSelection)
+
+**`6.2.0`** **`A11Y`**
+
+- **granularity** { [number](dataTypes#number) } - 粒度
+- **isExtendSelection** { [boolean](dataTypes#boolean) } - 是否扩展选则文本
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 按粒度移至上一位置 ] 行为](uiObjectActionsType#m-previousatmovementgranularity).
+
+## [m#] previousHtmlElement
+
+### previousHtmlElement(element)
+
+**`6.2.0`** **`A11Y`**
+
+- **element** { [string](dataTypes#string) } - 元素名称
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 按元素移至上一位置 ] 行为](uiObjectActionsType#m-previoushtmlelement).
+
+## [m#] showTextSuggestions
+
+### showTextSuggestions()
+
+**`6.2.0`** **`A11Y`** **`API>=33`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 显示文本建议 ] 行为](uiObjectActionsType#m-showtextsuggestions).
+
+## [m#] showTooltip
+
+### showTooltip()
+
+**`6.2.0`** **`A11Y`** **`API>=28`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 显示工具提示信息 ] 行为](uiObjectActionsType#m-showtooltip).
+
+## [m#] hideTooltip
+
+### hideTooltip()
+
+**`6.2.0`** **`A11Y`** **`API>=28`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 隐藏工具提示信息 ] 行为](uiObjectActionsType#m-hidetooltip).
+
+## [m#] show
+
+### show()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 显示在视窗内 ] 行为](uiObjectActionsType#m-show).
+
+## [m#] dismiss
+
+### dismiss()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 消隐 ] 行为](uiObjectActionsType#m-dismiss).
+
+## [m#] copy
+
+### copy()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 复制文本 ] 行为](uiObjectActionsType#m-copy).
+
+## [m#] cut
+
+### cut()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 剪切文本 ] 行为](uiObjectActionsType#m-cut).
+
+## [m#] paste
+
+### paste()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 粘贴文本 ] 行为](uiObjectActionsType#m-paste).
+
+## [m#] select
+
+### select()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 选中 ] 行为](uiObjectActionsType#m-select).
+
+## [m#] expand
+
+### expand()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 展开 ] 行为](uiObjectActionsType#m-expand).
+
+## [m#] collapse
+
+### collapse()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 折叠 ] 行为](uiObjectActionsType#m-collapse).
+
+## [m#] scrollLeft
+
+### scrollLeft()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 使视窗左移的滚动 ] 行为](uiObjectActionsType#m-scrollleft).
+
+## [m#] scrollUp
+
+### scrollUp()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 使视窗上移的滚动 ] 行为](uiObjectActionsType#m-scrollup).
+
+## [m#] scrollRight
+
+### scrollRight()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 使视窗右移的滚动 ] 行为](uiObjectActionsType#m-scrollright).
+
+## [m#] scrollDown
+
+### scrollDown()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 使视窗下移的滚动 ] 行为](uiObjectActionsType#m-scrolldown).
+
+## [m#] scrollForward
+
+### scrollForward()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 使视窗前移的滚动 ] 行为](uiObjectActionsType#m-scrollforward).
+
+## [m#] scrollBackward
+
+### scrollBackward()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 使视窗后移的滚动 ] 行为](uiObjectActionsType#m-scrollbackward).
+
+## [m#] scrollTo
+
+### scrollTo(row, column)
+
+**`A11Y`**
+
+- **row** { [number](dataTypes#number) } - 行序数
+- **column** { [number](dataTypes#number) } - 列序数
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 将指定位置滚动至视窗内 ] 行为](uiObjectActionsType#m-scrollto).
+
+## [m#] contextClick
+
+### contextClick()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 上下文点击 ] 行为](uiObjectActionsType#m-contextclick).
+
+## [m#] setText
+
+### setText(text)
+
+**`A11Y`**
+
+- **text** { [string](dataTypes#string) } - 文本
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 设置文本 ] 行为](uiObjectActionsType#m-settext).
+
+## [m#] setSelection
+
+### setSelection(start, end)
+
+**`A11Y`**
+
+- **start** { [number](dataTypes#number) } - 开始位置
+- **end** { [number](dataTypes#number) } - 结束位置
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 选择文本 ] 行为](uiObjectActionsType#m-setselection).
+
+## [m#] clearSelection
+
+### clearSelection()
+
+**`6.2.0`** **`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 取消选择文本 ] 行为](uiObjectActionsType#m-clearselection).
+
+## [m#] setProgress
+
+### setProgress(progress)
+
+**`A11Y`**
+
+- **progress** { [number](dataTypes#number) } - 进度值
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+控件节点执行 [[ 设置进度值 ] 行为](uiObjectActionsType#m-setprogress).
+
+## [m#] compass
+
+### compass(compassArg)
+
+**`6.2.0`** **`A11Y`**
+
+- **compassArg** { [DetectCompass](dataTypes#detectcompass) } - 罗盘参数, 用于控制罗盘定位
+- <ins>**returns**</ins> { [UiObject](uiObjectType) | [null](dataTypes#null) } - 罗盘最终定位的控件节点
+
+返回罗盘最终定位的 [控件节点](uiObjectType), 若定位失败, 返回 null.
+
+罗盘定位类似于在 [控件层级](glossaries#控件层级) 中自由移动, 最终定位在某个指定的控件节点上.
+
+```js
+let w = clickable().findOnce();
+
+console.log(w.parent()); /* 父控件. */
+console.log(w.parent().parent()); /* 二级父控件. */
+console.log(w.child(0)); /* 索引 0 (首个) 子控件. */
+console.log(w.child(2)); /* 索引 2 子控件. */
+console.log(w.child(w.childCount() - 1)); /* 末尾子控件. */
+console.log(w.parent().child(5)); /* 索引 5 兄弟控件. */
+console.log(w.parent().child(w.childCount() - 2)); /* 倒数第 2 兄弟控件. */
+console.log(w.parent().child(w.indexInParent() - 1)); /* 相邻左侧兄弟节点. */
+console.log(w.parent().child(w.indexInParent() + 1)); /* 相邻右侧兄弟节点. */
+console.log(w.parent().parent().parent().parent().child(0).child(1).child(1).child(0)); /* 多级访问. */
+
+/* 使用控件罗盘替代上述所有语句. */
+
+console.log(w.compass('p')); /* 父控件. */
+console.log(w.compass('p2')); /* 二级父控件. */
+console.log(w.compass('c0')); /* 索引 0 (首个) 子控件. */
+console.log(w.compass('c2')); /* 索引 2 子控件. */
+console.log(w.compass('c-1')); /* 末尾子控件. */
+console.log(w.compass('s5')); /* 索引 5 兄弟控件. */
+console.log(w.compass('s-2')); /* 倒数第 2 兄弟控件. */
+console.log(w.compass('s<1')); /* 相邻左侧兄弟节点. */
+console.log(w.compass('s>1')); /* 相邻右侧兄弟节点. */
+console.log(w.compass('p4c0>1>1>0')); /* 多级访问. */
+```
+
+罗盘参数有以下几类:
+
+- p: [parent (父控件)](#parent-p)
+- c: [child (子控件)](#child-c)
+- s: [sibling (兄弟控件)](#sibling-s)
+- k: [clickable (可点击控件)](#clickable-k)
+
+不同种类的罗盘参数可以重复使用或组合使用.
+
+#### parent (p)
+
+访问父控件.
+
+如 `w.parent()` 的两种罗盘定位形式:
+
+```js
+w.compass('p'); /* 较为常用. */
+w.compass('p1');
+```
+
+罗盘 `p` 可跟随一个数字, 表示层级跨度:
+
+```js
+/* 二级. */
+w.parent().parent(); /* 原始方式. */
+w.compass('pp');
+w.compass('p2'); /* 较为常用. */
+
+/* 五级. */
+w.parent().parent().parent().parent().parent(); /* 原始方式. */
+w.compass('ppppp');
+w.compass('p5'); /* 较为常用. */
+w.compass('p4p');
+w.compass('p3p2');
+w.compass('p2p1p2');
+```
+
+罗盘 `p` 每移动一次, 控件的 depth 将减少一级, 当 depth 为 0 时, 后续所有父级访问均返回 null:
+
+```js
+console.log(w.depth()); /* e.g. 23 */
+console.log(w.compass('p5').depth()); /* e.g. 18 */
+console.log(w.compass('p23').depth()); /* e.g. 0 */
+console.log(w.compass('p24')); // null
+console.log(w.compass('p40')); // null
+```
+
+罗盘 `p` 跟随负数时将抛出异常:
+
+```js
+/* e.g. java.lang.IllegalArgumentException: 无效的剩余罗盘参数: -2 */
+console.log(w.compass('p-2'));
+```
+
+`p0` 将返回控件本身:
+
+```js
+console.log(w.compass('p0') === w); // true
+```
+
+#### child (c)
+
+访问子控件.
+
+如 `w.child(0)` 的罗盘定位形式:
+
+```js
+w.compass('c0');
+```
+
+罗盘 `c` 可跟随一个整数, 表示子控件索引:
+
+```js
+/* 索引 2 子控件 */
+w.child(2);
+w.compass('c2');
+
+/* 倒数第 2 子控件. */
+w.child(w.childCount() - 2);
+w.compass('c-2');
+```
+
+连续多级子控件访问, 可使用 `cXcYcZ` 或 `cX>Y>Z` 形式:
+
+```js
+w.child(1).child(1).child(0).child(5).child(2).child(3);
+w.compass('c1c1c0c5c2c3');
+w.compass('c1>1>0>5>2>3'); /* 同上. */
+```
+
+#### sibling (s)
+
+访问兄弟控件.
+
+例如一个控件有 10 个子控件, 这些子控件互为兄弟控件, 它们拥有同一个父控件.  
+10 个子控件中, 索引为 n (n > 0 且 n < 9) 的子控件有两个相邻兄弟控件节点, 即索引为 n - 1 的左邻兄弟和索引为 n + 1 的右邻兄弟.
+
+```js
+/* 左邻兄弟节点. */
+w.parent().child(w.indexInParent() - 1);
+w.compass('s<1');
+
+/* 右邻兄弟节点. */
+w.parent().child(w.indexInParent() + 1);
+w.compass('s>1');
+
+/* 右侧第 2 个兄弟节点. */
+w.parent().child(w.indexInParent() + 2);
+w.compass('s>2');
+
+/* 索引 5 的兄弟节点. */
+w.parent().child(5);
+w.compass('s5');
+
+/* 倒数第 2 个兄弟节点. */
+w.parent().child(w.childCount() - 2);
+w.compass('s-2');
+```
+
+#### clickable (k)
+
+访问可点击控件.
+
+有些控件本身不可点击, 而是包含在一个可点击控件内部:
+
+```js
+let w = contentMatch(/.+/).findOnce();
+console.log(w.clickable()); // false
+console.log(w.parent().clickable()); // true
+```
+
+对于上述情况的控件, 通常执行 "父控件.click()" 都会达到预期, 即虽然点击的是父控件, 但实际效果和点击这个控件本身是一样的.
+
+在某些情况下, 这样的可点击父控件可能需要两级甚至更多级:
+
+```js
+let w = contentMatch(/.+/).findOnce();
+console.log(w.clickable()); // false
+console.log(w.parent().clickable()); // false
+console.log(w.parent().parent().clickable()); // false
+console.log(w.parent().parent().parent().clickable()); // false
+console.log(w.parent().parent().parent().parent().clickable()); // true
+```
+
+上述示例直到 4 级父控件才是可点击的, 对于这种情况通常需要使用循环语句结合 `clickable` 的条件检测:
+
+```js
+let w = contentMatch(/.+/).findOnce();
+let max = 5;
+let temp = w;
+while (max--) {
+    if (temp !== null && temp.clickable()) {
+        temp.click();
+        break;
+    }
+    temp = temp.parent();
+}
+```
+
+上述示例的 `max` 变量表示最多尝试的层级数, 层级数过小, 可能导致错过真正可点击的父控件, 过大则可能会得到不相关的可点击控件 (这样的控件点击后将出现非预期结果), 通常这个 `max` 建议设置为 2.
+
+将上述示例用控件罗盘表示:
+
+```js
+let w = contentMatch(/.+/).findOnce();
+let temp = w.compass('k5'); /* 5 表示尝试的最大层级数, 通常建议设置为 2. */
+if (temp !== null && temp.clickable()) {
+    temp.click();
+}
+```
+
+将上述示例用 [拾取选择器](uiSelectorType#m-pickup) 表示:
+
+```js
+pickup(/.+/, 'k5', 'click');
+```
+
+## [m] isCompass
+
+### isCompass(s)
+
+**`6.2.0`** **`A11Y`**
+
+- **s** { [string](dataTypes#string) } - 罗盘参数
+- <ins>**returns**</ins> { [UiObject](uiObjectType) | [null](dataTypes#null) }
+
+检测罗盘参数是否符合既定格式.
+
+```js
+console.log(UiObject.isCompass('p2c3')); // true
+console.log(UiObject.isCompass('p-2c3')); // true
+console.log(UiObject.isCompass('p2c-3')); // true
+console.log(UiObject.isCompass('hello')); // false
+```
+
+上述示例中的 `p-2c3` 罗盘参数, 在使用时会抛出异常, 但因符合既定格式, 故 `isCompass` 返回 `true`.
+
+## [m] ensureCompass
+
+### ensureCompass(s)
+
+**`6.2.0`** **`A11Y`**
+
+- **s** { [string](dataTypes#string) } - 罗盘参数
+- <ins>**returns**</ins> { [UiObject](uiObjectType) | [null](dataTypes#null) }
+
+确保罗盘参数符合既定格式, 若不符合则抛出异常.
+
+```js
+UiObject.ensureCompass('p2c3'); /* 无异常. */
+UiObject.ensureCompass('world'); /* 抛出异常. */
+```
+
+## [m] detect
+
+控件探测.
+
+探测相当于对控件进行一系列组合操作 (罗盘定位, 结果筛选, 参化调用, 回调处理).
+
+部分特性:
+
+- `detect` 已全局化, 支持全局使用.
+- `detect` 的首个参数固定为 [UiObject](uiObjectType) 类型.
+- [compass](#m-compass) 是 `detect` 的衍生方法.
+- [pickup](uiSelectorType#m-pickup) 的内部实现引用了 `detect` 方法.
+
+### detect(w, compass)
+
+**`6.2.0`** **`Global`** **`Overload 1/7`** **`A11Y`**
+
+- **w** { [UiObject](uiObjectType) } - 控件节点
+- **compass** { [DetectCompass](dataTypes#detectcompass) } - 罗盘参数
+- <ins>**returns**</ins> { [UiObject](uiObjectType) | [null](dataTypes#null) } - 探测后的控件节点
+
+携带 [罗盘参数](dataTypes#detectcompass) 的控件探测.
+
+相当于 [w.compass(compass)](#m-compass), 因此 `compass` 是 `detect` 的衍生方法.
+
+### detect(w, result)
+
+**`6.2.0`** **`Global`** **`Overload 2/7`** **`A11Y`**
+
+- **w** { [UiObject](uiObjectType) } - 控件节点
+- **result** { [DetectResult](dataTypes#detectresult) } - 探测结果参数
+- <ins>**returns**</ins> { [UiObject](uiObjectType) | [null](dataTypes#null) } - 探测结果
+
+携带 [探测结果参数](dataTypes#detectresult) 的控件探测.
+
+### detect(w, compass, result)
+
+**`6.2.0`** **`Global`** **`Overload 3/7`** **`A11Y`**
+
+- **w** { [UiObject](uiObjectType) } - 控件节点
+- **compass** { [DetectCompass](dataTypes#detectcompass) } - 罗盘参数
+- **result** { [DetectResult](dataTypes#detectresult) } - 探测结果参数
+- <ins>**returns**</ins> { [UiObject](uiObjectType) | [null](dataTypes#null) } - 探测结果
+
+携带 [罗盘参数](dataTypes#detectcompass) 和 [探测结果参数](dataTypes#detectresult) 的控件探测.
+
+需特别留意 compass 和 result 的顺序, 两者均为字符串时, 前者会被解析为 `罗盘参数`.
+
+```js
+console.log(w.parent().parent().child(1).child(0).bounds()); /* 潜在的空指针异常. */
+console.log(detect(w, 'p2c1>0', 'bounds')); /* 空指针安全. */
+```
+
+### detect(w, callback)
+
+**`6.2.0`** **`Global`** **`Overload 4/7`** **`A11Y`**
+
+- **w** { [UiObject](uiObjectType) } - 控件节点
+- **callback** { [DetectCallback](dataTypes#detectcallback) } - 探测回调
+- <ins>**returns**</ins> { [UiObject](uiObjectType) | [null](dataTypes#null) } - 探测回调的结果
+
+携带 [探测回调](dataTypes#detectcallback) 的控件探测.
+
+```js
+detect(pickup(/^[A-Z][a-z]+ ?\d*$/), (w) => {
+    w ? w.click() : console.warn('未找到指定控件');
+});
+```
+
+### detect(w, compass, callback)
+
+**`6.2.0`** **`Global`** **`Overload 5/7`** **`A11Y`**
+
+- **w** { [UiObject](uiObjectType) } - 控件节点
+- **compass** { [DetectCompass](dataTypes#detectcompass) } - 罗盘参数
+- **callback** { [DetectCallback](dataTypes#detectcallback) } - 探测回调
+- <ins>**returns**</ins> { [UiObject](uiObjectType) | [null](dataTypes#null) } - 探测回调的结果
+
+携带 [罗盘参数](dataTypes#detectcompass) 和 [探测回调](dataTypes#detectcallback) 的控件探测.
+
+```js
+detect(pickup(/^[A-Z][a-z]+ ?\d*$/), 'k2', (w) => {
+    w ? w.click() : console.warn('未找到指定控件');
+});
+```
+
+### detect(w, result, callback)
+
+**`6.2.0`** **`Global`** **`Overload 6/7`** **`A11Y`**
+
+- **w** { [UiObject](uiObjectType) } - 控件节点
+- **result** { [DetectResult](dataTypes#detectresult) } - 探测结果参数
+- **callback** { [DetectCallback](dataTypes#detectcallback) } - 探测回调
+- <ins>**returns**</ins> { [UiObject](uiObjectType) | [null](dataTypes#null) } - 探测回调的结果
+
+携带 [探测结果参数](dataTypes#detectresult) 和 [探测回调](dataTypes#detectcallback) 的控件探测.
+
+```js
+detect(pickup(/^[A-Z][a-z]+ ?\d*$/), 'content', (content) => {
+    content ? console.log(content) : console.warn('无文本内容或未能定位指定控件');
+});
+```
+
+### detect(w, compass, result, callback)
+
+**`6.2.0`** **`Global`** **`Overload 7/7`** **`A11Y`**
+
+- **w** { [UiObject](uiObjectType) } - 控件节点
+- **compass** { [DetectCompass](dataTypes#detectcompass) } - 罗盘参数
+- **result** { [DetectResult](dataTypes#detectresult) } - 探测结果参数
+- **callback** { [DetectCallback](dataTypes#detectcallback) } - 探测回调
+- <ins>**returns**</ins> { [UiObject](uiObjectType) | [null](dataTypes#null) } - 探测回调的结果
+
+携带 [罗盘参数](dataTypes#detectcompass), [探测结果参数](dataTypes#detectresult) 和 [探测回调](dataTypes#detectcallback) 的控件探测.
+
+需特别留意 compass 和 result 的顺序, 两者均为字符串时, 前者会被解析为 `罗盘参数`.
+
+```js
+detect(pickup({ clickable: true }), 'p2c1', 'content', (content) => {
+    content ? console.log(content) : console.warn('无文本内容或未能定位指定控件');
+});
+```
\ No newline at end of file
diff --git a/api/uiSelectorType.md b/api/uiSelectorType.md
new file mode 100644
index 0000000..0483018
--- /dev/null
+++ b/api/uiSelectorType.md
@@ -0,0 +1,6106 @@
+# 选择器 (UiSelector)
+
+UiSelector (选择器), 亦可看作是 [控件节点](uiObjectType) 的条件筛选器, 用于通过附加不同的条件, 筛选出一个或一组活动窗口中的 `控件节点`, 并做进一步处理, 如 [ 执行 [控件行为](uiObjectActionsType) (点击, 长按, 设置文本等) / 判断位置 / 获取文本内容 / 获取控件特定状态 / 在 [控件层级](glossaries#控件层级) 中进行 [罗盘](uiObjectType.md#m-compass) 导航 ] 等.
+
+```js
+text("立即开始");
+```
+
+上述示例是一个选择器, 要求控件满足文本为 "立即开始" 的条件.
+
+选择器的构建通常是基于控件属性的, 如 [ text / desc / className / action / height / id ] 等.
+
+构建式选择器调用后会返回自身类型, 因此可使用 [链式调用](https://zh.m.wikipedia.org/zh-hans/%E6%96%B9%E6%B3%95%E9%93%BE%E5%BC%8F%E8%B0%83%E7%94%A8) 构建出用于多条件筛选的选择器:
+
+```js
+text("立即开始").minHeight(0.2).clickable(true);
+```
+
+上述示例是一个多条件选择器, 要求控件同时满足三个条件: 文本为 "立即开始", 控件高度值不低于屏幕高度的 20%, 控件可点击.
+
+在当前章节, 绝大多数方法的返回值类型标均注为 "UiSelector", 它们属于可链式调用的 "选择器构建方法", 其他方法统称为 "动作", 可归纳为 "状态方法" (查看状态的动作), "查找方法" (查找控件的动作), "[行为方法](uiObjectActionsType)" (执行控件行为的动作).
+
+选择器构建方法:
+
+- [m#] text
+- [m#] desc
+- [m#] id
+- [m#] className
+- ... ...
+
+状态方法:
+
+- [m#] exists
+- [m#] toString
+
+查找方法:
+
+- [m#] findOnce
+- [m#] find
+- [m#] findOne
+- [m#] untilFindOne
+- [m#] untilFind / waitFor
+- [m] pickup
+
+行为方法:
+
+- [m#] click
+- [m#] longClick
+- [m#] focus
+- [m#] clearFocus
+- ... ...
+
+一个选择器构建之后, 需要执行一个上述 "动作" 才能发挥选择器的作用:
+
+```js
+let sel = text("立即开始").minHeight(0.2).clickable(true);
+console.log(sel.exists()); /* 查看状态的动作. */
+console.log(sel.findOnce()); /* 查找控件的动作. */
+console.log(sel.click()); /* 执行控件行为的动作. */
+```
+
+---
+
+<p style="font: bold 2em sans-serif; color: #FF7043">UiSelector</p>
+
+---
+
+## [@] UiSelector
+
+**`Global`**
+
+如需构建 UiSelector, 可使用本章节的任意 "选择器构建方法", 且它们都是全局可用的:
+
+```js
+console.log(text("立即开始") instanceof UiSelector); // true
+console.log(text("立即开始").clickable() instanceof UiSelector); // true
+```
+
+如需构建一个 "空" 选择器, 可使用 `selector` 方法:
+
+```js
+console.log(selector()); // class org.autojs.autojs.core.automator.filter.Selector
+console.log(selector() instanceof UiSelector); // true
+```
+
+当某个选择器名称与当前作用域中用户已定义的变量名称冲突时, 可利用 `selector` 方法避免冲突:
+
+```js
+/* text 选择器被覆写. */
+let text = "hello";
+
+/* text 不再是选择器. */
+console.log(text("立即开始").exists()); // TypeError: text 是 string 而非函数.
+
+/* 使用 selector() 避免命名冲突. */
+console.log(selector().text("立即开始").exists()); // e.g. true
+```
+
+## [m#] id
+
+### id(str)
+
+**`[6.2.0]`** **`Global`**
+
+- **str** { [string](dataTypes#string) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+ID 资源选择器.
+
+- 筛选条件说明: ID 资源全称或 ID 资源项名称完全匹配指定字符串
+- 关联控件属性: [id](uiObjectType#m-id)
+
+安卓资源全称格式为 `package:type/entry`, 即 `包名:类型/资源项`.  
+ID 资源全称的 `类型` 为 `id`.  
+一个有效的 ID 资源全称: `com.test:id/some_entry`.  
+其中 `com.test` 为包名, `some_entry` 为 ID 资源项名称, `com.test:id/some_entry` 为 ID 资源全称.
+
+在 AutoJs6 中, ID 资源选择器支持两种方式作为筛选条件:
+
+- ID 资源全称 (对应上述示例的 `com.test:id/some_entry`)
+- ID 资源项名称 (对应上述示例的 `some_entry`)
+
+例如对于以下 4 个控件:
+
+```js
+wA.id(); // com.test.abc:id/some_entry
+wB.id(); // com.test.abc:id/some_other_entry
+wC.id(); // com.test.jkl:id/some_entry
+wD.id(); // com.test.xyz:id/some_entry
+```
+
+`id('com.test.abc:id/some_entry')` 是一个 ID 资源全称筛选器, 可以匹配控件 `wA`.
+
+`id('com.test.xyz:id/some_entry')` 同样是 ID 资源全称筛选器, 可以匹配控件 `wD`.
+
+`id('some_entry')` 则是一个 ID 资源项名称筛选器.  
+它不包含包名信息, 匹配时只关心资源项名称, 因此 `wA`, `wC` 和 `wD` 均可匹配.  
+需额外留意上述匹配方式与 Auto.js 4.x 版本不同, 4.x 版本筛选时会考虑前台活动应用的包名.  
+如果编写的代码需兼容不同的 Auto.js 版本, 建议使用 [idEndsWith](#m-idendswith) (如 `idEndsWith('some_entry')`) 或 [idMatches](#m-idmatches) (如 `idMatches(/.*some_entry/)`).
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(id('some_entry'), '@');
+pickup({ id: 'some_entry' }, '@');
+pickup({ id: [ 'some_entry' ] }, '@');
+```
+
+> 方法变更记录
+> - 6.2.0 - 筛选条件为 ID 资源项 (非 ID 资源全称) 时, 忽略包名匹配.
+
+## [m#] idStartsWith
+
+### idStartsWith(str)
+
+**`[6.2.0]`** **`Global`**
+
+- **str** { [string](dataTypes#string) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[ID 资源选择器](#m-id) 的 [前缀匹配筛选器](#xxxstartswith).
+
+- 筛选条件说明: ID 资源全称前缀或 ID 资源项名称前缀匹配指定字符串
+- 关联控件属性: [id](uiObjectType#m-id)
+
+在 AutoJs6 中, ID 资源前缀匹配筛选器支持两种方式作为筛选条件:
+
+- ID 资源全称 (如 `com.test:id/some_entry`)
+- ID 资源项名称 (如 `some_entry`)
+
+例如对于以下 4 个控件:
+
+```js
+wA.id(); // com.test.abc:id/some_entry
+wB.id(); // com.test.abc:id/some_other_entry
+wC.id(); // com.test.jkl:id/some_entry
+wD.id(); // com.test.xyz:id/some_entry
+```
+
+`idStartsWith('com.test.abc:id/some_')` 是一个包含包名的 ID 前缀匹配筛选器, 可以匹配控件 `wA` 和 `wB`.
+
+`idStartsWith('com.test.xyz:id/some_')` 同样是一个包含包名的 ID 前缀匹配筛选器, 可以匹配控件 `wD`.
+
+`idStartsWith('some_')` 则是一个仅包含 ID 资源项名称的前缀匹配筛选器.  
+它不包含包名信息, 匹配时只关心资源项名称, 因此 `wA`, `wB`, `wC` 和 `wD` 均可匹配.  
+需额外留意上述匹配方式与 Auto.js 4.x 版本不同, 4.x 版本筛选时会考虑前台活动应用的包名.  
+如果编写的代码需兼容不同的 Auto.js 版本, 建议使用 [idMatches](#m-idmatches) (如 `idMatches(/.*some_.*/)`).
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(idStartsWith('some_'), '@');
+pickup({ idStartsWith: 'some_' }, '@');
+pickup({ idStartsWith: [ 'some_' ] }, '@');
+```
+
+> 方法变更记录
+> - 6.2.0 - 筛选条件为 ID 资源项 (非 ID 资源全称) 时, 忽略包名匹配.
+
+## [m#] idEndsWith
+
+### idEndsWith(str)
+
+**`Global`**
+
+- **str** { [string](dataTypes#string) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[ID 资源选择器](#m-id) 的 [后缀匹配筛选器](#xxxendswith).
+
+- 筛选条件说明: ID 资源全称后缀匹配指定字符串
+- 关联控件属性: [id](uiObjectType#m-id)
+
+例如对于以下 4 个控件:
+
+```js
+wA.id(); // com.test.abc:id/some_entry
+wB.id(); // com.test.abc:id/some_other_entry
+wC.id(); // com.test.jkl:id/some_entry
+wD.id(); // com.test.xyz:id/some_entry
+```
+
+`idEndsWith('abc')` 不可匹配上述任何控件.
+
+`idEndsWith('some_entry')` 可以匹配控件 `wA`, `wC` 和 `wD`.
+
+`idEndsWith('_entry')` 可以匹配控件 `wA`, `wB`, `wC` 和 `wD`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(idEndsWith('_entry'), '@');
+pickup({ idEndsWith: '_entry' }, '@');
+pickup({ idEndsWith: [ '_entry' ] }, '@');
+```
+
+## [m#] idContains
+
+### idContains(str)
+
+**`Global`**
+
+- **str** { [string](dataTypes#string) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[ID 资源选择器](#m-id) 的 [包含匹配筛选器](#xxxcontains).
+
+- 筛选条件说明: ID 资源全称任意长度连续匹配指定字符串
+- 关联控件属性: [id](uiObjectType#m-id)
+
+ID 资源包含匹配筛选器在筛选时, 将同时对 `ID 资源全称` 和 `ID 资源项名称` 进行筛选.
+
+例如对于以下 4 个控件:
+
+```js
+wA.id(); // com.test.abc:id/some_entry
+wB.id(); // com.test.abc:id/some_other_entry
+wC.id(); // com.test.jkl:id/some_entry
+wD.id(); // com.test.xyz:id/some_entry
+```
+
+`idContains('abc')` 可以匹配控件 `wA` 和 `wB`, 因为 `'abc'` 匹配了它们的 ID 资源包名.
+
+`idContains('com.test.')` 可以匹配控件 `wA`, `wB`, `wC` 和 `wD`, 因为 `'com.test.'` 匹配了它们的 ID 资源包名.
+
+`idContains('other')` 可以匹配控件 `wB`, 因为 `'other'` 匹配了它的 ID 资源项名称.
+
+`idContains('some_')` 则可以匹配控件 `wA`, `wB`, `wC` 和 `wD`, 因为 `'some_'` 匹配了它们的 ID 资源项名称.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(idContains('some_'), '@');
+pickup({ idContains: 'some_' }, '@');
+pickup({ idContains: [ 'some_' ] }, '@');
+```
+
+## [m#] idMatches
+
+### idMatches(regex)
+
+**`Global`** **`DEPRECATED`**
+
+- **regex** { [string](dataTypes#string) | [RegExp](dataTypes.md#regexp) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[ID 资源选择器](#m-id) 的 [正则全匹配筛选器](#xxxmatches).
+
+- 筛选条件说明: ID 资源全称的正则表达式规则完全匹配指定参数
+- 关联控件属性: [id](uiObjectType#m-id)
+
+ID 正则全匹配筛选器在筛选时, 将同时对 `ID 资源全称` 和 `ID 资源项名称` 进行筛选.
+
+例如对于以下 4 个控件:
+
+```js
+wA.id(); // com.test.abc:id/some_entry
+wB.id(); // com.test.abc:id/some_other_entry
+wC.id(); // com.test.jkl:id/some_entry
+wD.id(); // com.test.xyz:id/some_entry
+```
+
+`idMatches(/abc/)` 或 `idMatches('abc')` 不可匹配上述任何控件 (因为 `idMatches(/abc/)` 相当于 `idMatch(/^abc$/)`).
+
+`idMatches(/com\.test\..+/)` 或 `idMatches('com\\.test\\..+')` 可以匹配控件 `wA`, `wB`, `wC` 和 `wD`, 因为 `/^com\.test\..+$/` 匹配了它们的 ID 资源包名.
+
+`idMatches(/other/)` 或 `idMatches('other')` 不可匹配上述任何控件.
+
+`idMatches(/.*other.*/)` 或 `idMatches('.*other.*')` 可以匹配控件 `wB`, 因为 `/^.*other.*$/` 匹配了它的 ID 资源项名称.
+
+`idMatches(/some_/)` 或 `idMatches('some_')` 不可匹配上述任何控件.
+
+`idMatches(/.*some_.*/)` 或 `idMatches('.*some_.*')` 可以匹配控件 `wA`, `wB`, `wC` 和 `wD`, 因为 `/^.*some_.*$/` 匹配了它们的 ID 资源项名称.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(idMatches(/.*some_.*/), '@');
+pickup({ idMatches: /.*some_.*/ }, '@');
+pickup({ idMatches: [ /.*some_.*/ ] }, '@');
+```
+
+> 注: 自 6.2.0 版本起, idMatches 已弃用, 建议使用 [idMatch](#m-idmatch), 详情参阅 [正则全匹配筛选器](#xxxmatches) 小节.
+
+## [m#] idMatch
+
+### idMatch(regex)
+
+**`6.2.0`** **`Global`**
+
+- **regex** { [string](dataTypes#string) | [RegExp](dataTypes.md#regexp) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[ID 资源选择器](#m-id) 的 [正则匹配筛选器](#xxxmatch).
+
+- 筛选条件说明: ID 资源全称的正则表达式规则匹配指定参数
+- 关联控件属性: [id](uiObjectType#m-id)
+
+ID 正则匹配筛选器在筛选时, 将同时对 `ID 资源全称` 和 `ID 资源项名称` 进行筛选.
+
+例如对于以下 4 个控件:
+
+```js
+wA.id(); // com.test.abc:id/some_entry
+wB.id(); // com.test.abc:id/some_other_entry
+wC.id(); // com.test.jkl:id/some_entry
+wD.id(); // com.test.xyz:id/some_entry
+```
+
+`idMatch(/abc/)` 或 `idMatch('abc')` 可以匹配控件 `wA` 和 `wB`, 因为 `/abc/` 匹配了它们的 ID 资源包名.
+
+`idMatch(/com\.test\..+/)` 或 `idMatch('com\\.test\\..+')` 可以匹配控件 `wA`, `wB`, `wC` 和 `wD`, 因为 `/com\.test\..+/` 匹配了它们的 ID 资源包名.
+
+`idMatch(/other/)` 或 `idMatch('other')` 可以匹配控件 `wB`, 因为 `/other/` 匹配了它的 ID 资源项名称.
+
+`idMatch(/some_/)` 或 `idMatch('some_')` 可以匹配控件 `wA`, `wB`, `wC` 和 `wD`, 因为 `/some_/` 匹配了它们的 ID 资源项名称.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(idMatch(/some_/), '@');
+pickup({ idMatch: /some_/ }, '@');
+pickup({ idMatch: [ /some_/ ] }, '@');
+```
+
+## [m#] idHex
+
+### idHex(str)
+
+**`6.2.0`** **`Global`**
+
+- **str** { [string](dataTypes#string) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[ID 资源十六进制代表值](uiObjectType#m-idhex) 选择器.
+
+```js
+console.log(idHex('0x7f090117').findOnce().idEntry()); /* e.g. explorer_item_list */
+```
+
+## [m#] text
+
+### text(str)
+
+**`Global`**
+
+- **str** { [string](dataTypes#string) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+文本选择器.
+
+- 筛选条件说明: 文本完全匹配指定字符串
+- 关联控件属性: [text](uiObjectType#m-text)
+
+例如对于以下 4 个控件:
+
+```js
+wA.text(); // start
+wB.text(); // Service Notification
+wC.text(); // Contacts
+wD.text(); // Coconuts
+```
+
+`text('Coconuts')` 是一个文本选择器, 可以匹配控件 `wD`.
+
+`text('start')` 同样是一个文本选择器, 可以匹配控件 `wA`.  
+但 `text('START')` 不能匹配上述任何控件, 因为文本匹配是大小写敏感的.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(text('start'), '@');
+pickup({ text: 'start' }, '@');
+pickup({ text: [ 'start' ] }, '@');
+```
+
+## [m#] textStartsWith
+
+### textStartsWith(str)
+
+**`Global`**
+
+- **str** { [string](dataTypes#string) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[文本选择器](#m-text) 的 [前缀匹配筛选器](#xxxstartswith).
+
+- 筛选条件说明: 文本前缀匹配指定字符串
+- 关联控件属性: [text](uiObjectType#m-text)
+
+例如对于以下 4 个控件:
+
+```js
+wA.text(); // start
+wB.text(); // Service Notification
+wC.text(); // Contacts
+wD.text(); // Coconuts
+```
+
+`textStartsWith('Co')` 是一个文本选择器, 可以匹配控件 `wC` 和 `wD`.
+
+`textStartsWith('star')` 同样是一个文本选择器, 可以匹配控件 `wA`, 注意文本匹配是大小写敏感的.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(textStartsWith('star'), '@');
+pickup({ textStartsWith: 'star' }, '@');
+pickup({ textStartsWith: [ 'star' ] }, '@');
+```
+
+## [m#] textEndsWith
+
+### textEndsWith(str)
+
+**`Global`**
+
+- **str** { [string](dataTypes#string) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[文本选择器](#m-text) 的 [后缀匹配筛选器](#xxxendswith).
+
+- 筛选条件说明: 文本后缀匹配指定字符串
+- 关联控件属性: [text](uiObjectType#m-text)
+
+例如对于以下 4 个控件:
+
+```js
+wA.text(); // start
+wB.text(); // Service Notification
+wC.text(); // Contacts
+wD.text(); // Coconuts
+```
+
+`textEndsWith('vice')` 不可匹配上述任何控件.
+
+`textEndsWith('ts')` 可以匹配控件 `wC` 和 `wD`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(textEndsWith('ts'), '@');
+pickup({ textEndsWith: 'ts' }, '@');
+pickup({ textEndsWith: [ 'ts' ] }, '@');
+```
+
+## [m#] textContains
+
+### textContains(str)
+
+**`Global`**
+
+- **str** { [string](dataTypes#string) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[文本选择器](#m-text) 的 [包含匹配筛选器](#xxxcontains).
+
+- 筛选条件说明: 文本任意长度连续匹配指定字符串
+- 关联控件属性: [text](uiObjectType#m-text)
+
+例如对于以下 4 个控件:
+
+```js
+wA.text(); // start
+wB.text(); // Service Notification
+wC.text(); // Contacts
+wD.text(); // Coconuts
+```
+
+`textContains('t')` 可以匹配控件 `wA`, `wB`, `wC` 和 `wD`.
+
+`textContains('on')` 可以匹配控件 `wB` 和 `wC`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(textContains('on'), '@');
+pickup({ textContains: 'on' }, '@');
+pickup({ textContains: [ 'on' ] }, '@');
+```
+
+## [m#] textMatches
+
+### textMatches(regex)
+
+**`Global`** **`DEPRECATED`**
+
+- **regex** { [string](dataTypes#string) | [RegExp](dataTypes.md#regexp) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[文本选择器](#m-text) 的 [正则全匹配筛选器](#xxxmatches).
+
+- 筛选条件说明: 文本的正则表达式规则完全匹配指定参数
+- 关联控件属性: [text](uiObjectType#m-text)
+
+例如对于以下 4 个控件:
+
+```js
+wA.text(); // start
+wB.text(); // Service Notification
+wC.text(); // Contacts
+wD.text(); // Coconuts
+```
+
+`textMatches(/star/)` 或 `textMatches('star')` 不可匹配上述任何控件 (因为 `textMatches(/star/)` 相当于 `textMatch(/^star$/)`).
+
+`textMatches(/Co\w+ts/)` 或 `textMatches('Co\\w+ts')` 可以匹配控件 `wC` 和 `wD`, 因为 `/^Co\w+ts$/` 匹配了它们的文本.
+
+`textMatches(/cat/)` 或 `textMatches('cat')` 不可匹配上述任何控件.
+
+`textMatches(/.*cat.*/)` 或 `textMatches('.*cat.*')` 可以匹配控件 `wB`, 因为 `/^.*cat.*$/` 匹配了它的文本.
+
+`textMatches(/t\w{0,3}/)` 或 `textMatches('t\\w{0,3}')` 不可匹配上述任何控件.
+
+`textMatches(/.*t\w{0,3}/)` 或 `textMatches('.*t\\w{0,3}')` 可以匹配控件 `wA`, `wB`, `wC` 和 `wD`, 因为 `/^.*t\w{0,3}$/` 匹配了它们的文本.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(textMatches(/.*t\w{0,3}/), '@');
+pickup({ textMatches: /.*t\w{0,3}/ }, '@');
+pickup({ textMatches: [ /.*t\w{0,3}/ ] }, '@');
+```
+
+> 注: 自 6.2.0 版本起, textMatches 已弃用, 建议使用 [textMatch](#m-textmatch), 详情参阅 [正则全匹配筛选器](#xxxmatches) 小节.
+
+## [m#] textMatch
+
+### textMatch(regex)
+
+**`6.2.0`** **`Global`**
+
+- **regex** { [string](dataTypes#string) | [RegExp](dataTypes.md#regexp) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[文本选择器](#m-text) 的 [正则匹配筛选器](#xxxmatch).
+
+- 筛选条件说明: 文本的正则表达式规则匹配指定参数
+- 关联控件属性: [text](uiObjectType#m-text)
+
+例如对于以下 4 个控件:
+
+```js
+wA.text(); // start
+wB.text(); // Service Notification
+wC.text(); // Contacts
+wD.text(); // Coconuts
+```
+
+`textMatch(/star/)` 或 `textMatch('star')` 可以匹配 `wA` 控件.
+
+`textMatch(/Co\w+ts/)` 或 `textMatch('Co\\w+ts')` 可以匹配控件 `wC` 和 `wD`.
+
+`textMatch(/cat/)` 或 `textMatch('cat')` 可以匹配 `wB` 控件.
+
+`textMatch(/t\w{0,3}/)` 或 `textMatch('t\\w{0,3}')` 可以匹配控件 `wA`, `wB`, `wC` 和 `wD`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(textMatch(/t\w{0,3}/), '@');
+pickup({ textMatch: /t\w{0,3}/ }, '@');
+pickup({ textMatch: [ /t\w{0,3}/ ] }, '@');
+```
+
+## [m#] desc
+
+### desc(str)
+
+**`Global`**
+
+- **str** { [string](dataTypes#string) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+内容描述标签选择器.
+
+- 筛选条件说明: 内容描述标签完全匹配指定字符串
+- 关联控件属性: [desc](uiObjectType#m-desc)
+
+例如对于以下 4 个控件:
+
+```js
+wA.desc(); // start
+wB.desc(); // Service Notification
+wC.desc(); // Contacts
+wD.desc(); // Coconuts
+```
+
+`desc('Coconuts')` 是一个内容描述标签选择器, 可以匹配控件 `wD`.
+
+`desc('start')` 同样是一个内容描述标签选择器, 可以匹配控件 `wA`.  
+但 `desc('START')` 不能匹配上述任何控件, 因为内容描述标签匹配是大小写敏感的.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(desc('start'), '@');
+pickup({ desc: 'start' }, '@');
+pickup({ desc: [ 'start' ] }, '@');
+```
+
+## [m#] descStartsWith
+
+### descStartsWith(str)
+
+**`Global`**
+
+- **str** { [string](dataTypes#string) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[内容描述标签选择器](#m-desc) 的 [前缀匹配筛选器](#xxxstartswith).
+
+- 筛选条件说明: 内容描述标签前缀匹配指定字符串
+- 关联控件属性: [desc](uiObjectType#m-desc)
+
+例如对于以下 4 个控件:
+
+```js
+wA.desc(); // start
+wB.desc(); // Service Notification
+wC.desc(); // Contacts
+wD.desc(); // Coconuts
+```
+
+`descStartsWith('Co')` 是一个内容描述标签选择器, 可以匹配控件 `wC` 和 `wD`.
+
+`descStartsWith('star')` 同样是一个内容描述标签选择器, 可以匹配控件 `wA`, 注意内容描述标签匹配是大小写敏感的.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(descStartsWith('star'), '@');
+pickup({ descStartsWith: 'star' }, '@');
+pickup({ descStartsWith: [ 'star' ] }, '@');
+```
+
+## [m#] descEndsWith
+
+### descEndsWith(str)
+
+**`Global`**
+
+- **str** { [string](dataTypes#string) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[内容描述标签选择器](#m-desc) 的 [后缀匹配筛选器](#xxxendswith).
+
+- 筛选条件说明: 内容描述标签后缀匹配指定字符串
+- 关联控件属性: [desc](uiObjectType#m-desc)
+
+例如对于以下 4 个控件:
+
+```js
+wA.desc(); // start
+wB.desc(); // Service Notification
+wC.desc(); // Contacts
+wD.desc(); // Coconuts
+```
+
+`descEndsWith('vice')` 不可匹配上述任何控件.
+
+`descEndsWith('ts')` 可以匹配控件 `wC` 和 `wD`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(descEndsWith('ts'), '@');
+pickup({ descEndsWith: 'ts' }, '@');
+pickup({ descEndsWith: [ 'ts' ] }, '@');
+```
+
+## [m#] descContains
+
+### descContains(str)
+
+**`Global`**
+
+- **str** { [string](dataTypes#string) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[内容描述标签选择器](#m-desc) 的 [包含匹配筛选器](#xxxcontains).
+
+- 筛选条件说明: 内容描述标签任意长度连续匹配指定字符串
+- 关联控件属性: [desc](uiObjectType#m-desc)
+
+例如对于以下 4 个控件:
+
+```js
+wA.desc(); // start
+wB.desc(); // Service Notification
+wC.desc(); // Contacts
+wD.desc(); // Coconuts
+```
+
+`descContains('t')` 可以匹配控件 `wA`, `wB`, `wC` 和 `wD`.
+
+`descContains('on')` 可以匹配控件 `wB` 和 `wC`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(descContains('on'), '@');
+pickup({ descContains: 'on' }, '@');
+pickup({ descContains: [ 'on' ] }, '@');
+```
+
+## [m#] descMatches
+
+### descMatches(regex)
+
+**`Global`** **`DEPRECATED`**
+
+- **regex** { [string](dataTypes#string) | [RegExp](dataTypes.md#regexp) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[内容描述标签选择器](#m-desc) 的 [正则全匹配筛选器](#xxxmatches).
+
+- 筛选条件说明: 内容描述标签的正则表达式规则完全匹配指定参数
+- 关联控件属性: [desc](uiObjectType#m-desc)
+
+例如对于以下 4 个控件:
+
+```js
+wA.desc(); // start
+wB.desc(); // Service Notification
+wC.desc(); // Contacts
+wD.desc(); // Coconuts
+```
+
+`descMatches(/star/)` 或 `descMatches('star')` 不可匹配上述任何控件 (因为 `descMatches(/star/)` 相当于 `descMatch(/^star$/)`).
+
+`descMatches(/Co\w+ts/)` 或 `descMatches('Co\\w+ts')` 可以匹配控件 `wC` 和 `wD`, 因为 `/^Co\w+ts$/` 匹配了它们的内容描述标签.
+
+`descMatches(/cat/)` 或 `descMatches('cat')` 不可匹配上述任何控件.
+
+`descMatches(/.*cat.*/)` 或 `descMatches('.*cat.*')` 可以匹配控件 `wB`, 因为 `/^.*cat.*$/` 匹配了它的内容描述标签.
+
+`descMatches(/t\w{0,3}/)` 或 `descMatches('t\\w{0,3}')` 不可匹配上述任何控件.
+
+`descMatches(/.*t\w{0,3}/)` 或 `descMatches('.*t\\w{0,3}')` 可以匹配控件 `wA`, `wB`, `wC` 和 `wD`, 因为 `/^.*t\w{0,3}$/` 匹配了它们的内容描述标签.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(descMatches(/.*t\w{0,3}/), '@');
+pickup({ descMatches: /.*t\w{0,3}/ }, '@');
+pickup({ descMatches: [ /.*t\w{0,3}/ ] }, '@');
+```
+
+> 注: 自 6.2.0 版本起, descMatches 已弃用, 建议使用 [descMatch](#m-descmatch), 详情参阅 [正则全匹配筛选器](#xxxmatches) 小节.
+
+## [m#] descMatch
+
+### descMatch(regex)
+
+**`6.2.0`** **`Global`**
+
+- **regex** { [string](dataTypes#string) | [RegExp](dataTypes.md#regexp) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[内容描述标签选择器](#m-desc) 的 [正则匹配筛选器](#xxxmatch).
+
+- 筛选条件说明: 内容描述标签的正则表达式规则匹配指定参数
+- 关联控件属性: [desc](uiObjectType#m-desc)
+
+例如对于以下 4 个控件:
+
+```js
+wA.desc(); // start
+wB.desc(); // Service Notification
+wC.desc(); // Contacts
+wD.desc(); // Coconuts
+```
+
+`descMatch(/star/)` 或 `descMatch('star')` 可以匹配 `wA` 控件.
+
+`descMatch(/Co\w+ts/)` 或 `descMatch('Co\\w+ts')` 可以匹配控件 `wC` 和 `wD`.
+
+`descMatch(/cat/)` 或 `descMatch('cat')` 可以匹配 `wB` 控件.
+
+`descMatch(/t\w{0,3}/)` 或 `descMatch('t\\w{0,3}')` 可以匹配控件 `wA`, `wB`, `wC` 和 `wD`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(descMatch(/t\w{0,3}/), '@');
+pickup({ descMatch: /t\w{0,3}/ }, '@');
+pickup({ descMatch: [ /t\w{0,3}/ ] }, '@');
+```
+
+## [m#] content
+
+### content(str)
+
+**`6.2.0`** **`Global`**
+
+- **str** { [string](dataTypes#string) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+内容选择器.
+
+- 筛选条件说明: 内容完全匹配指定字符串
+- 关联控件属性: [content](uiObjectType#m-content)
+
+例如对于以下 4 个控件:
+
+```js
+wA.content(); // start
+wB.content(); // Service Notification
+wC.content(); // Contacts
+wD.content(); // Coconuts
+```
+
+`content('Coconuts')` 是一个内容选择器, 可以匹配控件 `wD`.
+
+`content('start')` 同样是一个内容选择器, 可以匹配控件 `wA`.  
+但 `content('START')` 不能匹配上述任何控件, 因为内容匹配是大小写敏感的.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(content('start'), '@');
+pickup({ content: 'start' }, '@');
+pickup({ content: [ 'start' ] }, '@');
+```
+
+## [m#] contentStartsWith
+
+### contentStartsWith(str)
+
+**`6.2.0`** **`Global`**
+
+- **str** { [string](dataTypes#string) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[内容选择器](#m-content) 的 [前缀匹配筛选器](#xxxstartswith).
+
+- 筛选条件说明: 内容前缀匹配指定字符串
+- 关联控件属性: [content](uiObjectType#m-content)
+
+例如对于以下 4 个控件:
+
+```js
+wA.content(); // start
+wB.content(); // Service Notification
+wC.content(); // Contacts
+wD.content(); // Coconuts
+```
+
+`contentStartsWith('Co')` 是一个内容选择器, 可以匹配控件 `wC` 和 `wD`.
+
+`contentStartsWith('star')` 同样是一个内容选择器, 可以匹配控件 `wA`, 注意内容匹配是大小写敏感的.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(contentStartsWith('star'), '@');
+pickup({ contentStartsWith: 'star' }, '@');
+pickup({ contentStartsWith: [ 'star' ] }, '@');
+```
+
+## [m#] contentEndsWith
+
+### contentEndsWith(str)
+
+**`6.2.0`** **`Global`**
+
+- **str** { [string](dataTypes#string) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[内容选择器](#m-content) 的 [后缀匹配筛选器](#xxxendswith).
+
+- 筛选条件说明: 内容后缀匹配指定字符串
+- 关联控件属性: [content](uiObjectType#m-content)
+
+例如对于以下 4 个控件:
+
+```js
+wA.content(); // start
+wB.content(); // Service Notification
+wC.content(); // Contacts
+wD.content(); // Coconuts
+```
+
+`contentEndsWith('vice')` 不可匹配上述任何控件.
+
+`contentEndsWith('ts')` 可以匹配控件 `wC` 和 `wD`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(contentEndsWith('ts'), '@');
+pickup({ contentEndsWith: 'ts' }, '@');
+pickup({ contentEndsWith: [ 'ts' ] }, '@');
+```
+
+## [m#] contentContains
+
+### contentContains(str)
+
+**`6.2.0`** **`Global`**
+
+- **str** { [string](dataTypes#string) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[内容选择器](#m-content) 的 [包含匹配筛选器](#xxxcontains).
+
+- 筛选条件说明: 内容任意长度连续匹配指定字符串
+- 关联控件属性: [content](uiObjectType#m-content)
+
+例如对于以下 4 个控件:
+
+```js
+wA.content(); // start
+wB.content(); // Service Notification
+wC.content(); // Contacts
+wD.content(); // Coconuts
+```
+
+`contentContains('t')` 可以匹配控件 `wA`, `wB`, `wC` 和 `wD`.
+
+`contentContains('on')` 可以匹配控件 `wB` 和 `wC`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(contentContains('on'), '@');
+pickup({ contentContains: 'on' }, '@');
+pickup({ contentContains: [ 'on' ] }, '@');
+```
+
+## [m#] contentMatches
+
+### contentMatches(regex)
+
+**`6.2.0`** **`Global`** **`DEPRECATED`**
+
+- **regex** { [string](dataTypes#string) | [RegExp](dataTypes.md#regexp) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[内容选择器](#m-content) 的 [正则全匹配筛选器](#xxxmatches).
+
+- 筛选条件说明: 内容的正则表达式规则完全匹配指定参数
+- 关联控件属性: [content](uiObjectType#m-content)
+
+例如对于以下 4 个控件:
+
+```js
+wA.content(); // start
+wB.content(); // Service Notification
+wC.content(); // Contacts
+wD.content(); // Coconuts
+```
+
+`contentMatches(/star/)` 或 `contentMatches('star')` 不可匹配上述任何控件 (因为 `contentMatches(/star/)` 相当于 `contentMatch(/^star$/)`).
+
+`contentMatches(/Co\w+ts/)` 或 `contentMatches('Co\\w+ts')` 可以匹配控件 `wC` 和 `wD`, 因为 `/^Co\w+ts$/` 匹配了它们的内容.
+
+`contentMatches(/cat/)` 或 `contentMatches('cat')` 不可匹配上述任何控件.
+
+`contentMatches(/.*cat.*/)` 或 `contentMatches('.*cat.*')` 可以匹配控件 `wB`, 因为 `/^.*cat.*$/` 匹配了它的内容.
+
+`contentMatches(/t\w{0,3}/)` 或 `contentMatches('t\\w{0,3}')` 不可匹配上述任何控件.
+
+`contentMatches(/.*t\w{0,3}/)` 或 `contentMatches('.*t\\w{0,3}')` 可以匹配控件 `wA`, `wB`, `wC` 和 `wD`, 因为 `/^.*t\w{0,3}$/` 匹配了它们的内容.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(contentMatches(/.*t\w{0,3}/), '@');
+pickup({ contentMatches: /.*t\w{0,3}/ }, '@');
+pickup({ contentMatches: [ /.*t\w{0,3}/ ] }, '@');
+```
+
+> 注: 自 6.2.0 版本起, contentMatches 已弃用, 建议使用 [contentMatch](#m-contentmatch), 详情参阅 [正则全匹配筛选器](#xxxmatches) 小节.
+
+## [m#] contentMatch
+
+### contentMatch(regex)
+
+**`6.2.0`** **`Global`**
+
+- **regex** { [string](dataTypes#string) | [RegExp](dataTypes.md#regexp) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[内容选择器](#m-content) 的 [正则匹配筛选器](#xxxmatch).
+
+- 筛选条件说明: 内容的正则表达式规则匹配指定参数
+- 关联控件属性: [content](uiObjectType#m-content)
+
+例如对于以下 4 个控件:
+
+```js
+wA.content(); // start
+wB.content(); // Service Notification
+wC.content(); // Contacts
+wD.content(); // Coconuts
+```
+
+`contentMatch(/star/)` 或 `contentMatch('star')` 可以匹配 `wA` 控件.
+
+`contentMatch(/Co\w+ts/)` 或 `contentMatch('Co\\w+ts')` 可以匹配控件 `wC` 和 `wD`.
+
+`contentMatch(/cat/)` 或 `contentMatch('cat')` 可以匹配 `wB` 控件.
+
+`contentMatch(/t\w{0,3}/)` 或 `contentMatch('t\\w{0,3}')` 可以匹配控件 `wA`, `wB`, `wC` 和 `wD`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(contentMatch(/t\w{0,3}/), '@');
+pickup({ contentMatch: /t\w{0,3}/ }, '@');
+pickup({ contentMatch: [ /t\w{0,3}/ ] }, '@');
+```
+
+## [m#] className
+
+### className(str)
+
+**`Global`**
+
+- **str** { [string](dataTypes#string) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+类名选择器.
+
+- 筛选条件说明: 类名或安卓控件类名简称完全匹配指定字符串
+- 关联控件属性: [className](uiObjectType#m-classname)
+
+在 AutoJs6 中, 类名选择器支持两种方式作为筛选条件:
+
+- 类名全称 (如 `android.widget.EditText`)
+- 安卓控件类名简称 (如 `EditText`)
+
+例如对于以下 4 个控件:
+
+```js
+wA.className(); // android.view.View
+wB.className(); // android.widget.Button
+wC.className(); // android.widget.EditText
+wD.className(); // androidx.recyclerview.widget.RecyclerView
+```
+
+`className('android.widget.Button')` 是一个类名选择器, 可以匹配控件 `wB`.  
+`className('Button')` 与上述选择器效果相同, 它使用安卓控件类名简称作为筛选条件.
+
+`className('androidx.recyclerview.widget.RecyclerView')` 同样是一个类名选择器, 可以匹配控件 `wD`.  
+但 `className('RecyclerView')` 不能匹配上述任何控件, 因为只有 `android.widget.` 开头的类名才能使用简称形式进行筛选.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(className('Button'), '@');
+pickup({ className: 'Button' }, '@');
+pickup({ className: [ 'Button' ] }, '@');
+```
+
+## [m#] classNameStartsWith
+
+### classNameStartsWith(str)
+
+**`[6.2.0]`** **`Global`**
+
+- **str** { [string](dataTypes#string) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[类名选择器](#m-classname) 的 [前缀匹配筛选器](#xxxstartswith).
+
+- 筛选条件说明: 类名前缀匹配指定字符串
+- 关联控件属性: [className](uiObjectType#m-classname)
+
+在 AutoJs6 中, 类名前缀匹配筛选器支持两种方式作为筛选条件:
+
+- 类名全称 (如 `android.widget.EditText`)
+- 安卓控件类名简称 (如 `EditText`)
+
+例如对于以下 4 个控件:
+
+```js
+wA.className(); // android.view.View
+wB.className(); // android.widget.Button
+wC.className(); // android.widget.EditText
+wD.className(); // androidx.recyclerview.widget.RecyclerView
+```
+
+`classNameStartsWith('android.widget.Bu')` 是一个类名前缀选择器, 可以匹配控件 `wB`.  
+`classNameStartsWith('Bu')` 与上述选择器效果相同, 它使用安卓控件类名简称作为筛选条件.
+
+`classNameStartsWith('androidx.recyclerview.widget.Rec')` 同样是一个类名前缀选择器, 可以匹配控件 `wD`.  
+但 `classNameStartsWith('Rec')` 不能匹配上述任何控件, 因为只有 `android.widget.` 开头的类名才能使用简称形式进行前缀筛选.
+
+需额外留意上述匹配方式与 Auto.js 4.x 版本不同, 4.x 版本在做类名前缀筛选时, 不支持简称形式.  
+如果编写的代码需兼容不同的 Auto.js 版本, 建议使用 [classNameEndsWith](#m-classnameendswith) (如 `classNameEndsWith('RecyclerView')`) 或 [classNameMatches](#m-classnamematches) (如 `classNameMatches(/.*Rec.*/)`).
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(classNameStartsWith('Rec'), '@');
+pickup({ classNameStartsWith: 'Rec' }, '@');
+pickup({ classNameStartsWith: [ 'Rec' ] }, '@');
+```
+
+> 方法变更记录
+> - 6.2.0 - 支持安卓控件类名简称作为类名前缀筛选条件.
+
+## [m#] classNameEndsWith
+
+### classNameEndsWith(str)
+
+**`Global`**
+
+- **str** { [string](dataTypes#string) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[类名选择器](#m-classname) 的 [后缀匹配筛选器](#xxxendswith).
+
+- 筛选条件说明: 类名后缀匹配指定字符串
+- 关联控件属性: [className](uiObjectType#m-classname)
+
+例如对于以下 4 个控件:
+
+```js
+wA.className(); // android.view.View
+wB.className(); // android.widget.Button
+wC.className(); // android.widget.EditText
+wD.className(); // androidx.recyclerview.widget.RecyclerView
+```
+
+`classNameEndsWith('View')` 可以匹配控件 `wA` 和 `wD`.  
+而 `classNameEndsWith('view')` 不可匹配上述任何控件, 因为类名匹配是大小写敏感的.
+
+`classNameEndsWith('Button')` 可以匹配控件 `wB`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(classNameEndsWith('Button'), '@');
+pickup({ classNameEndsWith: 'Button' }, '@');
+pickup({ classNameEndsWith: [ 'Button' ] }, '@');
+```
+
+## [m#] classNameContains
+
+### classNameContains(str)
+
+**`Global`**
+
+- **str** { [string](dataTypes#string) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[类名选择器](#m-classname) 的 [包含匹配筛选器](#xxxcontains).
+
+- 筛选条件说明: 类名任意长度连续匹配指定字符串
+- 关联控件属性: [className](uiObjectType#m-classname)
+
+例如对于以下 4 个控件:
+
+```js
+wA.className(); // android.view.View
+wB.className(); // android.widget.Button
+wC.className(); // android.widget.EditText
+wD.className(); // androidx.recyclerview.widget.RecyclerView
+```
+
+`classNameContains('android')` 可以匹配控件 `wA`, `wB`, `wC` 和 `wD`.
+
+`classNameContains('Button')` 可以匹配控件 `wB`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(classNameContains('Button'), '@');
+pickup({ classNameContains: 'Button' }, '@');
+pickup({ classNameContains: [ 'Button' ] }, '@');
+```
+
+## [m#] classNameMatches
+
+### classNameMatches(regex)
+
+**`Global`** **`DEPRECATED`**
+
+- **regex** { [string](dataTypes#string) | [RegExp](dataTypes.md#regexp) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[类名选择器](#m-classname) 的 [正则全匹配筛选器](#xxxmatches).
+
+- 筛选条件说明: 类名的正则表达式规则完全匹配指定参数
+- 关联控件属性: [className](uiObjectType#m-classname)
+
+例如对于以下 4 个控件:
+
+```js
+wA.className(); // android.view.View
+wB.className(); // android.widget.Button
+wC.className(); // android.widget.EditText
+wD.className(); // androidx.recyclerview.widget.RecyclerView
+```
+
+`classNameMatches(/EditText/)` 或 `classNameMatches('EditText')` 不可匹配上述任何控件 (因为 `classNameMatches(/EditText/)` 相当于 `classNameMatch(/^EditText$/)`).
+
+`classNameMatches(/android.+View/)` 或 `classNameMatches('android.+View')` 可以匹配控件 `wA` 和 `wD`, 因为 `/^android.+View$/` 匹配了它们的类名.
+
+`classNameMatches(/Edit/)` 或 `classNameMatches('Edit')` 不可匹配上述任何控件.
+
+`classNameMatches(/.*Edit.*/)` 或 `classNameMatches('.*Edit.*')` 可以匹配控件 `wC`, 因为 `/^.*Edit.*$/` 匹配了它的类名.
+
+`classNameMatches(/V\w{0,3}/)` 或 `classNameMatches('V\\w{0,3}')` 不可匹配上述任何控件.
+
+`classNameMatches(/.*V\w{0,3}/)` 或 `classNameMatches('.*V\\w{0,3}')` 可以匹配控件 `wA` 和 `wD`, 因为 `/^.*V\w{0,3}$/` 匹配了它们的类名.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(classNameMatches(/.*V\w{0,3}/), '@');
+pickup({ classNameMatches: /.*V\w{0,3}/ }, '@');
+pickup({ classNameMatches: [ /.*V\w{0,3}/ ] }, '@');
+```
+
+> 注: 自 6.2.0 版本起, classNameMatches 已弃用, 建议使用 [classNameMatch](#m-classnamematch), 详情参阅 [正则全匹配筛选器](#xxxmatches) 小节.
+
+## [m#] classNameMatch
+
+### classNameMatch(regex)
+
+**`6.2.0`** **`Global`**
+
+- **regex** { [string](dataTypes#string) | [RegExp](dataTypes.md#regexp) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[类名选择器](#m-classname) 的 [正则匹配筛选器](#xxxmatch).
+
+- 筛选条件说明: 类名的正则表达式规则匹配指定参数
+- 关联控件属性: [className](uiObjectType#m-classname)
+
+例如对于以下 4 个控件:
+
+```js
+wA.className(); // android.view.View
+wB.className(); // android.widget.Button
+wC.className(); // android.widget.EditText
+wD.className(); // androidx.recyclerview.widget.RecyclerView
+```
+
+`classNameMatch(/EditText/)` 或 `classNameMatch('EditText')` 可以匹配 `wC` 控件.  
+`classNameMatch(/Edit/)` 或 `classNameMatch('Edit')` 也可以匹配 `wC` 控件.
+
+`classNameMatch(/^android/)` 或 `classNameMatch('^android')` 可以匹配 `wA`, `wB`, `wC` 和 `wD` 控件.
+
+`classNameMatch(/V\w{0,3}$/)` 或 `classNameMatch('V\\w{0,3}$')` 可以匹配控件 `wA` 和 `wD`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(classNameMatch(/V\w{0,3}$/), '@');
+pickup({ classNameMatch: /V\w{0,3}$/ }, '@');
+pickup({ classNameMatch: [ /V\w{0,3}$/ ] }, '@');
+```
+
+## [m#] packageName
+
+### packageName(str)
+
+**`Overload 1/2`** **`Global`**
+
+- **str** { [string](dataTypes#string) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+包名选择器.
+
+- 筛选条件说明: 包名完全匹配指定字符串
+- 关联控件属性: [packageName](uiObjectType#m-packagename)
+
+例如对于以下 4 个控件:
+
+```js
+wA.packageName(); // org.mozilla.firefox
+wB.packageName(); // com.microsoft.office.word
+wC.packageName(); // com.twitter.android
+wD.packageName(); // com.accuweather.android
+```
+
+`packageName('com.twitter.android')` 是一个包名选择器, 可以匹配控件 `wC`.
+
+`packageName('com.microsoft.office.word)` 同样是一个包名选择器, 可以匹配控件 `wB`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(packageName(com.microsoft.office.word), '@');
+pickup({ packageName: com.microsoft.office.word }, '@');
+pickup({ packageName: [ com.microsoft.office.word ] }, '@');
+```
+
+### packageName(app)
+
+**`6.2.0`** **`Overload 2/2`** **`Global`**
+
+- **app** { [App](appType) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+包名选择器.
+
+- 筛选条件说明: 包名完全匹配指定 [应用枚举类](appType) 实例的包名
+- 关联控件属性: [packageName](uiObjectType#m-packagename)
+
+例如对于以下 4 个控件:
+
+```js
+wA.packageName(); // org.mozilla.firefox
+wB.packageName(); // com.microsoft.office.word
+wC.packageName(); // com.twitter.android
+wD.packageName(); // com.accuweather.android
+```
+
+`packageName(App.TWITTER)` 是一个包名选择器, 可以匹配控件 `wC`, 它使用 `应用枚举类` 实例对象作为筛选条件.
+
+`packageName(App.WORD)` 同样是一个包名选择器, 可以匹配控件 `wB`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(packageName(App.WORD), '@');
+pickup({ packageName: App.WORD }, '@');
+pickup({ packageName: [ App.WORD ] }, '@');
+```
+
+## [m#] packageNameStartsWith
+
+### packageNameStartsWith(str)
+
+**`Global`**
+
+- **str** { [string](dataTypes#string) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[包名选择器](#m-packagename) 的 [前缀匹配筛选器](#xxxstartswith).
+
+- 筛选条件说明: 包名前缀匹配指定字符串
+- 关联控件属性: [packageName](uiObjectType#m-packagename)
+
+例如对于以下 4 个控件:
+
+```js
+wA.packageName(); // org.mozilla.firefox
+wB.packageName(); // com.microsoft.office.word
+wC.packageName(); // com.twitter.android
+wD.packageName(); // com.accuweather.android
+```
+
+`packageNameStartsWith('com.')` 是一个包名前缀选择器, 可以匹配控件 `wB`, `wC` 和 `wD`.
+
+`packageNameStartsWith('com.a)` 同样是一个包名前缀选择器, 可以匹配控件 `wD`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(packageNameStartsWith('com.a'), '@');
+pickup({ packageNameStartsWith: 'com.a' }, '@');
+pickup({ packageNameStartsWith: [ 'com.a' ] }, '@');
+```
+
+## [m#] packageNameEndsWith
+
+### packageNameEndsWith(str)
+
+**`Global`**
+
+- **str** { [string](dataTypes#string) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[包名选择器](#m-packagename) 的 [后缀匹配筛选器](#xxxendswith).
+
+- 筛选条件说明: 包名后缀匹配指定字符串
+- 关联控件属性: [packageName](uiObjectType#m-packagename)
+
+例如对于以下 4 个控件:
+
+```js
+wA.packageName(); // org.mozilla.firefox
+wB.packageName(); // com.microsoft.office.word
+wC.packageName(); // com.twitter.android
+wD.packageName(); // com.accuweather.android
+```
+
+`packageNameEndsWith('android')` 可以匹配控件 `wC` 和 `wD`.  
+而 `packageNameEndsWith('Android')` 不可匹配上述任何控件, 因为包名匹配是大小写敏感的.
+
+`packageNameEndsWith('firefox')` 可以匹配控件 `wA`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(packageNameEndsWith('firefox'), '@');
+pickup({ packageNameEndsWith: 'firefox' }, '@');
+pickup({ packageNameEndsWith: [ 'firefox' ] }, '@');
+```
+
+## [m#] packageNameContains
+
+### packageNameContains(str)
+
+**`Global`**
+
+- **str** { [string](dataTypes#string) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[包名选择器](#m-packagename) 的 [包含匹配筛选器](#xxxcontains).
+
+- 筛选条件说明: 包名任意长度连续匹配指定字符串
+- 关联控件属性: [packageName](uiObjectType#m-packagename)
+
+例如对于以下 4 个控件:
+
+```js
+wA.packageName(); // org.mozilla.firefox
+wB.packageName(); // com.microsoft.office.word
+wC.packageName(); // com.twitter.android
+wD.packageName(); // com.accuweather.android
+```
+
+`packageNameContains('com')` 可以匹配控件 `wB`, `wC` 和 `wD`.
+
+`packageNameContains('office')` 可以匹配控件 `wB`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(packageNameContains('office'), '@');
+pickup({ packageNameContains: 'office' }, '@');
+pickup({ packageNameContains: [ 'office' ] }, '@');
+```
+
+## [m#] packageNameMatches
+
+### packageNameMatches(regex)
+
+**`Global`** **`DEPRECATED`**
+
+- **regex** { [string](dataTypes#string) | [RegExp](dataTypes.md#regexp) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[包名选择器](#m-packagename) 的 [正则全匹配筛选器](#xxxmatches).
+
+- 筛选条件说明: 包名的正则表达式规则完全匹配指定参数
+- 关联控件属性: [packageName](uiObjectType#m-packagename)
+
+例如对于以下 4 个控件:
+
+```js
+wA.packageName(); // org.mozilla.firefox
+wB.packageName(); // com.microsoft.office.word
+wC.packageName(); // com.twitter.android
+wD.packageName(); // com.accuweather.android
+```
+
+`packageNameMatches(/office/)` 或 `packageNameMatches('office')` 不可匹配上述任何控件 (因为 `packageNameMatches(/office/)` 相当于 `packageNameMatch(/^office$/)`).
+
+`packageNameMatches(/com.+android/)` 或 `packageNameMatches('com.+android')` 可以匹配控件 `wC` 和 `wD`, 因为 `/^com.+android$/` 匹配了它们的包名.
+
+`packageNameMatches(/twitter/)` 或 `packageNameMatches('twitter')` 不可匹配上述任何控件.
+
+`packageNameMatches(/.*twitter.*/)` 或 `packageNameMatches('.*twitter.*')` 可以匹配控件 `wC`, 因为 `/^.*twitter.*$/` 匹配了它的包名.
+
+`packageNameMatches(/\.\w*r\w*d/)` 或 `packageNameMatches('\\.\\w*r\\w*d')` 不可匹配上述任何控件.
+
+`packageNameMatches(/.*\.\w*r\w*d/)` 或 `packageNameMatches('.*\\.\\w*r\\w*d')` 可以匹配控件 `wB`, `wC` 和 `wD`, 因为 `/^.*\.\w*r\w*d$/` 匹配了它们的包名.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(packageNameMatches(/.*\.\w*r\w*d/), '@');
+pickup({ packageNameMatches: /.*\.\w*r\w*d/ }, '@');
+pickup({ packageNameMatches: [ /.*\.\w*r\w*d/ ] }, '@');
+```
+
+> 注: 自 6.2.0 版本起, packageNameMatches 已弃用, 建议使用 [packageNameMatch](#m-packagenamematch), 详情参阅 [正则全匹配筛选器](#xxxmatches) 小节.
+
+## [m#] packageNameMatch
+
+### packageNameMatch(regex)
+
+**`6.2.0`** **`Global`**
+
+- **regex** { [string](dataTypes#string) | [RegExp](dataTypes.md#regexp) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[包名选择器](#m-packagename) 的 [正则匹配筛选器](#xxxmatch).
+
+- 筛选条件说明: 包名的正则表达式规则匹配指定参数
+- 关联控件属性: [packageName](uiObjectType#m-packagename)
+
+例如对于以下 4 个控件:
+
+```js
+wA.packageName(); // org.mozilla.firefox
+wB.packageName(); // com.microsoft.office.word
+wC.packageName(); // com.twitter.android
+wD.packageName(); // com.accuweather.android
+```
+
+`packageNameMatch(/office/)` 或 `packageNameMatch('office')` 可以匹配 `wC` 控件.
+
+`packageNameMatch(/android$/)` 或 `packageNameMatch('android$')` 可以匹配 `wC` 和 `wD` 控件.
+
+`packageNameMatch(/\.\w*r\w*d$/)` 或 `packageNameMatch('\\.\\w*r\\w*d$')` 可以匹配控件 `wB`, `wC` 和 `wD`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(packageNameMatch(/\.\w*r\w*d$/), '@');
+pickup({ packageNameMatch: /\.\w*r\w*d$/ }, '@');
+pickup({ packageNameMatch: [ /\.\w*r\w*d$/ ] }, '@');
+```
+
+---
+
+## [m#] currentApp
+
+### currentApp(app)
+
+**`6.2.0`** **`Overload 1/2`** **`Global`**
+
+- **app** { [App](appType) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+应用选择器.
+
+- 筛选条件说明: 包名完全匹配指定 [应用枚举类](appType) 实例的包名
+- 关联控件属性: [packageName](uiObjectType#m-packagename)
+
+currentApp 传入 `应用枚举类` 实例时, 与 [packageName(app)](#packagenameapp) 效果相同.
+
+例如对于以下 4 个控件:
+
+```js
+wA.packageName(); // org.mozilla.firefox
+wB.packageName(); // com.microsoft.office.word
+wC.packageName(); // com.twitter.android
+wD.packageName(); // com.accuweather.android
+```
+
+`currentApp(App.TWITTER)` 是一个应用选择器, 可以匹配控件 `wC`.  
+`packageName(App.TWITTER)` 是一个 [包名选择器](#m-packagename), 与上述选择器效果相同.
+
+`currentApp(App.WORD)` 同样是一个应用选择器, 可以匹配控件 `wB`.
+`packageName(App.WORD)` 与上述选择器效果相同.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(currentApp(App.WORD), '@');
+pickup({ currentApp: App.WORD }, '@');
+pickup({ currentApp: [ App.WORD ] }, '@');
+```
+
+### currentApp(name)
+
+**`6.2.0`** **`Overload 2/2`** **`Global`**
+
+- **name** { [string](dataTypes#string) } - 应用枚举类实例的 [ 别名 / 当前语言应用名 / 简体中文应用名 / 英文应用名 ]
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+应用选择器.
+
+- 筛选条件说明: 包名完全匹配指定参数对应的 [应用枚举类](appType) 实例的包名
+- 关联控件属性: [packageName](uiObjectType#m-packagename)
+
+1. 解析 `name` 参数, 通过 [ 别名 / 当前语言应用名 / 简体中文应用名 / 英文应用名 ] 确定 `应用枚举类` 唯一实例
+2. 获取上述 `应用枚举类` 实例的包名作为参照值
+3. 筛选包名可匹配上述参照值的控件
+
+例如对于以下控件:
+
+```js
+w.packageName(); // com.eg.android.AlipayGphone
+```
+
+`currentApp('支付宝')` 是一个应用选择器, 可以匹配控件 `w`, 它使用 `应用枚举类` 实例的简体中文应用名作为筛选条件.
+
+`currentApp('Alipay')` 是一个应用选择器, 可以匹配控件 `w`, 它使用 `应用枚举类` 实例的英文应用名作为筛选条件.
+
+`currentApp('alipay')` 是一个应用选择器, 可以匹配控件 `w`, 它使用 `应用枚举类` 实例的别名作为筛选条件.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(currentApp('alipay'), '@');
+pickup({ currentApp: 'alipay' }, '@');
+pickup({ currentApp: [ 'alipay' ] }, '@');
+```
+
+## [m#] bounds
+
+### bounds(left, top, right, bottom)
+
+**`[6.2.0]`** **`Global`**
+
+- **left** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形左边界 X 坐标或百分比
+- **top** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形上边界 Y 坐标或百分比
+- **right** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形右边界 X 坐标或百分比
+- **bottom** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形下边界 Y 坐标或百分比
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 选择器.
+
+- 筛选条件说明: 控件矩形完全匹配指定的边界参数
+- 关联控件属性: [bounds](uiObjectType#m-bounds)
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(0, 48 - 112, 160)
+wB.bounds(); // Rect(0, 192 - 972, 1728)
+wC.bounds(); // Rect(0, 192 - 1080, 1920)
+```
+
+`bounds(0, 48, 112, 160)` 是一个控件矩形选择器, 可以匹配控件 `wA`, 它使用 4 个绝对坐标值作为筛选条件.
+
+`bounds(0, 0.1, 0.9, 0.9)` 是一个控件矩形选择器, 有可能会匹配控件 `wB`, 它使用屏幕宽度和高度的百分比作为筛选条件.
+
+`bounds(0, 192, -1, -1)` 是一个控件矩形选择器, 有可能会匹配控件 `wC`, 它使用绝对坐标值和屏幕宽高的指代值作为筛选条件.
+
+打印选择器信息时, 百分比参数取保留三位小数的近似值:
+
+```js
+/* 设备屏幕: 1080 × 1920. */
+
+console.log(655 / device.width); // 0.6064814814814815
+console.log(bounds(655 / device.width, 0.1, 0.9, 0.9)); // bounds(0.606, 0.1, 0.9, 0.9)
+```
+
+百分比参数转换为实际像素值进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将同时筛选最近的两个整数:
+
+```js
+/* 设备屏幕: 1080 × 1920. */
+
+/* 对于选择器 bounds(0.606, 0.1, 0.9, 0.9) . */
+
+console.log('left: ' + 0.606 * device.width); // 654.48
+console.log('top: ' + 0.1 * device.height); // 192
+console.log('right: ' + 0.9 * device.width); // 972
+console.log('bottom: ' + 0.9 * device.height); // 1728
+
+/* 注意到 left 坐标不是整数, 因此会同时筛选 654 和 655 两个 left 坐标. */
+/* 如果控件 w 的控件矩形为 Rect(655, 192 - 972, 1728), 则它可以被上述选择器匹配. */
+```
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(bounds(0, 192, -1, -1), '@');
+pickup({ bounds: [ 0, 192, -1, -1 ] }, '@');
+```
+
+## [m#] boundsInside
+
+### boundsInside(left, top, right, bottom)
+
+**`[6.2.0]`** **`Global`**
+
+- **left** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形左边界 X 坐标或百分比
+- **top** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形上边界 Y 坐标或百分比
+- **right** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形右边界 X 坐标或百分比
+- **bottom** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形下边界 Y 坐标或百分比
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 选择器.
+
+- 筛选条件说明: 控件矩形完全位于指定的边界内
+- 关联控件属性: [bounds](uiObjectType#m-bounds)
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(0, 48 - 112, 160)
+wB.bounds(); // Rect(0, 192 - 972, 1728)
+wC.bounds(); // Rect(0, 192 - 1080, 1920)
+```
+
+`boundsInside(0, 32, 112, 160)` 是一个控件矩形选择器, 可以匹配控件 `wA`, 它使用 4 个绝对坐标值作为筛选条件.
+
+`boundsInside(0, 0.02, 0.95, 0.95)` 是一个控件矩形选择器, 有可能会匹配控件 `wB`, 它使用屏幕宽度和高度的百分比作为筛选条件.
+
+`boundsInside(0, 128, -1, -1)` 是一个控件矩形选择器, 有可能会匹配控件 `wB` 和 `wC`, 它使用绝对坐标值和屏幕宽高的指代值作为筛选条件.
+
+`boundsInside(0, 0, -1, -1)` 是一个特殊的控件矩形筛选器, 它筛选边界全部位于屏幕内部的控件, 因此 `wA`, `wB` 和 `wC` 均可匹配, 但不可匹配 `Rect(0, -10 - 20, 20)`, 因其 `top` 坐标出界.
+
+打印选择器信息时, 百分比参数取保留三位小数的近似值:
+
+```js
+/* 设备屏幕: 1080 × 1920. */
+
+console.log(655 / device.width); // 0.6064814814814815
+console.log(boundsInside(655 / device.width, 0.1, 0.9, 0.9)); // boundsInside(0.606, 0.1, 0.9, 0.9)
+```
+
+百分比参数转换为实际像素值进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对边界做 [控件矩形外展](glossaries#控件矩形外展) 处理:
+
+```js
+/* 设备屏幕: 1080 × 1920. */
+
+/* 对于选择器 boundsInside(0.606, 0.1, 0.9, 0.9) . */
+
+console.log('left: ' + 0.606 * device.width); // 654.48
+console.log('top: ' + 0.1 * device.height); // 192
+console.log('right: ' + 0.9 * device.width); // 972
+console.log('bottom: ' + 0.9 * device.height); // 1728
+
+/* 注意到 left 坐标不是整数, 因此会外展 left 坐标, 得到 654. */
+/* 如果控件 w 的控件矩形为 Rect(655, 192 - 972, 1728), 则它可以被上述选择器匹配. */
+```
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsInside(0, 0.02, 0.95, 0.95), '@');
+pickup({ boundsInside: [ 0, 0.02, 0.95, 0.95 ] }, '@');
+```
+
+## [m#] boundsContains
+
+### boundsContains(left, top, right, bottom)
+
+**`[6.2.0]`** **`Global`**
+
+- **left** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形左边界 X 坐标或百分比
+- **top** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形上边界 Y 坐标或百分比
+- **right** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形右边界 X 坐标或百分比
+- **bottom** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形下边界 Y 坐标或百分比
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 选择器.
+
+- 筛选条件说明: 控件矩形完全包含指定的边界
+- 关联控件属性: [bounds](uiObjectType#m-bounds)
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(0, 48 - 112, 160)
+wB.bounds(); // Rect(0, 192 - 972, 1728)
+wC.bounds(); // Rect(0, 192 - 1080, 1920)
+```
+
+`boundsContains(0, 55, 112, 160)` 是一个控件矩形选择器, 可以匹配控件 `wA`, 它使用 4 个绝对坐标值作为筛选条件.
+
+`boundsContains(0, 0.3, 0.85, 0.85)` 是一个控件矩形选择器, 有可能会匹配控件 `wB` 和 `wC`, 它使用屏幕宽度和高度的百分比作为筛选条件.
+
+`boundsContains(0, 0.3, -1, -1)` 是一个控件矩形选择器, 有可能会匹配控件 `wC`, 它使用绝对坐标值和屏幕宽高的指代值作为筛选条件.
+
+打印选择器信息时, 百分比参数取保留三位小数的近似值:
+
+```js
+/* 设备屏幕: 1080 × 1920. */
+
+console.log(655 / device.width); // 0.6064814814814815
+console.log(boundsContains(655 / device.width, 0.1, 0.9, 0.9)); // boundsContains(0.606, 0.1, 0.9, 0.9)
+```
+
+百分比参数转换为实际像素值进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对边界做 [控件矩形内收](glossaries#控件矩形内收) 处理:
+
+```js
+/* 设备屏幕: 1080 × 1920. */
+
+/* 对于选择器 boundsContains(0.606, 0.1, 0.9, 0.9) . */
+
+console.log('left: ' + 0.606 * device.width); // 654.48
+console.log('top: ' + 0.1 * device.height); // 192
+console.log('right: ' + 0.9 * device.width); // 972
+console.log('bottom: ' + 0.9 * device.height); // 1728
+
+/* 注意到 left 坐标不是整数, 因此会内收 left 坐标, 得到 655. */
+/* 如果控件 w 的控件矩形为 Rect(655, 192 - 972, 1728), 则它可以被上述选择器匹配. */
+```
+
+boundsContains 选择器除了可用于 "矩形区域" 限定, 还可以用于 "线区域" 甚至 "点区域" 限定:
+
+```js
+/* "线区域" 限定. */
+boundsContains(0.23, 0.1, 0.23, 0.98); /* 注意到 left 与 right 相同. */
+boundsContains(0.1, 0.75, 0.9, 0.75); /* 注意到 top 与 bottom 相同. */
+
+/* "点区域" 限定. */
+boundsContains(0.23, 0.1, 0.23, 0.1); /* 注意到 left 与 right 相同, 且 top 与 bottom 相同. */
+```
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsContains(0, 0.3, 0.85, 0.85), '@');
+pickup({ boundsContains: [ 0, 0.3, 0.85, 0.85 ] }, '@');
+```
+
+## [m#] boundsLeft
+
+### boundsLeft(value)
+
+**`6.2.0`** **`Global`**
+
+- **value** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形左边界 X 坐标或百分比
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的左边界与指定边界相符
+- 关联控件属性: [ [boundsLeft](uiObjectType#m-boundsleft) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(108, 48 - 112, 160)
+wB.bounds(); // Rect(108, 96 - 256, 1280)
+wC.bounds(); // Rect(108, 112 - 1040, 1600)
+```
+
+`boundsLeft(108)` 是一个控件矩形边界选择器, 可以匹配控件 `wA`, `wB` 和 `wC`, 它使用绝对坐标值作为筛选条件.
+
+`boundsLeft(0.1)` 也是一个控件矩形边界选择器, 可能会匹配控件 `wA`, `wB` 和 `wC`, 它使用屏幕宽度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsLeft(0.1), '@');
+pickup({ boundsLeft: 0.1 }, '@');
+```
+
+### boundsLeft(min, max)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形以 X 坐标或百分比表示的左边界最小值
+- **max** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形以 X 坐标或百分比表示的左边界最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的左边界与指定的边界限制相符
+- 关联控件属性: [ [boundsLeft](uiObjectType#m-boundsleft) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(108, 48 - 112, 160)
+wB.bounds(); // Rect(108, 96 - 256, 1280)
+wC.bounds(); // Rect(108, 112 - 1040, 1600)
+```
+
+`boundsLeft(100, 200)` 是一个控件矩形边界选择器, 可以匹配控件 `wA`, `wB` 和 `wC`, 它使用绝对坐标值作为筛选条件.
+
+`boundsLeft(0.05, 0.15)` 也是一个控件矩形边界选择器, 可能会匹配控件 `wA`, `wB` 和 `wC`, 它使用屏幕宽度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsLeft(0.05, 0.15), '@');
+pickup({ boundsLeft: [ 0.05, 0.15 ] }, '@');
+```
+
+## [m#] boundsTop
+
+### boundsTop(value)
+
+**`6.2.0`** **`Global`**
+
+- **value** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形上边界 Y 坐标或百分比
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的上边界与指定边界相符
+- 关联控件属性: [ [boundsTop](uiObjectType#m-boundstop) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(10, 96 - 112, 160)
+wB.bounds(); // Rect(30, 96 - 256, 1280)
+wC.bounds(); // Rect(24, 96 - 1040, 1600)
+```
+
+`boundsTop(96)` 是一个控件矩形边界选择器, 可以匹配控件 `wA`, `wB` 和 `wC`, 它使用绝对坐标值作为筛选条件.
+
+`boundsTop(0.05)` 也是一个控件矩形边界选择器, 可能会匹配控件 `wA`, `wB` 和 `wC`, 它使用屏幕高度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsTop(0.1), '@');
+pickup({ boundsTop: 0.1 }, '@');
+```
+
+### boundsTop(min, max)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形以 Y 坐标或百分比表示的上边界最小值
+- **max** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形以 Y 坐标或百分比表示的上边界最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的上边界与指定的边界限制相符
+- 关联控件属性: [ [boundsTop](uiObjectType#m-boundstop) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(10, 96 - 112, 160)
+wB.bounds(); // Rect(30, 96 - 256, 1280)
+wC.bounds(); // Rect(24, 96 - 1040, 1600)
+```
+
+`boundsTop(60, 120)` 是一个控件矩形边界选择器, 可以匹配控件 `wA`, `wB` 和 `wC`, 它使用绝对坐标值作为筛选条件.
+
+`boundsTop(0.02, 0.12)` 也是一个控件矩形边界选择器, 可能会匹配控件 `wA`, `wB` 和 `wC`, 它使用屏幕高度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsTop(0.02, 0.12), '@');
+pickup({ boundsTop: [ 0.02, 0.12 ] }, '@');
+```
+
+## [m#] boundsRight
+
+### boundsRight(value)
+
+**`6.2.0`** **`Global`**
+
+- **value** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形右边界 X 坐标或百分比
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的右边界与指定边界相符
+- 关联控件属性: [ [boundsRight](uiObjectType#m-boundsright) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(18, 48 - 256, 160)
+wB.bounds(); // Rect(50, 96 - 256, 1280)
+wC.bounds(); // Rect(66, 112 - 256, 1600)
+```
+
+`boundsRight(256)` 是一个控件矩形边界选择器, 可以匹配控件 `wA`, `wB` 和 `wC`, 它使用绝对坐标值作为筛选条件.
+
+`boundsRight(0.237)` 也是一个控件矩形边界选择器, 可能会匹配控件 `wA`, `wB` 和 `wC`, 它使用屏幕宽度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsRight(0.237), '@');
+pickup({ boundsRight: 0.237 }, '@');
+```
+
+### boundsRight(min, max)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形以 X 坐标或百分比表示的右边界最小值
+- **max** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形以 X 坐标或百分比表示的右边界最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的右边界与指定的边界限制相符
+- 关联控件属性: [ [boundsRight](uiObjectType#m-boundsright) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(18, 48 - 256, 160)
+wB.bounds(); // Rect(50, 96 - 256, 1280)
+wC.bounds(); // Rect(66, 112 - 256, 1600)
+```
+
+`boundsRight(210, 320)` 是一个控件矩形边界选择器, 可以匹配控件 `wA`, `wB` 和 `wC`, 它使用绝对坐标值作为筛选条件.
+
+`boundsRight(0.2, 0.25)` 也是一个控件矩形边界选择器, 可能会匹配控件 `wA`, `wB` 和 `wC`, 它使用屏幕宽度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsRight(0.2, 0.25), '@');
+pickup({ boundsRight: [ 0.2, 0.25 ] }, '@');
+```
+
+## [m#] boundsBottom
+
+### boundsBottom(value)
+
+**`6.2.0`** **`Global`**
+
+- **value** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形下边界 Y 坐标或百分比
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的下边界与指定边界相符
+- 关联控件属性: [ [boundsBottom](uiObjectType#m-boundsbottom) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(10, 48 - 112, 1632)
+wB.bounds(); // Rect(30, 96 - 256, 1632)
+wC.bounds(); // Rect(24, 112 - 1040, 1632)
+```
+
+`boundsBottom(1632)` 是一个控件矩形边界选择器, 可以匹配控件 `wA`, `wB` 和 `wC`, 它使用绝对坐标值作为筛选条件.
+
+`boundsBottom(0.85)` 也是一个控件矩形边界选择器, 可能会匹配控件 `wA`, `wB` 和 `wC`, 它使用屏幕高度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsBottom(0.85), '@');
+pickup({ boundsBottom: 0.85 }, '@');
+```
+
+### boundsBottom(min, max)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形以 Y 坐标或百分比表示的下边界最小值
+- **max** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形以 Y 坐标或百分比表示的下边界最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的下边界与指定的边界限制相符
+- 关联控件属性: [ [boundsBottom](uiObjectType#m-boundsbottom) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(10, 48 - 112, 1632)
+wB.bounds(); // Rect(30, 96 - 256, 1632)
+wC.bounds(); // Rect(24, 112 - 1040, 1632)
+```
+
+`boundsBottom(1600, -1)` 是一个控件矩形边界选择器, 可以匹配控件 `wA`, `wB` 和 `wC`, 它使用绝对坐标值和屏幕高度代指值作为筛选条件.
+
+`boundsBottom(0.8, 0.9)` 也是一个控件矩形边界选择器, 可能会匹配控件 `wA`, `wB` 和 `wC`, 它使用屏幕高度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsBottom(0.8, 0.9), '@');
+pickup({ boundsBottom: [ 0.8, 0.9 ] }, '@');
+```
+
+## [m#] boundsWidth
+
+### boundsWidth(value)
+
+**`6.2.0`** **`Global`**
+
+- **value** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形横向宽度或百分比度量
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的尺寸选择器.
+
+- 筛选条件说明: 控件矩形的宽度与指定度量相符
+- 关联控件属性: [ [boundsWidth](uiObjectType#m-boundswidth) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(18, 48 - 256, 160)
+wA.boundsWidth(); // 238
+wB.bounds(); // Rect(50, 96 - 256, 1280)
+wB.boundsWidth(); // 206
+wC.bounds(); // Rect(66, 112 - 256, 1600)
+wC.boundsWidth(); // 190
+```
+
+`boundsWidth(206)` 是一个控件矩形尺寸选择器, 可以匹配控件 `wB`, 它使用宽度值作为筛选条件.
+
+`boundsWidth(0.191)` 也是一个控件矩形尺寸选择器, 可能会匹配控件 `wB`, 它使用屏幕宽度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsWidth(206), '@');
+pickup({ boundsWidth: 206 }, '@');
+```
+
+### boundsWidth(min, max)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形横向宽度或百分比度量的最小值
+- **max** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形横向宽度或百分比度量的最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的尺寸选择器.
+
+- 筛选条件说明: 控件矩形的宽度与指定的度量限制相符
+- 关联控件属性: [ [boundsWidth](uiObjectType#m-boundswidth) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(18, 48 - 256, 160)
+wA.boundsWidth(); // 238
+wB.bounds(); // Rect(50, 96 - 256, 1280)
+wB.boundsWidth(); // 206
+wC.bounds(); // Rect(66, 112 - 256, 1600)
+wC.boundsWidth(); // 190
+```
+
+`boundsWidth(150, 300)` 是一个控件矩形尺寸选择器, 可以匹配控件 `wA`, `wB` 和 `wC`, 它使用宽度值作为筛选条件.
+
+`boundsWidth(0.139, 0.278)` 也是一个控件矩形尺寸选择器, 可能会匹配控件 `wA`, `wB` 和 `wC`, 它使用屏幕宽度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsWidth(0.139, 0.278), '@');
+pickup({ boundsWidth: [ 0.139, 0.278 ] }, '@');
+```
+
+## [m#] boundsHeight
+
+### boundsHeight(value)
+
+**`6.2.0`** **`Global`**
+
+- **value** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形纵向高度或百分比度量
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的尺寸选择器.
+
+- 筛选条件说明: 控件矩形的高度与指定度量相符
+- 关联控件属性: [ [boundsHeight](uiObjectType#m-boundsheight) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(10, 48 - 112, 1632)
+wA.boundsHeight(); // 1584
+wB.bounds(); // Rect(30, 96 - 256, 1632)
+wB.boundsHeight(); // 1536
+wC.bounds(); // Rect(24, 112 - 1040, 1632)
+wC.boundsHeight(); // 1520
+```
+
+`boundsHeight(1536)` 是一个控件矩形尺寸选择器, 可以匹配控件 `wB`, 它使用高度值作为筛选条件.
+
+`boundsHeight(0.8)` 也是一个控件矩形尺寸选择器, 可能会匹配控件 `wB`, 它使用屏幕高度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsHeight(0.8), '@');
+pickup({ boundsHeight: 0.8 }, '@');
+```
+
+### boundsHeight(min, max)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形纵向高度或百分比度量的最小值
+- **max** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形纵向高度或百分比度量的最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的高度与指定的度量限制相符
+- 关联控件属性: [ [boundsHeight](uiObjectType#m-boundsheight) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(10, 48 - 112, 1632)
+wA.boundsHeight(); // 1584
+wB.bounds(); // Rect(30, 96 - 256, 1632)
+wB.boundsHeight(); // 1536
+wC.bounds(); // Rect(24, 112 - 1040, 1632)
+wC.boundsHeight(); // 1520
+```
+
+`boundsHeight(1500, -1)` 是一个控件矩形尺寸选择器, 可以匹配控件 `wA`, `wB` 和 `wC`, 它使用高度值和屏幕高度代指值作为筛选条件.
+
+`boundsHeight(0.781, 0.982)` 也是一个控件矩形尺寸选择器, 可能会匹配控件 `wA`, `wB` 和 `wC`, 它使用屏幕高度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsHeight(0.781, 0.982), '@');
+pickup({ boundsHeight: [ 0.781, 0.982 ] }, '@');
+```
+
+## [m#] boundsCenterX
+
+### boundsCenterX(value)
+
+**`6.2.0`** **`Global`**
+
+- **value** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形中心点 X 坐标或百分比
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的中心点选择器.
+
+- 筛选条件说明: 控件矩形中心点 X 坐标与指定的坐标相符
+- 关联控件属性: [ [boundsCenterX](uiObjectType#m-boundscenterx) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(18, 48 - 256, 160)
+wA.boundsCenterX(); // 137
+wB.bounds(); // Rect(50, 96 - 256, 1280)
+wB.boundsCenterX(); // 153
+wC.bounds(); // Rect(66, 112 - 256, 1600)
+wC.boundsCenterX(); // 161
+```
+
+`boundsCenterX(153)` 是一个控件矩形中心点选择器, 可以匹配控件 `wB`, 它使用坐标值作为筛选条件.
+
+`boundsCenterX(0.142)` 也是一个控件矩形中心点选择器, 可能会匹配控件 `wB`, 它使用屏幕宽度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsCenterX(0.142), '@');
+pickup({ boundsCenterX: 0.142 }, '@');
+```
+
+### boundsCenterX(min, max)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形以坐标值或百分比表示的中心点 X 坐标最小值
+- **max** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形以坐标值或百分比表示的中心点 X 坐标最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的中心点选择器.
+
+- 筛选条件说明:控件矩形中心点 X 坐标与指定的坐标限制相符
+- 关联控件属性: [ [boundsCenterX](uiObjectType#m-boundscenterx) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(18, 48 - 256, 160)
+wA.boundsCenterX(); // 137
+wB.bounds(); // Rect(50, 96 - 256, 1280)
+wB.boundsCenterX(); // 153
+wC.bounds(); // Rect(66, 112 - 256, 1600)
+wC.boundsCenterX(); // 161
+```
+
+`boundsCenterX(120, 240)` 是一个控件矩形中心点选择器, 可以匹配控件 `wA`, `wB` 和 `wC`, 它使用坐标值作为筛选条件.
+
+`boundsCenterX(0.111, 0.222)` 也是一个控件矩形中心点选择器, 可能会匹配控件 `wA`, `wB` 和 `wC`, 它使用屏幕宽度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsCenterX(0.111, 0.222), '@');
+pickup({ boundsCenterX: [ 0.111, 0.222 ] }, '@');
+```
+
+## [m#] boundsCenterY
+
+### boundsCenterY(value)
+
+**`6.2.0`** **`Global`**
+
+- **value** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形中心点 Y 坐标或百分比
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的中心点选择器.
+
+- 筛选条件说明: 控件矩形中心点 Y 坐标与指定的坐标相符
+- 关联控件属性: [ [boundsCenterY](uiObjectType#m-boundscentery) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(10, 48 - 112, 1632)
+wA.boundsCenterY(); // 840
+wB.bounds(); // Rect(30, 96 - 256, 1632)
+wB.boundsCenterY(); // 864
+wC.bounds(); // Rect(24, 112 - 1040, 1632)
+wC.boundsCenterY(); // 872
+```
+
+`boundsCenterY(864)` 是一个控件矩形中心点选择器, 可以匹配控件 `wB`, 它使用坐标值作为筛选条件.
+
+`boundsCenterY(0.45)` 也是一个控件矩形中心点选择器, 可能会匹配控件 `wB`, 它使用屏幕高度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsCenterY(0.45), '@');
+pickup({ boundsCenterY: 0.45 }, '@');
+```
+
+### boundsCenterY(min, max)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形以坐标值或百分比表示的中心点 Y 坐标最小值
+- **max** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形以坐标值或百分比表示的中心点 Y 坐标最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形中心点 Y 坐标与指定的坐标限制相符
+- 关联控件属性: [ [boundsCenterY](uiObjectType#m-boundscentery) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(10, 48 - 112, 1632)
+wA.boundsCenterY(); // 840
+wB.bounds(); // Rect(30, 96 - 256, 1632)
+wB.boundsCenterY(); // 864
+wC.bounds(); // Rect(24, 112 - 1040, 1632)
+wC.boundsCenterY(); // 872
+```
+
+`boundsCenterY(800, 900)` 是一个控件矩形中心点选择器, 可以匹配控件 `wA`, `wB` 和 `wC`, 它使用坐标值作为筛选条件.
+
+`boundsCenterY(0.417, 0.469)` 也是一个控件矩形中心点选择器, 可能会匹配控件 `wA`, `wB` 和 `wC`, 它使用屏幕高度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsCenterY(0.417, 0.469), '@');
+pickup({ boundsCenterY: [ 0.417, 0.469 ] }, '@');
+```
+
+## [m#] boundsMinLeft
+
+### boundsMinLeft(min)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形以 X 坐标或百分比表示的左边界最小值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的左边界与指定的边界限制相符
+- 关联控件属性: [ [boundsLeft](uiObjectType#m-boundsleft) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(108, 48 - 112, 160)
+wB.bounds(); // Rect(108, 96 - 256, 1280)
+wC.bounds(); // Rect(108, 112 - 1040, 1600)
+```
+
+`boundsMinLeft(100)` 是一个控件矩形边界选择器, 可以匹配控件 `wA`, `wB` 和 `wC`, 它使用绝对坐标值作为筛选条件.
+
+`boundsMinLeft(0.05)` 也是一个控件矩形边界选择器, 可能会匹配控件 `wA`, `wB` 和 `wC`, 它使用屏幕宽度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsMinLeft(0.05), '@');
+pickup({ boundsMinLeft: 0.05 }, '@');
+```
+
+## [m#] boundsMinTop
+
+### boundsMinTop(min)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形以 Y 坐标或百分比表示的上边界最小值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的上边界与指定的边界限制相符
+- 关联控件属性: [ [boundsTop](uiObjectType#m-boundstop) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(10, 96 - 112, 160)
+wB.bounds(); // Rect(30, 96 - 256, 1280)
+wC.bounds(); // Rect(24, 96 - 1040, 1600)
+```
+
+`boundsMinTop(60)` 是一个控件矩形边界选择器, 可以匹配控件 `wA`, `wB` 和 `wC`, 它使用绝对坐标值作为筛选条件.
+
+`boundsMinTop(0.02)` 也是一个控件矩形边界选择器, 可能会匹配控件 `wA`, `wB` 和 `wC`, 它使用屏幕高度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsMinTop(0.02), '@');
+pickup({ boundsMinTop: 0.02 }, '@');
+```
+
+## [m#] boundsMinRight
+
+### boundsMinRight(min)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形以 X 坐标或百分比表示的右边界最小值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的右边界与指定的边界限制相符
+- 关联控件属性: [ [boundsRight](uiObjectType#m-boundsright) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(18, 48 - 256, 160)
+wB.bounds(); // Rect(50, 96 - 256, 1280)
+wC.bounds(); // Rect(66, 112 - 256, 1600)
+```
+
+`boundsMinRight(210)` 是一个控件矩形边界选择器, 可以匹配控件 `wA`, `wB` 和 `wC`, 它使用绝对坐标值作为筛选条件.
+
+`boundsMinRight(0.2)` 也是一个控件矩形边界选择器, 可能会匹配控件 `wA`, `wB` 和 `wC`, 它使用屏幕宽度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsMinRight(0.2), '@');
+pickup({ boundsMinRight: 0.2 }, '@');
+```
+
+## [m#] boundsMinBottom
+
+### boundsMinBottom(min)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形以 Y 坐标或百分比表示的下边界最小值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的下边界与指定的边界限制相符
+- 关联控件属性: [ [boundsBottom](uiObjectType#m-boundsbottom) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(10, 48 - 112, 1632)
+wB.bounds(); // Rect(30, 96 - 256, 1632)
+wC.bounds(); // Rect(24, 112 - 1040, 1632)
+```
+
+`boundsMinBottom(1600)` 是一个控件矩形边界选择器, 可以匹配控件 `wA`, `wB` 和 `wC`, 它使用绝对坐标值作为筛选条件.
+
+`boundsMinBottom(0.8)` 也是一个控件矩形边界选择器, 可能会匹配控件 `wA`, `wB` 和 `wC`, 它使用屏幕高度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsMinBottom(0.8), '@');
+pickup({ boundsMinBottom: 0.8 }, '@');
+```
+
+## [m#] boundsMinWidth
+
+### boundsMinWidth(min)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形横向宽度或百分比度量的最小值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的尺寸选择器.
+
+- 筛选条件说明: 控件矩形的宽度与指定的度量限制相符
+- 关联控件属性: [ [boundsWidth](uiObjectType#m-boundswidth) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(18, 48 - 256, 160)
+wA.boundsMinWidth(); // 238
+wB.bounds(); // Rect(50, 96 - 256, 1280)
+wB.boundsMinWidth(); // 206
+wC.bounds(); // Rect(66, 112 - 256, 1600)
+wC.boundsMinWidth(); // 190
+```
+
+`boundsMinWidth(150)` 是一个控件矩形尺寸选择器, 可以匹配控件 `wA`, `wB` 和 `wC`, 它使用宽度值作为筛选条件.
+
+`boundsMinWidth(0.139)` 也是一个控件矩形尺寸选择器, 可能会匹配控件 `wA`, `wB` 和 `wC`, 它使用屏幕宽度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsMinWidth(0.139), '@');
+pickup({ boundsMinWidth: 0.139 }, '@');
+```
+
+## [m#] boundsMinHeight
+
+### boundsMinHeight(min)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形纵向高度或百分比度量的最小值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的高度与指定的度量限制相符
+- 关联控件属性: [ [boundsHeight](uiObjectType#m-boundsheight) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(10, 48 - 112, 1632)
+wA.boundsMinHeight(); // 1584
+wB.bounds(); // Rect(30, 96 - 256, 1632)
+wB.boundsMinHeight(); // 1536
+wC.bounds(); // Rect(24, 112 - 1040, 1632)
+wC.boundsMinHeight(); // 1520
+```
+
+`boundsMinHeight(1500)` 是一个控件矩形尺寸选择器, 可以匹配控件 `wA`, `wB` 和 `wC`, 它使用高度值作为筛选条件.
+
+`boundsMinHeight(0.781)` 也是一个控件矩形尺寸选择器, 可能会匹配控件 `wA`, `wB` 和 `wC`, 它使用屏幕高度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsMinHeight(0.781), '@');
+pickup({ boundsMinHeight: 0.781 }, '@');
+```
+
+## [m#] boundsMinCenterX
+
+### boundsMinCenterX(min)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形以坐标值或百分比表示的中心点 X 坐标最小值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的中心点选择器.
+
+- 筛选条件说明:控件矩形中心点 X 坐标与指定的坐标限制相符
+- 关联控件属性: [ [boundsCenterX](uiObjectType#m-boundscenterx) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(18, 48 - 256, 160)
+wA.boundsMinCenterX(); // 137
+wB.bounds(); // Rect(50, 96 - 256, 1280)
+wB.boundsMinCenterX(); // 153
+wC.bounds(); // Rect(66, 112 - 256, 1600)
+wC.boundsMinCenterX(); // 161
+```
+
+`boundsMinCenterX(120)` 是一个控件矩形中心点选择器, 可以匹配控件 `wA`, `wB` 和 `wC`, 它使用坐标值作为筛选条件.
+
+`boundsMinCenterX(0.111)` 也是一个控件矩形中心点选择器, 可能会匹配控件 `wA`, `wB` 和 `wC`, 它使用屏幕宽度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsMinCenterX(0.111), '@');
+pickup({ boundsMinCenterX: 0.111 }, '@');
+```
+
+## [m#] boundsMinCenterY
+
+### boundsMinCenterY(min)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形以坐标值或百分比表示的中心点 Y 坐标最小值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形中心点 Y 坐标与指定的坐标限制相符
+- 关联控件属性: [ [boundsCenterY](uiObjectType#m-boundscentery) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(10, 48 - 112, 1632)
+wA.boundsMinCenterY(); // 840
+wB.bounds(); // Rect(30, 96 - 256, 1632)
+wB.boundsMinCenterY(); // 864
+wC.bounds(); // Rect(24, 112 - 1040, 1632)
+wC.boundsMinCenterY(); // 872
+```
+
+`boundsMinCenterY(800)` 是一个控件矩形中心点选择器, 可以匹配控件 `wA`, `wB` 和 `wC`, 它使用坐标值作为筛选条件.
+
+`boundsMinCenterY(0.417)` 也是一个控件矩形中心点选择器, 可能会匹配控件 `wA`, `wB` 和 `wC`, 它使用屏幕高度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsMinCenterY(0.417), '@');
+pickup({ boundsMinCenterY: 0.417 }, '@');
+```
+
+## [m#] boundsMaxLeft
+
+### boundsMaxLeft(max)
+
+**`6.2.0`** **`Global`**
+
+- **max** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形以 X 坐标或百分比表示的左边界最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的左边界与指定的边界限制相符
+- 关联控件属性: [ [boundsLeft](uiObjectType#m-boundsleft) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(108, 48 - 112, 160)
+wB.bounds(); // Rect(108, 96 - 256, 1280)
+wC.bounds(); // Rect(108, 112 - 1040, 1600)
+```
+
+`boundsMaxLeft(200)` 是一个控件矩形边界选择器, 可以匹配控件 `wA`, `wB` 和 `wC`, 它使用绝对坐标值作为筛选条件.
+
+`boundsMaxLeft(0.15)` 也是一个控件矩形边界选择器, 可能会匹配控件 `wA`, `wB` 和 `wC`, 它使用屏幕宽度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsMaxLeft(0.15), '@');
+pickup({ boundsMaxLeft: 0.15 }, '@');
+```
+
+## [m#] boundsMaxTop
+
+### boundsMaxTop(max)
+
+**`6.2.0`** **`Global`**
+
+- **max** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形以 Y 坐标或百分比表示的上边界最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的上边界与指定的边界限制相符
+- 关联控件属性: [ [boundsTop](uiObjectType#m-boundstop) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(10, 96 - 112, 160)
+wB.bounds(); // Rect(30, 96 - 256, 1280)
+wC.bounds(); // Rect(24, 96 - 1040, 1600)
+```
+
+`boundsMaxTop(120)` 是一个控件矩形边界选择器, 可以匹配控件 `wA`, `wB` 和 `wC`, 它使用绝对坐标值作为筛选条件.
+
+`boundsMaxTop(0.12)` 也是一个控件矩形边界选择器, 可能会匹配控件 `wA`, `wB` 和 `wC`, 它使用屏幕高度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsMaxTop(0.12), '@');
+pickup({ boundsMaxTop: 0.12 }, '@');
+```
+
+## [m#] boundsMaxRight
+
+### boundsMaxRight(max)
+
+**`6.2.0`** **`Global`**
+
+- **max** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形以 X 坐标或百分比表示的右边界最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的右边界与指定的边界限制相符
+- 关联控件属性: [ [boundsRight](uiObjectType#m-boundsright) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(18, 48 - 256, 160)
+wB.bounds(); // Rect(50, 96 - 256, 1280)
+wC.bounds(); // Rect(66, 112 - 256, 1600)
+```
+
+`boundsMaxRight(320)` 是一个控件矩形边界选择器, 可以匹配控件 `wA`, `wB` 和 `wC`, 它使用绝对坐标值作为筛选条件.
+
+`boundsMaxRight(0.25)` 也是一个控件矩形边界选择器, 可能会匹配控件 `wA`, `wB` 和 `wC`, 它使用屏幕宽度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsMaxRight(0.25), '@');
+pickup({ boundsMaxRight: 0.25 }, '@');
+```
+
+## [m#] boundsMaxBottom
+
+### boundsMaxBottom(max)
+
+**`6.2.0`** **`Global`**
+
+- **max** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形以 Y 坐标或百分比表示的下边界最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的下边界与指定的边界限制相符
+- 关联控件属性: [ [boundsBottom](uiObjectType#m-boundsbottom) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(10, 48 - 112, 1632)
+wB.bounds(); // Rect(30, 96 - 256, 1632)
+wC.bounds(); // Rect(24, 112 - 1040, 1632)
+```
+
+`boundsMaxBottom(-1)` 是一个控件矩形边界选择器, 可以匹配控件 `wA`, `wB` 和 `wC`, 它使用屏幕高度代指值作为筛选条件.
+
+`boundsMaxBottom(0.9)` 也是一个控件矩形边界选择器, 可能会匹配控件 `wA`, `wB` 和 `wC`, 它使用屏幕高度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsMaxBottom(0.9), '@');
+pickup({ boundsMaxBottom: 0.9 }, '@');
+```
+
+## [m#] boundsMaxWidth
+
+### boundsMaxWidth(max)
+
+**`6.2.0`** **`Global`**
+
+- **max** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形横向宽度或百分比度量的最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的尺寸选择器.
+
+- 筛选条件说明: 控件矩形的宽度与指定的度量限制相符
+- 关联控件属性: [ [boundsWidth](uiObjectType#m-boundswidth) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(18, 48 - 256, 160)
+wA.boundsMaxWidth(); // 238
+wB.bounds(); // Rect(50, 96 - 256, 1280)
+wB.boundsMaxWidth(); // 206
+wC.bounds(); // Rect(66, 112 - 256, 1600)
+wC.boundsMaxWidth(); // 190
+```
+
+`boundsMaxWidth(300)` 是一个控件矩形尺寸选择器, 可以匹配控件 `wA`, `wB` 和 `wC`, 它使用宽度值作为筛选条件.
+
+`boundsMaxWidth(0.278)` 也是一个控件矩形尺寸选择器, 可能会匹配控件 `wA`, `wB` 和 `wC`, 它使用屏幕宽度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsMaxWidth(0.278), '@');
+pickup({ boundsMaxWidth: 0.278 }, '@');
+```
+
+## [m#] boundsMaxHeight
+
+### boundsMaxHeight(max)
+
+**`6.2.0`** **`Global`**
+
+- **max** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形纵向高度或百分比度量的最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的高度与指定的度量限制相符
+- 关联控件属性: [ [boundsHeight](uiObjectType#m-boundsheight) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(10, 48 - 112, 1632)
+wA.boundsMaxHeight(); // 1584
+wB.bounds(); // Rect(30, 96 - 256, 1632)
+wB.boundsMaxHeight(); // 1536
+wC.bounds(); // Rect(24, 112 - 1040, 1632)
+wC.boundsMaxHeight(); // 1520
+```
+
+`boundsMaxHeight(-1)` 是一个控件矩形尺寸选择器, 可以匹配控件 `wA`, `wB` 和 `wC`, 它使用屏幕高度代指值作为筛选条件.
+
+`boundsMaxHeight(0.982)` 也是一个控件矩形尺寸选择器, 可能会匹配控件 `wA`, `wB` 和 `wC`, 它使用屏幕高度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsMaxHeight(0.982), '@');
+pickup({ boundsMaxHeight: 0.982 }, '@');
+```
+
+## [m#] boundsMaxCenterX
+
+### boundsMaxCenterX(max)
+
+**`6.2.0`** **`Global`**
+
+- **max** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形以坐标值或百分比表示的中心点 X 坐标最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的中心点选择器.
+
+- 筛选条件说明:控件矩形中心点 X 坐标与指定的坐标限制相符
+- 关联控件属性: [ [boundsCenterX](uiObjectType#m-boundscenterx) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(18, 48 - 256, 160)
+wA.boundsMaxCenterX(); // 137
+wB.bounds(); // Rect(50, 96 - 256, 1280)
+wB.boundsMaxCenterX(); // 153
+wC.bounds(); // Rect(66, 112 - 256, 1600)
+wC.boundsMaxCenterX(); // 161
+```
+
+`boundsMaxCenterX(240)` 是一个控件矩形中心点选择器, 可以匹配控件 `wA`, `wB` 和 `wC`, 它使用坐标值作为筛选条件.
+
+`boundsMaxCenterX(0.222)` 也是一个控件矩形中心点选择器, 可能会匹配控件 `wA`, `wB` 和 `wC`, 它使用屏幕宽度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsMaxCenterX(0.222), '@');
+pickup({ boundsMaxCenterX: 0.222 }, '@');
+```
+
+## [m#] boundsMaxCenterY
+
+### boundsMaxCenterY(max)
+
+**`6.2.0`** **`Global`**
+
+- **max** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形以坐标值或百分比表示的中心点 Y 坐标最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形中心点 Y 坐标与指定的坐标限制相符
+- 关联控件属性: [ [boundsCenterY](uiObjectType#m-boundscentery) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+wA.bounds(); // Rect(10, 48 - 112, 1632)
+wA.boundsMaxCenterY(); // 840
+wB.bounds(); // Rect(30, 96 - 256, 1632)
+wB.boundsMaxCenterY(); // 864
+wC.bounds(); // Rect(24, 112 - 1040, 1632)
+wC.boundsMaxCenterY(); // 872
+```
+
+`boundsMaxCenterY(900)` 是一个控件矩形中心点选择器, 可以匹配控件 `wA`, `wB` 和 `wC`, 它使用坐标值作为筛选条件.
+
+`boundsMaxCenterY(0.469)` 也是一个控件矩形中心点选择器, 可能会匹配控件 `wA`, `wB` 和 `wC`, 它使用屏幕高度百分比作为筛选条件.
+
+百分比参数转换为像素值坐标进行筛选时, 若数值为整数, 则直接筛选, 若非整数, 将对数值做四舍五入处理.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(boundsMaxCenterY(0.469), '@');
+pickup({ boundsMaxCenterY: 0.469 }, '@');
+```
+
+## [m#] left
+
+### left(value)
+
+**`6.2.0`** **`Global`**
+
+- **value** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形左边界 X 坐标或百分比
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的左边界与指定边界相符
+- 关联控件属性: [ [boundsLeft](uiObjectType#m-boundsleft) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsLeft](#boundsleftvalue) 的别名方法.
+
+### left(min, max)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形以 X 坐标或百分比表示的左边界最小值
+- **max** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形以 X 坐标或百分比表示的左边界最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的左边界与指定的边界限制相符
+- 关联控件属性: [ [boundsLeft](uiObjectType#m-boundsleft) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsLeft](#boundsleftmin-max) 的别名方法.
+
+## [m#] top
+
+### top(value)
+
+**`6.2.0`** **`Global`**
+
+- **value** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形上边界 Y 坐标或百分比
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的上边界与指定边界相符
+- 关联控件属性: [ [boundsTop](uiObjectType#m-boundstop) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsTop](#boundstopvalue) 的别名方法.
+
+### top(min, max)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形以 Y 坐标或百分比表示的上边界最小值
+- **max** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形以 Y 坐标或百分比表示的上边界最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的上边界与指定的边界限制相符
+- 关联控件属性: [ [boundsTop](uiObjectType#m-boundstop) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsTop](#boundstopmin-max) 的别名方法.
+
+## [m#] right
+
+### right(value)
+
+**`6.2.0`** **`Global`**
+
+- **value** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形右边界 X 坐标或百分比
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的右边界与指定边界相符
+- 关联控件属性: [ [boundsRight](uiObjectType#m-boundsright) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsRight](#boundsrightvalue) 的别名方法.
+
+### right(min, max)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形以 X 坐标或百分比表示的右边界最小值
+- **max** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形以 X 坐标或百分比表示的右边界最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的右边界与指定的边界限制相符
+- 关联控件属性: [ [boundsRight](uiObjectType#m-boundsright) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsRight](#boundsrightmin-max) 的别名方法.
+
+## [m#] bottom
+
+### bottom(value)
+
+**`6.2.0`** **`Global`**
+
+- **value** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形下边界 Y 坐标或百分比
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的下边界与指定边界相符
+- 关联控件属性: [ [boundsBottom](uiObjectType#m-boundsbottom) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsBottom](#boundsbottomvalue) 的别名方法.
+
+### bottom(min, max)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形以 Y 坐标或百分比表示的下边界最小值
+- **max** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形以 Y 坐标或百分比表示的下边界最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的下边界与指定的边界限制相符
+- 关联控件属性: [ [boundsBottom](uiObjectType#m-boundsbottom) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsBottom](#boundsbottommin-max) 的别名方法.
+
+## [m#] width
+
+### width(value)
+
+**`6.2.0`** **`Global`**
+
+- **value** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形横向宽度或百分比度量
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的尺寸选择器.
+
+- 筛选条件说明: 控件矩形的宽度与指定度量相符
+- 关联控件属性: [ [boundsWidth](uiObjectType#m-boundswidth) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsWidth](#boundswidthvalue) 的别名方法.
+
+### width(min, max)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形横向宽度或百分比度量的最小值
+- **max** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形横向宽度或百分比度量的最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的尺寸选择器.
+
+- 筛选条件说明: 控件矩形的宽度与指定的度量限制相符
+- 关联控件属性: [ [boundsWidth](uiObjectType#m-boundswidth) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsWidth](#boundswidthmin-max) 的别名方法.
+
+## [m#] height
+
+### height(value)
+
+**`6.2.0`** **`Global`**
+
+- **value** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形纵向高度或百分比度量
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的尺寸选择器.
+
+- 筛选条件说明: 控件矩形的高度与指定度量相符
+- 关联控件属性: [ [boundsHeight](uiObjectType#m-boundsheight) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsHeight](#boundsheightvalue) 的别名方法.
+
+### height(min, max)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形纵向高度或百分比度量的最小值
+- **max** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形纵向高度或百分比度量的最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的高度与指定的度量限制相符
+- 关联控件属性: [ [boundsHeight](uiObjectType#m-boundsheight) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsHeight](#boundsheightmin-max) 的别名方法.
+
+## [m#] centerX
+
+### centerX(value)
+
+**`6.2.0`** **`Global`**
+
+- **value** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形中心点 X 坐标或百分比
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的中心点选择器.
+
+- 筛选条件说明: 控件矩形中心点 X 坐标与指定的坐标相符
+- 关联控件属性: [ [boundsCenterX](uiObjectType#m-boundscenterx) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsCenterX](#boundscenterxvalue) 的别名方法.
+
+### centerX(min, max)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形以坐标值或百分比表示的中心点 X 坐标最小值
+- **max** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形以坐标值或百分比表示的中心点 X 坐标最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的中心点选择器.
+
+- 筛选条件说明:控件矩形中心点 X 坐标与指定的坐标限制相符
+- 关联控件属性: [ [boundsCenterX](uiObjectType#m-boundscenterx) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsCenterX](#boundscenterxmin-max) 的别名方法.
+
+## [m#] centerY
+
+### centerY(value)
+
+**`6.2.0`** **`Global`**
+
+- **value** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形中心点 Y 坐标或百分比
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的中心点选择器.
+
+- 筛选条件说明: 控件矩形中心点 Y 坐标与指定的坐标相符
+- 关联控件属性: [ [boundsCenterY](uiObjectType#m-boundscentery) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsCenterY](#boundscenteryvalue) 的别名方法.
+
+### centerY(min, max)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形以坐标值或百分比表示的中心点 Y 坐标最小值
+- **max** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形以坐标值或百分比表示的中心点 Y 坐标最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形中心点 Y 坐标与指定的坐标限制相符
+- 关联控件属性: [ [boundsCenterY](uiObjectType#m-boundscentery) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsCenterY](#boundscenterymin-max) 的别名方法.
+
+## [m#] minLeft
+
+### minLeft(min)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形以 X 坐标或百分比表示的左边界最小值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的左边界与指定的边界限制相符
+- 关联控件属性: [ [boundsLeft](uiObjectType#m-boundsleft) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsMinLeft](#boundsminleftmin) 的别名方法.
+
+## [m#] minTop
+
+### minTop(min)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形以 Y 坐标或百分比表示的上边界最小值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的上边界与指定的边界限制相符
+- 关联控件属性: [ [boundsTop](uiObjectType#m-boundstop) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsMinTop](#boundsmintopmin) 的别名方法.
+
+## [m#] minRight
+
+### minRight(min)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形以 X 坐标或百分比表示的右边界最小值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的右边界与指定的边界限制相符
+- 关联控件属性: [ [boundsRight](uiObjectType#m-boundsright) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsMinRight](#boundsminrightmin) 的别名方法.
+
+## [m#] minBottom
+
+### minBottom(min)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形以 Y 坐标或百分比表示的下边界最小值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的下边界与指定的边界限制相符
+- 关联控件属性: [ [boundsBottom](uiObjectType#m-boundsbottom) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsMinBottom](#boundsminbottommin) 的别名方法.
+
+## [m#] minWidth
+
+### minWidth(min)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形横向宽度或百分比度量的最小值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的尺寸选择器.
+
+- 筛选条件说明: 控件矩形的宽度与指定的度量限制相符
+- 关联控件属性: [ [boundsWidth](uiObjectType#m-boundswidth) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsMinWidth](#boundsminwidthmin) 的别名方法.
+
+## [m#] minHeight
+
+### minHeight(min)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形纵向高度或百分比度量的最小值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的高度与指定的度量限制相符
+- 关联控件属性: [ [boundsHeight](uiObjectType#m-boundsheight) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsMinHeight](#boundsminheightmin) 的别名方法.
+
+## [m#] minCenterX
+
+### minCenterX(min)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形以坐标值或百分比表示的中心点 X 坐标最小值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的中心点选择器.
+
+- 筛选条件说明:控件矩形中心点 X 坐标与指定的坐标限制相符
+- 关联控件属性: [ [boundsCenterX](uiObjectType#m-boundscenterx) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsMinCenterX](#boundsmincenterxmin) 的别名方法.
+
+## [m#] minCenterY
+
+### minCenterY(min)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形以坐标值或百分比表示的中心点 Y 坐标最小值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形中心点 Y 坐标与指定的坐标限制相符
+- 关联控件属性: [ [boundsCenterY](uiObjectType#m-boundscentery) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsMinCenterY](#boundsmincenterymin) 的别名方法.
+
+## [m#] maxLeft
+
+### maxLeft(max)
+
+**`6.2.0`** **`Global`**
+
+- **max** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形以 X 坐标或百分比表示的左边界最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的左边界与指定的边界限制相符
+- 关联控件属性: [ [boundsLeft](uiObjectType#m-boundsleft) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsMaxLeft](#boundsmaxleftmax) 的别名方法.
+
+## [m#] maxTop
+
+### maxTop(max)
+
+**`6.2.0`** **`Global`**
+
+- **max** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形以 Y 坐标或百分比表示的上边界最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的上边界与指定的边界限制相符
+- 关联控件属性: [ [boundsTop](uiObjectType#m-boundstop) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsMaxTop](#boundsmaxtopmax) 的别名方法.
+
+## [m#] maxRight
+
+### maxRight(max)
+
+**`6.2.0`** **`Global`**
+
+- **max** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形以 X 坐标或百分比表示的右边界最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的右边界与指定的边界限制相符
+- 关联控件属性: [ [boundsRight](uiObjectType#m-boundsright) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsMaxRight](#boundsmaxrightmax) 的别名方法.
+
+## [m#] maxBottom
+
+### maxBottom(max)
+
+**`6.2.0`** **`Global`**
+
+- **max** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形以 Y 坐标或百分比表示的下边界最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的下边界与指定的边界限制相符
+- 关联控件属性: [ [boundsBottom](uiObjectType#m-boundsbottom) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsMaxBottom](#boundsmaxbottommax) 的别名方法.
+
+## [m#] maxWidth
+
+### maxWidth(max)
+
+**`6.2.0`** **`Global`**
+
+- **max** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形横向宽度或百分比度量的最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的尺寸选择器.
+
+- 筛选条件说明: 控件矩形的宽度与指定的度量限制相符
+- 关联控件属性: [ [boundsWidth](uiObjectType#m-boundswidth) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsMaxWidth](#boundsmaxwidthmax) 的别名方法.
+
+## [m#] maxHeight
+
+### maxHeight(max)
+
+**`6.2.0`** **`Global`**
+
+- **max** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形纵向高度或百分比度量的最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形的高度与指定的度量限制相符
+- 关联控件属性: [ [boundsHeight](uiObjectType#m-boundsheight) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsMaxHeight](#boundsmaxheightmax) 的别名方法.
+
+## [m#] maxCenterX
+
+### maxCenterX(max)
+
+**`6.2.0`** **`Global`**
+
+- **max** { [ScreenMetricNumberX](dataTypes#screenmetricnumberx) } - 矩形以坐标值或百分比表示的中心点 X 坐标最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的中心点选择器.
+
+- 筛选条件说明:控件矩形中心点 X 坐标与指定的坐标限制相符
+- 关联控件属性: [ [boundsCenterX](uiObjectType#m-boundscenterx) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsMaxCenterX](#boundsmaxcenterxmax) 的别名方法.
+
+## [m#] maxCenterY
+
+### maxCenterY(max)
+
+**`6.2.0`** **`Global`**
+
+- **max** { [ScreenMetricNumberY](dataTypes#screenmetricnumbery) } - 矩形以坐标值或百分比表示的中心点 Y 坐标最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的边界选择器.
+
+- 筛选条件说明: 控件矩形中心点 Y 坐标与指定的坐标限制相符
+- 关联控件属性: [ [boundsCenterY](uiObjectType#m-boundscentery) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#boundsMaxCenterY](#boundsmaxcenterymax) 的别名方法.
+
+## [m#] screenCenterX
+
+### screenCenterX(b, tolerance)
+
+**`6.2.0`** **`Global`**
+
+- **b** { [boolean](dataTypes#boolean) } - X 坐标是否居中
+- **tolerance** { [number](dataTypes#number) } - 居中误差容限
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的中心点选择器.
+
+- 筛选条件说明: 控件矩形中心点 X 坐标与屏幕中点 X 坐标的差值是否在误差容限内的情况与指定参数 (b) 相符
+- 关联控件属性: [ [boundsCenterX](uiObjectType#m-boundscenterx) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+device.width; // 1080
+
+wA.bounds(); // Rect(520, 48 - 560, 160)
+wA.boundsCenterX(); // 540
+Math.abs(wA.boundsCenterX() - device.width / 2) / device.width; // 0
+
+wB.bounds(); // Rect(50, 96 - 1040, 1280)
+wB.boundsCenterX(); // 545
+Math.abs(wB.boundsCenterX() - device.width / 2) / device.width; /* 约为 0.005 . */
+
+wC.bounds(); // Rect(66, 112 - 256, 1600)
+wC.boundsCenterX(); // 161
+Math.abs(wC.boundsCenterX() - device.width / 2) / device.width; /* 约为 0.351 . */
+```
+
+`screenCenterX(true, 0)` 是一个控件矩形中心点选择器, 可以匹配控件 `wA`, 参数 `0` 表示严格横向居中, 不允许丝毫误差, `true` 表示正常筛选, 如果为 `false`, 表示反向筛选, 即筛选不满足严格横向居中的控件.
+
+`screenCenterX(true, 0.1)` 也是一个控件矩形中心点选择器, 可以匹配控件 `wA` 和 `wB`, 因为 `wA` 是严格横向居中的, `wB` 的居中误差约为 `0.005`, 小于指定的 `0.1`, `wC` 的居中误差过大, 因此未能被筛选.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(screenCenterX(0.1), '@');
+pickup({ screenCenterX: 0.1 }, '@');
+```
+
+### screenCenterX(b)
+
+**`6.2.0`** **`Global`**
+
+- **b** { [boolean](dataTypes#boolean) } - X 坐标是否居中
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的中心点选择器.
+
+- 筛选条件说明: 控件矩形中心点 X 坐标与屏幕中点 X 坐标的差值是否在误差容限内的情况与指定参数 (b) 相符
+- 关联控件属性: [ [boundsCenterX](uiObjectType#m-boundscenterx) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#screenCenterX](#screencenterx)(`b`, `0.016`) 的重载方法.
+
+### screenCenterX(tolerance)
+
+**`6.2.0`** **`Global`**
+
+- **tolerance** { [number](dataTypes#number) } - 居中误差容限
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的中心点选择器.
+
+- 筛选条件说明: 控件矩形中心点 X 坐标与屏幕中点 X 坐标的差值在误差容限内
+- 关联控件属性: [ [boundsCenterX](uiObjectType#m-boundscenterx) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#screenCenterX](#screencenterx)(`true`, `tolerance`) 的重载方法.
+
+### screenCenterX()
+
+**`6.2.0`** **`Global`**
+
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的中心点选择器.
+
+- 筛选条件说明: 控件矩形中心点 X 坐标与屏幕中点 X 坐标的差值不大于 0.016
+- 关联控件属性: [ [boundsCenterX](uiObjectType#m-boundscenterx) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#screenCenterX](#screencenterx)(`true`, `0.016`) 的重载方法.
+
+## [m#] screenCenterY
+
+### screenCenterY(b, tolerance)
+
+**`6.2.0`** **`Global`**
+
+- **b** { [boolean](dataTypes#boolean) } - Y 坐标是否居中
+- **tolerance** { [number](dataTypes#number) } - 居中误差容限
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的中心点选择器.
+
+- 筛选条件说明: 控件矩形中心点 Y 坐标与屏幕中点 Y 坐标的差值是否在误差容限内的情况与指定参数 (b) 相符
+- 关联控件属性: [ [boundsCenterY](uiObjectType#m-boundscentery) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 3 个控件:
+
+```js
+device.height; // 1920
+
+wA.bounds(); // Rect(10, 48 - 260, 1872)
+wA.boundsCenterY(); // 960
+Math.abs(wA.boundsCenterY() - device.width / 2) / device.width; // 0
+
+wB.bounds(); // Rect(150, 96 - 1020, 1820)
+wB.boundsCenterY(); // 958
+Math.abs(wB.boundsCenterY() - device.width / 2) / device.width; /* 约为 0.001 . */
+
+wC.bounds(); // Rect(266, 1400 - 356, 1600)
+wC.boundsCenterY(); // 1500
+Math.abs(wC.boundsCenterY() - device.width / 2) / device.width; /* 约为 0.281 . */
+```
+
+`screenCenterY(true, 0)` 是一个控件矩形中心点选择器, 可以匹配控件 `wA`, 参数 `0` 表示严格纵向居中, 不允许丝毫误差, `true` 表示正常筛选, 如果为 `false`, 表示反向筛选, 即筛选不满足严格纵向居中的控件.
+
+`screenCenterY(true, 0.1)` 也是一个控件矩形中心点选择器, 可以匹配控件 `wA` 和 `wB`, 因为 `wA` 是严格纵向居中的, `wB` 的居中误差约为 `0.001`, 小于指定的 `0.1`, `wC` 的居中误差过大, 因此未能被筛选.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(screenCenterY(0.1), '@');
+pickup({ screenCenterY: 0.1 }, '@');
+```
+
+### screenCenterY(b)
+
+**`6.2.0`** **`Global`**
+
+- **b** { [boolean](dataTypes#boolean) } - Y 坐标是否居中
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的中心点选择器.
+
+- 筛选条件说明: 控件矩形中心点 Y 坐标与屏幕中点 Y 坐标的差值是否在误差容限内的情况与指定参数 (b) 相符
+- 关联控件属性: [ [boundsCenterY](uiObjectType#m-boundscentery) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#screenCenterY](#screencentery)(`b`, `0.016`) 的重载方法.
+
+### screenCenterY(tolerance)
+
+**`6.2.0`** **`Global`**
+
+- **tolerance** { [number](dataTypes#number) } - 居中误差容限
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的中心点选择器.
+
+- 筛选条件说明: 控件矩形中心点 Y 坐标与屏幕中点 Y 坐标的差值在误差容限内
+- 关联控件属性: [ [boundsCenterY](uiObjectType#m-boundscentery) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#screenCenterY](#screencentery)(`true`, `tolerance`) 的重载方法.
+
+### screenCenterY()
+
+**`6.2.0`** **`Global`**
+
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的中心点选择器.
+
+- 筛选条件说明: 控件矩形中心点 Y 坐标与屏幕中点 Y 坐标的差值不大于 0.016
+- 关联控件属性: [ [boundsCenterY](uiObjectType#m-boundscentery) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#screenCenterY](#screencentery)(`true`, `0.016`) 的重载方法.
+
+## [m#] screenCoverage
+
+### screenCoverage(min)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [number](dataTypes#number) } - 矩形可视化部分的空间占比最小值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的空间选择器.
+
+- 筛选条件说明: 控件矩形可视化部分的空间占比 (即屏幕覆盖率) 满足指定的参数
+- 关联控件属性: [ [boundsWidth](uiObjectType#m-boundswidth) / [boundsHeight](uiObjectType#m-boundsheight) / [bounds](uiObjectType#m-bounds) ]
+
+例如对于以下 5 个控件:
+
+```js
+device.width; // 1080
+device.height; // 1920
+
+wA.bounds(); // Rect(0, 0 - 1080, 1896)
+(wA.width() * wA.height()) / (device.width * device.height); // 0.9875
+
+wB.bounds(); // Rect(150, 96 - 1020, 1820)
+(wB.width() * wB.height()) / (device.width * device.height); /* 约为 0.723 .*/
+
+wC.bounds(); /* Rect(-2000, -1400 - 80, 1920), 屏幕覆盖率约为 7.4% . */
+wD.bounds(); /* Rect(-200, 0 - 1080, 1920), 屏幕覆盖率为 100% . */
+wE.bounds(); /* Rect(20, 30 - 840, 4000), 屏幕覆盖率约为 74.7% . */
+```
+
+`screenCoverage(0.95)` 是一个控件矩形空间选择器, 可以匹配控件 `wA` 和 `wD`, 参数 `0.95` 表示可视化部分的空间占比不小于 `95%`, `wD` 较为特殊, 它的左边界为负数, 表示左边界超出屏幕可视化区域, 因此计算时按 `0` 处理.
+
+同样特殊的, 还有 `wC` 及 `wE`.  
+`wC` 的左边界及上边界均为负数, 超出了屏幕可视化区域, 计算面积时均按 `0` 处理:
+
+```js
+/* (right - left) * (bottom - top) */
+(80 - 0) * (1920 - 0)
+```
+
+`wE` 的下边界为 `4000`, 大于示例中的设备高度 `1920`, 超出了屏幕可视化区域, 计算面积时按设备高度 `1920` 处理:
+
+```js
+/* (right - left) * (bottom - top) */
+(840 - 20) * (1920 - 30)
+```
+
+因此 5 个控件中, `wC` 的屏幕覆盖率是最低的, 对于选择器 `screenCoverage(0.7)`, 除 `wC` 外的 4 个控件均可被筛选.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(screenCoverage(0.7), '@');
+pickup({ screenCoverage: 0.7 }, '@');
+```
+
+### screenCoverage()
+
+**`6.2.0`** **`Global`**
+
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件矩形 (Rect)](dataTypes#androidrect) 的空间选择器.
+
+- 筛选条件说明: 控件矩形可视化部分的屏幕占比不小于 `94.8%`
+- 关联控件属性: [ [boundsWidth](uiObjectType#m-boundswidth) / [boundsHeight](uiObjectType#m-boundsheight) / [bounds](uiObjectType#m-bounds) ]
+
+[UiSelector#screenCoverage](#screencoverage)(`0.948`) 的重载方法.
+
+## [m#] algorithm
+
+### algorithm(str)
+
+**`Global`**
+
+- **str** { [string](dataTypes#string) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+选择器的算法配置器.
+
+- 配置器说明: 用于配置在检索窗口控件时使用的遍历方式
+- 配置选项 (非大小写敏感):
+    - `DFS` - 深度优先搜索 (默认)
+    - `BFS` - 广度优先搜索
+- 关联控件属性: [ 无 ]
+
+```js
+console.log('DFS 搜索耗时: ' +
+    recorder(() => text('hi').algorithm('DFS').findOnce()));
+console.log('BFS 搜索耗时: ' +
+    recorder(() => text('hi').algorithm('BFS').findOnce()));
+```
+
+BFS 在控件的 [深度](uiObjectType#m-depth) 较低或 [控件层级](glossaries#控件层级) 总数较少时, 可能会提升部分搜索效率.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(algorithm('BFS'), '@');
+pickup({ algorithm: 'BFS' }, '@');
+```
+
+## [m#] action
+
+### action(...actions)
+
+**`6.2.0`** **`Global`**
+
+- **actions** { [...](documentation#可变参数)[string](dataTypes#string)[[]](documentation#可变参数) } - 控件行为 ID
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+[控件行为](uiObjectActionsType) 选择器.
+
+- 筛选条件说明: 控件支持指定的全部行为参数
+- 关联控件属性: [ [actionNames](uiObjectType#m-actionnames) / [hasAction](uiObjectType#m-hasaction) ]
+
+一个控件可能支持多种控件行为, 如点击, 长按, 设置文本等, 每个行为对应一个控件行为 ID, 如点击的 ID 为 `ACTION_CLICK`, 设置文本的 ID 为 `ACTION_SET_TEXT`, 更多控件行为 ID 可参阅 [控件节点行为](uiObjectActionsType) 章节的 `行为 ID` 表格.
+
+`action('ACTION_SET_TEXT')` 是一个控件行为选择器, 要求控件满足支持设置文本的条件.
+
+`action('ACTION_CLICK')` 也是一个控件行为选择器, 要求控件满足支持点击的条件.
+
+参数中的 `'ACTION_'` 前缀可省略, 即 `action('SET_TEXT')` 与 `action('ACTION_SET_TEXT')` 等价.
+
+action 选择器支持 [变长参数](documentation#可变参数), `action('SET_TEXT', 'CLICK')` 选择器则要求控件同时满足支持设置文本和支持点击的条件.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(action('SET_TEXT'), '@');
+pickup({ action: 'SET_TEXT' }, '@');
+
+pickup(action('SET_TEXT', 'CLICK'), '@');
+pickup({ action: [ 'SET_TEXT', 'CLICK' ] }, '@');
+```
+
+## [m#] filter
+
+### filter(f)
+
+**`Global`**
+
+- **f** { [(](dataTypes#function)w: [UiObject](uiObjectType)[)](dataTypes#function) [=>](dataTypes#function) [boolean](dataTypes#boolean) } - 过滤器
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+过滤器选择器, 将过滤器作为测试条件直接进行控件筛选.
+
+- 筛选条件说明: 控件可通过过滤器测试条件
+- 关联控件属性: [ 无 ]
+
+filter 选择器相当于高度自定义的条件筛选器, 它可以实现更具体更符合特定需求的控件筛选.
+
+```js
+filter(w => w.text().length >= 5); /* 筛选文本长度不小于 5 的控件. */
+filter(w => w.top() < cY(0.5) && w.width() > cX(0.9)); /* 筛选控件矩形上边界位于屏幕上半部分且宽度大于屏幕宽度 90% 的控件. */
+filter(w => w.childCount() >= 2); /* 筛选至少有 2 个子节点的控件. */
+```
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(filter(w => w.childCount() >= 2), '@');
+pickup({ filter: w => w.childCount() >= 2 }, '@');
+```
+
+## [m#] hasChildren
+
+### hasChildren(b?)
+
+**`6.2.0`** **`Overload [1-2]/2`** **`Global`**
+
+- **[ b = true ]** { [boolean](dataTypes#boolean) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+控件子节点存在状态选择器.
+
+- 筛选条件说明: 控件的子节点存在状态与指定参数相符
+- 关联控件属性: [ [hasChildren](uiObjectType#m-haschildren) / [childCount](uiObjectType#m-childcount) ]
+
+例如对于以下控件:
+
+```js
+/* 表示控件存在至少一个子节点, 即控件不是叶子结点. */
+w.hasChildren(); // true
+```
+
+`hasChildren()` 及 `hasChildren(true)` 均可匹配控件 `w`.
+
+`hasChildren()` 选择器相当于 `filter(w => w.childCount() > 0)` 选择器.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(hasChildren(), '@');
+pickup({ hasChildren: [] }, '@');
+pickup({ hasChildren: null }, '@'); /* 不推荐. */
+
+pickup(hasChildren(true), '@');
+pickup({ hasChildren: true }, '@');
+```
+
+## [m#] checkable
+
+### checkable(b?)
+
+**`Overload [1-2]/2`** **`Global`**
+
+- **[ b = true ]** { [boolean](dataTypes#boolean) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+控件勾选可用性选择器.
+
+- 筛选条件说明: 控件的勾选可用性与指定参数相符
+- 关联控件属性: [checkable](uiObjectType#m-checkable)
+
+例如对于以下控件:
+
+```js
+/* 表示控件可被选中. */
+w.checkable(); // true
+```
+
+`checkable()` 及 `checkable(true)` 均可匹配控件 `w`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(checkable(), '@');
+pickup({ checkable: [] }, '@');
+pickup({ checkable: null }, '@'); /* 不推荐. */
+
+pickup(checkable(true), '@');
+pickup({ checkable: true }, '@');
+```
+
+## [m#] checked
+
+### checked(b?)
+
+**`Overload [1-2]/2`** **`Global`**
+
+- **[ b = true ]** { [boolean](dataTypes#boolean) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+控件勾选状态选择器.
+
+- 筛选条件说明: 控件的勾选状态与指定参数相符
+- 关联控件属性: [checked](uiObjectType#m-checked)
+
+例如对于以下控件:
+
+```js
+/* 表示控件已被选中. */
+w.checked(); // true
+```
+
+`checked()` 及 `checked(true)` 均可匹配控件 `w`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(checked(), '@');
+pickup({ checked: [] }, '@');
+pickup({ checked: null }, '@'); /* 不推荐. */
+
+pickup(checked(true), '@');
+pickup({ checked: true }, '@');
+```
+
+## [m#] focusable
+
+### focusable(b?)
+
+**`Overload [1-2]/2`** **`Global`**
+
+- **[ b = true ]** { [boolean](dataTypes#boolean) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+控件聚焦可用性选择器.
+
+- 筛选条件说明: 控件的聚焦可用性与指定参数相符
+- 关联控件属性: [focusable](uiObjectType#m-focusable)
+
+例如对于以下控件:
+
+```js
+/* 表示控件可被聚焦. */
+w.focusable(); // true
+```
+
+`focusable()` 及 `focusable(true)` 均可匹配控件 `w`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(focusable(), '@');
+pickup({ focusable: [] }, '@');
+pickup({ focusable: null }, '@'); /* 不推荐. */
+
+pickup(focusable(true), '@');
+pickup({ focusable: true }, '@');
+```
+
+## [m#] focused
+
+### focused(b?)
+
+**`Overload [1-2]/2`** **`Global`**
+
+- **[ b = true ]** { [boolean](dataTypes#boolean) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+控件聚焦状态选择器.
+
+- 筛选条件说明: 控件的聚焦状态与指定参数相符
+- 关联控件属性: [focused](uiObjectType#m-focused)
+
+例如对于以下控件:
+
+```js
+/* 表示控件已被聚焦. */
+w.focused(); // true
+```
+
+`focused()` 及 `focused(true)` 均可匹配控件 `w`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(focused(), '@');
+pickup({ focused: [] }, '@');
+pickup({ focused: null }, '@'); /* 不推荐. */
+
+pickup(focused(true), '@');
+pickup({ focused: true }, '@');
+```
+
+## [m#] visibleToUser
+
+### visibleToUser(b?)
+
+**`Overload [1-2]/2`** **`Global`**
+
+- **[ b = true ]** { [boolean](dataTypes#boolean) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+控件对用户可见状态选择器.
+
+- 筛选条件说明: 控件的对用户可见状态与指定参数相符
+- 关联控件属性: [visibleToUser](uiObjectType#m-visibletouser)
+
+例如对于以下控件:
+
+```js
+/* 表示控件对用户可见. */
+w.visibleToUser(); // true
+```
+
+`visibleToUser()` 及 `visibleToUser(true)` 均可匹配控件 `w`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(visibleToUser(), '@');
+pickup({ visibleToUser: [] }, '@');
+pickup({ visibleToUser: null }, '@'); /* 不推荐. */
+
+pickup(visibleToUser(true), '@');
+pickup({ visibleToUser: true }, '@');
+```
+
+## [m#] accessibilityFocused
+
+### accessibilityFocused(b?)
+
+**`Overload [1-2]/2`** **`Global`**
+
+- **[ b = true ]** { [boolean](dataTypes#boolean) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+控件获取无障碍焦点状态选择器.
+
+- 筛选条件说明: 控件的获取无障碍焦点状态与指定参数相符
+- 关联控件属性: [accessibilityFocused](uiObjectType#m-accessibilityfocused)
+
+例如对于以下控件:
+
+```js
+/* 表示控件支持无障碍聚焦行为. */
+w.accessibilityFocused(); // true
+```
+
+`accessibilityFocused()` 及 `accessibilityFocused(true)` 均可匹配控件 `w`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(accessibilityFocused(), '@');
+pickup({ accessibilityFocused: [] }, '@');
+pickup({ accessibilityFocused: null }, '@'); /* 不推荐. */
+
+pickup(accessibilityFocused(true), '@');
+pickup({ accessibilityFocused: true }, '@');
+```
+
+## [m#] selected
+
+### selected(b?)
+
+**`Overload [1-2]/2`** **`Global`**
+
+- **[ b = true ]** { [boolean](dataTypes#boolean) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+控件选中状态选择器.
+
+- 筛选条件说明: 控件的选中状态与指定参数相符
+- 关联控件属性: [selected](uiObjectType#m-selected)
+
+例如对于以下控件:
+
+```js
+/* 表示控件支持选中行为. */
+w.selected(); // true
+```
+
+`selected()` 及 `selected(true)` 均可匹配控件 `w`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(selected(), '@');
+pickup({ selected: [] }, '@');
+pickup({ selected: null }, '@'); /* 不推荐. */
+
+pickup(selected(true), '@');
+pickup({ selected: true }, '@');
+```
+
+## [m#] clickable
+
+### clickable(b?)
+
+**`Overload [1-2]/2`** **`Global`**
+
+- **[ b = true ]** { [boolean](dataTypes#boolean) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+控件点击可用性选择器.
+
+- 筛选条件说明: 控件的点击可用性与指定参数相符
+- 关联控件属性: [clickable](uiObjectType#m-clickable)
+
+例如对于以下控件:
+
+```js
+/* 表示控件支持点击行为. */
+w.clickable(); // true
+```
+
+`clickable()` 及 `clickable(true)` 均可匹配控件 `w`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(clickable(), '@');
+pickup({ clickable: [] }, '@');
+pickup({ clickable: null }, '@'); /* 不推荐. */
+
+pickup(clickable(true), '@');
+pickup({ clickable: true }, '@');
+```
+
+## [m#] longClickable
+
+### longClickable(b?)
+
+**`Overload [1-2]/2`** **`Global`**
+
+- **[ b = true ]** { [boolean](dataTypes#boolean) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+控件长按可用性选择器.
+
+- 筛选条件说明: 控件的长按可用性与指定参数相符
+- 关联控件属性: [longClickable](uiObjectType#m-longclickable)
+
+例如对于以下控件:
+
+```js
+/* 表示控件支持长按行为. */
+w.longClickable(); // true
+```
+
+`longClickable()` 及 `longClickable(true)` 均可匹配控件 `w`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(longClickable(), '@');
+pickup({ longClickable: [] }, '@');
+pickup({ longClickable: null }, '@'); /* 不推荐. */
+
+pickup(longClickable(true), '@');
+pickup({ longClickable: true }, '@');
+```
+
+## [m#] enabled
+
+### enabled(b?)
+
+**`Overload [1-2]/2`** **`Global`**
+
+- **[ b = true ]** { [boolean](dataTypes#boolean) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+控件启用状态选择器.
+
+- 筛选条件说明: 控件的启用状态与指定参数相符
+- 关联控件属性: [enabled](uiObjectType#m-enabled)
+
+例如对于以下控件:
+
+```js
+/* 表示控件是启用的 (未被禁用的). */
+w.enabled(); // true
+```
+
+`enabled()` 及 `enabled(true)` 均可匹配控件 `w`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(enabled(), '@');
+pickup({ enabled: [] }, '@');
+pickup({ enabled: null }, '@'); /* 不推荐. */
+
+pickup(enabled(true), '@');
+pickup({ enabled: true }, '@');
+```
+
+## [m#] password
+
+### password(b?)
+
+**`Overload [1-2]/2`** **`Global`**
+
+- **[ b = true ]** { [boolean](dataTypes#boolean) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+控件密码型状态选择器.
+
+- 筛选条件说明: 控件的密码型状态与指定参数相符
+- 关联控件属性: [password](uiObjectType#m-password)
+
+例如对于以下控件:
+
+```js
+/* 表示控件是密码型控件. */
+w.password(); // true
+```
+
+`password()` 及 `password(true)` 均可匹配控件 `w`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(password(), '@');
+pickup({ password: [] }, '@');
+pickup({ password: null }, '@'); /* 不推荐. */
+
+pickup(password(true), '@');
+pickup({ password: true }, '@');
+```
+
+## [m#] scrollable
+
+### scrollable(b?)
+
+**`Overload [1-2]/2`** **`Global`**
+
+- **[ b = true ]** { [boolean](dataTypes#boolean) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+控件滚动可用性选择器.
+
+- 筛选条件说明: 控件的滚动可用性与指定参数相符
+- 关联控件属性: [scrollable](uiObjectType#m-scrollable)
+
+例如对于以下控件:
+
+```js
+/* 表示控件可滚动. */
+w.scrollable(); // true
+```
+
+`scrollable()` 及 `scrollable(true)` 均可匹配控件 `w`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(scrollable(), '@');
+pickup({ scrollable: [] }, '@');
+pickup({ scrollable: null }, '@'); /* 不推荐. */
+
+pickup(scrollable(true), '@');
+pickup({ scrollable: true }, '@');
+```
+
+## [m#] editable
+
+### editable(b?)
+
+**`Overload [1-2]/2`** **`Global`**
+
+- **[ b = true ]** { [boolean](dataTypes#boolean) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+控件编辑可用性选择器.
+
+- 筛选条件说明: 控件的编辑可用性与指定参数相符
+- 关联控件属性: [editable](uiObjectType#m-editable)
+
+例如对于以下控件:
+
+```js
+/* 表示控件可编辑. */
+w.editable(); // true
+```
+
+`editable()` 及 `editable(true)` 均可匹配控件 `w`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(editable(), '@');
+pickup({ editable: [] }, '@');
+pickup({ editable: null }, '@'); /* 不推荐. */
+
+pickup(editable(true), '@');
+pickup({ editable: true }, '@');
+```
+
+## [m#] contentValid
+
+### contentValid(b?)
+
+**`Overload [1-2]/2`** **`Global`**
+
+- **[ b = true ]** { [boolean](dataTypes#boolean) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+控件内容有效状态选择器.
+
+- 筛选条件说明: 控件的内容有效的状态与指定参数相符
+- 关联控件属性: isContentValid
+
+例如对于以下控件:
+
+```js
+/* 表示控件是内容有效的. */
+w.isContentValid(); // true
+```
+
+`contentValid()` 及 `contentValid(true)` 均可匹配控件 `w`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(contentValid(), '@');
+pickup({ contentValid: [] }, '@');
+pickup({ contentValid: null }, '@'); /* 不推荐. */
+
+pickup(contentValid(true), '@');
+pickup({ contentValid: true }, '@');
+```
+
+## [m#] contextClickable
+
+### contextClickable(b?)
+
+**`Overload [1-2]/2`** **`Global`**
+
+- **[ b = true ]** { [boolean](dataTypes#boolean) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+控件上下文点击有效性选择器.
+
+- 筛选条件说明: 控件的上下文点击有效性与指定参数相符
+- 关联控件属性: isContextClickable
+
+例如对于以下控件:
+
+```js
+/* 表示控件支持上下文点击行为. */
+w.isContextClickable(); // true
+```
+
+`contextClickable()` 及 `contextClickable(true)` 均可匹配控件 `w`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(contextClickable(), '@');
+pickup({ contextClickable: [] }, '@');
+pickup({ contextClickable: null }, '@'); /* 不推荐. */
+
+pickup(contextClickable(true), '@');
+pickup({ contextClickable: true }, '@');
+```
+
+## [m#] multiLine
+
+### multiLine(b?)
+
+**`Overload [1-2]/2`** **`Global`**
+
+- **[ b = true ]** { [boolean](dataTypes#boolean) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+控件多行文本编辑有效性选择器.
+
+- 筛选条件说明: 控件的多行文本编辑的有效性与指定参数相符
+- 关联控件属性: isMultiLine
+
+例如对于以下控件:
+
+```js
+/* 表示控件是文本可编辑的, 且支持多行编辑. */
+w.isMultiLine(); // true
+```
+
+`multiLine()` 及 `multiLine(true)` 均可匹配控件 `w`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(multiLine(), '@');
+pickup({ multiLine: [] }, '@');
+pickup({ multiLine: null }, '@'); /* 不推荐. */
+
+pickup(multiLine(true), '@');
+pickup({ multiLine: true }, '@');
+```
+
+## [m#] dismissable
+
+### dismissable(b?)
+
+**`Overload [1-2]/2`** **`Global`**
+
+- **[ b = true ]** { [boolean](dataTypes#boolean) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+控件消隐有效性选择器.
+
+- 筛选条件说明: 控件的消隐有效性与指定参数相符
+- 关联控件属性: isDismissable
+
+例如对于以下控件:
+
+```js
+/* 表示控件可被消隐. */
+w.isDismissable(); // true
+```
+
+`dismissable()` 及 `dismissable(true)` 均可匹配控件 `w`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(dismissable(), '@');
+pickup({ dismissable: [] }, '@');
+pickup({ dismissable: null }, '@'); /* 不推荐. */
+
+pickup(dismissable(true), '@');
+pickup({ dismissable: true }, '@');
+```
+
+## [m#] depth
+
+### depth(d)
+
+**`Global`**
+
+- **d** { [number](dataTypes#number) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+控件的 [控件层级](glossaries#控件层级) 深度数值选择器.
+
+- 筛选条件说明: 控件的控件层级深度与指定参数相符
+- 关联控件属性: [depth](uiObjectType#m-depth)
+
+例如对于以下控件:
+
+```js
+w.depth(); // 5
+```
+
+`depth(5)` 是一个控件数值选择器, 可以匹配控件 `w`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(depth(5), '@');
+pickup({ depth: 5 }, '@');
+```
+
+## [m#] rowCount
+
+### rowCount(d)
+
+**`Global`**
+
+- **d** { [number](dataTypes#number) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+控件的 [信息集控件](glossaries#信息集控件) 的行数数值选择器.
+
+- 筛选条件说明: 控件的信息集控件行数与指定参数相符
+- 关联控件属性: [rowCount](uiObjectType#m-rowcount)
+
+例如对于以下控件:
+
+```js
+w.rowCount(); // 5
+```
+
+`rowCount(5)` 是一个控件数值选择器, 可以匹配控件 `w`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(rowCount(5), '@');
+pickup({ rowCount: 5 }, '@');
+```
+
+## [m#] columnCount
+
+### columnCount(d)
+
+**`Global`**
+
+- **d** { [number](dataTypes#number) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+控件深度数值选择器.
+
+- 筛选条件说明: 控件的控件层级深度与指定参数相符
+- 关联控件属性: [columnCount](uiObjectType#m-columncount)
+
+例如对于以下控件:
+
+```js
+w.columnCount(); // 5
+```
+
+`columnCount(5)` 是一个控件数值选择器, 可以匹配控件 `w`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(columnCount(5), '@');
+pickup({ columnCount: 5 }, '@');
+```
+
+## [m#] row
+
+### row(d)
+
+**`Global`**
+
+- **d** { [number](dataTypes#number) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+控件的 [子项信息集控件](glossaries#子项信息集控件) 所在行的索引数值选择器.
+
+- 筛选条件说明: 控件的子项信息集控件所在行的索引数值与指定参数相符
+- 关联控件属性: [row](uiObjectType#m-row)
+
+例如对于以下控件:
+
+```js
+w.row(); // 5
+```
+
+`row(5)` 是一个控件数值选择器, 可以匹配控件 `w`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(row(5), '@');
+pickup({ row: 5 }, '@');
+```
+
+## [m#] column
+
+### column(d)
+
+**`Global`**
+
+- **d** { [number](dataTypes#number) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+控件的 [子项信息集控件](glossaries#子项信息集控件) 所在列的索引数值选择器.
+
+- 筛选条件说明: 控件的子项信息集控件所在列的索引值与指定参数相符
+- 关联控件属性: [column](uiObjectType#m-column)
+
+例如对于以下控件:
+
+```js
+w.column(); // 5
+```
+
+`column(5)` 是一个控件数值选择器, 可以匹配控件 `w`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(column(5), '@');
+pickup({ column: 5 }, '@');
+```
+
+## [m#] rowSpan
+
+### rowSpan(d)
+
+**`Global`**
+
+- **d** { [number](dataTypes#number) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+控件的 [子项信息集控件](glossaries#子项信息集控件) 纵跨的行数数值选择器.
+
+- 筛选条件说明: 控件的子项信息集控件纵跨的行数与指定参数相符
+- 关联控件属性: [rowSpan](uiObjectType#m-rowspan)
+
+例如对于以下控件:
+
+```js
+w.rowSpan(); // 5
+```
+
+`rowSpan(5)` 是一个控件数值选择器, 可以匹配控件 `w`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(rowSpan(5), '@');
+pickup({ rowSpan: 5 }, '@');
+```
+
+## [m#] columnSpan
+
+### columnSpan(d)
+
+**`Global`**
+
+- **d** { [number](dataTypes#number) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+控件的 [子项信息集控件](glossaries#子项信息集控件) 横跨的列数数值选择器.
+
+- 筛选条件说明: 控件的子项信息集控件横跨的列数与指定参数相符
+- 关联控件属性: [columnSpan](uiObjectType#m-columnspan)
+
+例如对于以下控件:
+
+```js
+w.columnSpan(); // 5
+```
+
+`columnSpan(5)` 是一个控件数值选择器, 可以匹配控件 `w`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(columnSpan(5), '@');
+pickup({ columnSpan: 5 }, '@');
+```
+
+## [m#] drawingOrder
+
+### drawingOrder(order)
+
+**`6.2.0`** **`Global`**
+
+- **order** { [number](dataTypes#number) } - 控件视图绘制次序
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+控件视图绘制次序数值选择器.
+
+- 筛选条件说明: 控件视图绘制次序与指定参数相符
+- 关联控件属性: [drawingOrder](uiObjectType#m-drawingorder)
+
+例如对于以下控件:
+
+```js
+w.drawingOrder(); // 23
+```
+
+`drawingOrder(23)` 可以匹配控件 `w`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(drawingOrder(23), '@');
+pickup({ drawingOrder: 23 }, '@');
+```
+
+## [m#] indexInParent
+
+### indexInParent(d)
+
+**`Global`**
+
+- **d** { [number](dataTypes#number) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+控件在其父控件索引数值选择器.
+
+- 筛选条件说明: 控件在其父控件的索引值与指定参数相符
+- 关联控件属性: [indexInParent](uiObjectType#m-indexinparent)
+
+例如对于以下控件:
+
+```js
+w.indexInParent(); // 5
+```
+
+`indexInParent(5)` 是一个控件数值选择器, 可以匹配控件 `w`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(indexInParent(5), '@');
+pickup({ indexInParent: 5 }, '@');
+```
+
+## [m#] childCount
+
+### childCount(d)
+
+**`6.2.0`** **`Global`**
+
+- **d** { [number](dataTypes#number) }
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+控件子节点数量数值选择器.
+
+- 筛选条件说明: 控件的子节点数量与指定参数相符
+- 关联控件属性: [childCount](uiObjectType#m-childcount)
+
+例如对于以下控件:
+
+```js
+w.childCount(); // 5
+```
+
+`childCount(5)` 是一个控件数值选择器, 可以匹配控件 `w`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(childCount(5), '@');
+pickup({ childCount: 5 }, '@');
+```
+
+## [m#] minChildCount
+
+### minChildCount(min)
+
+**`6.2.0`** **`Global`**
+
+- **min** { [number](dataTypes#number) } - 控件子节点数量最小值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+控件子节点数量数值选择器.
+
+- 筛选条件说明: 控件的子节点数量与指定参数限制相符
+- 关联控件属性: [childCount](uiObjectType#m-childcount)
+
+例如对于以下控件:
+
+```js
+wA.childCount(); // 0
+wB.childCount(); // 3
+wB.childCount(); // 5
+```
+
+`minChildCount(2)` 是一个控件数值选择器, 可以匹配控件 `wB` 和 `wC`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(minChildCount(2), '@');
+pickup({ minChildCount: 2 }, '@');
+```
+
+## [m#] maxChildCount
+
+### maxChildCount(max)
+
+**`6.2.0`** **`Global`**
+
+- **max** { [number](dataTypes#number) } - 控件子节点数量最大值
+- <ins>**returns**</ins> { [UiSelector](uiSelectorType) }
+
+控件子节点数量数值选择器.
+
+- 筛选条件说明: 控件的子节点数量与指定参数限制相符
+- 关联控件属性: [childCount](uiObjectType#m-childcount)
+
+例如对于以下控件:
+
+```js
+wA.childCount(); // 0
+wB.childCount(); // 3
+wB.childCount(); // 5
+```
+
+`maxChildCount(4)` 是一个控件数值选择器, 可以匹配控件 `wA` 和 `wB`.
+
+[拾取选择器](#m-pickup) 示例:
+
+```js
+pickup(maxChildCount(4), '@');
+pickup({ maxChildCount: 4 }, '@');
+```
+
+## [m#] findOnce
+
+### findOnce()
+
+**`Global`** **`Overload 1/2`** **`A11Y`**
+
+- <ins>**returns**</ins> { [UiObject](uiObjectType) | [null](dataTypes#null) }
+
+根据选择器条件筛选控件.  
+筛选结果为单个控件, 不存在任何符合筛选条件的控件时, 返回 null.
+
+特性:
+
+- 阻塞筛选 - [ × ]
+- 集合结果 - [ × ]
+
+```js
+let sel = text('hello').boundsCenterY(0.3);
+let w = sel.findOnce();
+```
+
+上述示例中, `w` 表示符合筛选条件的首个控件 (可能为 null).
+
+### findOnce(index)
+
+**`Global`** **`Overload 2/2`** **`A11Y`**
+
+- **index** { [number](dataTypes#number) } - 控件索引
+- <ins>**returns**</ins> { [UiObject](uiObjectType) | [null](dataTypes#null) }
+
+根据选择器条件筛选控件.  
+筛选结果为索引参数指定的单个控件, 不存在时返回 null.
+
+特性:
+
+- 阻塞筛选 - [ × ]
+- 集合结果 - [ × ]
+
+```js
+let sel = text('hello').boundsCenterY(0.3);
+let wA = sel.findOnce();
+let wB = sel.findOnce(0);
+let wC = sel.findOnce(4);
+```
+
+上述示例中, `wB` 与 `wA` 等价, 表示符合筛选条件的首个 (第 1 个) 控件 (可能为 null).  
+`wC` 表示第 5 个符合筛选条件的控件 (可能为 null).
+
+## [m#] exists
+
+### exists()
+
+**`Global`** **`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) }
+
+根据选择器条件判断是否存在满足筛选条件的控件.
+
+相当于 `UiSelector#findOnce() !== null`.
+
+## [m#] find
+
+### find()
+
+**`Global`** **`A11Y`**
+
+- <ins>**returns**</ins> { [UiObjectCollection](uiObjectCollectionType) }
+
+根据选择器条件筛选全部符合筛选条件的控件.  
+筛选结果为 [控件集合](uiObjectCollectionType), 不存在任何符合筛选条件的控件时, 返回空集合.
+
+特性:
+
+- 阻塞筛选 - [ × ]
+- 集合结果 - [ √ ]
+
+```js
+let sel = text('hello').boundsCenterY(0.3);
+let wc = sel.find();
+wc.forEach(w => console.log(w.centerY()));
+```
+
+上述示例中, `wc` 表示符合筛选条件的控件集合.
+
+## [m#] findOne
+
+### findOne(timeout)
+
+**`Global`** **`Overload 1/2`** **`A11Y`** **`Non-UI`**
+
+- <ins>**returns**</ins> { [UiObject](uiObjectType) | [null](dataTypes#null) }
+
+根据选择器条件持续筛选控件, 直到出现符合筛选条件的控件或筛选超时.  
+筛选结果为单个控件, 指定时限内不存在任何符合筛选条件的控件时, 返回 null.
+
+特性:
+
+- 阻塞筛选 - [ √ ]
+- 集合结果 - [ × ]
+
+```js
+let sel = text('hello').boundsCenterY(0.3);
+let w = sel.findOne(3e3); /* 3000 毫秒, 即 3 秒. */
+console.log(w.centerY());
+```
+
+上述示例中, `w` 表示 3 秒内符合筛选条件的首个控件, 超时则为 null.
+
+### findOne()
+
+**`Global`** **`Overload 2/2`** **`A11Y`** **`Non-UI`** **`DEPRECATED`**
+
+- <ins>**returns**</ins> { [UiObject](uiObjectType) }
+
+根据选择器条件持续筛选控件, 直到出现符合筛选条件的控件.  
+意味着此方法可能导致脚本 **永久阻塞**.  
+筛选结果为单个控件.
+
+特性:
+
+- 阻塞筛选 - [ √ ]
+- 集合结果 - [ × ]
+
+此方法相当于 `UiSelector#findOne(-1)`.  
+因 `findOne()` 易造成歧义及混淆, 因此被弃用, 建议使用 `findOne(-1)` 或 `untilFindOne()` 替代.
+
+```js
+let sel = text('hello').boundsCenterY(0.3);
+let w = sel.findOne();
+console.log(w.centerY());
+```
+
+上述示例中, `w` 表示符合筛选条件的首个控件.  
+第三行 `console.log(w.centerY());` 可能永远无法执行, 除非 `sel.findOne()` 筛选成功解除阻塞.
+
+## [m#] untilFindOne
+
+### untilFindOne()
+
+**`Global`** **`A11Y`** **`Non-UI`**
+
+- <ins>**returns**</ins> { [UiObject](uiObjectType) }
+
+根据选择器条件持续筛选控件, 直到出现符合筛选条件的控件.  
+意味着此方法可能导致脚本 **永久阻塞**.  
+筛选结果为单个控件.
+
+特性:
+
+- 阻塞筛选 - [ √ ]
+- 集合结果 - [ × ]
+
+此方法相当于 `UiSelector#findOne(-1)`.
+
+```js
+let sel = text('hello').boundsCenterY(0.3);
+let w = sel.untilFindOne();
+console.log(w.centerY());
+```
+
+上述示例中, `w` 表示符合筛选条件的首个控件.  
+第三行 `console.log(w.centerY());` 可能永远无法执行, 除非 `sel.untilFindOne()` 筛选成功解除阻塞.
+
+## [m#] untilFind
+
+### untilFind()
+
+**`Global`** **`A11Y`** **`Non-UI`**
+
+- <ins>**returns**</ins> { [UiObjectCollection](uiObjectCollectionType) }
+
+根据选择器条件持续筛选控件, 直到出现符合筛选条件的控件.  
+意味着此方法可能导致脚本 **永久阻塞**.  
+筛选结果为控件集合.
+
+特性:
+
+- 阻塞筛选 - [ √ ]
+- 集合结果 - [ √ ]
+
+```js
+let sel = text('hello').boundsCenterY(0.3);
+let wc = sel.untilFind();
+console.log(wc.length);
+```
+
+上述示例中, `w` 表示符合筛选条件的首个控件.  
+第三行 `console.log(wc.length);` 可能永远无法执行, 除非 `sel.untilFind()` 筛选成功解除阻塞.
+
+## [m#] waitFor
+
+### waitFor()
+
+**`Global`** **`A11Y`** **`Non-UI`** **`DEPRECATED`**
+
+- <ins>**returns**</ins> { [UiObjectCollection](uiObjectCollectionType) }
+
+根据选择器条件持续筛选控件, 直到出现符合筛选条件的控件.  
+意味着此方法可能导致脚本 **永久阻塞**.  
+筛选结果为控件集合.
+
+特性:
+
+- 阻塞筛选 - [ √ ]
+- 集合结果 - [ √ ]
+
+[UiSelector#untilFind](#untilfind) 的别名方法.
+
+因 `waitFor()` 易造成歧义及混淆, 因此被弃用, 建议使用 `untilFind()` 替代.
+
+## [m#] performAction
+
+用于执行指定的控件行为.  
+在 [控件节点行为](uiObjectActionsType) 章节已详细描述相关内容, 此处仅注明方法签名, 相关内容将不再赘述.
+
+### performAction(action, ...arguments)
+
+**`Global`** **`A11Y`**
+
+- **action** { [number](dataTypes#number) } - 行为的唯一标志符 (Action ID)
+- **arguments** { [...](documentation#可变参数)[ActionArgument](uiObjectActionsType#i-actionargument)[[]](documentation#可变参数) } - 行为参数, 用于给行为传递参数
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已执行且执行过程中无异常
+
+## [m#] click
+
+### click()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 点击 ] 行为](uiObjectActionsType#m-click).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+> 注: 此方法不是全局的, 它被 automator.click 替代
+
+## [m#] longClick
+
+### longClick()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 长按 ] 行为](uiObjectActionsType#m-longclick).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+> 注: 此方法不是全局的, 它被 automator.longClick 替代
+
+## [m#] accessibilityFocus
+
+### accessibilityFocus()
+
+**`Global`** **`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 获取无障碍焦点 ] 行为](uiObjectActionsType#m-accessibilityfocus).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] clearAccessibilityFocus
+
+### clearAccessibilityFocus()
+
+**`Global`** **`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 清除无障碍焦点 ] 行为](uiObjectActionsType#m-clearaccessibilityfocus).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] focus
+
+### focus()
+
+**`Global`** **`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 获取焦点 ] 行为](uiObjectActionsType#m-focus).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] clearFocus
+
+### clearFocus()
+
+**`Global`** **`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 清除焦点 ] 行为](uiObjectActionsType#m-clearfocus).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] dragStart
+
+### dragStart()
+
+**`6.2.0`** **`A11Y`** **`AP**`Global`** I>=32`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 拖放开始 ] 行为](uiObjectActionsType#m-dragstart).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] dragDrop
+
+### dragDrop()
+
+**`6.2.0`** **`A11Y`** **`AP**`Global`** I>=32`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 拖放放下 ] 行为](uiObjectActionsType#m-dragdrop).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] dragCancel
+
+### dragCancel()
+
+**`6.2.0`** **`A11Y`** **`AP**`Global`** I>=32`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 拖放取消 ] 行为](uiObjectActionsType#m-dragcancel).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] imeEnter
+
+### imeEnter()
+
+**`6.2.0`** **`A11Y`** **`AP**`Global`** I>=30`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 输入法 ENTER 键 ] 行为](uiObjectActionsType#m-imeenter).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] moveWindow
+
+### moveWindow(x, y)
+
+**`6.2.0`** **`A11Y`** **`AP**`Global`** I>=26`**
+
+- **x** { [number](dataTypes#number) } - X 坐标
+- **y** { [number](dataTypes#number) } - Y 坐标
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 移动窗口到新位置 ] 行为](uiObjectActionsType#m-movewindow).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] nextAtMovementGranularity
+
+### nextAtMovementGranularity(granularity, isExtendSelection)
+
+**`6.2.0`** **`Global`** **`A11Y`**
+
+- **granularity** { [number](dataTypes#number) } - 粒度
+- **isExtendSelection** { [boolean](dataTypes#boolean) } - 是否扩展选则文本
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 按粒度移至下一位置 ] 行为](uiObjectActionsType#m-nextatmovementgranularity).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] nextHtmlElement
+
+### nextHtmlElement(element)
+
+**`6.2.0`** **`Global`** **`A11Y`**
+
+- **element** { [string](dataTypes#string) } - 元素名称
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 按元素移至下一位置 ] 行为](uiObjectActionsType#m-nexthtmlelement).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] pageLeft
+
+### pageLeft()
+
+**`6.2.0`** **`A11Y`** **`AP**`Global`** I>=29`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 使视窗左移的翻页 ] 行为](uiObjectActionsType#m-pageleft).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] pageUp
+
+### pageUp()
+
+**`6.2.0`** **`A11Y`** **`AP**`Global`** I>=29`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 使视窗上移的翻页 ] 行为](uiObjectActionsType#m-pageup).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] pageRight
+
+### pageRight()
+
+**`6.2.0`** **`A11Y`** **`AP**`Global`** I>=29`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 使视窗右移的翻页 ] 行为](uiObjectActionsType#m-pageright).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] pageDown
+
+### pageDown()
+
+**`6.2.0`** **`A11Y`** **`AP**`Global`** I>=29`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 使视窗下移的翻页 ] 行为](uiObjectActionsType#m-pagedown).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] pressAndHold
+
+### pressAndHold()
+
+**`6.2.0`** **`A11Y`** **`AP**`Global`** I>=30`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 按住 ] 行为](uiObjectActionsType#m-pressandhold).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] previousAtMovementGranularity
+
+### previousAtMovementGranularity(granularity, isExtendSelection)
+
+**`6.2.0`** **`Global`** **`A11Y`**
+
+- **granularity** { [number](dataTypes#number) } - 粒度
+- **isExtendSelection** { [boolean](dataTypes#boolean) } - 是否扩展选则文本
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 按粒度移至上一位置 ] 行为](uiObjectActionsType#m-previousatmovementgranularity).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] previousHtmlElement
+
+### previousHtmlElement(element)
+
+**`6.2.0`** **`Global`** **`A11Y`**
+
+- **element** { [string](dataTypes#string) } - 元素名称
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 按元素移至上一位置 ] 行为](uiObjectActionsType#m-previoushtmlelement).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] showTextSuggestions
+
+### showTextSuggestions()
+
+**`6.2.0`** **`A11Y`** **`AP**`Global`** I>=33`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 显示文本建议 ] 行为](uiObjectActionsType#m-showtextsuggestions).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] showTooltip
+
+### showTooltip()
+
+**`6.2.0`** **`A11Y`** **`AP**`Global`** I>=28`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 显示工具提示信息 ] 行为](uiObjectActionsType#m-showtooltip).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] hideTooltip
+
+### hideTooltip()
+
+**`6.2.0`** **`A11Y`** **`AP**`Global`** I>=28`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 隐藏工具提示信息 ] 行为](uiObjectActionsType#m-hidetooltip).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] show
+
+### show()
+
+**`Global`** **`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 显示在视窗内 ] 行为](uiObjectActionsType#m-show).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] dismiss
+
+### dismiss()
+
+**`Global`** **`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 消隐 ] 行为](uiObjectActionsType#m-dismiss).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] copy
+
+### copy()
+
+**`Global`** **`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 复制文本 ] 行为](uiObjectActionsType#m-copy).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] cut
+
+### cut()
+
+**`Global`** **`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 剪切文本 ] 行为](uiObjectActionsType#m-cut).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] paste
+
+### paste()
+
+**`Global`** **`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 粘贴文本 ] 行为](uiObjectActionsType#m-paste).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] select
+
+### select()
+
+**`Global`** **`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 选中 ] 行为](uiObjectActionsType#m-select).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] expand
+
+### expand()
+
+**`Global`** **`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 展开 ] 行为](uiObjectActionsType#m-expand).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] collapse
+
+### collapse()
+
+**`Global`** **`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 折叠 ] 行为](uiObjectActionsType#m-collapse).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] scrollLeft
+
+### scrollLeft()
+
+**`Global`** **`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 使视窗左移的滚动 ] 行为](uiObjectActionsType#m-scrollleft).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] scrollUp
+
+### scrollUp()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 使视窗上移的滚动 ] 行为](uiObjectActionsType#m-scrollup).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+> 注: 此方法不是全局的, 它被 automator.scrollUp 替代
+
+## [m#] scrollRight
+
+### scrollRight()
+
+**`Global`** **`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 使视窗右移的滚动 ] 行为](uiObjectActionsType#m-scrollright).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] scrollDown
+
+### scrollDown()
+
+**`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 使视窗下移的滚动 ] 行为](uiObjectActionsType#m-scrolldown).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+> 注: 此方法不是全局的, 它被 automator.scrollDown 替代
+
+## [m#] scrollForward
+
+### scrollForward()
+
+**`Global`** **`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 使视窗前移的滚动 ] 行为](uiObjectActionsType#m-scrollforward).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] scrollBackward
+
+### scrollBackward()
+
+**`Global`** **`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 使视窗后移的滚动 ] 行为](uiObjectActionsType#m-scrollbackward).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] scrollTo
+
+### scrollTo(row, column)
+
+**`Global`** **`A11Y`**
+
+- **row** { [number](dataTypes#number) } - 行序数
+- **column** { [number](dataTypes#number) } - 列序数
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 将指定位置滚动至视窗内 ] 行为](uiObjectActionsType#m-scrollto).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] contextClick
+
+### contextClick()
+
+**`Global`** **`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 上下文点击 ] 行为](uiObjectActionsType#m-contextclick).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] setText
+
+### setText(text)
+
+**`A11Y`**
+
+- **text** { [string](dataTypes#string) } - 文本
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 设置文本 ] 行为](uiObjectActionsType#m-settext).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+> 注: 此方法不是全局的, 它被 automator.setText 替代
+
+## [m#] setSelection
+
+### setSelection(start, end)
+
+**`Global`** **`A11Y`**
+
+- **start** { [number](dataTypes#number) } - 开始位置
+- **end** { [number](dataTypes#number) } - 结束位置
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 选择文本 ] 行为](uiObjectActionsType#m-setselection).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] clearSelection
+
+### clearSelection()
+
+**`6.2.0`** **`Global`** **`A11Y`**
+
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 取消选择文本 ] 行为](uiObjectActionsType#m-clearselection).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m#] setProgress
+
+### setProgress(progress)
+
+**`Global`** **`A11Y`**
+
+- **progress** { [number](dataTypes#number) } - 进度值
+- <ins>**returns**</ins> { [boolean](dataTypes#boolean) } - 是否行为已全部执行且执行过程中无异常
+
+根据选择器条件, 使用 [untilFind](#m-untilfind) 筛选得到控件集合, 对集合执行 [[ 设置进度值 ] 行为](uiObjectActionsType#m-setprogress).
+
+因 `untilFind` 方法具有阻塞特性, 意味着此方法可能导致脚本 **永久阻塞**.
+
+## [m] pickup
+
+拾取选择器, 简称拾取器, 是高度封装的混合形式选择器, 用于在筛选控件及处理结果过程中实现快捷操作.  
+支持 [ 选择器多形式混合 / 控件罗盘 / 结果筛选 / 参化调用 ] 等.
+
+部分特性:
+
+- `pickup` 已全局化, 支持全局使用.
+- `pickup` 支持 [UiObject](uiObjectType) 类型参数, 但只是将其作为根节点进行控件筛选, 而不能对其进行罗盘导航及结果筛选等操作.
+- `pickup` 的内部实现引用了 [detect](uiObjectType#m-detect) 方法.
+
+### pickup()
+
+**`6.2.0`** **`Global`** **`Overload 1/17`** **`A11Y`**
+
+- <ins>**returns**</ins> { [UiObject](uiObjectType) | [null](dataTypes#null) }
+
+无条件拾取器, 相当于 `findOnce()`, 此时得到的控件通常是活动窗口 [depth](uiObjectType#m-depth) 为 `0` 的控件.
+
+```js
+pickup().depth(); // 0
+```
+
+### pickup(selector)
+
+**`6.2.0`** **`Global`** **`Overload 2/17`** **`A11Y`**
+
+- **selector** { [PickupSelector](dataTypes#pickupselector) }
+- <ins>**returns**</ins> { [any](dataTypes#any) }
+
+相当于 `selector.findOnce()`.
+
+selector 参数支持 [单一型选择器](dataTypes#单一型选择器) ([经典选择器](dataTypes#经典选择器) / [内容选择器](dataTypes#内容选择器) / [对象选择器](dataTypes#对象选择器)) 和 [混合型选择器](dataTypes#混合型选择器):
+
+```js
+/* 经典选择器参数. */
+let selClassic = text('abc').clickable().centerX(0.5).boundsInside(0.2, 0.05, -1, -1).action('CLICK', 'SET_TEXT', 'LONG_CLICK');
+pickup(selClassic);
+
+/* 对象选择器参数. */
+let selObject = {
+    text: 'abc',
+    clickable: [], /* 或 clickable: true . */
+    centerX: 0.5,
+    boundsInside: [ 0.2, 0.05, -1, -1 ],
+    action: [ 'CLICK', 'SET_TEXT', 'LONG_CLICK' ],
+};
+pickup(selObject);
+
+/* 混合型选择器参数. */
+pickup([ 'abc', {
+    clickable: [], /* 或 clickable: true . */
+    centerX: 0.5,
+    boundsInside: [ 0.2, 0.05, -1, -1 ],
+    action: [ 'CLICK', 'SET_TEXT', 'LONG_CLICK' ],
+} ]);
+```
+
+### pickup(selector, result)
+
+**`6.2.0`** **`Global`** **`Overload 3/17`** **`A11Y`**
+
+- **selector** { [PickupSelector](dataTypes#pickupselector) }
+- **result** { [PickupResult](dataTypes#pickupresult) }
+- <ins>**returns**</ins> { [any](dataTypes#any) }
+
+对 `selector.findOnce()` 根据 `result` 参数进行 [结果筛选](dataTypes#pickupresult) 或 [参化调用](dataTypes#uiobjectinvokable).
+
+```js
+/* 结果筛选 - 文本. */
+
+pickup(textMatch(/ab?.+/), 'text'); /* 返回符合筛选条件控件的文本, 无符合条件的控件时返回空字符串 ("") . */
+
+/* 结果筛选 - 点. */
+
+pickup(clickable(true), 'point'); /* 返回符合筛选条件控件的坐标, 无符合条件的控件时返回 null . */
+pickup(clickable(true), '.'); /* 同上. */
+
+/* 参化调用 - 获取控件矩形 (Rect) . */
+
+pickup(clickable(true), 'bounds'); /* 空指针安全. */
+clickable(true).findOnce().bounds(); /* 效果同上, 但存在潜在的空指针异常. */
+
+/* 参化调用 - 设置文本. */
+
+pickup(className('EditText'), [ 'setText', 'hello' ]); /* 空指针安全. */
+className('EditText').findOnce().setText('hello'); /* 效果同上, 但存在潜在的空指针异常. */
+
+/* 参化调用 - 设置文本选区. */
+
+pickup(className('EditText'), [ 'setSelection', 1, 5 ]); /* 空指针安全. */
+className('EditText').findOnce().setSelection(1, 5); /* 效果同上, 但存在潜在的空指针异常. */
+```
+
+### pickup(selector, compass)
+
+**`6.2.0`** **`Global`** **`Overload 4/17`** **`A11Y`**
+
+- **selector** { [PickupSelector](dataTypes#pickupselector) }
+- **compass** { [DetectCompass](dataTypes#detectcompass) }
+- <ins>**returns**</ins> { [any](dataTypes#any) }
+
+对 `selector.findOnce()` 进行 [罗盘定位](uiObjecttype#m-compass).
+
+```js
+pickup(text('abc'), 'p3'); /* 空指针安全. */
+text('abc').findOnce().parent().parent().parent(); /* 效果同上, 但存在潜在的空指针异常. */
+```
+
+### pickup(selector, compass, result)
+
+**`6.2.0`** **`Global`** **`Overload 5/17`** **`A11Y`**
+
+- **selector** { [PickupSelector](dataTypes#pickupselector) }
+- **compass** { [DetectCompass](dataTypes#detectcompass) }
+- **result** { [PickupResult](dataTypes#pickupresult) }
+- <ins>**returns**</ins> { [any](dataTypes#any) }
+
+对 `selector.findOnce()` 进行 [罗盘定位](uiObjecttype#m-compass) 后, 再进行 [结果筛选](dataTypes#pickupresult) 或 [参化调用](dataTypes#uiobjectinvokable).
+
+```js
+pickup(text('abc'), 'p3', 'click'); /* 空指针安全. */
+text('abc').findOnce().parent().parent().parent().click(); /* 效果同上, 但存在潜在的空指针异常. */
+
+pickup(text('abc'), 's>1', 'bounds'); /* 空指针安全. */
+let w = text('abc').findOnce();
+w.parent().child(w.indexInParent() + 1).bounds(); /* 效果同上, 但存在潜在的空指针异常. */
+```
+
+### pickup(root, selector)
+
+**`6.2.0`** **`Global`** **`Overload 6/17`** **`A11Y`**
+
+- **root** { [UiObject](uiObjectType) }
+- **selector** { [PickupSelector](dataTypes#pickupselector) }
+- <ins>**returns**</ins> { [any](dataTypes#any) }
+
+以 `root` 参数指定的控件为根节点, 执行 `selector.findOnce()` 筛选.
+
+```js
+let w = text('abc').findOnce();
+pickup(w, 'xyz'); /* 在 w 控件的所有子孙节点中筛选内容为 'xyz' 的控件. */
+```
+
+> 参阅: [pickup(selector)](#pickupselector)
+
+### pickup(root, selector, result)
+
+**`6.2.0`** **`Global`** **`Overload 7/17`** **`A11Y`**
+
+- **root** { [UiObject](uiObjectType) }
+- **selector** { [PickupSelector](dataTypes#pickupselector) }
+- **result** { [PickupResult](dataTypes#pickupresult) }
+- <ins>**returns**</ins> { [any](dataTypes#any) }
+
+以 `root` 参数指定的控件为根节点, 对 `selector.findOnce()` 根据 `result` 参数进行 [结果筛选](dataTypes#pickupresult) 或 [参化调用](dataTypes#uiobjectinvokable).
+
+```js
+let w = text('abc').findOnce();
+pickup(w, 'xyz', 'height'); /* 在 w 控件的所有子孙节点中筛选内容为 'xyz' 的控件的高度. */
+```
+
+> 参阅: [pickup(selector, result)](#pickupselector-result)
+
+### pickup(root, selector, compass)
+
+**`6.2.0`** **`Global`** **`Overload 8/17`** **`A11Y`**
+
+- **root** { [UiObject](uiObjectType) }
+- **selector** { [PickupSelector](dataTypes#pickupselector) }
+- **compass** { [DetectCompass](dataTypes#detectcompass) }
+- <ins>**returns**</ins> { [any](dataTypes#any) }
+
+以 `root` 参数指定的控件为根节点, 对 `selector.findOnce()` 进行 [罗盘定位](uiObjecttype#m-compass).
+
+```js
+let w = text('abc').findOnce();
+pickup(w, 'xyz', 'p2'); /* 在 w 控件的所有子孙节点中筛选内容为 'xyz' 的控件的二级父节点. */
+```
+
+> 参阅: [pickup(selector, compass)](#pickupselector-compass)
+
+### pickup(root, selector, compass, result)
+
+**`6.2.0`** **`Global`** **`Overload 9/17`** **`A11Y`**
+
+- **root** { [UiObject](uiObjectType) }
+- **selector** { [PickupSelector](dataTypes#pickupselector) }
+- **compass** { [DetectCompass](dataTypes#detectcompass) }
+- **result** { [PickupResult](dataTypes#pickupresult) }
+- <ins>**returns**</ins> { [any](dataTypes#any) }
+
+以 `root` 参数指定的控件为根节点, 对 `selector.findOnce()` 进行 [罗盘定位](uiObjecttype#m-compass) 后, 再进行 [结果筛选](dataTypes#pickupresult) 或 [参化调用](dataTypes#uiobjectinvokable).
+
+```js
+let w = text('abc').findOnce();
+pickup(w, 'xyz', 'p2', 'width'); /* 在 w 控件的所有子孙节点中筛选内容为 'xyz' 的控件的二级父节点的宽度. */
+```
+
+> 参阅: [pickup(selector, compass, result)](#pickupselector-compass-result)
+
+### pickup(selector, callback)
+
+**`6.2.0`** **`Global`** **`Overload 10/17`** **`A11Y`**
+
+- **selector** { [PickupSelector](dataTypes#pickupselector) }
+- **callback** { [(](dataTypes#function)o: [any](dataTypes#any)[)](dataTypes#function) [=>](dataTypes#function) [R](dataTypes#generic) }
+- <ins>**returns**</ins> { [R](dataTypes#generic) }
+
+对 [pickup(selector)](#pickupselector) 增加回调处理, 将回调函数的返回值 (`undefined` 除外) 作为最终结果. 当回调函数返回 `undefined` 时, 则将拾取器的结果作为最终结果.
+
+```js
+pickup(text('abc'), (o) => {
+    if (o !== null) {
+        console.log(`已找到所需控件, 其文本为${o.text()}`);
+        return o.text();
+    } else {
+        console.warn(`未找到所需控件`);
+        return '';
+    }
+}); /* pickup 的结果可能为所需控件文本或空字符串. */
+```
+
+### pickup(selector, result, callback)
+
+**`6.2.0`** **`Global`** **`Overload 11/17`** **`A11Y`**
+
+- **selector** { [PickupSelector](dataTypes#pickupselector) }
+- **result** { [PickupResult](dataTypes#pickupresult) }
+- **callback** { [(](dataTypes#function)o: [any](dataTypes#any)[)](dataTypes#function) [=>](dataTypes#function) [R](dataTypes#generic) }
+- <ins>**returns**</ins> { [any](dataTypes#any) }
+
+对 [pickup(selector, result)](#pickupselector-result) 增加回调处理, 将回调函数的返回值 (`undefined` 除外) 作为最终结果. 当回调函数返回 `undefined` 时, 则将拾取器的结果作为最终结果.
+
+```js
+pickup(clickable(true), 'point', (o) => {
+    if (o !== null) {
+        console.log(`已找到控件, 其中心位于坐标${o}`);
+        return o;
+    }
+    return org.opencv.core.Point();
+}); /* pickup 返回控件真实坐标点或坐标点 (0, 0) . */
+```
+
+### pickup(selector, compass, callback)
+
+**`6.2.0`** **`Global`** **`Overload 12/17`** **`A11Y`**
+
+- **selector** { [PickupSelector](dataTypes#pickupselector) }
+- **compass** { [DetectCompass](dataTypes#detectcompass) }
+- **callback** { [(](dataTypes#function)o: [any](dataTypes#any)[)](dataTypes#function) [=>](dataTypes#function) [R](dataTypes#generic) }
+- <ins>**returns**</ins> { [any](dataTypes#any) }
+
+对 [pickup(selector, compass)](#pickupselector-compass) 增加回调处理, 将回调函数的返回值 (`undefined` 除外) 作为最终结果. 当回调函数返回 `undefined` 时, 则将拾取器的结果作为最终结果.
+
+```js
+pickup(text('abc'), 'p3', (o) => {
+    if (o !== null && o.childCount() > 0) {
+        o.children().forEach(w => w.setText('hello'));
+    }
+}); /* pickup 结果为原本的拾取结果. */
+```
+
+### pickup(selector, compass, result, callback)
+
+**`6.2.0`** **`Global`** **`Overload 13/17`** **`A11Y`**
+
+- **selector** { [PickupSelector](dataTypes#pickupselector) }
+- **compass** { [DetectCompass](dataTypes#detectcompass) }
+- **result** { [PickupResult](dataTypes#pickupresult) }
+- **callback** { [(](dataTypes#function)o: [any](dataTypes#any)[)](dataTypes#function) [=>](dataTypes#function) [R](dataTypes#generic) }
+- <ins>**returns**</ins> { [any](dataTypes#any) }
+
+以 `root` 参数指定的控件为根节点, 对 [pickup(selector, compass, result)](#pickupselector-compass-result) 增加回调处理, 将回调函数的返回值 (`undefined` 除外) 作为最终结果. 当回调函数返回 `undefined` 时, 则将拾取器的结果作为最终结果.
+
+### pickup(root, selector, callback)
+
+**`6.2.0`** **`Global`** **`Overload 14/17`** **`A11Y`**
+
+- **root** { [UiObject](uiObjectType) }
+- **selector** { [PickupSelector](dataTypes#pickupselector) }
+- **callback** { [(](dataTypes#function)o: [any](dataTypes#any)[)](dataTypes#function) [=>](dataTypes#function) [R](dataTypes#generic) }
+- <ins>**returns**</ins> { [R](dataTypes#generic) }
+
+对 [pickup(selector)](#pickupselector) 增加回调处理, 将回调函数的返回值 (`undefined` 除外) 作为最终结果. 当回调函数返回 `undefined` 时, 则将拾取器的结果作为最终结果.
+
+```js
+/* w 将作为根节点. */
+/* 也可使用 pickup({descMatch: /hello?.+/}) 替换. */
+let w = descMatch(/hello?.+/).findOnce();
+
+pickup(w, text('abc'), (o) => {
+    if (o !== null) {
+        console.log(`已找到所需控件, 其文本为${o.text()}`);
+        return o.text();
+    } else {
+        console.warn(`未找到所需控件`);
+        return '';
+    }
+}); /* pickup 的结果可能为所需控件文本或空字符串. */
+```
+
+### pickup(root, selector, result, callback)
+
+**`6.2.0`** **`Global`** **`Overload 15/17`** **`A11Y`**
+
+- **root** { [UiObject](uiObjectType) }
+- **selector** { [PickupSelector](dataTypes#pickupselector) }
+- **result** { [PickupResult](dataTypes#pickupresult) }
+- **callback** { [(](dataTypes#function)o: [any](dataTypes#any)[)](dataTypes#function) [=>](dataTypes#function) [R](dataTypes#generic) }
+- <ins>**returns**</ins> { [any](dataTypes#any) }
+
+以 `root` 参数指定的控件为根节点, 对 [pickup(selector, result)](#pickupselector-result) 增加回调处理, 将回调函数的返回值 (`undefined` 除外) 作为最终结果. 当回调函数返回 `undefined` 时, 则将拾取器的结果作为最终结果.
+
+```js
+/* w 将作为根节点. */
+/* 也可使用 pickup({descMatch: /hello?.+/}) 替换. */
+let w = descMatch(/hello?.+/).findOnce();
+
+pickup(w, clickable(true), 'point', (o) => {
+    if (o !== null) {
+        console.log(`已找到控件, 其中心位于坐标${o}`);
+        return o;
+    }
+    return org.opencv.core.Point();
+}); /* pickup 返回控件真实坐标点或坐标点 (0, 0) . */
+```
+
+### pickup(root, selector, compass, callback)
+
+**`6.2.0`** **`Global`** **`Overload 16/17`** **`A11Y`**
+
+- **root** { [UiObject](uiObjectType) }
+- **selector** { [PickupSelector](dataTypes#pickupselector) }
+- **compass** { [DetectCompass](dataTypes#detectcompass) }
+- **callback** { [(](dataTypes#function)o: [any](dataTypes#any)[)](dataTypes#function) [=>](dataTypes#function) [R](dataTypes#generic) }
+- <ins>**returns**</ins> { [any](dataTypes#any) }
+
+以 `root` 参数指定的控件为根节点, 对 [pickup(selector, compass)](#pickupselector-compass) 增加回调处理, 将回调函数的返回值 (`undefined` 除外) 作为最终结果. 当回调函数返回 `undefined` 时, 则将拾取器的结果作为最终结果.
+
+```js
+/* w 将作为根节点. */
+/* 也可使用 pickup({descMatch: /hello?.+/}) 替换. */
+let w = descMatch(/hello?.+/).findOnce();
+
+pickup(w, text('abc'), 'p3', (o) => {
+    if (o !== null && o.childCount() > 0) {
+        o.children().forEach(w => w.setText('hello'));
+    }
+}); /* pickup 结果为原本的拾取结果. */
+```
+
+### pickup(root, selector, compass, result, callback)
+
+**`6.2.0`** **`Global`** **`Overload 17/17`** **`A11Y`**
+
+- **root** { [UiObject](uiObjectType) }
+- **selector** { [PickupSelector](dataTypes#pickupselector) }
+- **compass** { [DetectCompass](dataTypes#detectcompass) }
+- **result** { [PickupResult](dataTypes#pickupresult) }
+- **callback** { [(](dataTypes#function)o: [any](dataTypes#any)[)](dataTypes#function) [=>](dataTypes#function) [R](dataTypes#generic) }
+- <ins>**returns**</ins> { [any](dataTypes#any) }
+
+以 `root` 参数指定的控件为根节点, 对 [pickup(selector, compass, result)](#pickupselector-compass-result) 增加回调处理, 将回调函数的返回值 (`undefined` 除外) 作为最终结果. 当回调函数返回 `undefined` 时, 则将拾取器的结果作为最终结果.
+
+```js
+/* w 将作为根节点. */
+/* 也可使用 pickup({descMatch: /hello?.+/}) 替换. */
+let w = descMatch(/hello?.+/).findOnce();
+
+pickup(w, text('abc'), 's>1', 'bounds', (o) => {
+    if (o === null) {
+        throw Error('获取控件矩形失败, 请确保前台页面符合需求.');
+    }
+}); /* 如果没有异常, pickup 结果为原本的拾取结果. */
+```
+
+# 筛选器类型
+
+## xxxStartsWith
+
+前缀匹配筛选器.
+
+筛选条件为 [字符串](dataTypes#string) 类型, 匹配对应控件属性串值的前缀.
+
+```js
+w.desc(); // splendid
+descStartsWith('spl'); /* 可匹配 w. */
+descStartsWith('spa'); /* 不可匹配 w. */
+```
+
+## xxxEndsWith
+
+后缀匹配筛选器.
+
+筛选条件为 [字符串](dataTypes#string) 类型, 匹配对应控件属性串值的后缀.
+
+```js
+w.desc(); // splendid
+descEndsWith('did'); /* 可匹配 w. */
+descEndsWith('diy'); /* 不可匹配 w. */
+```
+
+## xxxContains
+
+包含匹配筛选器.
+
+筛选条件为 [字符串](dataTypes#string) 类型, 匹配任意长度连续的控件属性串值.
+
+```js
+w.desc(); // splendid
+descContains('did'); /* 可匹配 w. */
+descContains('spl'); /* 可匹配 w. */
+descContains('len'); /* 可匹配 w. */
+descContains(''); /* 可匹配 w, 但通常无实际意义. */
+descContains('app'); /* 不可匹配 w. */
+```
+
+## xxxMatches
+
+正则全匹配筛选器.
+
+筛选条件为 [字符串](dataTypes#string) 类型或 [正则表达式](dataTypes#regexp) 类型, 按正则表达式规则完全匹配控件属性串值.
+
+### 正则表达式类型
+
+筛选条件为正则表达式类型时, 效果等同于 JavaScript 的 [RegExp.prototype.test](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/RegExp/test), 但依照起止位置做完全匹配, 相当于自动添加匹配起始位置的 `^` 与匹配结束位置的 `$`.
+
+```js
+w.desc(); // splendid
+/* 相当于 descMatch(/^s.*did$/) . */
+descMatches(/s.*did/); /* 不可匹配 w. */
+/* 相当于 descMatch(/^did$/) . */
+descMatches(/did/); /* 不可匹配 w. */
+/* 相当于 descMatch(/^did$/) . */
+descMatches(/did$/); /* 不可匹配 w. */
+/* 相当于 descMatch(/^did$/) . */
+descMatches(/^did/); /* 不可匹配 w. */
+/* 相当于 descMatch(/^.*did.*$/) . */
+descMatches(/.*did.*/); /* 可匹配 w. */
+/* 相当于 descMatch(/^l[ae]ng?$/) . */
+descMatches(/l[ae]ng?/); /* 不可匹配 w. */
+/* 相当于 descMatch(/^.+$/) . */
+descMatches(/.+/); /* 可匹配 w. */
+/* 相当于 descMatch(/^(?:)$/) . */
+descMatches(/(?:)/); /* 不可匹配 w. */
+/* 相当于 descMatch(/^spl\.?.+$/) . */
+descMatches(new RegExp('spl\\.?.+$')); /* 不可匹配 w. */
+```
+
+### 字符串类型
+
+筛选条件为字符串类型时, 相当于 JavaScript 的 [RegExp.prototype.constructor](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/RegExp/RegExp) 构造函数的 `pattern (模式)` 参数, 但依照起止位置做完全匹配, 相当于自动添加匹配起始位置的 `^` 与匹配结束位置的 `$`.
+
+如字符串 `'abc'` 按照正则表达式 `/^abc$/` 处理,  
+字符串 `'\\d+'` 按照正则表达式 `/^\d+$/` 处理.
+
+```js
+w.desc(); // splendid
+/* 相当于 descMatch(/^s.*did$/) . */
+descMatches('s.*did'); /* 不可匹配 w. */
+/* 相当于 descMatch(/^did$/) . */
+descMatches('did'); /* 不可匹配 w. */
+/* 相当于 descMatch(/^did$/) . */
+descMatches('did$'); /* 不可匹配 w. */
+/* 相当于 descMatch(/^did$/) . */
+descMatches('^did'); /* 不可匹配 w. */
+/* 相当于 descMatch(/^.*did.*$/) . */
+descMatches('.*did.*'); /* 可匹配 w. */
+/* 相当于 descMatch(/^l[ae]ng?$/) . */
+descMatches('l[ae]ng?'); /* 不可匹配 w. */
+/* 相当于 descMatch(/^.+$/) . */
+descMatches('.+'); /* 可匹配 w. */
+/* 相当于 descMatch(/^$/) . */
+descMatches(''); /* 不可匹配 w. */
+/* 相当于 descMatch(/^spl\.?.+$/) . */
+descMatches('spl\\.?.+$'); /* 不可匹配 w. */
+```
+
+对于 xxxMatches, 会经常出现类似如下的匹配方式:
+
+```js
+/* 相当于 descMatch(/^.*word.*$/) . */
+xxxMatches(/.*word.*/); /* 或 xxxMatches('.*word.*') . */
+```
+
+而对于 xxxMatch, 其匹配方式往往更符合 JavaScript 开发者的使用习惯:
+
+```js
+xxxMatch(/word/);
+```
+
+方法 xxxMatches 的内部实现采用 Java [matches](https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#matches(java.lang.String)), 它与 JavaScript [match](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/String/match) 的不同导致上述使用方式的差异.
+
+因此在 AutoJs6 中, xxxMatches 的全部方法均已标记为 `Deprecated (已弃用)`, 除非需要考虑多版本兼容, 否则建议始终使用 xxxMatch 替代 xxxMatches.
+
+> 参阅: [Difference in results between Java matches vs JavaScript match](https://stackoverflow.com/questions/21883629/difference-in-results-between-java-matches-vs-javascript-match)
+
+## xxxMatch
+
+正则匹配筛选器.
+
+筛选条件为 [字符串](dataTypes#string) 类型或 [正则表达式](dataTypes#regexp) 类型, 按正则表达式规则匹配控件属性串值.
+
+### 正则表达式类型
+
+筛选条件为正则表达式类型时, 效果等同于 JavaScript 的 [RegExp.prototype.test](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/RegExp/test).
+
+```js
+w.desc(); // splendid
+descMatch(/s.*did/); /* 可匹配 w. */
+descMatch(/did/); /* 可匹配 w. */
+descMatch(/did$/); /* 可匹配 w. */
+descMatch(/^did/); /* 不可匹配 w. */
+descMatch(/l[ae]ng?/); /* 可匹配 w. */
+descMatch(/.+/); /* 可匹配 w, 与 descMatch(/(?:)/) 效果相同. */
+descMatch(new RegExp('spl\\.?.+$')); /* 可匹配 w. */
+```
+
+### 字符串类型
+
+筛选条件为字符串类型时, 相当于 JavaScript 的 [RegExp.prototype.constructor](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/RegExp/RegExp) 构造函数的 `pattern (模式)` 参数.
+
+如字符串 `'abc'` 按照正则表达式 `/abc/` 处理,  
+字符串 `'\\d+'` 按照正则表达式 `/\d+/` 处理.
+
+```js
+w.desc(); // splendid
+/* 相当于 descMatch(/s.*did/) . */
+descMatch('s.*did'); /* 可匹配 w. */
+/* 相当于 descMatch(/did/) . */
+descMatch('did'); /* 可匹配 w. */
+/* 相当于 descMatch(/did$/) . */
+descMatch('did$'); /* 可匹配 w. */
+/* 相当于 descMatch(/^did/) . */
+descMatch('^did'); /* 不可匹配 w. */
+/* 相当于 descMatch(/l[ae]ng?/) . */
+descMatch('l[ae]ng?'); /* 可匹配 w. */
+/* 相当于 descMatch(/.+/) . */
+descMatch('.+'); /* 可匹配 w, 与 descMatch('') 效果相同. */
+/* 相当于 descMatch(/spl\.?.+$/) . */
+descMatch('spl\\.?.+$'); /* 可匹配 w. */
+```
\ No newline at end of file
diff --git a/api/util.md b/api/util.md
index 96a8135..e9d7b9d 100644
--- a/api/util.md
+++ b/api/util.md
@@ -1,7 +1,5 @@
 # Util
 
-> Stability: 2 - Stable
-
 The `util` module is primarily designed to support the needs of Node.js' own
 internal APIs. However, many of the utilities are useful for application and
 module developers as well. It can be accessed using:
@@ -565,8 +563,6 @@ see [Custom promisified functions][].
 added: v8.3.0
 -->
 
-> Stability: 1 - Experimental
-
 An implementation of the [WHATWG Encoding Standard][] `TextDecoder` API.
 
 ```js
@@ -705,8 +701,6 @@ mark.
 added: v8.3.0
 -->
 
-> Stability: 1 - Experimental
-
 An implementation of the [WHATWG Encoding Standard][] `TextEncoder` API. All
 instances of `TextEncoder` only support UTF-8 encoding.
 
@@ -741,8 +735,6 @@ added: v0.7.5
 deprecated: v6.0.0
 -->
 
-> Stability: 0 - Deprecated: Use [`Object.assign()`] instead.
-
 The `util._extend()` method was never intended to be used outside of internal
 Node.js modules. The community found and used it anyway.
 
@@ -756,8 +748,6 @@ added: v0.3.0
 deprecated: v0.11.3
 -->
 
-> Stability: 0 - Deprecated: Use [`console.error()`][] instead.
-
 * `string` {string} The message to print to `stderr`
 
 Deprecated predecessor of `console.error`.
@@ -769,8 +759,6 @@ added: v0.3.0
 deprecated: v0.11.3
 -->
 
-> Stability: 0 - Deprecated: Use [`console.error()`][] instead.
-
 * `...strings` {string} The message to print to `stderr`
 
 Deprecated predecessor of `console.error`.
@@ -782,8 +770,6 @@ added: v0.6.0
 deprecated: v4.0.0
 -->
 
-> Stability: 0 - Deprecated
-
 * `object` {any}
 
 Internal alias for [`Array.isArray`][].
@@ -808,8 +794,6 @@ added: v0.11.5
 deprecated: v4.0.0
 -->
 
-> Stability: 0 - Deprecated
-
 * `object` {any}
 
 Returns `true` if the given `object` is a `Boolean`. Otherwise, returns `false`.
@@ -832,8 +816,6 @@ added: v0.11.5
 deprecated: v4.0.0
 -->
 
-> Stability: 0 - Deprecated: Use [`Buffer.isBuffer()`][] instead.
-
 * `object` {any}
 
 Returns `true` if the given `object` is a `Buffer`. Otherwise, returns `false`.
@@ -856,8 +838,6 @@ added: v0.6.0
 deprecated: v4.0.0
 -->
 
-> Stability: 0 - Deprecated
-
 * `object` {any}
 
 Returns `true` if the given `object` is a `Date`. Otherwise, returns `false`.
@@ -880,8 +860,6 @@ added: v0.6.0
 deprecated: v4.0.0
 -->
 
-> Stability: 0 - Deprecated
-
 * `object` {any}
 
 Returns `true` if the given `object` is an [`Error`][]. Otherwise, returns
@@ -920,8 +898,6 @@ added: v0.11.5
 deprecated: v4.0.0
 -->
 
-> Stability: 0 - Deprecated
-
 * `object` {any}
 
 Returns `true` if the given `object` is a `Function`. Otherwise, returns
@@ -948,8 +924,6 @@ added: v0.11.5
 deprecated: v4.0.0
 -->
 
-> Stability: 0 - Deprecated
-
 * `object` {any}
 
 Returns `true` if the given `object` is strictly `null`. Otherwise, returns
@@ -973,8 +947,6 @@ added: v0.11.5
 deprecated: v4.0.0
 -->
 
-> Stability: 0 - Deprecated
-
 * `object` {any}
 
 Returns `true` if the given `object` is `null` or `undefined`. Otherwise,
@@ -998,8 +970,6 @@ added: v0.11.5
 deprecated: v4.0.0
 -->
 
-> Stability: 0 - Deprecated
-
 * `object` {any}
 
 Returns `true` if the given `object` is a `Number`. Otherwise, returns `false`.
@@ -1024,8 +994,6 @@ added: v0.11.5
 deprecated: v4.0.0
 -->
 
-> Stability: 0 - Deprecated
-
 * `object` {any}
 
 Returns `true` if the given `object` is strictly an `Object` **and** not a
@@ -1051,8 +1019,6 @@ added: v0.11.5
 deprecated: v4.0.0
 -->
 
-> Stability: 0 - Deprecated
-
 * `object` {any}
 
 Returns `true` if the given `object` is a primitive type. Otherwise, returns
@@ -1088,8 +1054,6 @@ added: v0.6.0
 deprecated: v4.0.0
 -->
 
-> Stability: 0 - Deprecated
-
 * `object` {any}
 
 Returns `true` if the given `object` is a `RegExp`. Otherwise, returns `false`.
@@ -1112,8 +1076,6 @@ added: v0.11.5
 deprecated: v4.0.0
 -->
 
-> Stability: 0 - Deprecated
-
 * `object` {any}
 
 Returns `true` if the given `object` is a `string`. Otherwise, returns `false`.
@@ -1138,8 +1100,6 @@ added: v0.11.5
 deprecated: v4.0.0
 -->
 
-> Stability: 0 - Deprecated
-
 * `object` {any}
 
 Returns `true` if the given `object` is a `Symbol`. Otherwise, returns `false`.
@@ -1162,8 +1122,6 @@ added: v0.11.5
 deprecated: v4.0.0
 -->
 
-> Stability: 0 - Deprecated
-
 * `object` {any}
 
 Returns `true` if the given `object` is `undefined`. Otherwise, returns `false`.
@@ -1187,8 +1145,6 @@ added: v0.3.0
 deprecated: v6.0.0
 -->
 
-> Stability: 0 - Deprecated: Use a third party module instead.
-
 * `string` {string}
 
 The `util.log()` method prints the given `string` to `stdout` with an included
@@ -1207,8 +1163,6 @@ added: v0.3.0
 deprecated: v0.11.3
 -->
 
-> Stability: 0 - Deprecated: Use [`console.log()`][] instead.
-
 Deprecated predecessor of `console.log`.
 
 ### util.puts([...strings])
@@ -1218,8 +1172,6 @@ added: v0.3.0
 deprecated: v0.11.3
 -->
 
-> Stability: 0 - Deprecated: Use [`console.log()`][] instead.
-
 Deprecated predecessor of `console.log`.
 
 [`'uncaughtException'`]: process.html#process_event_uncaughtexception
diff --git a/api/web.md b/api/web.md
new file mode 100644
index 0000000..05831ea
--- /dev/null
+++ b/api/web.md
@@ -0,0 +1,10 @@
+# 万维网 (Web)
+
+---
+
+<p style="font: italic 1em sans-serif; color: #78909C">此章节待补充或完善...</p>
+<p style="font: italic 1em sans-serif; color: #78909C">Marked by SuperMonster003 on Oct 22, 2022.</p>
+
+---
+
+
diff --git a/api/widgetsBasedAutomation.md b/api/widgetsBasedAutomation.md
deleted file mode 100644
index 397b114..0000000
--- a/api/widgetsBasedAutomation.md
+++ /dev/null
@@ -1,1226 +0,0 @@
-# 基于控件的操作
-
-基于控件的操作指的是选择屏幕上的控件，获取其信息或对其进行操作。对于一般软件而言，基于控件的操作对不同机型有很好的兼容性；但是对于游戏而言，由于游戏界面并不是由控件构成，无法采用本章节的方法，也无法使用本章节的函数。有关游戏脚本的编写，请参考《基于坐标的操作》。
-
-基于控件的操作依赖于无障碍服务，因此最好在脚本开头使用`auto()`函数来确保无障碍服务已经启用。如果运行到某个需要权限的语句无障碍服务并没启动，则会抛出异常并跳转到无障碍服务界面。这样的用户体验并不好，因为需要重新运行脚本，后续会加入等待无障碍服务启动并让脚本继续运行的函数。
-
-您也可以在脚本开头使用`"auto";`表示这个脚本需要无障碍服务，但是不推荐这种做法，因为这个标记必须在脚本的最开头(前面不能有注释或其他语句、空格等)，我们推荐使用`auto()`函数来确保无障碍服务已启用。
-
-## auto([mode])
-
-* `mode` {string} 模式
-
-检查无障碍服务是否已经启用，如果没有启用则抛出异常并跳转到无障碍服务启用界面；同时设置无障碍模式为mode。mode的可选值为：
-
-* `fast` 快速模式。该模式下会启用控件缓存，从而选择器获取屏幕控件更快。对于需要快速的控件操作的脚本可以使用该模式，一般脚本则没有必要使用该函数。
-* `normal` 正常模式，默认。
-
-如果不加mode参数，则为正常模式。
-
-建议使用`auto.waitFor()`和`auto.setMode()`代替该函数，因为`auto()`函数如果无障碍服务未启动会停止脚本；而`auto.waitFor()`则会在在无障碍服务启动后继续运行。
-
-示例：
-
-```
-auto("fast");
-```
-
-示例2：
-
-```
-auto();
-```
-
-## auto.waitFor()
-
-检查无障碍服务是否已经启用，如果没有启用则跳转到无障碍服务启用界面，并等待无障碍服务启动；当无障碍服务启动后脚本会继续运行。
-
-因为该函数是阻塞的，因此除非是有协程特性，否则不能在ui模式下运行该函数，建议在ui模式下使用`auto()`函数。
-
-## auto.setMode(mode)
-
-* `mode` {string} 模式
-
-设置无障碍模式为mode。mode的可选值为：
-
-* `fast` 快速模式。该模式下会启用控件缓存，从而选择器获取屏幕控件更快。对于需要快速的控件查看和操作的脚本可以使用该模式，一般脚本则没有必要使用该函数。
-* `normal` 正常模式，默认。
-
-## auto.setFlags(flags)
-
-**[v4.1.0新增]**
-
-* `flags` {string} | {Array} 一些标志，来启用和禁用某些特性，包括：
-    * `findOnUiThread` 使用该特性后，选择器搜索时会在主进程进行。该特性用于解决线程安全问题导致的次生问题，不过目前貌似已知问题并不是线程安全问题。
-    * `useUsageStats` 使用该特性后，将会以"使用情况统计"服务的结果来检测当前正在运行的应用包名（需要授予"查看使用情况统计"权限)。如果觉得currentPackage()返回的结果不太准确，可以尝试该特性。
-    * `useShell` 使用该特性后，将使用shell命令获取当前正在运行的应用的包名、活动名称，但是需要root权限。
-
-启用有关automator的一些特性。例如：
-
-```
-auto.setFlags(["findOnUiThread", "useShell"]);
-```
-
-## auto.serivce
-
-**[v4.1.0新增]**
-
-* [AccessibilityService](https://developer.android.com/reference/android/accessibilityservice/AccessibilityService)
-
-获取无障碍服务。如果无障碍服务没有启动，则返回`null`。
-
-参见[AccessibilityService](https://developer.android.com/reference/android/accessibilityservice/AccessibilityService)。
-
-## auto.windows
-
-**[v4.1.0新增]**
-
-* {Array}
-
-当前所有窗口([AccessibilityWindowInfo](https://developer.android.com/reference/android/view/accessibility/AccessibilityWindowInfo))的数组，可能包括状态栏、输入法、当前应用窗口，弹出窗口、悬浮窗、分屏应用窗口等。可以分别获取每个窗口的布局信息。
-
-该函数需要Android 5.0以上才能运行。
-
-## auto.root
-
-**[v4.1.0新增]**
-
-* {UiObject}
-
-当前窗口的布局根元素。如果无障碍服务未启动或者WindowFilter均返回false，则会返回`null`。
-
-如果不设置windowFilter，则当前窗口即为活跃的窗口（获取到焦点、正在触摸的窗口）；如果设置了windowFilter，则获取的是过滤的窗口中的第一个窗口。
-
-如果系统是Android5.0以下，则始终返回当前活跃的窗口的布局根元素。
-
-## auto.rootInActiveWindow
-
-**[v4.1.0新增]**
-
-* {UiObject}
-
-当前活跃的窗口（获取到焦点、正在触摸的窗口）的布局根元素。如果无障碍服务未启动则为`null`。
-
-## auto.setWindowFilter(filter)
-
-**[v4.1.0新增]**
-
-* `filter` {Function} 参数为窗口([AccessibilityWindowInfo](https://developer.android.com/reference/android/view/accessibility/AccessibilityWindowInfo))，返回值为Boolean的函数。
-
-设置窗口过滤器。这个过滤器可以决定哪些窗口是目标窗口，并影响选择器的搜索。例如，如果想要选择器在所有窗口（包括状态栏、输入法等）中搜索，只需要使用以下代码：
-
-```
-auto.setWindowFilter(function(window){
-    //不管是如何窗口，都返回true，表示在该窗口中搜索
-    return true;
-});
-```
-
-又例如，当前使用了分屏功能，屏幕上有Auto.js和QQ两个应用，但我们只想选择器对QQ界面进行搜索，则：
-
-```
-auto.setWindowFilter(function(window){
-    // 对于应用窗口，他的title属性就是应用的名称，因此可以通过title属性来判断一个应用
-    return window.title == "QQ";
-});
-```
-
-选择器默认是在当前活跃的窗口中搜索，不会搜索诸如悬浮窗、状态栏之类的，使用WindowFilter则可以控制搜索的窗口。
-
-需要注意的是， 如果WindowFilter返回的结果均为false，则选择器的搜索结果将为空。
-
-另外setWindowFilter函数也会影响`auto.windowRoots`的结果。
-
-该函数需要Android 5.0以上才有效。
-
-## auto.windowRoots
-
-**[v4.1.0新增]**
-
-* {Array}
-
-返回当前被WindowFilter过滤的窗口的布局根元素组成的数组。
-
-如果系统是Android5.0以下，则始终返回当前活跃的窗口的布局根元素的数组。
-
-# SimpleActionAutomator
-
-> Stability: 2 - Stable
-
-SimpleActionAutomator提供了一些模拟简单操作的函数，例如点击文字、模拟按键等。这些函数可以直接作为全局函数使用。
-
-## click(text[, i])
-
-* `text` {string} 要点击的文本
-* `i` {number} 如果相同的文本在屏幕中出现多次，则i表示要点击第几个文本, i从0开始计算
-
-返回是否点击成功。当屏幕中并未包含该文本，或者该文本所在区域不能点击时返回false，否则返回true。
-
-该函数可以点击大部分包含文字的按钮。例如微信主界面下方的"微信", "联系人", "发现", "我"的按钮。  
-通常与while同时使用以便点击按钮直至成功。例如:
-
-```
-while(!click("扫一扫"));
-```
-
-当不指定参数i时则会尝试点击屏幕上出现的所有文字text并返回是否全部点击成功。
-
-i是从0开始计算的, 也就是, `click("啦啦啦", 0)`表示点击屏幕上第一个"啦啦啦", `click("啦啦啦", 1)`表示点击屏幕上第二个"啦啦啦"。
-
-> 文本所在区域指的是，从文本处向其父视图寻找，直至发现一个可点击的部件为止。
-
-## click(left, top, bottom, right)
-
-* `left` {number} 要点击的长方形区域左边与屏幕左边的像素距离
-* `top` {number} 要点击的长方形区域上边与屏幕上边的像素距离
-* `bottom` {number} 要点击的长方形区域下边与屏幕下边的像素距离
-* `right` {number} 要点击的长方形区域右边与屏幕右边的像素距离
-
-**注意，该函数一般只用于录制的脚本中使用，在自己写的代码中使用该函数一般不要使用该函数。**
-
-点击在指定区域的控件。当屏幕中并未包含与该区域严格匹配的区域，或者该区域不能点击时返回false，否则返回true。
-
-有些按钮或者部件是图标而不是文字（例如发送朋友圈的照相机图标以及QQ下方的消息、联系人、动态图标），这时不能通过`click(text, i)`来点击，可以通过描述图标所在的区域来点击。left, bottom, top, right描述的就是点击的区域。
-
-至于要定位点击的区域，可以在悬浮窗使用布局分析工具查看控件的bounds属性。
-
-通过无障碍服务录制脚本会生成该语句。
-
-## longClick(text[, i]))
-
-* `text` {string} 要长按的文本
-* `i` {number} 如果相同的文本在屏幕中出现多次，则i表示要长按第几个文本, i从0开始计算
-
-返回是否点击成功。当屏幕中并未包含该文本，或者该文本所在区域不能点击时返回false，否则返回true。
-
-当不指定参数i时则会尝试点击屏幕上出现的所有文字text并返回是否全部长按成功。
-
-## scrollUp([i])
-
-* `i` {number} 要滑动的控件序号
-
-找到第i+1个可滑动控件上滑或**左滑**。返回是否操作成功。屏幕上没有可滑动的控件时返回false。
-
-另外不加参数时`scrollUp()`会寻找面积最大的可滑动的控件上滑或左滑，例如微信消息列表等。
-
-参数为一个整数i时会找到第i + 1个可滑动控件滑动。例如`scrollUp(0)`为滑动第一个可滑动控件。
-
-## scrollDown([i])
-
-* `i` {number} 要滑动的控件序号
-
-找到第i+1个可滑动控件下滑或**右滑**。返回是否操作成功。屏幕上没有可滑动的控件时返回false。
-
-另外不加参数时`scrollUp()`会寻找面积最大的可滑动的控件下滑或右滑。
-
-参数为一个整数i时会找到第i + 1个可滑动控件滑动。例如`scrollUp(0)`为滑动第一个可滑动控件。
-
-## setText([i, ]text)
-
-* i {number} 表示要输入的为第i + 1个输入框
-* text {string} 要输入的文本
-
-返回是否输入成功。当找不到对应的文本框时返回false。
-
-不加参数i则会把所有输入框的文本都置为text。例如`setText("测试")`。
-
-这里的输入文本的意思是，把输入框的文本置为text，而不是在原来的文本上追加。
-
-## input([i, ]text)
-
-* i {number} 表示要输入的为第i + 1个输入框
-* text {string} 要输入的文本
-
-返回是否输入成功。当找不到对应的文本框时返回false。
-
-不加参数i则会把所有输入框的文本追加内容text。例如`input("测试")`。
-
-# UiSelector
-
-UiSelector即选择器，用于通过各种条件选取屏幕上的控件，再对这些控件进行点击、长按等动作。这里需要先简单介绍一下控件和界面的相关知识。
-
-一般软件的界面是由一个个控件构成的，例如图片部分是一个图片控件(ImageView)，文字部分是一个文字控件(TextView)；同时，通过各种布局来决定各个控件的位置，例如，线性布局(LinearLayout)里面的控件都是按水平或垂直一次叠放的，列表布局(AbsListView)则是以列表的形式显示控件。
-
-控件有各种属性，包括文本(text), 描述(desc), 类名(className), id等等。我们通常用一个控件的属性来找到这个控件，例如，想要点击QQ聊天窗口的"发送"按钮，我们就可以通过他的文本属性为"发送"来找到这个控件并点击他，具体代码为:
-
-```
-var sendButton = text("发送").findOne();
-sendButton.click();
-```
-
-在这个例子中, `text("发送")`表示一个条件(文本属性为"发送")，`findOne()`表示基于这个条件找到一个符合条件的控件，从而我们可以得到发送按钮sendButton，再执行`sendButton.click()`即可点击"发送"按钮。
-
-用文本属性来定位按钮控件、文本控件通常十分有效。但是，如果一个控件是图片控件，比如Auto.js主界面右上角的搜索图标，他没有文本属性，这时需要其他属性来定位他。我们如何查看他有什么属性呢？首先打开悬浮窗和无障碍服务，点击蓝色的图标(布局分析), 可以看到以下界面：
-
-之后我们点击搜索图标，可以看到他有以下属性：
-
-我们注意到这个图标的desc(描述)属性为"搜索"，那么我们就可以通过desc属性来定位这个控件，得到点击搜索图标的代码为:
-
-```
-desc("搜索").findOne().click();
-```
-
-可能心细的你可能注意到了，这个控件还有很多其他的属性，例如checked, className, clickable等等，为什么不用这些属性来定位搜索图标呢？答案是，其他控件也有这些值相同的属性、尝试一下你就可以发现很多其他控件的checked属性和搜索控件一样都是`false`，如果我们用`checked(false)`作为条件，将会找到很多控件，而无法确定哪一个是搜索图标。因此，要找到我们想要的那个控件，**选择器的条件通常需要是可唯一确定控件的**。我们通常用一个独一无二的属性来定位一个控件，例如这个例子中就没有其他控件的desc(描述)属性为"搜索"。
-
-另外，对于这个搜索图标而言，id属性也是唯一的，我们也可以用`id("action_search").findOne().click()`来点击这个控件。如果一个控件有id属性，那么这个属性很可能是唯一的，除了以下几种情况：
-
-* QQ的控件的id属性很多都是"name"，也就是在QQ界面难以通过id来定位一个控件
-* 列表中的控件，比如QQ联系人列表，微信联系人列表等
-
-尽管id属性很方便，但也不总是最方便的，例如对于微信和网易云音乐，每次更新他的控件id都会变化，导致了相同代码对于不同版本的微信、网易云音乐并不兼容。
-
-除了这些属性外，主要还有以下几种属性：
-
-* `className` 类名。类名表示一个控件的类型，例如文本控件为"android.widget.TextView", 图片控件为"android.widget.ImageView"等。
-* `packageName` 包名。包名表示控件所在的应用包名，例如QQ界面的控件的包名为"com.tencent.mobileqq"。
-* `bounds` 控件在屏幕上的范围。
-* `drawingOrder` 控件在父控件的绘制顺序。
-* `indexInParent` 控件在父控件的位置。
-* `clickable` 控件是否可点击。
-* `longClickable` 控件是否可长按。
-* `checkable` 控件是否可勾选。
-* `checked` 控件是否可已勾选。
-* `scrollable` 控件是否可滑动。
-* `selected` 控件是否已选择。
-* `editable` 控件是否可编辑。
-* `visibleToUser` 控件是否可见。
-* `enabled` 控件是否已启用。
-* `depth` 控件的布局深度。
-
-有时候只靠一个属性并不能唯一确定一个控件，这时需要通过属性的组合来完成定位，例如`className("ImageView").depth(10).findOne().click()`，通过链式调用来组合条件。
-
-通常用这些技巧便可以解决大部分问题，即使解决不了问题，也可以通过布局分析的"生成代码"功能来尝试生成一些选择器代码。接下来的问题便是对选取的控件进行操作，包括：
-
-* `click()` 点击。点击一个控件，前提是这个控件的clickable属性为true
-* `longClick()` 长按。长按一个控件，前提是这个控件的longClickable属性为true
-* `setText()` 设置文本，用于编辑框控件设置文本。
-* `scrollForward()`, `scrollBackward()` 滑动。滑动一个控件(列表等), 前提是这个控件的scrollable属性为true
-* `exits()` 判断控件是否存在
-* `waitFor()` 等待控件出现
-
-这些操作包含了绝大部分控件操作。根据这些我们可以很容易写出一个"刷屏"脚本(代码仅为示例，请不要在别人的群里测试，否则容易被踢):
-
-```
-while(true){
-    className("EditText").findOne().setText("刷屏...");
-    text("发送").findOne().clicK();
-}
-```
-
-上面这段代码也可以写成：
-
-```
-while(true){
-    className("EditText").setText("刷屏...");
-    text("发送").clicK();
-}
-```
-
-如果不加`findOne()`而直接进行操作，则选择器会找出**所有**符合条件的控件并操作。
-
-另外一个比较常用的操作的滑动。滑动操作的第一步是找到需要滑动的控件，例如要滑动QQ消息列表则在悬浮窗布局层次分析中找到`AbsListView`，这个控件就是消息列表控件，如下图：
-
-长按可查看控件信息，注意到其scrollable属性为true，并找出其id为"recent_chat_list"，从而下滑QQ消息列表的代码为：
-
-```
-id("recent_chat_list").className("AbsListView").findOne().scrollForward();
-```
-
-`scrollForward()`为向前滑，包括下滑和右滑。
-
-选择器的入门教程暂且要这里，更多信息可以查看下面的文档和选择器进阶。
-
-## selector()
-
-* 返回 {UiSelector}
-
-创建一个新的选择器。但一般情况不需要使用该函数，因为可以直接用相应条件的语句创建选择器。
-
-由于历史遗留原因，本不应该这样设计(不应该让`id()`, `text()`等作为全局函数，而是应该用`By.id()`, `By.text()`)，但为了后向兼容性只能保留这个设计。
-
-这样的API设计会污染全局变量，后续可能会支持"去掉这些全局函数而使用By.***"的选项。
-
-## UiSelector.algorithm(algorithm)
-
-**[v4.1.0新增]**
-
-* `algorithm` {string} 搜索算法，可选的值有：
-    * `DFS` 深度优先算法，选择器的默认算法
-    * `BFS` 广度优先算法
-
-指定选择器的搜索算法。例如：
-
-```
-log(selector().text("文本").algorithm("BFS").find());
-```
-
-广度优先在控件所在层次较低时，或者布局的层次不多时，通常能更快找到控件。
-
-## UiSelector.text(str)
-
-* `str` {string} 控件文本
-* 返回 {UiSelector} 返回选择器自身以便链式调用
-
-为当前选择器附加控件"text等于字符串str"的筛选条件。
-
-控件的text(文本)属性是文本控件上的显示的文字，例如微信左上角的"微信"文本。
-
-## UiSelector.textContains(str)
-
-* `str` {string} 要包含的字符串
-
-为当前选择器附加控件"text需要包含字符串str"的筛选条件。
-
-这是一个比较有用的条件，例如QQ动态页和微博发现页上方的"大家都在搜...."的控件可以用`textContains("大家都在搜").findOne()`来获取。
-
-## UiSelector.textStartsWith(prefix)
-
-* `prefix` {string} 前缀
-
-为当前选择器附加控件"text需要以prefix开头"的筛选条件。
-
-这也是一个比较有用的条件，例如要找出Auto.js脚本列表中名称以"QQ"开头的脚本的代码为`textStartsWith("QQ").find()`。
-
-## UiSelector.textEndsWith(suffix)
-
-* suffix {string} 后缀
-
-为当前选择器附加控件"text需要以suffix结束"的筛选条件。
-
-## UiSelector.textMatches(reg)
-
-* `reg` {string} | {Regex} 要满足的正则表达式。
-
-为当前选择器附加控件"text需要满足正则表达式reg"的条件。
-
-有关正则表达式，可以查看[正则表达式 - 菜鸟教程](http://www.runoob.com/Stringp/Stringp-example.html)。
-
-需要注意的是，如果正则表达式是字符串，则需要使用`\\`来表达`\`(也即Java正则表达式的形式)，例如`textMatches("\\d+")`匹配多位数字；但如果使用JavaScript语法的正则表达式则不需要，例如`textMatches(/\d+/)`。但如果使用字符串的正则表达式则该字符串不能以"/"同时以"/"结束，也即不能写诸如`textMatches("/\\d+/")`的表达式，否则会被开头的"/"和结尾的"/"会被忽略。
-
-## UiSelector.desc(str)
-
-* `str` {string} 控件文本
-* 返回 {UiSelector} 返回选择器自身以便链式调用
-
-为当前选择器附加控件"desc等于字符串str"的筛选条件。
-
-控件的desc(描述，全称为Content-Description)属性是对一个控件的描述，例如网易云音乐右上角的放大镜图标的描述为搜索。要查看一个控件的描述，同样地可以借助悬浮窗查看。
-
-desc属性同样是定位控件的利器。
-
-## UiSelector.descContains(str)
-
-* `str` {string} 要包含的字符串
-
-为当前选择器附加控件"desc需要包含字符串str"的筛选条件。
-
-## UiSelector.descStartsWith(prefix)
-
-* `prefix` {string} 前缀
-
-为当前选择器附加控件"desc需要以prefix开头"的筛选条件。
-
-## UiSelector.descEndsWith(suffix)
-
-* `suffix` {string} 后缀
-
-为当前选择器附加控件"desc需要以suffix结束"的筛选条件。
-
-## UiSelector.descMatches(reg)
-
-* `reg` {string} | {Regex} 要满足的正则表达式。
-
-为当前选择器附加控件"desc需要满足正则表达式reg"的条件。
-
-有关正则表达式，可以查看[正则表达式 - 菜鸟教程](http://www.runoob.com/Stringp/Stringp-example.html)。
-
-需要注意的是，如果正则表达式是字符串，则需要使用`\\`来表达`\`(也即Java正则表达式的形式)，例如`textMatches("\\d+")`匹配多位数字；但如果使用JavaScript语法的正则表达式则不需要，例如`textMatches(/\d+/)`。但如果使用字符串的正则表达式则该字符串不能以"/"同时以"/"结束，也即不能写诸如`textMatches("/\\d+/")`的表达式，否则会被开头的"/"和结尾的"/"会被忽略。
-
-## UiSelector.id(resId)
-
-* `resId` {string} 控件的id，以"包名:id/"开头，例如"com.tencent.mm:id/send_btn"。**也可以不指定包名**，这时会以当前正在运行的应用的包名来补全id。例如id("send_btn"),在QQ界面想当于id("com.tencent.mobileqq:id/send_btn")。
-
-为当前选择器附加"id等于resId"的筛选条件。
-
-控件的id属性通常是可以用来确定控件的唯一标识，如果一个控件有id，那么使用id来找到他是最好的方法。要查看屏幕上的控件的id，可以开启悬浮窗并使用界面工具，点击相应控件即可查看。若查看到的控件id为null, 表示该控件没有id。另外，在列表中会出现多个控件的id相同的情况。例如微信的联系人列表，每个头像的id都是一样的。此时不能用id来唯一确定控件。
-
-在QQ界面经常会出现多个id为"name"的控件，在微信上则每个版本的id都会变化。对于这些软件而言比较难用id定位控件。
-
-## UiSelector.idContains(str)
-
-* `str` {string} id要包含的字符串
-
-为当前选择器附加控件"id包含字符串str"的筛选条件。比较少用。
-
-## UiSelector.idStartsWith(prefix)
-
-* `prefix` {string} id前缀
-
-为当前选择器附加"id需要以prefix开头"的筛选条件。比较少用。
-
-## UiSelector.idEndsWith(suffix)
-
-* `suffix` {string} id后缀
-
-为当前选择器附加"id需要以suffix结束"的筛选条件。比较少用。
-
-## UiSelector.idMatches(reg)
-
-* reg {Regex} | {string} id要满足的正则表达式
-
-附加id需要满足正则表达式。
-
-需要注意的是，如果正则表达式是字符串，则需要使用`\\`来表达`\`(也即Java正则表达式的形式)，例如`textMatches("\\d+")`匹配多位数字；但如果使用JavaScript语法的正则表达式则不需要，例如`textMatches(/\d+/)`。但如果使用字符串的正则表达式则该字符串不能以"/"同时以"/"结束，也即不能写诸如`textMatches("/\\d+/")`的表达式，否则会被开头的"/"和结尾的"/"会被忽略。
-
-```
-idMatches("[a-zA-Z]+")
-```
-
-## UiSelector.className(str)
-
-* `str` {string} 控件文本
-* 返回 {UiSelector} 返回选择器自身以便链式调用
-
-为当前选择器附加控件"className等于字符串str"的筛选条件。
-
-控件的className(类名)表示一个控件的类别，例如文本控件的类名为android.widget.TextView。
-
-如果一个控件的类名以"android.widget."开头，则可以省略这部分，例如文本控件可以直接用`className("TextView")`的选择器。
-
-常见控件的类名如下：
-
-* `android.widget.TextView` 文本控件
-* `android.widget.ImageView` 图片控件
-* `android.widget.Button` 按钮控件
-* `android.widget.EditText` 输入框控件
-* `android.widget.AbsListView` 列表控件
-* `android.widget.LinearLayout` 线性布局
-* `android.widget.FrameLayout` 帧布局
-* `android.widget.RelativeLayout` 相对布局
-* `android.widget.RelativeLayout` 相对布局
-* `android.support.v7.widget.RecyclerView` 通常也是列表控件
-
-## UiSelector.classNameContains(str)
-
-* `str` {string} 要包含的字符串
-
-为当前选择器附加控件"className需要包含字符串str"的筛选条件。
-
-## UiSelector.classNameStartsWith(prefix)
-
-* `prefix` {string} 前缀
-
-为当前选择器附加控件"className需要以prefix开头"的筛选条件。
-
-## UiSelector.classNameEndsWith(suffix)
-
-* `suffix` {string} 后缀
-
-为当前选择器附加控件"className需要以suffix结束"的筛选条件。
-
-## UiSelector.classNameMatches(reg)
-
-* `reg` {string} | {Regex} 要满足的正则表达式。
-
-为当前选择器附加控件"className需要满足正则表达式reg"的条件。
-
-有关正则表达式，可以查看[正则表达式 - 菜鸟教程](http://www.runoob.com/Stringp/Stringp-example.html)。
-
-需要注意的是，如果正则表达式是字符串，则需要使用`\\`来表达`\`(也即Java正则表达式的形式)，例如`textMatches("\\d+")`匹配多位数字；但如果使用JavaScript语法的正则表达式则不需要，例如`textMatches(/\d+/)`。但如果使用字符串的正则表达式则该字符串不能以"/"同时以"/"结束，也即不能写诸如`textMatches("/\\d+/")`的表达式，否则会被开头的"/"和结尾的"/"会被忽略。
-
-## UiSelector.packageName(str)
-
-* `str` {string} 控件文本
-* 返回 {UiSelector} 返回选择器自身以便链式调用
-
-为当前选择器附加控件"packageName等于字符串str"的筛选条件。
-
-控件的packageName表示控件所属界面的应用包名。例如微信的包名为"com.tencent.mm", 那么微信界面的控件的packageName为"com.tencent.mm"。
-
-要查看一个应用的包名，可以用函数`app.getPackageName()`获取，例如`toast(app.getPackageName("微信"))`。
-
-## UiSelector.packageNameContains(str)
-
-* `str` {string} 要包含的字符串
-
-为当前选择器附加控件"packageName需要包含字符串str"的筛选条件。
-
-## UiSelector.packageNameStartsWith(prefix)
-
-* `prefix` {string} 前缀
-
-为当前选择器附加控件"packageName需要以prefix开头"的筛选条件。
-
-## UiSelector.packageNameEndsWith(suffix)
-
-* `suffix` {string} 后缀
-
-为当前选择器附加控件"packageName需要以suffix结束"的筛选条件。
-
-## UiSelector.packageNameMatches(reg)
-
-* `reg` {string} | {Regex} 要满足的正则表达式。
-
-为当前选择器附加控件"packageName需要满足正则表达式reg"的条件。
-
-有关正则表达式，可以查看[正则表达式 - 菜鸟教程](http://www.runoob.com/Stringp/Stringp-example.html)。
-
-## UiSelector.bounds(left, top, right, buttom)
-
-* `left` {number} 控件左边缘与屏幕左边的距离
-* `top` {number} 控件上边缘与屏幕上边的距离
-* `right` {number} 控件右边缘与屏幕左边的距离
-* `bottom` {number} 控件下边缘与屏幕上边的距离
-
-一个控件的bounds属性为这个控件在屏幕上显示的范围。我们可以用这个范围来定位这个控件。尽管用这个方法定位控件对于静态页面十分准确，却无法兼容不同分辨率的设备；同时对于列表页面等动态页面无法达到效果，因此使用不推荐该选择器。
-
-注意参数的这四个数字不能随意填写，必须精确的填写控件的四个边界才能找到该控件。例如，要点击QQ主界面的右上角加号，我们用布局分析查看该控件的属性，如下图：
-
-可以看到bounds属性为(951, 67, 1080, 196)，此时使用代码`bounds(951, 67, 1080, 196).clickable().click()`即可点击该控件。
-
-## UiSelector.boundsInside(left, top, right, buttom)
-
-* `left` {number} 范围左边缘与屏幕左边的距离
-* `top` {number} 范围上边缘与屏幕上边的距离
-* `right` {number} 范围右边缘与屏幕左边的距离
-* `bottom` {number} 范围下边缘与屏幕上边的距离
-
-为当前选择器附加控件"bounds需要在left, top, right, buttom构成的范围里面"的条件。
-
-这个条件用于限制选择器在某一个区域选择控件。例如要在屏幕上半部分寻找文本控件TextView，代码为:
-
-```
-var w = className("TextView").boundsInside(0, 0, device.width, device.height / 2).findOne();
-log(w.text());
-```
-
-其中我们使用了`device.width`来获取屏幕宽度，`device.height`来获取屏幕高度。
-
-## UiSelector.boundsContains(left, top, right, buttom)
-
-* `left` {number} 范围左边缘与屏幕左边的距离
-* `top` {number} 范围上边缘与屏幕上边的距离
-* `right` {number} 范围右边缘与屏幕左边的距离
-* `bottom` {number} 范围下边缘与屏幕上边的距离
-
-为当前选择器附加控件"bounds需要包含left, top, right, buttom构成的范围"的条件。
-
-这个条件用于限制控件的范围必须包含所给定的范围。例如给定一个点(500, 300), 寻找在这个点上的可点击控件的代码为:
-
-```
-var w = boundsContains(500, 300, 500, 300).clickable().findOne();
-w.click();
-```
-
-## UiSelector.drawingOrder(order)
-
-* order {number} 控件在父视图中的绘制顺序
-
-为当前选择器附加控件"drawingOrder等于order"的条件。
-
-drawingOrder为一个控件在父控件中的绘制顺序，通常可以用于区分同一层次的控件。
-
-但该属性在Android 7.0以上才能使用。
-
-## UiSelector.clickable([b = true])
-
-* `b` {Boolean} 表示控件是否可点击
-
-为当前选择器附加控件是否可点击的条件。但并非所有clickable为false的控件都真的不能点击，这取决于控件的实现。对于自定义控件(例如显示类名为android.view.View的控件)很多的clickable属性都为false都却能点击。
-
-需要注意的是，可以省略参数`b`而表示选择那些可以点击的控件，例如`className("ImageView").clickable()`表示可以点击的图片控件的条件，`className("ImageView").clickable(false)`表示不可点击的图片控件的条件。
-
-## UiSelector.longClickable([b = true])
-
-* `b` {Boolean} 表示控件是否可长按
-
-为当前选择器附加控件是否可长按的条件。
-
-## UiSelector.checkable([b = true])
-
-* `b` {Boolean} 表示控件是否可勾选
-
-为当前选择器附加控件是否可勾选的条件。勾选通常是对于勾选框而言的，例如图片多选时左上角通常有一个勾选框。
-
-## UiSelector.selected([b = true])
-
-* `b` {Boolean} 表示控件是否被选
-
-为当前选择器附加控件是否已选中的条件。被选中指的是，例如QQ聊天界面点击下方的"表情按钮"时，会出现自己收藏的表情，这时"表情按钮"便处于选中状态，其selected属性为true。
-
-## UiSelector.enabled([b = true])
-
-* `b` {Boolean} 表示控件是否已启用
-
-为当前选择器附加控件是否已启用的条件。大多数控件都是启用的状态(enabled为true)，处于“禁用”状态通常是灰色并且不可点击。
-
-## UiSelector.scrollable([b = true])
-
-* `b` {Boolean} 表示控件是否可滑动
-
-为当前选择器附加控件是否可滑动的条件。滑动包括上下滑动和左右滑动。
-
-可以用这个条件来寻找可滑动控件来滑动界面。例如滑动Auto.js的脚本列表的代码为:
-
-```
-className("android.support.v7.widget.RecyclerView").scrollable().findOne().scrollForward();
-//或者classNameEndsWith("RecyclerView").scrollable().findOne().scrollForward();
-```
-
-## UiSelector.editable([b = true])
-
-* `b` {Boolean} 表示控件是否可编辑
-
-为当前选择器附加控件是否可编辑的条件。一般来说可编辑的控件为输入框(EditText)，但不是所有的输入框(EditText)都可编辑。
-
-## UiSelector.multiLine([b = true])
-
-* b {Boolean} 表示文本或输入框控件是否是多行显示的
-
-为当前选择器附加控件是否文本或输入框控件是否是多行显示的条件。
-
-## UiSelector.findOne()
-
-* 返回 [UiObject](#widgets_based_automation_uiobject)
-
-根据当前的选择器所确定的筛选条件，对屏幕上的控件进行搜索，直到屏幕上出现满足条件的一个控件为止，并返回该控件。如果找不到控件，当屏幕内容发生变化时会重新寻找，直至找到。
-
-需要注意的是，如果屏幕上一直没有出现所描述的控件，则该函数会阻塞，直至所描述的控件出现为止。因此此函数不会返回`null`。
-
-该函数本来应该命名为`untilFindOne()`，但由于历史遗留原因已经无法修改。如果想要只在屏幕上搜索一次而不是一直搜索，请使用`findOnce()`。
-
-另外，如果屏幕上有多个满足条件的控件，`findOne()`采用深度优先搜索(DFS)，会返回该搜索算法找到的第一个控件。注意控件找到的顺序有时会起到作用。
-
-## UiSelector.findOne(timeout)
-
-* `timeout` {number} 搜索的超时时间，单位毫秒
-* 返回 [UiObject](#widgets_based_automation_uiobject)
-
-根据当前的选择器所确定的筛选条件，对屏幕上的控件进行搜索，直到屏幕上出现满足条件的一个控件为止，并返回该控件；如果在timeout毫秒的时间内没有找到符合条件的控件，则终止搜索并返回`null`。
-
-该函数类似于不加参数的`findOne()`，只不过加上了时间限制。
-
-示例：
-
-```
-//启动Auto.js
-launchApp("Auto.js");
-//在6秒内找出日志图标的控件
-var w = id("action_log").findOne(6000);
-//如果找到控件则点击
-if(w != null){
-    w.click();
-}else{
-    //否则提示没有找到
-    toast("没有找到日志图标");
-}
-```
-
-## UiSelector.findOnce()
-
-* 返回 [UiObject](#widgets_based_automation_uiobject)
-
-根据当前的选择器所确定的筛选条件，对屏幕上的控件进行搜索，如果找到符合条件的控件则返回该控件；否则返回`null`。
-
-## UiSelector.findOnce(i)
-
-* `i` {number} 索引
-
-根据当前的选择器所确定的筛选条件，对屏幕上的控件进行搜索，并返回第 i + 1 个符合条件的控件；如果没有找到符合条件的控件，或者符合条件的控件个数 < i, 则返回`null`。
-
-注意这里的控件次序，是搜索算法深度优先搜索(DSF)决定的。
-
-## UiSelector.find()
-
-* 返回 [UiCollection](#widgets_based_automation_uicollection)
-
-根据当前的选择器所确定的筛选条件，对屏幕上的控件进行搜索，找到所有满足条件的控件集合并返回。这个搜索只进行一次，并不保证一定会找到，因而会出现返回的控件集合为空的情况。
-
-不同于`findOne()`或者`findOnce()`只找到一个控件并返回一个控件，`find()`函数会找出所有满足条件的控件并返回一个控件集合。之后可以对控件集合进行操作。
-
-可以通过empty()函数判断找到的是否为空。例如：
-
-```
-var c = className("AbsListView").find();
-if(c.empty()){
-    toast("找到啦");
-}else{
-    toast("没找到╭(╯^╰)╮");
-}
-```
-
-## UiSelector.untilFind()
-
-* 返回 [UiCollection](#widgets_based_automation_uicollection)
-
-根据当前的选择器所确定的筛选条件，对屏幕上的控件进行搜索，直到找到至少一个满足条件的控件为止，并返回所有满足条件的控件集合。
-
-该函数与`find()`函数的区别在于，该函数永远不会返回空集合；但是，如果屏幕上一直没有出现满足条件的控件，则该函数会保持阻塞。
-
-## UiSelector.exists()
-
-* 返回 {Boolean}
-
-判断屏幕上是否存在控件符合选择器所确定的条件。例如要判断某个文本出现就执行某个动作，可以用：
-
-```
-if(text("某个文本").exists()){
-    //要支持的动作
-}
-```
-
-## UiSelector.waitFor()
-
-等待屏幕上出现符合条件的控件；在满足该条件的控件出现之前，该函数会一直保持阻塞。
-
-例如要等待包含"哈哈哈"的文本控件出现的代码为：
-
-```
-textContains("哈哈哈").waitFor();
-```
-
-## UiSelector.filter(f)
-
-* `f` {Function} 过滤函数，参数为UiObject，返回值为boolean
-
-为当前选择器附加自定义的过滤条件。
-
-例如，要找出屏幕上所有文本长度为10的文本控件的代码为：
-
-```
-var uc = className("TextView").filter(function(w){
-    return w.text().length == 10;
-});
-```
-
-# UiObject
-
-UiObject表示一个控件，可以通过这个对象获取到控件的属性，也可以对控件进行点击、长按等操作。
-
-获取一个UiObject通常通过选择器的`findOne()`, `findOnce()`等函数，也可以通过UiCollection来获取，或者通过`UiObject.child()`, `UiObject.parent()`等函数来获取一个控件的子控件或父控件。
-
-## UiObject.click()
-
-* 返回 {Boolean}
-
-点击该控件，并返回是否点击成功。
-
-如果该函数返回false，可能是该控件不可点击(clickable为false)，当前界面无法响应该点击等。
-
-## UiObject.longClick()
-
-* 返回 {Boolean}
-
-长按该控件，并返回是否点击成功。
-
-如果该函数返回false，可能是该控件不可点击(longClickable为false)，当前界面无法响应该点击等。
-
-## UiObject.setText(text)
-
-* `text` {string} 文本
-* 返回 {Boolean}
-
-设置输入框控件的文本内容，并返回是否设置成功。
-
-该函数只对可编辑的输入框(editable为true)有效。
-
-## UiObject.copy()
-
-* 返回 {Boolean}
-
-对输入框文本的选中内容进行复制，并返回是否操作成功。
-
-该函数只能用于输入框控件，并且当前输入框控件有选中的文本。可以通过`setSelection()`函数来设置输入框选中的内容。
-
-```
-var et = className("EditText").findOne();
-//选中前两个字
-et.setSelection(0, 2);
-//对选中内容进行复制
-if(et.copy()){
-    toast("复制成功");
-}else{
-    toast("复制失败");
-}
-```
-
-## UiObject.cut()
-
-对输入框文本的选中内容进行剪切，并返回是否操作成功。
-
-该函数只能用于输入框控件，并且当前输入框控件有选中的文本。可以通过`setSelection()`函数来设置输入框选中的内容。
-
-## UiObject.paste()
-
-* 返回 {Boolean}
-
-对输入框控件进行粘贴操作，把剪贴板内容粘贴到输入框中，并返回是否操作成功。
-
-```
-//设置剪贴板内容为“你好”
-setClip("你好");
-var et = className("EditText").findOne();
-et.paste();
-```
-
-## UiObject.setSelection(start, end)
-
-* `start` {number} 选中内容起始位置
-* `end` {number} 选中内容结束位置(不包括)
-* 返回 {Boolean}
-
-对输入框控件设置选中的文字内容，并返回是否操作成功。
-
-索引是从0开始计算的；并且，选中内容不包含end位置的字符。例如，如果一个输入框内容为"123456789"，要选中"4567"的文字的代码为`et.setSelection(3, 7)`。
-
-该函数也可以用来设置光标位置，只要参数的end等于start，即可把输入框光标设置在start的位置。例如`et.setSelection(1, 1)`会把光标设置在第一个字符的后面。
-
-## UiObject.scrollForward()
-
-* 返回 {Boolean}
-
-对控件执行向前滑动的操作，并返回是否操作成功。
-
-向前滑动包括了向右和向下滑动。如果一个控件既可以向右滑动和向下滑动，那么执行`scrollForward()`的行为是未知的(这是因为Android文档没有指出这一点，同时也没有充分的测试可供参考)。
-
-## UiObject.scrollBackward()
-
-* 返回 {Boolean}
-
-对控件执行向后滑动的操作，并返回是否操作成功。
-
-向后滑动包括了向右和向下滑动。如果一个控件既可以向右滑动和向下滑动，那么执行`scrollForward()`的行为是未知的(这是因为Android文档没有指出这一点，同时也没有充分的测试可供参考)。
-
-## UiObject.select()
-
-* 返回 {Boolean}
-
-对控件执行"选中"操作，并返回是否操作成功。"选中"和`isSelected()`的属性相关，但该操作十分少用。
-
-## UiObject.collapse()
-
-* 返回 {Boolean}
-
-对控件执行折叠操作，并返回是否操作成功。
-
-## UiObject.expand()
-
-* 返回 {Boolean}
-
-对控件执行操作，并返回是否操作成功。
-
-## UiObject.show()
-
-对集合中所有控件执行显示操作，并返回是否全部操作成功。
-
-## UiObject.scrollUp()
-
-对集合中所有控件执行向上滑的操作，并返回是否全部操作成功。
-
-## UiObject.scrollDown()
-
-对集合中所有控件执行向下滑的操作，并返回是否全部操作成功。
-
-## UiObject.scrollLeft()
-
-对集合中所有控件执行向左滑的操作，并返回是否全部操作成功。
-
-## UiObject.scrollRight()
-
-## children()
-
-* 返回 [UiCollection](#widgets_based_automation_uicollection)
-
-返回该控件的所有子控件组成的控件集合。可以用于遍历一个控件的子控件，例如：
-
-```
-className("AbsListView").findOne().children()
-    .forEach(function(child){
-        log(child.className());
-    });
-```
-
-## childCount()
-
-* 返回 {number}
-
-返回子控件数目。
-
-## child(i)
-
-* i {number} 子控件索引
-* 返回 {UiObject}
-
-返回第i+1个子控件。如果i>=控件数目或者小于0，则抛出异常。
-
-需要注意的是，由于布局捕捉的问题，该函数可能返回`null`，也就是可能获取不到某个子控件。
-
-遍历子控件的示例：
-
-```
-var list = className("AbsListView").findOne();
-for(var i = 0; i < list.childCount(); i++){
-    var child = list.child(i);
-    log(child.className());
-}
-```
-
-## parent()
-
-* 返回 {UiObject}
-
-返回该控件的父控件。如果该控件没有父控件，返回`null`。
-
-## bounds()
-
-* 返回 [Rect](https://hyb1996.github.io/AutoJs-Docs/widgets-based-automation.html#widgets_based_automation_rect)
-
-返回控件在屏幕上的范围，其值是一个[Rect](https://hyb1996.github.io/AutoJs-Docs/widgets-based-automation.html#widgets_based_automation_rect)对象。
-
-示例：
-
-```
-var b = text("Auto.js").findOne().bounds();
-toast("控件在屏幕上的范围为" + b);
-```
-
-如果一个控件本身无法通过`click()`点击，那么我们可以利用`bounds()`函数获取其坐标，再利用坐标点击。例如：
-
-```
-var b = desc("打开侧拉菜单").findOne().bounds();
-click(b.centerX(), b.centerY());
-//如果使用root权限，则用 Tap(b.centerX(), b.centerY());
-```
-
-## boundsInParent()
-
-* 返回 [Rect](https://hyb1996.github.io/AutoJs-Docs/widgets-based-automation.html#widgets_based_automation_rect)
-
-返回控件在父控件中的范围，其值是一个[Rect](https://hyb1996.github.io/AutoJs-Docs/widgets-based-automation.html#widgets_based_automation_rect)对象。
-
-## drawingOrder()
-
-* 返回 {number}
-
-返回控件在父控件中的绘制次序。该函数在安卓7.0及以上才有效，7.0以下版本调用会返回0。
-
-## id()
-
-* 返回 {string}
-
-获取控件的id，如果一个控件没有id，则返回`null`。
-
-## text()
-
-* 返回 {string}
-
-获取控件的文本，如果控件没有文本，返回`""`。
-
-## findByText(str)
-
-* `str` {string} 文本
-* 返回 [UiCollection](#widgets_based_automation_uicollection)
-
-根据文本text在子控件中递归地寻找并返回文本或描述(desc)**包含**这段文本str的控件，返回它们组成的集合。
-
-该函数会在当前控件的子控件，孙控件，曾孙控件...中搜索text或desc包含str的控件，并返回它们组合的集合。
-
-## findOne(selector)
-
-* `selector` [UiSelector](#widgets_based_automation_uiselector)
-* 返回 [UiOobject](#widgets_based_automation_uiobject)
-
-根据选择器selector在该控件的子控件、孙控件...中搜索符合该选择器条件的控件，并返回找到的第一个控件；如果没有找到符合条件的控件则返回`null`。
-
-例如，对于酷安动态列表，我们可以遍历他的子控件(每个动态列表项)，并在每个子控件中依次寻找点赞数量和图标，对于点赞数量小于10的点赞：
-
-```
-//找出动态列表
-var list = id("recycler_view").findOne();
-//遍历动态
-list.children().forEach(function(child){
-    //找出点赞图标
-    var like = child.findOne(id("feed_action_view_like"));
-    //找出点赞数量
-    var likeCount = child.findOne(id("text_view"));
-    //如果这两个控件没有找到就不继续了
-    if(like == null || likeCount == null){
-        return;
-    }
-    //判断点赞数量是否小于10
-    if(parseInt(likeCount.text()) < 10){
-        //点赞
-        like.click();
-    }
-});
-```
-
-## find(selector)
-
-* `selector` [UiSelector](#widgets_based_automation_uiselector)
-* 返回 [UiCollection](#widgets_based_automation_uicollection)
-
-根据选择器selector在该控件的子控件、孙控件...中搜索符合该选择器条件的控件，并返回它们组合的集合。
-
-# UiCollection
-
-UiCollection, 控件集合, 通过选择器的`find()`, `untilFind()`方法返回的对象。
-
-UiCollection"继承"于数组，实际上是一个UiObject的数组，因此可以使用数组的函数和属性，例如使用length属性获取UiCollection的大小，使用forEach函数来遍历UiCollection。
-
-例如，采用forEach遍历屏幕上所有的文本控件并打印出文本内容的代码为：
-
-```
-console.show();
-className("TextView").find().forEach(function(tv){
-    if(tv.text() != ""){
-        log(tv.text());
-    }
-});
-```
-
-也可以使用传统的数组遍历方式：
-
-```
-console.show();
-var uc = className("TextView").find();
-for(var i = 0; i < uc.length; i++){
-    var tv = uc[i];
-    if(tv.text() != ""){
-        log(tv.text());
-    }
-}
-```
-
-UiCollection的每一个元素都是UiObject，我们可以取出他的元素进行操作，例如取出第一个UiObject并点击的代码为`ui[0].click()`。如果想要对该集合的所有元素进行操作，可以直接在集合上调用相应的函数，例如`uc.click()`，该代码会对集合上所有UiObject执行点击操作并返回是否全部点击成功。
-
-因此，UiCollection具有所有UiObject对控件操作的函数，包括`click()`, `longClick()`, `scrollForward()`等等，不再赘述。
-
-## UiCollection.size()
-
-* 返回 {number}
-
-返回集合中的控件数。
-
-历史遗留函数，相当于属性length。
-
-## UiCollection.get(i)
-
-* `i` {number} 索引
-* 返回 [UiObject](#widgets_based_automation_uiobject)
-
-返回集合中第i+1个控件(UiObject)。
-
-历史遗留函数，建议直接使用数组下标的方式访问元素。
-
-## UiCollection.each(func)
-
-* `func` {Function} 遍历函数，参数为UiObject。
-
-遍历集合。
-
-历史遗留函数，相当于`forEach`。参考[forEach](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)。
-
-## empty()
-
-* 返回 {Boolean}
-
-返回控件集合是否为空。
-
-## nonEmpty()
-
-* 返回 {Boolean}
-
-返回控件集合是否非空。
-
-## UiCollection.find(selector)
-
-* `selector` [UiSelector](#widgets_based_automation_uiselector)
-* 返回 [UiCollection](#widgets_based_automation_uicollection)
-
-根据selector所确定的条件在该控件集合的控件、子控件、孙控件...中找到所有符合条件的控件并返回找到的控件集合。
-
-注意这会递归地遍历控件集合里所有的控件以及他们的子控件。和数组的`filter`函数不同。
-
-例如：
-
-```
-var names = id("name").find();
-//在集合
-var clickableNames = names.find(clickable());
-```
-
-## UiCollection.findOne(selector)
-
-* `selector` [UiSelector](#widgets_based_automation_uiselector)
-* 返回 [UiOobject](#widgets_based_automation_uiobject)
-
-根据选择器selector在该控件集合的控件的子控件、孙控件...中搜索符合该选择器条件的控件，并返回找到的第一个控件；如果没有找到符合条件的控件则返回`null`。
-
-# Rect
-
-`UiObject.bounds()`, `UiObject.boundsInParent()`返回的对象。表示一个长方形(范围)。
-
-## Rect.left
-
-* {number}
-
-长方形左边界的x坐标、
-
-## Rect.right
-
-* {number}
-
-长方形右边界的x坐标、
-
-## Rect.top
-
-* {number}
-
-长方形上边界的y坐标、
-
-## Rect.bottom
-
-* {number}
-
-长方形下边界的y坐标、
-
-## Rect.centerX()
-
-* 返回 {number}
-
-长方形中点x坐标。
-
-## Rect.centerY()
-
-* 返回 {number}
-
-长方形中点y坐标。
-
-## Rect.width()
-
-* 返回 {number}
-
-长方形宽度。通常可以作为控件宽度。
-
-## Rect.height()
-
-* 返回 {number}
-
-长方形高度。通常可以作为控件高度。
-
-## Rect.contains(r)
-
-* r [Rect](#widgets_based_automation_rect)
-
-返回是否包含另一个长方形r。包含指的是，长方形r在该长方形的里面(包含边界重叠的情况)。
-
-## Rect.intersect(r)
-
-* r [Rect](#widgets_based_automation_rect)
-
-返回是否和另一个长方形相交。
-
-# UiSelector进阶
-
-未完待续。
\ No newline at end of file